C++构造与析构

今天看了下Qt编程，顺便查了下C++的构造与析构，看到网上有一篇测试的文章，自己在linux也试了下，不过结果还是和在windows下有些区别的，具体原因我也没有深入研究。

具体代码如下：

#include "stdio.h"
class Demo{
public :
int i;
const char* objName;
Demo(){
objName = "Default object.";
printf("%s, objName = %s/r/n", "Demo default ctor. method.", objName);
i = 1000;
}
Demo(int ival, const char* name){
printf("%s,i = %d, objName = %s/r/n", "Demo(int ival) ctor method", ival, name);
i = ival;
objName = name;
}
Demo(const Demo& d){
printf("%s/r/n", "Demo copy ctor method.");
i = d.i;
objName = "copied d";
}
~Demo(){  //xigou
printf("%s, i = %d, objName = %s/r/n", "Demo dector. method" , i, objName);
i = -1;
objName = "Error";
}
};
Demo& testMethod0(){
printf("%s/r/n", "Enter testMethod0.");
Demo d(0, "d in testMethod0");
printf("%s/r/n", "Exit testMethod0.");
return d;
}
Demo testMethod1(){
printf("%s/r/n", "Enter testMethod1.");
Demo d(1, "d in testMethod1");
printf("%s/r/n", "Exit testMethod1.");
return d;
}
Demo* testMethod2(){
printf("%s/r/n", "Enter testMethod2.");
Demo *d = new Demo(2, "d in testMethod2");
printf("%s/r/n", "Exit testMethod2.");
return d;
}
int main(int argc, char* argv[])
{
Demo d;  //声明函数居然会发生构造
d = testMethod1();  //2
Demo& d1 = testMethod0(); //3
Demo d2(999, "d1"); //4
Demo* d3 = testMethod2();  //5
printf("d.i = %d/r/n", d.i);
printf("d1.i = %d/r/n", d1.i);
printf("d2.i = %d/r/n", d2.i);
printf("d3.i = %d/r/n", d3->i);
delete d3;
return 0;
}

执行结果如下：

Demo default ctor. method., objName = Default object.
Enter testMethod1.
Demo(int ival) ctor method,i = 1, objName = d in testMethod1
Exit testMethod1.
Demo dector. method, i = 1, objName = d in testMethod1
Enter testMethod0.
Demo(int ival) ctor method,i = 0, objName = d in testMethod0
Exit testMethod0.
Demo dector. method, i = 0, objName = d in testMethod0
Demo(int ival) ctor method,i = 999, objName = d1
Enter testMethod2.
Demo(int ival) ctor method,i = 2, objName = d in testMethod2
Exit testMethod2.
d.i = 1
d1.i = -1
d2.i = 999
d3.i = 2
Demo dector. method, i = 2, objName = d in testMethod2
Demo dector. method, i = 999, objName = d1
Demo dector. method, i = 1, objName = d in testMethod1
在进行对象声明的时候也调用了一个默认构造函数，在调用方法0和方法1时，内部创建的对象都是临时的，在退出相对应的函数的时候对象就析构了，d和d1应该是指向被析构的对象，不过奇怪的是，它们最好输出的值居然是正确的，在网上那篇文章中，说在d = testMethod1(); 发生了拷贝操作，但我们这里没有出现，不过在编译这个文件的时候倒是说“warning: reference to local variable ‘d’ returned”，好像是说引用了局部变量d，难道说类的声明也仅仅是一个引用，只有在 testMethod2(); 使用了指针对指向了新的对象，这个对象没有被自动析构，不过使用指针引用对象的话需要自己对对象进行删除。

看输出结果发现明明发生了5次析构，刚好也是发生了5次构造，但是没有发现默认构造的对象被析构，d in testMedthod1倒是析构了两次，怪异，总感觉又一次是析构默认创建的对象，不过又找不到依据。

使用 Demo d = testMethod1();的方式倒是可以防止默认析构。

看来以后使用c++还是有些问题需要注意。