一、在不同的内存中创建类的实例对象

在上一篇博客【C++】构造函数分类 ② ( 在不同的内存中创建类的实例对象 | 栈内存中创建实例对象 | new 关键字创建对象 ) 中 , 分析了在栈内存和堆内存中创建对象的两种情况 ;

本篇博客中 , 继续分析 , 栈内存中调用有参构造函数的两种方法 :

括号法
等号法

C++ 类成员变量为 :

public:
	int m_age;
	char* m_name;

之后都是以该成员变量为参考 , 为这两个成员变量赋值 ;

1、括号法调用构造函数

首先 , 在 Student 类中, 定义两个有参的构造函数 , 之后就使用括号法调用上述构造函数 ;

	// 有参构造函数
	Student(int age, const char* name)
	{
		// 方法体 省略
		cout << "调用有参构造函数" << endl;
	}

不推荐的用法 : 通过 Student(18, “Tom”) 方法 , 手动调用有参的构造函数 , 上述代码会产生一个匿名的 Student 实例对象 , 然后再将该匿名对象赋值给栈内存中的 Student s2 变量 ;

匿名对象创建完成后 , 会立刻进行初始化 ;

	// 手动调用有参构造函数
	// 直接调用构造函数会产生匿名对象, 涉及到该匿名对象的生命周期
	Student s2 = Student(18, "Tom");

推荐的用法 : 在栈内存中创建类的实例对象 , 推荐使用下面的方法 , 在声明的栈内存变量名称后 , 直接使用括号 , 并传入构造函数的参数 ;

	// 使用 括号法 调用有参构造函数
	Student s4(1, "J");

调用 Student s4(1, “J”) 创建实例对象 , 相当于调用了 Student(int age, const char* name) 有参构造函数 , 然后将实例对象赋值给了 s4 变量 ;

2、等号法调用构造函数

首先 , 定义单个参数的构造函数 ;

	// 有参构造函数
	Student(const char* name)
	{
		// 为 m_name 成员分配内存
		m_name = (char*)malloc(100);

		// 为 m_name 成员设置字符串值
		if (m_name != NULL)
		{
			strcpy_s(m_name, sizeof(name), name);
		}

		// 为 m_age 成员设置初始值
		m_age = 0;

		cout << "调用有参构造函数" << endl;
	}

使用等号法调用有一个参数的有参构造函数 ,

将字符串直接赋值给 Student s5 变量 , 相当于调用了 Student(const char* name) 有参构造函数 , 并将创建的实例对象赋值给 s5 变量 ,

这是 C++ 对 = 等号运算符的增强 ;

	// 使用 等号法 调用 有一个参数的 有参构造函数
	// C++ 对等号进行了功能增强
	Student s5 = "K";

二、完整代码示例

在下面的代码中 ,

声明 Student 类时 , 定义了 :

默认无参构造函数
有参构造函数 - 1 个参数
有参构造函数 - 2 个参数
拷贝构造函数 - 1 个参数的有参构造函数 , 函数类型是 Student(const Student& obj)

调用构造函数创建实例对象时 , 分别使用了

直接声明 Student 变量 , 自动调用默认无参构造函数 ,
使用括号法调用 2 参数有参构造函数
调用拷贝构造函数
使用等号法调用 1 参数有参构造函数

代码示例 :

#include "iostream"
using namespace std;

class Student
{
public:

	// 无参构造函数
	Student()
	{
		// 为 m_name 成员分配内存
		m_name = (char*)malloc(100);

		// 为 m_name 成员设置字符串值
		if (m_name != NULL)
		{
			strcpy_s(m_name, 5, "name");
		}

		// 为 m_age 成员设置初始值
		m_age = 0;

		cout << "调用无参构造函数" << endl;
	}

	// 有参构造函数
	Student(const char* name)
	{
		// 为 m_name 成员分配内存
		m_name = (char*)malloc(100);

		// 为 m_name 成员设置字符串值
		if (m_name != NULL)
		{
			strcpy_s(m_name, sizeof(name), name);
		}

		// 为 m_age 成员设置初始值
		m_age = 0;

		cout << "调用有参构造函数" << endl;
	}

	// 有参构造函数
	Student(int age, const char* name)
	{
		// 为 m_name 成员分配内存
		m_name = (char*)malloc(100);

		// 为 m_name 成员设置字符串值
		if (m_name != NULL)
		{
			strcpy_s(m_name, sizeof(name), name);
		}

		// 为 m_age 成员设置初始值
		m_age = age;

		cout << "调用有参构造函数" << endl;
	}

	// 拷贝构造函数
	Student(const Student& obj)
	{
		// 为 m_name 成员分配内存
		m_name = (char*)malloc(100);

		// 为 m_name 成员设置字符串值
		if (m_name != NULL)
		{
			strcpy_s(m_name, sizeof(obj.m_name), obj.m_name);
		}

		// 为 m_age 成员设置初始值
		m_age = obj.m_age;

		cout << "调用拷贝构造函数" << endl;
	}

	~Student()
	{
		// 销毁 name 指向的堆内存空间
		if (m_name != NULL)
		{
			free(m_name);
		}
		cout << "调用析构函数" << endl;
	}

public:
	int m_age;
	char* m_name;
};

int main()
{
	// 声明 Student 类型实例对象
	// 调用无参构造函数
	Student s1;
	// 打印 Student s1 实例对象值
	cout << "name : " << s1.m_name << " , age : " << s1.m_age << endl;

	// 手动调用有参构造函数
	// 直接调用构造函数会产生匿名对象, 涉及到该匿名对象的生命周期
	Student s2 = Student(18, "Tom");
	// 打印 Student s1 实例对象值
	cout << "name : " << s2.m_name << " , age : " << s2.m_age << endl;

	// 使用 括号法 调用有参构造函数
	Student s4(1, "J");
	// 打印 Student s4 实例对象值
	cout << "name : " << s4.m_name << " , age : " << s4.m_age << endl;

	// 使用 等号法 调用 有一个参数的 有参构造函数
	// C++ 对等号进行了功能增强
	Student s5 = "K";
	// 打印 Student s4 实例对象值
	cout << "name : " << s5.m_name << " , age : " << s5.m_age << endl;

	// 调用拷贝构造函数
	Student s3 = Student(s2);
	// 打印 Student s3 实例对象值
	cout << "name : " << s3.m_name << " , age : " << s3.m_age << endl;



	// 控制台暂停 , 按任意键继续向后执行
	system("pause");
	return 0;
}

执行结果 :

调用无参构造函数
name : name , age : 0
调用有参构造函数
name : Tom , age : 18
调用有参构造函数
name : J , age : 1
调用有参构造函数
name : K , age : 0
调用拷贝构造函数
name : Tom , age : 18
请按任意键继续. . .