【C++初阶】类和对象(二)

​

​📝个人主页：@Sherry的成长之路
🏠学习社区：Sherry的成长之路（个人社区）
📖专栏链接：C++初阶
🎯长路漫漫浩浩，万事皆有期待

上一篇博客：【C++初阶】类和对象(一)

1.类的六个默认成员函数

我们讲过，当类中一个成员没有时，则为空类。

但是空类中真的什么都没有吗？其实并不是，任何一个类在我们不写任何成员的情况下，都会生成如下 六个默认成员函数 ：

它们是特殊的成员函数：如果自己没有实现，编译器会自己生成，不一定效果最佳，但有一定价值。

它们的作用很强大，比如写 C 语言时，写一个栈，可能快速写完后，忘记了初始化和销毁，不是崩溃就是内存泄漏。C++ 针对这种情况设计了构造函数（初始化）和析构函数（清理）

同理，其他成员函数也都是根据场景设计，弥补 C 中的不足。

2.构造函数

就拿日期类来说：

class Date
{
private:int _year;int _month;int _day;public:void Init(int year, int month, int day){_year = year;_month = month;_day = day;}void Print(){cout << _year << '-' << _month << '-' << _day << endl;}
};

并没有写构造函数，那么这个日期类存在构造函数吗？ 存在。

2.1 概念

对于Date类，可以通过 Init 成员函数给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？当然可以，就是用构造函数。

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

class Date
{
public:Date(){_year = 0;_month = 1;_day = 1;}Date(int year, int month, int day){_year = year;_month = month;_day = day;}private:int _year;int _month;int _day;
};int main()
{Date d1; // 自动调用第一个构造函数Date d2(2023, 1, 31); // 传参调用第二个构造函数return 0;
}

构造函数名称和类名相同，为 Date ，函数无返回值。

构造函数会自动调用；若需要主动调用，只要 Date() 即可，括号中为参数。

d1 被自动调用，d2 主动调用，两者都初始化完毕；它们互不冲突，且构成函数重载 。而两个函数其实有些繁琐，根据 缺省参数 的特性，我们发现其实这两个函数可以合并成一个函数：

Date(int year = 0, int month = 1, int day = 1)
{_year = year;_month = month;_day = day;
}// 调用
Date d1;
Date d2(2023, 1);
Date d3(2023, 1, 31);

使用全缺省参数，使调用更加多样。但是使用这种实现方式，须注意二义性 ，例如这里再写一份无参的构造函数 Date() ，就会造成二义性，语法能编译通过，但是调用不知道调用哪一个。

2.2 特性

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

基本特征 如下：

1.函数名与类名相同。
2.无返回值。
3.对象 实例化 时编译器 自动调用 对应的构造函数。
4.构造函数可以重载。
5.如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数；一旦用户显式定义，编译器将不再生成默认无参构造函数
6.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个（无参构造函数、全缺省构造函数、没写编译器默认生成的构造函数，都可以认为是默认构造函数）

编译器默认生成的构造函数为空函数。C++ 中把类型分为两类
1.内置类型（基本类型：int/char/double/内置类型数组）
2.自定义类型（struct/class/联合定义的类型）。

当我们不写构造函数时，对于内置类型不做初始化处理，对于自定义类型会调用它自动生成的默认构造函数（不用参数时调用）构造初始化（先对成员进行构造，再对整体进行构造）。但是如果没有默认构造函数就报错。

默认构造函数：全缺省构造函数或者无参构造函数

编译器自动生成的构造函数机制：
 1、编译器自动生成的构造函数对内置类型不做处理。
 2、对于自定义类型，编译器会再去调用它们自己的默认构造函数。

总结：虽然在我们不写的情况下，编译器会自动生成构造函数，但是编译器自动生成的构造函数可能达不到我们想要的效果，所以大多数情况下都需要我们自己写构造函数。

若用户定义了构造函数，则编译器不生成默认无参构造函数，若调用方式错误，则会报错

去掉无参构造 ：

总结：C++ 中编译器默认生成构造函数，但没有对内置类型与自定义类型统一处理（不处理内置类型成员变量，只处理自定义类型成员变量）

所以在 C++ 11 时，对于内置类型打了一个补丁：内置类型成员变量在类中声明时可以给默认值（缺省值）

一般情况下，构造函数都需要我们自己写，但以下两种情况，可以不用：
a.内置类型成员都有缺省值，且初始化符合我们的要求

b.全是自定义类型的构造，且都定义默认构造

3.析构函数

通过前面构造函数的学习，我们知道一个对象是怎么初始化的，那一个对象又是怎么清理的？

3.1 概念

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

3.2 特性

析构函数的函数名是在类名前加上字符 ~ ，例如基于 Date 类写一个析构函数：

~Date()
{// Date 类没有资源需要清理，所以当前 Date 类不写析构函数都可以cout << "~Date()" << endl;
}

析构函数无参、无返回类型，因此，析构函数 不构成函数重载 ，因为函数无参，所以一个类只能有一个析构函数 。

虽然 Date 类不需要析构函数，但是有的情景下就需要，比如 Stack（栈），我们简单写一个栈类：

class Stack
{
public:Stack(int capacity = 4) // 构造函数，缺省1参数，不传参默认给 4{_a = (int*)malloc(sizeof(int) * capacity);if (_a = nullptr){cout << "malloc fail" << endl;exit(-1);}_top = 0;_capacity = capacity;}private:int* _a;size_t _top;size_t _capacity;
};int main()
{Stack s1;Stack s2;return 0;
}

对于栈来说，就需要析构函数，因为对于 s1, s2 为 main 中局部变量，但是它们指向的空间是 malloc 动态开辟的，所以必须释放，否则会造成内存泄漏。

必须写出析构函数 ：

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

通过析构函数来完成栈的销毁，而当局部变量出作用域时，系统会自动调用析构函数

我们知道构造是 d1 先构造，再构造d2 ，但是析构的顺序呢？对于在栈帧中的对象，因为 d1 先压栈，d2 再压栈，所以会先出 d2 ，就先对 d2 进行析构，它们的析构顺序与构造顺序是相反的

若没有定义析构函数，则编译器会自动生成，但是自动生成的析构函数会干什么？它会销毁栈吗？ 并不会。

析构函数对于内置类型的成员变量不做处理，对于自定义类型会去调用它的析构函数

可能会疑惑，C++ 为什么多此一举搞自动生成析构函数，它又不对内置类型处理，有什么用呢？

假设拿栈来说，这个指针就是要被释放，置空；如果我一看到指针都释放，都默认用 free ，如果是 free 了不是动态开辟的指针，那就出事了，所以对内置类型不处理这时反而是保护程序。

而对于自定义类型的成员变量去调用它的析构函数是很有用的，就比如这题：232. 用栈实现队列。之前用 C 语言实现时，我们需要对其完成初始化，手动销毁，但是现在就不用了，我们完全可以通过构造函数和析构函数的特性来完成自动处理 ：

class Stack
{
public:Stack(int capacity = 4) // 构造{_a = (int*)malloc(sizeof(int) * capacity);if (_a = nullptr){cout << "malloc fail" << endl;exit(-1);}_top = 0;_capacity = capacity;}~Stack() // 析构{free(_a);_a = nullptr;_top = _capacity = 0;}
private:int* _a;size_t _top;size_t _capacity;
};class MyQueue
{
public:void push(int x) {}
private:Stack pushST;Stack popST;
};int main()
{MyQueue mq; // 自动调用构造和析构return 0;
}

这时对于自定义类型 mq ，就不用写了。因为对于默认生成的构造函数和析构函数，会自动调用它的构造和析构。这个自定义类型是 Stack ，于是就会自动调用，自动完成初始化和销毁。所以默认的析构函数也很有必要！

总结 ：

析构函数名是在类名前加上字符 ~
无参数无返回值类型
一个类只能有一个析构函数（无参不构成重载）; 若未显式定义，系统会自动生成默认的析构函数
对象生命周期结束时（局部变量出作用域），C++编译系统自动调用析构函数

4.拷贝构造函数

对于内置类型，编译器可以直接对数据完成拷贝；但是在对自定义类型进行拷贝时，编译器是不适合直接拷贝的，而这时可以使用拷贝构造函数。

4.1 概念

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

4.2 特性

拷贝构造函 数是特殊的成员函数 。它的名字也为类名，和构造函数构成函数重载，且必须使用传引用传参，使用传值传参会报错：

验证传值传参报错：

一定要加上引用才不会报错 ：

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

仔细观察拷贝构造函数传参的过程，重复出现 Date date(d1) ，在传参时，是不是无形中又调用了拷贝构造函数？

因为我们的 date 形参就是原对象 d1 ，而传参过来，则是一份和原先对象一模一样的对象，这个对象不存在，所以我们需要先进行拷贝构造，而拷贝构造到下一层也是相同的原理，就是在一直拷贝构造不存在的形参，从而形成死递归 。

但是使用引用传参就没事了，因为 date 此刻变为 d1 的别名，这时就不存在 拷贝对象不存在从而继续拷贝的情况 。此刻就可以顺利进入拷贝构造函数。

所以拷贝构造参数一定不能为传值，要传引用！我们也可以抽象出一个概念：自定义类型传值传参就是拷贝构造 。

而对于拷贝构造函数的参数，一般加 const 修饰 ，因为拷贝构造函数的功能可能会写反，比如：

Date(Date& d) // 拷贝构造函数
{d._year = _year; // 写反了d._month = _month;d._day = _day;
}

这时不仅没有拷贝构造成功，还把 d1 改了：

这就错误了，但是加上 const 修饰便会发现问题：

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

当 Date 类没有拷贝构造函数时，仍然按照字节序完成了值拷贝

但是对于 Stack 类就不行：

class Stack
{
public:Stack(int capacity = 4){_array = (int*)malloc(sizeof(int) * capacity);if (_array == nullptr){cout << "malloc fail" << endl;exit(-1);}_top = 0;_capacity = capacity;}void Push(const int& data) {_array[_top] = data;_top++;}~Stack(){free(_array);_array = nullptr;_top = _capacity = 0;}private:int* _array;size_t _top;size_t _capacity;
};int main()
{Stack st1;st1.Push(1);Stack st2(st1);return 0;
}

当我们进行操作时，程序奔溃了

因为 st1 和 st2 指向的同一块空间，释放了两次。

这里我们使用的默认拷贝构造就是编译器自动处理的，很明显这里不行。而如果要实现正确的拷贝构造，需要深拷贝。所谓深拷贝，就是让它们有独立的空间，就比如这里的 Stack ，就是让 _array 指向不同的空间，使得它们之间的操作互不影响，接下来，我们简单写一下深拷贝：

class Stack
{
public:Stack(int capacity = 4){_array = (int*)malloc(sizeof(int) * capacity);if (_array == nullptr){cout << "malloc fail" << endl;exit(-1);}_top = 0;_capacity = capacity;}Stack(const Stack& st){_array = (int*)malloc(sizeof(int) * st._capacity);if (_array == nullptr){cout << "malloc fail" << endl;exit(-1);}memcpy(_array, st._array, sizeof(st._array) * st._top); // 拷贝 st1 指向空间的值到 st2 指向的空间_top = st._top;_capacity = st._capacity;}void Push(const int& data){_array[_top] = data;_top++;}~Stack(){free(_array);_array = nullptr;_top = _capacity = 0;}private:int* _array;size_t _top;size_t _capacity;
};

这时就没有问题了，st1 和 st2 指向了不同的空间：

结论：当自己实现了析构函数释放空间，就需要实现拷贝构造（深拷贝），深拷贝我们之后会详细学习。可以理解为拷贝构造是为自定义类型的深拷贝而生的

如果此时使用浅拷贝，就会存在两个问题：1.析构函数释放空间两次，报错 2.一个修改值，另一个也会被影响

特性 ：

拷贝构造函数是 构造函数的一个重载形式 。
拷贝构造函数的参数只有一个且必须是类的类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按 字节序 完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
只要自定义构造函数或者拷贝构造函数，都不会生成构造函数，自定义类型成员会调用它的拷贝构造。

总结：拷贝构造当我们不写，生成的默认拷贝构造函数对于内置类型和自定义类型都会拷贝处理。但是处理细节与构造和析构是不一样的。

5.运算符重载

5.1 规则

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

class Date
{
public:Date(int year = 0, int month = 1, int day = 1){_year = year;_month = month;_day = day;}private:int _year;int _month;int _day;
};int main()
{Date d1(2023, 2, 3);Date d2(2023, 3, 4);return 0;
}

创建 d1 和 d2 两个对象，时间分别为 2023.2.3 和 2023.3.4 ，如何比较它们的天数的先后，或者是算它们中间相差的天数？

对于平常情况下，我们可以手算，但是对于计算机呢？如何直接用运算符来比较？可不可以直接比较它们的先后？可以不可以让 d2 的天数直接减去 d1 的天数？例如 d1 > d2 ，d2 - d1 ？

在 C++ 中，只支持对内置类型的运算符计算，并不支持直接对自定义类型进行运算符计算，但是通过运算符重载可以达到这个效果 。

运算符重载：

函数名字为：关键字operator后面接 需要重载的运算符符号
函数原型：返回值类型 operator 操作符(参数列表)

返回值与参数：

对于返回值：不同的运算符重载函数，返回值是不同的，例如 > 就是 bool 类型；- 就是 int 类型
对于参数操作数有几个操作符，就有几个操作数

对于一个比较大小运算符重载的参数需要注意几点：

bool operator>(const Date& d1, const Date& d2);

重载的是 > ，1.对于这个符号有两个操作数；2.参数写成引用的形式，减少空间的消耗；3.加上 const 修饰，也防止这两个对象由于引用的原因被修改。

接下来，我们写出这个运算符重载：

但是这迎来一个问题 ：运算符重载在类外部访问不到成员变量，这样就使得运算符重载不起作用了。那么我们就要相除解决方案。

方法 1（可以但不推荐）：

去掉 Date 类中成员变量的 private 的私有，我们先用了再说：

这时，调试，然后到 d1 < d2 ，f11 进入运算符重载，对于这边的调用有两种方式：

编译器看到自定义类型 d1 < d2 去找是否重载了运算符，如果找到了，就转换为 operator< (d1, d2) 调用函数，找不到就 报错

方法 2：

方法 1破坏了封装性，所以不太可行。所以可以写在类的里面 ，但是这里会有一个问题：

写成成员函数时，成员函数默认会有一个 this 指针，但是对于运算符重载的参数个数等于操作数个数，<有两个，现在就有三个了，所以错了。

例如如果直接调用 operaror< 函数时：

Date d1;
d1.operator<(d2);

d1 作为 this 指针被传过去，d2 被作为另一个参数，但是这里对于我们当前的函数来说，有三个参数：this, d1, d2 ，参数不匹配了！

所以需要修改：

bool operator>(const Date& d) 
{if (_year > d._year){return true;}else if (_year == d._year){if (_month > d._month){return true;}else if (_month == d._month){if (_day > d._day){return true;}}}return false;
}

这时 d1 > d2 ，会先去到类的成员里面找，找到了转换为 d1.operator>(d2)，若类中没找到，再到全局找，找到转换为 operator>(d1, d2) ，进行调用。

对于上面两种 operator> 全局的和类中的可以同时存在（参数不同构成重载），若同时存在，则调用类中成员的，和就近原则没什么关系，取决于编译器的实现机制；但是这种情况一般不存在，因为成员变量一般都是 private 私有的，全局的并没有用。

对于运算符重载的规则：

不能通过连接其他符号来创建新的操作符 ：比如operator@
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
.*(没用过，类似于访问解引用，重点记，选择题容易考) ::(作用域访问符) sizeof ?:(三目运算符) .(访问自定义类型) 注意以上5个运算符不能重载。经常在笔试选择题中出现。
返回值类型不一定是内置类型，例如 Date operate++() 返回值是日期
运算符重载的返回值必须写

赋值运算符在类中不显式实现时，编译器会生成一份默认的，此时用户在类外再将赋值运算符重载为全局的，就和编译器生成的默认赋值运算符冲突了，故赋值运算符只能重载成成员函数

5.2 赋值运算符重载

赋值运算符重载是对于两个已经存在对象之间的赋值拷贝，本质是一个运算符重载函数。

简单写一下：

// d1 = d3
void operator=(const Date& d)
{_year = d._year;_month = d._month;_day = d._day;
}

可以完成功能，但是不符合连续赋值的含义：例如 i = j = k = 10 ，是将 10 赋给 k ，k 赋给 j ，j 赋给 i ，最后赋值后的返回值没有变量接收，就把值丢弃，通过这种方式 完成连续赋值 。

但是下图呢？

由于 operator= 没有返回值，为void，这样就不可行了，所以需要修改 ：

// d1 = d3
Date operator=(const Date& d)
{_year = d._year;_month = d._month;_day = d._day;return *this;
}

根据上方的连续赋值规则，返回的应该是 左操作数 ，即 d1 ，也就是 this 指针指向的对象，即 *this ；但是对于 *this 的返回这里由于是传值返回，而 *this 指向的是一个对象，所以会调用拷贝构造函数

class Date
{
public:Date(int year = 0, int month = 1, int day = 1){_year = year;_month = month;_day = day;}Date(const Date& d){cout << "进行拷贝构造" << endl;}// d1 = d3Date operator=(const Date& d){_year = d._year;_month = d._month;_day = d._day;return *this; // 调用拷贝构造}private:int _year;int _month;int _day;
};int main()
{Date d1(2023, 2, 3);Date d2(2023, 3, 4);Date d3(2022, 2, 3);d3 = d2 = d1; // 两次赋值，共计两次拷贝构造return 0;
}

因此返回时，最好使用 引用返回 来提高返回效率，因为出作用域 *this 仍然存在，所以引用返回完全没问题。

// d1 = d3
Date& operator=(const Date& d)
{_year = d._year;_month = d._month;_day = d._day;return *this;
}

此刻不进行拷贝构造

但是还不是最终版本，因为可能会写错为 d1 = d1 ，自己给自己赋值 ，虽然代码并没有问题，但是浪费了赋值的过程，所以可以再加一个检查，形成最终版本 :

Date& operator=(const Date& d)
{if (this != &d) // this 和 d 的地址相等 {_year = d._year;_month = d._month;_day = d._day;}return *this;
}

总结一下赋值运算符重载格式 ：

参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this ：要符合连续赋值的含义
用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝

编译器默认生成的赋值重载，跟拷贝构造做的事情完全类似 ：

内置类型成员，会完成字节序1值拷贝（浅拷贝）
自定义类型成员，会调用它的 operator= 赋值重载

补充：

Date d2 = d1; // 拷贝构造 or 赋值重载？

两个已经存在的对象才是赋值重载，d2 并不存在，所以是拷贝构造

总结 ：
以上默认生成的四个默认成员函数，不能在类外面直接定义为全局，否则会与自动生成的默认成员函数冲突，但可以类内申明，类外定义。析构和构造处理机制基本类似；拷贝构造和复制重载处理机制基本类似。

构造和析构：

• 内置类型不做处理
• 自定义类型会调用对应的构造/析构

拷贝构造和赋值重载：

• 内置类型完成浅拷贝，按字节序拷贝
• 自定义类型去调用它的拷贝构造和赋值重载

6.总结：

今天我们认识并具体学习了类和对象的默认成员函数，分别为：构造函数、析构函数、拷贝构造函数、赋值操作符重载的知识。接下来，我们将继续学习类和对象的相关知识。希望我的文章和讲解能对大家的学习提供一些帮助。

当然，本文仍有许多不足之处，欢迎各位小伙伴们随时私信交流、批评指正！我们下期见~