不同情形下 对象的构造函数和析构函数的调用并不相同

对象在不同情况下的构造函数和析构函数的调用差异很大

构造函数和析构函数的调用次数有所不同

 

当对象做参数时，实参完全复制给形参，所以不需再调用构造函数

其实是调用的拷贝构造函数即CClass a();CClass b=a；

 

但形参运行时为临时变量，需调用析构函数

但对象引用做参数时，因为是原实参本身，所以在函数内不会调用析构

 

#include <iostream> using namespace std; class Aclass { public: int a; Aclass(int t=0){ this->a=t; cout<<"constructor "<<a<<endl; } void print(){ cout<<"print "<<this->a<<endl; } ~Aclass(){ cout<<"destructor "<<a<<endl; } }; Aclass test(Aclass para)//attention please!!! { Aclass tmp(4); tmp.print(); tmp.a=para.a+1; para.print(); return tmp; } void main() { Aclass t1(2); Aclass t2; t2=test(t1); t1.print(); t2.print(); }    

结果是：

constructor 2
constructor 0
constructor 4
print 4
print 2
destructor  3
destructor  2
destructor  3
print 2
print 3
destructor  3
destructor  2
Press any key to continue

 

  #include <iostream> using namespace std; class Aclass { public: int a; Aclass(int t=0){ this->a=t; cout<<"constructor "<<a<<endl; } void print(){ cout<<"print "<<this->a<<endl; } ~Aclass(){ cout<<"destructor "<<a<<endl; } }; Aclass test(Aclass& para)//attention please!!! { Aclass tmp(4); tmp.print(); tmp.a=para.a+1; para.print(); return tmp; } void main() { Aclass t1(2); Aclass t2; t2=test(t1); t1.print(); t2.print(); }  

结果是

constructor 2
constructor 0
constructor 4
print 4
print 2
destructor  3  （the parameter object's destruction has gone ）
destructor  3
print 2
print 3
destructor  3
destructor  2
Press any key to continue

参数引用的实参析构函数没了

 多出来的析构函数是谁的呢

利用断点调试的时候可以清晰的看出constructor对应的destructor

先看下例

#include <iostream> using namespace std; class Aclass { public: int a; Aclass(int t=0){ this->a=t; cout<<"constructor "<<a<<endl; } void print(){ cout<<"print "<<this->a<<endl; } ~Aclass(){ cout<<"destructor "<<a<<endl; } }; void test(Aclass& para) { Aclass tmp(4); tmp.a=para.a+1; } void main() { Aclass t1(2); Aclass t2; test(t1); }

结果

constructor 2
constructor 0
constructor 4
destructor  3
destructor  0
destructor  2
Press any key to continue

数量一致

差别主要在return 语句

那么，问题很可能就在这里

 我们有一种猜测，就是函数返回时，先对要返回的局部变量做一份拷贝，函数返回

之后 ，才把返回值赋给被赋值变量

有待证明

 

 

#include <iostream> using namespace std; class Aclass { public: int a; Aclass(int t=0){ this->a=t; cout<<"constructor "<<a<<endl; } void print(){ cout<<"print "<<this->a<<endl; } ~Aclass(){ cout<<"destructor "<<a<<endl; } }; Aclass* test(Aclass para) { Aclass tmp(4); tmp.print(); tmp.a=para.a+1; para.print(); return &tmp; } void main() { Aclass t1(2); Aclass* t2; t2=test(t1); t1.print(); t2->print(); }

结果是

constructor 2
constructor 4
print 4
print 2
destructor  3
print 2
print -858993460
destructor  2
Press any key to continue

临时对象的指针是不能做返回值的

对象指针 因没有分配对象内存而无所谓构造函数的调用了

 

#include <iostream> using namespace std; class Aclass { public: int a; Aclass(int t=0){ this->a=t; cout<<"constructor "<<a<<endl; } void print(){ cout<<"print "<<this->a<<endl; } ~Aclass(){ cout<<"destructor "<<a<<endl; } }; Aclass test(Aclass& para) { Aclass* tmp=new Aclass(4); tmp->a=para.a+1; return *tmp; } void main() { Aclass t1(2); Aclass t2; t2=test(t1); }

如果使用new 动态分配内存，析构在delete时才调用

动态变量存在于堆内存，必须手动释放

有一个new就要有一个delete与之对应