---

♥♥♥~~~~~~欢迎光临知星小度博客空间~~~~~~♥♥♥

♥♥♥零星地变得优秀~也能拼凑出星河~♥♥♥

♥♥♥我们一起努力成为更好的自己~♥♥♥

♥♥♥如果这一篇博客对你有帮助~别忘了点赞分享哦~♥♥♥

♥♥♥如果有什么问题可以评论区留言或者私信我哦~♥♥♥

✨✨✨✨✨✨ 个人主页✨✨✨✨✨✨

---

在前面一篇博客类与对象（第一集），我们简单了解了一下C++中的类与对象~接下来，我们要更加深层次的探讨C++中的类与对象~体会C++的魅力~准备好了吗~我们发车啦~🚗🚗🚗🚗🚗🚗

目录

类的默认成员函数

构造函数

析构函数

构造函数和析构函数的好处

拷贝构造函数

类的默认成员函数

前面我们提到了类里面有成员变量和成员函数，那么什么是默认成员函数呢？

定义：

》默认成员函数就是用户（程序员）没有显式实现，编译器会自动生成的成员函数称为默认成员函数

接下来，我们一个个来看~

构造函数

构造函数是特殊的成员函数，构造函数虽然名称叫构造，但是 构造函数的 主要任务 并不是开空间创建对象(我们常使用的局部对象是栈帧创建时，空间就已经开好)，而是对象实例化时 初始化对象 。

这样看来，构造函数的本质是要替代我们以前Stack和Date类中写的Init（初始化）函数的功能。同时， 构造函数自动调用 的 特点就完美的替代的了Init函数调用。

1. 函数名与类名相同 。

》函数名与类名相同，有利于编译器识别这个函数是用于类初始化的函数，而不是普通的成员函数

class Date
{
public:
	//构造函数函数名与类名相同
	Date()
	{
		//构造函数
	}
};

2. 无返回值 。 (C++规定构造函数 不需要返回值，同时也不需要写void)

》 构造函数的存在是为了初始化对象，而不是返回数据~我们可以理解为规定~

3. 对象实例化时 系统会 自动调用对应的构造函数 。

》 （这就不需要我们手动调用构造函数了，更加方便，同时也避免了忘记初始化的情况~）

#include<iostream>
using namespace std;
class Date
{
public:
	//构造函数函数名与类名相同
	Date()
	{
		//构造函数
		cout << "Date()" << endl;
	}
};
int main()
{
	Date d1;//创建一个对象
	//对象实例化时系统会自动调用对应的构造函数
	return 0;
}

4. 构造函数可以重载

》 也就是说我们可以在同一个类里面写多个构造函数，来满足不同的初始化需求~

》 函数重载的要求是函数参数个数或者类型不同

#include<iostream>
using namespace std;
class Date
{
public:
	//构造函数函数名与类名相同
	Date()
	{
		//构造函数
		cout << "Date()" << endl;
	}
	// 构造函数可以重载
	Date(int y)
	{
		cout << "Date(int y)" << endl;
	}

};
int main()
{
	Date d1;//创建一个对象
	Date d2(2);
	return 0;
}

5. 如果类中没有显式定义构造函数，则C++编译器会自动生成⼀个无参的默认构造函数 ，如果用户显 式定义编译器将不再生成~

》 这样看来，编译器还是十分强大的，当我们忘记写构造函数，编译器自动生成一个没有参数的默认构造函数~

没有写构造函数，就会使用编译器生成的默认构造函数~

6. 无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数 ，都叫做 默认构造函数

》 这 三个函数有且只有一个存在 ，不能同时存在（默认构造函数只存在一个）

》 无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义（编译器不知道调用哪一个）

》总结： 不传实参就可以调用的构造函数就叫默认构造函数

#include<iostream>
using namespace std;
class Date
{
public:
	Date()
	{
		cout << "Date()" << endl;
	}
	Date(int y = 2)
	{
		cout << "Date(int y)" << endl;
	}

};
int main()
{
	Date d1();//创建一个对象
	return 0;
}

因为编译器不知道调用哪一个，虽然没有报错，但是没有输出结果~这是存在歧义的~

7. 编译器生成的默认构造函数，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是由编译器决定的，那么初始化的值也是不确定的。

但是对于自定义类型成员变量必须调用这个成员变量的默认构造函数初始 化。

》 如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要使用初始化列表（后面的博客会讲解）才能解决

补充：

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

内置类型就是语言提供的原始数据类型 ， 如： int/char/double/指针 等

自定义类型就是我们使用class/struct/union等关键字自己定义的类型

我们来看看下面的代码：

#include<iostream>
using namespace std;
class Date
{
private:
	int _year;
	int _month;
	int _day;

public:
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
};

int main()
{
	Date d1;//调用编译器生成的默认构造函数
	d1.Print();
	return 0;
}

我们可以看到年月日都是随机的，那么这肯定不是我们想要的~

所以如果这里我们使用编译器自动生成的默认构造函数，不能满足我们的需求~我们就需要自己写构造函数~比如日期类（我们肯定不希望日期是随机的的，未真正初始化的）

#include<iostream>
using namespace std;
class Date
{
private:
	int _year;
	int _month;
	int _day;
	
public:
	//构造函数
	//成员函数前面有一个隐含的this指针
	// Date* const this
	Date(int year,int month,int day)
	{
		_year = year;//相当于this->_year = year;
		_month = month;
		//this->_month = month;
		_day = day;
		//this->_day = day;
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
};

int main()
{
	Date d1(2024, 11, 11);//调用自己写的构造函数，满足我们的需求
	d1.Print();
	return 0;
}

又比如我们的栈~

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

那如果是使用两个栈实现一个队列，这种情况如果栈写了构造函数，就不需要写构造函数了~

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

这里栈的构造函数已经实现了队列的成员初始化~

总结：目前来看，大多数情况下需要自己写构造函数，如果一个类里面的成员全部是自定义类型，并且自定义类型的构造函数已经写好了，那么就不需要我们写构造函数了，比如两个栈实现一个队列，后续我们会了解更多的不需要自己写构造函数的情况

析构函数

了解了构造函数，我们就来看看与它作用相反的析构函数，既然构造函数是用来初始化的，那么析构函数就是用来对对象中的资源在生命周期结束时进行清理（类似于以前的Destory函数），比如手动申请的空间等等~

注意：

》 析构函数 不是完成对对象本身的销毁 ，只是 完成对象中资源的清理释放工作 ~比如局部对象是存在栈帧的，函数结束栈帧销毁，他就已经释放了，不需要我们管~像我们动态开辟的内存就需要我们手动释放资源

》 C++规定 对象在销毁时会自动调用析构函数 ，这样就可以 避免我们忘记释放资源而导致内存泄漏~

析构函数的特点

1. 析构函数名是 在类名前加上字符 ~，同时 函数名与类名相同~

2. 无参数无返回值 。 (同样不需要加void)

3. 对象生命周期结束时，系统会自动调用析构函数 。

#include<iostream>
using namespace std;
class Date
{
public:
	//构造函数函数名与类名相同
	Date()
	{
		//构造函数
		cout << "Date()" << endl;
	}
	//析构函数
	~Date()
	{
		cout << "~Date()" << endl;
	}
};
int main()
{
	Date d1;//对象实例化
	return 0;
}

4. ⼀个类只能有⼀个析构函数 。若 未显式定义，系统会自动生成默认的析构函数 。

（与前面构造函数类似~）

5. 跟构造函数类似，当我们不写 编译器自动生成的析构函数对内置类型成员不做处理 ， 自定义类型的成员会调用他的析构函数释放资源 。

6. 我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说 自定义类型成员无论什么情况都会自动调用析构函数，避免出现内存泄漏的情况~

7. 如果类中 没有申请资源时，析构函数可以不写 ，直接使用编译器生成的默认析构函数，如Date类；如果 默认生成的析构就足够使用，也不需要显示写析构 ，如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;
	}
	//栈的析构函数必须自己写，释放资源
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_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;
	}
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	Stack st;
	MyQueue mq;
	return 0;
}

8. ⼀个局部域的多个对象，C++规定 后定义的先析构，（后面会讲到这个内容）

构造函数和析构函数的好处

》编译器有时候自动生成的默认构造函数和默认构造函数满足我们需求的情况下，可以减少我们的代码量（如两个栈实现队列不需要自己写析构函数，也不需要写构造函数）

》编译器会自动调用构造函数和析构函数，就可以避免内存泄漏或者忘记初始化的情况~同时不用显示调用，也减少了我们的代码量~

拷贝构造函数

接下来就是这篇博客的重点了~拷贝构造函数~首先我们就需要知道拷贝构造函数是干什么的~

拷贝构造函数是用来通过一个已经初始化的对象去初始化另外一个新创建的对象~

拷贝构造函数 显示的第一个参数是自身类类型的引用 ，且任何额外的参数都有默认值~

1. 拷贝构造函数是构造函数的⼀个重载（函数名相同，都是类名）~

可以理解为拷贝构造函数是特殊的构造函数~

2. 拷贝构造函数的 参数只有⼀个 ，并且 必须是类类型对象的引用

》 使用传值方式编译器直接报错，因为语 法逻辑上会引发无穷递归调用~在传参的时候相当于也需要调用拷贝构造函数就回不来了~

#include<iostream>
using namespace std;
class Date
{
public:
	//构造函数
	Date(int year,int month,int day)
	{
		_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, 11, 11);//d1调用构造函数
	Date d2(d1);//调用拷贝构造函数~用已经存在的对象去初始化新的对象
	Date d3 = d1;//同样是调用拷贝构造函数~用已经存在的对象去初始化新的对象
	d1.Print();
	d2.Print();
	d3.Print();
	return 0;
}

3. C++规定 自定义类型对象进行拷贝行为必须调用拷贝构造 ，所以这里 自定义类型 传值传参 和 传值返回 （它们都会产生临时对象）都会调用拷贝构造完成~

注意：

》 传值返回会产生⼀个临时对象调用拷贝构造

》 传值使用引用返回，返回的是返回对象的别名，没有产生拷贝

》 如果 返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回就有问题，这时的引用相当于⼀个野引用，类似⼀个野指针⼀样

》 传引用返回可以减少拷贝，但是 ⼀定要确保返回对象，在当前函数结束后还在，才能使用引用返回~

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


//void Func1(Date d)//调用拷贝构造完成拷贝（产生了一个临时对象）
void Func1(Date& d)//使用引用传参优化，不需要拷贝构造，传自身，减少拷贝构造次数~
{
	cout << "&d" << endl;
	cout << &d << endl;
	cout << "d.Print()" << endl;
	d.Print();
}

Date Func2()//返回对象也会调用拷贝构造函数（相当于产生了一个临时对象）
//Date& Func2()//使用引用返回，不需要拷贝构造，返回自身，存在问题//err
//问题：Func2函数结束，tmp对象就销毁了，相当于了⼀个野引用
{
	Date tmp(2024, 2, 2);
	cout << "tmp.Print()" << endl;
	tmp.Print();
	return tmp;
}
int main()
{
	Date d1(2024, 11, 11);
	cout << "d1.Print()" << endl;
	d1.Print();
	//d1传值传参给d要调用拷贝构造完成拷贝，使用传引用传参可以减少拷贝
	cout << "&d1" << endl;
	cout << &d1 << endl;
	Func1(d1);

	
	Date ret = Func2();
	cout << "ret.Print()" << endl;
	ret.Print();
	return 0;
}

4. 若未显式定义拷贝构造，编译器会自动生成一个拷贝构造函数 ~

》 自动生成的拷贝构造 对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝) ， 对自定义类型成员变量会调用他的拷贝构造 。

#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(2024, 11, 11);//d1调用构造函数
	Date d2(d1);//调用编译器自动生成的拷贝构造函数
	Date d3 = d1;//调用编译器自动生成的拷贝构造函数
	//自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝)
	d1.Print();
	d2.Print();
	d3.Print();
	return 0;
}

》 浅拷贝也就是把对象中的值拷贝过来~相当于共享同一份资源（比如内存空间、文件） ，那么如果对象中存在资源管理，比如动态开辟内存， 当多个对象共享同一份资源（内存空间）时，资源/空间释放的时候就会释放多次 （一个对象销毁时就已经释放了，其他对象不知道依然认为有效的~）这就会出问题~

》 还可能出现的问题是 一个对象修改时，会影响其他与它共享这个资源的对象 ~

》 深拷贝就可以很好的解决这个问题， 每一个对象都独立拥有一份资源（空间） ，这样就不会导致访问出错~

5.

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

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

》 像 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(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;
	MyQueue mq1;
	// MyQueue自动生成的拷贝构造，会自动调用Stack拷贝构造完成pushst/popst
	// 的拷贝，只要Stack拷贝构造实现了深拷贝，就没问题~
	MyQueue mq2 = mq1;
	return 0;
}

---

♥♥♥本篇博客内容结束，期待与各位优秀程序员交流，有什么问题请私信♥♥♥

♥♥♥如果这一篇博客对你有帮助~别忘了点赞分享哦~♥♥♥

✨✨✨✨✨✨个人主页✨✨✨✨✨✨

---