以一个类的类名加一括号构成的一条语句为什么会同时调用构造函数和析构函数，哪位高手能帮小弟我解释一下，编译器里面具体做了些什么东西？多谢

以一个类的类名加一括号构成的一条语句为什么会同时调用构造函数和析构函数，谁能帮我解释一下，编译器里面具体做了些什么东西？谢谢。
以一个类的类名加一括号构成的一条语句为什么会同时调用构造函数和析构函数，谁能帮我解释一下，编译器里面具体做了些什么东西？谢谢。

#include   <iostream>
using   namespace   std;

class   Base
{
public:
Base()   {   cout   < <   "Constructor   called "   < <   endl;   }
~Base()   {   cout   < <   "Destructor   called "   < <   endl;   }

};

void   main()
{
Base();
}

/*   此程序输出：
Constructor   called
Destructor   called
*/

------解决方案--------------------
这就是构造一个临时的匿名的对象，所以会在一行语句中同时调用构造函数和析构函数
------解决方案--------------------
生成了一个临时对象。
------解决方案--------------------
okok
------解决方案--------------------
Base();是一个临时的匿名对象，建它一般是用来做为中间量的，像楼主这样用只能用来作测试，没有实用性。它建了之后，用完就释放，所以它构造之后就析构了

例如在函数里用它：
void test(const Base& bs)
{
}
void main()
{
test(Base()); //用一个匿名的Base对象去调用test函数
}


而
Base b;
Base c;
不是临时的对象，它们要到生命期结束才会析构
------解决方案--------------------
临时匿名对象的生存期被定在一句语句的结束。也就是到了下一行语句之前，临时匿名对象被销毁。关于这个生存期的问题标准委员会有过长时间的争论，最终确定这个方案。理由差不多是：有一个方案比没有这个方案强。
临时匿名对象通常为了简化代码。比如有个类X，包含一个成员函数f()，执行一个操作。你可以这么写：
X x_(100);
x_.f();
也可以这么写：
X(100).f();
------解决方案--------------------
总之，匿名对象一般常用在两个地方

1。new分配堆对象时
int *p= new int(5); //分配一个int匿名对象，用5初始化之

2。函数调用或返回时
A* test()
{
return new A(); //建一个匿名对象，并返回指向它的指针
}

或

void test(const Base& bs)
{
}
void main()
{
test(Base()); //用一个匿名的Base对象去调用test函数
}
------解决方案--------------------
还有一个东西叫“拷贝构造函数”
------解决方案--------------------
有些东西叫“优化”。你唯一需要记住的是各种构造函数的总调用次数必须和析构函数的调用参数相同。
------解决方案--------------------
临时匿名对象的生存期被定在一句语句的结束。也就是到了下一行语句之前，临时匿名对象被销毁。关于这个生存期的问题标准委员会有过长时间的争论，最终确定这个方案。理由差不多是：有一个方案比没有这个方案强。
临时匿名对象通常为了简化代码。比如有个类X，包含一个成员函数f()，执行一个操作。你可以这么写：
X x_(100);
x_.f();
也可以这么写：
X(100).f();

------解决方案--------------------
不是很明白lz的意思。我的理解是这样的：test(const base b)的时候，是要调用拷贝构造函数，以你的传入的参数为对象构造了临时变量，在从test（）出来的时候自然要析构。你没有定义拷贝构造函数，系统是默认生成的，只是你没有打印出来。构造和析构一定是对应的。而构造是包括拷贝构造函数的。
------解决方案--------------------
写了个程序，应该可以看到析构，构造过程。
#include <iostream>
using namespace std;

class Base
{
public:
Base(const char& c)
{
s_ncount++;
cout < <s_ncount < <endl;
}

Base(const Base& b)
{
s_ncount++;
cout < <s_ncount < <endl;
}

~Base()
{
s_ncount --;
cout < <s_ncount < <endl;
}
protected:
char ch;

static int s_ncount;
};

int Base::s_ncount = 0;

void test(const Base b)
{
}

void main()
{