文章目录

1.类的六个默认构造函数2.构造函数2.1特性2.1.1 函数名与类名相同2.1.2. 无返回值（不能写void）2.1.3. 对象实例化时编译器自动调用对应的构造函数2.1.4 构造函数可以重载2.1.5编译器生成默认的构造函数2.1.6编译器生成的默认构造有何用？2.1.7三种默认构造函数 3.析构函数3.1特性3.1.1析构函数名是在类名前加上字符 ~3.1.2无参数无返回值类型（不能写void）3.1.3一个类只能有一个析构函数。3.1.4对象生命周期结束时，编译系统自动调用析构函数3.1.5编译器生成的默认析构函数 4.拷贝构造4.1特征4.1.1拷贝构造函数是构造函数的一个重载形式4.1.2拷贝构造函数的参数4.1.3编译器生成默认的拷贝构造函数(浅拷贝)4.1.4拷贝构造函数典型调用场景： 5.赋值运算符重载5.1运算符重载5.2赋值运算符重载5.2.1赋值运算符重载格式5.2.2返回值类型5.2.3检测是否自己给自己赋值5.2.4注意返回值5.2.5重载成类的成员函数5.2.6默认赋值运算符重载 5.3前置++与后置++重载5.4运算符重载拓展 6.const成员函数7.取地址及const取地址操作符重载

1.类的六个默认构造函数

如果一个类中什么成员都没有，简称为空类。

class test{ };

空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

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

2.构造函数

class Data{ public:void Init(int year = 1, int month = 1, int day = 1){ this->_year = year;this->_month = month;this->_day = day;}void Print(){ cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;};int main(){ Data d1;d1.Init(2024, 5, 22);d1.Print();Data d2;d2.Init(2024, 5, 21);d2.Print();return 0;}

对于上方的Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

2.1特性

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

特性：

2.1.1 函数名与类名相同

2.1.2. 无返回值（不能写void）

2.1.3. 对象实例化时编译器自动调用对应的构造函数

2.1.4 构造函数可以重载

特别注意：在调用无参构造时，后面不能跟括号。

2.1.5编译器生成默认的构造函数

如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

未显示定义，编译器自动生成，可以通过编译

若显示定义了构造函数，编译器不再生成；即没有默认构造函数，编译报错。

2.1.6编译器生成的默认构造有何用？

不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？

下面代码中，d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？

存在即合理，它还是有一定的用处的。

C++把类型分成内置类型(基本类型)和自定义类型。

内置类型就是语言提供的数据类型，如：int/char/float/任何类型的指针…，自定义类型就是我们使用class/struct/union等自己定义的类型，

对于内置类型来说，C++标准并没有规定要不要处理（可处理，可不处理，取决于编译器）

对于自定义类型来说，会调用该类型的默认构造函数

看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员 _t 调用的它的默认成员函数。

注意：：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值（类中不是定义，类的实例化才是定义，易错）

2.1.7三种默认构造函数

无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

三种默认构造函数：

无参构造函数全缺省构造函数我们没写编译器默认生成的构造函数

注意：无参构造与全缺省的构造只能存在一个，否则会存在调用歧义

总结：

无需传参就可以调用的构造函数就是默认构造函数。一般情况下，构造函数都需要我们显示的去实现。只有少数情况下可让编译器自动生成构造函数，例如成员全是自定义类型

3.析构函数

析构函数：与构造函数功能相反，析构函数不是完成对象本身的销毁工作，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

3.1特性

3.1.1析构函数名是在类名前加上字符 ~

3.1.2无参数无返回值类型（不能写void）

3.1.3一个类只能有一个析构函数。

一个类只能有一个析构函数若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载。

3.1.4对象生命周期结束时，编译系统自动调用析构函数

可以借助调试看一眼，我们并没有调用析构函数，但是在代码179行按F11会自动进入析构函数。

上面的代码我们好像没有看出来析构函数有什么用，那就看下面的代码：

下方代码我们简单的实现了一个栈，此时编译器自动调用栈所实现的析构函数，会将我们所申请的资源清理掉。

typedef int DataType;class Stack{ public://构造Stack(size_t capacity = 3){ this->_array = (DataType*)malloc(sizeof(DataType) * capacity);if (NULL == _array){ perror("malloc申请空间失败!!!");return;}this->_capacity = capacity;this->_size = 0;}void Push(DataType data){ // CheckCapacity();_array[_size] = data;_size++;}//析构~Stack(){ if (_array){ free(_array);_array = NULL;_capacity = 0;_size = 0;}}private:DataType* _array;int _capacity;int _size;};int main(){ Stack s;s.Push(1);s.Push(2);return 0;}

3.1.5编译器生成的默认析构函数

关于编译器自动生成的析构函数，是否会完成一些事情呢？

下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员调用它的析构函数；对内置类型成员不做处理。

总结：

有资源需要清理的，就需要写析构函数，否则会造成内存泄漏问题。如：栈、链表…有两种情况不需要写析构，编译器默认生成的就可以

a.全是内置类型的成员，没有资源需要清理的。如Date类…

b.内置类型成员无需清理，其它都是自定义类型的成员。如两个栈实现一个队列

4.拷贝构造

在创建对象时，可否创建一个与已存在对象一模一样的新对象呢？

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

4.1特征

拷贝构造函数也是特殊的成员函数，其特征如下：

4.1.1拷贝构造函数是构造函数的一个重载形式

没有返回值

class Date{ public://构造函数Date(int year, int month, int day){ this->_year = year;this->_month = month;this->_day = day;}//拷贝构造Date(const Date& d){ this->_year = d._year;this->_month = d._month;this->_day = d._day;}private:int _year;int _month;int _day;};int main(){ Date d1(2024,5,24);//拷贝构造//以下两种方式等价Date d2(d1);Date d3 = d1;return 0;}

4.1.2拷贝构造函数的参数

拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

为什么会引起无穷递归呢？

首先我们要知道，自定义类型传值传参要调用拷贝构造（可以看成一种规定）

下面的代码调试可以发现，当我们第一次按F11进入fun函数时，它是先进入到了Date类中的拷贝构造函数，第二次按F11才会进入fun函数。

如果这样，不写引用的话就会引发无穷的递归。

本来是只想调用拷贝构造，但是调用前要传参数，传递参数又要发生拷贝构造；那么还是要传递参数，此时就会形成没有尽头的递归，

4.1.3编译器生成默认的拷贝构造函数(浅拷贝)

若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

我们发现，对于所有成员确实都拷贝过去了，可是对于数组元素来说，它们两个数组的地址是相同的，也就是二者数组的同一块空间，这就有点不好了。

注意：

在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的；而自定义类型是调用其拷贝构造函数完成拷贝的。

4.1.4拷贝构造函数典型调用场景：

使用已存在对象创建新对象函数参数类型为类类型对象函数返回值类型为类类型对象

class Date { public: Date(int year, int minute, int day) { cout << "Date(int,int,int):" << this << endl; } Date(const Date& d) { cout << "Date(const Date& d):" << this << endl; } ~Date() { cout << "~Date():" << this << endl; } private: int _year; int _month; int _day; }; Date Test(Date d) { Date temp(d); return temp; } int main() { Date d1(2022,1,13); Test(d1); return 0; }

总结：

如果没有管理资源，一般不需要写拷贝构造，默认生成的拷贝构造就可以。如Data如果都是自定义类型的成员，内置类型成员也没有指向资源，也类似默认生成的拷贝构造就可以。如两个栈实现队列一般情况下，不需要显示的写析构函数，就不需要显示的写拷贝构造如果内部有指针或一些值指向资源，需要写析构释放，通常就需要显示写构造完成深拷贝。如：Stack、List等。

5.赋值运算符重载

我们写了这么多的日期类，好像都没怎么操作过，下面写个日期的比较吧：

比如我们写个函数比较两个日期哪个小，那么我们就得这样写：

bool CompareLess(Date& d1, Date& d2){ if (d1._year < d2._year){ return true;}else if(d1._year == d2._year){ if (d1._month < d2._month){ return true;}else if (d1._month == d2._month){ return d1._day < d2._day;}}return false;}

如果比较两个日期哪个大呢？是不是又得写一份类似的代码，而且调用的时候可读性又不好，如下：

bool CompareLarger(Date& d1, Date& d2){ if (d1._year > d2._year){ return true;}else if (d1._year == d2._year){ if (d1._month > d2._month){ return true;}else if (d1._month == d2._month){ return d1._day > d2._day;}}return false;}int main(){ Date d1(2024, 6, 25);Date d2(2024, 6, 1);Date d3(2025, 6, 1);cout << CompareLess(d1, d2) << endl;cout << CompareLess(d2, d3) << endl;return 0;}

那能不能像内置类型那样直接用> < 这样比呢？那样多得劲。但是很遗憾，C++不支持这样写

但是祖师爷发明了运算符重载来支持这样写。

5.1运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型和参数列表与普通的函数类似。

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

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

//全局的两个函数//bool CompareLess(Date& d1, Date& d2)bool operator<(Date& d1, Date& d2)//操作符重载{ if (d1._year < d2._year){ return true;}else if(d1._year == d2._year){ if (d1._month < d2._month){ return true;}else if (d1._month == d2._month){ return d1._day < d2._day;}}return false;}//bool CompareLarger(Date& d1, Date& d2)bool operator>(Date& d1, Date& d2)//操作符重载{ if (d1._year > d2._year){ return true;}else if (d1._year == d2._year){ if (d1._month > d2._month){ return true;}else if (d1._month == d2._month){ return d1._day > d2._day;}}return false;}int main(){ Date d1(2024, 6, 25);Date d2(2024, 6, 1);Date d3(2025, 6, 1);//显示调用cout << operator>(d1, d2) << endl;//隐式调用cout << (d1 < d2) << endl;cout << (d2 > d3) << endl;return 0;}

注意：

不能通过连接其他符号来创建新的操作符：比如operator@

重载操作符 必须有一个类类型参数（即不可以重新定义内置类型已经存在的操作符的行为）

.* (点星)、 :: (域限定符) 、sizeof 、?:（三目运算符） . (成员点)。注意以上5个运算符不能重载。这个经常在笔试选择题中出现。作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this

我们一般将运算符重载放在类中，而不是类外。因为成员变量通常是私有的，在类外是访问不到的，所以通常将函数重载作为类的成员函数。（上面代码可以访问是因为将它放为public了）

5.2赋值运算符重载

5.2.1赋值运算符重载格式

参数类型：const T&，传递引用可以提高传参效率

5.2.2返回值类型

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

假设有下面的代码，我想让d1变成d4，那会发生什么呢？

此时调用的不是拷贝构造，而是一个赋值拷贝（将一个已经存在的对象，拷贝赋值给另一个已经存在的对象）

那赋值应该怎么写呢？下面这样写就可以吗？

但是很多人都不是这样写的，别人是这样写的，有一个返回值：

这样写是因为可能存在连续的赋值

int main(){ Date d1(2024, 5, 27);//拷贝构造Date d2 = d1;Date d3(d1);Date d4(2024,5,30);d1 = d4;//此时是什么？赋值拷贝d1 = d2 = d4; //连续赋值return 0;}

很多人也都建议使用引用返回：

那传值返回与传引用返回有什么区别呢？效率上的区别

看下面的func函数：

那有没有什么方式让它不发生拷贝构造呢？传引用返回

下面代码没有发生拷贝构造

但此时会有问题，确实减少了拷贝，但是引用实际上就是给d取了一个别名，二者都指向d，但是d都析构了，此时返回了临时变量的地址，类似于C中的野指针了。

二者地址打印出来是一样的。

总结一下：

若返回对象是一个局部对象或临时对象，出来当前函数的作用域就析构销毁了，就不能使用引用返回，用引用返回是存在风险的，引用对象在那个函数的栈帧中已经销毁了。

即：

出了作用域，返回对象还没有析构，那就可以传引用放回，减少拷贝

a、返回对象声明周期到了，会析构，传值返回

b、返回对象声明周期没到，不会析构，传引用返回

对于最开始写的日期的赋值重载，this在operator的栈帧上，但是*this在main函数的栈帧中，返回对象没有析构，因此可以使用引用返回。

5.2.3检测是否自己给自己赋值

为了防止有人自己给自己赋值，赋值前可以判断一下，提高效率，避免不必要的操作。

5.2.4注意返回值

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

5.2.5重载成类的成员函数

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

5.2.6默认赋值运算符重载

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

注意：

内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

5.3前置++与后置++重载

我们知道，前置++与后置++重载以后，二者是一样的，没有办法区分。我们的祖师爷就给后置++强行增加了一个int类型的形参，该形参不需要写参数名，调用函数参数不需要传（编译器自动传）或者 传递任何数都可，这个参数仅仅为了跟前置区分，不会使用。

一般会这样写：

5.4运算符重载拓展

我们之前要想打印类中的成员变量，都是写了一个Print函数

那我们能不能使用C++标准库中的cout与cin输出呢？

很显然，正常情况下是不可以的。

对于内置类型我们可以直接使用是因为C++标准库中已经写好了，流插入与流提取也是函数重载。

int i = 10;cout << i;//上面的代码本质上转换为下面的cout.operator<<(i);

cout与cin可以自动识别类型，本质上是因为这些流插入重载构成函数重载。

那自定义类型要想写，那我们就得自己写函数重载，怎么写呢？如下：

此时我们发现依然无法调用，为什么呢？

如果我们自己调用，那就应该按下面的方式写。

你是我d1的成员函数嘛

void Test1(){ Date d1(2024, 5, 26);Date d2(1982, 6, 6);//cout << d1;//cout << d2;//自己写调用d1.operator<<(cout);d2.operator<<(cout);}

所以我们应该按下面的方式写：

这样写又非常的奇怪，那我们能不能让它的顺序颠倒一下呢？

所以，operator<<想重载为成员函数可以，但是用起来不符合正常逻辑，不建议这样做，建议重载为全局函数。

6.const成员函数

有时候我们需要把对象设置为只读的，但是这时候就会存在一些问题。

因此，我们的祖师爷就规定在函数的后面加const，看起来很怪，但确实也没有什么好的办法了

7.取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

class Date{ public:Date* operator&(){ return this;}const Date* operator&()const{ return this;}private:int _year; // 年int _month; // 月int _day; // 日};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！