#include<iostream>
using namespace std;

class MyClass
{
public:
    MyClass()
    {
        x=0;
        cout<<"default constructor of MyClass called!"<<endl;
    }
    MyClass(int i)
    {
        x=i;
        cout<<"Constructor of MyClass called! ("<<x<<")"<<endl;
    }
    ~MyClass()
    {
        cout<<"Destructor of MyClass called! ("<<x<<")"<<endl;
    }
    int GetX()
    {
        return x;
    }
    void Print()
    {
        cout<<x<<endl;
    }
private:
    int x;
};

class ExamClass
{
public:
    ExamClass()
    {
        val=0;
        cout<<"Default constructor of ExamClass called!"<<endl;
    }
    ExamClass(int i,int j,int k)/*:member_obj2(k),member_obj1(j)*/
    {
        member_obj2=k;
        member_obj1=j;//为什么将上面注释的部分改为这两行后，在程序没有结束就会调用析构函数呢？
        val=i;
        cout<<"constructor of ExamClass called!("<<val<<")"<<endl;
    }
    ~ExamClass()
    {
        cout<<"Destructor of ExamClass called!("<<val<<")"<<endl;
    }
    void Print()
    {
        cout<<val<<","<<member_obj1.GetX()<<","<<member_obj2.GetX()<<endl;
    }
private:
    MyClass member_obj1,member_obj2;
    int val;
};
int main()
{
    ExamClass obj1,obj2(1,2,3);
    system("pause");
    obj2.Print();
    system("pause");
    return 0;
}

问题为上面注释的中文说明处，还有麻烦说明下析构函数是何时被调用的？谢谢

[ 本帖最后由 jfckpep 于 2011-7-21 14:46 编辑 ]

ExamClass(int i,int j,int k)
    {
        member_obj2(k),member_obj1(j);
        val=i;
        cout<<"constructor of ExamClass called!("<<val<<")"<<endl;
    }
楼主你是说这样可以正确执行吗？不可能吧。
另外，在程序没有结束就会调用析构函数呢，具体什么意思啊

ExamClass(int i,int j,int k)/*:member_obj2(k),member_obj1(j)*/
     {
         member_obj2=k;
         member_obj1=j;//我的程序是这样的啊，不是“member_obj2(k)，member_obj1(j)；”
         val=i;
         cout<<"constructor of ExamClass called!("<<val<<")"<<endl;
     }
 
另外，运行程序，可以看到主函数还没结束时，就调用了析构函数~ExamClass，即可以看到输出了“Desturctor of MyClass called!"

哦，如果我把程序改为这样
ExamClass(int i,int j,int k)
    {
        MyClass temp1(k),temp2(j);
        member_obj1=temp1;
        member_obj2=temp1;
        val=i;
        cout<<"constructor of ExamClass called!("<<val<<")"<<endl;
    }
那么毫无疑问，你知道肯定有Desturctor of MyClass called!这句话被输出两次，因为当temp1，temp2离开函数时，他会被析构
问题出在这
 member_obj2=k;    member_obj1=j
楼主你没发现这语法很奇怪吗，赋值操作符两边应该都是MyClass类型的，但是你把一个int赋给一个MyClass，却没有报错。在c++中，如果你没有为类写一个赋值操作符函数，会有一个合成的赋值操作符函数，但是编译器合成的赋值操作符函数接受的参数也是MyClass类型的，也就是k和j本应该为MyClass类型的，但是他不是，因为他不是，所以编译器会去寻找能否进行类型转换，使赋值操作成功，而刚好，你提供了这个函数 MyClass(int i)
这种叫做单参数的构造函数，当他没有被声明为explicit时，可以进行类型转换，也就是说，这里因为i为int，所以当需要一个MyClass时，int可以转换为MyClass，所以你的member_obj2=k;    member_obj1=j
这两句就是这种情况，所以编译器用k和j构造两个临时的MyClass变量，因为是临时的，所以当离开函数时，析构函数就调用了。楼主可以在MyClass(int i)前面加上explicit，这样编译器就会保错了
希望我说得够清楚

嗯，当时没考虑类型，谢谢了
你那个member_obj1=temp1;该将temp1改为temp2的

菜鸟，飘过

specilize 功力深厚

把它内存地址打印出来就可以看得很清楚了：
    MyClass()
    {
        x=0;
        cout<<"default constructor of MyClass called!"<<"  addr:"<<this<<endl;
    }
    MyClass(int i)
    {
        x=i;
        cout<<"Constructor of MyClass called! ("<<x<<")"<<"  addr:"<<this<<endl;
    }
    ~MyClass()
    {
        cout<<"Destructor of MyClass called! ("<<x<<")"<<"  addr:"<<this<<endl;
    }


在进入
ExamClass(int i,int j,int k)/*:member_obj2(k),member_obj1(j)*/
{
  //这里member_obj2 member_obj1已经调用了默认的构造函数了。
  member_obj2=k；// 这个时候。会有三步操作，1，调用MyClass(int i)构造一个临时对象，2再调用默认赋值运算符号赋值给member_obj2 ，
                 // 3 临时对象析构。 如果你从写一下赋值运算就看得很清楚了。
}

那改成ExamClass(int i,int j,int k):member_obj2(k),member_obj1(j)的话就没有调用，两种方法有什么不一样吗？

我来说说吧
首先有两个名词，构造函数，和初始化列表（就是:member_obj2(k),member_obj1(j)）具体内容和作用百度或谷歌
其次，类的数据成员的初始化不是在构造函数的函数体中进行的，是在初始化列表中进行的，初始化的顺序是按它们被声明顺序（可自己去查详细资料），如果你没有提供初始化列表的话，编译器会帮你搞定的，但前提是它能搞的定。
最后，在构造函数的函数体里进行的只会是数据成员的赋值。

class Test
{
public:
    Test(){}
    // Test():d(0){} 试着去编译这两种不同的构造函数
private:
    const int d;
};
int main()
{
    Test a;
    return 0;
}

让你困惑的应该不是析构函数在什么时候被调用。