PoEduo - Lesson03-5_运算符重载- 第7天 |
复习前面的知识点
空类会自动生成哪些默认函数
6个默认函数 1 构造 2 析构 3 赋值 4 拷贝构造 5 operator&（返回的是this） 6 operator*
深拷贝 与 浅拷贝 当有指针参与的情况下，请注意维护对象属性的生命同期。
关键字 explicit 禁止函数隐式的转换
示例 写一个Integer 类
#include <iostream> class Integer
{
public:
Integer(int num = ):_num (num){}
void operator = (int num)
{
_num = num;
}
private:
int _num;
}; int main()
{
Integer demo = ;
demo = ; // 在这里拷贝赋值效率低下，因为产生临时对象，所以可以重载operator=(Integer&) return ;
}
看高亮代码，引出 运算符重载
operator 运算符
除了5个不能重载，其它符号都能够重载，举例说明： “&”取地址运算符（不仅仅可以重载，它是默认生成的函数）。
五个无法重载的运算符： 1 “：：”域运算符 2 “？：”三目运算符 3 “.” 直接成员访问运算符 4 sizeof运算符 5 “*.”类成员指针运算符
运算符是有语义的，要根据对象的需求来重载运算符。
如果要连续的赋值，就要设计函数的返回值了：
#include <iostream> class Integer
{
public:
Integer(int num = ):_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 = ; std::cout << demo.GetNum() << std::endl; return ;
}
以上代码才是正常的写法，考虑到了连续=的使用情况。
看上图，充值说明连续赋值，少不了返回值，没有返回值，是不能连续赋值操作的。
如果返回值是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 = ):_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 = ):_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() ,other();
demo = other = ;
other = demo + ; std::cout << demo.GetNum() << std::endl; return ;
}
运行：
再来：如果写成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 = ):_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 += ;
return temp;
} Integer& operator++() //前++
{
_num += ;
return *this; } int GetNum()const
{
return _num;
}
private:
int _num;
}; Integer f1()
{
return Integer();
} Integer& f2()
{
return Integer();
} int main()
{
Integer i1 ;
Integer i2 ; i1 = f1();
i2 = f2(); return ;
}
运行：
仔细看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 |
作业： |
预告，下节学习内容：友元 |