C++ ─── 操作符重载和赋值重载

class Date
{ 
public :
//构造函数
 Date(int year = 1900, int month = 1, int day = 1)
   {
        _year = year;
        _month = month;
        _day = day;
   }
 //拷贝构造函数
 Date (const Date& d)
   {
        _year = d._year;
        _month = d._month;
        _day = d._day;
   }
 //赋值重载函数
 Date& operator=(const Date& d)//引用
     {
         if(this != &d)//取地址判断是否是自己给自己赋值
       {
            _year = d._year;
            _month = d._month;
            _day = d._day;
       }
        
        return *this;
     }
 
private:
     int _year ;
     int _month ;
     int _day ;
};

        2. 赋值运算符只能重载成类的成员函数不能重载成全局函数

class Date
{
public:
     Date(int year = 1900, int month = 1, int day = 1)
     {
         _year = year;
         _month = month;
         _day = day;
     }
     int _year;
     int _month;
     int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
     if (&left != &right)
     {
         left._year = right._year;
         left._month = right._month;
         left._day = right._day;
     }
     return left;
}
// 编译失败：
// error C2801: “operator =”必须是非静态成员

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

        注意：内置类型成员变量（int ,char）是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符 重载完成赋值。

class Time
{
public:
     Time()
     {
         _hour = 1;
         _minute = 1;
         _second = 1;
     }
 Time& operator=(const Time& t)
     {
         if (this != &t)
         {
             _hour = t._hour;
             _minute = t._minute;
             _second = t._second;
         }
         return *this;
     }
private:
     int _hour;
     int _minute;
     int _second;
};
 
class Date
{
private:
     // 基本类型(内置类型)
     int _year = 1970;
     int _month = 1;
     int _day = 1;
     // 自定义类型
     Time _t;
};
 
int main()
{
     Date d1;
     Date d2;
     d1 = d2;
     return 0;
}

        既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了 ，还需要自己实

现吗？当然像日期类这样的类是没必要的。

        注意： 如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必

须要实现。

前置++和后置++重载

class Date
{
public:
     Date(int year = 1900, int month = 1, int day = 1)
     {
         _year = year;
         _month = month;
         _day = day;
     }
 // 前置++：返回+1之后的结果
 // 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
     Date& operator++()
     {
         _day += 1;
         return *this;
     }
 
 // 后置++：
 // 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
 // C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
 // 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1
 //而temp是临时对象，因此只能以值的方式返回，不能返回引用
 
     Date operator++(int)
     {
         Date temp(*this);
         _day += 1;
         return temp;
     }
private:
     int _year;
     int _month;
     int _day;
};
 
int main()
{
     Date d;
     Date d1(2022, 1, 13);
     d = d1++;    // d: 2022,1,13   d1:2022,1,14
     d = ++d1;    // d: 2022,1,15   d1:2022,1,15
     return 0;
}

这个博客如果对你有帮助，给博主一个免费的点赞就是最大的帮助❤

欢迎各位点赞，收藏和关注哦❤

如果有疑问或有不同见解，欢迎在评论区留言哦❤

后续我会一直分享双一流211西北大学软件（C，数据结构，C++，Linux，MySQL）的学习干货以及重要代码的分享