✅<1>主页：我的代码爱吃辣
📃<2>知识讲解：C++
🔥<3>创作者：我的代码爱吃辣
☂️<4>开发环境：Visual Studio 2022
💬<5>前言：C++类中一共有六个默认成员函数，今天我们先来认识构造函数，析构函数，和拷贝构造函数。
目录
一.类的六个默认成员函数
如果一个类中什么成员都没有，简称为空类。
空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员
函数。
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。
class Date {};
二构造函数
（1）概念
-
class
Date
-
{
-
public:
-
void Init(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.
Init(
2022,
7,
5);
-
d1.
Print();
-
Date d2;
-
d2.
Init(
2022,
7,
6);
-
d2.
Print();
-
return
0;
-
}
对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置
信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？
构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证
每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。
（2）特性
构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任
务并不是开空间创建对象，而是初始化对象。
其特征如下：
1.函数名与类名相同。
2.无返回值。
3.构造函数可以重载。
-
class
Date
-
{
-
public:
-
// 1.无参构造函数
-
Date()
-
{}
-
// 2.带参构造函数
-
Date(
int year,
int month,
int day)
-
{
-
_year = year;
-
_month = month;
-
_day = day;
-
}
-
private:
-
int _year;
-
int _month;
-
int _day;
-
};
-
void TestDate()
-
{
-
Date d1;
// 调用无参构造函数
-
Date d2(2015, 1, 1);
// 调用带参的构造函数
-
-
Date d3();
-
}
注意：
Date d3();如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明。
以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象。
warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
4.对象实例化时编译器自动调用对应的构造函数。
我们通过调试来观察，当我们实例化一个对象的时候，会不会自动调用他的构造函数。
5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦
用户显式定义编译器将不再生成。
-
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;
-
return
0;
-
}
上述程序成功执行。
-
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;
-
return
0;
-
}
- 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数。
- 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成。
- 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用。
在我们没有自己设计构造函数的时候，编译器会自己生成一个构造函数，我们来看一下编译器自己生成的构造函数会做些什么。
-
class
Date
-
{
-
public:
-
void Print()
-
{
-
cout << _year <<
"/" << _month <<
"/" << _day << endl;
-
}
-
private:
-
int _year;
-
int _month;
-
int _day;
-
};
-
int main()
-
{
-
Date d1;
-
d1.
Print();
-
-
return
0;
-
}
不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？
解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类
型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看
下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员
函数。
-
class
Time
-
{
-
public:
-
Time()
-
{
-
cout <<
"Time()" << endl;
-
_hour =
0;
-
_minute =
0;
-
_second =
0;
-
}
-
-
private:
-
int _hour;
-
int _minute;
-
int _second;
-
};
-
class
Date
-
{
-
public:
-
void Print()
-
{
-
cout << _year <<
"/" << _month <<
"/" << _day << endl;
-
}
-
-
private:
-
// 基本类型(内置类型)
-
int _year;
-
int _month;
-
int _day;
-
// 自定义类型
-
Time
_t;
-
-
};
-
int main()
-
{
-
Date d;
-
d.
Print();
-
return
0;
-
}
这里打印了"Print()"，也就是说编译器对_t成员变量调用了它的构造函数，也就说明在d对象里面我们没有自己实现构造函数，而编译器自己实现的构造函数，只对自定义类型成员变量做处理（调用其对应的构造函数），对内置类型是不做任何处理的。
对于上述的结果，我们应该有一个疑惑。如果我们就是没有实现构造函数，那对于我们来说对处理手动实现构造函数以外，还有没有其他的方式来实现对内置类型的成员变量的初始化呢？
在C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在
类中声明时可以给默认值。如下面代码：
-
class
Date
-
{
-
public:
-
void Print()
-
{
-
cout << _year <<
"/" << _month <<
"/" << _day << endl;
-
}
-
-
private:
-
// 基本类型(内置类型)
-
int _year =
2022;
-
int _month =
2;
-
int _day =
5;
-
};
-
int main()
-
{
-
Date d;
-
d.
Print();
-
return
0;
-
}
6.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
-
class
Date
-
{
-
public:
-
Date()
-
{
-
_year =
1900;
-
_month =
1;
-
_day =
1;
-
}
-
Date(
int year =
1900,
int month =
1,
int day =
1)
-
{
-
_year = year;
-
_month = month;
-
_day = day;
-
}
-
private:
-
int _year;
-
int _month;
-
int _day;
-
};
-
// 以下测试函数能通过编译吗？
-
int main(){
-
{
-
Date d1;
-
}
无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。所以也就导致，实例化一个对象的时候，编译器就无法分清楚该调用那个构造函数，这就是默认构造函数只能与一个的原因。
我们给d1对象指定的实际参数列表：
-
class
Date{
-
public:
-
Date(){
-
_year =
1900;
-
_month =
1;
-
_day =
1;
-
}
-
Date(
int year =
1900,
int month =
1,
int day =
1){
-
_year = year;
-
_month = month;
-
_day = day;
-
}
-
private:
-
int _year;
-
int _month;
-
int _day;
-
};
-
// 以下测试函数能通过编译吗？
-
int main(){
-
//给出实际参数
-
Date d1(10,200,300);
-
}
此时又可以成功的编译了，当我们写了参数，也就给编译器指定了调用构造函数。
三.析构函数
大家还记得Leetcode有效的括号这一题嘛，我们利用栈结构来进行括号的匹配。
其中的主要逻辑代码：
-
bool isValid(char * s){
-
ST* stact =
StactInit();
-
while(*s)
-
{
-
if(*s==
'('||*s==
'{'||*s==
'[')
-
{
-
StactPushBank(stact,*s);
-
s++;
-
}
-
else
-
{
-
if(
StactEmpty(stact))
-
{
-
StactDestory(stact);
-
return
false;
-
}
-
char ch=
StactTop(stact);
-
StactPopBank(stact);
-
if((ch==
'(' && *s==
')')||
-
(ch==
'[' && *s==
']')||
-
ch==
'{' && *s==
'}')
-
{
-
s++;
-
}
-
else
-
{
-
StactDestory(stact);
-
return
false;
-
}
-
}
-
}
-
if(!
StactEmpty(stact))
-
{
-
StactDestory(stact);
-
return
false;
-
}
-
StactDestory(stact);
-
return
true;
-
}
我们要充分考虑各种可能结束的情况，从而在每次结束之前对栈进行销毁，可谓非常的不爽。
而在C++中就是非常好的解决了这个问题——析构函数。
（1）概念
通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？
析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由
编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
（2）特性
析构函数是特殊的成员函数，其特征如下：
1.析构函数名是在类名前加上字符 ~。
2.无参数无返回值类型。
3.一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载。
-
typedef
int DataType;
-
class
Stack
-
{
-
public:
-
Stack(
size_t capacity =
3)
-
{
-
_array = (DataType*)
malloc(
sizeof(DataType) * capacity);
-
if (
NULL == _array)
-
{
-
perror(
"malloc申请空间失败!!!");
-
return;
-
}
-
_capacity = capacity;
-
_size =
0;
-
}
-
void Push(DataType data)
-
{
-
// CheckCapacity();
-
_array[_size] = data;
-
_size++;
-
}
-
// 其他方法...
-
-
//析构函数
-
~
Stack()
-
{
-
if (_array)
-
{
-
free(_array);
-
_array =
NULL;
-
_capacity =
0;
-
_size =
0;
-
}
-
}
-
-
private:
-
DataType* _array;
-
int _capacity;
-
int _size;
-
};
4.对象生命周期结束时，C++编译系统系统自动调用析构函数。
5. 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器
生成的默认析构函数，对自定类型成员调用它的析构函数。
-
class
Time
-
{
-
public:
-
~
Time()
-
{
-
cout <<
"Time()" << endl;
-
}
-
private:
-
int _hour=
0;
-
int _minute=
0;
-
int _second=
0;
-
};
-
class
Date
-
{
-
private:
-
// 基本类型(内置类型)
-
int _year =
1970;
-
int _month =
1;
-
int _day =
1;
-
// 自定义类型
-
Time
_t;
-
};
-
int main()
-
{
-
Date d();
-
return
0;
-
}
程序运行结束后输出：~Time()
在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？
因为：
- main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month,_day三个是 内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可。
- 而_t是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。
- 但是：main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数。
- 注意：创建哪个类的对象则调用该类的够构函数，销毁那个类的对象则调用该类的析构函数。
6.如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如
Date类；有资源申请时，一定要写，并且正确的 free() 我们申请的空间，否则会造成内存泄漏，比如Stack类。
四.拷贝构造函数
在生活中，可能存在长得非常像的两个人，我们称之为，双胞胎。
如果我们需要实例化两个一模一样的对象，此时就需要调用对象的拷贝构造函数。
（1）概念
在C++中想要拷贝一个对象，就只能通过调用其对应的拷贝构造函数。
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存
在的类类型对象创建新对象时由编译器自动调用。
（2）特性
拷贝构造函数也是特殊的成员函数，其特征如下：
1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，
因为会引发无穷递归调用。
拷贝构造函数的参数只有一个参数，且必须是类类型的对象的引用，如果是值，会引发引发无穷的函数递归调用。
原因：我们知道，函数的传值调用，形式参数是对实际参数的一份临时拷贝，如果参数是类类型，就必须要调用其对应的拷贝构造函数，而调用拷贝构造函数就又要传类类型的参数，又要调用拷贝构造函数~~~~
3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按
字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝
-
class
Time
-
{
-
public:
-
Time()
-
{
-
_hour =
1;
-
_minute =
1;
-
_second =
1;
-
}
-
//拷贝构造函数
-
Time(
const Time& t)
-
{
-
_hour = t._hour;
-
_minute = t._minute;
-
_second = t._second;
-
cout <<
"Time::Time(const Time&)" << endl;
-
}
-
private:
-
int _hour;
-
int _minute;
-
int _second;
-
};
-
class
Date
-
{
-
public:
-
void show()
-
{
-
cout << _year <<
"/" << _month <<
"/" << _day << endl;
-
}
-
private:
-
// 基本类型(内置类型)
-
int _year =
1970;
-
int _month =
1;
-
int _day =
1;
-
// 自定义类型
-
Time
_t;
-
};
-
int main()
-
{
-
Date d1;
-
-
// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
-
// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
-
Date d2(d1);
-
d1.
show();
-
d2.
show();
-
return
0;
-
}
说明：Date d2 (d1) : 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数，如果没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数。输出“Time::Time(const Time&)”，证明自定义类型是调用其拷贝构造函数完成拷贝的；
注意：这也是拷贝构造：
Date d2 = d1;
注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定
义类型是调用其拷贝构造函数完成拷贝的。
什么是深浅拷贝的我们举个例子看看：
4.编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？
当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？
-
class
A
-
{
-
public:
-
A()
-
{
-
a =
10;
-
arr = (
int*)
malloc(
sizeof(
int) * a);
-
for (
int i =
0; i < a; i++)
-
{
-
arr[i] = i;
-
}
-
}
-
void show()
-
{
-
for (
int i =
0; i < a; i++)
-
{
-
cout << arr[i] <<
" ";
-
}
-
cout << endl;
-
}
-
-
int* arr;
-
int a;
-
};
-
int main()
-
{
-
A a;
-
A b(a);
-
//修改b对象的arr数组
-
for (
int i =
0; i < b.a; i++)
-
{
-
b.arr[i]=
0;
-
}
-
//观察两个对象中arr的元素
-
b.
show();
-
a.
show();
-
return
0;
-
}
修改b对象的 arr ，a对象的 arr 也会被修改，浅拷贝危害：就像上述图中，浅拷贝指针和原结构指针，共同指向同一块空间，就会使得两者相互影响。
注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请
时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
5. 拷贝构造函数典型调用场景：
- 使用已存在对象创建新对象
- 函数参数类型为类类型对象
- 函数返回值类型为类类型对象
-
class
Date
-
{
-
public:
-
Date(
int year,
int minute,
int day)
-
{
-
cout <<
"Date(int,int,int):" <<
this << endl;
-
}
-
Date(
const Date& d)
-
{
-
cout <<
"Date(const Date& d):" <<
this << endl;
-
}
-
~
Date()
-
{
-
cout <<
"~Date():" <<
this << endl;
-
}
-
private:
-
int _year;
-
int _month;
-
int _day;
-
};
-
Date Test(Date d)
-
{
-
Date temp(d);
-
return temp;
-
}
-
int main()
-
{
-
Date d1(2022, 1, 13);
-
Test(d1);
-
return
0;
-
}
为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用
尽量使用引用。
-
Date Test(const Date& d)
-
{
-
Date temp(d);
-
return temp;
-
}
我们在test传递参数的时候使用引用，也减少了拷贝构造的调用次数。
转载：https://blog.csdn.net/qq_63943454/article/details/128888988