✨个人主页： Yohifo

🎉所属专栏： C++修行之路

🎊每篇一句： 图片来源

I do not believe in taking the right decision. I take a decision and make it right.

我不相信什么正确的决定。我都是先做决定，然后把事情做好。

📘前言

祖师爷在设计 C++ 中的类时，规定每个类中都有六个默认成员函数，即使我们不主动写，编译器也会自动生成，这些成员函数就是神秘的天选之子，不仅神秘，而且还很强大，可以这么说：类和对象的是否学懂，取决于对这几个天选之子的理解程度。本文将会逐一介绍这几个默认成员函数，跟随我的脚步，一起揭开他们的神秘面纱

注意：以上函数都需要加上 “默认” 前缀，因为编译器自动生成并调用的是默认成员函数

📘正文

📖默认成员函数

祖师爷规定，每个类中都必须有这六个默认成员函数：

默认构造函数 重要

默认析构函数 重要

默认拷贝构造函数 较重要

默认赋值重载函数 较重要

默认取地址重载函数 一般

默认const取地址重载函数 一般

虽说都是祖师爷钦定的天选之子，但最后两个相对来说比较简单，因此介绍也会比较少

默认成员函数规则比较多，尤其是构造和析构，当初祖师爷在设计的时候，部分地方设计欠佳，导致后人在学习 C++ 时，额外增加了不少学习成本

下面就来看看祖师爷是如何设计的、出了什么问题、以及是怎么解决的

📖构造函数

构造函数是祖师爷首先钦定的天选之子

构造函数诞生的目的是为了减少频繁手动初始化的问题，将初始化这个事情变成自动化处理

将C语言和C++都看作车辆，初始化操作看作换挡，可以这样认为：

C语言依赖于手动操作，就像手动挡车辆，有驾驶乐趣，但比较麻烦

C++面向对象自动操作，就像自动挡车辆，上手简单，驾驶难度低

我们是可以自己编写构造函数的，祖师爷给了我们这个权力，他钦定的天选之子是默认构造函数，由编译器自动生成，并供类默认调用的，下面来看看编写构造函数的规则

本文介绍的函数都属于特殊函数，规则和普通函数不同

构造函数创建规则：

函数名和类名相同

不需要返回值，甚至连 void 都不需要写

对象实例化时，编译器自动调用默认构造函数

构造函数支持重载，即可以存在多个构造函数，但默认构造函数只能有一个

构造函数还有一种特殊形式：默认构造函数

语法规定，不带参数或参数为全缺省的构造函数称为默认构造函数

默认构造函数有两种写法，推荐全缺省参数的形式

class Date
{
public:
  //特别注意：默认构造函数只允许存在一个形式
  //一般推荐使用形式二：全缺省参数
  //因为这样方便后续初始化时指定值
  默认构造函数形式一：不带参数
  //Date()
  //{
  //  _year = 1970;
  //  _month = 1;
  //  _day = 1;
  //}
  //默认构造函数形式二：参数为全缺省
  Date(int year = 1970, int month = 1, int day = 1)
  {
  _year = year;
  _month = month;
  _day = day;
  cout << "Date(int year = 1970, int month = 1, int day = 1)" << endl;
  }
  //其他普通构造函数，只要与默认构造函数构成重载，都合法
  Date(double b)
  {
  _year = 2023;
  _month = 2;
  _day = 9;
  cout << "Date(double b)" << endl;
  }
  //……
private:
  int _year;
  int _month;
  int _day;
};

严格来说，现阶段的初始化方式不规范，此时为赋值

正确的初始化方式是使用初始化列表，当然这个东西在下篇介绍

出自 《Effective C++》

当构造函数写好后，我们就可以这样使用：

int main()
{
  //调用默认构造函数，d1 初始化为1970 1 1
  Date d1;  //相当于 Date d1(); 但不能这样写
  //因为调用的是全缺省参数的默认构造函数，我们也可以传参数
  //Date d1(2001, 1, 1);  //这种初始化也是合法的
  //调用自定义构造函数
  Date d2(1.1);
  return 0;
}

构造函数允许重载，因此调用不会冲突，运行结果如下：

🖋️默认构造函数

如果我们没写默认构造函数， 就会由编译器自动生成，这是祖师爷制定的规则；假如我们写了，同时也满足默认构造函数的需求，编译器就会以我们写的为准，并转而调用我们写的默认构造函数

注：默认构造函数就是调用时，不需要传参的构造函数

默认构造函数形式一：不带参数

//Date()
  //{
  //  _year = 1970;
  //  _month = 1;
  //  _day = 1;
  //}
  //默认构造函数形式二：参数为全缺省
  Date(int year = 1970, int month = 1, int day = 1)
  {
  _year = year;
  _month = month;
  _day = day;
  cout << "Date(int year = 1970, int month = 1, int day = 1)" << endl;
  }

这里暂时无法给大家演示编译器自动生成并调用的现象

因为祖师爷在设计默认构造函数时，埋下了一个坑：

默认构造函数不对内置数据类型做处理，如 int 、double、char等

至于自定义类型，默认构造函数会去调用属于它们的初始化函数(默认构造函数)

注意：数据类型主要分为两类 <内置类型和自定义类型>

简言之：默认构造函数有点像不干实事的函数

假设我们的类中只有内置类型，那么默认构造函数真就什么都没有做；出现自定义类型时，也只会主动去调用它的默认构造函数，至于自定义类型的默认构造函数干了什么，类的默认构造函数是不管的

因祖师爷设计疏忽而留下的坑，为后世学习C++增加了阻力

这么看来，这个天选之子似乎没有什么用，默认构造函数还得我们自己编写

不过在有些场景下，默认构造函数很有用

题目：用栈实现队列

需要在队列这个类中，调用两个栈类，实现队列类

此时我们只需要写好栈的默认构造函数

队列类的默认构造函数不需要写，因为自动生成的会去调用自定义类型的默认构造函数，即栈的默认构造函数，显然是存在的

为了解决祖师爷留下来的坑，委员会在C++11标准中新增了一个补丁声明时给缺省值

🖋️新增补丁

这个补丁是新标准中的，可能部分老编译器不支持

具体操作很简单：在成员变量声明时，将内置类型给上缺省值，调用编译器生成的默认构造函数时，就会以这些缺省值来初始化成员变量，达到初始化的效果

注意：此时给的是缺省值，并非在声明阶段赋值，类中成员变量为声明阶段

class Date
{
private:
  int _year = 2023; //在内置类型声明时给上缺省值
  int _month = 2; //这样即使调用生成的默认构造函数
  int _day = 9; //也能达到初始化的效果
};

了补丁辅助我们后，就可以看看编译器是否调用了默认构造函数

在打了补丁的情况下，实例化一个对象，可以看到效果如下：

C++11中的补丁可以解决内置类型不初始化这个问题，但相对来说，全缺省参数形式的默认构造函数更加实用，不仅能初始化，还能指定初始化值

注意：这个补丁是为内置类型准备的，对于自定义类型，默认构造函数会去调用属于它的默认构造函数

在涉及开辟空间的初始化行为时，可以先给 nullptr，再到默认构造函数体内开辟空间

📖析构函数

析构函数就是另一个天选之子了

构造函数： 解决频繁初始化操作

析构函数： 解决频繁销毁操作

不难看出，这是两兄弟，一个负责做菜，一个负责洗碗

此时仍然是手动挡和自动挡的区别

析构函数和构造函数师出同门，规则也都差不多

析构函数创建规则：

函数名在类名的前面加上~

也没有返回值，连 void 都不需要写

对象声明周期结束时，编译器会自动调用默认析构函数

析构函数不支持重载，毕竟不能对同一个对象销毁多次

析构函数也有一种特殊形式：默认析构函数

不过因为析构函数不支持重载，所以默认与否已经不重要了，如果我们写了，编译器就用我们写的默认析构函数，否则就用编译器自动生成的

默认析构函数也存在默认构造函数的坑：对内置类型不作处理

🖋️默认析构函数

如果我们没写，编译器会自动生成默认析构函数，假如我们写了，编译器就会用我们写的

注：默认析构函数是在对象生命周期结束时自动调用

class Date
{
public:
  //析构函数写法比较特殊，需要多加注意
  ~Date()
  {
  //假设动态开辟了空间
  //是需要在析构函数中释放的
  _year = _month = _day = 0;
  }
private:
  int _year = 2023;
  int _month = 2;
  int _day = 9;
};

同默认构造函数一样，默认析构函数对内置类型也不处理，对自定义类型，会去调用属于它的默认构造函数

默认构造函数不难写，普通自定义类型是否释放问题不大，但涉及动态内存开辟时，如果不释放内存，就会发生内存泄漏问题，因此当我们的对象涉及动态内存开辟时，需要自己编写默认析构函数，确保安全问题。

~Test()
{
  //假设 pa 为动态开辟的空间
  //需要释放
  free(pa);
  pa = nullptr;
}

📖拷贝构造函数

拷贝构造函数 算是 构造函数 的远房亲戚，因为它们的函数名一样，不过参数不同，构成重载

对于内置类型，我们可以通过 = 完成拷贝，对于自定义类型，规则较多，拷贝需要我们自己完成，因此拷贝构造函数应运而生

为何自定义类型不能直接赋值？

因为自定义类型种类繁多，比如栈、队列、树、图，数据结构很复杂，尤其是涉及空间开辟问题时，不能简单通过指针赋值完成拷贝，这样会导致重复析构问题；正确做法是 开辟空间->拷贝数据->更新指向->完成拷贝

int a = 10;
int b = a;  //内置类型，简单拷贝(赋值)

造函数实现也很简单：

class Date
{
public:
  //拷贝构造函数，此时是简单拷贝，只能用于非动态内存开辟的空间
  //拷贝构造函数函数名与构造函数相同，不过参数类型为类
  Date(const Date& d)
  {
  //d 拷贝给 *this
  _year = d._year;
  _month = d._month;
  _day = d._day;
  }
private:
  int _year = 2023;
  int _month = 2;
  int _day = 9;
};

使用时有以下两种用法：

Date d1;  //将 d1 拷贝给 d2 和 d3
Date d2(d1);  //法一
Date d3 = d1; //法二

既然是天选之子之一，编译器也会生成默认拷贝构造函数

🖋️默认拷贝构造函数

默认拷贝构造函数 是个懂事的函数，对于内置类型，它不再持有偏见，也就是说默认拷贝构造函数能完成简单内置类型的拷贝操作

正常情况下，即成员变量不涉及空间开辟时，拷贝构造函数 没有必要写，用编译器自动生成的足够了

对于涉及空间开辟的，一定要写默认拷贝构造函数

class SeqList
{
public:
  //现在编写一个涉及空间开辟的拷贝构造函数
  SeqList(const SeqList& tmp)
  {
  _pa = (int*)malloc(sizeof(int) * _capacity);
  if (nullptr == _pa)
  {
    cout << "malloc fail" << endl;
    exit(-1); //失败，直接退出程序
  }
  //将 tmp 空间中的值，拷贝到 *this 中
  memcpy(_pa, tmp._pa, sizeof(int) * _size);
  _size = tmp._size;
  _capacity = tmp._capacity;
  }
private:
  int* _pa = nullptr;
  int _size = 0;
  int _capacity = 4;  //动态顺序表
};

默认拷贝构造函数实现比较简单，但有一个值得注意的大问题：无穷递归

🖋️无穷递归

所谓无穷递归问题就是指设计拷贝构造函数时，参数没有设为引用

如下所示：

SeqList(SeqList tmp)
{
  //此时必然会引发无穷递归问题
  //……
}

问题出现原因：值传递，需要先生成临时变量，再传递，而生成临时变量这个行为本身就是在调用拷贝构造函数

也就是说：此时我们在实现拷贝构造函数，但参数又需要拷贝构造函数 这让编译器很难堪

大力士无法举起自己，光靠金针菇也无法完成卡Bug行为

解决方法：因为待拷贝对象本来就已经存在，此时可以使用引用，避免产生临时变量，再加以 const 修饰，保护待拷贝对象

因此正确的拷贝构造函数应该这样写：

SeqList(const SeqList& tmp)
{
  //有效避免无穷递归问题
  //……
}

🖋️浅拷贝

浅拷贝 就是简单的逐字节序拷贝

浅拷贝可能出现空间共用的情况

浅拷贝可能引发对同一块空间的重复析构问题

浅拷贝不可取，尤其是在面对复杂数据结构时

🖋️深拷贝

深拷贝需要我们自己实现

深拷贝 在面对空间问题时，会先给 对象2 开辟一块同样大的空间，再将 对象1 空间中的数据拷贝过来

深拷贝中，两个对象的空间是独立的、互不干扰的

深拷贝才是众望所归

当成员涉及复杂数据结构、空间开辟时，就需要写出默认拷贝构造函数

🖋️小结

构造函数家族至此就介绍完成了，简单小结一下：

何时需要自己写默认析构函数？

当我们写出默认拷贝函数完成复杂对象的拷贝时，就证明需要默认析构函数来释放对象

小技巧：

在函数传参与返回时，如果对象生命周期足够长，就可以考虑使用引用的方式，避免参数走拷贝构造->生成临时变量->再传递的路线，提高程序运行效率

特别注意： 默认拷贝构造函数与默认构造函数名相同，当我们只写拷贝而不写构造时，编译器就会报错，因为此时的拷贝会被误以为是默认构造函数

也就是说，默认拷贝构造函数存在的前提是默认构造函数已存在

📖运算符重载

C++支持运算符重载，运算符重载使得自定义类型间的符号运算变成可能

比如：

int a = 1;
int b = 2;
a - b;  //合法
Date d1;
Date d2;
d1 - d2;  //非法，此时需要通过运算符重载解决这个问题
//解决方法如下
const Date operator-(const Date& d)
{
  //简单演示，逻辑存在问题，可以忽略
  Date tmp(*this);  //调用拷贝构造
  tmp._year -= d._year; //内置类型，可以正常相减
  tmp._month -= d._month; //同理
  tmp._day -= d._day; //同上
  return tmp; //tmp 为临时变量，不能传引用返回
}

此时就可以正常使用 d1 - d2 了

注：运算符重载和函数重载没有关系

🖋️operator操作符

operator 译为运算符，是C++中新的关键字，operator 的作用很简单，实现自定义类型的运算

使用规则：

operator 函数中的操作数取决于参数个数

operator 一般写在类中，方便通过 this 指针访问成员变量

写在类中时，this 指针就算一个隐藏参数

operator也可以写在类外，此时会发生无法访问成员变量问题，可以这样解决：

将成员变量设为 public （不安全）

通过函数获取类中的成员变量值 （麻烦）

设置为友元函数（也比较麻烦）

写在类中，最简单、省事，而且还可以使用 this 指针

运算符重载是这样用的：

int main()
{
  //注：此时只是演示，日期类的减法不能这样写
  Date d1(2023, 2, 9);
  Date d2(2022, 2, 9);
  Date d3 = (d1 - d2);  //结果为 1 0 0
  //此时的调用相当于 d1.operator-(d2) 
  //d1 作为 this 对象传递
  //也可以这样使用
  Date d4 = operator-(d1, d2);
  return 0;
}

基于运算符重载，我们可以干很多事情，比如直接通过 [] 访问类中的成员，实现两个对象的快速运算等操作

🖋️使用注意

operator 虽然很好，但也有很多使用规则：

operator 操作符就是函数名

不能与非操作符链接

参数中必须有一个自定义类型

对于内置运算符，不能改变其含义

成员函数的第一个参数为 this

有五个运算符不支持重载：

.* 稀有运算符，很少见

:: 域作用限定符

sizeof 操作符

? : 三目运算符

. 访问成员符

为何运算符能实现重载？

跟函数重载同理，保证函数修饰名不同，构成重载

下面是我测试出的部分运算符重载修饰规则：

基于运算符重载，我们可以介绍第四个天选之子：赋值重载函数

📖赋值重载函数

赋值重载函数的实现原理就是运算符重载

此时重载的运算符是 =

赋值重载的目的：将 d1 对象赋值给 d2，非拷贝构造，d1、d2均已存在

class Date
{
public:
  //赋值重载函数
  Date& operator=(const Date& d)
  {
  //能用引用的地方，就用引用
  //避免去走拷贝构造函数
  //如果传入的是两个相同值，没必要再执行赋值
  if (this == &d)
  {
    return *this;
  }
  _year = d._year;
  _month = d._month;
  _day = d._day;
  //返回赋值完成的值，即 *this
  return *this;
  }
private:
  int _year = 2023;
  int _month = 2;
  int _day = 9;
};

为何传引用？

两个对象都已存在，使用引用，提高效率

为何判断相同？

避免资源浪费，当类的成员变量很多时，假如出现 d1 = d1 = d1 这种情况时，可以有效避免资源浪费

为何返回 *this ？

因为可能出现重复赋值的情况，如 d1 = d2 = d3

赋值重载函数不难实现，只是需要注意的地方很多

🖋️默认赋值重载函数

祖师爷在实现默认赋值重载函数时，实现的几乎已经很好了，无论是内置类型还是自定义类型，都会处理

不过默认赋值重载函数仍然是基于字节序的浅赋值，在面对空间开辟时，仍然需要我们自己编写深度赋值重载函数，否则就会发生重复析构问题

🖋️深度赋值

深度赋值的实现和深拷贝几乎一模一样，这里就不加以赘述

一但对象中涉及动态内存开辟，必须自己实现深度拷贝

🖋️注意事项

拷贝构造 和 赋值重载存在本质区别，一个是对象尚未实例化，另一个是两个对象都已存在

当两个对象都被创建，并发生赋值行为时，才叫做赋值重载

Date d1;
Date d2(d1);  //拷贝构造，d2 未存在
Date d3 = (d1 - d2);  //赋值重载，d1、d2 已存在

涉及空间资源管理时，必须实现深度拷贝

设计赋值重载函数时，充分利用引用，提高效率

📖const修饰

const 修饰可以提高程序的健壮性

const 常被用来修饰引用、指针

当被指向对象为常量或临时变量时，必须使用 const 修饰，避免出现权限放大问题

//int* pa = 10; //错误，10 具有常性
const int* pa = (const int*)10; //成功，此时 pa 为常量指针
//int& pb = 20; //错误，20 具有常性
const int& pb = 20; //成功引用，此时 pb = 20

const 一般用来修饰指针参数或引用参数，确保参数在使用过程中不被修改

🖋️修饰*this

引入：两个日期 d1、d2，d1 - d2 时，d1 需要被修改，但 d2 不能被修改，因此实现 operator- 时，参数 d 为 const Date& 类型

我们在实现函数时，存在这种情况 确保 *this 不被修改，即 this 指针指向内容不被修改

this 指针太危险了，如果不加以保护的话，可能实现者的不经意行为会导致严重的后果

class Date
{
public:
  //实现简单的打印函数
  void Print()
  { 
  cout << _year << "年";
  cout << _month << "月";
  cout << _day << "日";
  cout << endl
  //有可能不小心出现这样的情况
  _year = _month = _day;
  //此时该对象就危险了，成员变量全被改了
  }
private:
  int _year = 2023;
  int _month = 2;
  int _day = 9;
};

this 指针给了我们足够的自由，我们在使用时也应该尊重它

class Date
{
public:
  //实现简单的打印函数
  //原指针类型为 Date* const ，只允许指向对象
  //修改指针类型为 const Date* const 双重保护
  void Print() const
  { 
  cout << _year << "年";
  cout << _month << "月";
  cout << _day << "日";
  cout << endl
  //有可能不小心出现这样的情况
  _year = _month = _day;  //此时会报错，因为 this 指针类型为 const Date* const
  //此时该对象就危险了，成员变量全被改了
  }
private:
  int _year = 2023;
  int _month = 2;
  int _day = 9;
};

除了上述情况外，还可能存在这种情况：

const Date d1;
//此时 d1 具有常性，普通的 this 指针无法调动，需要使用 const 指针
1

2

总之，const可以修饰this指针，起到保护和权限平移交接的效果

📖取地址重载函数

接下来简单介绍一下剩下两个天选之子

取地址重载函数

获取当前对象的地址

class Date
{
public:
  Date* operator&()
  {
  return this;
  }
private:
  int _year = 2023;
  int _month = 2;
  int _day = 9;
};

📖const修饰的取地址重载函数

const修饰的取地址重载函数

获取 const 修饰对象的地址

class Date
{
public:
  const Date* operator&() const
  {
  return this;
  }
private:
  int _year = 2023;
  int _month = 2;
  int _day = 9;
};

这两个默认成员函数都很简单，使用编译器默认生成的就够了，除非我们不想让别人获取到当前地址，直接手动设置，每次都返回 nullptr ，当然这种情况几乎不存在

开发者何必为难开发者

📘总结

以上就是关于 类和对象（中） 的全部内容了，本文主要侧重点为 六大天选之子，以及编译器自动生成的默认成员函数，何时用编译器的、何时用我们自己写的，都是有讲究的，部分成员函数规则多、实现麻烦，需要多加练习以加深理解。这里推荐日期类的实现练习，能让我们对类和对象有一个更深层次的理解，关于日期类的实现，我将会在下篇文章中介绍，敬请期待！

如果你觉得本文写的还不错的话，期待留下一个小小的赞👍，你的支持是我分享的最大动力！

如果本文有不足或错误的地方，随时欢迎指出，我会在第一时间改正