欢迎来到Harper·Lee的学习笔记！

博主主页传送门：Harper·Lee的博客主页

个人语录：他强任他强，清风拂山岗！

一、类的默认成员函数

如果一个类里面什么的成员都没有，我门将其简称为空类。但是空类里面真的什么都没有吗？其实不然，任何一个类包括空类，里面都会自动生成6个默认成员函数。

<code>class Date

{ -- -->

//空类，大小为1

};

默认成员函数：用户没有显示实现 ，编译器会自动生成的成员函数（一旦我们显示地实现了，即使是一个空的函数，编译器也不会再生成了）。一个类在我们不主动实现的情况下，编译器会自动生成6个默认成员函数；如果我们主动写了，那么编译器就不再生成了。

对于默认成员函数，我们主要从两个问题来进行学习：

Q1：程序员不写，编译器默认生成的函数行为是什么，是否满足我们的需求？

Q2：编译器默认生成的函数不满足我们的需求，我们需要自己实现，那么如何自己实现？

二、 构造函数–初始化工作（重点）

2.1 定义

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

例如：下面一个日期类的成员函数<code>Date，就是一个构造函数。

#include<iostream>

using namespace std;

class Date

{ -- -->

public:

Date(int year = 2024, int month = 1, int day = 1)//构造函数

{

_year = year;

_month = month;

_day = day;

}

void Print()

{

cout << _year << "年" << _month << "月" << _day << "日" << endl;

}

private:

int _year;

int _month;

int _day;

};

2.2 特性

构造函数的主要任务并不是开空间创建对象（我们经常使用的局部对象是栈桢创建时，空间就开好了），而是在对象进行实例化时初始化对象的 。

说明：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型，

如：int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。

函数名与类名相同。无返回值。（不写返回值，也不写void）对象实例化时编译器自动调用对应的构造函数。构造函数可以重载。（就是一个类可以有多个构造函数，也就是有多种初始化方式，编译器会根据程序员所传递的参数去调用对应的构造函数。）自己实现的无参构造函数、自己实现的全缺省构造函数、我们不写但是编译器默认生成的构造函数，都叫做默认构造函数。 这三个默认构造函数只能存在一个 。

总之：无需传参就可以调用的函数就是默认构造函数。

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

当然你可能会想：既然编译器可以自动生成构造函数，那我们就没必要再去实现构造函数了。起始这种想法是错误的。那么编译器的自动生成还有什么意义呢？请看下面的代码：（没有自己去实现构造函数，编译器自动生成的默认构造不得行啊！）

#include<iostream>

using namespace std;

//（没有初始化）

class Date

{

public:

//没有写Date构造函数

void Print()

{

cout << _year << "年" << _month << "月" << _day << "日" << endl;

}

private:

int _year;

int _month;

int _day;

};

int main()

{

Date d1;//无参没有括号，是对象实例化吗？？

d1.Print();

return 0;

}

运行结果：

上面的这段代码我没有实现构造函数，那么编译器就需要自动生成。编译器自动生成的构造函数机制：

对于内置类型，编译器自动生成的构造函数对内置类型不做处理，因此它的行为是不确定的；对于自定义类型，编译器会去调用成员变量自己的默认构造函数。 如果这个成员变量没有默认构造函数，就会保报错，我们要初始化这个成员变量，需要使用初始化列表。

我们不写，编译器默认生成的构造函数：（上面的例子就是我们不写的构造）

（1）对内置类型的成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器；

（2）对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化；

根据上面的代码，我们不写，编译器自动生成的默认构造函数不满足我们的需求！

<code>//实现一个栈的构造函数：不需要传入private里面变量的值，就需要自己主动实现！！！

#include<iostream>

using namespace std;

typedef int STDataType;

class Stack

{ -- -->

public:

Stack(int n = 4)//只需传入一个大小，写全缺省：知道具体大小就传入具体大小，不知道具体大小就用默认缺省值

{

_a = (STDataType*)malloc(sizeof(STDataType) * n);

if (nullptr == _a)

{

perror("malloc申请空间失败");

return;

}

_capacity = n;

_top = 0;

}

private:

STDataType* _a;

size_t _capacity;

size_t _top;

};

// 两个Stack实现队列——复习——就不需要自己去实现构造函数了

//对于自定义类型的成员变量，要求调用这个成员变量的默认构造函数初始化

class MyQueue

{

public:

//没有去实现Myqueue的构造函数

//编译器默认生成Myqueue的构造函数调用了Stack的额构造，完成了两个

private:

Stack pushst;//这里是使用Stack创建的变量：叫做自定义类型成员变量

Stack popst;

};

int main()

{

Stack st;

MyQueue mq;//这里的构造是编译器自动生成的

//会调用自定义类型成员变量pushst、popst的默认构造函数Stack(int n = 4)

return 0;

}

//C++标准：不是所有编译器都会处理

//如果自定义类型成员变量没有刚才所的默认构造函数，那么就会报error：

做总结：大多数情况下，构造函数都需要我们自己去实现，少数像Myqueue且Stack有默认构造时，Myqueue自动生成就可以用。

（3）如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决。

2.3 构造函数的种类

#include<iostream>

using namespace std;

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;

}

// 3.全缺省构造函数

/*Date(int year = 1, int month = 1, int day = 1)

{

_year = year;

_month = month;

_day = day;

}*/

void Print()

{

cout << _year << "/" << _month << "/" << _day << endl;

}

private:

int _year;

int _month;

int _day;

};

int main()

{

// 如果留下第⼆个带参构造，第⼀三个注释掉

// 编译报错：error C2512: “Date”: 没有合适的默认构造函数可⽤

Date d1; // 调⽤默认构造函数

Date d2(2025, 1, 1); // 调⽤带参的构造函数

// 注意：如果通过无参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法

// 区分这⾥是函数声明还是实例化对象

// warning C4930: “Date d3(void)”: 未调⽤原型函数(是否是有意⽤变量定义的?)

Date d3();

d1.Print();

d2.Print();

return 0;

}

2.3.1 无参构造函数

#include<iostream>

using namespace std;

class Date

{

public:

Date()//无参构造函数

{

_year = 2024;

_month = 1;

_day = 1;

}

void Print()

{

cout << _year << "年" << _month << "月" << _day << "日" << endl;

}

private:

int _year;

int _month;

int _day;

};

int main()

{

Date d1;//注意：无参调用不能加括号，带参的才可以

d1.Print();

return 0;

}

运行结果：

2.3.2 带参构造函数

<code>#include<iostream>

using namespace std;

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 d1(2000, 1, 1);

d1.Print();

return 0;

}

运行结果：

2.3.3 全缺省构造函数

<code>#include<iostream>

using namespace std;

class Date

{ -- -->

public:

Date(int year = 2024, int month = 1, int day = 1)//全缺省

{

_year = year;

_month = month;

_day = day;

}

void Print()

{

cout << _year << "年" << _month << "月" << _day << "日" << endl;

}

private:

int _year;

int _month;

int _day;

};

int main()

{

Date d1;

d1.Print();

return 0;

}

运行结果：

注意：无参构造函数和全缺省构造函数他们虽然构成函数重载，但是当存在多个默认构造函数时，一旦我们对对象进行实例化，编译器不知道调用哪个构造函数，就会引起歧义。

注意：调用时无参的不能加括号，带参的才可以加括号。

<code>#include<iostream>

using namespace std;

class Date

{ -- -->

public:

Date()//无参构造函数

{

_year = 1;

_month = 1;

_day = 1;

}

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 d1;//无参构造函数调用不加括号。

d1.Print();

Date d2(2000, 1, 1);//带参函数调用加括号

d2.Print();

return 0;

}

运行结果：

说明：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型，如：int/char/double/指针`等，自定义类型就是我们使用class/struct等关键字自己定义的类型。

我们不写时，编译器默认生成的构造函数，似乎不能满足我们的需求，我们最好还是自己去实现构造函数，而且最好是全缺省的。

三、析构函数–清理工作

3.1 定义

析构函数的功能与构造函数的相反，析构函数不是完成对对象本身的销毁， C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。

构造函数类似于Init，析构类似于Stack中实现的Destroy功能。有资源生成的类才需要写析构函数。 前面的日期类Date就没有资源需要清理，就不需要写析构函数。

3.2 特点

析构函数的特点：析构函数的特点：（在之前就需要写一个Init、Destroy函数）

析构函数名是在类名前加上字符~；无参数无返回值，也不需要加void；-----不会出现重载的情况！一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数；对象生命周期结束时，系统会自动调用析构函数；跟构造函数类似，我们不写 编译器自动生成的析构函数 对内置类型成员不做处理，自定类型成员会调用他的析构函数；还需要注意的是我们 显示写 析构函数，对于自定义类型成员也会调用他（自定义类型成员）的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数！

从下面的代码中可以发现，编译器是会自动生成Myqueue的析构函数的，如果我们自己写了析构函数~Myqueue，那么编译器是不会去调用这个函数的，而是会调用本身的析构函数！

<code>#include<iostream>

using namespace std;

typedef int STDataType;

class Stack

{ -- -->

public:

Stack(int n = 4)

{

_a = (STDataType*)malloc(sizeof(STDataType) * n);

if (nullptr == _a)

{

perror("malloc申请空间失败");

return;

}

_capacity = n;

_top = 0;

}

~Stack()//如果不写栈的析构函数，那么就会出现内存泄漏！！！！

{

cout << "~Stack()" << endl;

free(_a);//释放掉 _a ？？？？？

_a = nullptr;//置空

_top = _capacity = 0;//变值

}

private:

STDataType* _a;

size_t _capacity;

size_t _top;

};

// 两个Stack实现队列

class MyQueue

{

public:

//编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源

// 显⽰写析构，也会⾃动调⽤Stack的析构

~MyQueue()//本来不需要自己写，但是这里又自己添加了一个析构函数名，什么也没有实现

{

cout << "~MyQueue()" << endl;

//调用的时候可以发现：自己显示地写了析构函数，也会自动调用Stack本身的析构，避免内存泄漏

}

private:

Stack pushst;//自定义类型pushst、popst会调用自己即Stack的析构

Stack popst;

};

int main()

{

Stack st1;

Stack st2;

MyQueue mq;//对象空间的开辟 ：编译器编译时系统就开辟好了的

return 0;

}

运行结果：

tips：监视窗口输入this即可看见所有成员变量！！！

有多个对象，析构的原则：后定义的先析构、先定义的后析构。 （根据调试的过程发现调用的函数的先后顺序！）自定义类型成员的析构不用管，自动生成的析构只管内置类型的；默认生成的析构够用就不用管。

3.3 括号匹配

<code>

#include<iostream>

using namespace std;

// ⽤最新加了构造和析构的C++版本Stack实现

bool isValid(const char* s) { -- -->

Stack st;

while (*s)

{

if (*s == '[' || *s == '(' || *s == '{')

{

st.Push(*s);

}

else

{

// 右括号⽐左括号多，数量匹配问题

if (st.Empty())

{

return false;

}

// 栈⾥⾯取左括号

char top = st.Top();

st.Pop();

// 顺序不匹配

if ((*s == ']' && top != '[')

|| (*s == '}' && top != '{')

|| (*s == ')' && top != '('))

{

return false;

}

}

++s;

}

// 栈为空，返回真，说明数量都匹配 左括号多，右括号少匹配问题

return st.Empty();

}

// ⽤之前C版本Stack实现

bool isValid(const char* s) {

ST st;

STInit(&st);

while (*s)

{

// 左括号⼊栈

if (*s == '(' || *s == '[' || *s == '{')

{

STPush(&st, *s);

}

else // 右括号取栈顶左括号尝试匹配

{

if (STEmpty(&st))

{

STDestroy(&st);

return false;

}

char top = STTop(&st);

STPop(&st);

// 不匹配

if ((top == '(' && *s != ')')

|| (top == '{' && *s != '}')

|| (top == '[' && *s != ']'))

{

STDestroy(&st);

return false;

}

}

++s;

}

// 栈不为空，说明左括号⽐右括号多，数量不匹配

bool ret = STEmpty(&st);

STDestroy(&st);

return ret;

}

int main()

{

cout << isValid("[()][]") << endl;

cout << isValid("[(])[]") << endl;

return 0;

}

四、拷贝构造函数

4.1 定义

如果一个构造函数的的是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造函数是一个特殊的构造函数。

<code>#include<iostream>

using namespace std;

class Date

{ -- -->

public:

Date(int year = 1, 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;

}

void Print()

{

cout << _year << "年" << _month << "月" << _day << "日" << endl;

}

private:

int _year;

int _month;

int _day;

};

int main()

{

Date d1(2024, 1, 1);

d1.Print();

Date d2(d1);//拷贝一个对象来初始化对象d2，尽量用const来限定，避免传入的参数被修改！！！

d2.Print();

return 0;

}

4.2 特点

拷贝构造函数是构造函数的一个重载形式。拷贝构造函数的参数第一个参数必须是类类型对象的引用，且任何额外的参数都有默认值（缺省值），使用传值方式编译器直接报错，因为语法逻辑上会引发无穷递归调用。C++规定：传值传参要调用拷贝构造。

4.3 传值传参VS引用传参

4.3.1 传值传参调用有引用&的拷贝构造函数

拷贝构造函数的第一个参数如果假如使用传值传参方式编译器就会直接报错，因为语法逻辑上会引发无穷递归调用（调试可以看见）。

//拷贝构造的第一个参数是自身类类型对象的引用

#include<iostream>

using namespace std;

class Date

{

public:

Date(int year = 1, int month = 1, int day = 1)//带参构造函数

{

_year = year;

_month = month;

_day = day;

}

//const可以保护d，避免：像if(d._year == _year)写成：if(d._year = _year)

//拷贝构造的写法：函数名和类名相同；如果还有参数，就必须有默认/缺省值

Date(const Date& d)

{

_year = d._year;

_month = d._month;

_day = d._day;

}

void Print()

{

cout << _year << "年" << _month << "月" << _day << "日" << endl;

}

private:

int _year;

int _month;

int _day;

};

void Func1(Date d)//这里不是拷贝构造函数，无&只有一个参数d，调用时就是传值传参！！！！！

{

cout << &d << endl;

d.Print();

}

int main()

{

Date d1(2024, 1, 1);

d1.Print();

//C++规定:传值传参要调用拷贝构造

Func1(d1);//这里调用Func1函数会形成拷贝构造（传值传参：d1作为传入的值传给Func1中的d来接收）

// error C3867 : “Date::Func1” : 非标准语法；请使用 "&" 来创建指向成员的指针

return 0;

}

分析过程（C语言和C++的区别）：根据调试发现，按F11首先进入的函数是拷贝构造函数，而不是进入函数Func1，得到的结果进入Func1函数，完成的是传参过程；再按F11，完成Func1函数调用，这里是正常的调用。分析原因：正常调用是因为拷贝构造函数Date使用了引用&，因此Func1函数调用没有形成无穷递归，而是正常调用。

建议：对于自定义类型，这个Func1函数不建议传值传参。因为它需要调用拷贝构造函数，因此建议自定义类型传引用。内置类型影响不大。（更多内容看const引用）

<code>void Func1(const Date& d)//这里不是拷贝构造函数，无&只有一个参数d，调用时就是传值传参！！！！！

{ -- -->

cout << &d << endl;

//d.Print();但是加入const时，这里编译不通过

}

4.3.2 直接调用无引用的拷贝构造函数

下面改进的代码就相当于d是d1的别名，直接就将d1作为参数传入，而不会形成新的拷贝构造函数，正常调用该函数。代码如下:

#include<iostream>

using namespace std;

class Date

{

public:

Date(int year = 1, 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()

{

cout << _year << "年" << _month << "月" << _day << "日" << endl;

}

private:

int _year;

int _month;

int _day;

};

int main()

{

Date d1(2024, 1, 1);

Date d2(d1);//这里就是正常（直接）调用拷贝构造函数

d2.Print();

return 0;

}

分析代码过程：调用拷贝构造函数需要传值传参，而C++规定，传值传参生成临时对象时，就需要为它调用拷贝构造函数，形成新的临时拷贝构造函数，如图中的Date d(d1);调用它又需要传参d1，就又会形成新的拷贝构造函数，一直循环往复……整个函数调用的过程分析图如下：

分析原因：造成无穷递归主要就是因为下面这两个函数：

<code>Date d2(d1);

Date d(d1);//这个函数就是新形成的拷贝构造函数！

提出疑问：图中的Date d(d1);是什么意思？

提出假设：如果没有传值，而是引用，就不会生成拷贝构造，就是正常的调用。相当于：<code>**Date d2(d1);**就变成：**d就是d1，this就是d2**。

4.3.3 直接调用有引用的拷贝构造函数

代码如下：

#include<iostream>

using namespace std;

class Date

{ -- -->

public:

Date(int year = 1, 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;

}

void Print()

{

cout << _year << "年" << _month << "月" << _day << "日" << endl;

}

private:

int _year;

int _month;

int _day;

};

int main()

{

Date d1(2024, 1, 1);

Date d2(d1);//这里就是正常（直接）调用拷贝构造函数

d2.Print();

return 0;

}

分析：在这段代码里面，相当于d是d1的别名，并没有形成新的拷贝构造，正常就结束调用了。拷贝构造函数的第一个参数是自身类类型对象的引用，这才是正确的拷贝构造函数！

—注意注意注意—

传引用的时候，最好加入const，避免传入参数被修改。C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。（传值传参是为了生成的临时对象调用的拷贝构造函数）

4.4 未显示定义拷贝构造函数

若未显式定义拷贝构造，编译器会生成自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。（拷贝构造函数对内置类型不做处理，例如日期类但是这里不一样了）

内置类型有拷贝构造，自定义类型也有拷贝构造。但是：

4.4.1 无资源的不需要显示实现拷贝构造

有些自动生成的拷贝构造够用了，不需要我们显示实现。像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的拷贝构造就可以完成需要的拷贝，所以不需要我们显示实现拷贝构造。

4.4.2 某些自动生成的拷贝构造不满足

有些自动生成的拷贝构造就不满足需求，无论还内置类型还是自定义类型。

内置类型分析：像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的拷贝构造完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝 (对指向的资源也进行拷贝，对指针有所处理)。

#include<iostream>

using namespace std;

typedef int STDataType;

class Stack

{

public:

Stack(int n = 4)//构造

{

_a = (STDataType*)malloc(sizeof(STDataType) * n);

if (nullptr == _a)

{

perror("malloc申请空间失败");

return;

}

_capacity = n;

_top = 0;

}

加入这一部分后，才是深拷贝，st1和st2空间得出地址就不是一样的了

st2(st1):这里参数对应：st1就是st，st2就是this指针

//Stack(const Stack& st)//拷贝构造函数：不写，就会进行浅拷贝/值拷贝

//{

//// 需要对_a指向资源创建同样⼤的资源再拷⻉值

//_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);

//if (nullptr == _a)

//{

//perror("malloc申请空间失败!!!");

//return;

//}

//memcpy(_a, st._a, sizeof(STDataType) * st._top);

//_top = st._top;

//_capacity = st._capacity;

//}

void Push(STDataType x)

{

if (_top == _capacity)

{

int newcapacity = _capacity * 2;

STDataType* tmp = (STDataType*)realloc(_a, newcapacity *

sizeof(STDataType));

if (tmp == NULL)

{

perror("realloc fail");

return;

}

_a = tmp;

_capacity = newcapacity;

}

_a[_top++] = x;

}

~Stack()//析构

{

cout << "~Stack()" << endl;

free(_a);

_a = nullptr;

_top = _capacity = 0;

}

private://内置类型

STDataType* _a;

size_t _capacity;

size_t _top;

};

int main()

{

Stack st1;

st1.Push(1);

st1.Push(2);

Stack st2(st1);

//Stack不显示实现拷贝构造函数，而是用自动生成的拷贝构造函数完成了浅拷贝

//调试发现，程序崩溃：因为st1和st2⾥⾯的_a指针指向同一块资源同一块空间，而且析构函数运行了两次，即同一块空间被析构了两次。

return 0;

}

调试发现：st1和st2⾥⾯的_a指针指向同一块资源同一块空间，而且析构函数运行了两次，即同一块空间被析构了两次（调试过程得出），程序崩溃。因此，我们不显示实现，编译器自动生成的拷贝构造函数完成浅拷贝/值拷贝的过程并不一定满足需求，需要我们自己显示实现完成深拷贝。

加入拷贝构造函数后，深拷贝结果如下：

自定义类型分析：像MyQueue（指的是两个栈实现队列中的<code>MyQueue）这样的类型内部主要是自定义类型Stack成员，编译器自动生成的拷贝构造会调用Stack的拷贝构造，也不需要我们显示实现MyQueue的拷贝构造。调试发现，使用的是深拷贝。

//两个栈实现队列中的MyQueue

#include<iostream>

using namespace std;

typedef int STDataType;

class Stack

{ -- -->

public:

Stack(int n = 4)//构造

{

_a = (STDataType*)malloc(sizeof(STDataType) * n);

if (nullptr == _a)

{

perror("malloc申请空间失败");

return;

}

_capacity = n;

_top = 0;

}

//st2(st1):这里参数对应：st1就是st，sh2就是this指针

Stack(const Stack& st)//拷贝构造函数：不写，就会进行浅拷贝/值拷贝

{

// 需要对_a指向资源创建同样⼤的资源再拷⻉值

_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);

if (nullptr == _a)

{

perror("malloc申请空间失败!!!");

return;

}

memcpy(_a, st._a, sizeof(STDataType) * st._top);

_top = st._top;

_capacity = st._capacity;

}

void Push(STDataType x)

{

if (_top == _capacity)

{

int newcapacity = _capacity * 2;

STDataType* tmp = (STDataType*)realloc(_a, newcapacity *

sizeof(STDataType));

if (tmp == NULL)

{

perror("realloc fail");

return;

}

_a = tmp;

_capacity = newcapacity;

}

_a[_top++] = x;

}

~Stack()//析构

{

cout << "~Stack()" << endl;

free(_a);

_a = nullptr;

_top = _capacity = 0;

}

private://成员都是内置类型

STDataType* _a;

size_t _capacity;

size_t _top;

};

// 两个Stack实现队列

class MyQueue

{

public:

private:

Stack pushst;

Stack popst;

};

int main()

{

Stack st1;

st1.Push(1);

st1.Push(2);

// Stack不显⽰实现拷⻉构造，⽤⾃动⽣成的拷⻉构造完成浅拷⻉

// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃

Stack st2(st1);//Stack st2 = st1;也可以这样写

MyQueue mq1;

// MyQueue⾃动⽣成的拷⻉构造，会⾃动调⽤Stack拷⻉构造完成pushst/popst

// 的拷⻉，只要Stack拷⻉构造⾃⼰实现了深拷⻉，他就没问题

MyQueue mq2(mq1);

return 0;

}

4.4.3 小tip

这里有一个小技巧，如果一个类显示实现了析构并释放资源，那么他就需要我们显示写拷贝构造，否则就不需要。

4.5 C++规定传值传参调用拷贝构造的原因

这其实是为了补足C语言的缺陷：

在C语言中，直接进行传值传参，原本形参的改变并不影响实参，但是若放在类似于有资源生成的栈结构体种，形参的改变会影响实参。例如下面的代码若从C语言的角度来看，func函数中，st1传值传参给st，本应st1的改变不会引起st的改变，但实际上，st1改变会影响st；st1进行销毁时，但st也会被销毁，因此C++在这里规定调用拷贝构造，实际上是补足C语言的缺陷，调用拷贝构造，进行深拷贝

#include<iostream>

using namespace std;

typedef int STDataType;

class Stack

{

public:

Stack(int n = 4)//构造

{

_a = (STDataType*)malloc(sizeof(STDataType) * n);

if (nullptr == _a)

{

perror("malloc申请空间失败");

return;

}

_capacity = n;

_top = 0;

}

//st2(st1):这里参数对应：st1就是st，sh2就是this指针

Stack(const Stack& st)//拷贝构造函数：不写，就会进行浅拷贝/值拷贝

{

// 需要对_a指向资源创建同样⼤的资源再拷⻉值

_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);

if (nullptr == _a)

{

perror("malloc申请空间失败!!!");

return;

}

memcpy(_a, st._a, sizeof(STDataType) * st._top);

_top = st._top;

_capacity = st._capacity;

}

void Push(STDataType x)

{

if (_top == _capacity)

{

int newcapacity = _capacity * 2;

STDataType* tmp = (STDataType*)realloc(_a, newcapacity *

sizeof(STDataType));

if (tmp == NULL)

{

perror("realloc fail");

return;

}

_a = tmp;

_capacity = newcapacity;

}

_a[_top++] = x;

}

~Stack()//析构

{

cout << "~Stack()" << endl;

free(_a);

_a = nullptr;

_top = _capacity = 0;

}

private://成员都是内置类型

STDataType* _a;

size_t _capacity;

size_t _top;

};

void func(Stack st)

{

}

int main()

{

Stack st1;

st1.Push(1);

st1.Push(2);

func(st1);

return 0;

}

在上面的代码中，其实还有一处缺陷：

在这里，传值传参调用拷贝构造的代驾会很大，比如：在数据非常大的情况下，需要开辟一块相同得到很大的空间，存放拷贝得到的数据。因此最好使用引用，st变成st1的别名。

void func(const Stack& st)

{

//……

}

4.6 浅拷贝/值拷贝和深拷贝

浅拷贝/值拷贝：实际上就是将d1的内容完完全全地复制了一份拷贝给d2。（浅拷贝容易出现很多问题）

Date d2(d1);//用已存在的对象d1创建对象d2

深拷贝 ：像栈（Stack）这样的类，编译器自动生成的拷贝构造函数就不能满足我们的需求了，例如下面这两句代码，我们本来是想用已存在的对象st1创建对象st2，但是编译器自动生成的拷贝是浅拷贝，拷贝出来的对象st2不能满足我们的需求。

Stack st1;

Stack s2(s1);//用已存在的对象st1创建对象st2

//后来调试发现st1和st2的地址相同

因此，在我们创建出拷贝构造函数后，就可以用已存在的对象来创建另一个新的对象。

int main()

{

Stack st1;

st1.Push(1);

st1.Push(2);

Stack st2(st1);//用st1创建st2

return 0;

}

4.7 传值返回和传引用返回

传值返回：传值返回会产生一个临时对象调用拷贝构造。传值引用返回：返回的是返回对象的别名（引用），没有产生拷贝。如果返回对象是一个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回是有问题的，这是的引用相当于一个野引用，类似于野指针。传引用返回可以减少拷贝，但是一定要确保返回对象，在当前函数结束后还在，才能用引用返回。

五、赋值运算符重载

5.1 运算符重载

· 当运算符被用于类类型的对象时，C++允许我们通过运算符重载的形式指定新的含义（也就是我们自己定义规则）。

· C++规定类类型对象使用运算符时，必须转换成调用对对应运算符重载，若没有对应的运算符重载，编译器就会编译报错。

· 运算符重载是一个具有特殊名字的函数，它的名字是由operator关键字和后面要定义的运算符共同构。和其他函数一样，它也有函数体、返回类型、参数列表。运算符重载的格式及运用：

返回值 operator要定义的运算符 (参数列表)

{

//函数体：自己定义规则

}

//运用：

bool operator==(Date d1, Date d2)//最好加一个引用

{

//比较大小：bool类型

}

int main()

{

Date d1(2024,1,1);

Date d2(1900,1,1);

operator == (x1, x2);//左侧的传给第一个参数，右侧的穿个第二个参数

return 0;

}

重载运算符的参数个数和该运算符作用的运算对象数量一样多。有些运算符有两重含义，比如： *（乘法或者解引用）；一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少⼀个。运算符重载以后，其优先级和结合性与对应的内置类型运算符保持一致。不能通过连接语法中没有的符号来创建新的运算符：比如operator@。不能重载的运算符：sizeof、::（域作用限定符）、? :（三目运算符）、对象 . 成员、. *（常用于成员函数的回调）。重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义。如：int operator+(int x,int y)。 （即：不能operator的运算符是+，结果内部用的是 . 运算符）一个类重载出的运算符必须要有意义。比如Date类重载operator-就有意义，但是重载operator+就没有意义。重载++运算符时，有前置++和后置++，运算符重载函数名都`operator++，无法很好的区分。C++规定，后置++重载时，增加一个int形参，跟前置++构成函数重载，方便区分。重载**<<**和**>>**时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调用时就变成了**对象<<cout**，不符合使用习惯和可读性。重载为全局函数把**ostream/istream**放到第一个形参位置就可以了，第二个形参位置当类类型对象。

5.1.1 成员函数的回调.*运算符

成员函数回调不常用，之前在学习C语言中的qsort时使用过，理解一下即可。下面的代码主要是为了认识一下.*运算符。

#include <iostream>

using namespace std;

class A

{

public:

void func()

{

cout << "A::func()" << endl;

}

};

typedef void(A::* PF)();//成员函数指针类型，就相当于typedef void (*)() PF 函数指针。

//这里是成员函数，需要使用::域作用限定符

//这里就是定义了一个函数指针变量，并且typedef为PF

int main()

{

//void(A:: * PF)() = nullptr;//定义成员函数指针变量的方法示范：定义了一个函数指针，且是空指针

PF pf = nullptr;//

pf = &A::func;

//1.func函数是类域里面的，使用时需要指定类域

//2.C++规定普通函数的函数名就是函数指针

//3.成员函数指定类域时，需要加一个&才能取到函数指针

//（普通函数）回调的方法：(*pf)();//先解引用，再加一个()。

//但是现在在成员函数中不行。

//那进一步改成这样：(*pf)(&aa);

//也不行：this指针在形参实参中都不能显示。

A aa;//用类定义一个类对象aa

(aa.*pf)();//正常回调，在这里就用到了 .* 操作符，它一般用于成员函数的回调

//不能直接用类名A，即不能：(A.*pf)();

return 0;

}

5.1.2 重载为全局的面临对象访问私有成员变量的问题

代码如下：

#include<iostream>

using namespace std;

class Date

{

public:

Date(int year = 1, int month = 1, int day = 1)

{

_year = year;

_month = month;

_day = day;

}

void Print()

{

cout << _year << "年" << _month << "月" << _day << "日" << endl;

}

private:

int _year;

int _month;

int _day;

};

bool operator==(Date d1, Date d2)

{

return d1._year == d2._year

&& d1._month == d2._month

&& d1._day == d2._day;//没有访问权限：error C2248: “Date::_day”: 无法访问 private 成员(在“Date”类中声明)

//法1：注释private

//法2：类里面定义：int GetYear(){}

}

int main()

{

Date x1(2024, 1, 1);

Date x2(2024, 1, 1);

operator == (x1, x2);//显示调用：左侧的传给第一个参数，右侧的穿个第二个参数

return 0;

}

运行结果：

上面的代码报错：<code>error C2248: “Date::_day”: 无法访问 private 成员(在“Date”类中声明)

方法一：注释掉private，将私有转化成公有。但是这样是可以在类外面直接修改它们的内容的；数据可以随便修改，就是不可控的！

//注释掉private

#include<iostream>

using namespace std;

class Date

{ -- -->

public:

Date(int year = 1, int month = 1, int day = 1)

{

_year = year;

_month = month;

_day = day;

}

void Print()

{

cout << _year << "年" << _month << "月" << _day << "日" << endl;

}

//private:方法一

int _year;

int _month;

int _day;

};

bool operator==(Date d1, Date d2)

{

return d1._year == d2._year

&& d1._month == d2._month

&& d1._day == d2._day;//没有访问权限：error C2248: “Date::_day”: 无法访问 private 成员(在“Date”类中声明)

}

int main()

{

Date x1(2024, 1, 1);

Date x2(2024, 7, 1);

operator == (x1, x2);//显示调用：左侧的传给第一个参数，右侧的穿个第二个参数

x1 == x2;

return 0;

}

方法二：将operator放在类里面，重载成成员函数（最推荐！！）。但是重载成成员函数的时候：

如果一个重载运算符函数时成员函数，那么它的第一个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少一个！此时调用方式发生变化！如果这个函数的全局、成员函数都存在：优先调用成员函数。

#include<iostream>

using namespace std;

class Date

{

public:

Date(int year = 1, int month = 1, int day = 1)

{

_year = year;

_month = month;

_day = day;

}

void Print()

{

cout << _year << "年" << _month << "月" << _day << "日" << endl;

}

//重载成成员函数

bool operator==(Date d2) //=======有一个隐含的this指针=======

{

//如果全局函数和成员函数的这个函数都存在：优先调用成员函数

//比较大小：bool类型

return _year == d2._year

&& _month == d2._month

&& _day == d2._day;

}

private:

int _year;

int _month;

int _day;

};

int main()

{

Date x1(2024, 1, 1);

Date x2(2024, 1, 1);

//??????????调用方式

//这种调用方式是显示调用，如果写了成员的和全局的，这里会调用全局的函数

operator==(x1,x2);

//运算符重载函数可以显示调用

//x1.operator==(x2);

//这种调用方式：编译器会转换成x1.operator==(x2);

x1 == x2;//

return 0;

}

方法三：类的里面定义：int GetYear(){ }（提供get函数）//???

int GetYear()

{

return _year;

}

int GetMonth()

{

return _month;

}

int GetDay()

{

return _day;

}

方法四：使用友元函数

总结：类里面可以访问，类外面不可以访问：

法一：注释掉private：私有改为公有，在类外面就可以访问成员变量了，不安全！法二：提供get函数间接访问；法三：运算符的那个函数放在了在类外面不行，就放在类里面重载成成员函数；法四：友元函数。

5.1.3 运算符重载和函数重载的区别

二者之间没有区别。

函数重载：函数名相同、参数不同的两个及以上函数构成函数重载。运算符重载：对运算符定义新的意义。

5.2 赋值运算符重载

5.2.1 拷贝构造和赋值运算符重载的区别

赋值运算符重载：是一个默认成员函数，用于完成两个已经存在的对象直接的拷贝赋值。

区别拷贝构造：拷贝构造用于一个对象拷贝初始化给另一个要创建的对象。

int main()

{

Date d1(2024, 1, 1);//这里是用三个值来初始化

Date d2(2024, 1, 2);

//赋值重载/赋值重载拷贝---是运算符重载

d1 = d2;//两个已经存在的对象

//拷贝构造---完成新的对象的初始化，而非创建出这个新的对象。这里没有创建！

//它的初始化使用同类型的对象进行的，这一步叫做：拷贝构造

Date d3(d2);//这里是用同类型对象来初始化

Date d4 = d2;//

//它相当于：先是一种从类型开始的初始化，再是一种拷贝

return 0;

}

5.2.2 赋值运算符重载的特点

赋值运算符重载是一个运算符重载，规定必须重载为成员函数（而不是全局函数）。 赋值运算重载的参数建议写成const+当前类类型引用，否则传值传参会有拷贝（避免无穷递归）。

//d1 = d2:d2赋值拷贝给d1

//1. 可以用传值传参，但是容易无穷递归，这里没有发生无穷递归

void operator=(Date d)// = :表示赋值。赋值重载

{

//建议: 写成类类型的引用

}

//2. 使用const+引用

void operator=(const Date& d)

{

//关系：d就是d2（的别名），this就是d1

_year = d._year;

_month = d._month;

_day = d._day;

}

有返回值，且建议写成当前类类型引用，引用返回可以提高效率，有返回值目的是为了支持连续赋值场景。

//d4 = d3 = d1

//让连续赋值正常的方法：-------

//d3 = d1，在这里返回的是d3，返回类型是d3的类型。又因为：d1传给d（d是d1的别名），d3传给this指针解引用，this是d3的地址

Date& operator=(const Date& d)

{

_year = d._year;

_month = d._month;

_day = d._day;

//在这里就用上了this

return *this;

//但是：传值返回也会生成一个拷贝，该函数结束，浪费资源生成了一个拷贝，所以建议使用引用返回，加一个&

}

//引用返回是为了提高效率

//=====指针和引用功能相似，但不能用指针替代引用，因为引起的改变很多、很繁琐、代码很复杂，可读性变差

//会让原本的拷贝构造Date d3(d2);变成Date d3(&d2);，已经变成一个普通的构造了（因为没有自身类类型引用了）

没有显式实现时，编译器会自动生成一个默认赋值运算符重载，默认赋值运算符重载行为跟默认拷贝构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的赋值重载。

和前面的拷贝构造类似，这里自动生成的默认赋值运算符重载不一定适合各个类型，分析如下：

5.2.3 是否需要显示实现赋值运算符重载

内置类型且无资源–不需要： 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就可以完成需要的拷贝，所以不需要我们显示实现赋值运算符重载。内置类型–需要： 像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的赋值运算符重载完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。自定义类型成员–不需要： 像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动生成的赋值运算符重载会调用Stack的赋值运算符重载，也不需要我们显示实现MyQueue的赋值运算符重载。小tips： 这里还有一个小技巧，如果一个类显示实现了析构并释放资源，那么他就需要显示写赋值运算符重载，否则就不需要。

---

文末结语：感谢uu支持，愿各位读者事业有成、学业进步！