1、回顾上一节
上一节中,我们通过了两个全局友元函数进行了运算符重载,并且简单说明了如何进行类成员函数的运算符重载,这里首先将全局重载函数改写为成员重载函数!
示例:
#include <iostream>
using namespace std;
class Complex
{
private:
int a;
int b;
public:
Complex(int i = 0, int j = 0)
{
a = i;
b = j;
}
//成员函数操作符重载
Complex operator+ (const Complex& rb);
friend ostream& operator<< (ostream& out,const Complex& rc);
};
//“+”号运算符为双目运算符,所以重载参数有两个,且只能有两个,但是如果该重载函数为类的
//成员函数,那么就只能有一个显示的参数,因为会有一个隐藏的this指针参数
Complex Complex::operator+ (const Complex& rb)
{
Complex ret;
ret.a = this->a + rb.a;
ret.b = this->b + rb.b;
return ret;
}
//这里返回类型为ostream类对象的引用,是为了函数调用完成后,还能继续使用cout对象
//比如:cout << c3 << endl; ==> (cout << c3) << endl;
//如果返回值不为ostream&,那么该调用会失败!
ostream& operator<< (ostream& out, const Complex& rc)
{
out << rc.a << " + " << rc.b << "i";
return out;
}
int main()
{
Complex c1(5, 2);
Complex c2(4, 9);
Complex c3 = c1 + c2; //等价于:c1.operator+(c2);
cout << c3 << endl; //等价于:operator<<(cout,c3);
cout << "Press any key to continue..." << endl;
cin.get();
return 0;
}
思考:
什么时候使用全局函数重载操作符?什么时候使用成员函数重载操作符?
- 当无法修改左操作数的类的实现时,使用全局函数进行重载,用这种方法也能对原有的类进行功能扩展,即使我们没有源代码
- C++规定,=, [], ()和->操作符只能通过成员函数进行重载
2、类的默认操作符重载
- C++编译器会为每个类提供默认的赋值操作符,既是拷贝构造函数
- 默认的赋值操作符只是做简单的值复制
- 类中存在指针成员变量时就需要重载赋值操作符,因为一旦只进行简单的值复制,那么两个对象的的成员变量就同时指向了同一内存空间,这就会引发问题,比如,b对象是a对象的拷贝,如果a对象被析构,那么它申请的内存空间会被释放,而b对象此时正“使用”着该内存空间!
3、“++”和“–”运算符的重载
- 这两个操作符只有一个操作数
- 这两个操作符有前缀和有后缀的区分
思考:
那么,如何重载这两个操作符才能区分前置运算和后置运算??
答案:
可以通过占位参数来实现,因为操作符的重载本质上还是函数的重载,所以可以用参数的不同来区分两者,这里实现“++”运算符的重载来举例说明!
示例:
#include <iostream>
using namespace std;
class Complex
{
private:
int a;
int b;
public:
Complex(int i = 0, int j = 0)
{
a = i;
b = j;
}
//成员函数操作符重载
Complex operator+ (const Complex& rb);
friend ostream& operator<< (ostream& out,const Complex& rc);
Complex operator++ (int); //obj++
Complex& operator++ (); //++obj
};
//“+”号运算符为双目运算符,所以重载参数有两个,且只能有两个,但是如果该重载函数为类的
//成员函数,那么就只能有一个显示的参数,因为会有一个隐藏的this指针参数
Complex Complex::operator+ (const Complex& rb)
{
Complex ret;
ret.a = this->a + rb.a;
ret.b = this->b + rb.b;
return ret;
}
//这里返回类型为ostream类对象的引用,是为了函数调用完成后,还能继续使用cout对象
//比如:cout << c3 << endl; ==> (cout << c3) << endl;
//如果返回值不为ostream&,那么该调用会失败!
ostream& operator<< (ostream& out, const Complex& rc)
{
out << rc.a << " + " << rc.b << "i";
return out;
}
//为了与内置版本保持一致,后置运算符应该返回对象的原值,返回一个值而非引用
//为了同时重载前置和后置运算符,后置版本接受一个额外的(不被使用)int类型的形参,当我们使用后置运算符时,编译器为这个形参提供一个值为0的实参
Complex Complex::operator++ (int) //obj++
{
cout << "obj++" << endl;
Complex temp = *this;
this->a++;
this->b++;
return temp;
}
//这里返回值使用引用是为了和内置版本保持一致
Complex& Complex::operator++ () //++obj
{
cout << "++obj" << endl;
this->a++;
this->b++;
return *this;
}
int main()
{
Complex c1(5, 2);
Complex c2(4, 9);
Complex temp = c2++; //等价于: temp = c2; c2.operator++(int);
temp = ++c2; //等价于: c2.operator++(); temp = c2;
(++c2)++;
Complex c3 = c1 + c2; //等价于:c1.operator+(c2);
cout << c3 << endl; //等价于:operator<<(cout,c3);
cout << "Press any key to continue..." << endl;
cin.get();
return 0;
}
4、不应该被重载的运算符
最好不要去重载”&&”、”||” 和 “,” 运算符,原因如下:
- &&和||内置实现了短路规则
- “,”号运算符的重载版本无法保证它原有的求值顺序
- 操作符重载是靠函数重载来完成的
- 操作数作为函数参数传递
- C++的函数参数都会被求值,无法实现短路规则
5、不能被重载的运算符
- ‘::’ – 作用域运算符
- ‘.*’ – 成员指针运算符
- ‘.’ – 成员运算符
- ‘? :’ – 条件运算符
- ‘sizeof’ – sizeof运算符
TIPS:
”.*/->*” – 成员指针运算符的使用举例
#include <iostream>
using namespace std;
class CTEST
{
public:
double data;
public:
CTEST(double x)
{
data = x;
}
double fx(double x)
{
return data*data-x;
}
};
int main()
{
CTEST obj(3.14); //定义一个类对象
CTEST *p = &obj; //定义一个对象指针,并指向obj对象
double CTEST::*ip; //定义一个类成员变量指针,注意和 double *ip; 区分
ip = &CTEST::data; //让ip指针指向一个类成员变量,注意和 ip = &obj.data; 区分
cout << "obj.*ip = " << obj.*ip << endl; //通过对象名使用成员变量指针访问
cout << "obj.data = " << obj.data << endl; //普通的成员变量访问
cout << "p->*ip = " << p->*ip << endl; //通过对象指针使用成员变量指针访问
cout << "p->data = " << p->data << endl; //普通的成员变量访问
double (CTEST::*fp)(double); //定义一个类成员函数指针,注意和 double (*fp)(double); 区分
fp = &CTEST::fx; //让fp指向类成员函数,这里得显示取地址,注意和 fp = &obj.fx; 区分
cout << "(obj.*fp)(0.5) = " << (obj.*fp)(0.5) << endl;
cout << "obj.fx(0.5) = " << obj.fx(0.5) << endl;
cout << "(p->*fp)(5.5) = "<< (p->*fp)(5.5) << endl;
cout << "(p->fx)(5.5) = " << (p->fx)(5.5) << endl;
return 0;
}
6、小结
- 操作符重载可以直接使用类的成员函数实现
- =, [], ()和->操作符只能通过成员函数进行重载
- ++操作符通过一个int参数进行前置与后置的重载
- C++中不要重载&&、|| 和 , 操作符
- C++中不允许重载 ::、.*、. 、? :、sizeof运算符