【C++】抽象之神：类和对象（中）万字详解

Hi，朋友们，好久不见

我们上次学到了C++类和对象（上），感觉那难度还行，能接受，但这次的类和对象（中），一开始真是让我觉得脑子转不动的无力感，难呐！好在之后功夫不负有心人，在我努力下可以理清搞懂这节课的知识了，我愿称C++为抽象之神——！这节课很重要，这篇接近两万字的博客是我断断续续花了一段时间整理出来的，感慨呀~ 这节课知识繁琐且相互缠绕，第一遍可能会有点晕，接下来几遍就是要一起细细品鉴这些知识，现在就让我的思路带着你一起开启类和对象（中）之旅吧！ 

目录

1.  类的默认成员函数

2.  构造函数

3. 析构函数

4. 拷贝构造函数

5、赋值运算符重载

5.1 运算符重载

5.2 赋值运算符重载

5.3 日期类实现

Date.h

Date.cpp

test.cpp

6. 取地址运算符重载

6.1 const成员函数

6.2 取地址运算符重载

1.  类的默认成员函数

默认成员函数就是：用户没有显示实现，编译器会自动生成的成员函数称为默认成员函数。

一个类，在我们不写的情况下编译器会默认生成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最后两个取地址重载不重要，我们稍微了解一下即可。其次就是C++以后还会增加两个默认成员函数，移动构造和移动赋值，我们以后再讲解这个。默认成员函数很重要，也比较复杂，我们从下面两个方面去学习：（全文所学习的知识点就是在贯彻这两点，等我们大概理解全篇知识再回头看就知道这两句话的含金量了）

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

下面我们来学习第一个默认成员函数：构造函数。这个构造函数跟我们以前学习的函数语法大不相同，做好准备！

2.  构造函数

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

【构造函数的特点】

  1. 函数名和类名相同；
  2. 无返回值（返回值不需要给，也不需要写void）；
  3. 对象实例化时系统会自动调用对应的构造函数；
  4. 构造函数可以重载（函数名相同，参数不同，像下面代码里面的有参，无参）；
  5. 如果类中没有显示定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显示定义编译器将不再生成；
  6. 无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。但是这三个函数只能有且仅有一个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。要注意很多人会认为编译器默认生成那个叫默认构造，实际上无参构造、全缺省构造也是默认构造，总结一下就是不传实参就可以调用的构造就叫默认构造。
  7. 我们不写，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是否初始化是不确定的，看编译器。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数来初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决，初始化列表我们后面会讲解。

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

【解释】

前四点中，最重要的是第3点，对象实例化时会默认调用对应的构造函数，其他3点是基本的语法 ；再看5,6,7点，第5点，如果类中没有显示定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显示定义编译器将不再生成，这里提到了一个默认构造函数，我们稍后解释；我们写了就算了，如果不写，编译器默认生成的无参的构造函数对内置类型成员的初始化没有要求，也就是说是否初始化是不确定的，看编译器，对于自定义类型成员变量（注意，对于用struct，class等关键字我们来自己定义的类型就叫自定义类型）要求调用这个成员变量的默认构造函数（再次提到了默认成员函数）来初始化，如果这个自定义类型成员变量，没有默认构造函数，那么就会报错，我们要初始化这个自定义类型成员变量，需要用初始化列表才能解决，初始化列表我们后面会讲解。什么是默认构造函数呢？无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。但是这三个函数只能有且仅有一个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。要注意很多人会认为编译器默认生成那个叫默认构造，实际上无参构造、全缺省构造也是默认构造，总结一下就是不传实参就可以调用的构造就叫默认构造。

总结，一般情况下，构造函数都需要自己写，少数情况下，默认生成的就可以用，如MyQueue，默认生成的构造函数可以调用Stack的全缺省默认构造函数。

比较绕哈，上面的知识要结合下面的代码及代码里面的注释细节我们要好好理解梳理一下思路！

#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 = 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()
{// 如果留下三个构造中的第⼆个带参构造，第⼀个和第三个注释掉// 编译报错：error C2512: “Date”: 没有合适的默认构造函数可⽤Date d1;     //调用默认构造函数Date d2(2025, 1, 1);//调用带参的构造函数// 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法// 区分这⾥是函数声明还是实例化对象// warning C4930: “Date d3(void)”: 未调⽤原型函数(是否是有意⽤变量定义的?)//Date d3();//Date d2(2025, 1, 1);这里并不会引起歧义，如果是函数的声明，参数部分应该加上类型，不加类型 //就是实例化对象d1.Print();d2.Print();return 0;
}
#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;
};//两个队列实现一个栈
class MyQueue
{
public://编译器默认生成MyQueue的构造函数调用了Stack的构造，完成了两个成员的初始化
private:Stack pushst;Stack popst;
};int main()
{//第七点：对于自定义类型成员变量，要求调用这个成员变量的默认构造函数来初始化。
//如果这个成员变量，没有默认构造函数，那么就会报错，
//我们要初始化这个成员变量，需要用初始化列表才能解决，
//初始化列表我们后面会讲解；我们没有显示写MyQueue的构造函数，
//编译器会默认生成一个构造函数，对于自定义类型的成员变量Stack，
//要求调用这个Stack成员变量的默认构造函数来初始化。MyQueue mq;return 0;
}

3. 析构函数

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

析构函数的特点：

  1. 析构函数名是在类名之前加上字符 ~ ；
  2. 无参数无返回值（也就意味着没有函数重载）（这里跟构造类似，也不需要加void）；
  3. 一个类只能有一个析构函数。若未显示定义，系统会自动生成默认的析构函数；
  4. 对象生命周期结束时，系统会自动调用析构函数；（注意系统会何时调用析构函数？）
  5. 跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定义类型成员会调用它的析构函数；
  6. 还需要注意的是我们显示写析构函数，对于自定义类型成员也会调用它的析构函数，也就是说自定义类型成员无论什么情况下都会自动调用析构函数。
  7. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，如Date；如果默认生成的析构就可以用，也就不需要显示写析构，如MyQueue（这里虽然调用的是我们自己写的Stack的析构函数，但我们确实是没有显示写~MyQueue，所以算是编译器默认生成的析构函数）；但是有资源申请时，一定要自己写析构，否则会造成资源泄露（函数栈帧结束会自己销毁空间，但是栈里面的指针所指向的空间并没有被释放，我们需要写一个析构函数去释放它），如Stack。
  8. 一个局部域的多个对象，C++规定后定义的先析构。

（总结：如果我们显示申请了资源，比如指针，那我们就需要自己实现析构，其他情况基本都不需要显示写）

tip：return的时候（此时对象生命周期结束）会自动调用析构函数结束。

#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;}//对于这个栈，里面申请了资源所以我们就得自己实现一个析构函数，如果我们不写析构函数，系统会自        //动生成一个析构函数，但是自动生成的析构函数对内置类型成员不做处理，也就是对指针类型不做处 //理，那么指针所指向的空间就没有被释放，就会造成内存泄漏~Stack(){cout << "~Stack()" << endl;free(_a);_a = nullptr;_top = _capacity = 0;}private:STDataType* _a;size_t _capacity;size_t _top;
};//两个栈实现一个队列
class MyQueue
{
public://编译器默认生成的MyQueue的析构函数调用了Stack的析构，释放了Stack内部的资源//显示写析构，也会自动调用Stack的析构
private:Stack pushst;Stack popst;
};int main()
{//先析构mq，再析构st，先定义的后析构Stack st;MyQueue mq;return 0;
}

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

#include<iostream>
using namespace std;//用最新加了析构函数和构造函数的C++版本Stack实现
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();
}// ⽤之前C版本Stack实现
bool isValid(const char* s) 
{ST st;STInit(&st);while (*s){// 左括号⼊栈if (*s == '(' || *s == '[' || *s == '{'){STPush(&st, *s);}else // 右括号取栈顶左括号尝试匹配{if (STEmpty(&st)){STDestroy(&st);return false;}char top = STTop(&st);STPop(&st);// 不匹配if ((top == '(' && *s != ')')|| (top == '{' && *s != '}')|| (top == '[' && *s != ']')){STDestroy(&st);return false;}}++s;}// 栈不为空，说明左括号⽐右括号多，数量不匹配bool ret = STEmpty(&st);STDestroy(&st);return ret;
}int main()
{cout << isValid("[()][]") << endl;cout << isValid("[(])[]") << endl;return 0;
}

这就是析构函数，需要我们结合知识点和例子好好思考，真是字字斟酌呀，细细思考，悟。。。

4. 拷贝构造函数

简单来说，拷贝构造函数就是类类型对象初始化的拷贝。

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

拷贝构造的特点：

  1. 拷贝构造函数是构造函数的一个重载。
  2. 拷贝构造函数的第一个参数必须是类类型对象的引用，使用传值方式编译器直接报错，因为语法逻辑会引发无穷递归调用。拷贝构造函数也可以多个参数，但是第一个参数必须是类类型对象的引用，后面的参数必须有缺省值。
  3. C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。
  4. 若未显示定义拷贝构造，编译器会自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝（一个字节一个字节的拷贝）(对于Data就不需要写拷贝构造函数，因为他里面只有自定义类型，编译器生成的拷贝构造就可以完成拷贝，不会出现什么问题)，对自定义类型成员变量对调用他的拷贝构造。
  5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷贝构造就可以完成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。像MyQueue这样的类型内部主要是⾃定义类型 Stack成员，编译器自动生成的拷贝构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实现 MyQueue的拷⻉构造。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现了析构并释放资源，那么他就需要显示写拷贝构造，否则就不需要。
  6. 传值返回会产⽣⼀个临时对象调⽤拷⻉构造，传值引⽤返回，返回的是返回对象的别名(引⽤)，没有产⽣拷⻉（传引用返回可以减少拷贝）。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少 拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回。

【无穷递归】 

#include<iostream>
using namespace std;class Date
{
public:Date(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day = day;}//编译报错：error C2652: “Date”: ⾮法的复制构造函数: 第⼀个参数不应是“Date”//Date(Date d)//Date d3(d1),这里解释一下，d就相当于d1，隐藏的this就相当于d3Date(const Date& d){this._year = d.year;this._month = d.month;this._day = d.day;}Date(const Date& d){_year = d.year;_month = d.month;_day = d.day;}Date(Date* d){_year = d->year;_month = d->month;_day = d->day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}
private:int _year;int _month;int _day;
};void Func1(Date d)
{cout << &d << endl;d.Print();
}Date& Func2()
{Date tmp(2024, 12, 9);tmp.Print();return tmp;
}int main()
{Date d1(2024, 12, 10);//C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里传值传参要调用拷贝构造//这里的d1是一个对象，C++规定对象的传值传参要调用拷贝构造，所以运行到这里要先调用我们上面实现    //的拷贝构造函数，调用完拷贝构造函数之后回到这里，再调用Func1函数，是这样的一个流程，注意！Func1(d1);cout << &d1 << endl;// 这⾥可以完成拷⻉，但不是拷⻉构造，这里传的是对象类型的指针，只是⼀个普通的构造，//对应上面的用指针接受的函数Date d2(&d1);d1.Print();d2.Print();//这样写才是拷⻉构造，通过同类型的对象初始化构造，⽽不是指针Date d3(d1);d2.Print();// 也可以这样写，这⾥也是拷⻉构造，运用赋值操作符Date d4 = d1;d2.Print();// Func2返回了⼀个局部对象tmp的引⽤作为返回值// Func2函数结束，tmp对象就销毁了，相当于了⼀个野引⽤Date ret = Func2();ret.Print();return 0;
}
#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;}Stack(const Stack& st){// 需要对_a指向资源创建同样⼤的资源再拷⻉值_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);if (nullptr == _a){perror("malloc申请空间失败!!!");return;}memcpy(_a, st._a, sizeof(STDataType) * st._top);_top = st._top;_capacity = st._capacity;}void Push(STDataType x){if (_top == _capacity){int newcapacity = _capacity * 2;STDataType* tmp = (STDataType*)realloc(_a, newcapacity *sizeof(STDataType));if (tmp == NULL){perror("realloc fail");return;}_a = tmp;_capacity = newcapacity;}_a[_top++] = x;}~Stack(){cout << "~Stack()" << endl;free(_a);_a = nullptr;_top = _capacity = 0;}private:STDataType* _a;size_t _capacity;size_t _top;
};// 两个Stack实现队列
class MyQueue
{
public:
private:Stack pushst;Stack popst;
};
int main()
{Stack st1;st1.Push(1);st1.Push(2);// Stack不显⽰实现拷⻉构造，⽤⾃动⽣成的拷⻉构造完成浅拷⻉// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃Stack st2 = st1;MyQueue mq1;// MyQueue⾃动⽣成的拷⻉构造，会⾃动调⽤Stack拷⻉构造完成pushst/popst// 的拷⻉，只要Stack拷⻉构造⾃⼰实现了深拷⻉，他就没问题MyQueue mq2 = mq1;return 0;
}

有了上面的代码加解析，我们再理解一下这些细节，见下

那我们该怎么办呢？见下

5、赋值运算符重载

5.1 运算符重载

  1. 当运算符被用于类类型的对象时，C++允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。
  2. 运算符重载是具有特殊名字的函数，他的名字是由 operator 和后面要定义的运算符共同构成。和其他函数一样，它也具有其返回类型和参数列表以及函数体。
  3. 重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。
  4. 如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少一个。
  5. 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持一致。
  6. 不能通过连接语法中没有的符号来创建新的操作符：⽐如operator@。
  7. .*     ::     sizeof     ?:    . 注意以上5个运算符不能重载。(选择题里面常考，⼤家要记⼀下重载操作符⾄少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义，如： int operator+(int x, int y)）。
  8. ​​​​​⼀个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如Date类重载operator-就有意义，但是重载operator*就没有意义。
  9. 重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。 C++规定，后置++重载时，增加⼀个int 形参，跟前置++构成函数重载，方便区分。
  10. 重载 << 和 >> 时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧运算对象，调⽤时就变成了 对象<<cout，不符合使⽤习惯和可读性。重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第二个形参位置当类类型对象。 
#include<iostream>
using namespace std;// 编译报错：“operator +”必须⾄少有⼀个类类型的形参
int operator+(int x, int y)
{return x - y;
}
class A
{
public:void func(){cout << "A::func()" << endl;}
};typedef void(A::* PF)(); //成员函数指针类型
int main()
{// C++规定成员函数要加&才能取到函数指针PF pf = &A::func;A obj;//定义ob类对象temp// 对象调⽤成员函数指针时，使⽤.*运算符(obj.*pf)();return 0;
}
#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;
};
// 重载为全局的⾯临对象访问私有成员变量的问题
// 有⼏种⽅法可以解决：
// 1、成员放公有
// 2、Date提供getxxx函数
// 3、友元函数
// 4、重载为成员函数
bool operator==(const Date& d1, const Date& d2)
{return d1._year == d2._year&& d1._month == d2._month&& d1._day == d2._day;
}
int main()
{Date d1(2024, 7, 5);Date d2(2024, 7, 6);// 运算符重载函数可以显⽰调⽤operator==(d1, d2);// 编译器会转换成 operator==(d1, d2);d1 == d2;return 0;
}
#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;}//d1==d2 -> d1.operator==(d2)bool operator==(const Date& d){return _year == d._year&& _month == d._month&& _day == d._day;}Date& operator++(){cout << "前置++" << endl;//...return *this;}Date operator++(int){Date tmp;cout << "后置++" << endl;//...return tmp;}
private:int _year;int _month;int _day;
};int main()
{Date d1(2024, 7, 5);Date d2(2024, 7, 6);// 运算符重载函数可以显⽰调⽤d1.operator==(d2);// 编译器会转换成 d1.operator==(d2);d1 == d2;// 编译器会转换成 d1.operator++();++d1;// 编译器会转换成 d1.operator++(0);d1++;return 0;
}

5.2 赋值运算符重载

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

赋值运算符重载的特点：

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

    总结

    1.构造一般都需要自己写，自己传参定义初始化；

    2.析构，构造时有资源申请（如malloc或者fopen）等就需要显示写析构 ；

    3.拷贝构造和赋值重载，显示写了析构，内部管理资源，就需要显示实现深拷贝。

    class Date
{
public:Date(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day = day;}Date(const Date& d){cout << " Date(const Date& d)" << endl;_year = d._year;_month = d._month;_day = d._day;}// 传引⽤返回减少拷⻉// d1 = d2;Date& operator=(const Date& d){// 要检查⾃⼰给⾃⼰赋值的情况if (this != &d){_year = d._year;_month = d._month;_day = d._day;}// d1 = d2表达式的返回对象应该为d1，也就是*thisreturn *this;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}
private:int _year;int _month;int _day;
};
int main()
{Date d1(2024, 7, 5);Date d2(d1);Date d3(2024, 7, 6);d1 = d3;// 需要注意这⾥是拷⻉构造，不是赋值重载// 请牢牢记住赋值重载完成两个已经存在的对象直接的拷⻉赋值// ⽽拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象Date d4 = d1;//这里是连续赋值，这里是两次调用赋值运算符重载，从右往左进行，d1=的右操作数是d3=d2的返回值，也就是d3,这个例子表现的是特点里面的第二点//d1=d2=d3;return 0;
}

5.3 日期类实现

Date.h

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;class Date
{//友元函数的声明，类里面在函数声明前面加一个friend，public里面或外面都可以//这样该函数就可以在类外面去访问类里面的成员变量friend ostream& operator<<(ostream& out, const Date& d);friend istream& operator>>(istream& in, Date& d);public://函数的声明Date(int year = 2025, int month = 1, int day=1);void Print()const;//实现一个日期检查的成员函数，在构造函数和流插入时检查日期是否合法bool CheckDate()const;//对于短小且频繁调用的函数我们设置为内联函数，类里面的函数默认就是内联函数(inline)，所以我们在类里面进行实现int GetMonthDay(int year, int month)const{assert(month > 0 && month < 13);//我们这里把数组搞成静态的，因为我们会非常频繁的调用这个函数，//我们直接把月份数组创建在静态区，这样每次调用这个函数就不用每次都重新创建了（小细节）static int monthDayArr[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };//这里我们先判断是否是2月再进行判断闰年，不是2月我们就没必要去判断是否是闰年（小细节）if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))){return 29;}return monthDayArr[month];}bool operator<(const Date& d)const;bool operator>(const Date& d)const;bool operator<=(const Date& d)const;bool operator>=(const Date& d)const;bool operator==(const Date& d)const;bool operator!= (const Date & d)const;//d1 += 天数Date& operator+=(int n);Date operator+(int n)const;//d1 -= 天数Date& operator-=(int n);Date operator-(int n)const;//++d1Date& operator++();//为了区分，构成重载，给后置++，强行加了一个int形参// 这里不需要写形参名，因为接收值是多少无所谓，因为不需要// 这个参数仅仅是为了跟前置++构成重载区分//d1++ -> d1.operator++(0)Date operator++(int);//--d1 -> d1.operator--()Date& operator--();//d1-- -> d1.operator--(0)Date operator--(int);//日期相减int operator-(const Date& d)const;private:int _year;int _month;int _day;
};//这里不需要＋const，这两个函数压根就不是成员函数就没有this指针
ostream& operator<<(ostream& out, const Date& d);
istream& operator>>(istream& in, Date& d);

Date.cpp

#include"Date.h"//检查日期是否合法
bool Date::CheckDate()const
{if (_month < 1 || _month > 12 || _day < 1 || _day > GetMonthDay(_year, _month)){return false;}else{return true;}
}//这里用到了预作用限定符，表示这个函数是成员函数且里面的变量不仅可以在全局里面找也可以到类里面去寻找
//缺省值只能在声明给，不能声明和定义同时给Date::Date(int year ,int month, int day)
{_year = year;_month = month;_day = day;if (!CheckDate()){cout << "日期非法->";cout << *this << endl;}
}void Date::Print()const{cout << _year << '-' << _month << '-' << _day << endl;}//d1<d2bool Date::operator<(const Date& d)const{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;}}//实现一个<和=，再使用复用就可以实现接下来的运算符重载bool Date::operator>(const Date& d)const{return !(*this <= d);}bool Date::operator<=(const Date& d)const{return (*this < d || *this == d);}bool Date::operator>=(const Date& d)const{return !(*this < d);}bool Date::operator==(const Date& d)const{return (_year == d._year && _month == d._month && _day == d._day);}bool Date::operator!= (const Date& d)const{return !(_year == d._year && _month == d._month && _day == d._day);}//Date& Date::operator+=(int n)//{// _day += n;// while (_day > GetMonthDay(_year, _month))// {//	 _day -= GetMonthDay(_year, _month);//	 _month++;//	 if (_month == 13)//	 {//		 _year++;//		 _month = 1;//	 }// }// return *this;//返回引用，减少拷贝//}//里面的tmp是临时变量，出了作用域就要被销毁，所以这里使用传值返回Date Date::operator+(int n)const{Date tmp = *this;//若n<0if (n < 0){return tmp -= -n;}tmp._day += n;while (tmp._day > GetMonthDay(tmp._year, tmp._month)){tmp._day -= GetMonthDay(tmp._year, tmp._month);tmp._month++;if (tmp._month == 13){tmp._year++;tmp._month = 1;}}return tmp;//返回引用，减少拷贝（类类型对象传值返回要调用拷贝构造）}//Date Date::operator+(int n)//{// //这里+复用+=// Date tmp = *this;// tmp += n;// return tmp;//}//这里+=复用+Date& Date::operator+=(int n){*this = *this + n;return *this;}//这里的两种复用方式哪个更好呢？//+复用+=更好，因为+=复用+多使用拷贝构造，在+里面已经有了两个拷贝构造了，+=再次复用会增加拷贝次数Date& Date::operator-=(int n){if (n < 0){return *this += -n;}_day -= n;while (_day <= 0){_month--;if (_month == 0){_month = 12;_year -= 1;}_day += GetMonthDay(_year, _month);}return *this;}Date Date::operator-(int n)const{//-相对于-=是自身不改变Date tmp = *this;tmp -= n;return tmp;}//++d1Date& Date::operator++(){*this += 1;return *this;}//d1++//这个跟上面那个不一样的是，上面前置++是返回++之前的值，后置++是返回++之前的值，但是*this本身都会+1//只不过返回值不同,我们可以写代码自己观察一下结果，尝试一下Date Date::operator++(int){Date tmp(*this);*this += 1;return tmp;}//--d1Date& Date::operator--(){*this -= 1;return *this;}//d1--Date Date::operator--(int){Date tmp = *this;*this -= 1;return tmp;}//实现日期－日期//d1-d2
int Date::operator-(const Date& d)const{//这里判断*this和d哪个大，谁大谁赋值给max，巧用flag，我们可以学习这种方法Date max = *this;Date min = d;int flag = 1;if (*this < d){max = d;min = *this;int flag = -1;}int n = 0;while (max != min){min++;n++;}return n * flag;}//为什么这里ostream& out不加const，因为d要写入插入out里面，out是要改变的，加了const就不允许改变了，而d不需要改变
ostream& operator<<(ostream& out, const Date& d)
{out << d._year << '-' << d._month << '-' << d._day << endl;return out;
}
//但是我们现在又面临一个问题，那就是类成员变量私有不能访问,我们可以使用友元函数的声明进行解决,见.h文件类里面//cout << d1;
//本质调用
//operator(cout, d1);//这里ostream& in前面可以加const->要从其里面去提取数据，提取的数据写入到d里面，d要改变不需要加const
istream& operator>>(istream& in,Date& d)
{while (1){cout << "请依次输入年月日：>";in >> d._year >> d._month >> d._day;if (d.CheckDate())//注意这里是要调用对象里面的成员函数{break;}else{cout << "日期非法，请重新输入：" << endl;}}return in;
}

test.cpp

#include"Date.h"//int main()
//{
//	Date d1;
//	d1.Print();
//	/*d1 += 100;
//	d1.Print();*/
//
//	Date d2 = d1 + 100;
//	d2.Print();
//	d1.Print();
//
//	d2 -= 100;
//	d2.Print();
//
//	Date d3 = d1++;
//	d3.Print();
//	d1.Print();
//
//	++d1;
//	d1.Print();
//
//	return 0;
//}int main()
{Date d1(2024, 12, 18);Date d2(2025, 19, 1);//cout << d2 - d1 << endl;//cout << d1;本质调用operator(cout, d1);cin >> d1;cout << d1 << endl;return 0;
}

我们要理解并会实现Date类，我们后续的学习会使用到。 

6. 取地址运算符重载

6.1 const成员函数

  1. 将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后面（函数的声明和定义都要加）。
  2. const实际修饰的是成员函数隐含的this指针（this指向的对象），表明在该成员函数中不能对类的任何成员进行修改。const修饰Date类的Print成员函数，Print隐含的this指针由Date* const this 变为const Date* const this。
  3. 总结：什么时候+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;}// void Print(const Date* const this) constvoid Print() const{cout << _year << "-" << _month << "-" << _day << endl;}
private:int _year;int _month;int _day;
};
int main()
{// 这⾥⾮const对象也可以调⽤const成员函数是⼀种权限的缩⼩Date d1(2024, 7, 5);d1.Print();const Date d2(2024, 8, 5);d2.Print();return 0;
}

6.2 取地址运算符重载

取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器自动生成的就可以够我们用了，不需要去显示实现。除非⼀些很特殊的场景，比如我们不想让别⼈取到当前类对象的地址，就可以自己实现⼀份，胡乱返回⼀个地址（哈哈 ）。
我们一般情况下都不需要去操心对普通类和const修饰的类进行取地址的操作符了，编译器已经给我们实现好了，直接用就OK了。 

class Date
{
public:Date* operator&(){return this;//return nullptr;}const Date* operator&()const{return this;//return nullptr;}
private:int _year;int _month;int _day;};//我们自己实现这两个函数的时候，编译器就不再实现了，此时返回值就我们自己定

本类和对象（中）就结束了，我们常常回顾在练习中理解知识点的真正含义。

知识虽难，我们也要坚持学下去，别放弃

完——

Kamin_Emin、JONY_高音质在线试听_Kamin歌词|歌曲下载_酷狗音乐

我最近喜欢的一首音乐，分享给你

我是云边有个稻草人

期待与你的下一次相遇！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/491967.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

C++手动实现一个HashMap

C++手动实现一个HashMap

1.HashMap原理 参考我的博客&#xff1a;https://blog.csdn.net/Revendell/article/details/110009858 开链法&#xff1a;STL的hashtable便是采用开链法解决冲突。这种做法是在每一个表格元素中维护一个list&#xff1a;散列函数为我们分配某一个list&#xff0c;然后我们在…
阅读更多...
【Linux】深入理解进程信号机制：信号的产生、捕获与阻塞

【Linux】深入理解进程信号机制：信号的产生、捕获与阻塞

&#x1f3ac; 个人主页&#xff1a;谁在夜里看海. &#x1f4d6; 个人专栏&#xff1a;《C系列》《Linux系列》《算法系列》 ⛰️ 时间不语&#xff0c;却回答了所有问题 目录 &#x1f4da;前言 &#x1f4da;一、信号的本质 &#x1f4d6;1.异步通信 &#x1f4d6;2.信…
阅读更多...
sql server 数据库还原，和数据检查

sql server 数据库还原，和数据检查

右键数据库选择还原&#xff0c; 还原的备份文件必须选择在本地的文件&#xff08;远程文件没有试过&#xff09;还原数据库名字可以修改&#xff0c;然后file选择中有个2个目录data file 的目录 &#xff0c;和log data 的目录都可以重新选择还原到的新的目录&#xff0c;不要…
阅读更多...
v31蓝牙信标方案

v31蓝牙信标方案

革新点 带蜂鸣器功能 容易安装和移动 多彩均匀明显的指示灯 长电池寿命&#xff0c;常规使用1-2年 自带1个按键 钮扣电池组供电 产品概述 电子标签拣货系统是一组安装在货架储位上的电子设备&#xff0c;通过计算机与软件的控制&#xff0c;藉由指示灯或数字显示作为辅助…
阅读更多...
内存中优雅的csv对象（Python）

内存中优雅的csv对象（Python）

磁盘*.csv文件是文本&#xff0c;以行结构的二维list是内存中的“csv”。 (笔记模板由python脚本于2024年12月18日 10:15:23创建&#xff0c;本篇笔记适合学习过list、panda的coder翻阅) 【学习的细节是欢悦的历程】 Python 官网&#xff1a;https://www.python.org/ Free&…
阅读更多...
OpenGL —— 2.6.1、绘制一个正方体并贴图渲染颜色（附源码，glfw+glad）

OpenGL —— 2.6.1、绘制一个正方体并贴图渲染颜色（附源码，glfw+glad）

源码效果 C++源码 纹理图片 需下载stb_image.h这个解码图片的库，该库只有一个头文件。 具体代码： vertexShader.glsl #version
阅读更多...
H5 中 van-popup 的使用以及题目的切换

H5 中 van-popup 的使用以及题目的切换

H5 中 van-popup 的使用以及题目的切换 在移动端开发中&#xff0c;弹窗组件是一个常见的需求。vant 是一个轻量、可靠的移动端 Vue 组件库&#xff0c;其中的 van-popup 组件可以方便地实现弹窗效果。本文将介绍如何使用 van-popup 实现题目详情的弹窗展示&#xff0c;并实现…
阅读更多...
Metaploit-永恒之蓝漏洞利用

Metaploit-永恒之蓝漏洞利用

1&#xff1a;Metaploit介绍　　 本次测试主要是利用永恒之蓝漏洞对windows7进行控制利用&#xff0c;掌握Metaploit工具的使用&#xff0c;知道永恒之蓝的漏洞利用原理。永恒之蓝是在Windows的SMB服务处理SMB v1请求时发生的漏洞&#xff0c;这个漏洞导致攻击者在目标系统上可…
阅读更多...
FPGA高速下载器SZ901

FPGA高速下载器SZ901

SZ901基于AMD(Xilinx) Virtual Cable协议. 本设备使用千兆网络接口。基于此接口,本设备可以同时支持多达四路FPGA板卡同时调试,每组相互独立,互不干扰。 特点 1,支持JTAG 速度最高53Mb/s&#xff0c;电压范围1.2-3.3V,最高支持200cm排线 2,支持4路JTAG独立使用 3,支持多路…
阅读更多...
【递归，搜索与回溯算法】穷举 vs 暴搜 vs 深搜 vs 回溯 vs 剪枝算法入门专题详解

【递归，搜索与回溯算法】穷举 vs 暴搜 vs 深搜 vs 回溯 vs 剪枝算法入门专题详解

前言 什么是回溯算法&#xff1f; 回溯算法是一种经典的递归算法&#xff0c;通常用于解决组合问题、排列问题和搜索问题等。 回溯算法的基本思想 从一个初始状态开始&#xff0c;按照一定的规则向前搜索&#xff0c;当搜索到某个状态无法前进时&#xff0c;回退…
阅读更多...
设计模式之桥接模式：抽象与实现之间的分离艺术

设计模式之桥接模式：抽象与实现之间的分离艺术

~犬&#x1f4f0;余~ “我欲贱而贵&#xff0c;愚而智&#xff0c;贫而富&#xff0c;可乎&#xff1f; 曰&#xff1a;其唯学乎” 桥接模式概述与角色组成 想象一下你家里的电视遥控器&#xff0c;无论是索尼还是三星的电视机&#xff0c;遥控器的按键功能都差不多&#xff1…
阅读更多...
ASRPRO学习笔记一之语音模型位置和语音替换

ASRPRO学习笔记一之语音模型位置和语音替换

一、语音替换的步骤 1、扬声器录音 打开GoldWave,点击工具栏中的蓝色控制属性按钮&#xff0c;点击设备&#xff0c;选择扬声器&#xff0c;点击ok。打开电脑上的网易云音乐&#xff0c;点击红色的录制按钮&#xff0c;开始录制音乐&#xff0c;在网易云音乐上点击播放音乐,录…
阅读更多...
多因子认证 (Multi-factor authentication, MFA)

多因子认证 (Multi-factor authentication, MFA)

多因子认证 (MFA) 是一种思想&#xff0c;而UsernamePassword&#xff0c;OTP等是具体的认证手段。多因子认证就是将这些认证手段结合。 目录 什么是MFAMFA的作用MFA的实际应用 认证认证 (Authentication, AuthN) 因素常见的认证 (Authentication, AuthN) 类型密码认证无密码认…
阅读更多...
内存压缩禁用设置

内存压缩禁用设置

设置禁用内存压缩功能 1、“Win”“X”键→“A”键 2、如果输入“Get-MMAgent”并按“Enter”键&#xff0c;则可以从“MemoryCompression”中检查内存压缩功能的状态。 True启用&#xff0c;False禁用 3、要禁用内存压缩功能&#xff0c;请输入“Disable-MMAgent -mc”并…
阅读更多...
素数回文数的个数

素数回文数的个数

素数回文数的个数 C语言代码C 代码Java代码Python代码 &#x1f490;The Begin&#x1f490;点点关注&#xff0c;收藏不迷路&#x1f490; 求11到n之间&#xff08;包括n&#xff09;&#xff0c;既是素数又是回文数的整数有多少个。 输入 一个大于11小于1000的整数n。 输出…
阅读更多...
QT网络（一）：主机信息查询

QT网络（一）：主机信息查询

网络简介 在QT中进行网络通信可以使用QT提供的Qt Network模块&#xff0c;该模块提供了用于编写TCP/IP网络应用程序的各种类&#xff0c;如用于TCP通信的QTcpSocket和 QTcpServer&#xff0c;用于 UDP 通信的 QUdpSocket&#xff0c;还有用于网络承载管理的类&#xff0c;以及…
阅读更多...
Flutter Navigator2.0的原理和Web端实践

Flutter Navigator2.0的原理和Web端实践

01 背景与动机 在Navigator 2.0推出之前&#xff0c;Flutter主要通过Navigator 1.0和其提供的 API&#xff08;如push(), pop(), pushNamed()等&#xff09;来管理页面路由。然而&#xff0c;Navigator 1.0存在一些局限性&#xff0c;如难以实现复杂的页面操作&#xff08;如移…
阅读更多...
如何在谷歌浏览器中开启安全浏览

如何在谷歌浏览器中开启安全浏览

在数字化时代&#xff0c;网络安全变得愈发重要。作为全球最受欢迎的网络浏览器之一&#xff0c;谷歌浏览器提供了多种功能来保护用户的在线安全。本文将详细介绍如何在谷歌浏览器中开启安全浏览&#xff0c;并额外提供一些有用的页面滚动设置、地址栏快捷搜索和跟踪防护的相关…
阅读更多...
【物联网技术与应用】实验3：七彩LED灯闪烁

【物联网技术与应用】实验3：七彩LED灯闪烁

实验3 七彩LED灯闪烁 【实验介绍】 七彩LED灯上电后&#xff0c;7色动闪光LED模块可自动闪烁内置颜色。它可以用来制作相当吸引人的灯光效果。 【实验组件】 ● Arduino Uno主板* 1 ● USB数据线* 1 ● 7彩LED模块*1 ● 面包板*1 ● 9V方型电池*1 ● 跳线若干 【实验原…
阅读更多...
直播美颜插件开发全流程：从美颜sdk的集成到实际部署

直播美颜插件开发全流程：从美颜sdk的集成到实际部署

对于开发者来说&#xff0c;如何高效地开发和部署一个直播美颜插件&#xff0c;则需要从美颜SDK的集成到实际部署的全流程把控。本篇文章&#xff0c;我将详细解析这个流程中的关键技术和核心环节&#xff0c;助力开发者高效完成项目交付。 一、项目需求分析与技术选型 在开发…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023