【C++初阶】一文讲通默认成员函数~类和对象（中）

fhvyxyci

发布于 2024-10-20 08:09:57

24900

代码可运行

文章被收录于专栏：学习学习

运行总次数：0

代码可运行

1. 类的默认成员函数

默认成员函数就是用户没有显式实现，编译器会自动生成的成员函数称为默认成员函数（注意并不意味着只有编译器生成的才是默认成员函数）。一个类，我们不写任何默认成员函数的情况下编译器会生成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最后两个取地址重载不重要，稍微了解一下即可。

C++11以后还增加了两个默认成员函数，移动构造和移动赋值，这个我们以后的博客讲解。

默认成员函数很重要，也比较复杂，我们要从两个方面去了解：第一：我们不写时，编译器默认生成的函数行为是什么？是否满足我们的需求？第二：如果编译器默认生成的函数不满足我们的需求，就需要我们自己实现，那么如何实现?

下面我们依次讲解这六种默认成员函数。

2. 构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象（局部对象是在栈帧创建时就开好空间了），而是在对象实例化时初始化对象。
构造函数的本质是要替代我们以前在数据结构初阶中写的Init()函数的功能，而且构造函数自动调用的特点就更好地替代了它。

构造函数的特点:

函数名与类名相同。
无返回值。(返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)

class test
{
public:
	// 构造函数,与类名相同,没有返回值
	test()
	{}
private:
};

对象实例化时系统会自动调用对应的构造函数。 这个可以通过VS的逐语句调试看到。
构造函数可以重载。 一般分为无参数，部分缺省和全缺省三种，上面给出的示例就是无参的。
如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。 但是要注意C++标准并没有规定编译器生成的默认构造函数是否要对成员函数进行初始化，所以在不同的编译器下，这段代码：

#include<iostream>
using namespace std;
class test
{
public:
	int a()
	{
		return _a;
	}
private:
	int _a;
};

int main()
{
	test t1;
	cout << t1.a() << endl;
	return 0;
}

会出现不同的结果： VS2022：未初始化

devc++（5.11）初始化为0

可以看到两种编译器默认生成的构造函数对是否初始化的处理并不相同，所以尽可能要自己写一个默认构造函数（下一条）。

无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。 但是这三个函数有且只有一个存在，不能同时存在。 无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义，所以如果有了全缺省构造函数就不用再写无参构造函数了。 特别提醒：可能有人会以为默认构造函数是编译器默认生成那个叫默认构造，实际上无参构造函数、全缺省构造函数也是默认构造，也就是不传实参就可以调用的构造就叫默认构造。

#include<iostream>
using namespace std;
class test
{
public:
	//test()
	//{
	//	// 1.无参数
	//	_a = 1;
	//	_b = 1;
	//	cout << "test()" << endl;
	//}

	test(int a = 2, int b = 2)
	{
		// 2.全缺省
		//在构造函数中加一句输出可以方便我们观察，实际开发中不要这么写
		cout << "test(int a = 2, int b = 2)" << endl;
		_a = a;
		_b = b;
	}
	//注意如果上面两个默认构造函数同时出现，编译器会报错：E0339：类 "test" 包含多个默认构造函数
	
	//test(int a, int b = 3)	//别忘了缺省参数只能从右往左给
	//{
	//	// 3.部分缺省，会和全缺省冲突
	//	cout << "test(int a, int b = 3)" << endl;
	//	_a = a;
	//	_b = b;
	//}

	//test(int a, int b)
	//{
	//	// 4.无缺省
	//	//实际上和这个也会和全缺省冲突，没有必要写
	//	cout << "test(int a, int b)" << endl;
	//	_a = a;
	//	_b = b;
	//}

	//test(int a)
	//{
	//	// 5.带参构造函数
	//	cout << "test(int a)" << endl;
	//	_a = a;
	//	_b = 0;
	//}

private:
	int _a;
	int _b;
};

int main()
{
	test t1;		//注意如果没有参数，就不要写()，不然会和函数声明的格式一致导致报错
	test t2(1);		//如果 2全缺省和 5带参同时出现，就会报错，无法匹配
	test t3(1, 2);	//上面的构造函数如果只留下 5带参，就会报错，因为编译器没有生成默认构造，没有匹配的构造函数
	return 0;
}

结合上面的几点总结就是，我们应该显式地写出一个默认构造函数，最好是全缺省的，或者也可以根据实际需要使用其他的构造函数。

我们不写时，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的。但是对于自定义类型成员变量，C++要求调用这个成员变量的默认构造函数初始化，如果这个成员变量没有默认构造函数就会报错，如果我们坚持要使用这个没有默认构造的成员变量，必须使用初始化列表才能解决，初始化列表在下篇博客讲解。说明：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型如：int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。

比如

#include<iostream>
using namespace std;
class testIn
{
public:
	testIn()
	{
		cout << "testIn()" << endl;
		_a = 0;
	}
private:
	int _a;
};

class test
{
public:
	//无构造
private:
	testIn ti1;
	testIn ti2;
};

int main()
{
	test();
	return 0;

运行之后

可以看到虽然我们没有显式写 test 类的默认构造，但是编译器默认生成的默认构造也会去调用 testIn 的默认构造。

但是如果我们将testIn中的默认构造改为带参构造

testIn(int a)
{
	cout << "testIn(int a)" << endl;
	_a = a;
}

编译器就会给出报错：

总之，如果类的成员均是由默认构造函数的自定义类型，就不需要写默认构造，除非默认构造不符合需求。

3. 析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，比如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。析构函数的功能类比我们之前 Stack 实现的 Destroy 功能，而像 Date 没有 Destroy ，其实就是没有资源需要释放，所以严格说 Date 是不需要析构函数的。析构函数的特点:

析构函数名是在类名前加上字符 ~。
无参数无返回值。(这里跟构造类似，也不需要加void)

#include<iostream>
class test2
{
public:
	// 构造函数
	test2()
	{}
	// 析构函数
	~test2()
	{}
private:
};

int main()
{
	test t1;
	return 0;
}

一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
对象生命周期结束时，系统会自动调用析构函数。（这也可以通过VS的逐语句调试功能看见）
跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定义类型成员会调用他的析构函数。
还需要注意的是就算我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。
如果类中没有动态开辟内存时，析构函数可以不写，直接使用编译器生成的默认析构函数，如 Date 类（没有申请空间，只有常量）；如果默认生成的析构就可以用，也就不需要显式写析构；但是有资源申请时，一定要自己写析构，否则会造成资源泄漏，如 Stack（栈，底层一般是动态开辟的数组）。
一个局部域的多个对象，C++规定后定义的先析构。

我们举一个相对实际的例子来讲解。

#include<iostream>
typedef int STDataType;
using namespace std;
class Stack
{
public:
	Stack(int n = 4)
	{
		cout << "Stack(int n = 4)" << endl;
		_data = (STDataType*)malloc(sizeof(STDataType) * n);
		_size = 0;
		_capacity = n;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_data);
		_size = _capacity = 0;
	}

private:
	STDataType* _data;
	size_t _size;
	size_t _capacity;
};

// 这个是使用两个栈去模拟实现队列
class MyQueue
{
public:
	MyQueue()
	{
		//就算我们显示写了构造，也会调用默认构造
		//不显式写构造，也会调用默认构造
		//如果不想调用默认构造，需要使用下篇博客介绍的初始化列表
		cout << "MyQueue()" << endl;
	}

	~MyQueue()
	{
		//同样的，无论我们有没有显式写析构，都会调用成员变量的析构
		//s1.~Stack();	//如果显式调用成员变量的析构，会报错（如果成员变量中有动态开辟的空间需要释放的话）
		cout << "~MyQueue()" << endl;
	}
private:
	Stack s1;
	Stack s2;
};

int main()
{
	Stack s;
	MyQueue mq1;
	return 0;
}

另外，可以看到，mq1 变量先发生了析构，印证了第8点：后定义的先析构。

构造函数与析构函数大大提高了C++类的实用性，在使用时，不需要去手动地开辟空间，在变量不再使用时，也不用担心忘记释放动态开辟的空间导致内存泄漏。

4. 拷贝构造函数

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

拷贝构造的特点:

拷贝构造函数是构造函数的一个重载。
拷贝构造函数的第一个参数必须是类类型对象的引用，使用传值方式编译器直接报错，因为语法逻辑上会引发无穷递归调用。拷贝构造函数也可以多个参数，但是第一个参数必须是类类型对象的引用，后面的参数必须有缺省值。

C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。
若未显式定义拷贝构造，编译器会生成自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。
像 Date 这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的拷贝构造就可以完成需要的拷贝，所以不需要我们显示实现拷贝构造。像 Stack 这样的类，虽然也都是内置类型，但是有动态开辟的空间，编译器自动生成的拷贝构造完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。像 MyQueue（两个成员变量都是 Stack 类型）编译器自动生成的拷贝构造会调用 Stack 的拷贝构造，也不需要我们显式实现 MyQueue 的拷贝构造。这里还有一个小技巧，如果一个类显示实现了析构并释放资源，那么它就需要显示写拷贝构造，否则就不需要。

// 不需要显式实现拷贝构造的：Date类
#include<iostream>
class Date
{
public:
	Date()
	{
		cout << "Date()" << endl;
		_year = 2024;
		_month = 10;
		_day = 18;
	}

	Date(int year, int month, int day)
	{
		cout << "Date(int year, int month, int day)" << endl;
		_year = year;
		_month = month;
		_day = day;
	}

	~Date()
	{
		cout << "~Date()" << endl;
		//没有动态内存，不需要显式析构，写上也可以
		_year = 0;
		_month = 0;
		_day = 0;
	}

	Date(const Date& d1)
	{
		cout << "Date(const Date& d1)" << endl;
		//浅拷贝实际上也不需要显式写出来
		_year = d1._year;
		_month = d1._month;
		_day = d1._day;
	}

	void Print()
	{
		cout << _year << ":" << _month << ":" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

再来看上面的 Stack 类，如果要给它写一个拷贝构造是什么样的？这样可以吗？

Stack::Stack(const Stack& s)
{
	_data = s._data;
	_size = s._size;
	_capacity = s._capacity;
}

如果这样写，先抛开其他问题，先看会产生会导致程序崩溃的问题：

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

调试器来可以发现，s1 和 s2 中的 _data 成员指向的是同一块成员，且不说修改时会导致两个对象中的数据会一起被修改，而且当析构时，s2先进行析构，_data 这块空间被释放掉了，但是s1随即又进行了 free，但是这时候这一块已经被释放了，对不是动态开辟的空间进行free会导致程序崩溃。所以正确的做法是开辟一块一样大的空间，把s1中的 _data 中的数据拷贝到 s2 的 _data 里。

Stack::Stack(const Stack& s)
{
	cout << "Stack(const Stack& s)" << endl;
	_data = (STDataType*)malloc(sizeof(STDataType) * s._capacity);
	for (size_t i = 0; i < s._size; i++)
	{
		_data[i] = s._data[i];
	}
	_size = s._size;
	_capacity = s._capacity;
}

传值返回会产生一个临时对象调用拷贝构造，所以和C语言不同，C++可以直接传值返回自定义类型，而无需借助指针。传值引用返回，返回的是返回对象的别名(引用)，没有产生拷贝。但是如果返回对象是一个当前函数局部域的局部对象，函数调用结束就销毁了，那么使用引用返回是有问题的，这时的引用就是野引用，类似野指针。传引用返回可以减少拷贝，但是一定要确保返回对象在当前函数结束后没有销毁（也就是返回对象引用的对象要是动态开辟的），才能用引用返回。

// Date Func1()
Date& Func1()
{
	Date tmp(2024, 10, 18);
	return tmp;
}

int main()
{
	Date tmp = Func1();
	tmp.Print();
	return 0;
}

运行这段代码，可以发现 tmp 打印出来的是乱码，因为 Func1() 中的 tmp 在函数运行结束时就销毁了，所以 Func1() 返回的是一个野引用，没有指向有效的数据，只不过由于 Date 类中没有指针，所以没有发生空指针的解引用导致程序崩溃罢了。

我们再来看看什么情况下会是拷贝构造：

void Func1(Date d)
{
	cout << &d << endl;
}

void Func2(Date& d)
{
	cout << &d << endl;
}

int main()
{
	Date d1(2024, 7, 5);

	// C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里传值传参要调用拷贝构造
	// 所以这里的d1传值传参给d要调用拷贝构造完成拷贝，传引用传参可以避免这里的拷贝
	Func1(d1);

	//这样写就是直接传引用，没有调用拷贝构造
	Func2(d1);

	//这样写也是拷贝构造，通过同类型的对象初始化构造，而不是指针
	Date d3(d1);
	d3.Print();

	//也可以这样写，这里也是拷贝构造，C++支持这样的写法
	Date d4 = d1;
	d4.Print();

	return 0;
}

5. 赋值运算符重载

5. 1 运算符重载

当运算符被用于类类型的对象时，编译器既定的操作符大部分无法对类使用，因此C++允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。
运算符重载是具有特殊名字的函数，它的名字是由operator和后面要定义的运算符共同构成。
和其他函数一样，它也具有其返回类型和参数列表以及函数体。重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。举例：Date 类中重载比较和赋值操作符。这两个都是二元操作符，所以除了隐含的 this 指针之外，还需要显式地写出一个形参，注意这里使用引用传参可以减少拷贝。

int operator>(const Date& d);
Date& operator=(const Date& d);

一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数（ this 指针），右侧运算对象传给第二个参数。
如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少一个。
运算符重载以后，其优先级和结合性与对应的内置类型运算符保持一致。
不能通过连接语法中没有的符号来创建新的操作符:比如operator@。
. * :: sizeof ?: (注：最后一个是三目操作符?:)以上5个运算符不能重载。
重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义，如在Date类中重载加法操作符 int operator+(int x，int y)。
一个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如Date类重载operator-就有意义，但是重载operator/就没有意义。
重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。C++规定，后置++重载时，增加一个 int 形参，这个形参没有实际意义，所以可以不取名字，跟前置++构成函数重载，方便区分。

//前置++
Date& operator++();
//后置++
Date& operator++(int);

重载操作符在使用时，可以直接像内置类型调用操作符一样操作，也可以直接写出来operator函数，即使写的是前者，编译器在编译时也是转换为后者进行编译。我们以 == 这个操作符为例：

bool operator==(const Date& d)
{
	return (_year == d._year && _month == d._month && _day == d._day);
}

当需要调用时，就可以有：

int main()
{
	Date d1(2024, 10, 19);
	Date d2(d1);
	if (d1 == d2)
		cout << "yes" << endl;
	else
		cout << "no" << endl;

	if (d1.operator==(d2))
		cout << "yes" << endl;
	else
		cout << "no" << endl;
	return 0;
}

这两个条件语句都会输出 yes ，是完全等价的。

重载 << 和 >> （流插入和流提取）时，需要重载为全局函数，因为重载为成员函数，this 指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调用时就变成了对象<<cout ，不符合使用习惯和可读性。重载为全局函数把ostream/istream放到第一个形参位置就可以了，第二个形参位置当类类型对象。（注：ostream 和 istream 分别是 cout 和 cin 的类型，函数传参或返回这两种类型的参数必须使用引用，这两个函数也都需要返回值 ostream& 或 istream& 来使得能连续输入/输出）我们看个例子来理解：假如说我们直接把 operator<< 重载为成员函数，那它在调用时就是这样的。

//Date类中
ostream& operator<<(ostream& out)
{
	out << _year << ":" << _month << ":" << _day;
	return out;
}

int main()
{
	Date d1(2024, 10, 19);

	//这个编译器会报错(没有匹配的 << 操作符)
	//cout << d1 << endl;

	//需要这么写
	d1 << cout << endl;	//顺带一提，正是因为operator<<函数有返回值ostream&，所以才能继续输出endl，否则会报错
	d1.operator<<(cout) << endl;
	return 0;
}

这样写很怪，我们最常用的写法不能写出来，所以我们需要将这个函数重载为全局函数。重载为全局函数尤为遇见一个难题：怎么访问私有成员变量？这里有3中解决办法：

成员放公有
Date 提供 getxxx 函数
友元函数（下篇博客详细介绍）

但是很显然第一个并不合适，破坏了类的封装，所以我们在2和3中选取一个，我们先使用get函数来解决这个问题。

//Date类中
	int get_year()
	{
		return _year;
	}
	int get_month()
	{
		return _month;
	}
	int get_day()
	{
		return _day;
	}
//全局实现operator<<函数
ostream& operator<<(ostream& out, Date& d)	//注意这里不能写const来修饰d，原因在第6章解释
{
	out << d.get_year() << ":" << d.get_month() << ":" << d.get_day();
	return out;
}
//调用
int main()
{
	Date d1(2024, 10, 19);
	cout << d1 << endl;

	return 0;
}

这样就是正常的输出语句的格式了，输入也是同理，要重载为全局函数。

5. 2 赋值运算符重载

赋值运算符重载是一个默认成员函数，用于完成两个已经存在的对象直接的拷贝赋值，这里要注意跟拷贝构造区分，拷贝构造用于一个对象拷贝初始化给另一个要创建的对象。

赋值运算符重载的特点:

赋值运算符重载是一个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成 const 当前类类型引用，否则会传值传参会有拷贝。
有返回值，且建议写成当前类类型引用，引用返回可以提高效率，有返回值目的是为了支持连续赋值场景。
没有显式实现时，编译器会自动生成一个默认赋值运算符重载，默认赋值运算符重载行为跟默认拷贝构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用它的赋值重载函数。
像 Date 这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就可以完成需要的拷贝，所以不需要我们显式实现赋值运算符重载。像 Stack 这样的类，虽然也都是内置类型，但是成员变量指向了动态开辟的空间，编译器自动生成的赋值运算符重载完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝（对指向的资源也进行拷贝）。像 MyQueue 这样的类型内部主要是自定义类型 Stack 成员，编译器自动生成的赋值运算符重载会调用 Stack 的赋值运算符重载,也不需要我们显示实现。
这里还有一个小技巧，如果一个类显示实现了析构并释放资源，那么它就需要显示写赋值运算符重载，否则就不需要。

// Date类中
Date& operator=(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
	//返回*this的引用以方便连续赋值
	return *this;
}
//调用
int main()
{
	Date d1(2024, 10, 19);

	Date d2;
	//赋值运算符重载
	d2 = d1;

	//拷贝构造
	Date d3 = d1;

	cout << d1 << endl;
	cout << d2 << endl;
	cout << d3 << endl;
	return 0;
}

补充：赋值运算符重载和拷贝构造该怎么区分？ 类似内置类型的赋值和初始化，一个是在创建变量时调用，另一个是变量创建后再调用。

这样就大功告成了吗？我们来看这样的调用：

int main()
{
	Date d1(2024, 10, 19);
	//自己赋值给自己
	d1 = d1;
	cout << d1 << endl;
	return 0;
}

虽然这样的代码一般不会出现，但是为了代码的健壮性，还是要进行以下处理。尽管对于Date类来说，这样的赋值没有太大的损耗，更不会出现程序异常，但是对于Stack这样的需要进行深拷贝的类，如果这样调用就会造成较大的损耗，甚至一些类的拷贝逻辑如果处理不当，可能会导致空指针，所以为了减少性能损失，我们在拷贝之前进行判断*this==d是否成立。

Date& operator=(const Date& d)
{
	if (!(*this == d))	//当然也可以实现一个!=操作符的重载
	{
		cout << "Date& operator=(const Date& d)" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
		//返回*this的引用以方便连续赋值
	}
	return *this;
}

这时再调用刚才的main函数，就会发现没有再进行无效的拷贝了。

6. 取地址运算符重载

6. 1 const成员函数

被 const 修饰的成员函数称为 const 成员函数，const 修饰成员函数放到成员函数参数列表的后面。
const 实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。如 const 修饰 Date 类的 Print 成员函数，Print 隐含的 this 指针由 Date*const this 变为 const Date* const this

void Print() const
{
	cout << _year << ":" << _month << ":" << _day << endl;
}

注意如果说成员函数内部不需要对this指针进行修改，就最好加上const修饰成员函数，不然可能会因为权限放大导致程序无法运行，比如上面的实现operator<<时的情况：如果说这个重载函数是这样的：

ostream& operator<<(ostream& out, const Date& d)
{
	out << d.get_year() << ":" << d.get_month() << ":" << d.get_day();
	return out;
}

由于d是一个被 const 修饰的变量，而 get 的三个成员函数都没有被 const 修饰，那么当d调用成员函数get_year()时，会传值给Date*const this，也就是发生了权限的放大（this指针可以修改成员变量，而d不可以，这显然是不合法的）。解决办法就是将 get 的三个函数都用 const 修饰起来，毕竟它们也不需要修改成员变量。

即使成员函数被const修饰，也可以接收没有被const修饰的对象，因为这是权限缩小，是合法的。