PoEduo - C++阶段班【Po学校】-Lesson03-5_运算符重载- 第7天
PoEduo - Lesson03-5_运算符重载- 第7天 |
复习前面的知识点
空类会自动生成哪些默认函数
6个默认函数 1 构造 2 析构 3 赋值 4 拷贝构造 5 operator&(返回的是this) 6 operator*
深拷贝 与 浅拷贝 当有指针参与的情况下,请注意维护对象属性的生命同期。
关键字 explicit 禁止函数隐式的转换
示例 写一个Integer 类
#include <iostream> class Integer { public: Integer(int num = 0):_num (num){} void operator = (int num) { _num = num; } private: int _num; }; int main() { Integer demo = 10; demo = 100; // 在这里拷贝赋值效率低下,因为产生临时对象,所以可以重载operator=(Integer&) return 0; }
看高亮代码,引出 运算符重载
operator 运算符
除了5个不能重载,其它符号都能够重载,举例说明: “&”取地址运算符(不仅仅可以重载,它是默认生成的函数)。
五个无法重载的运算符: 1 “::”域运算符 2 “?:”三目运算符 3 “.” 直接成员访问运算符 4 sizeof运算符 5 “*.”类成员指针运算符
运算符是有语义的,要根据对象的需求来重载运算符。
如果要连续的赋值,就要设计函数的返回值了:
#include <iostream> class Integer { public: Integer(int num = 0):_num (num){} Integer& operator = (int num) { _num = num; return *this; } int GetNum()const { return _num; } private: int _num; }; int main() { Integer demo ,other; demo = other = 100; std::cout << demo.GetNum() << std::endl; return 0; }
以上代码才是正常的写法,考虑到了连续=的使用情况。
看上图,充值说明连续赋值,少不了返回值,没有返回值,是不能连续赋值操作的。
如果返回值是void,那demo.operator=(other.operator(100));里面的other.operator(100)这个函数就返回void,就会变成:demo.operator=(void);程序就出错了。改返回为Integer&,return *this;“Integer&”可以理解为默认的Integer类型的引用,它调用了默认赋值函数。代码在Integer& operator=(int num)这个函数里面加一个输出:
Integer& operator = (int num) { std::cout << "Integer& operator = (" << num << ")" << std::endl; _num = num; return *this; }
运行:
进一步的验证,确实调用了operator=函数,那么返回Integer&这时候调用了默认赋值,是这样子的么,再来把默认赋值也写上:
Integer& operator = (const Integer& other) { std::cout << "Integer& operator = (默认赋值函数被调用……)" << std::endl; _num = other._num; return *this; } Integer& operator = (int num) { std::cout << "Integer& operator = (" << num << ")" << std::endl; _num = num; return *this; }
对比上下两个operator=函数,它们的返回类型都是Integer&,下面的返回一个int值的opetatro=函数,能不能改成Int类型返回呢?
Integer(int num = 0):_num (num){} Integer& operator = (const Integer& other) { std::cout << "Integer& operator = (默认赋值函数被调用……)" << std::endl; _num = other._num; return *this; } int operator = (int num) { std::cout << "Integer& operator = (" << num << ")" << std::endl; _num = num; return _num; }
运行:
改了代码,程序能够正确运行,但程序的语义不对版本,类型和我们期望的类型不一致了。我要一个越南新娘,你给我返回了一个“东莞退休”的。并不是我们想要的。
所以operator=函数,返回的一定是我们当前对象的引用。
重载operator+=
#include <iostream> class Integer { public: Integer(int num = 0):_num (num){} Integer& operator = (const Integer& other) { std::cout << "Integer& operator = (默认赋值函数被调用……)" << std::endl; _num = other._num; return *this; } Integer& operator = (int num) { std::cout << "Int operator = (" << _num << ")" << std::endl; _num = num; return *this; } Integer& operator+ (const int num) { _num += num; return *this; } int GetNum()const { return _num; } private: int _num; }; int main() { Integer demo(10) ,other(20); demo = other = 100; other = demo + 100; std::cout << demo.GetNum() << std::endl; return 0; }
运行:
再来:如果写成demo = 100+ othter; int类型在前,就又出现问题了:这个时候,相当于这样子调用,int.operator+(other);
引出友元的概念:友元,它不属于我们当前的类,但它能调用当前类的成员。一般用来重载运算符:
friend Integer& operator+(int num,Integer& me) { me._num += num; return me; }
运行:
定义了一个Integer类型的引用友元:Integer& me,计算并接收结果后,返回友元。
demo = 100 + other +1000;这句代码会调用哪几个函数呢?
1 friend operator+ ; 2 operator+ ; 3 赋值 ; 注意“+”号的优先级。
发现上例重载+有点小问题,正常的加是不需要修改本身的,上例正确来说是“+=”的重载。
那么 ,正常int里面的“+”,怎么重载呢?
Integer& operator+= (const int num) { _num += num; return *this; } friend Integer& operator+=(int num,Integer& me) { me._num += num; return me; }
改为正常的“+”重载:
Integer operator+(const int num) { Integer temp = _num; temp._num += num; return temp; } friend Integer operator+(int num, const Integer& me) { Integer temp = me._num; temp._num += num; return temp; }
对比一下,看重载是否正确:
完全一样,成功实现+重载。
重载“++”运算符
那么,一个++它是前加加还是后++呢,我们可以用一个没参数,一个拥有参数来区别,重载实现:
先测试下子,哪个是前++,哪个是后++:
再看一段代码,有关临时对象的知识点:
#include <iostream> class Integer { public: Integer(int num = 0):_num(num) { std::cout << "Integer(int "<<")" << _num<< std::endl; } Integer(const Integer& other):_num(other._num) { std::cout << "Integer(const Integer& other "<< " )" << _num << std::endl; } ~Integer() { std::cout << "~Integer( " << " )" << _num << std::endl; } Integer& operator = (const Integer& other) { std::cout << "Integer& operator = (默认赋值函数被调用……)" << std::endl; _num = other._num; return *this; } Integer& operator = (const int num) { std::cout << "Int operator = (" << _num << ")" << std::endl; _num = num; return *this; } Integer operator+(const int num) { Integer temp = _num; temp._num += num; return temp; } friend Integer operator+(int num, const Integer& me) { Integer temp = me._num; temp._num += num; return temp; } Integer& operator+= (const int num) { _num += num; return *this; } friend Integer& operator+=(int num,Integer& me) { me._num += num; return me; } Integer operator++(int) //后++ { Integer temp = *this; _num += 1; return temp; } Integer& operator++() //前++ { _num += 1; return *this; } int GetNum()const { return _num; } private: int _num; }; Integer f1() { return Integer(10); } Integer& f2() { return Integer(20); } int main() { Integer i1 ; Integer i2 ; i1 = f1(); i2 = f2(); return 0; }
运行:
仔细看f1(),这是返回对象。用f10,f11 调试,看到底在哪里析构:
从调用f1开始:
再看:
创建临时对象,调用了构造函数。
还在f1()之内
f1()生命周期终结,返回对象:
跳出了f1(),回来99行的代码:i1=xxx; 此时并没有析构对象。
i1 = xxx; 调用拷贝赋值operator=
拷贝赋值operator=函数完成任务
再次跳转99行代码:i1=xxx;
到了这里,99行的i1=f1(); 才正常结束,这里要验证的是:f1()方法返回对象,它是在哪里析构的呢:返回对象,它是在赋值语句完成结束后,也就是函数的外面,99行i1= xxx; 完成结束时,才调用析构的。
再看f2(),返回引用。
f2()和f1()最大的区别:
这个调用了默认的拷贝赋值函数,是在i2 = XXX;这个时候调用的,这个时候f2()已经跳出了。而重点是:临时对象是在哪里析构的呢?它是在f2()函数跳出时,调用析构函数。问题是:如上图,在默认赋值函数中,被调用方other这个对象,在跳出f2()之时被析构,已经是不安全的了。虽然赋值的数据没有出错,但已经不安全的了,危险就来自函数f2里面,临时对象抛出了一个引用后,跳出函数 ,析构玩消失~!
再回头看 i1 = f1(); 这个是用f1返回一个对象,这个对象是在 (i1 = XXX ;) 拷贝赋值完成之后被析构的, 而f2()返回的是一个对象引用,它是在跳出函数的时候就被析构的,所以,赋值语句里面,函数的返回赋值给一个对象时,函数返回一个对象的引用是不安全的。
关系运算符
bool operator==(const Integer& other)const { return _num== other._num; }
插入 提取 流运算符
"<<" ">>"
friend void operator<<(std::ostream& os,const Integer& me) { os << me._num; }
运行发现以上代码不可以连续的<< 现修改:
friend std::ostream operator<<(std::ostream& os,const Integer& me) { os << me._num; return os; }
运行报错:
1>------ 已启动生成: 项目: PoEdu_Integer, 配置: Debug Win32 ------
1> main.cpp
1>e:\c_code\poedu_integer\poedu_integer\main.cpp(83): error C2280: “std::basic_ostream<char,std::char_traits<char>>::basic_ostream(const std::basic_ostream<char,std::char_traits<char>> &)”: 尝试引用已删除的函数
1> c:\program files (x86)\microsoft visual studio 14.0\vc\include\ostream(84): note: 参见“std::basic_ostream<char,std::char_traits<char>>::basic_ostream”的声明
========== 生成: 成功 0 个,失败 1 个,最新 0 个,跳过 0 个 ==========
ostream流对象,是不让新建的,只能返回一个引用
friend std::ostream& operator<<(std::ostream& os,const Integer& me) { os << me._num; return os; }
改成引用 就OK了。os内部会进行改变,不能加const。
来看std::cin >>
friend std::istream& operator>>(std::istream& lhs, Integer& rhs) { lhs >> rhs._num; return lhs; }
这里Integer& rhs就不能是const.
资料查阅:链接地址www.cplusplus.com/reference/vector/vector/?kw=vector |
作业: |
预告,下节学习内容:友元 |
![](https://images2015.cnblogs.com/blog/1017002/201612/1017002-20161231222210445-1148779207.png)