目录

 运算符重载

赋值运算符重载

前置++和后置++重载 

this指针

 运算符重载

C++为了增强代码的可读性引入了运算符重载，在默认情况下，C++是不支持自定义类型对象使用运算符，为了能让自定义类型能够像内置类型一样去使用运算符，就引入了运算符重载。运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

注意：

1. 不能通过连接其他符号来创建新的操作符：比如operator@
2. 重载操作符必须有一个类类型参数
3. 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
4. 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this 
5. 以下运算符不能重载：

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

重载 > 运算符，用于把两个 Date 对象比较大小
bool Date::operator>(const Date& d)

 也可以写成  bool operator>(Date* const this,Date& d)，一般运算符重载有两个参数，但是一般会把this指针省略。

Date是一个日期类，属于自定义类型，不能直接加减或者相比较，需要把运算符重载。

    // 重载 > 运算符，用于把两个 Date 对象比较大小bool Date::operator>(const Date& d)//	bool operator>(Date* const this,Date& d){if (_year > d._year){return true;}else if (_year == d._year && _month > d._month){return true;}else if (_year == d._year && _month == d._month && _day > d._day){return true;}else{return false;}}

赋值运算符重载

赋值运算符重载格式：

参数类型：const T&，传递引用可以提高传参效率，传值需要拷贝参数，对于自定义类型来说如果字节过大，效率可能会很低。

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

检测是否自己给自己赋值

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

 Date类赋值运算符的重载（=）

//赋值运算符重载Date& Date:: operator=(const Date& d){_year = d._year;_month = d._month;_day = d._day;return *this;}

注意区分赋值运算符重载和拷贝构造函数

拷贝构造是一个已经存在的对象拷贝初始化一个马上创建实例化的对象。

        Date d1(2022, 11, 22);

        Date d2(d1);  // 拷贝构造 ，将d1拷贝给d2
        Date d3 = d1; // 拷贝构造

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

        Date d1(2022, 11, 22);
        Date d2(2022, 11, 23);

        //赋值运算符重载
        d1 = d2;        //d1.operator>(d2);

赋值运算符调用可以直接使用运算符，也可以调用函数。d1 = d2/d1.operator>(d2）。 

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)
    {

        //自己给自己赋值直接返回*this
        if (this != &d)
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }

        return *this;
    }
private:
    int _year;
    int _month;
    int _day;
};

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

赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现 一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

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

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

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;
}

编译器生成的默认赋值运算符重载函数可以完成字节序的值拷贝,但只是浅拷贝，对于像栈需要动态申请空间的使用默认的赋值运算符重载是不行的，栈的赋值是一个深拷贝，赋值运算符重载函数必须自己实现。

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

前置++和后置++重载 

前置++返回++之后的值，后置++返回++之前的值。

前置++

// 前置++返回+1之后的值
    Date& Date::operator++()
    {
        *this += 1;
        return *this;
    }

前置++this指向的对象函数结束后不会销毁，故以引用方式返回提高效率 。

后置++

后置++为了跟前置++，进行区分，增加了参数占位，跟前置++构成函数重载。

后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递。

// 后置++
    Date Date::operator++(int)
    {
        Date ret(*this);
        *this += 1;
        return ret;
    }

后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存 一份，然后this+1，而temp是临时对象，因此只能以值的方式返回，不能返回引用。

this指针

C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量” 的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。

this指针的特性

1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。

2. 只能在“成员函数”的内部使用。

3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给 this形参。所以对象中不存储this指针。

4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传 递，不需要用户传递。

void Print() {

cout <<_year<< "-" <<_month << "-"<< _day <

}

//this指针

void Print(Date* this) {

cout <

}

我们自己在写代码一般是省略this的。 

this指针一般存储在栈（形参）， 有些编译器会放到寄存器中。

代码一：

class A
{
public:
    void Print()  //A* const this
    {
        cout << "Print()" << endl;
    }
private:
    int _a;
};
int main()
{
    A* p = nullptr;
    p->Print();
    return 0;
}

代码二：

class A
{
public:
    void PrintA()  //A* const this
    {
        cout << _a << endl;
    }
private:
    int _a;
};
int main()
{
    A* p = nullptr;
    p->PrintA();
    return 0;
} 

 两段代码都给this指针传的是空指针，但是程序一不会报错，p虽然是空指针，但是p调用成员函数不会编译报错，空指针不是语法错误，编译器检查不出来。p作为实参传递给隐藏的this指针，代码一并没有对p解引用，所以不会出现空指针访问。

代码二对p解引用，出现了空指针访问。