【C++】类和对象（中）

---

---

 前言

        本文主要讲述了类和对象的六个默认成员函数，这是c++类和对象中最重要的一节，干货多多，并且最终会实现完整的日期类代码。

---

一、类的默认成员函数

• 默认成员函数就是用户没有显式实现，编译器会自动生成的成员函数称为默认成员函数。⼀个类，我们不写的情况下编译器会默认生成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最后两个取地址重载不重要，我们稍微了解⼀下即可。其次就是C++11以后还会增加两个默认成员函数， 移动构造和移动赋值，这个我们后面再讲解。

默认成员函数很重要，也比较复杂，我们要从两个方面去学习：

1. 我们不写时，编译器默认生成的函数行为是什么，是否满足我们的需求。
2. 第二：编译器默认生成的函数不满足我们的需求，我们需要自己实现，那么如何自己实现？

---

二、构造函数

• 构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象（我们常使用的局部对象是栈帧创建时，空间就开好了），而是对象实例化时初始化对象。构造函数的本质是要替代我们以前 Stack 和 Date类中写的 Init 函数的功能，构造函数自动调用的特点就完美的替代的了 Init。

构造函数的特点：

1. 函数名与类名相同。
2. 无返回值。(返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)
3. 对象实例化时系统会自动调用对应的构造函数。
4. 构造函数可以重载。
5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义，编译器将不再生成。
6. 无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。但是这三个函数有且只有⼀个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。要注意很多人会认为默认构造函数是编译器默认生成那个叫默认构造，实际上无参构造函数、全缺省构造函数也是默认构造，总结一下就是不传实参就可以调用的构造就叫默认构造。

#include <iostream>
using namespace std;

class Date
{
public:
//构造函数
//1.无参构造函数
Date()
{
_year = 1;
_month = 1;
_day = 1;
}

//2.带参构造函数，与无参构造函数形成重载函数，因此这两种构造可以并存
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}

//3.全缺省构造函数，与无参构造函数产生歧义，因此不能与无参构造函数并存
/*Date(int year = 1970, 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;
};

（因为以上显式定义了构造函数，因此编译器不会自动生成构造函数）

正常使用构造函数：上面代码中，只写一个全缺省构造函数是最方便的。当然你也可以写前面无参与带参两种构造函数。

#include <iostream>
using namespace std;

class Date
{
public:
//构造函数
//3.全缺省构造函数，与无参构造函数产生歧义，因此不能与无参构造函数并存
Date(int year = 1970, 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 a;
Date b(2024, 8, 20);

a.Print();
b.Print();

return 0;
}

运行结果：

---

报错情况分析： 

如果只写了无参构造函数，创建对象时进行了传参，就会报错：

如果没有无参或者全缺省构造函数，创建对象时没有进行传参，就会报错：

注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则编译器无法编译：

---

• 我们不写，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是否初始化是不确定的，看编译器。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决，初始化列表，我们下篇文章再细细讲解。

说明：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型， 如：int/char/double/指针等，自定义类型就是我们使用 class/struct 等关键字自己定义的类型。

内置类型：

#include <iostream>
using namespace std;

class Date
{
public:
//不写构造函数，编译器会自动生成一个无参的默认构造函数。

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

private:
int _year;
int _month;
int _day;
};


int main()
{
    //使用编译器生成的默认构造函数
Date a;
a.Print();

return 0;
}

运行结果

VS下初始化为随机值。

---

自定义类型：例如两个栈实现一个队列

#include <iostream>
using namespace std;

typedef int STDataType;
class Stack
{
public:
Stack(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a)
{
perror("malloc申请空间失败");
return;
}
_capacity = n;
_top = 0;
}

    //...省略

private:
STDataType* _a;
size_t _capacity;
size_t _top;
};

// 两个Stack实现队列
class MyQueue
{
public:
//编译器默认⽣成 MyQueue 的构造函数调用了Stack的构造，完成了两个成员的初始化

private:
Stack pushst;
Stack popst;
};

int main()
{
MyQueue q;

return 0;
}

对于 MyQueue ，编译器默认生成的构造函数会调用 Stack 类的构造函数。

如果此时 Stack 类也没有写构造函数，那么就会报错或警告：

---

三、析构函数

• 析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，比如局部对象是存在栈帧的， 函数结束栈帧销毁，他就释放了，不需要我们管，C++ 规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放⼯作。析构函数的功能类比我们之前 Stack 实现的Destroy功能，而像 Date类 没有 Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。

析构函数的特点：

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值。(这里跟构造类似，也不需要加void。注意析构无参，因此不能重载)
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时，系统会自动调用析构函数。
5. 跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定类型成员会调用他的析构函数。
6. 还需要注意的是我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。
7. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，如Date；如果默认生成的析构就可以用，也就不需要显示写析构，如MyQueue；但是有资源申请时，一定要自己写析构，否则会造成资源泄漏，如Stack。
8. 一个局部域的多个对象，C++规定后定义的先析构。

#include <iostream>
using namespace std;

typedef int STDataType;
class Stack
{
public:
Stack(int n = 4)
{
cout << "Stack()" << endl;
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a)
{
perror("malloc fail!");
exit(1);
}
_capacity = n;
_top = 0;
}

~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}

private:
STDataType* _a;
size_t _capacity;
size_t _top;
};

class MyQueue
{
public:
//因为成员变量为自定义 Stack 类型，
//编译器默认生成的构造和析构函数就会自动调用 Stack 类的构造和析构函数
//因此我们不必显示的去写

private:
Stack pushst;
Stack popst;
};

int main()
{
//Stack 类的构造和析构函数都写了打印函数，观察打印情况
Stack a;

cout << endl;

MyQueue b;

return 0;
}

运行结果：

解释：

• 前三个构造函数分别是 a , pushst, popst。而析构函数是后定义的先析构，因此三个析构函数分别是 popst, pushst, a 。

---

关于析构怎样才需要自己显示的去写的问题：

1. 如果成员函数都是内置类型，就是只在栈上开辟空间，栈上开辟的空间在程序结束后会自动销毁，因此不需要我们显示的去写析构函数。
2. 前面我们看到在堆上面申请空间是一定要显示的去写析构的，当日不是只有堆上开辟空间才需要写析构。在一些特殊需求的场景，比如打开并写入文件，那么我们析构函数中就可以加上关闭文件等操作。
3. 所以，我们要灵活运用析构，析构的特性是在类销毁时会自动调用。我们根据不同情况灵活利用这一特性，在很多时候会很方便。

---

• 对比一下用C++和C实现的Stack解决之前括号匹配问题 isValid，我们发现有了构造函数和析构函数确实方便了很多，不会再忘记调用 Init 和 Destory 函数了，也方便了不少。

连接：. - 力扣（LeetCode）

C语言：

typedef char STDataType;
//定义栈结构
typedef struct Stack
{
STDataType* arr;
int capacity;//栈的空间大小
int top;//栈顶
}ST;

//初始化
void STInit(ST* ps)
{
assert(ps);

//全初始化为空
ps->arr = NULL;
ps->capacity = ps->top = 0;
}

//销毁
void STDesTroy(ST* ps)
{
assert(ps);

//判断arr
if (ps->arr)
{
free(ps->arr);
}

//销毁后置空
ps->arr = NULL;
ps->capacity = ps->top = 0;
}

//入栈
void StackPush(ST* ps, STDataType x)
{
assert(ps);

//判断空间是否充足
if (ps->top == ps->capacity)
{
//使用三目操作符根据容量是否为0来选择如何给定新容量大小
int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
//1.如果容量为0，赋值4  2.如果容量不为零，进行二倍扩容

//申请新空间
STDataType* tmp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail!");
exit(1);
}

//修改参数
ps->arr = tmp;
ps->capacity = newCapacity;
}

//空间充足
ps->arr[ps->top++] = x;
}

//判空
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}

//出栈
void StackPop(ST* ps)
{
assert(ps);
//判断栈容量是否为空

assert(!StackEmpty(ps));
//直接让栈顶下移一位即可
--ps->top;
}

//取栈顶元素
STDataType StackTop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));//判空

//直接返回栈顶元素
return ps->arr[ps->top - 1];
}

//获取栈中有效元素个数
int STSize(ST* ps)
{
assert(ps);
return ps->top;
}

bool isValid(char* s)
{
//创建一个栈
ST st;
STInit(&st);

//新建一个指针
char* ps = s;

//循环遍历
while (*ps != '\0')
{
if (*ps == '(' || *ps == '[' || *ps == '{')
{
//入栈
StackPush(&st, *ps);
}
else
{
//假如栈中无数据，一开始就是右括号
if (StackEmpty(&st))
{
//直接销毁栈，并返回否
STDesTroy(&st);
return false;
}

//如果栈中有数据,先取栈顶元素
char ch = StackTop(&st);
if (*ps == ')' && ch == '('
|| *ps == ']' && ch == '['
|| *ps == '}' && ch == '{')
{
//匹配正确,出栈
StackPop(&st);
}
else
{
//匹配失败
STDesTroy(&st);
return false;
}
}
++ps;
}

//如果栈中还有数据，证明左括号多了
if (!StackEmpty(&st))
{
STDesTroy(&st);
return false;
}

//一切正常
STDesTroy(&st);
return true;
}

---

C++：

class Solution {
public:
    // ⽤最新加了构造和析构的C++版本Stack实现
    bool isValid(string s) {
        stack<char> st;
        auto it = s.begin();

        while (it != s.end())
        {
            if (*it == '[' || *it == '(' || *it == '{')
            {
                st.push(*it);
            }
            else
            {
                // 右括号⽐左括号多，数量匹配问题
                if (st.empty())
                {
                    return false;
                }
                // 栈⾥⾯取左括号
                char top = st.top();
                st.pop();

                //顺序不匹配
                if ((*it == ']' && top != '[')
                    || (*it == '}' && top != '{')
                    || (*it == ')' && top != '('))
                {
                    return false;
                }
            }
            ++it;
        }

        //栈为空，返回真，说明数量都匹配,左括号多，右括号少匹配问题
        return st.empty();
    }
};

当然，这里面C++还包含了模版和STL的一些知识。不过看不懂没关系，还有一个版本体现出C++的构造和析构的作用：

C++第二版：

#include<iostream>
using namespace std;

//⽤最新加了构造和析构的C++版本Stack实现
//Stack的C++版在上一篇文章末尾

bool isValid(const char* s) 
{
    Stack st;
    while (*s)
    {
        if (*s == '[' || *s == '(' || *s == '{')
        {
            st.Push(*s);
        }
        else
        {
            //右括号⽐左括号多，数量匹配问题
 
            if (st.Empty())
            {
                return false;
            }
            //栈⾥⾯取左括号
 
            char top = st.Top();
            st.Pop();
            //顺序不匹配
 
            if ((*s == ']' && top != '[')
                 || (*s == '}' && top != '{')
                 || (*s == ')' && top != '('))
            {
                return false;
            }
        }
        ++s;
    }

    //栈为空，返回真，说明数量都匹配左括号多，右括号少匹配问题
    return st.Empty();
}

---

四、拷贝构造函数

如果一个构造函数的第一个参数是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数 也叫做拷贝构造函数，也就是说拷贝构造是⼀个特殊的构造函数。

拷贝构造的特点：

1. 拷贝构造函数是构造函数的⼀个重载。
2. 拷贝构造函数的第一个参数必须是类类型对象的引用，使用传值方式编译器直接报错，因为语法逻辑上会引发无穷递归调用。拷贝构造函数也可以多个参数，但是第⼀个参数必须是类类型对象的引用，后面的参数必须有缺省值（不然会有歧义导致调用不到）。

拷贝构造： 

#include <iostream>
using namespace std;

class Date
{
public:
//构造函数
Date(int year =1, 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;
}

private:
int _year;
int _month;
int _day;
};

int main()
{
    //普通构造调用
Date d1(2024, 8, 20);

//拷贝构造调用
Date d2(d1);

return 0;
}

拷贝构造，参数不使用引用报错的原因：

重点：之所以使用引用，是因为引用跳过了拷贝构造这一步骤，就不会导致死递归

疑问：那么引用可以，指针行不行呢？

答案：指针传参也可以跳过拷贝构造，但是将构造函数的参数改为指针后，它就不再是一个拷贝构造了，只是一个普通的重载构造函数，而且调用方式也不一样。C++规定拷贝构造参数是引用，而不是指针。

指针构造演示：

#include <iostream>
using namespace std;

class Date
{
public:
//构造函数
Date(int year =1, 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(const Date* d)
{
_year = d->_year;
_month = d->_month;
_day = d->_day;
}

private:
int _year;
int _month;
int _day;
};


int main()
{
//普通构造调用
Date d1(2024, 8, 20);

//拷贝构造调用
Date d2(d1);

//普通（指针）构造调用
Date d3(&d1);

return 0;
}

拷贝构造另一种调用方式：使用 "=" 符号

---

拷贝构造参数前面加上 const 的原因：

我们先假设不加 const，有以下场景：

我们编译的时候就会报错。为什么呢？

答案：前面我们学过 const引用，我们知道权限可以缩小但不能放大。我们简单复习下 const引用，比如 ,这就是一个错误的写法，因为 b*2的结果会被存储在一个临时对象中，这个临时对象具有常性，因此我们引用时因该加上 const ，，同样上述函数返回了 Date 类型的 ret 对象，因为函数结束后函数栈帧会被销毁，但是函数返回值会作为一个临时对象暂存下来，这个临时对象也具有常性，因此我们使用 f()这个返回值去拷贝构造时，返回值是 const 修饰的，而拷贝构造参数没有 const 修饰，这里就涉及了权限的放大。所以为了避免类似情况，拷贝构造形参统一使用const修饰。

补充：临时对象是因为 const引用才能够延长生命周期，直到这个const引用生命周期结束。关于临时对象存储位置，一般是存储在栈上创建的。

---

拷贝构造的特点（继）：

• 3. C++ 规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。
• 4. 若未显式定义拷贝构造，编译器会生成自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝 / 浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。
• 5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的拷贝构造就可以完成需要的拷贝，所以不需要我们显示实现拷贝构造。像 Stack 这样的类，虽然也都是内置类型，但是 _a 指向了资源，编译器自动生成的拷贝构造完成的值拷贝 / 浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。像 MyQueue 这样的类型内部主要是自定义类型 Stack成员，编译器自动生成的拷贝构造会调用 Stack 的拷贝构造，也不需要我们显示实现 MyQueue 的拷贝构造。这里还有⼀个小技巧，如果一个类显示实现了析构并释放资源，那么他就需要显示写拷贝构造，否则就不需要。

首先，Date类不显示写拷贝构造：（浅拷贝）

Stack类也不写拷贝构造的话，就会出现问题：

#include <iostream>
using namespace std;

typedef int STDataType;
class Stack
{
public:
Stack(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (_a == nullptr)
{
perror("malloc fail!");
exit(1);
}

_capacity = n;
_top = 0;
}

~Stack()
{
free(_a);
_a = nullptr;
_capacity = _top = 0;
}

private:
STDataType* _a;
size_t _capacity;
size_t _top;
};

int main()
{
Stack st1;
Stack st2(st1);

return 0;
}

运行结果：

报错原因：

1. 原因就是编译器默认生成的拷贝构造是浅拷贝
2. 
3. 
4. 

改进后的 Stack 类：

#include <iostream>
using namespace std;

typedef int STDataType;
class Stack
{
public:
Stack(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (_a == nullptr)
{
perror("malloc fail!");
exit(1);
}

_capacity = n;
_top = 0;
}

//拷贝构造（深拷贝）
Stack(const Stack& st)
{
_a = (STDataType*)malloc(sizeof(STDataType) * (st._capacity));
if (_a == nullptr)
{
perror("malloc fail!");
exit(1);
}

memcpy(_a, st._a, sizeof(STDataType) * (st._top));
_capacity = st._capacity;
_top = st._top;
}

~Stack()
{
free(_a);
_a = nullptr;
_capacity = _top = 0;
}

private:
STDataType* _a;
size_t _capacity;
size_t _top;
};

int main()
{
Stack st1;
Stack st2(st1);

return 0;
}

---

• 6. 传值返回会产生一个临时对象调用拷贝构造，传引用返回，返回的是返回对象的别名(引用)，没有产生拷贝。但是如果返回对象是一个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回是有问题的，这时的引用相当于一个野引用，类似一个野指针一样。传引用返回可以减少拷贝，但是一定要确保返回对象，在当前函数结束后还在，才能用引用返回。

首先，传值返回：

Stack f()
{
Stack st;
st.Push(1);
st.Push(2);
st.Push(3);

//传值返回，先把st拷贝给了一个临时对象
return st;
}

int main()
{
//第二次拷贝，将返回的临时对象拷贝给ret
Stack ret = f();
cout << ret.Top() << endl;

return 0;
}

运行结果：（Stack完整代码见上篇文章）

传值返回理论上进行了两次拷贝构造，但是编译器是计算是进行了优化的，这个在后面细说。

---

易错点：传引用返回

//传引用返回
Stack& f()
{
Stack st;
st.Push(1);
st.Push(2);
st.Push(3);

return st;
}

int main()
{
Stack ret = f();
cout << ret.Top() << endl;

return 0;
}

注意：这里传引用返回就涉及了野引用，就和野指针一样，因为函数中创建的对象属于局部对象，出了函数它就销毁了。

传引用返回可以减少一次拷贝构造，对大型类来说可以提升不少效率，但是前提是这个类对象出来函数不会被销毁。如以下情况就可以进行传引用返回：

//传引用返回
Stack& f()
{
//static修饰
static Stack st;
st.Push(1);
st.Push(2);
st.Push(3);

return st;
}

int main()
{
Stack ret = f();
cout << ret.Top() << endl;

return 0;
}

运行结果：

使用 static 修饰后，st 的生命周期就和全局变量一样了，这时候出了函数也不会被销毁。

---

五、赋值运算符重载

在学习赋值运算符重载前，我们需要先了解学习运算符重载

1.运算符重载

• 1. 当运算符被用于类类型的对象时，C++语言允许我们通过运算符重载的形式指定新的含义。C++ 规定类类型对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。
• 2. 运算符重载是具有特殊名字的函数，他的名字是由 operator 和后面要定义的运算符共同构成。和其他函数一样，它也具有其返回类型和参数列表以及函数体。
• 3. 重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。一元运算符有一个参数，二元运算符有两个参数。二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。

例：重载 " < " 运算符（第一种方式）

#include <iostream>
using namespace std;

class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}

//private:
int _year;
int _month;
int _day;
};

//第一种重载方式，为了能访问到类成员函数，将private注释掉了
bool operator<(const Date x1, const Date x2)
{
if (x1._year < x2._year)
{
return true;
}
else if (x1._year == x2._year && x1._month < x2._month)
{
return true;
}
else if (x1._year == x2._year
 && x1._month == x2._month
 && x1._day < x2._day)
{
return true;
}

return false;
}

int main()
{
Date d1(2024, 8, 20);
Date d2(2024, 8, 30);

bool ret1 = d1 < d2;//第一种调用方式，方便并且可读性高，推荐
bool ret2 = operator<(d1, d2);//第二种调用方式，不直观

cout << ret1 << endl;
cout << ret2 << endl;

return 0;
}

运行结果：

---

上面第一种运算符重载的方法不太通用，因为我们大部分时候都会把成员变量设置为私有，那么有什么方法既能实现运算符重载又能避免改变类成员变量属性？

1. 定义 Get 成员函数去获取类成员变量，java 常用，c++ 用的少
2. 将重载运算符函数定义为类成员函数，常用方式

---

• 4. 如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐式的 this 指针，因此运算符重载作为成员函数时，参数比运算对象少一个。
• 5. 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持一致。

#include <iostream>
using namespace std;

class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}

//设置为成员函数，this 指针代替了第一个参数
bool operator<(const Date x)
{
if (_year < x._year)
{
return true;
}
else if (_year == x._year && _month < x._month)
{
return true;
}
else if (_year == x._year
&& _month == x._month
&& _day < x._day)
{
return true;
}

return false;
}

private:
int _year;
int _month;
int _day;
};

int main()
{
Date d1(2024, 8, 20);
Date d2(2024, 8, 30);

bool ret1 = d1 < d2;
bool ret2 = d1.operator<(d2);//第二种调用方式发生变化，不过也用的少

cout << ret1 << endl;
cout << ret2 << endl;

return 0;
}

运行结果： 

---

运算符重载（续）特点和注意事项：

• 6. 不能通过连接语法中没有的符号来创建新的操作符：比如operator@。
• 7. " .* "（用于调用成员函数指针）、" :: "（作用域解析运算符）、" sizeof "（计算大小的）、" ? : "（条件运算符）、 " . "（成员访问运算符）， 注意以上5个运算符不能重载。(选择题里面常考，大家要记一下）

.* 运算符简单介绍：用于调用成员函数指针

#include <iostream>
using namespace std;

class A
{
public:
void func()
{
cout << "A::func()" << endl;
}
};

//重命名函数指针,注意指定类域
typedef void(A::* PF)();

int main()
{
PF pf = &A::func;//定义函数指针 pf 赋值为A类的函数指针

A obj;//定义一个A类对象

(obj.*pf)();//类对象调用成员函数指针时使用 .* 运算符

return 0;
}

运行结果：

---

• 8. 重载操作符至少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义。如：int operator+(int x, int y)就是不合法的，必须至少有一个类类型参数。
• 9. 一个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如Date类重载operator-就有意义，但是重载operator*就没有意义。
• 10. 重载++ 运算符时，有前置++ 和后置++，运算符重载函数名都是operator++，无法很好的区分。 C++规定，后置++重载时，增加一个int形参，跟前置++构成函数重载，方便区分。前后置-- 同理。

例：实现重载运算符++

#include <iostream>
#include <assert.h>
using namespace std;

class Date
{
public:
Date(int year = 1970, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}

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

//获取某月天数
int GetMonthDay(int year, int month)
{
assert(month > 0 && month < 13);
static int MonthDayArray[13] = { -1,31,28,31,30,31,30,31,31,30,31,30,31 };
if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
{
return 29;
}

return MonthDayArray[month];
}

//重载运算符+=
Date& operator+=(int day)
{
_day += day;
while (_day > GetMonthDay(_year, _month))
{
_day -= GetMonthDay(_year, _month);
_month++;
if (_month == 13)
{
++_year;
_month = 1;
}
}

return *this;
}

//重载前置++
Date& operator++()
{
*this += 1;
return *this;
}

//重载后置++,返回局部对象，不能返回引用
Date operator++(int)
{
Date tmp(*this);
*this += 1;
return tmp;
}

private:
int _year;
int _month;
int _day;
};

int main()
{
Date d1(2024, 8, 20);
++d1;//前置++
d1.Print();

Date ret = d1++;//后置++
ret.Print();

d1.Print();

return 0;
}

运行结果：

解释： 

1. 为了方便实现 Date 类的前置++和后置++，我们先实现了 += 的运算符重载，这样前置++和后置++都可以直接复用+=运算符。
2. 后置++参数里写个 int 就行。没有必要加上参数名。
3. 实现 += 运算符重载就需要知道每个月的天数，因此定义了成员函数 GetMonthDay。GetMonthDay 中的数组使用 static 修饰是因为该函数数组会多次调用，为提升效率因此将其放在静态区，GetMonthDay函数作为成员函数一方面方便获取成员变量，另一方面作为成员函数访问效率高，因为成员函数默认为内联函数。
4. += 和前置++ 的运算符重载函数的返回类型都采用引用返回，这是为了避免进行拷贝构造来提升效率，这里能引用返回是因为返回的对象出了函数依旧存在，因此可以引用返回，但是后置++就不能引用返回，因为后置++返回的是++前的数值，因此我们是提前拷贝一份，存在局部对象中，然后返回局部对象。局部对象就不能使用引用返回。
5. this指针是当前对象的地址。*this指针就是当前对象，因此在成员函数中常见。

---

• 11. 重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调用时就变成了 对象<<cout ，不符合使用习惯和可读性。重载为全局函数把 ostream/istream 放到第一个形参位置就可以了，第二个形参位置当前类类型对象。

实现 <<和>>重载：

#include <iostream>
using namespace std;

class Date
{
public:
Date(int year = 1970, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}

ostream& operator<<(ostream& out)
{
out << _year << "年" << _month << "月" << _day << "日" << endl;

return out;
}

private:
int _year;
int _month;
int _day;
};

我们发现一个问题，就是重载运算符函数为成员函数时，this 会抢占第一个参数位置，导致我们不能正常像 cout<<d1 这样调用函数。

怎么解决这个问题呢？

1. 写成全局函数，并把成员变量设置为公有或者实现get函数获取成员变量（不推荐）
2. 使用友元关键字 friend，写成全局的运算符重载函数后，在类里面使用友元声明，这样这个全局函数就能访问类的私有成员变量了。

#include <iostream>
using namespace std;

class Date
{
public:
Date(int year = 1970, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}

//友元声明
friend ostream& operator<<(ostream& out, const Date& d);

private:
int _year;
int _month;
int _day;
};

//全局函数
ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << "年" << d._month << "月" << d._day << "日" << endl;

return out;
}

int main()
{
Date d1(2024, 8, 20);
cout << d1;

return 0;
}

运行结果：

你可能还有一个疑问：<<重载函数为什么要返回 cout 的引用？

1. 首先返回值是为了能够实现连续打印（<<和>>都是左结合）。如：
2. 
3. 引用返回是 cout 和 cin 这些是不支持拷贝构造的。

同理，实现流提取 cin>> 也一样：

#include <iostream>
using namespace std;

class Date
{
public:
Date(int year = 1970, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}

//友元声明
friend ostream& operator<<(ostream& cout, const Date& d);
friend istream& operator>>(istream& in, Date& d);

private:
int _year;
int _month;
int _day;
};

ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << "年" << d._month << "月" << d._day << "日" << endl;

return out;
}

istream& operator>>(istream& in, Date& d)
{
cout << "请输入年月日：>";
in >> d._year >> d._month >> d._day;

return in;
}

int main()
{
Date d1, d2;
cin >> d1 >> d2;
cout << d1 << d2 << endl;

return 0;
}

运行结果：

当然，如果是一个比较严谨的日期类，在输入日期的时候是需要判断一下日期是否合法。不过不着急，完整的日期类在本文的最后会实现出来。

---

2.赋值运算符重载

赋值运算符重载是一个默认成员函数，用于完成两个已经存在的对象直接的拷贝赋值，这里要注意跟拷贝构造区分，拷贝构造用于一个对象拷贝初始化给另一个要创建的对象。

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

简单来说：在创建对象时使用 "=" 是调用拷贝构造，对于已经创建了的对象使用 "=" 是调用赋值运算符重载函数。

---

赋值运算符重载的特点：

1. 赋值运算符重载是⼀个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成 const 当前类类型引用，否则传值传参会有拷贝。
2. 有返回值，且建议写成当前类类型引用，引用返回可以提高效率，有返回值目的是为了支持连续赋值场景。
3. 没有显式实现时，编译器会自动生成一个默认赋值运算符重载，默认赋值运算符重载行为跟默认拷贝构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的赋值重载函数。
4. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就可以完成需要的拷贝，所以不需要我们显示实现赋值运算符重载。像Stack这样的类，虽然也都是内置类型，但是 _a 指向了资源，编译器自动生成的赋值运算符重载完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动生成的赋值运算符重载会调用Stack的赋值运算符重载， 也不需要我们显示实现MyQueue的赋值运算符重载。这里还有⼀个小技巧，如果⼀个类显示实现 了析构并释放资源，那么他就需要显示写赋值运算符重载，否则就不需要。
5. 我们发现赋值运算符重载和拷贝构造特点很像对不对，用法上注意区分辨别

#include <iostream>
using namespace std;

class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}

//传引用返回减少拷贝
Date& operator=(const Date& d)
{
//避免自己赋值自己
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}

return *this;
}

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

private:
int _year;
int _month;
int _day;
};

int main()
{
Date d1(2024, 8, 20);
Date d2;
d2 = d1;

d2.Print();

return 0;
}

运行结果：

当然，Date类可以不写，编译器自动生成运算符重载是一样的：

#include <iostream>
using namespace std;

class Date
{
public:
Date(int year = 1, 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(2024, 8, 20);
Date d2;
d2 = d1;

d2.Print();

return 0;
}

---

六、取地址运算符重载

1.const 成员函数

1. 将 const 修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯。
2. const 实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。比如 const 修饰Date类的Print成员函数，Print 隐含的 this指针由 Date* const this 变为 const Date* const this。
3. 因为 c++ 规定 this 指针不能显示的写在形参的位置，因此将 const 写在成员函数后面。
4. 没有 const 修饰的成员函数的 this 指针是：Date* const this，注意它的 const 是在 * 的右边，它是修饰指针本身不能改变的，不涉及权限放大与缩小，只有 const Date* const this 中 * 左边的 const 才涉及权限的放大与缩小，因为 * 左边的 const 是修饰指针指向的内容不能修改。
5. 加上 const 的好处：普通对象和 const 对象都能调用 const 修饰的成员函数。
6. 注意此处 const 修饰函数的用法只适用于类成员函数，如果是上文中重载的 <<和>> 函数就不能在函数后面加 const ，因为它们两个是全局函数，加 const 是直接加在形参上的。
7. const 可以修饰哪些成员函数？答：像构造析构等涉及需要修改成员变量的函数就不能加上 const ，像 Date 类中 Print 函数中没有涉及修改成员变量，因此 Print 就可以加上 const 修饰。总结就是：如果函数需要修改成员变量就不加 const ，如果成员函数不涉及修改成员变量就加上 const。

作用就是，如果实例化的对象是 const 修饰的，那么它就不能调用没有被 const 修饰的成员函数。

#include <iostream>
using namespace std;

class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}

//const 修饰
void Print() const
{
cout << _year << "-" << _month << "-" << _day << endl;
}

private:
int _year;
int _month;
int _day;
};

int main()
{
const Date d1(2024, 8, 20);
d1.Print();

//没被 const 修饰的对象也可以调用 const 成员函数，因为这里是权限的缩小。
Date d2 = d1;
d2.Print();

return 0;
}

---

2.取地址运算符重载

• 取地址运算符重载分为普通取地址运算符重载和 const 取地址运算符重载，一般这两个函数编译器自动生成的就可以够我们用了，不需要去显示实现。除非一些很特殊的场景，比如我们不想让别人取到当前类对象的地址，就可以自己实现一份，胡乱返回⼀个地址。

#include <iostream>
using namespace std;

class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}

//普通取地址运算符重载
Date* operator&()
{
return this;
}

//const 取地址运算符重载
const Date* operator&() const
{
return this;
}

private:
int _year;
int _month;
int _day;
};

为什么分成普通取地址运算符重载和 const 取地址运算符重载算两种？

• 答：假如对象是 const 修饰的对象，那么取其地址必须返回 const 修饰的指针，而普通对象就只返回普通指针即可。这一点比较特殊因此写成两种。另外因为是 const 对象调用，因此需要再函数后面加上 const 修饰。

注意：

• & 运算符重载基本不用我们实现，编译器自动实现的就能使用。除非你想让取地址的结果不是该对象的真实地址（很特殊的情况），那么你就可以自己实现这两种取地址运算符重载，返回空指针或者随便写一个地址。

---

七、完整的日期类实现

#include <iostream>
#include <assert.h>
using namespace std;

class Date
{
//友元函数，友元放在类任意位置都行
friend ostream& operator<<(ostream& out, const Date& x);// <<流插入重载
friend istream& operator>>(istream& out, Date& x);// >>流提取重载

public:
//析构函数
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;

if (!CheckDate())
{
cout << "日期非法->" << *this << endl;
}
}

//比较运算符重载函数
bool operator<(const Date& x) const;
bool operator>(const Date& x) const;
bool operator<=(const Date& x) const;
bool operator>=(const Date& x) const;
bool operator==(const Date& x) const;
bool operator!=(const Date& x) const;

//加减运算符重载
Date& operator+=(int day);
Date operator+(int day) const;
Date& operator-=(int day);
Date operator-(int day) const;

Date& operator++();
Date operator++(int);
Date& operator--();
Date operator--(int);

//判断日期是否合法
bool CheckDate()
{
if (_month < 1 || _month>12 || _day<1 || _day > GetMonthDay(_year, _month))
{
return false;
}
else
{
return true;
}
}

//日期-日期
int operator-(const Date& x) const;

//打印
void print() const
{
cout << _year << "-" << _month << "-" << _day << endl;
}

//获取某月的天数
int GetMonthDay(int year, int month) const
{
assert(month > 0 && month < 13);

static int Day[13] = { -1,31,28,31,30,31,30,31,31,30,31,30,31 };

if (month == 2 && (year % 4 == 0 && year % 100 != 0 || year % 400 == 0))
{
return 29;
}

return Day[month];
}

private:
int _year;
int _month;
int _day;
};

//先实现 < 和 == 的运算符重载，其他的比较运算符直接复用即可
bool Date::operator<(const Date& x) const
{
if (_year < x._year)
{
return true;
}
else if (_year == x._year && _month < x._month)
{
return true;
}
else if (_year == x._year && _month == x._month && _day < x._day)
{
return true;
}

return false;
}

bool Date::operator==(const Date& x) const
{
return _year == x._year && _month == x._month && _day == x._day;
}

bool Date::operator>(const Date& x) const
{
return !(*this <= x);
}

bool Date::operator<=(const Date& x) const
{
return *this < x || *this == x;
}

bool Date::operator>=(const Date& x) const
{
return !(*this < x);
}

bool Date::operator!=(const Date& x) const
{
return !(*this == x);
}


Date& Date::operator+=(int day)
{
//避免有人 += 一个负数
if (day < 0)
{
return *this -= -day;
}

_day += day;

while (_day > GetMonthDay(_year, _month))
{
_day -= GetMonthDay(_year, _month);
++_month;

if (_month == 13)
{
++_year;
_month = 1;
}
}

return *this;
}

Date Date::operator+(int day) const
{
Date tmp = *this;

tmp += day;

return tmp;
}

Date& Date::operator-=(int day)
{
//避免有人 -= 一个负数
if (day < 0)
{
return *this += -day;
}

_day -= day;

while (_day <= 0)
{
--_month;

if (_month == 0)
{
--_year;
_month = 12;
}

_day += GetMonthDay(_year, _month);
}

return *this;
}

Date Date::operator-(int day) const
{
Date tmp = *this;

tmp -= day;

return tmp;
}

Date& Date::operator++()
{
*this += 1;
return *this;
}

Date Date::operator++(int)
{
Date tmp(*this);
*this += 1;
return tmp;
}

Date& Date::operator--()
{
*this -= 1;
return *this;
}

Date Date::operator--(int)
{
Date tmp(*this);
*this -= 1;
return tmp;
}

int Date::operator-(const Date& x) const
{
Date max = *this;
Date min = x;
int flag = 1;

if (*this < x)
{
max = x;
min = *this;
flag = -1;
}

int n = 0;
while (min != max)
{
++min;
++n;
}

return n * flag;
}

ostream& operator<<(ostream& out, const Date& x)
{
out << x._year << "年" << x._month << "月" << x._day << "日" << endl;
return out;
}

istream& operator>>(istream& in, Date& x)
{
while (1)
{
cout << "请依次输入年、月、日：>" << endl;
in >> x._year >> x._month >> x._day;

if (x.CheckDate())
{
break;
}
else
{
cout << "日期非法，请重新输入" << endl;
}
}

return in;
}

int main()
{
const Date d1(2024, 11, 28);
Date d2(2025, 1, 29);

cout << d1;
cout << d2;

//计算离春节还有几天
    cout << "离春节剩余天数：";
    cout << d2 - d1 << endl;

return 0;
}

运行结果：

---

总结

        以上就是本文的全部内容了，感谢你的支持！

原文地址：https://blog.csdn.net/x_p96484685433/article/details/143947215

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！