通俗易懂C++类和对象详解（二）类的默认成员函数及其细节

C++类和对象详解（二）

✅5700字详细介绍类中的默认成员函数

上一篇：C++类和对象详解（一）

---

---

0. 前言

• 类中隐藏的成员函数

在之前的章节中，我们已经学习了成员函数。

class A {
public:
	//类的成员函数
	void fun() {
		cout << "Hello World\n";
	}
private:
	int _i;
	int _j;
};

实际上，类中还隐藏了6个默认的成员函数，如果用户不写，则编译器会自动生成。在以上的代码中，隐藏的6个默认的成员函数如下：

class A {
public:
//== 1.构造函数 ==================
	A(){}
//== 2.析构函数 ==================
	~A(){}
//== 3.拷贝构造函数 ===============
	A(const A &a)
		:_i(a._i)
		,_j(a._j)
	{}
//== 4.赋值运算符重载 =============
	A& operator=(const A &a){
		if (*this != &a) {
			_i = a._i;
			_j = a._j;
		}
		return *this;
	}
//== 5.取地址运算符重载 ============
	A* operator&(){
		return this;
	}
//== 6.const取地址运算符重载 =======
	const A* operator&() const {
		return this;
	}
//===============================

	void fun() {
		cout << "Hello World\n";
	}
private:
	int _i;
	int _j;
};

下面将一一介绍这6个默认的构造函数

---

1. 构造函数

• 构造函数是什么

每个类中都存在构造函数，如果用户不写，编译器则会自动生成。

class A {
public:
	//构造函数
	A() {}
private:
	int _i;
};

构造函数是一个隐藏的默认成员函数，其函数名与类名相同，且不写返回值。

---

• 构造函数的调用

在对象实例化的过程中，构造函数会被调用。

class A {
public:
	A() {
		cout << "test A" << endl;
	}
};

int main() {
	A a1;
	return 0;
}

为了方便观察，我们在构造函数中输出"test A"。

程序输出了"test A"，证明程序调用了构造函数A()。

转到反汇编，可以发现程序在对象实例化A a1;的时候，调用了函数A()。

---

• 构造函数的作用

因为构造函数是在创建对象的时候调用的，因此它常用于初始化对象。

通过函数重载，我们可以自己写构造函数来初始化成员变量。

class A {
public:
	A() {
		_i = 0;
	}
	A(int a) {
		_i = a;
	}
	void print() {
		printf("_i = %d", _i);
	}
private:
	int _i;
};

int main() {
	A a1;
	a1.print();
	A a2(3);
	a2.print();
	return 0;
}

输出结果：

上面的两个构造函数也可以单独写成缺省参数的形式。

A(int a = 0) {
	_i = a;
}

如果类的成员变量中存在自定义类型，那么这个类在实例化对象的时候，也会调用自定义类型的构造函数。

// == A类 =======================
class A {
public:
	A() {
		cout << "Hello A\n";
		_i = 0;
	}
private:
	int _i;
};
// == B类 =======================
class B {
private:
	int _n;
	A _a;
};
// ==============================
int main() {
	B b1;
	return 0;
}

以上的代码中，由于B类型中包含A的对象，所以在main函数中创建B类的对象b1时，会调用A类的构造函数。

---

• 内置类型的初始化

类初始化时，默认会处理自定义类型，调用自定义类型的构造函数，但是默认不对内置类型进行初始化。在C++11中规定：内置类型在类中声明可以给予初值。

class A {
public:
	int a = 1;
	int b = 2;
};

struct St {
	int c = 3;
	int d = 4;
};

• 初始化列表

在之前的初始化对象中，成员变量是在构造函数内部被赋值初始化的。

A(int a = 0) {
	_i = a;
}

这个赋值操作也可以写成初始化列表的形式：

A(int a = 0)
	:_i(a)
{}

初始化列表的写法：

1. 初始化列表写在函数的圆括号)之后，花括号{之前。一般写在其中间一行，且向后缩进。
2. 初始化列表以冒号:开头，以逗号,分隔成员列表，不以分号结尾。
3. 每个成员的初始值或表达式放入圆括号()中，写在成员之后。

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

如果类中存在const修饰的常量或者引用的成员变量，则必须使用初始化列表进行初始化。

class A {
public:
	A(int &i, int c = 0)
		:c_(c)
		,i_(i)
	{}
private:
	int& i_;
	const int c_;
};

int main() {
	int i = 10;
	A a(i, 20);
	return 0;
}

---

• explicit关键字

在创建对象时，对于只有一个参数或者第一个参数之后的参数都有默认值的构造函数，除了用函数调用的形式传参，还可以用等号=进行类型转换赋值。

class A {
public:
	A(int a = 0)
		:_i(a)
	{}
private:
	int _i;
};

int main() {
	A a1(1);
	A a2 = 2;
	return 0;
}

如果使用explicit关键字修饰构造函数，则会禁止这种构造函数的隐式类型转换。

class A {
public:
	explicit A(int a = 0, int b = 2)
		:_i(a)
	{}
private:
	int _i;
};

int main() {
	A a1(1);
//	A a2 = 2; //禁止使用
	return 0;
}

---

2. 析构函数

• 析构函数是什么

析构函数也是类中的6个默认函数之一，它的写法为：在构造函数之前加一个~符号。

• 析构函数的调用

在对象声明周期结束时，编译器会调用析构函数。

class A {
public:
	A() {
		cout << "test  A" << endl;
	}
	~A() {
		cout << "test ~A" << endl;
	}
};

int main() {
	A a1;
	return 0;
}

从运行结果来看，程序确实调用了析构函数~A()，那么析构函数具体是在什么时候被调用的呢？

转到反汇编，可以发现，在函数return之后，}之前，程序调用了析构函数。

---

• 析构函数的作用

如果类中的成员变量是内置类型，那么当对象的生命周期结束后，其在栈中开辟的空间会自动被销毁，此时析构函数好像没什么用。但如果类中有通过malloc之类的函数在堆区开辟空间，对象销毁时没有及时释放空间，则会造成内存泄漏。因此，析构函数可以对其开辟的空间进行释放，比如下面的栈。

class Stack {
public:
	Stack(int capa = 4)
		:_capacity(capa)
		,_top(0)
	{
		_data = (int*)malloc(_capacity * sizeof(int));
		assert(_data);
	}
	~Stack() {
		free(_data);
	}
private:
	int _top;
	int _capacity;
	int* _data;
};

上面的代码中，栈中的数据是存放在堆区，并用_data指针标识的。当对象的生命周期结束时，程序只会回收指针_data占用的空间，而不会释放_data指向的空间，所以我们需要用到析构函数来释放这块空间。

---

• 析构函数的调用顺序

对象的析构遵循：先创建的对象后析构，后创建的对象先析构。

int main() {
	A a1;
	A a2;
	return 0;
}

以上的代码中，a1先创建a2后创建，所以在析构时，a2先析构a1后析构。

---

• 析构函数与构造函数的区别

析构函数和构造函数都是类的6个默认函数之一，它们有相似的名字，一个用于初始化，一个用于销毁。

默认成员函数	什么时候调用	能否重载	参数	返回值类型	主要用途
构造函数	对象创建时	可以定义多个重载	可以有参数	无返回值类型	初始化成员变量
析构函数	对象销毁时	一个类中只能存在一个	无参数	无返回值类型	销毁对象中关联的空间

---

3. 拷贝构造函数

• 拷贝构造是什么

拷贝构造是构造函数的一个重载，它也是6个默认函数之一。默认拷贝构造的函数定义如下：

class A {
public:
	A()
		:_i(0)
	{}

	A(const A &a)
		:_i(a._i)
	{}
private:
	int _i;
};

---

• 拷贝构造的调用

当对象发生拷贝时，会调用拷贝构造函数。

下面的代码可以把对象a1拷贝给a2。

A a1;
A a2(a1);

同样的，可以通过下面的代码探究拷贝构造是如何调用的。

class A {
public:
	A()
		:_i(0)
	{}

	A(const A &a)
		:_i(a._i)
	{
		cout << "test A(const A &a)" << endl;
	}
private:
	int _i;
};

int main() {
	A a1;
	A a2(a1);
	return 0;
}

程序输出了拷贝构造函数中的语句，证明程序调用了拷贝构造。

转到反汇编，可以发现在对象发生拷贝时，调用了拷贝构造。

事实上，只要对象发生了拷贝，就必须调用拷贝构造，包括函数传参的过程。

以下的代码中，调用fun函数时，对象a1作为参数被传递给a，此时就会发生形如a(a1)的拷贝构造。

void fun(A a) {

}

int main() {
	A a1;
	fun(a1);
	return 0;
}

因此，拷贝构造函数的参数必须带引用&，写成const A &a的形式，否则就会发生无限递归。如以下的代码：

A(const A a) //错误的！
	:_i(a._i)
{}

此时如果调用拷贝构造函数：

int main() {
	A a1;
	A a2(a1);
	return 0;
}

此时a2对a1进行拷贝，需要调用拷贝构造，而调用拷贝构造时传参又要发生拷贝，再次调用拷贝构造，于是就进入了无限递归。

因此，在定义拷贝构造时必须使用引用传参。

现在的编译器一般在编译时，就能检查出这种不传引用错误。

---

• 拷贝构造的作用

在上面的示例中，拷贝构造只是拷贝了对象中对应的成员变量。这种情况下，不自己写，直接使用编译器默认生成的拷贝构造函数也可以。但在一些特殊情况，就不得不自己定义拷贝构造。

以下的代码是对一个栈进行拷贝，使用了默认的拷贝构造。

class Stack {
public:
	Stack(int capa = 4)
		:_capacity(capa)
		, _top(0)
	{
		_data = (int*)malloc(_capacity * sizeof(int));
		assert(_data);
	}
	~Stack() {
		free(_data);
	}
private:
	int _top;
	int _capacity;
	int* _data;
};

int main() {
	Stack s1;
	Stack s2(s1);
	return 0;
}

但是，这个代码会报错！

进过调试可以发现，这个代码对同一个内存块进行了两次free操作。

栈中的数据是保存在堆区的，而对象中的_data指针只会记录这个空间的地址。

在对象s1和s2的生命周期结束后，程序会分别调用它们的析构函数，即分别对两个对象中_data指针所指向的空间进行释放。

但是因为s2中的_data指针是从s1中拷贝而来的，所以这两个对象的_data指针实际上指向了同一块空间。

因此，在释放空间的时候，free对同一块空间释放了两次，引发了这个错误。

正确的拷贝应该是，在堆中的开辟新的空间，再把s1的数据拷贝给s2。

改进：在上面的代码加入拷贝构造：

Stack(const Stack& s)
	:_capacity(s._capacity)
	,_top(s._top)
{
	_data = (int*)malloc(_capacity * sizeof(int));
	assert(_data);
	memcpy(_data, s._data, _capacity * sizeof(int));
}

这样，栈就能完成正确的拷贝了。

---

4. 赋值运算符重载

赋值运算符重载也是6个默认成员函数之一，它的本质是通过运算符重载，调用拷贝构造函数。对于运算符重载，这里不做详细介绍。

• 赋值运算符重载的定义和使用

赋值运算符重载的定义如下：

class A {
public:
	A(int i = 0)
		:_i(i)
	{}
	A(const A& a)
		:_i(a._i)
	{}
	A& operator=(const A& a) {
		if (this != &a) {
			_i = a._i;
		}
		return *this;
	}
private:
	int _i;
};

使用时，可以用等号=代替圆括号()进行拷贝操作，使代码更加美观。

int main() {
	A a1(1);
	A a2, a3, a4;
	
	a2 = a1;
	a4 = a3 = a2;
	
	return 0;
}

---

5. 取地址运算符重载

取地址运算符重载的定义如下：

class A {
public:
	A* operator&() {
		return this;
	}
};

这个默认成员函数的作用是取地址并返回，一般不需要重新定义，使用编译器默认生成的即可。

---

6. const取地址运算符重载

const取地址运算符重载即用const修饰取地址运算符重载，定义如下：

class A {
public:
	const A* operator&() const {
		return this;
	}
};

同取地址运算符重载一样，使用编译器默认生成的即可，一般不会重新定义，除非想要在取地址操作中返回其他内容。

---

7. 总结

类中存在6个默认成员函数，如果用户不显示定义，编译器都会自动生成。下面以类名为A的类为例：

默认成员函数	定义形式	说明
构造函数	A()	对象创建时调用
析构函数	~A()	对象销毁时调用
拷贝构造函数	A(const A& a)	对象拷贝时调用
赋值运算符重载	A& operator=(const A& a)	本质上是拷贝构造
取地址运算符重载	A* operator&()	取地址，通常不写
const取地址运算符重载	const A* operator&() const	取地址，通常不写

---