2、赋值运算符重载

赋值运算符重载是对于两个已经存在对象之间的赋值拷贝。

简单写一下：

// d1 = d3
void operator=(const Date& d)
{
    _year = d._year;
    _month = d._month;
    _day = d._day;
}

这里可以完成功能，但是不符合连续赋值的含义 ，例如 i = j = k = 10 ，是将 10 赋给 k ，k 赋给 j ，j 赋给 i ，最后赋值后的返回值没有变量接收了，所以就把值丢弃，通过这种方式 完成连续赋值 。

但是此刻呢？

由于 operator= 没有返回值，这样就不可行了，所以需要修改 ：

// d1 = d3
Date operator=(const Date& d)
{
    _year = d._year;
    _month = d._month;
    _day = d._day;
    return *this;
}

根据上方的连续赋值规则，返回的应该是 左操作数 ，即 d1 ，也就是 this 指针指向的对象，即 *this ；但是对于 *this 的返回这里由于是传值返回，而 *this 指向的是一个对象，所以会调用拷贝构造函数：

class Date
{
public:
  Date(int year = 0, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  Date(const Date& d)
  {
    cout << "进行拷贝构造" << endl;
  }
  // d1 = d3
  Date operator=(const Date& d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
    return *this; // 调用拷贝构造
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1(2023, 2, 3);
  Date d2(2023, 3, 4);
  Date d3(2022, 2, 3);
  d3 = d2 = d1; // 两次赋值，共计两次拷贝构造
  return 0;
}

所以返回时，最好使用 引用返回 来提高返回效率，因为出作用域 *this 仍然存在，所以引用返回完全没问题。

// d1 = d3
Date& operator=(const Date& d)
{
    _year = d._year;
    _month = d._month;
    _day = d._day;
    return *this;
}

此刻不进行拷贝构造：

但是此刻不是最终版本，因为可能会写错为 d1 = d1 ，自己给自己赋值 ，虽然代码并没有问题，但是浪费了赋值的过程，所以可以再加一个检查，形成最终版本 :

Date& operator=(const Date& d)
{
    if (this != &d) // this 和 d 的地址相等 
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    return *this;
}

总结一下赋值运算符重载格式 ：

       参数类型：const T&，传递引用可以提高传参效率

       返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

       检测是否自己给自己赋值

       返回*this ：要符合连续赋值的含义

       用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝

编译器默认生成的赋值重载，跟拷贝构造做的事情完全类似 ：

• 内置类型成员，会完成字节序1值拷贝（浅拷贝）
• 自动类型成员，会调用它的 operator=

补充：

Date d2 = d1; // 拷贝构造 or 赋值重载？

两个已经存在的对象才是赋值重载，d5 并不存在，所以是拷贝构造：

学到这里，稍微总结一下 ：

以上默认生成的四个默认成员函数，析构和构造处理机制基本类似；拷贝构造和复制重载处理机制基本类似。

七、const 成员

若定义了一个 const 的对象，然后访问其成员函数，会发生什么情况？

报错了，这是为什么？

因为在传参时，d2 的地址 &d2 会被传递给 Print() ，作为隐藏的参数 this 指针：

void Print(Date* const this) // this 指针隐藏
{
    cout << _year << '-' << _month << '-' << _day << endl;
}

对于 Date d ，传递过去的 &d 是 Date* ；而 const Date d2 ，传递过去的 &d2 是 const Date* .

而对于 this 指针本身是 Date* const this ，此刻 const 修饰的是 this ，this 不可改，但是 *this 是可改的 ，而传参时传过来的 &d2 为 const Date* ，这时 const 修饰指针指向的内容，即对象本身不可改了。但是对于 this 来说，*this，也就是指向的内容，即对象本身是可改的，但是现在由于 const 使得指向内容不可改，权限被放大了。对于权限来说，只能对等和缩小，但是这里放大了，所以报错 。

为了解决这一问题，C++ 引入了 const 成员 ，在该成员后加上 const ：

   将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

void Print() const
{
    cout << _year << '-' << _month << '-' << _day << endl;
}

这时 this 指针的类型变为 const Date* const this ，权限对等了，这时 this 指针不能改，且 *this ，即 this 指向的对象也不能改，和 const Date d2 的目的相同：不可改 d2 . 这时，就没有问题了：

而对于 d 对象，它虽然没有 const ，但是也只是 权限缩小，使得 d 在 Print() 成员函数中不可修改而已，也是没问题的。

   总结：成员函数加上 const 是好的，建议能加上 const 都加上。这样普通对象和 const 对象，都可以调用。但是如果对于要对 对象 进行修改的成员函数不要加上，这样就完成不了目的了。

注：对于构造和析构不能加上const修饰。

八、取地址与const取地址操作符重载

我们知道，对于自定义类型成员来说，平常的操作符需要重载后才能对对象进行操作。但是对于自定义类型的对象来说，如果不写这两个成员函数，使用默认的成员函数照样也可以完成目的：

所以我们一般不写，但是写的话也可以：

class A
{
public:
  A* operator&()
  {
    return this;
  }
  const A* operator&() const
  {
    return this;
  }
};

就只要返回 this 就可以；对于 const 取地址操作符，则要加上 const 成员，并且返回的指针也要加上 const 修饰。

九、结语

那么本篇文章就到此结束了。

对于六个默认成员函数，前四个最重要：构造、析构、拷贝构造、运算符重载。后两个有一定作用，但是作用不大。

由此，我们做一下编译器默认生成的成员函数的总结：

构造和析构：

       内置类型不做处理

       自定义类型会调用对应的构造/析构

拷贝构造和复制重载：

       内置类型完成浅拷贝，按字节序拷贝

       自定义类型去调用它的拷贝构造和赋值重载

取地址与const取地址操作符重载：

       可以直接取出成员的地址，一般不自己写

今天的内容还是有一定难度的，建议大家下去多多理解和练习哦！

如果觉得 a n d u i n anduin anduin 写的不错的话，可以点赞 + 收藏 + 评论支持一下哦！

那么我们下期见！