第13课 - 操作符重载 - 下

思考：

通过operator关键字能够将操作符定义为全局函数，操作符重载的本质就是函数重载。类的成员函数是否可以作为操作符重载的函数？

1. operator+的成员函数实现

#include <cstdlib>

#include <iostream>

using namespace std;

class Complex

{

int a;

int b;

public:

Complex(int a, int b)

{

this->a = a;

this->b = b;

}

int getA()

{

return a;

}

int getB()

{

return b;

}

Complex operator+ (const Complex& c2);

//看上去只有一个参数，实际有俩，另一个是this指针

friend ostream& operator<< (ostream& out, const Complex& c);

};

ostream& operator<< (ostream& out, const Complex& c)

{

out<<c.a<<" + "<<c.b<<"i";

return out;

}

Complex Complex::operator+ (const Complex& c2)

{

Complex ret(0, 0);

ret.a = this->a + c2.a;

ret.b = this->b + c2.b;

return ret;

}

int main(int argc, char *argv[])

{

Complex c1(1, 2);

Complex c2(3, 4);

Complex c3 = c1 + c2;

cout<<c1<<endl;

cout<<c2<<endl;

cout<<c3<<endl;

cout << "Press the enter key to continue ...";

cin.get();

return EXIT_SUCCESS;

}

运行结果：

1 + 2i

3 + 4i

4 + 6i

用成员函数重载的操作符，比全局操作符重载函数少一个参数，即左操作数。另外也不需要使用friend关键字。

Complex c1(1, 2);

Complex c2(3, 4);

Complex c3 = c1 + c2;

等价于

Complex c1(1, 2);

Complex c2(3, 4);

Complex c3 = c1.operator+ c2;

操作符的重载实际上就都是函数来实现的。

问：

什么时候使用全局函数重载操作符？什么时候使用全局函数重载操作符？

答：

l  当无法修改左操作数的类时，使用全局函数进行重载。

l  =, [], ()和->操作符只能通过成员函数进行重载。

2. 代码—数组的改进

重载赋值操作符，重载数组操作符，重载比较操作符。

C++编译器会为每个类提供默认的赋值操作符。默认的赋值操作符只是做简单的值复制。

类中存在指针成员变量时就需要重载赋值操作符。

Array.h

#ifndef _ARRAY_H_

#define _ARRAY_H_

class Array

{

private:

int mLength;

int* mSpace;

public:

Array(int length);

Array(const Array& obj);

int length();

~Array();

int& operator[](int i);

Array& operator= (const Array& obj);

bool operator== (const Array& obj);

bool operator!= (const Array& obj);

};

#endif

Array.cpp

#include <stdio.h>

#include "Array.h"

Array::Array(int length)

{

if( length < 0 )

{

length = 0;

}

mLength = length;

mSpace = new int[mLength];

}

Array::Array(const Array& obj)

{

mLength = obj.mLength;

mSpace = new int[mLength];

for(int i=0; i<mLength; i++)

{

mSpace[i] = obj.mSpace[i];

}

}

int Array::length()

{

return mLength;

}

Array::~Array()

{

mLength = -1;

printf("%08X\n", mSpace);

delete[] mSpace;

}

int& Array::operator[](int i)

{

return mSpace[i];

}

Array& Array::operator= (const Array& obj)

{

delete[] mSpace;

mLength = obj.mLength;

mSpace = new int[mLength];

for(int i=0; i<mLength; i++)

{

mSpace[i] = obj.mSpace[i];

}

return *this;

}

bool Array::operator == (const Array& obj)

{

bool ret = true;

if( mLength == obj.mLength )

{

for(int i=0; i<mLength; i++)

{

if( mSpace[i] != obj.mSpace[i] )

{

ret = false;

break;

}

}

}

else

{

ret = false;

}

return ret;

}

bool Array::operator!= (const Array& obj)

{

return !(*this == obj);

}

main.c

#include <stdio.h>

#include "Array.h"

int main()

{

Array a1(10);

Array a2(0);

Array a3(0);

if( a1 != a2 )

{

printf("a1 != a2\n");

}

for(int i=0; i<a1.length(); i++)

{

a1[i] = i + 1;

}

for(int i=0; i<a1.length(); i++)

{

printf("Element %d: %d\n", i, a1[i]);

}

a3 = a2 = a1;

if( a1 == a2 )

{

printf("a1 == a2\n");

}

for(int i=0; i<a2.length(); i++)

{

printf("Element %d: %d\n", i, a2[i]);

}

printf("Press any key to continue...");

getchar();

return 0;

}

3. 要点

C++编译器会为每个类提供默认的赋值操作符。

默认的赋值操作符只是做简单的值复制。

类中存在指针成员变量时就需要重载赋值操作符。

l  ++操作符的重载（--操作符是一样的）

++操作符只有一个操作数.

++操作符有前缀和有后缀的区分

l  如何重载++操作符才能区，分前置运算和后置运算？

操作符重载是通过函数重载实现的，C++中通过一个占位参数来区分前置运算和后置运算。

#include <cstdlib>

#include <iostream>

using namespace std;

class Complex

{

int a;

int b;

public:

Complex(int a, int b)

{

this->a = a;

this->b = b;

}

int getA()

{

return a;

}

int getB()

{

return b;

}

Complex operator+ (const Complex& c2);

Complex operator++ (int); // obj++

Complex& operator++(); // ++obj

friend ostream& operator<< (ostream& out, const Complex& c);

};

ostream& operator<< (ostream& out, const Complex& c)

{

out<<c.a<<" + "<<c.b<<"i";

return out;

}

Complex Complex::operator++ (int) //具体的实现

{

Complex ret = *this;  //拷贝构造函数，将当前的值拷贝到ret中。

a++;

b++;

return ret;

}

Complex& Complex::operator++()  //具体的实现

{

++a;

++b;

return *this;

}

//以上连个函数说明前置的++效率更高。

Complex Complex::operator+ (const Complex& c2)

{

Complex ret(0, 0);

ret.a = this->a + c2.a;

ret.b = this->b + c2.b;

return ret;

}

int main(int argc, char *argv[])

{

Complex c1(1, 2);

Complex c2(3, 4);

Complex c3 = c2;

c2++;

++c3;

cout<<c1<<endl;

cout<<c2<<endl;

cout<<c3<<endl;

cout << "Press the enter key to continue ...";

cin.get();

return EXIT_SUCCESS;

}

4. 为什么不能重载&&和||操作符

从语法的角度可以重载，但是最好不要，容易出错。

#include <cstdlib>

#include <iostream>

using namespace std;

class Test

{

int i;

public:

Test(int i)

{

this->i = i;

}

Test operator+ (const Test& obj)  //加法操作符重载

{

Test ret(0);

cout<<"Test operator+ (const Test& obj)"<<endl;

ret.i = i + obj.i;

return ret;

}

bool operator&& (const Test& obj)  //与运算操作符重载

{

cout<<"bool operator&& (const Test& obj)"<<endl;

return i && obj.i;

}

};

int main(int argc, char *argv[])

{

int a1 = 0;

int a2 = 1;

if( a1 && (a1 + a2) )

{

cout<<"Hello"<<endl;

}

Test t1 = 0;

Test t2 = 1;

if( t1 && (t1 + t2) )

{

cout<<"World"<<endl;

}

cout << "Press the enter key to continue ...";

cin.get();

return EXIT_SUCCESS;

}

运行结果：

Test operator+ (const Test& obj)

bool operator&& (const Test& obj)

l  &&和||是C++中非常特殊的操作符。

l  &&和||内置实现了短路规则。

l  操作符重载是靠函数重载来完成的。

l  操作数作为函数参数传递。

l  C++的函数参数都会被求值，无法实现短路规则。

小结：

操作符重载可以直接使用类的成员函数实现。

=, [], ()和->操作符只能通过成员函数进行重载。

++操作符通过一个int参数进行前置与后置的重载。

C++中不要重载&&和||操作符。