[菜鸟提问]关于构造函数与析构函数的调用问题

[lzero13199]

#include<iostream.h>
class example
{
public:
example(int n)
{ i=n;
cout<<"Constructing\n";
}
~example()
{ cout<<"Destructing\n";}
int get_i(){ return i;}
private:
int i;
};
int sqr_it(example o)
{ return o.get_i()*o.get_i(); }
main()
{
examle x(10);
cout<<x.get_i()<<endl;
cout<<sqr_it(x)<<endl;
return 0;
}
为什么运行结果会是那样？构造函数和析构函数是成对出现的吗？析构函数到底是什么时候调用的？怎样算撤销一个对象了？希望高人赐教！先谢过！

[昵称很不好取]

#include <iostream> 
using namespace std;

class example{ 
public: 
	example(int n) 
	{  
		i=n; 
		cout <<"Constructing\n"; 
	} 
	~example() 
	{ 
		cout <<"Destructing\n";
	} 
	int get_i(){ return i;} 
private: 
	int i; 
}; 

int sqr_it(example o) 
{ 
	return o.get_i()*o.get_i();  
} 
int main() 
{ 
	example x(10);           //调用构造函数
	cout <<x.get_i() <<endl; //输出10
	cout <<sqr_it(x) <<endl; //调用拷贝构造函数(此题无输出)，输出100，之后调用析构函数，销毁临时对象
	
	return 0;                //x声明周期结束，调用析构函数
}

[菜鸟二号]

楼上正解

[mmilmf]

Constructing
10
Destructing
100
Destructing
以上是输出结果，
在程序走到example x(10); 时(这里你把类名打错啦)。会调用构造函数，接下来通过对象x调用类的
成员函数，输出10.走到第二个cout语句时，通过参数传递又调用一次构造函数，但是在此之前先调用
析构函数回收x，此时x对象的生命周期即将结束。最后sqr_it结束之后，析构函数最后回收o

[JecenFan]

一般情况下都是成对出现的，但大多数情况当不需要释放内存时往往会省略析构函数 或构造函数

[JecenFan]

[Quote=引用 3 楼 mmilmf 的回复:]
Constructing
10
Destructing
100
Destructing
以上是输出结果，
在程序走到example x(10); 时(这里你把类名打错啦)。会调用构造函数，接下来通过对象x调用类的
成员函数，输出10.走到第二个cout语句时，通过参数传递又调用一次构造函数，但是在此之前先调用
析构函数回收x，此时x对象的生命周期即将结束。最后sqr_it结束之后，析构函数最后回收o

[/Quote]
上面说的对 析构函数是用来释放内存的，以减少内存的占用量。

[qizhi0119]

sqr_it()
走进这个函数的时候会走一个复制构造函数.然后走的多出来的析构函数和这里的是配套的.
只不过你的是默认的复制构造函数,所以没有打印信息,我给你补上了个复制构造函数.

代码如下:

#include <iostream> 
using namespace std;
class example 
{ 
  public: 
      example(int n = 10) 
      {  
		  i=n; 
          cout <<"Constructing\n"; 
      } 
	  example(example &e)
	  {
		  i = e.i;
		  cout<<"copy Constructing.\n";
	  }
      ~example() 
      { cout <<"Destructing\n";} 
      int get_i(){ return i;} 
  private: 
      int i; 
};
int sqr_it(example o) 
{
	return o.get_i()*o.get_i(); 
} 

class A
{
};
int main() 
{ 
      example test(10); 
      cout <<test.get_i() <<endl;
      cout <<sqr_it(test) <<endl; 
      return 0; 
} 

[leewon1988]

借用1楼代码

#include <iostream> 
using namespace std;

class example{ 
public: 
    example(int n) 
    {  
        i=n; 
        cout <<"Constructing\n"; 
    } 
    ~example() 
    { 
        cout <<"Destructing\n";
    } 
    int get_i(){ return i;} 
private: 
    int i; 
}; 

int sqr_it(example o) 
{ 
    return o.get_i()*o.get_i();  
} 
int main() 
{ 
{////////////////
    example x(10);           //调用构造函数
    cout <<x.get_i() <<endl; //输出10
    cout <<sqr_it(x) <<endl; //调用拷贝构造函数(此题无输出)，输出100，之后调用析构函数，销毁临时对象
 }/////////   
    return 0;                //x声明周期结束，调用析构函数
}

这样应该就可以看到析构函数的输出了

[damingg]

[Quote=引用 3 楼 mmilmf 的回复:]
Constructing
10
Destructing
100
Destructing
以上是输出结果，
在程序走到example x(10); 时(这里你把类名打错啦)。会调用构造函数，接下来通过对象x调用类的
成员函数，输出10.走到第二个cout语句时，通过参数传递又调用一次构造函数，但是在此之前先调用
析构函数回收x，此时x对象的生命周期即将结束。最后sqr_it结束之后，析构函数最后回收o

[/Quote]
走到第二个cout语句时，通过参数传递又调用一次构造函数，但是在此之前先调用
析构函数回收x怎么感觉说的很绕口，你的意思是第一个destructing是x的么？
我怎么感觉：
第一个destructing是o的析构
第二个destructing是x的

[yangyunzhao]

[Quote=引用 4 楼 tracyfjc 的回复:]
一般情况下都是成对出现的，但大多数情况当不需要释放内存时往往会省略析构函数 或构造函数
[/Quote]
析构会省略么？似乎没有遇到过省略的情况，能不能写个示例代码，看看如何省略？

[na2650945]

对象超出他的生命期限就析构被。
具体什么时候。
还真难说。
不同的对象被。

[macrojj]

[Quote=引用 3 楼 mmilmf 的回复:]
Constructing
10
Destructing
100
Destructing
以上是输出结果，
在程序走到example x(10); 时(这里你把类名打错啦)。会调用构造函数，接下来通过对象x调用类的
成员函数，输出10.走到第二个cout语句时，通过参数传递又调用一次构造函数，但是在此之前先调用
析构函数回收x，x的生命到函数结束才结束，故这句话是错的。此时x对象的生命周期即将结束。最后sqr_it结束之后，析构函数最后回收o

[/Quote]

在调用sqr_it 时，传入一个临时变量x' 隐式的做了这个操作 example x'=x;故会调用的是 拷贝构造函数。在你们程序里 没有拷贝构造函数。
example(example & tmp){cout<<"copy Constructing ";i=tmp.i;};加上之后：

Constructing
10
copy Constructing Destructi
100
Destructing
Press any key to continue

此答案是错的