C++ 对象的生存期详解

1.局部对象

（1）对于局部定义的对象，每当程序控制流到达该对象定义处时，定义构造函数。当程序走出该局部域时，调用析构函数。

这种普通的局部对象具有动态生存期。

#include<iostream>
using namespace std;

class Complex
{
	double Real;//实部
	double Image;//虚部
public:
	Complex() :Real{}, Image{}//缺省的构造函数
	{
		cout << "构造一个对象：" << this << endl;
	}
	Complex(double r, double i) :Real{ r }, Image{ i }//带参数的构造函数
	{
		cout << "构造一个对象：" << this << endl;
	}
	~Complex()
	{
		cout << "析构一个对象：" << this << endl;
	}
	void Print() const  //常方法
	{
		cout << "Real=" << Real << '\t' << "Image" << Image << endl;
	}
};
void fun()
{
	Complex c1(1.0, 2.0);
}

void main()
{
	int n = 5;
	for(int i=0;i<n;i++)
	{
		fun();
	}
}

运行结果及分析：
从结果可以看出，每调用一次fun函数时，就先调用构造函数，再调用析构函数，因此会出现下面的运行结果。每次调用fun函数时，都是在给Complex类的对象c1赋值时调用构造函数，在fun函数结束时再调用析构函数，一共调用5次fun函数。
另外在每次调用fun函数时，this指针都指向Complex类的对象c1的地址。

②对于静态局部定义的对象，在程序控制首次到达该对象的定义处时，调用构造函数。当整个程序结束时调用析构函数。

静态局部对象具有静态生存期。

class Complex
{
	double Real;//实部
	double Image;//虚部
public:
	Complex() :Real{}, Image{}//缺省的构造函数
	{
		cout << "构造一个对象：" << this << endl;
	}
	Complex(double r, double i) :Real{ r }, Image{i}//带参数的构造函数
	{
		cout << "构造一个对象：" << this << endl;
	}
	~Complex()
	{
		cout << "析构一个对象：" << this << endl;
	}
	void Print() const  //常方法
	{
		cout << "Real=" << Real << '\t' << "Image" << Image << endl;
	}
};
void fun()
{
	static Complex sc(3.0, 4.0);
}

void main()
{
	int n = 5;
	for(int i=0;i<n;i++)
	{
		fun();
	}
}

运行结果及分析：
从运行结果可以看出，因为在定义对象时有static关键字，所以该对象具有静态生存期，也就是说该对象为静态对象，当程序第一次到达该对象定义处时，调用构造函数，当这个程序结束时，也就是调用5次fun函数结束后，再调用析构函数。
注意：因为有关键字static，所以并不是调用一次fun函数，就调用一次构造函数和析构函数。

2.全局对象

对于全局定义的对象，每当程序进入入口函数main之前对象就以及定义，这时要调用构造函数。整个程序结束时才调用析构函数。

全局对象具有静态生存期

#include<iostream>
using namespace std;

class Object
{
private:
	int value;
public:
	Object(int x = 0) :value(x)
	{
		cout << "构造Object对象:" << value << endl;
	}
	~Object()
	{
		cout << "析构Object对象:" << value << endl;
	}
};
Object obja(1);//全局对象
int main()
{
	Object objb(2);//局部对象
	return 0;
}
Object objc(3);//全局对象

运行结果及分析：

有结果可以看出，对于全局对象，当程序开始运行时顺序执行，先调用Object类的全局对象obja(1)，调用一次构造函数；再调用Object类的全局对象objc(3)，再调用一次构造函数；最后调用主函数中的Object类的局部对象objb(2)，再调用一次构造函数。但是调用析构函数时，与调用构造函数的调用顺序相反，调用顺序为Object objb(2)，Object objc(3)，Object obja(1)。

3.动态创建的对象

使用new创建对象，delete释放对象。
（1）使用malloc和free

malloc在使用时，申请内存空间是从堆中获取。

#include<iostream>
using namespace std;

class Complex
{
private:
	double Real;//实部
	double Image;//虚部
public:
	Complex() :Real{}, Image{}  //缺省的构造函数
	{
		cout << "构造对象:" << this << endl;
	}
	Complex(double r, double i) :Real{ r }, Image{ i }//带参数的构造函数
	{
		cout << "构造对象: " << this << endl;
	}
	~Complex()
	{
		cout << "析构对象:" << this << endl;
	}
	void Print() const  //常方法
	{
		cout << "Real=" << Real << '\t' << "Image=" << Image << endl;
	}
};
int main()
{
	int n = 5;
	Complex* cp = (Complex*)malloc(sizeof(Complex));
	cp->Print();
	free(cp);

	Complex* bp = (Complex*)malloc(sizeof(Complex) * n);
	bp->Print();
	free(bp);

	return 0;
}

运行结果：

（2）使用new创建对象

#include<iostream>
using namespace std;

class Complex
{
private:
	double Real;//实部
	double Image;//虚部
public:
	Complex() :Real{}, Image{}  //缺省的构造函数
	{
		cout << "构造一个对象:" << this << endl;
	}
	Complex(double r, double i) :Real{ r }, Image{ i }//带参数的构造函数
	{
		cout << "构造一个对象: " << this << endl;
	}
	~Complex()
	{
		cout << "析构一个对象:" << this << endl;
	}
	void Print() const  //常方法
	{
		cout << "Real=" << Real << '\t' << "Image=" << Image << endl;
	}
};

int main()
{
	int n = 5;
	Complex* cp = new Complex(1,2);
	cp->Print();
	delete cp;
	return 0;
}

运行结果及分析：
使用new申请空间创建对象时调用构造函数，使用delete释放空间时调用析构函数。
在用new创建对象时，this指针指向该对象的地址。