c++类的生存周期

#include<iostream>
using namespace std;
/*
       类和对象 
	   1、构造函数
	             初始化对象所占内存空间
	   2、析构函数
	             释放对象所占资源
	   3、拷贝构造函数
	              用一个已存在的对象来构造一个相同类型的对象
				   形参必须使用引用对象
	 4、赋值运算符的重载函数
	              用一个已存在的对象给另一个相同类型的已存在的对象赋值
				  形参要使用常引用
				  常引用的作用：1、防止实参被修改2、接收隐式生成的临时对象
*/
//对象的生存周期


class  Object
{

public:

	//Object(char*name)

	Object(int num)
	{
		cout<<"Object::Object(int)"<<endl;
		mname=new char[1];
		mnum=num;
	}
	Object(char*name="",int num=0)
	{
		cout<<"Object::Object(char,int)"<<endl;
		mname=new char[strlen(name)+1];
		strcpy(mname,name);
		Show();
		if(num==0)
		{
			mnum=strlen(mname+1);
		}
		
	}
	Object(const  Object& rhs)
	{
		cout<<"Object::Object(Object)"<<endl;
		mname=new char[strlen(rhs.mname)+1];
		strcpy(mname,rhs.mname);
		mnum=rhs.mnum;
	}
	Object & operator=(const Object&rhs)
	{
		cout<<"Object::operator=(Object)"<<endl;
		if(this!=&rhs)
		{
			delete[] mname;
			mname=new char[strlen(rhs.mname)+1];
			strcpy(mname,rhs.mname);
			mnum=rhs.mnum;

		}
		return *this;
	}
	void Show()
	{
		cout<<"name:"<<mname<<endl;
	}
	~Object()
	{
		cout<<"Object::~Object()"<<endl;
		delete[] mname;//堆上的资源
		mname=NULL;
	}

private:
	char* mname;
	int mnum;
};
//对象的生存周期
Object gobj1("global  object1");//1调用char*类型的构造函数，最后一个销毁，main函数结束之后，程序结束之前
static Object gobj2("global  object2");//2

//先全局后局部
int main()
{
	cout<<"-------------"<<endl;
	Object lobj1("local object1");//1
	cout<<"-------------"<<endl;
	Object lobj2(10);//2

	static Object sobj("static object");//3


	Object lobj3=lobj1;//拷贝构造函数
	lobj3=lobj2;//赋值运算符的重载函数

	Object* pobj4=new Object("local object4");//堆上返回的都是一个地址，栈上的指针指向堆上的一个对象,堆上的空间需要手动释放
	cout<<"-------------"<<endl;

	Object aobj5[2];//声称对象数组  掉默认构造函数
	cout<<"-------------"<<endl;

	Object* pobj6=&Object("local object6");//右边显示生成临时对象  把对象的地址给了栈上的指针  ，有临时对象生成，临时对象遇到;销毁，poj6指向无效地址，地址虽然归还给系统，如果内存块里面的值没有被修改，结果就是正确的，打印错误的话，内存块已经被分配，数据被覆盖
	Object& robj7=(Object)("local object7",20);//引用回提升 临时对象的生存周期，和引用对象相同一直到main结束才销毁

	Object& pobj8=*(new Object("local object8"));//=右边，堆上对象生成，返回地址
     
	Object obj9="object9";//构造一个新的对象 Object obj9("object9")
	delete pobj4;//堆上的对象销毁，有析构函数的调用

	cout<<"-------------"<<endl;
	Object obj10=Object("object10");//=右边显示生成临时对象   ，生成临时对象的目的就是为了构造一个新的对象，就一生成临时对象的方式生成新对象，整个代码只有一个对象生成
	obj9=Object("object11");//右边的对象给左边赋值,赋值运算符的重载函数，；到了临时对象就要销毁,不是生成一个新的对象，不会被优化，有一个析构函数的调用
	cout<<"-------------"<<endl;

	return 0;
}
Object gobj3("global  object3");//3
static Object gobj4("global  object4");//4











/*int main()
{
	//Object obj="object";//等同于Object obj("object")调用构造函数
	Object obj=(Object)("object",10);//逗号表达式，用参数10，显示生成临时对象，是为了生成新对象，以
	//以生成临时对象的方式生成新对象。有优化。 整个过程只有一个对象生成。调用有整形参数的构造函数
	return 0;
}
*/








//构造函数是第一种
//int main()
//{
//	//临时对象的作用是为了生成新对象   以生成临时对象的方式生成新的对象
//	Object obj=Object("object");//有一个对象生成      这个临时对象的作用是为了生成新的对象，编译器优化掉
//	return 0;
//}








//引用会提升临时对象的生存周期  从调用点到mian()结束
//int main()
//{
//	Object *pobj=&Object("object");//显示生成临时对象  取他的地址      有两个函数执行 有对象的生成 也有对象的销毁   临时对象的生存周期
//	cout<<"______________"<<endl;
//	Object &pobj1=Object("object");//右边显示生成临时对象   左边用引用引用这个临时对象  只有一个函数调用      &会提升临时对象的生存周期 
//	cout<<"______________"<<endl;
//
//	return 0;
//}













//int main()
//{
//	Object obj1("object1");
//	Object*  pobj=new Object("object   heap");//对象在堆上开辟
//	delete pobj;//不仅要把堆内存释放掉  还要调用析构函数
//	cout<<"*_____________*"<<endl;
//
//	return 0;
//}















/*


	形参是对象类型 建议使用引用
	void Func(Object obj)
{
	Object temp(obj);
}

	
	int main()
{
	Object ob1("object1");
	Func(ob1);
	return 0;

}*/