C++运算符重载（四）之赋值运算符重载

赋值运算符重载

c++编译器至少给一个类添加4个函数

1. 默认构造函数(无参，函数体为空)

2. 默认析构函数(无参，函数体为空)

3. 默认拷贝构造函数，对属性进行值拷贝

4. 赋值运算符 operator=, 对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

示例：

class Person
{
public:
​
    Person(int age)
    {
        //将年龄数据开辟到堆区
        m_Age = new int(age);
    }
​
    //重载赋值运算符 
    Person& operator=(Person &p)//注意是引用
    {
        if (m_Age != NULL)
        {
            delete m_Age;
            m_Age = NULL;
        }
        //编译器提供的代码是浅拷贝，赋值时只会将指针所指向的的地址进行赋值，释放堆区的数据时会造成浅拷贝问题。
        //m_Age = p.m_Age;
​
        //提供深拷贝 解决浅拷贝的问题
        m_Age = new int(*p.m_Age);//重新开辟一块堆区，各自释放各自的堆区。
​
        //返回自身
        return *this;//是为了实现连续赋值操作
    }
​
​
    ~Person()
    {
        if (m_Age != NULL)
        {
            delete m_Age;
            m_Age = NULL;//如果指针不为空就释放指针指向的堆区内存，并且让指针的指向改为NULL，防止之后误操作。
        }
    }
​
    //年龄的指针
    int *m_Age;
​
};
​
​
void test01()
{
    Person p1(18);
​
    Person p2(20);
​
    Person p3(30);
​
    p3 = p2 = p1; //连续赋值操作
​
    cout << "p1的年龄为：" << *p1.m_Age << endl;
​
    cout << "p2的年龄为：" << *p2.m_Age << endl;
​
    cout << "p3的年龄为：" << *p3.m_Age << endl;
}
​
int main() {
​
    test01();
​
    //int a = 10;
    //int b = 20;
    //int c = 30;
​
    //c = b = a;//连续赋值操作，前提是a,b,c 的数据类型是相同的。
    //cout << "a = " << a << endl;
    //cout << "b = " << b << endl;
    //cout << "c = " << c << endl;
​
    system("pause");
​
    return 0;
}

如果指针不为空就释放指针指向的堆区内存，并且让指针的指向改为NULL，防止之后误操作。

实例：日期的比较与拷贝

一、定义一个日期类用于测试

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1):_year(year),_month(month),_day(day)
    {}
​
    void print()//输出日期
    {
        cout << _year << "/" << _month << "/" << _day << endl;
    }
​
private:
    int _year;
    int _month;
    int _day;
};
​

​
​

正常情况下运算符默认都是给内置类型用的，所以如果想比较两个日期大小是无法实现的。

int main()
{
    Date d1(2022, 2, 21);
    Date d2(2022, 2, 23);
    Date d3(2022, 2, 24);
    //d1 == d2;直接比较会导致无法编译
    return 0;
}

二、重载运算符== 函数名：operator加上运算符 参数：有几个操作数就有几个参数，参数类型就是要操作对象的类型 返回值：看运算符运算后的返回值是什么

//存在this指针，要少传一个参数
    bool operator==(const Date& x)//引用节省空间，const保护实参
    {
        return _year == x._year && _month == x._month && _day == x._day;
    }
​

公有函数无法访问私有变量，所以运算符重载要写在类内当作成员函数c

三、日期赋值= 参数类型 返回值 检测是否自己给自己赋值 返回 * this 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。 如果不写，会默认生成赋值重载，和拷贝构造行为类似，内置类型会完成值拷贝，自定义类型成员会调用他的赋值重载

//赋值重载
    Date operator=(const Date& d)//返回值类型是Date
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
        return *this;//支持连续赋值,this是当前对象的别名，拷贝构造。
    }
​
​
​

测试结果

int main()
{
    Date d1(2022, 2, 21);
    Date d2(2022, 2, 23);
    Date d3(2022, 2, 24);
    d1 == d2;
    //d1.operator== (d2);//可以调用但可读性差
    //d1 == d2;//编译器自动转换为 d1.operator== (d2);   
​
  
    d1 = d3;
    d1.print();
    //赋值运算符重载：用于两个已经定义出的对象间的拷贝赋值
    
    //拷贝构造：一个对象准备定义时，用另一个对象来初始化他
    Date d4(d3);
    d4.print();
    Date d5 = d3;//这里是拷贝构造，只要是创建时定义就是拷贝构造，注意区分赋值重载。
    d1 = d3 = d2;//连续赋值,链式编程思想
    d1.print();
    return 0;
}

注意

不能通过连接其他符号来创建新的操作符：比如operator@ 重载操作符必须有一个类类型或者枚举类型的操作数 用于内置类型的操作符，其含义不能改变，例如：内置的整型 + ，不 能改变其含义 作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参 .*、::、sizeof 、 ? : 、.注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

总结

栈：构造，析构，拷贝构造，赋值重载都需要自己写 日期类除构造函数外都可以使用编译器默认