C++何时调用构造函数，何时调用析构函数

前言

  C++中的构造函数、析构函数的调用时机常常让人很头疼，这篇文章就详细的讲解在实际开发中常见的构造函数和析构函数的调用情况。

1、构造函数与析构函数的概念

  对象的初始化和清理也是两个非常重要的安全问题。一个对象或者变量没有初始状态，对其使用后果是未知。同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

  c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。

  对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供，编译器提供的构造函数和析构函数是 空实现。

• 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
• 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法：类名(){}

1. 构造函数，没有返回值也不写void
2. 函数名称与类名相同
3. 构造函数可以有参数，因此可以发生重载
4. 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

析构函数语法： ~类名(){}

1. 析构函数，没有返回值也不写void
2. 函数名称与类名相同,在名称前加上符号 ~
3. 析构函数不可以有参数，因此不可以发生重载
4. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

2、构造函数的分类及调用

两种分类方式：

• ​ 按参数分为： 有参构造和无参构造

• 按类型分为： 普通构造和拷贝构造

三种调用方式：

• 括号法
• 显示法
• 隐式转换法

示例：

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "有参构造函数!" << endl;
	}
	//拷贝构造函数，参数const：不可以修改传进来的P对象    
    //引用的本质是指针常量 Person &p = Person *const p ;
	Person(const Person& p) {
		age = p.age;
		cout << "拷贝构造函数!" << endl;
	}
	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int age;
};

//2、构造函数的调用
//调用无参构造函数
void test01() {
	Person p; //调用无参构造函数
}

//调用有参的构造函数
void test02() {

	//2.1  括号法，常用
	Person p1(10); //有参构造函数
    Person p3(p1); //拷贝构造函数
	//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
	//Person p2();

	//2.2 显式法(等号右边都是匿名对象，左边是对象名)
	Person p2 = Person(10); //有参构造
	Person p3 = Person(p2); //拷贝构造
	//Person(10)单独写就是匿名对象  当前行结束之后，马上析构。创建了一个对象，但没有名

	//2.3 隐式转换法
	Person p4 = 10; // Person p4 = Person(10); 
	Person p5 = p4; // Person p5 = Person(p4); 

	//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明 Person (p4) == Person p4(与上边已有的p4重定义)
	//Person (p4);
}

int main() {

	test01();
	//test02();

	system("pause");

	return 0;
}

3、拷贝构造函数的调用时机

  C++中拷贝构造函数调用时机通常有三种情况：

• 使用一个已经创建完毕的对象来初始化一个新对象
• 值传递的方式给函数参数传值
• 以值方式返回局部对象

class Person {
public:
	Person() {
		cout << "无参构造函数!" << endl;
		mAge = 0;
	}
	Person(int age) {
		cout << "有参构造函数!" << endl;
		mAge = age;
	}
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		mAge = p.mAge;
	}
	//析构函数在释放内存之前调用
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int mAge;
};

//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {

	Person man(100); //p对象已经创建完毕
	Person newman(man); //显式法调用拷贝构造函数
    //隐式转换法调用拷贝构造函数  Person newman2 = man 等价于 Person newman2 = Person (man)
	Person newman2 = man; 
}

//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p1) {}
void test02() {
	Person p; //无参构造函数
	doWork(p);
}

//3. 以值方式返回局部对象，通过两次打印的两个地址不一样可证明
//根据函数返回的p1对象创建(拷贝)一个新的对象返回给调用者
Person doWork2()
{
	Person p1;
	cout << (int *)&p1 << endl;
	return p1;
}

void test03()
{
	Person p = doWork2();   //返回的不是dowork2()里面的p1，而是拷贝p1所得来的对象
	cout << (int *)&p << endl;
}


int main() {

	//test01();
	//test02();
	test03();

	system("pause");

	return 0;
}

4、析构函数的调用

  析构函数的坑点比较多，这里分开来写。

  4.1 一般情况

  对象生命周期结束，对象被销毁前会调用析构函数

#include 
using namespace std;

class  example
{
public:
	example()
	{
		cout << "调用构造函数" << endl;
	}
	
	 ~ example()
	 {
		 cout << "调用析构函数" << endl;
	 }

private:
	int i;
};

void test()
{
	example p;  //p开辟在栈上，test函数一结束，p就会被释放销毁
}

void main()
{
	test();
	system("pause");
}

  4.2 对象成员

  当类中成员是其他类对象时，我们称该成员为 对象成员
  构造的顺序是 ：先调用对象成员的构造，再调用本类构造
  析构顺序与构造相反

#include 
#include 
using namespace std;

class Phone
{
public:
	Phone()
	{
		cout << "Phone构造" << endl;
	}

	~Phone()
	{
		cout << "Phone析构" << endl;
	}

	string m_PhoneName;
};


class Person
{
public:
	Person()
	{
		cout << "Person构造" << endl;
	}

	~Person()
	{
		cout << "Person析构" << endl;
	}

public:
	Phone m_Phone;
};

void test01()
{
	//当类中成员是其他类对象时，我们称该成员为 对象成员
	//构造的顺序是 ：先调用对象成员的构造，再调用本类构造
	//析构顺序与构造相反
	Person p;

}


int main() {

	test01();

	system("pause");

	return 0;
}

  4.3 new出来的对象

#include 
using namespace std;

class  example
{
public:
	example()
	{
		cout << "调用构造函数" << endl;
	}
	
	 ~ example()
	 {
		 cout << "调用析构函数" << endl;
	 }

private:
	int i;

};

void main()
{
	example *p = new example();

	system("pause");
}

  只有释放指针p（delete p），才会调用析构函数，否则不会调用析构函数。

  4.4 多态的特殊情况

  对于多态来说，当父类指针指向子类对象时，如下所示：

Animal *animal = new Cat("Tom");

  释放父类指针不会调用子类对象的析构函数，当子类中存在new的堆区内存分配时，会出现内存泄漏的情况。解决办法就是：使用虚析构，需要把父类的析构函数声明为虚析构或者纯虚析构。这样释放父类指针就会调用子类的析构函数。

#include 
using namespace std;
#include 
#include 

class Animal {
public:

	Animal()
	{
		cout << "Animal 构造函数调用！" << endl;
	}
	virtual void Speak() = 0;

	virtual ~Animal() = 0;
	
};

Animal::~Animal()
{
	cout << "Animal 纯虚析构函数调用！" << endl;
}

//和包含普通纯虚函数的类一样，包含了纯虚析构函数的类也是一个抽象类。不能够被实例化。

class Cat : public Animal {
public:
	Cat(string name)
	{
		cout << "Cat构造函数调用！" << endl;
		m_Name = new string(name);
	}
	virtual void Speak()
	{
		cout << *m_Name << "小猫在说话!" << endl;
	}
	~Cat()
	{
		cout << "Cat析构函数调用!" << endl;
		if (this->m_Name != NULL) {
			delete m_Name;
			m_Name = NULL;
		}
	}

public:
	string *m_Name;
};

void test01()
{
	
	Animal *animal = new Cat("Tom");
	animal->Speak();

	//通过父类指针去释放，会导致子类对象可能清理不干净，造成内存泄漏
	//怎么解决？给基类增加一个虚析构函数
	//虚析构函数就是用来解决通过父类指针释放子类对象
	delete animal;
}

int main() {

	test01();

	system("pause");

	return 0;
}

5、总结

  关于析构函数和构造函数调用时机的问题，暂且告一段落。文章是根据自己平时所遇到的问题进行总结，写的不全面，还有很多例子没有提及到。还请大家多多指正~~