【C++修行之道】类和对象(二)类的6个默认成员函数、构造函数、析构函数

目录

一、类的6个默认成员函数

二、构造函数

[2.1 概念](#2.1 概念)

[2.2 特性](#2.2 特性)

[2.2.5 自动生成默认构造函数](#2.2.5 自动生成默认构造函数)

不进行显示定义的隐患:

[2.2.6 自动生成的构造函数意义何在?](#2.2.6 自动生成的构造函数意义何在?)

两个栈实现一个队列

[2.2.7 无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。](#2.2.7 无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。)

[2.4 一般情况,建议每个类,都可以写一个全缺省的构造(好用)](#2.4 一般情况,建议每个类,都可以写一个全缺省的构造(好用))

三、析构函数

[3.1 概念](#3.1 概念)

[3.2 特性](#3.2 特性)

[3.3 C++实现括号匹配和C语言的不同](#3.3 C++实现括号匹配和C语言的不同)


一、类的6个默认成员函数

如果一个类中什么成员都没有,简称为空类。

空类中真的什么都没有吗?并不是,任何类在什么都不写时,编译器会自动生成以下6个默认成员函数。

默认成员函数:用户没有显式实现 ,**编译器会自动生成(半自动化)**的成员函数称为默认成员函数。

class Date {};

二、构造函数

2.1 概念

对于以下Date类:

cpp 复制代码
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.Print();
	Date d2;

	d2.Print();
	return 0;
}

对于Date类,可以通过 Init 公有方法给对象设置日期,但如果每次创建对象时都调用该方法设置信息,未免有点麻烦,那能否在对象创建时,就将信息设置进去呢?

构造函数 是一个特殊的成员函数 ,名字与类名相同,创建类类型对象时由编译器自动调用 ,以保证每个数据成员都有 一个合适的初始值,并且在对象整个生命周期内只调用一次

2.2 特性

构造函数 是特殊的成员函数,需要注意的是,构造函数虽然名称叫构造,但是构造函数的主要任务并不是开空间创建对象,而是初始化对象

其特征如下:

  1. 函数名与类名相同。
  2. 无返回值。
  3. 对象实例化时 编译器自动调用对应的构造函数。
  4. 构造函数可以重载。
cpp 复制代码
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); // 调用带参的构造函数

	// 注意:如果通过无参构造函数创建对象时,对象后面不用跟括号,否则就成了函数声明
	// 以下代码的函数:声明了d3函数,该函数无参,返回一个日期类型的对象
	// warning C4930: "Date d3(void)": 未调用原型函数(是否是有意用变量定义的?)
	Date d3();
}

在C++中,当编译器看到一个像Date d3();这样的声明时,它会根据语法规则将其解析为一个函数声明,而不是一个对象定义。这是因为C++的语法允许这样的歧义,而且函数声明的优先级高于对象定义。因此,即使你本意是想创建一个对象,编译器也会将其视为一个函数声明。为了避免这种歧义,最好不要在对象定义时使用空括号。

2.2.5 自动生成默认构造函数

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

cpp 复制代码
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类中构造函数屏蔽后,代码可以通过编译,因为编译器生成了一个无参的默认构造函数
	// 将Date类中构造函数放开,代码编译失败,因为一旦显式定义任何构造函数,编译器将不再	生成
	// 无参构造函数,放开后报错:error C2512: "Date": 没有合适的默认构造函数可用
	Date d1;
	
	return 0;
}

在这个Date类的定义中,并没有显式定义任何构造函数。编译器会自动生成一个默认的无参构造函数。这个自动生成的构造函数不会进行任何实质性的初始化操作。

不进行显示定义的隐患:

cpp 复制代码
class A
{
public:
	A()
	{
		_a = 0;
	}
private:
	int _a;
};

class Time {
public:

private:
	int  _hour;
	int _minute;
	int _second;
	A _aa;
};

class Date
{
public:
	void Print() {
		cout << _year << _month << _day << endl;
	}
private:
	// 默认生成构造函数
	// 内置类型没有规定要处理(可处理,可不处理,看编译器)
	int _year;
	int _month;
	int _day;

	// 自定义类型调用默认构造函数
	Time _t;
};

int main()
{
	//Date d1(2024, 4, 9);
	//d1.Print();

	Date d2;
	d2.Print();

	return 0;
}

2.2.6 自动生成的构造函数意义何在?

关于编译器生成的默认成员函数,很多童鞋会有疑惑:不实现构造函数的情况下,编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用 ?d对象调用了编译器生成的默认构造数,但是d对象_year/_month/_day,依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用?

解答:C++把类型分成内置类型(基本类型)和自定义类型 。内置类型就是语言提供的数据类型,如:int/char...,自定义类型就是我们使用class/struct/union等自己定义的类型,看看下面的程序,就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数

cpp 复制代码
class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d;
	return 0;
}

注意:C++11 中针对内置类型成员不初始化的缺陷,又打了补丁,即:内置类型成员变量在类中声明时可以给默认值。

在实际应用中,通常建议在类的构造函数中初始化这些成员,以确保对象的状态是确定的**。**

两个栈实现一个队列
cpp 复制代码
typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(capacity * sizeof(DataType));
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_size = 0;
		_capacity = capacity;
	}
	void Push(const DataType& data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};
// 自动生成的构造函数意义何在?
class MyQueue
{
private:
	Stack _pushst;
	Stack _popst;
};

int main()
{
	

	MyQueue q;

	return 0;
}

自动生成的构造函数意义何在?

  • 确保成员变量的正确初始化:自动生成的构造函数会调用成员变量的默认构造函数,确保 MyQueue 中的两个 Stack 对象在 MyQueue 对象创建时被正确初始化。
  • 简化代码:由于 MyQueue 类在这个例子中没有特殊的初始化需求,因此不需要手动编写构造函数。
  • 如果类中没有需要特别处理的初始化逻辑,那么自动生成的构造函数可以简化代码,避免不必要的冗余。这样,开发者可以专注于类的其他功能和逻辑,而不必担心基本的初始化问题。

2.2.7 无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。

注意:无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数,都可以认为是默认构造函数。

cpp 复制代码
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;
};
// 以下测试函数能通过编译吗?
void Test()
{
	Date d1;
}

2.4 一般情况,建议每个类,都可以写一个全缺省的构造(好用)

cpp 复制代码
class Date
{
public:
	// 他们俩构成函数重载,但是无参调用时会存在歧义
	/*Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}*/

	// 一般情况,建议每个类,都可以写一个全缺省的构造(好用)
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//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();  无法跟函数声明区分开
	Date d1;
	d1.Print();

	Date d2(2024, 4, 2);// 对象(参数列表)
	d2.Print();

	Date d3(2024);
	d3.Print();

	Date d4(2024, 4);
	d4.Print();

	return 0;
}

三、析构函数

3.1 概念

通过前面构造函数的学习,我们知道一个对象是怎么来的,那一个对象又是怎么没呢的?析构函数:与构造函数功能相反 ,析构函数不是完成对对象本身的销毁,局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数,完成对象中资源的清理工作。

3.2 特性

析构函数是特殊的成员函数,其特征如下:

  1. 析构函数名是在类名前加上字符 ~
  2. 无参数无返回值类型。
  3. 一个类只能有一个析构函数。若未显式定义,系统会自动生成默认的析构函数。注意:析构函数不能重载
  4. 对象生命周期结束时,C++编译系统系统自动调用析构函数
cpp 复制代码
typedef int DataType;

class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		cout << "Stack(size_t capacity = 3)" << endl;

		_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()
	{
		cout << "~Stack()" << endl;

		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

int main()
{
	Stack st;

	return 0;
}
  1. 关于编译器自动生成的析构函数,是否会完成一些事情呢?下面的程序我们会看到,编译器生成的默认析构函数,对自定类型成员调用它的析构函数
cpp 复制代码
class Time
{
public:
	~Time()
	{
		cout << "~Time()" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
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是Tim类对象,所以在d销毁时,要将其内部包含的Time类的_t对象销毁,所以要调用Time类的析构函数。但是:main函数中不能直接调用Time类的析构函数,实际要释放的是Date类对象,所以编译器会调用Date类的析构函数,而Date没有显式提供,则编译器会给Date类生成一个默认的析构函数。

目的是:在其内部调用Time类的析构函数,即当Date对象销毁时,要保证其内部每个自定义对象都可以正确销毁,main函数中并没有直接调用Time类析构函数,而是显式调用编译器为Date类生成的默认析构函数

注意:创建哪个类的对象则调用该类的析构函数,销毁那个类的对象则调用该类的析构函数

  1. 如果类中没有申请资源时,析构函数可以不写,直接使用编译器生成的默认析构函数,比如Date类;有资源申请时,一定要写,否则会造成资源泄漏,比如Stack类。

3.3 C++实现括号匹配和C语言的不同

可以明显的看出,C++对应C语言来说简化了不少,对C语言进行了一定的优化。

今天就先到这了!!!

看到这里了还不给博主扣个:

⛳️ 点赞☀️收藏 ⭐️ 关注!

你们的点赞就是博主更新最大的动力!

有问题可以评论或者私信呢秒回哦。

相关推荐
程序猿小柒9 分钟前
【LeetCode每日一题】LeetCode 345.反转字符串中的元音字母
算法·leetcode
ha204289419411 分钟前
认识数据结构之——排序
数据结构·算法·排序算法
十年一梦实验室33 分钟前
【C++】sophus : rxso3.hpp 实现了 3D 空间中的旋转和缩放操作的 RxSO3 类 (二十一)
开发语言·c++·人工智能·算法·3d
yoyo勰1 小时前
sqlite3
c语言·sqlite
西岸行者1 小时前
捋一捋相关性运算,以及DTD和NLP中的应用
人工智能·算法·自然语言处理·信号处理
No0d1es1 小时前
GESP CCF C++六级编程等级考试认证真题 2024年12月
开发语言·c++·算法·青少年编程·gesp·ccf·六级
编码小哥1 小时前
C++信号处理
c++
机器视觉知识推荐、就业指导1 小时前
C++设计模式:组合模式(公司架构案例)
c++·后端·设计模式·组合模式
就爱学编程1 小时前
重生之我在异世界学编程之C语言:数据在内存中的存储篇(上)
c语言·数据结构
意疏1 小时前
【C 语言指针篇】指针的灵动舞步与内存的神秘疆域:于 C 编程世界中领略指针艺术的奇幻华章
c语言·开发语言·指针