在C++里面几乎可以重载所有的运算符
. .* :: ?:
sizeof typeid
static_cast dynamic_cast const_cast reinterpret_cast
这些运算符不能重载
只有已经存在的运算符可以重载,不能自己创造
重载的运算符不能改变其原来的操作数
不能改变它的优先级
运算符重载为成员函数参数表可以少一个,因为有一个隐藏的参数
重载为非成员函数,参数个数与操作数相同
x+y => x.operator+(y)
运算符左边的表达式叫做 receiver, 它决定用哪个 +
重载运算符的建议:
1: 单目的 应该 做成成员的
2: = () -> ->* 一定要做成成员的
3: 所有的二元运算符都做成非成员的
传进去的参数必须是引用,而且如果运算会改变算子就不能是const
assignment operator (重载赋值运算符)
如果没有自己重载的 =
那么系统生成的是一个成员级别的赋值,这一点跟拷贝构造是一样的
如果要写一个自己的重载 = ,那么这个函数必须是成员函数
如果类里面有指针,动态内存分配的需要自己写一个重载的 = 没有,就可以不写
防止系统做的错误行为,可以将 assignment operator 声明为private, 但这样写代价很大,因为这个类的对象是不能被赋值的
在构造函数加上 explicit 关键字,就意味着是显示的构造,不能做自动类型转换
尽量少用自动帮你做的事情(构造,类型转换...)
learning record code:
#include <iostream>
#include <string>
#include <cstring>
using namespace std;
class Integer{
private:
int i;
public:
Integer(int n = 0) : i(n) {}
const Integer operator+(const Integer &n) const
{
return Integer(i + n.i); // 返回的是一个对象,且不可修改
}
friend const Integer operator + (const Integer &lhs, const Integer &rhs);
operator double() const;
};
Integer::operator double() const // 专用的类型转换函数,将Integer的对象转换成double类型
{
return (double) i;
}
const Integer operator + (const Integer &lhs, const Integer &rhs)
{
return Integer(lhs.i + rhs.i);
}
class Cargo{
private:
char *p;
public:
Cargo & operator = ( const Cargo & rhs )
{
if(this != &rhs) // 一定要有这个判断
{
// perform assignment
delete p; // 如果没有之前的if判断,这里就会出错
p = new char[strlen(rhs.p) + 1];
strcpy(p, rhs.p);
}
cout << "inside Cargo::operator=" << endl;
return *this;
}
};
class Truck{
Cargo b;
};
class PathName{
private:
string name;
public:
explicit PathName(const string &); // 显式的构造函数,不能做自动类型转换
~PathName();
};
// class Orange;
// class Apple{
// int k;
// public:
// operator Orange() const;
// };
// Apple::operator Orange() const
// {
// }
// class Orange{
// int j;
// public:
// explicit Orange(Apple); // 显式构造函数,不能做隐式的类型转换
// };
// Orange::Orange(Apple)
// {
// }
// void f(Orange)
// {
// }
int main()
{
Truck a, b;
a = b;
return 0;
}