0
点赞
收藏
分享

微信扫一扫

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数


【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_02

  [ 本篇博客热榜最高排名:7 ]

写在前面

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_03

 朋友们好啊,今天终于更新了。我是柠檬叶子C,本章将继续讲解C++中的面向对象的知识点,本篇主要讲解默认成员函数中的构造函数、析构函数和拷贝构造函数。还是和以前一样,我们将由浅入深地去讲解,以 "初学者" 的角度去探索式地学习。会一步步地推进讲解,而不是直接把枯燥的知识点倒出来,应该会有不错的阅读体验。如果觉得不错,可以 "一键三连" 支持一下博主!你们的关注就是我更新的最大动力!Thanks ♪ (・ω・)ノ

Ⅰ.  默认成员函数

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_04

如果一个类中什么成员都没有,我们称之为 "空类" 。

❓ 但是空类中真的什么都没有吗?

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_构造函数_05

 并不是的……

类有六个默认成员函数,特殊的点非常多,后面我们会壹壹学习。

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_06

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_构造函数_07

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_08

 对于默认成员函数,如果我们不主动实现,编译器会自己生成一份。

❓ 他们有什么用呢?举个例子:

比如我们在上一章里举过的一个 Stack 的例子,

如果需要初始化和清理,"构造函数" 和 "析构函数" 就可以帮助我们完成。

构造函数就类似于 Init,而析构函数就类似于 Destroy。

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_c++_09

还是和以前一样,我们将先由浅入深地进行学习,我们先从 "构造函数" 开始讲起。

Ⅱ. 构造函数

0x00 引入

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_10

打开宇宙第一编辑器,一起敲一敲看看 ~

📚 为了能够更好地讲解,我们来写一个简单的日期类,通过日期类来讲解。

💬 Date.cpp

#include <iostream>

class Date {
public:
void SetDate(int year, int month, int day) {
_year = year;
_month = month;
_day = day;
}
void Print() {
printf("%d-%d-%d\n", _year, _month, _day);
}

private:
int _year;
int _month;
int _day;
};

int main(void)
{
Date d1;
d1.SetDate(2022, 3, 8);
d1.Print();

Date d2;
d2.SetDate(2022, 3, 12);
d2.Print();

return 0;
}

💡 对于 Date 类,我们可以通过我们写的成员函数 SetDate 给对象设置内容。

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_11

 但是每次创建对象都要调用这个 SetDate ,是不是太鸡儿烦了?

❓ 那有没有什么办法能在创建对象时,自动将我们要传递的内容放置进去呢?

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_12

 有!下面我们来隆重介绍一下 构造函数

0x01 构造函数的概念

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_c++_13

📚 构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编译器自动调用。

能够保证每个数据成员都有一个合适的初始值,并且在对象的生命周期内只调用一次。

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_构造函数_14

 构造函数的意义:能够保证对象被初始化。

构造函数是特殊的成员函数,主要任务是初始化,而不是开空间。(虽然构造函数的名字叫构造)

0x02 构造函数的特性

📚 构造函数是特殊的成员函数,主要特征如下:

① 构造函数的函数名和类名是相同的

② 构造函数无返回值

③ 构造函数可以重载

③ 会在对象实例化时自动调用对象定义出来。

比如下面的代码只要

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_c++_15

 就会自动调用,保证了对象一定是被初始化过的。

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_默认成员函数_16

 我们直接来看看它是怎么用的! 

💬 构造函数的用法:

#include <iostream>

class Date {
public:
/* 无参构造函数 */
Date() {
_year = 0;
_month = 1;
_day = 1;
}
/* 带参构造函数 */
Date(int year, int month, int day) {
_year = year;
_month = month;
_day = day;
}
void Print() {
printf("%d-%d-%d\n", _year, _month, _day);
}

private:
int _year;
int _month;
int _day;
};

int main(void)
{
Date d1; // 对象实例化,此时触发构造,调用无参构造函数
d1.Print();

Date d2(2022, 3, 9); // 对象实例化,此时触发构造,调用带参构造函数
d2.Print();

return 0;
}

🚩 运行结果如下:

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_17

 🔑 解读:不给参数时就会调用无参构造函数,给参数则会调用带参构造函数。

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_18

📌 注意事项:

① 构造函数是特殊的,不是常规的成员函数,不能直接调 

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_构造函数_19

 。

#include <iostream>

class Date {
public:
Date(int year = 1, int month = 0, int day = 0) {
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};

int main(void)
{
Date d1;
d1.Date(); // 不能这么去调,构造函数是特殊的,不是常规的成员函数!

return 0;
}

🚩 运行结果:(报错)

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_20

② 如果通过无参构造函数创建对象,对象后面不用跟括号,否则就成了函数声明。

#include <iostream>

class Date {
public:
Date(int year = 1, int month = 0, int day = 0) {
_year = year;
_month = month;
_day = day;
}
void Print() {
printf("%d-%d-%d\n", _year, _month, _day);
}
private:
int _year;
int _month;
int _day;
};

int main(void)
{
//带参这么调:加括号(),在括号中加参数列表
Date d2(2022, 3, 9);

Date d3(); // 这样可以吗?
// 既然代参的调用加括号,在括号中加参数列表。
// 那我不带参,可不可以加括号呢?
❌ 仍然不可以。
// 这个对象实际上没有被定义出来,这里会报错。
// 编译器不会识别,所以不传参数就老老实实地
// Date d3; 不要 Date d3();
// 主要是编译器没法识别,所以这里记住不能这么干就行了。

return 0;
}

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_21

③ 这里如果调用带参构造函数,我们需要传递三个参数(这里我们没设缺省) 。

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_22

④ 如果你没有自己定义构造函数(类中未显式定义),C++ 编译器会自动生成一个无参的默认构造函数。当然,如果你自己定义了,编译器就不会帮你生成了。

#include <iostream>

class Date {
public:
/* 如果用户显式定义了构造函数,编译器将不再生成
Date(int year, int month, int day) {
_year = year;
_month = month;
_day = day;
}
*/
void Print() {
printf("%d-%d-%d\n", _year, _month, _day);
}

private:
int _year;
int _month;
int _day;
};

int main(void)
{
Date d1; // 这里调用的是默认生成的无参的构造函数
d1.Print();

return 0;
}

🚩 运行结果如下:

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_默认成员函数_23

🔑 没有定义构造函数,对象也可以创建成功,因此此处调用的是编译器默认生成的构造函数。

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_24

0x03 默认构造函数

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_25

 无参构造函数、全缺省构造函数都被称为默认构造函数。

并且默认构造函数只能有一个!

class Date {
public:
/* 全缺省构造函数 - 默认构造函数 */
Date(int year = 1970, int month = 1, int day = 1) {
_year = year;
_month = month;
_day = day;
}

private:
int _year;
int _month;
int _day;
};

📌 注意事项:

① 无参构造函数、全缺省构造函数、我们没写编译器默认生成的无参构造函数,都可以认为是默认成员函数。

② 语法上无参和全缺省可以同时存在,但如果同时存在会引发二义性:

#include <iostream>

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

private:
int _year;
int _month;
int _day;
};

int main(void)
{
Date d1; ❌

return 0;
}

🚩 运行结果如下:(报错)

🔑 解读:无参的构造函数和全缺省的构造函数都成为默认构造函数,并且默认构造参数只能有一个,语法上他们两个可以同时存在,但是如果有对象定义去调用就会报错。

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_26

 

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_构造函数_27

 推荐实现全缺省或者半缺省,因为真的很好用:

#include <iostream>

class Date {
public:
/* 全缺省 */
Date(int year = 0, int month = 1, int day = 1) {
_year = year;
_month = month;
_day = day;
}

void Print() {
printf("%d-%d-%d\n", _year, _month, _day);
}
private:
int _year;
int _month;
int _day;
};

int main(void)
{
Date d1; // 如果不传,就是缺省值
Date d2(2022, 1, 15);
Date d3(2009);
Date d4(2012, 4);

d1.Print(); // 0-1-1
d2.Print(); // 2022-1-15
d3.Print(); // 2009-1-1
d4.Print(); // 2012-4-1

return 0;
}

🚩 运行结果如下:

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_默认成员函数_28

0x04 构造函数的特性的测试

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_29

📚 任何一个类的默认构造函数,只有三种:

① 无参的构造函数

② 全缺省的构造函数

③ 我们不写,编译器自己生成的构造函数

💬 如果你没有自己定义构造函数(类中未显式定义),

C++ 编译器会自动生成一个无参的默认构造函数。

当然,如果你自己定义了,编译器就不会帮你生成了。

#include <iostream>

class Date {
public:
// 让编译器自己生成一个
void Print() {
printf("%d-%d-%d\n", _year, _month, _day);
}

private:
int _year;
int _month;
int _day;
};

int main(void)
{
Date d1; // 这里调用的是默认生成的无参的构造函数
d1.Print();

return 0;
}

🚩 运行结果如下:

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_默认成员函数_30

 

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_31

 好了,我们来好好探讨探讨这个问题!

在我们不是先构造函数的情况下,编译器生成的默认构造函数。

似乎这看起来没有什么鸟用啊,这不就是一堆随机值嘛……

d1 对象调用了编译器生成的默认函数,但 d1 对象 year / month / day 依旧是随机值,

也就是说这里编译器生成的默认构造函数好像并没有什么卵用。

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_32

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

内置类型就是语法已经定义好的类型:如 int / char...,

自定义类型就是我们使用 class / struct / union / 自己定义的类型。

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

#include <iostream>
using namespace std;

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;
int _month;
int _day;

// 自定义类型
Time _t;
};

int main()
{
Date d;

return 0;
}

🚩 运行结果如下: 

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_33

💬 测试:对自定义类型处理,会调用默认构造函数(不用参数就可以调的函数)

#include<iostream>
using namespace std;

class A {
public:
// 默认构造函数(不用参数就可以调的)
A() {
cout << " A() " << endl;
_a = 0;
}

private:
int _a;
};

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

A _aa; // 对自定义类型处理,此时会调用默认构造函数 A() {...}
};

int main(void)
{
Date d1;

return 0;
}

🚩 运行结果如下:

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_默认成员函数_34

C++ 里面把类型分为两类:内置类型(基本类型)和 自定义类型

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_构造函数_35

C++ 规定:我们不写编译器默认生成构造函数,对于内置类型的成员变量,不做初始化处理。

但是对于自定义类型的成员变量会去调用它的默认构造函数(不用参数就可以调的)初始化。

如果没有默认构造函数(不用参数就可以调用的构造函数)就会报错!

💬 为了验证,这里我们故意写个带参的默认构造函数,让编译器不默认生成:

#include <iostream>
using namespace std;

class A {
public:
// 如果没有默认的构造函数,会报错。
A(int a) { // 故意给个参
cout << " A() " << endl;
_a = 0;
}
private:
int _a;
};

class Date {
public:
private:
// 如果没有默认构造函数就会报错

int _year;
int _month;
int _day;

A _aa;
};

int main(void)
{
Date d1;

return 0;
}

🚩 运行结果如下(报错)

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_36

💬 我们不写,让编译器默认生成一个:

#include<iostream>
using namespace std;

class A {
public:
// 让编译器默认生成
private:
int _a;
};

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

A _aa;
};

int main(void)
{
Date d1;

return 0;
}

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_c++_37

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_38

 是随机值没错,但是这是一种对自定义类型的 "处理" 。

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_c++_39

 这里说个题外话,个人认为 C++里,我们不写构造函数编译器会默认生成的这个特性设计得不好(狗头保命)……因为没有对内置类型和自定义类型统一处理,不处理内置类型成员变量,只处理自定义类型成员变量。

Ⅲ. 析构函数

0x00 引入

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_构造函数_40

 通过前面构造函数的学习,我们知道了一个对象是怎么来的了,

❓ 那一个对象又是怎么没的呢?既然构造函数的本质是初始化,那清理的工作交给谁来干呢?

💡 交给专门擦屁股的 —— 析构函数

以前我们玩数据结构的时候经常忘记调用 destroy

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_构造函数_41

多么振奋人心啊!话不多说让我们开始讲解!!! 

0x01 析构函数的概念

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_42

 析构函数与构造函数的功能相反。

构造函数是特殊的成员函数,主要任务是初始化,而不是开空间;

析构函数也一样,主要任务是清理,而不是做对象销毁的工作。

(局部对象销毁工作是由编译器完成的)

📚 概念:对象在销毁时会自动调用析构函数,完成对象的一些资源清理工作。

0x02 析构函数的特性

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_43

 构造函数是特殊的成员函数,主要特征如下:① 析构函数名是在类名前面加上字符 

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_构造函数_44

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_45

② 析构函数既没有参数也没有返回值(因为没有参数,所以也不会构成重载问题)

③ 一个类的析构函数有且仅有一个(如果不写系统会默认生成一个析构函数)

④ 析构函数在对象生命周期结束后,会自动调用。

(和构造函数是对应的构造函数是在对象实例化的时候自动调用)

💬 为了演示自动调用,我们来让析构函数被调用时 "吱" 一声:

#include <iostream>
using namespace std;

class Date {
public:
Date(int year = 1, int month = 0, int day = 0) {
_year = year;
_month = month;
_day = day;
}
void Print() {
printf("%d-%d-%d\n", _year, _month, _day);
}

~Date() {
// Date 类没有资源需要清理,所以Date不实现析构函都是可以的
cout << "~Date() 吱~ " << endl; // 测试一下,让他吱一声
}

private:
int _year;
int _month;
int _day;
};

int main(void)
{
Date d1;
Date d2(2022, 3, 9);

return 0;
}

🚩 运行结果:

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_默认成员函数_46

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_默认成员函数_47

额,之前举得日期类的例子没法很好地展示析构函数的 "魅力" ……

就像本段开头说情景,我们拿 Stack 来举个例子,这就很贴切了。

我们知道,栈是需要 destroy

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_默认成员函数_48

 这里我们让析构函数来干这个活,简直美滋滋!

💬 析构函数的用法:

#include<iostream>
#include<stdlib.h>
using namespace std;

typedef int StackDataType;
class Stack {
public:
/* 构造函数 - StackInit */
Stack(int capacity = 4) { // 这里只需要一个capacity就够了,默认给4(利用缺省参数)
_array = (StackDataType*)malloc(sizeof(StackDateType) * capacity);
if (_array == NULL) {
cout << "Malloc Failed!" << endl;
exit(-1);
}
_top = 0;
_capacity = capacity;
}

/* 析构函数 - StackDestroy */
~Stack() { // 这里就用的上析构函数了,我们需要清理开辟的内存空间(防止内存泄漏)
free(_array);
_array = nullptr;
_top = _capacity = 0;
}

private:
int* _array;
size_t _top;
size_t _capacity;
};

int main(void)
{
Stack s1;
Stack s2(20); // s2 栈 初始capacity给的是20(可以理解为"客制化")

return 0;
}

🔑 解读:我们在设置栈的构造函数时,定义容量 capacity 时利用缺省参数默认给个4的容量,这样用的时候默认就是4,如果不想要4可以自己传。

如此一来,就可以保证了栈被定义出来就一定被初始化,用完后会自动销毁。以后就不会有忘记调用 destroy

❓ 问一个比较有意思的问题,这里是先析构 s1 还是先析构 s2

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_构造函数_49

 既然都这样问了,应该是先析构 s2 了 ~

析构的顺序在局部的栈中是相反的,栈帧销毁清理资源时 s2 先清理,然后再清理 s1

(不信的话可以去监视一下 this 观察下成员变量)

0x03 析构函数的特性的测试

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_50

又到了测试环节,上号!

我们知道,如果没写析构函数编译器会自动生成一个。

那生成的析构函数会做什么事情呢?它会帮我们 destroy

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_默认成员函数_51

 想屁吃?哪有这种好事。

如果我们不写默认生成的析构函数,结果和构造函数类似,

对于自定义类型的成员变量不作处理,对于自定义类型的成员变量会去调用它的析构函数。

#include<iostream>
#include<stdlib.h>
using namespace std;
typedef int StackDataType;

class Stack {
public:
Stack(int capacity = 4) {
_array = (StackDataType*)malloc(sizeof(int*) * capacity);
if (_array == NULL) {
cout << "Malloc Failed!" << endl;
exit(-1);
}
_top = 0;
_capacity = capacity;
}
// ~Stack() {
// free(_array);
// _array = nullptr;
// _top = _capacity = 0;
// }

private:
int* _array;
size_t _top;
size_t _capacity;
};

int main(void)
{
Stack s1;
Stack s2(20);


return 0;
}

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_构造函数_52

难道就不能帮我把这些事都干了吗?帮我都销毁掉不就好了?

不不不,举个最简单的例子,迭代器,析构的时候是不释放的,因为不需要他来管,

所以默认不对内置类型处理是正常的,万一误杀了怎么办,对吧。 

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_默认成员函数_53

有人可能又要说了,这么一来默认生成的析构函数不就没有用了吗?

有用!他对内置类型的成员类型不作处理,会在一些情况下非常的有用!

比如说:   两个栈实现一个队列(LeetCode232) ,用C++可以非常的爽。

💬 自定义类型的成员变量调用它的析构函数:

#include <iostream>
using namespace std;

class String {
public:
String(const char* str = "jack") {
_str = (char*)malloc(strlen(str) + 1);
strcpy(_str, str);
}
~String() {
cout << "~String()" << endl;
free(_str);
}
private:
char* _str;
};

class Person {
private:
String _name;
int _age;
};

int main()
{
Person p;

return 0;
}

🚩 运行结果如下:

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_默认成员函数_54

Ⅳ.  拷贝构造函数

0x00 引入

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_默认成员函数_55

我们在创建对象的时候,能不能创建一个与某一个对象一模一样的新对象呢?

Date d1(2022, 3, 9);    
d1.Print();

Date d2(d1); // 照着d1的模子做一个d2
d2.Print();

当然可以,这时我们就可以用拷贝构造函数。

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_56

0x01 拷贝构造函数的概念

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_构造函数_57

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

0x02 拷贝构造函数的特性

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_构造函数_58

它也是一个特殊的成员函数,所以他符合构造函数的一些特性:

① 拷贝构造函数是构造函数的一个重载形式。函数名和类名相同,没有返回值。

② 拷贝构造函数的参数只有一个,并且必须要使用引用传参!

     

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_c++_59

 使用传值方式会引发无穷递归调用!

💬 拷贝构造函数的用法:

#include <iostream>

class Date {
public:
Date(int year = 0, int month = 1, int day = 1) {
_year = year;
_month = month;
_day = day;
}

/* Date d2(d1); */
Date(Date& d) { // 这里要用引用,否则就会无穷递归下去
_year = d._year;
_month = d._month;
_day = d._day;
}
void Print() {
printf("%d-%d-%d\n", _year, _month, _day);
}

private:
int _year;
int _month;
int _day;
};

int main(void)
{
Date d1(2022, 3, 9);
Date d2(d1); // 拷贝复制

// 看看拷贝成功没
d1.Print();
d2.Print();

return 0;
}

🚩 运行结果如下:

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_c++_60

❓ 为什么必须使用引用传参呢?

调用拷贝构造,需要先穿参数,传值传参又是一个拷贝构造。

调用拷贝构造,需要先穿参数,传值传参又是一个拷贝构造。

调用拷贝构造,需要先穿参数,传值传参又是一个拷贝构造。

……

一直在传参这里出不去了,所以这个递归是一个无穷无尽的。

💬 我们来验证一下:

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_默认成员函数_61

error: invalid constructor; you probably meant 'Date (const Date&)'

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_62

这里不是加不加 const 的问题,而是没有用引用导致的问题。

不用引用,他就会在传参那无线套娃递归。至于为什么我们继续往下看。

💬 拷贝构造函数加 const :

如果函数内不需要改变,建议把 const

class Date {
public:
Date(int year = 0, int month = 1, int day = 1) {
_year = year;
_month = month;
_day = day;
}

/* Date d2(d1); */
Date(const Date& d) { // 如果内部不需要改变,建议加上const
_year = d._year;
_month = d._month;
_day = d._day;
}

void Print() {
printf("%d-%d-%d\n", _year, _month, _day);
}

private:
int _year;
int _month;
int _day;
};

第一个原因:怕出错,万一你一不小心写反了怎么办?

/* Date d2(d1); */
Date(Date& d) {
d._year = _year;
d._month = _month;
d._day = _day;
}

这样会产生一个很诡异的问题,这一个可以被编译出来的 BUG ,结果会变为随机值。

所以,这里加一个 const 就安全多了,这些错误就会被检查出来了。

第二个原因:以后再讲,因为涉及一些临时对象的概念。

🔺 反正,不想深究的话就记住:如果函数体内不需要改变,建议把 const 加上就完事了。

0x03 关于默认生成的拷贝构造

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_63

 这里比较特殊,我们单独领出来讲。 

📚 默认生成拷贝构造:

① 内置类型的成员,会完成按字节序的拷贝(把每个字节依次拷贝过去)。

② 自定义类型成员,会再调用它的拷贝构造。

💬 拷贝构造我们不写生成的默认拷贝构造函数,对于内置类型和自定义类型都会拷贝处理。但是处理的细节是不一样的,这个跟构造和析构是不一样的!

#include<iostream>
using namespace std;

class Date {
public:
Date(int year = 0, int month = 1, int day = 1) {
_year = year;
_month = month;
_day = day;
}

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

void Print() {
printf("%d-%d-%d\n", _year, _month, _day);
}

private:
int _year;
int _month;
int _day;
};

int main(void)
{
Date d1(2002, 4, 8);

// 拷贝复制
Date d2(d1);

// 没有写拷贝构造,但是也拷贝成功了
d1.Print();
d2.Print();

return 0;
}

🚩 运行结果如下:

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_默认成员函数_64

🔑 他这和之前几个不同了,这个他还真给我解决了。

所以为什么要写拷贝构造?写他有什么意义?没有什么意义。

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_65

 默认生成的一般就够用了!

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_66

 当然,这并不意味着我们都不用写了,有些情况还是不可避免要写的

比如实现栈的时候,栈的结构问题,导致这里如果用默认的 拷贝构造,会翻车。

按字节把所有东西都拷过来会产生问题,如果 Stack st1 拷贝出另一个 Stack st2(st1

会导致他们都指向那块开辟的内存空间,导致他们指向的空间被析构两次,导致程序崩溃

然而问题不止这些……

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_c++_67

 其实这里的字节序拷贝是浅拷贝,下面几章我会详细讲一下深浅拷贝,这里的深拷贝和浅拷贝先做一个大概的了解。

🔺 总结:对于常见的类,比如日期类,默认生成的拷贝构造能用。但是对于栈这样的类,默认生成的拷贝构造不能用。

Ⅴ.  总结

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_68

默认成员函数有六只,本篇只介绍了三只,剩下的我们后面讲。

类和对象部分知识很重要,所以我们来做一个简单的总结 ~

0x00 构造函数 

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_构造函数_69

初始化,在对象实例化时候自动调用,保证实例化对象一定被初始化。

构造函数是默认成员函数,我们不写编译器会自己生成一份,我们写了编译器就不会生成。

我们不写内置类型成员变量不处理。

对于内置类型成员变量不处理。

对于自定义类型的成员变量会调用它的默认构造函数。

// 我们需要自己实现构造函数
class Date {
int _year;
int _month;
int _day;
};

// 我们不需要自己实现构造函数,默认生成的就可以
class MyQueue {
Stack _pushST;
Stack _popST;
};

0x01 析构函数

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_构造函数_70

 完成对象中自愿的清理。如果类对象需要资源清理,才需要自己实现析构函数。

析构函数在对象生命周期到了以后自动调用,如果你正确实现了析构函数,保证了类对象中的资源被清理。

什么时候生命周期到了?如果是局部变量,出了作用域。全局和静态变量,整个程序结束。

我们不写编译器会默认生成析构函数,我们实现了,编译器就不会实现了。

对于内置类型成员变量不处理。

对于自定义类型的成员变量会调用它的析构函数。

// 没有资源需要清理,不徐需要自己实现析构函数
class Date {
int _year;
int _month;
int _day;
};

// 需要自己实现析构函数,清理资源。
class Stack {
int* _a;
int _top;
int _capacity;
};

0x02 拷贝构造

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_编译器_71

使用同类型的对象去初始化实例对象。

参数必须是引用!不然会导致无穷递归。

如果我们不实现,编译器会默认生成一份默认的拷贝构造函数。

默认生成的拷贝构造:

① 内置类型完成按子继续的值拷贝。 —— 浅拷贝

② 自定义类型的成员变量,会去调用它的拷贝构造。

// 不需要自己实现,默认生成的拷贝构造,完成浅拷贝就能满足需求
class Date {
int _year;
int _month;
int _day;
};

// 需要自己实现,因为默认生成的浅拷贝不能满足需求。
// 我们需要自己实现深拷贝的拷贝构造,深拷贝我们后面会用专门的章节去讲解。
class Stack {
int* _a;
int _top;
int _capacity;
};

#include <iostream>
using namespace std;

class Date {
public:
Date(int year = 1, int month = 0, int day = 0) {
_year = year;
_month = month;
_day = day;
}

void Print() {
printf("%d-%d-%d\n", _year, _month, _day);
}

~Date() {
cout << "&Date()" << endl;
}

private:
int _year;
int _month;
int _day;
};

int main(void)
{
Date d1;
d1.Print();

Date d2(2002);
d2.Print();

Date d3(2022, 3);
d3.Print();

Date d4(2022, 3, 9);
d4.Print();

return 0;
}

 🚩 运行结果如下:

【C++要笑着学】类的默认成员函数详解 | 构造函数 | 析构函数 | 构造拷贝函数_类_72

参考资料:

Microsoft. MSDN(Microsoft Developer Network)[EB/OL]. []. .

百度百科[EB/OL]. []. https://baike.baidu.com/.

比特科技. C++[EB/OL]. 2021[2021.8.31]. .

📌 笔者:王亦优

📃 更新: 2022.3.15

❌ 勘误:Star丶北辰:拿栈举例时malloc空间 sizeof 有误【已修正】

📜 声明: 由于作者水平有限,本文有错误和不准确之处在所难免,本人也很想知道这些错误,恳望读者批评指正!

本章完。

举报

相关推荐

0 条评论