运算符重载（日志12）

1.概念

  运算符的重载，实际是一种特殊的函数重载，必须定义一个函数，并告诉C++编译器，当遇到该运算符时就调用此函数来行使运算符功能。这个函数叫做运算符重载函数（常为类的成员函数）。

  用函数的方式实现了（+ - * / []数组 & || 逻辑 等）运算符的重载。根据需求决定重载那些运算符，用到的时候再百度案例即可

2.运算符重载的基本格式

重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表。

Box operator+(const Box&);

   operator是关键字，它与重载的运算符一起构成函数名。

声明加法运算符用于把两个 Box 对象相加，返回最终的 Box 对象。大多数的重载运算符可被定义为普通的非成员函数或者被定义为类成员函数。如果我们定义上面的函数为类的非成员函数，那么我们需要为每次操作传递两个参数，如下所示：

Box operator+(const Box&, const Box&);

3.可重载运算符/不可重载运算符

4.运算符重载的方法

4.1一元运算符重载（注意：返回值当左值的时候，返回的是一个引用）

4.1.1插入运算符重载>> and 提取运算符重载<<

以提取运算符重载<<为例，cout 是 ostream 标准输出流类的对象。ostream 类和 cout 都是在头文件 中声明的。ostream 类将<<重载为成员函数。

#include <iostream>
using namespace std;

class Point{
public:
    Point(){};
    Point (int x, int y): x(x),y(y) {};
    friend ostream &operator<<(ostream &out , const Point &a);  //因为 << 是C++提供的类，我们无法访问，只能用友元函数。
private:
    int x,y;
};

//<< 运算符重载的函数实现   ostream是输出流的类/istream是输入流的类
ostream &operator<<(ostream &out , const Point &a){
    out << "<Point>( " << a.x << ", " << a.y << ")";
    return out;
}

int main() {

    cout << c<< endl;    //直接输出类会报错，需要上面的 << 运算符重载
}

输出结果：< Point>( 7, 7)

重点：另外应该会有人对ostream &operator<<(ostream &out , const Point &a)函数感到疑惑，首先在重载<<时，返回值类型是ostream&, 第一个参数也是ostream& 。也就是说，表达式cout<<c的返回值仍是 cout，所以cout<<c<<endl;才能成立。

4.1.2前置运算符重载++ and 后置运算符重载++

重点：为区别前置和后置运算符，C++编译器要求，需要在后置运算符重载函数中加参数“int”，这个类型在此除了以示区别之外并不代表任何实际含义；如果不加，编译器无法区分是前置++，还是后置++，导致报错。

#include <iostream>
using namespace std;

class Point{
public:
    Point(){};
    Point (int x, int y): x(x),y(y) {};
    friend Point operator+(const Point &, const Point &);
    friend ostream &operator<<(ostream &out , const Point &a);
    Point& operator++(){ //前置++运算符，需要引用返回，不需要参数。返回自增后的值，且返回的是一个左值 
        this->x ++;
        this->y ++;
        return *this;
    }
     //const 修饰返回值不能修改  
    const Point operator++(int){//后置++，不需要引用返回，需要参数区分。返回自增前的值，且返回的是一个右值
        Point temp(x,y);       //因为后置++，是先使用，后自++，所以这里要保存一个临时值，再++，返回的是临时值。
        this->x ++;
        this->y ++;
        return temp;
    }
private:
    int x,y;
};

Point operator+(const Point &a,const Point &b){
    Point ret;
    ret.x = a.x + b.x;
    ret.y = a.y + b.y;
    return ret;
}

ostream &operator<<(ostream &out , const Point &a){
    out << "<Point>(" << a.x << " , " << a.y << ")";
    return out;
}


int main() {
    Point a(2,4),b(5,3);
    Point c = a + b;
    cout << c << endl;
    c++;
    cout << c << endl;
    ++c;
    cout << c << endl;
}

4.1.3=等号运算符重载

C++中，对类对象进行操作时，就不能只是简简单单地，对类对象用=进行操作。

当没有自己设计等号运算符的重载函数，编译器会自动生成一个浅拷贝的赋值运算符的重载函数。

浅拷贝：只是简单地将一个对象的内存数据赋值给另一个对象，如果这个对象成员变量引用了外部资源时（new），那么这两个对象的成员变量都指向这个空间，当这两个对象生存周期结束时，进行析构，那么就会崩溃，对同一块内存delete了两次。

#include <iostream>
using namespace std;

class  Name
{
public:

   	//main函数中的问题   Name obj2 = obj1;  
	//解决方案: 手工的编写拷贝构造函数 使用深copy
	Name(const Name& obj)
	{
		m_len = obj.m_len;
		m_p = (char *)malloc(m_len + 1);
		strcpy(m_p, obj.m_p);
	}

   //等号运算符重载函数
	Name& operator=(Name &obj)  
	{
		//1.先释放旧的内存
		if (this->m_p != NULL)
		{
			delete[] m_p;
			m_len = 0;
		}
		//2.根据obj分配内存大小
		this->m_len = obj.m_len;
		this->m_p = new char [m_len+1]; //加1，结束符'\n'。
		
		//3.把obj赋值
		strcpy(m_p, obj.m_p);  //字符串的拷贝函数
		return *this;
	}
	
	~Name()    //析构函数
	{
		if (m_p != NULL)
		{
			free(m_p);
			m_p = NULL;
			m_len = 0;
		}
	}
protected:
private:
	char *m_p ;
	int m_len; 
};

void main()
{

	Name obj1("abcdefg");
	Name obj2 = obj1;  //C++编译器提供的 默认的copy构造函数  浅拷贝，需要手工编写构造函数
	Name obj3("obj3");

	obj1 = obj2 = obj3;    //调用等号运算符重载
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

4.2二元运算符重载

4.2.1类内重载

#include <iostream>
using namespace std;

class Point{
public:
    Point(){};
    Point (int x, int y): x(x),y(y) {};
    Point operator+(const Point &b){ //类内重载，运算符重载函数作为类的成员函数
        Point ret;
        ret.x = this->x + b.x;
        ret.y = this->y + b.y;
        return ret;
    }
    int x,y;
};

int main() {
    Point a(2,4),b(5,3);
    Point c = a + b;      //这里c++编译器会，自动去找 + 运算符的重载函数
	cout<< "x :" << c.x << endl;
    cout<<"y :" << c.y << endl;
}
//运行结果：x : 7     y : 7

重点：运算符重载是类内重载时，运算符重载函数作为类的成员函数，以上述代码为例 a + b 相当于 a 对象调用+方法并且传入参数时 b 对象。

4.2.2类外重载（用友元函数的方法实现）

#include <iostream>
using namespace std;

class Point{
public:
    Point(){};
    Point (int x, int y): x(x),y(y) {};
    friend Point operator+(const Point &, const Point &);   //声明类的友元函数
    int x,y;
};

Point operator+(const Point &a,const Point &b){//类外重载,运算符重载函数作为类的友元函数
    Point ret;
    ret.x = a.x + b.x;
    ret.y = a.y + b.y;
    return ret;
}

int main() {
     Point a(2,4),b(5,3);
    Point c = a + b;
	cout<< "x :" << c.x << endl;
    cout<<"y :" << c.y << endl;
}