下面代码是为了反应默认构造函数，复制构造函数，析构函数的调用情况
问：  Exmpl val3=Exmpl();//c++primer   p407   先用默认构造函数构造一个临时对象，再用复制函数。对啊，既然是临时对象，那是不是还要调用析构函数？
可由截图知 他只用了默认构造。。。？

#include <iostream>
#include<string>
#include <vector>
#include"Exmpl.h"
using namespace std;
void fun1(Exmpl a)
{}
void fun2(Exmpl &b)
{}
Exmpl fun3()
{
        Exmpl obj;
        return obj;//复制函数
}
int main(){
    cout<<"        Exmpl val1;//用默认构造函数"<<endl;
    Exmpl val1;//用默认构造函数
    cout<<"        Exmpl val3=Exmpl();//默认构造函数，复制"<<endl;
    Exmpl val3=Exmpl();//c++primer   p407    默认构造函数构造了一个临时对象，然后复制构造函数用该对象初始化        默认构造，复制构造
    cout<<"            Exmpl val2=val1;//复制函数"<<endl;
    Exmpl val2=val1;//复制函数
    cout<<"        fun1(val1);//复制函数  void fun1(Exmpl a)"<<endl;
    fun1(val1);//复制函数
    cout<<"        fun2(val1);//无需复制    void fun2(Exmpl &b)"<<endl;
    fun2(val1);//无需复制
    cout<<"        val1.input(cin);"<<endl;
    val1.input(cin);
    cout<<"        val2=val1;"<<endl;
    val2=val1;
    cout<<"        fun3();    Exmpl fun3() Exmpl obj; return obj;//复制函数}"<<endl;
    fun3();
    cout<<"        Exmpl *p=new Exmpl;//默认构造函数创造动态的。。。"<<endl;
    Exmpl *p=new Exmpl;//默认构造函数创造动态的。。。
    cout<<"        vector<Exmpl> vec(3);//默认构造函数创建一个临时对象，在复制构造函数复制到vector的各个元素然后析构函数删除临时对象   "<<endl;
    vector<Exmpl> vec(3);//默认构造函数创建一个临时对象，在复制构造函数复制到vector的各个元素然后析构函数删除临时对象    
    cout<<"        delete p;"<<endl;
    delete p;
    cout<<"        return 0;"<<endl;
    return 0;
}

struct Exmpl{
    //默认 构造函数
    Exmpl():ival(0)
    { 
        std::cout<<"Exmpl"<<std::endl;

    }
    //复制构造函数
    Exmpl(const Exmpl& E):ival(E.ival),sval(E.sval)
    {
    std::cout<<"Exmpl（const Exmpl&）"<<std::endl;
     }
    //输入的构造
    std::istream & input(std::istream& in)
    {
        std::cout<<"input   "<<"enter int and string"<<std::endl;
        in>>ival>>sval;
        return in;
    }
    //赋值操作符
    Exmpl& operator =(const Exmpl &eq)
    {
        std::cout<<"operator ="<<std::endl;
        ival=eq.ival;
        sval=eq.sval;
        return *this;
    }
    //析构函数
    ~Exmpl()
    {
        std::cout<<"~Exmpl()"<<std::endl;
    }

    int ival;
    std::string sval;
};

  谢谢

按引用传递 按地址传递都不是不调用的 当一个对象去初始化另一个对象是要用的 貌似是这样

#include <iostream>
#include <string>
using namespace std;

class X {
public:
    X(const string& name)
    {
        this->name = name;
        cout << "Constructor of " << "'" << name << "'" << endl;
    }
    X(const X& x)
    {
        name = x.name + " (copy)";
        cout << "Copy constructor of " << "'" << name << "'" << endl;
    }
    X& operator=(const X& x)
    {
        name = x.name + " (assign)";
        cout << "Assign operator of " << "'" << name << "'" << endl;
        return *this;
    }
    ~X()
    {
        cout << "Destructor of " << "'" << name << "'" << endl;
    }
private:
    string name;
};

void f()
{
    X x1("x1");            // Constructor
    X x2(x1);              // Copy constructor
    X x3 = x1;             // Copy constructor
    x3 = x1;               // Assign operator
    X x4 = X("temporary"); // 这里被优化掉了，其实变成了：X x4("temporary"); 临时对象并不创建
    X("temporary2");       // 显示调用
    /*
     * ~temporary2();
     * ~x4();
     * ~x3();
     * ~x2();
     * ~x1();
     */
}

int main(void)
{
    f();
    cin.get();
    return 0;
}

看看编译器是什么版本吧，以前的版本可能会创建那个临时对象，但是现在的编译器都比较智能了。

[ 本帖最后由 lz1091914999 于 2012-8-23 21:21 编辑 ]

现在的编译器进步了好多了。在声明对象的同时赋初值其实就是在构造，临时变量不是必须的。

学习……

那个虽然是临时对象，但还是放在栈里面的，所以会在其生命周期结束时调用析构函数，也就是是在函数结束的时候。

复制和析构在输出的结果上没体现。。。还是楼上说的优化了吧

谢谢各位