【C++篇】类与对象（中篇） 解密C++类的核心：六大默认成员函数详解与避坑指南

---

前言

大家好呀，我是我想吃余😁！这次我们学习的内容非常非常重要🔑，如果本章内容懵懵懂懂的话，那么将导致你无法写出一个正确的类,更别说写一个C++程序了。因此，今天的内容务必理解透彻。
默认成员函数是C++的门槛，因为其内容较为抽象复杂，导致C++难学的名头流传至今😂。其实并没有这么夸张，根本不必畏惧，学完之后你会感觉：也就那回事！
翻过这座大山，我们将正式踏入C++的旅程🛫
本文共有9000余字（鬼知道我写了多久😪），干货满满。建议读者选择宽裕的时间学习哦🥰

---

一、类的六个默认成员函数

如果一个类中什么成员也没有，那么这个类称为空类

class Date 
{};

难道空类中什么都没有吗？
答案是NO！
当类什么都不写时，编译器会自动生成6个默认成员函数。

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

---

二、构造函数

在我们过去学习数据结构时，用C语言实现栈、队列、堆……都需要手动调用和定义初始化Init和销毁Destroy函数对数据进行初始化和清理。

如果每次创建对象时都调用该方法设置信息，未免有点麻烦了，那能否在对象创建时，就将信息设置进去呢？

有的兄弟有的！

1. 概念

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

2. 特性（牢记）

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

1. 函数名与类名相同
2. 无返回值（注意区分void，void也属于返回值）
3. 对象实例化时编译器自动调用对应的构造函数
4. 构造函数可以重载

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;}private:int _year;int _month;int _day;
};void TestDate()
{Date d1; // 调用无参构造函数Date d2(2015, 1, 1); // 调用带参的构造函数Date d3();//错误写法，编译器会报错// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
}

• 💡：关于Data d3（)，编译器将无法区分这是d3是对象还是函数名，导致冲突。

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

class Date
{public:/*// 如果用户显式定义了构造函数，编译器将不再生成Date(int year, int month, int day){_year = year;_month = month;_day = day;}*/void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};int main()
{
// 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
// 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成
// 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
Date d1;
return 0;
}

6. 无参的构造函数和全缺省的构造函数以及编译器自己生成的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

   • 💡：不要将无参构造函数和全缺省构造函数进行重载。它们虽然可以构成重载，但是在无参调用它们的时侯会产生歧义（编译器不知道要调用哪个，导致报错）

   //错误示例
   class Date
   {public:Date(){_year = 1900;_month = 1;_day = 1;}Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}private:int _year;int _month;int _day;
   };
   void Test()
   {Date d1;
   }
   

7. 编译器生成的默认构造函数存在局限：

   • 对于内置类型，不做初始化处理
   • 对于自定义类型，会去调用它的默认构造函数

内置类型：语言本身定义的基础类型，int/char/double/指针……

自定义类型：用户自己定义的类型，class/struct……

如果我们不写构造函数，编译器默认生成构造函数，内置类型不做处理，自定义类型会去调用它的默认构造函数。

💡：有些编译器也会处理，但这是个性化行为，其实这是违反C++标准规定的，但不是所有编译器都会去处理的。因此为确保我们程序的可移植性，我们一律视为编译器不做处理，自行解决。

后来，C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在
类中声明时可以给默认值。

class Time
{public:Time(){cout << "Time()" << endl;_hour = 0;_minute = 0;_second = 0;}private:int _hour;int _minute;int _second;
};
class Date
{private:// 基本类型(内置类型)int _year = 1970;int _month = 1;int _day = 1;// 自定义类型Time _t;
};int main(){Date d;return 0;
}

结论：
1. 一般情况下，构造函数都需要我们自己写
2. 不用写的特殊情况：

• 内置类型成员都用缺省值，且缺省值符合我们的初始化要求
• 所有成员都是自定义类型成员，且这些自定义类型都定义了默认构造函数。（可能有点晦涩，下面有详细的解释）

在我们实现栈的时候，是需要自己写构造函数的。但我们用栈实现队列时，这时候只需要用到两个栈（一个栈用来出队列，另一个用来入队列），符合“所有成员都是自定义类型成员”条件。但如果实现栈时没有写构造函数，那么这个队列自然会出错了，这里不符合“自定义类型都定义了默认构造函数”条件。

8. 构造函数调用顺序原则：⼀个局部域的多个对象，先定义的先调用构造

---

三、析构函数

通过构造函数的学习，现在我们知道一个对象怎么初始化的，那一个对象是怎么进行资源清理的呢？

1. 概念

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

2. 特性（牢记）

1. 析构函数名是在类名前加上字符~
2. 无参数无返回值类型
3. 应该类只有一个析构函数，不能重载。若未显示定义析构函数，编译器会自动生成默认析构函数。
4. 对象生命周期结束时，C++编译系统自动调用析构函数。

使用实例（栈）

~Stack()
{if (_array){free(_array);_array = NULL;_capacity = 0;_size = 0;}
}

5. 跟构造函数类似，我们不写编译器⾃动⽣成的析构函数

• 内置类型成员不做处理
• ⾃定类型成员会调⽤他的析构函数。

class Time
{public:~Time(){cout << "~Time()" << endl;}private:int _hour;int _minute;int _second;
};
class Date
{private:// 基本类型(内置类型)int _year = 1970;int _month = 1;int _day = 1;// 自定义类型Time _t;
};
int main()
{Date d;return 0;
}

程序运行结束后输出：~Time()，说明调用了Time类的析构函数。
我们根本没有直接去创建Time类的对象呀，为什么还会调用它的析构函数呢？

我们来逐步分析代码：
我们创建了Date类的对象d，而d中有4个成员变量。
其中_year、 _month、_day是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；
而_t是Time类对象 ，d销毁时，要将其内部包含的Time类的_t对象销毁，所以会调用Time类的析构函数。

注意：main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数，默认析构函数再调用Time类析构函数。

💡：创建那个对则调用该类的构造函数，销毁哪个类的对象则调用该类的析构函数

6. 一般情况下，有动态申请资源，就需要自己写析构函数释放资源。
   不需要写的两种情况：

• 没有动态申请的资源，不需要写析构函数
• 需要释放资源的成员都是自定义类型，不需要写析构函数

实现Stack类时，需要动态申请内存，需要写；

class Stack
{private:STDataType* _a;size_t _capacity;size_t _top;
};

实现Date类时，成员都是内置类型，没有动态申请资源，不需要写；

class Date
{private:int _year;int _month;int _day;
};

实现MyQueue类（两个栈实现队列）时，需要释放资源的成员都是自定义类型，不需要写。

// 两个Stack实现队列
class MyQueue
{private:Stack pushst;Stack popst;
};

7. 析构函数调用顺序原则：⼀个局部域的多个对象，规定后定义的先析构

与构造相反，可以反着来记。

本质上是看对象的生命周期，哪个对象的生命周期先结束哪个对象就先调用析构。

生命周期要看作用域，出作用域了，生命周期就结束了。
💡：全局变量和静态变量在程序结束后生命周期才结束，可以将它们看作在同一作用域中。

---

四、拷贝构造函数

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

1. 概念

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

2. 特性（牢记）

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

所以函数名也与类名相同且也无返回值

2. 拷贝构造的参数只有一个且必须是类类型对象的引用。如果使用传值，编译其会报错（引发无穷递归）。

为什么会发生无穷递归呢？

我们来深入探索👁：

C++的拷贝规定：

• 内置类型直接拷贝
• 自定义类型必须调用拷贝构造函数完成拷贝。

我们都知道，函数的传值其实就是拷贝，而类是自定义类型，想要传值就要进行拷贝，想要拷贝就需要调用拷贝构造，拷贝构造又要传值，传值就要拷贝构造，拷贝构造就要传值，传值就要拷贝构造，拷贝构造就要传值，传值就要拷贝构造…… 发生无穷递归。

💡：拷贝构造函数的参数一定要用引用，千万不能用传值

class Date
{public:Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}// Date(const Date& d)   // 正确写法Date(const Date d)   // 错误写法：编译报错，会引发无穷递归{_year = d._year;_month = d._month;_day = d._day;}private:int _year;int _month;int _day;
};
int main()
{Date d1;Date d2(d1);return 0;
}

另外参数最好用是const修饰，目的是为了防止出错，因为总是会有小可爱会写反🤐：

Date(const Date& d)   {d._year = _year;d._month = _month;d._day = _day;}

用上const编译器就会提醒你啦！！！

3. 如果没有显示定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储的字节序完成值拷贝，又称浅拷贝。

在编译器生成的默认拷贝构造函数中：

• 内置类型是按照字节方式直接拷贝的（浅拷贝/值拷贝）
• 自定义类型是调用其拷贝构造函数完成拷贝的（深拷贝）

深拷贝以后我会讲解，这里只需要知道：它会另外开辟一块空间，将其拷贝到这块空间。

4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？

• 类中如果没有涉及资源申请时，拷贝构造函数是否写都可以
• 涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝

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

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

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

💡：为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。

---

五、赋值运算符重载

1. 运算符重载

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

书写方式：
返回值类型 operator操作符(参数列表)

operator是关键字

💡：操作符是几个操作数，重载函数就有几个参数

• 必须用运算符的操作符，不能用其他的符号，如operator$
• 作为类成员函数重载时，其形参表面看起来比操作数数目少1，因为参数隐藏了一个this。
• .*、::、sizeof、?:、.，这5个运算符不能重载，这个在笔试选择题会考

2. 赋值运算符重载

1. 格式

• 参数类型：const T&
  传递引用可以提高传参效率和防止无穷递归
• 返回值类型：T&
  返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
• 检测是否自己给自己赋值
• 返回*this

还是以Date为例：

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)
{if(this != &d)//检测是否自己给自己赋值{_year = d._year;_month = d._month;_day = d._day;}return *this;
}
private:int _year ;int _month ;int _day ;
};

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

《C++ prime》第五版:

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

3. 默认生成的赋值重载和拷贝构造的行为一样：

• 内置类型成员——值拷贝/浅拷贝
• 自定义类型成员会去调用它的赋值重载

与拷贝构造类似：

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

前置++和后置++重载

1. 前置++：返回+=1后的返回值，对象也+=1了
2. 后置++：返回原对象的返回值，对象+=1
   前置++和后置++都是一元运算符，所以两个函数都不需要参数，那么如何构成函数重载呢？
   C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递

Date operator++(int)

💡：这个int没有任何含义，仅仅只是为了构成函数重载

代码实现：

class Date
{
public:Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}// 前置++：返回+1之后的结果// 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率Date& operator++(){_day += 1;return *this;}
// 后置++：
// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1
//而temp是临时对象，因此只能以值的方式返回，不能返回引用Date operator++(int){Date temp(*this);_day += 1;return temp;}
private:int _year;int _month;int _day;
};
int main()
{Date d;Date d1(2022, 1, 13);d = d1++;    // d: 2022,1,13   d1:2022,1,14d = ++d1;    // d: 2022,1,15   d1:2022,1,15return 0;
}

---

六、const成员函数

先来看一段代码：

class Date
{
public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}void Print(){cout << "Print()" << endl;cout << "year:" << _year << endl;cout << "month:" << _month << endl;cout << "day:" << _day << endl << endl;}
private:int _year; // 年int _month; // 月int _day; // 日
};
void Test()
{Date d1(2022,1,13);d1.Print();const Date d2(2022,1,13);d2.Print();
}

咦？怎么报错了呢？

d1.Print()是肯定没问题的，因为我们之前一直都这样用，那问题一定在d2调用Print了。

问题锁定位置后，我们来看看d2.Print()的传参情况：

• 实参为&d2;
• 形参为 Date* this.

然而，d2的类型是const Date，这不是妥妥的权限放大嘛！（const Date -> Date）

这就导致了我们不能用const的对象调用成员函数，那么有什么方法可以解决这个问题呢？

有的兄弟有的

我们只需要改变this指针的参数类型就可以了:
Date* this -> const Date* this

但this指针是隐藏，该如何修改呢？

为此C++引出了const成员函数：

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

在成员函数的后面加上const

💡：声明和定义都需要加const

这样一来，无论是cons对象还是非const对象都可以随意调用成员函数了。

那能不能所有成员函数都要加const呢?

NO!

要修改对象成员变量的函数不能加const！！！
否则编译器会报错。

💡：只要成员函数内部不修改成员变量，都应该加const，这样一来const对象和普通对象都可以调用这些成员函数

---

七、取地址及const取地址操作符重载

这两个默认成员函数一般无需自己定义，编译器会默认生成。

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

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

💡：这两个默认成员函数了解即可，一般不用我们自己实现。

---

希望这篇文章对你有帮助♥