C++的运算符重载(2)

一、赋值运算符重载函数返回引用

1、返回引用好处1：提升程序效率

(1)赋值运算符重载函数返回值可以返回对象类型，也可以返回对象引用类型，都能工作。代码验证

#include <iostream>

using namespace std;

class coordinate
{
public:
    int x, y;

    void print(void);
    //coordinate& operator=(const coordinate& other);
    coordinate operator=(const coordinate& other);
    coordinate();
    coordinate(int x0, int y0);
    coordinate(const coordinate& rhs);    
};

void coordinate::print(void)
{
    cout << "a=(" << this->x << "," << this->y << ")" << endl;
}

#if 0
coordinate& coordinate::operator=(const coordinate& other)
{
    this->x = other.x;
    this->y = other.y;

    return *this;
}
#else
coordinate coordinate::operator=(const coordinate& other)
{
    this->x = other.x;
    this->y = other.y;

    return *this;
}

#endif

coordinate::coordinate()//默认构造函数
{
    this->x = 0;
    this->y = 0;
}

coordinate::coordinate(int x0, int y0)//自定义构造函数
{
    cout << "------constructor-------" << endl;

    this->x = x0;
    this->y = y0;
}

coordinate::coordinate(const coordinate& rhs)//拷贝构造函数
{
    cout << "------copy_constructor-------" << endl;

    this->x = rhs.x;
    this->y = rhs.y;
}

int main(int argc, char *argv[])
{
    coordinate a(1,5);
    coordinate b(4,5);
    coordinate c;

    cout << "----------c = a---------" <<endl;
    c = a;
    cout << "----------c = a---------" <<endl;

    a.print();
    b.print();
    c.print();

    return 0;
}

  图中上边的部分是返回引用的打印信息，下边的是返回对象的打印信息，返回对象时调用了拷贝构造函数。

(2)区别在于：返回引用可以避免一次返回值值传递的对象复制，这需要消耗资源的。

(3)总结：虽然C++语法并未强制要求，但是好的写法是应该返回引用

2、返回引用好处2：允许连续赋值式

(1)返回对象而不是引用时，在连续赋值（c = a = b;）时会编译可以，运行也可以，但是效率低同1中所讲。

(2)原因是先执行a=b操作，返回值再作为第2次赋值运算的右值（也就是函数参数），对象和引用是类型兼容的

(3)总结：连等在返回对象和引用时都可以，但是在返回void时就不可以了

3、思考：传参为什么要传引用

(1)如果传对象，则调用时是值传递，调用时需要复制一次，增加额外开销

(2)如果传指针，则重载后，使用时为了符合函数参数格式必须写成 a = &b;这种，不符合C语言写法习惯，也有歧义

(3)实际测试发现真的传指针时，写 c=a; c=&a;都能编译通过，且运行正确。但是确实很别扭。

(4)总结：有资料表明，其实C++早期发明引用概念时，就是为了解决此处运算符重载传参的尴尬。

二、String类的赋值运算符重载

1、标准库中String类的运算符重载

(1)https://zh.cppreference.com/w/%E9%A6%96%E9%A1%B5

(2)String类提供了 = 和 + 等多个运算符重载函数的成员

(3)标准库只给了API，没给实现，咱们可以自己实现个=运算符重载函数

2、String的=运算符重载演练

(1)自己编写一个MyString类，成员变量char *buf指向实际存储字符串的buf，new动态内存来使用。
(2)实践：先完成构造函数，成员函数print，len等基础设计，写代码测试ok
(3)编写=运算符重载函数，引出浅拷贝深拷贝问题

#include <iostream>

using namespace std;

class Mystring
{
private:
    char *buf; //指针指向实际存储字符串内容的buffer空间，采用动态分配

public:
    int len;   //字符中存储的有效字符个数

    Mystring();                //构造函数
    Mystring(const char *pSrc);      //拷贝构造函数
    ~Mystring();               //析构函数
    void print(void);          //普通成员函数
    Mystring& operator=(const Mystring& other);//运算符重载函数
};

Mystring::Mystring()
{
    //不写，空着等需要时再写，因为提供了自定义的构造函数，
    //所以必须要由默认的构造函数
    this->len = 32;
    this->buf = new char[32];
}

Mystring::Mystring(const char *pSrc)
{
    //计算有效字符的个数
    const char *p = pSrc;
 
    this->len = 0;
    while(*p++ != '\0')
    {
        this->len++;
    }
    cout << "cnt of pSrc is " << this->len << endl;

    //先给buf分配动态内存空间
    this->buf = new char[this->len+1];

    //将pSrc指向的源字符串内容，复制给当前Mystring对象来存储
    p = pSrc;
    char *tmp = this->buf;
    while(*p != '\0')
    {
        *tmp++ = *p++;            
    }
    *tmp = '\0';
}

Mystring::~Mystring()
{
    delete[] this->buf;
}

void Mystring::print(void)
{
    cout << "length of string = " << this->len << endl;
    
    char *p = this->buf;

    cout << "this string is : ";
    while(*p != '\0')
    {
        cout << *p++;
    }
    cout << endl;
}

Mystring& Mystring::operator=(const Mystring& other)
{
    delete[] this->buf;//释放掉原来的内存，重新申请内存
    this->buf = new char[other.len+1];//避免字符串内存越界
    this->len = other.len;

    char *p1 = this->buf;
    char *p2 = other.buf;

    while(*p2 != '\0')
    {
        *p1++ = *p2++;
    }

    //return *this;
}

int main(int argc, char *argv[])
{
    Mystring s1("123456");
    Mystring s2("absjhlllbsb");

    s1.print();
    s2.print();

    cout << "-----------------------" << endl; 
    s1 = s2;

    s1.print();
    s2.print();

    return 0;
}

3、总结

(1)运算符重载技术本身很简单，就是个语法糖，前面讲的完全够了

(2)运算符重载会牵出其他技术点（譬如浅拷贝深拷贝）共同完成某个工作，这就有难点，讲究功底了

(3)C++编程中涉及到动态内存的地方一定要慎重，三思五思再慎重都不为过,运算符重载函数返回值类型不是引用而是对象可能会引发段错误，我上面提供的程序就会，调试了半小时才发现（我太菜了）。

三、++和–运算符的前置后置如何实现

1、可前置可后置的运算符

(1)int a = 5; a++; ++a;结果不同

(2)重载++和–有无意义
  有意义，因为我们有时习惯了C语言的++和–的便利性。

2、如何重载++和–

C++编译器认为：

a++; 对应Type& operator++(int x); //int x用来做区分，此外没有任何其他作用。

++a对应Type& operator++(void);

示例代码：https://www.runoob.com/cplusplus/increment-decrement-operators-overloading.html

3、总结

(1)即使你觉得没必要，但是也得会，因为总有人会这样写

(2)掌握最本质的规律的人最强大，遇到越困难的问题越需要这种能力来解决

四、两种运算符重载方法

1、并非所有运算符都支持重载

(1)下面是不可重载的运算符列表

.			成员访问运算符
.*, ->*		成员指针访问运算符
::			域运算符
sizeof		长度运算符
? :			条件运算符 
#           预处理符号

2、并非只有一种方式实现重载

(1)有两种方法可以使运算符重载
  第一种：使重载运算符成为该类的成员函数。这允许运算符函数访问类的私有成员。它也允许函数使用隐式的this指针形参来访问调用对象。

  第二种：使重载的成员函数成为独立分开的函数。当以这种方式重载时，运算符函数必须声明为类的友元才能访问类的私有成员。

3、如何选择两种运算符重载

(1)大多数运算符（如+ =等）既可以作为成员函数也可以作为独立函数重载。

(2)更好的做法是将二元运算符重载为釆用相同类型形参的独立函数。这是因为，与独立运算符的重载不同，成员函数的重载通过使左侧形参变成隐式的，造成了两个形参之间的人为区别，这将允许转换构造函数应用右侧形参，但不应用左侧形参，从而产生了更改形参顺序的情况，导致正确的程序如果换个方式却出现了编译器错误。

示例如下：
Length a(4, 2), c(0);
c = a + 2; //编译，当于 c = a.operator+(2)
c = 2 + a; //不能编译：相当于 c = 2.operator+(a);

参考学习：https://blog.csdn.net/jacket_/article/details/89714947

注：本文章参考了《朱老师物联网大讲堂》课程笔记，并结合了自己的实际开发经历以及网上他人的技术文章，综合整理得到。如有侵权，联系删除！水平有限，欢迎各位在评论区交流。