🌟个人主页：落叶
目录
类的默认成员函数
构造函数
无参构造
带参构造函数
全缺省构造函数
析构函数
对⽐C和C++解决括号匹配问题
C语言版的Stack
C++版的Stack
拷⻉构造函数
类的默认成员函数
默认成员函数就是⽤⼾没有显式实现，编译器会⾃动⽣成的成员函数称为默认成员函数。⼀个类，我 们不写的情况下编译器会默认⽣成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最 后两个取地址重载不重要，我们稍微了解⼀下即可。其次就是C++11以后还会增加两个默认成员函数， 移动构造和移动赋值，这个我们后⾯再讲解。默认成员函数很重要，也⽐较复杂，我们要从两个⽅⾯ 去学习：
- 第⼀：我们不写时，编译器默认⽣成的函数⾏为是什么，是否满⾜我们的需求。
- 第⼆：编译器默认⽣成的函数不满⾜我们的需求，我们需要⾃⼰实现，那么如何⾃⼰实现？
构造函数
构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并 不是开空间创建对象(我们常使⽤的局部对象是栈帧创建时，空间就开好了)，⽽是对象实例化时初始化 对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数⾃动调⽤的 特点就完美的替代的了Init。
构造函数的特点：
1. 函数名与类名相同。
2. ⽆返回值。(返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)
3. 对象实例化时系统会⾃动调⽤对应的构造函数。
4. 构造函数可以重载。
5. 如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦⽤⼾显 式定义编译器将不再⽣成。
6. ⽆参构造函数、全缺省构造函数、我们不写构造时编译器默认⽣成的构造函数，都叫做默认构造函 数。但是这三个函数有且只有⼀个存在，不能同时存在。⽆参构造函数和全缺省构造函数虽然构成 函数重载，但是调⽤时会存在歧义。要注意很多人会认为默认构造函数是编译器默认⽣成那个叫 默认构造，实际上⽆参构造函数、全缺省构造函数也是默认构造，总结⼀下就是不传实参就可以调 ⽤的构造就叫默认构造。
6.1 默认构造有3个⽆参构造函数、全缺省构造函数，还有编译器生成的默认构造，但是这3个函数只能有一个存在，
7. 我们不写，编译器默认⽣成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始 化是不确定的，看编译器。对于⾃定义类型成员变量，要求调⽤这个成员变量的默认构造函数初始 化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要⽤ 初始化列表才能解决，初始化列表，我们下个章节再细细讲解。
说明：C++把类型分成内置类型(基本类型)和⾃定义类型。内置类型就是语⾔提供的原⽣数据类型， 如：int/char/double/指针等，⾃定义类型就是我们使⽤class/struct等关键字⾃⼰定义的类型。
无参构造
add会自动调用构造函数，类中没有显式定义构造函数，编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦⽤⼾显 式定义编译器将不再⽣成。
#include<iostream>
using namespace std;
class date
{
public:
//无参构造
date()
{
_year = 1;
_month = 1;
_day = 1;
}
//打印
void day()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
private:
int _year;//年
int _month;//月
int _day;//日
};
int main()
{
//实例化
date add; //这里会调用默认构造（无参构造）
add.day();
}如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法 区分这⾥是函数声明还是实例化对象。
// 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法
// 区分这⾥是函数声明还是实例化对象
// warning C4930: “date d3(void)”: 未调⽤原型函数(是否是有意⽤变量定义的?)
date d3();
结果：
带参构造函数
当add有参的话，编译器会调用带参构造。
#include<iostream>
using namespace std;
class date
{
public:
//带参构造
date(int year,int month,int day)
{
_year = year;
_month = month;
_day = day;
}
//打印
void day()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
private:
int _year;//年
int _month;//月
int _day;//日
};
int main()
{
//实例化
date add(2024,9,9);
add.day();
}
结果：
全缺省构造函数
当add有参的话，也会调用全缺省构造函数。
#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 day()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
private:
int _year;//年
int _month;//月
int _day;//日
};
int main()
{
//实例化
date add(2024);
add.day();
}结果：
编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化
#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的构造函数调⽤了Stack的构造，完成了两个成员的初始化
private:
Stack pushst;
Stack popst;
};
int main()
{
MyQueue mq;
return 0;
}结果：
析构函数
析构函数与构造函数功能相反，析构函数不是完成对对象本⾝的销毁，⽐如局部对象是存在栈帧的， 函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会⾃动调⽤析构函数，完成对 象中资源的清理释放⼯作。析构函数的功能类⽐我们之前Stack实现的Destroy功能，⽽像Date没有 Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。
析构函数的特点：
1. 析构函数名是在类名前加上字符~。
2. ⽆参数⽆返回值。(这⾥跟构造类似，也不需要加void)
3. ⼀个类只能有⼀个析构函数。若未显式定义，系统会⾃动⽣成默认的析构函数。
4. 对象⽣命周期结束时，系统会⾃动调⽤析构函数。
5. 跟构造函数类似，我们不写编译器⾃动⽣成的析构函数对内置类型成员不做处理，⾃定类型成员会 调⽤他的析构函数。
6. 还需要注意的是我们显⽰写析构函数，对于⾃定义类型成员也会调⽤他的析构，也就是说⾃定义类 型成员⽆论什么情况都会⾃动调⽤析构函数。
7. 如果类中没有申请资源时，析构函数可以不写，直接使⽤编译器⽣成的默认析构函数，如Date；如果默认⽣成的析构就可以⽤，也就不需要显⽰写析构，如MyQueue；但是有资源
申请时，⼀定要 ⾃⼰写析构，否则会造成资源泄漏，如Stack。
8.⼀个局部域的多个对象，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;
}
//析构函数
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
STDataType* _a;
size_t _capacity;
size_t _top;
};
int main()
{
Stack add;
return 0;
}结果：
这个Myqueue里的Stack会自动调用，Stack类里的析构函数，所以我们不用担心，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;
}
//析构函数
~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的析构
/*~MyQueue()
{}*/
Stack _pushst;
Stack _popst;
};
int main()
{
Myqueue add;
return 0;
}结果：
特殊情况：
假如_ptr指向了一块空间，那么就可以用析构函数进行释放Myqueue了。
// 两个Stack实现队列
class Myqueue
{
public:
//析构函数
~Myqueue()
{
cout << "Myqueue" << endl;
free(_ptr);
_ptr = nullptr;
}
private:
Stack _pushst;
Stack _popst;
//假如_ptr指向了一块空间，那么就可以用析构函数进行释放Myqueue了
int* _ptr;
};如果类中没有申请资源时，析构函数可以不写，直接使⽤编译器⽣成的默认析构函数，如Date；如果默认⽣成的析构就可以⽤，也就不需要显⽰写析构，如MyQueue；但是有资源
申请时，⼀定要 ⾃⼰写析构，否则会造成资源泄漏，如Stack。
总结：一般情况下显示的申请空间，才需要自己实现析构函数，其他情况基本都不需要写。
8.⼀个局部域的多个对象，C++规定后定义的先析构。
定义的先析构，就是从下往上析构，先析构Myqueue，再到Stack，然后date。
对⽐C和C++解决括号匹配问题
对⽐⼀下⽤C++和C实现的Stack解决之前括号匹配问题isValid，我们发现有了构造函数和析构函数确 实⽅便了很多，不会再忘记调⽤Init和Destory函数了，也⽅便了不少。
这是OJ题目的连接:OJ题目【栈和队列】-CSDN博客
C语言版的Stack
// ⽤之前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;
}C++版的Stack
在C++里我们就不用自己初始化了，编译器会自动调用构造函数，
在调用成员函数的时候，就不会传地址了，C++有个this隐含的指针。
C语言在每次生命周期结束前都会调用销毁函数，C++就不一样了，生命周期结束前编译器会调用析构函数，不需要我们显示写。
// ⽤最新加了构造和析构的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();
}拷⻉构造函数
如果⼀个构造函数的第⼀个参数是⾃⾝类类型的引⽤，且任何额外的参数都有默认值，则此构造函数也叫做拷⻉构造函数，也就是说拷⻉构造是⼀个特殊的构造函数。
拷⻉构造的特点：
1. 拷⻉构造函数是构造函数的⼀个重载。
2. 拷⻉构造函数的第⼀个参数必须是类类型对象的引⽤，使⽤传值⽅式编译器直接报错，因为语法逻辑上会引发⽆穷递归调⽤。?拷⻉构造函数也可以多个参数，但是第⼀个参数必须是类类型对象的引⽤，后⾯的参数必须有缺省值。
3. C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返回都会调⽤拷⻉构造完成。
4. 若未显式定义拷⻉构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构造。5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。像MyQueue这样的类型内部主要是⾃定义类型Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实现MyQueue的拷⻉构造。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现了析构并释放资源，那么他就需要显⽰写拷⻉构造，否则就不需要。
6. 传值返回会产⽣⼀个临时对象调⽤拷⻉构造，传引⽤返回，返回的是返回对象的别名(引⽤)，没有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回。
c++规定：类类型传值传参必须调用拷贝构造
我们来看这个拷贝构造，把add的数值拷贝给tab。但是为什么要用引用呢？
#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 go(date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
private:
int _year;//年
int _month;//月
int _day;//日
};
int main()
{
date add(2024,9,10);
//拷贝构造，把add的数拷贝初始化给tab
date tab(add);
//date tab = add;//当然也可以这样写
return 0;
}c++规定：类类型传值传参必须调用拷贝构造。
我们可以看到，类类型传值传参会调用拷贝构造，这样会无线的形成拷贝构造，就会无穷递归了。
所以使用引用，就不是类类型传值传参了，引用传的是d1的别名，这样就不会导致无穷递归了。
3. C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返回都会调⽤拷⻉构造完成。返回类类型，用类类型接收。
这个ret会返回临时对象，然后局部空间生命周期没了，临时对象会去调用d这个拷贝构造，这就造成权限放大了，
这里函数结束， ret对象就销毁了，也相当于了⼀个野引⽤。
权限放大：就是本来只能读的权限，调用d之后就可以修改数值，这就是权限放大。
权限缩小：就是可以读和写的权限，经过const修饰，不能写了，只能读，这就是权限缩小。
总的来说，权限放大就是多了一个或多个权限，权限缩小就是少了一个或多个权限。
Date f()
{
Date ret;
//...
return ret;
}
int main()
{
Date d5(f());
Date d6 = f();
return 0;
}
用const修饰就好了。
建议：以后不需要改变d里的成员数值的话，用const修饰，不然可以会导致权限放大。
//拷贝构造
Date(const Date& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}那么传指针会不会无穷递归呢，其实是不会的，
但是传指针的话就不是拷贝构造了，就只是一个普通的构造（函数）了。
#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;
}
private:
int _year;//年
int _month;//月
int _day;//日
};
int main()
{
date add(2024,9,10);
//拷贝构造，把add的数拷贝初始化给tab
date tab(&add);
return 0;
}
4. 若未显式定义拷⻉构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构造。
我们可以看到不显示定义拷贝构造，编译器会自动生成拷贝构造函数，生成的就是浅拷贝，一个字节一个字节的拷贝。
那如果是一个栈呢。
#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);
_capacity = 0;
_top = 0;
}
private:
STDataType* _a;
size_t _capacity;
size_t _top;
};
int main()
{
Stack st1;
Stack st2(st1);
return 0;
}
栈用浅拷贝的话，2个对象都会指向同一块空间，
st2先析构，再到st1，st2都已经把空间释放了，就不能再释放了。
我们可以看到下面这个报错，就是释放2次同一块空间，导致的报错。
这种情况，就要用到深拷贝了。
#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(const Stack& add)
{
//申请一块新的空间
_a = (STDataType*)malloc(sizeof(STDataType) * add._capacity);
if (_a == nullptr)
{
perror("malloc申请空间失败");
return;
}
//拷贝空间里的值
memcpy(_a, add._a, sizeof(STDataType) * add._top);
_capacity = add._capacity;
_top = add._top;
}
//析构函数
~Stack()
{
cout << "~Stack" << endl;
free(_a);
_capacity = 0;
_top = 0;
}
private:
STDataType* _a;
size_t _capacity;
size_t _top;
};
int main()
{
Stack st1(10);
//把st1拷贝给st2
Stack st2(st1);
return 0;
}深拷贝
给st2申请一块和st1一样的空间，然后用memcpy拷贝st1空间的值给st2。
这样析构就不会是同一块空间了。
像日期类那种没有指向空间的，使用编译器自动生成的浅拷贝就行了。
总结：
第⼀：我们不写时，编译器默认⽣成的函数⾏为是什么，是否满⾜我们的需求。
第⼆：编译器默认⽣成的函数不满⾜我们的需求，我们需要⾃⼰实现，那么如何⾃⼰实现？
像这种MyQueue我们可以不用写拷贝构造，
MyQueue成员的，Stack会自动调用函数里的深拷贝，所以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;
}
//深拷贝
Stack(const Stack& add)
{
//申请一块新的空间
_a = (STDataType*)malloc(sizeof(STDataType) * add._capacity);
if (_a == nullptr)
{
perror("malloc申请空间失败");
return;
}
//拷贝空间里的数值
memcpy(_a, add._a, sizeof(STDataType) * add._top);
_capacity = add._capacity;
_top = add._top;
}
//析构函数
~Stack()
{
cout << "~Stack" << endl;
free(_a);
_capacity = 0;
_top = 0;
}
private:
STDataType* _a;
size_t _capacity;
size_t _top;
};
class MyQueue
{
public:
private:
Stack pushst;
Stack popst;
};
int main()
{
MyQueue m1;
MyQueue m2(m1);
return 0;
}
5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。像MyQueue这样的类型内部主要是⾃定义类型Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实现MyQueue的拷⻉构造。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现了析构并释放资源，那么他就需要显⽰写拷⻉构造，否则就不需要。
6. 传值返回会产⽣⼀个临时对象调⽤拷⻉构造，传引⽤返回，返回的是返回对象的别名(引⽤)，没有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回。
