#include "iostream"
using namespace std;
//递增运算符重载
//自定义整型
class MyInteger {friend ostream &operator<<(ostream &cout, MyInteger mi);
public:
MyInteger() {m_Num = 0;
}
//重置前置++运算符 返回引用是为了对同一个数进行操作
MyInteger &operator++() {//这里不能返回值MyInteger 必须返回MyInteger& 因为操作的需要是都一个对象,返回值就是拷贝了
//先进行++运算
m_Num++;
//再将自身作返回
return *this;
}
//重置后置++运算符
private:
int m_Num;
};
//重载左移运算符
ostream &operator<<(ostream &cout, MyInteger mi) {cout<< mi.m_Num;
return cout;
}
void test() {MyInteger mi;
cout<< ++(++mi)<< endl;//C++里面原生的前置递增可以链式调用,后置递增不可以链式调用
}
int main() {// test();
//C++里面原生的前置递增可以链式调用,后置递增不可以链式调用
int a = 0;
++(++a);
cout<< a<< endl;//输出2
return 0;
}
2
后置递增
C++里面后置++是不能链式调用的
#include "iostream"
using namespace std;
//递增运算符重载
//自定义整型
class MyInteger {friend ostream &operator<<(ostream &cout, MyInteger mi);
public:
MyInteger() {m_Num = 0;
}
//重置前置++运算符 返回引用是为了对同一个数进行操作
MyInteger &operator++() {//这里不能返回值MyInteger 必须返回MyInteger& 因为操作的需要是都一个对象,返回值就是拷贝了
//先进行++运算
m_Num++;
//再将自身作返回
return *this;
}
//重置后置++运算符 !!!!!!之前学习的占位符终于找到用武之地了
//返回值用const修饰,他能防止一些问题,例如: (p++)++
const MyInteger operator++(int) {//int 代表占位参数,可以用于区分前置和后置递增,这里只能是int,double等不好使
MyInteger temp = *this;
m_Num++;
return temp;
}
private:
int m_Num;
};
//重载左移运算符
ostream &operator<<(ostream &cout, MyInteger mi) {cout<< mi.m_Num;
return cout;
}
void test() {MyInteger mi;
// cout<< ++(++mi)<< endl;
cout<< mi++<< endl;//输出0 //返回值用const修饰,他能防止一些问题,例如: (p++)++
cout<< mi<< endl;//输出1
}
int main() {test();
return 0;
}
0
1
递增运算符分为前置递增和后置递增。这两个分开来说吧。
前置递增。
需要创建一个名字叫做 人 的类,这个类中有一个 年龄 属性,且默认值为0,然后类外重载左移运算符方便打印输出。我们对人类的对象进行递增操作就是想让年龄增加。如下:
#includeusing namespace std;
class Person
{public:
int age = 0;
Person& operator++()//**1**
{age += 1;
return *this;
}
};
ostream& operator<<(ostream& cout, const Person &p)
{cout<< p.age;
return cout;
}
void test1()
{Person p;
cout<< "++p = "<< ++p<< endl;
cout<< "++(++p) = "<< ++(++p)<< endl;
cout<< "p = "<< p<< endl;
}
int main()
{test1();
system("pause");
return 0;
}
第一个问题 :返回值为什么是引用?
答案:因为前置递增运算符可以这样使用:++(++p)。即进行两次连续的递增操作。若返回值为一个对象,则会产生一个匿名对象,之后++操作是对匿名独对象进行++操作。结果如下:
第二个问题 :为什么这是前置递增,不应该是后置递增吗?
首先解释一下问题,还是举个例子吧。
加运算符在类内实现重载的写法:Person operator+(Person &p);
当你调用的时候,如:p1 + p2,其本质调用是 p1.operator+(p2); 。你会发现,是 +号前面的对象调用函数,加号后面的对象是参数 。所以,当我们调用Person& operator++();的时候,是不是应该写 p1++??
答案:(个人推测)可能和后置递增有关。为了区分前置和后置。
后置递增。
第一个问题 :是后置递增类内重载的写法遇到的问题:
返回值和参数都是啥??想这样写??
Person operator++();
Person& operator++();
Person operator++(Person& p);
....
想了好久,也没想出来该怎么写。
答案:const Person operator++(int)
其中int的作用是占位符,为了和前置递增区分开来,而且只能写int,写double、float等都是不行的。因为没有这个占位参数的话,该函数与前置递增就只有返回值不同了,而返回值是不可以作为函数重载的条件的。
至于返回值的为什么是Person话,而且还用const修饰,在下一个问题中说明。
第二个问题 具体是怎样实现的,毕竟后置递增和前置递增还是有区别的。
答案:
const Person operator++(int)
{Person p = *this;
age += 1;
return p;
}
首先创建一个临时的对象,用来保存当前值,因为该函数最后返回的不是递增后的结果,而是递增之前的值。
然后,属性加一,完成递增操作。
最后,返回临时对象
注意1: 此时的temp是一个临时对象,该函数运行结束后就会被编译器回收,所以我们直接返回temp的引用。我们需要进行值返回,值返回的话会调用拷贝构造函数重新创建一个对象。
注意2: 返回值用const修饰,他能防止一些问题,例如: (p++)++ 。我们可以做一个小测试。
int p = 0;
cout<< "(p++)++ = "<< (p++)++<< endl;
cout<< "p = "<< p<< endl;
我们预想的结果可能是输出:(p++)++ = 1 p = 2
但实际结果是这样的:
报错了,原因是++需要可修改的左值。从结果我们可以知道,表达式p++的结果是不允许被修改的,所以我们后置递增的返回值是const类型的。
那么为什么会这样呢?
同样举个例子:
int p;
cout<< "p = "<< p<< endl;
cout<< "p++ = "<< p++<< endl;
cout<< "p = "<< p<< endl;
运行结果如下:
我们输出 p++ 的结果是0,这个0是哪里来的呢??是变量p中存储的吗??并不是,此时p中存储的值已经被改变了,这个0是产生的一个临时值。这个临时值在内存中的位置是未知的,我们无法对其进行修改。
所以,当我们 (p++)++ 这样使用后置递增运算符的时候,相当于尝试修改临时变量的值,这是不被允许的。
所以,我们重载递增操作符的返回值要用const来修饰。
你是否还在寻找稳定的海外服务器提供商?创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源,准确流量调度确保服务器高可用性,企业级服务器适合批量采购,新人活动首月15元起,快前往官网查看详情吧