C++中的构造函数

1 构造函数的基本概念

1.1 构造函数的作用

构造函数的作用：

• 在创建一个新的对象时，自动调用的函数，用来进行“初始化”工作。
• 对这个对象内部的数据成员进行初始化。

1.2 构造函数的特点

构造函数的特点：

• 自动调用（在创建新对象时，自动调用）。
• 构造函数的函数名，和类名相同。
• 构造函数没有返回类型。
• 可以有多个构造函数（即函数重载形式）。

1.3 构造函数的种类

构造函数的种类：

• 默认构造函数
• 自定义的构造函数
• 拷贝构造函数
• 赋值构造函数

---

2 默认构造函数

没有参数的构造函数，称为默认构造函数。

2.1 合成的默认构造函数

当类中没有定义任何构造函数时，编译器默认提供一个无参构造函数，并且其函数体为空：

• 如果数据成员使用了“类内初始值”，就使用这个值来初始化数据成员。【C++11】
• 否则，就使用默认初始化（实际上，不做任何初始化）

注意：
只要手动定义了任何一个构造函数（包括拷贝构造函数），编译器就不会生成“合成的默认构造函数”。一般情况下，都应该定义自己的构造函数，不要使用“合成的默认构造函数”，仅当数据成员全部使用了“类内初始值”，才宜使用“合成的默认构造函数”。

#include <iostream>
#include <Windows.h>
#include <string>

using namespace std;

// 定义一个“人类”
class Human {
public:  //公有的，对外的
	void eat(); //方法， “成员函数”
	void sleep();
	void play();
	void work();

	string getName();
	int getAge();
	int getSalary();

private:
	string name;
	int age = 18;
	int salary;
};

void Human::eat() {
	cout << "吃炸鸡，喝啤酒！" << endl;
}

void Human::sleep() {
	cout << "我正在睡觉!" << endl;
}

void Human::play() {
	cout << "我在唱歌! " << endl;
}

void Human::work() {
	cout << "我在工作..." << endl;
}

string Human::getName() {
	return name;
}

int Human::getAge() {
	return age;
}

int Human::getSalary() {
	return salary;
}

int main(void) {
	Human  h1;  // 使用合成的默认初始化构造函数
	cout << "年龄: " << h1.getAge() << endl;     //使用了类内初始值
	cout << "薪资：" << h1.getSalary() << endl;  //没有类内初始值

	system("pause");
	return 0;
}

2.2 手动定义的默认构造函数

手动定义的默认构造函数，常称为“默认构造函数”。

Human::Human() {
	name = "无名氏";
	age = 18;
	salary = 30000;
}


int main(void) {
	Human  h1;  // 使用自定义的默认构造函数
	cout << "姓名：" << h1.getName() << endl;
	cout << "年龄: " << h1.getAge() << endl;    
	cout << "薪资：" << h1.getSalary() << endl; 

	system("pause");
	return 0;
}

说明： 如果某数据成员使用类内初始值，同时又在构造函数中进行了初始化，那么以构造函数中的初始化为准。相当于构造函数中的初始化，会覆盖对应的类内初始值。

---

3 自定义的重载构造函数

3.1 自定义的重载构造函数

自定义的重载构造函数比较简单，示例代码如下：

Human::Human() {
	name = "无名氏";
	age = 18;
	salary = 30000;
}

Human::Human(int age, int salary) {
	cout << "调用自定义的构造函数" << endl; 
	this->age = age;      //this是一个特殊的指针，指向这个对象本身
	this->salary = salary;
	name = "无名";
}


int main(void) {
	Human  h1(25, 35000);  // 使用自定义的默认构造函数

	cout << "姓名：" << h1.getName() << endl;
	cout << "年龄: " << h1.getAge() << endl;    
	cout << "薪资：" << h1.getSalary() << endl; 

	system("pause");
	return 0;
}

3.2 创建对象的几种方式

#include <stdio.h>

class Test
{
public:
    Test() 
    { 
        printf("Test()\n");
    }
    Test(int v) 
    { 
        printf("Test(int v), v = %d\n", v);
    }
};

int main()
{
    Test t;      // 第一种：调用 Test()
    Test t1(1);  // 第二种：调用 Test(int v)
    Test t2 = 2; // 第三种：调用 Test(int v)
    Test t3 = Test(); // 第4种：调用Test()
    
    int i(100);
    
    printf("i = %d\n", i);
    
    return 0;
}

3.3 手工调用构造函数

一般情况下，构造函数在对象定义时被自动调用；但是在一些特殊情况下，我们需要手工调用构造函数。

创建对象数组就需要手工调用构造函数：

#include <stdio.h>

class Test
{
private:
    int m_value;
public:
    Test() 
    { 
        printf("Test()\n");
        
        m_value = 0;
    }
    Test(int v) 
    { 
        printf("Test(int v), v = %d\n", v);
        
        m_value = v;
    }
    int getValue()
    {
        return m_value;
    }
};

int main()
{
    Test ta[3] = {Test(), Test(1), Test(2)};      
    
    for(int i=0; i<3; i++)
    {
        printf("ta[%d].getValue() = %d\n", i , ta[i].getValue());
    }
    
    Test t = Test(100);
    
    printf("t.getValue() = %d\n", t.getValue());
    
    return 0;
}

---

4 拷贝构造函数

4.1 合成的拷贝构造函数

当类中没有定义拷贝构造函数时，编译器默认提供也给拷贝构造函数，简单的进行成员变量的复制。编译器默认提供的拷贝构造函数也叫合成的拷贝构造函数，合成的拷贝构造函数使用“浅拷贝”。

拷贝构造函数的意义：

• 兼容C语言的初始化方式。
• 初始化行为能够符合预期的逻辑。

拷贝构造函数分为浅拷贝和深拷贝：

• 浅拷贝：拷贝后对象的物理状态相同。
• 深拷贝：拷贝后对象的逻辑状态相同。

当对象中有成员指代了系统的资源，我么需要进行深拷贝：

• 成员指向了动态内存空间。
• 成员打开了外存中的文件。
• 成员使用了系统中的网络端口。
• …

编译器提供的拷贝构造函数只进行浅拷贝！

4.2 手动定义的拷贝构造函数

一般性原则：自定义拷贝构造函数，必然要实现深拷贝！

4.3 拷贝构造函数的调用时机

什么时候调用拷贝构造函数？

1. 调用函数时，实参是对象，形参不是引用类型。如果函数的形参是引用类型，就不会调用拷贝构造函数。
2. 函数的返回类型是类，而且不是引用类型。
3. 对象数组的初始化列表中，使用对象。

void test(Human man) {
	cout << man.getSalary() << endl;
}

void test2(Human &man) { //不会调用拷贝构造函数，此时没有没有构造新的对象
	cout << man.getSalary() << endl;
}

Human test3(Human &man) {
	return man;
}

Human& test4(Human &man) {
	return man;
}


int main(void) {
	Human h1(25, 35000);  // 调用默认构造函数
	Human h2(h1);         // 调用拷贝构造函数
	Human h3 = h1;		  // 调用拷贝构造函数

	test(h1);		      // 调用拷贝构造函数
	test2(h1);			  // 不会调用拷贝构造函数
	test3(h1);            // 创建一个临时对象，接收test3函数的返回值，调用1次拷贝构造函数
	Human h4 = test3(h1); // 仅调用1次拷贝构造函数，返回的值直接作为h4的拷贝构造函数的参数
	test4(h1);            // 因为返回的是引用类型，所以不会创建临时对象，不会调用拷贝构造函数
	
	Human men[] = { h1, h2, h3 }; //调用3次拷贝构造函数

	system("pause");
	return 0;
}

4.4 继承关系中的拷贝构造函数

假设B继承自A，如下代码：

B b1;
B b2(b1);	// 先调用A类的构造函数，再调用B类的拷贝构造函数

---

5 赋值构造函数

5.1 合成的赋值构造函数

如果没有定义赋值构造函数，编译器会自动定义“合成的赋值构造函数”，与其他合成的构造函数相同，是“浅拷贝”（又称为“位拷贝”）。

5.2 自定义的赋值构造函数

简要的赋值构造函数代码如下：

Human& Human::operator=(const Human &man) {
	cout << "调用" << __FUNCTION__ << endl;
	if (this == &man) {
		return *this; //检测是不是对自己赋值：比如 h1 = h1;
	}

	// 如果有必要，需要先释放自己的资源（动态内存）
	//delete[] addr;
	//addr = new char[ADDR_LEN];

	// 深拷贝
	strcpy_s(addr, ADDR_LEN, other.addr);

	// 处理其他数据成员
	name = man.name;
	age = man.age;
	salary = man.salary;

	// 返回该对象本身的引用， 以便做链式连续处理，比如 a = b = c;
	return *this;
}

---

6 在已经申请的空间上调用构造函数

这真是一个骚操作，很多情况下我们需要为对象预先分配空间，但是如果对象没有默认的构造函数就会很尴尬。我们可以通过malloc分配空间，然后在需要的时间再在这片空间上调用指定的构造函数。示例代码如下：

#include <iostream>
#include <vector>
#include <cstdlib>

using namespace std;

class Test39
{
private:
	int age;
public:
	Test39()
	{
		cout << "Test39()" << endl;
	}

	~Test39()
	{
		cout << "~Test39()" << endl;
	}
};

void test39()
{
	Test39* p = (Test39*)malloc(sizeof(Test39));
	new (p) Test39();
	p->~Test39();
}

不得不说C++真的是骚，真的足够强大，真的让我学不会！越学不会我越喜欢，不信搞不定C++。

---

参考资料：

1. C/C++从入门到精通-高级程序员之路【奇牛学院】
2. C++深度解析教程