从零开始的c++之旅——C++类和对象（中）

                              

1. 类的默认成员函数

默认成员函数就是用户没有显示实现，但是编译器会自动生成的成员函数。

一个类，我们在不写的情况下编译器会默认生成六个默认函数，我们这里重点描述前四个，因为后面两个取地址重载不重要，简单提一下就行。

• 构造函数      • 析构函数     • 拷贝函数    • 赋值重载 

在c++11以后会增加两个默认成员函数在以后的博客中会讲解。 

 默认函数很重要，我们会从以下两个条件进行学习：

1.我们不写时，编译器默认生成的函数行为是什么？是否可以满足我们的需求？

2.编译器默认生成的函数不能满足我们的需求，我们要自己实现时，如何自己实现？

 2. 构造函数

构造函数是特殊的成员函数

需要注意的是，构造函数虽然叫构造，但是他的主要任务不是开辟空间创建对象（因为常用的局部对象是栈帧创建的，空间已经开好了），而是在对象实例化时初始化我们的对象。

就类似于我们上一篇博客中实现的数据结构栈中的Init初始化功能，构造函数自动调用的特点可以完美替代Init，因为这使得我们不再需要手动进行初始化。

构造函数的特点：

1. 函数名与类名相同

2. 无返回值（返回值什么都不用给，也不需要写void，这是c++的语法规定）

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

4.构造函数可以重载

5.如果类中没有显示定义的构造函数，则c++编译器会自动生成一个无参的默认构造函数，一旦我们自己显式定义编译器便不再生成。

6.无参构造函数，全缺省构造函数，以及我们不显式定义时编辑器默认生成的构造函数，都叫做默认构造函数。但是这三个函数有且只有一个存在，不能同时存在，也不能都不存在。

总结一下就是：不传实参就可以调用的就叫默认构造。

7.编辑器默认生成的构造函数对内置成员变量的初始化是不确定的，看编辑器。

对于自定义成员变量，会自动调用这个成员变量的默认构造函数初始化。

 说明：C++把类型分成内置类型(基本类型)和⾃定义类型。内置类型就是语⾔提供的原⽣数据类型，如：int/char/double/指针等，⾃定义类型就是我们使⽤class/struct等关键字⾃⼰定义的类型。

以下是以一个日期类来演示上述三种默认构造函数

#include<iostream>
using namespace std;
class Date
{
public :
	// 1.⽆参构造函数
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	} 
	// 2.带参构造函数
		Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	} 
	// 3.全缺省构造函数
		/*Date(int year = 1, int month = 1, int day = 1)
		{
		_year = year;
		_month = month;
		_day = day;
		}*/
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;	
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	// 如果留下三个构造中的第⼆个带参构造，第⼀个和第三个注释掉
	// 编译报错：error C2512: “Date”: 没有合适的默认构造函数可⽤
	Date d1; // 调⽤默认构造函数
	Date d2(2025, 1, 1); // 调⽤带参的构造函数
	d1.Print();
	d2.Print();
	return 0;
}

 这里还需要注意一点，如果我们使用的是无参的默认构造函数，那么在对象实例化时候就直接自动调用，也就是说不用在后面加上括号即 Data d1；

Data d3（）这种写法是错误的，因为编译器会报错“未调⽤原型函数”，因为这种写法会让让编译器分不清到底是函数的定义，还是对象实例化。

在第七点中我们提到，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;
	}
private:
	STDataType * _a;
	size_t _capacity;
	size_t _top;
};

class MyQueue
{
public :
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	MyQueue mq;
	return 0;
}

在MyQueue类里面，我们的成员变量为两个自定义类型，这就意味着在我们不需要再在pubilc中定义这个类的初始化函数，在MyQueue对象的实例化时会自动调用自定义类型的构造函数，省时省力。 

3. 析构函数

析构函数不不是如其名字一样完成对象本身的销毁的，因为我们比如说局部对象是存在栈帧的，但是在函数结束的时候栈帧销毁，就释放掉了我们不用管。

析构函数的作用就类似于实现Stack的Destroy功能，会在对象销毁时自动调用析构函数，完成对对象中资源的清理释放工作

而我们实现的日期类由于并没有申请资源，所以是不需要资源释放的，所以实际上Data是不需要析构函数的。

析构函数特点：

1. 析构函数就是类名前面加上一个 ~

2. 析构函数无参数无返回值（类似构造函数，也不需要加void）

3. 一个类只能由一个析构函数。若未显示定义，则系统会自动生成默认的析构函数

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

5. 编译器自动生成的析构函数对内置成员是不做处理的，对于自定义类型成员会调用他自

    己的析构函数。

6. 需要注意的是，自定义类型无论如何都会调用他自己的析构函数，即使我们写了析构函

    数，自定义类型成员也会调用他的析构函数。所以我们要注意避免资源的的重复回收。

7. 如果类中没有申请资源，那么可以不用写析构函数，使用编辑器生成的默认析构函数，

    例如Data日期类。或者默认输出的函数就可以用，也不需要写，如我们上面实现的两个栈

    模拟队列的类MyQueue；

    而当我们写的类中涉及到了资源的申请，那么一定要自己写析构，否则会导致内存泄露

    如Stack类，或者使用了文件指针访问文件等等。

8. 一个局部域的多个对象，c++规定后定义的先析构（就像我们锁钥匙一样，里面的锁先锁

   外面的锁后锁）

 下面我们用一道括号匹配问题感受一下c语言和c++的区别

c语言

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++

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

 可以明显的发现，c++在实现上就会简洁很多，因为c++在调用类时不需要再使用Init初始化和Destroy销毁，而是靠在类中定义的构造函数和析构函数自动完成任务。

4. 拷贝构造函数

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

使用我们也可以说拷贝构造函数是一种特殊的构造函数。

拷贝构造的特点

1. 拷贝构造函数是构造函数的重载

2. 拷贝函数的第一个参数必须是类类型对象的引用，使用传值方式编辑器直接报错，这里涉

    及到C++的语法问题，结合第三点一起讨论在后续会提及。

    拷贝构造函数可以有多个参数，但第一个参数必须是类类型对象的引用，其余参数必须

    都得有缺省值。

3. C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，使用这里自定义类型传值传值

    传参和传值返回都会调用拷贝构造完成。

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

    造对内置类型成员变量会完成值拷贝/浅拷贝（一个字节一个字节拷贝），对自定义类型对

    象会调用他的拷贝构造 

5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造

    就可以完 成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。像Stack这样的类，虽然也

    都是内置类型，但是若内置成员变量指向了资源所以使用浅拷贝就无法满足我们的需求（这点后续会解

    释原因，这时候就要我们自己定义拷贝函数实现深拷贝（对指向的资源也拷贝）。

    小技巧：如果一个类显示实现了析构函数并释放资源，那么他就需要显示写拷贝函数。

6. 传值返回会产生一个临时对象调用拷贝构造，传引用返回因为是对象的别名因此不会产生

    拷贝。但是如果返回对象是一个局部对象，函数结束就销毁了，那么使用引用返回就是有

    问题的，这时候引用就是一个野引用，类似野指针一样。

    所以，传引用返回可以减少拷贝提高效率，但是必须保证返回对象在函数结束的时候依然

    还在。

在第2点提到，拷贝函数的第一个参数必须是类类型对象的引用，否则会报错，因为形成了无线递归，结合第三点，如果是自定义类型对象在传值调用时会调用拷贝构造，但是如果我们的拷贝构造是传值调用的话，拷贝构造的参数又要调用拷贝构造，这就形成了俄罗斯套娃，无限循环以下是示例图

在第5点中我们提到，若内置成员变量申请了资源则需要自己定义拷贝函数进行深拷贝，比如若是Stack这样一个类，使用默认生成的拷贝函数的话，那么内置成员便会指向同一块空间，这时函数结束后自动调用析构函数，两个类对象都会调用他们的析构函数，则会对同一片空间析构两次，导致系统报错

使用正确的做法是自己定义拷贝构造函数，使拷贝的对象指向另一块空间，将被拷贝对象的数组中中的值拷贝过来。

 

5. 赋值运算符重载

5.1 运算符重载

• 当运算符被⽤于类类型的对象时，C++语⾔允许我们通过运算符重载的形式指定新的含义。C++规 定类类型对象使⽤运算符时，必须转换成调⽤对应运算符重载，若没有对应的运算符重载，则会编 译报错。

• 运算符重载是具有特殊名字的函数，他的名字是由operator和后⾯要定义的运算符共同构成。和其 他函数⼀样，它也具有其返回类型和参数列表以及函数体。

• 重载运算符函数的参数个数和该运算符作⽤的运算对象数量⼀样多。⼀元运算符有⼀个参数，⼆元 运算符有两个参数，⼆元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第⼆个参数。

• 如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算 符重载作为成员函数时，参数⽐运算对象少⼀个。

• 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。• 不能通过连接语法中没有的符号来创建新的操作符：⽐如operator@。

•  .*   ::   sizeof    ?   :   .  注意以上5个运算符不能重载。(选择题⾥⾯常考）

   .*运算符使用于对象调用成员函数指针如 ( obj.*pf )( ) 。

• 重载操作符⾄少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义，如： int operator+ ( int x,  int y )

• ⼀个类需要重载哪些运算符，是看哪些运算符重载后有意义，⽐如Date类重载operator-就有意 义，但是重载operator*就没有意义。

 • 重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，⽆法很好的区分。 C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，⽅便区分。

 • 重载 << 和 >> 时 ，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位 置，第⼀个形参位置是左侧运算对象，调⽤时就变成了对象<<cout,不符合使用析构和可读性，所以我们将将其重载为全局函数，把ostream/istream放到第⼀个形参位置就可以了，第⼆个形参位置当类类型对象。

重载为全局的⾯临对象访问私有成员变量的问题有⼏种⽅法可以解决

 1、成员放公有

 2、Date提供getxxx函数 

3、友元函数（像ostream这种形参位置有冲突推荐使用）

4、重载为成员函数（一般使用这种）

5.2 赋值运算符重载

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

赋值运算符重载的特点：

1. 赋值运算符重载是⼀个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成 const当前类类型引⽤，否则会传值传参会有拷⻉

 2. 有返回值，且建议写成当前类类型引⽤，引⽤返回可以提⾼效率，有返回值⽬的是为了⽀持连续赋 值场景。

3. 没有显式实现时，编译器会⾃动⽣成⼀个默认赋值运算符重载，默认赋值运算符重载⾏为

    跟默认拷 ⻉构造函数类似，对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节

    的拷⻉)，对⾃定义 类型成员变量会调⽤他的赋值重载函数。

4. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的赋值运算

    符重载就 可以完成需要的拷⻉，所以不需要我们显⽰实现赋值运算符重载。像Stack这样

    的类，虽然也都是 内置类型，但是_a指向了资源，编译器⾃动⽣成的赋值运算符重载完成

    的值拷⻉/浅拷⻉不符合我 们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏

    拷⻉)。像MyQueue这样的类型内部 主要是⾃定义类型Stack成员，编译器⾃动⽣成的赋值

    运算符重载会调⽤Stack的赋值运算符重载， 也不需要我们显⽰实现MyQueue的赋值运算

    符重载。

    ⼩技巧：如果⼀个类显⽰实现 了析构并释放资源，那么他就需要显⽰写赋值运算符重载，

    否则就不需要。

掌握了以上的默认成员函数，我们就可以进行练习，在下一个博客我们就要熟练运用以上的知识，实现一个完整的日期类，包括其中的运算。我们下个博客间见

加纳~