#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;
}*/