常见的临时变量的生成场景

 临时变量通常在函数参数传递发生类型转换以及函数返回值时被创建。比如下面这个例子： 

void uppercasify(const string& str) 
{} 

int main(int argc, char* argv[]) 
{ 
     char subtleBookPlug[] = "Effective C++"; 
     uppercasify(subtleBookPlug);  // 此处有类型转换 
     return 1; 
} 

 

函数uppercasify需要const string&类型的参数，而实参类型为char *，故编译器会尝试着进行类型转换。

此时一个string类型的临时变量将被创建，并用subtleBookPlug来初始化对象，最后将临时变量传给函数uppercasify。 【调用了类的单参数构造函数】
理解了这个例子，也就能较好的理解为什么 C/C++不允许为非const的引用类型创建临时变量了。比如下面这个例子： 

void uppercasify(string& str)  // 参数类型改为string & 
{} 

int main(int argc, char* argv[]) 
{ 
     char subtleBookPlug[] = "Effective C++"; 
     uppercasify(subtleBookPlug); 
     return 1; 
} 

        此时，如果创建了一个临时变量，那函数所修改的对象为临时变量，而不是用户所期待的subtleBookPlug了，从而容易引起误操作，故会编译出错。 

产生临时变量的三种情况：一：以By Value的方式传值；二：参数为const的类型。三：类型转换

一：以By Value的方式传值。 
        我们都知道，引用类型和指针类型传递的都是地址，可以直接对地址中存放的数据进行操作，而以传值的方式传递参数，就会在heap中重新分配一个临时区域，将实参中的数据拷贝到临时区域中，而你对这份数据进行的任何的操作都不会影响实参的内容，因为实参跟形参只是内容相同，分别在两块不同的内存中。而引用和指针操作的是同一块内存，所以形参修改后，实参也修改了。 
二：参数为const的类型。 
        因为常量是不能修改，在只需要实参中的数据，而不需对实参进行修改时，或是禁止对实参进行修改时，把形参定义为const类型，系统会产生一个临时变量，就能起到保护数据的作用，如在函数strlen中，修改参数的值行吗？本来只是想得到实参的长度，结果在函数中被修改了，那得到得实参长度还是真实的吗。 
        如果你程序中的数据到处都可以被修改，那是多么的可怕（所以我们讨厌全局变量），所以const还是有它存在的价值。 
三：类型转换的时候会产生临时变量。 
        真是糟糕啊，在用类型转换带来便利的同时，产生临时变量就是我们承担的损失。 
        如将一个short类型转换成int类型，他们占用的内存不一样，如果不产生临时变量，那不就short类型和int类型占用的字节数不就一样了吗，sizeof不就坑爹了吗；

  

     C++语言禁止为非常量引用产生临时对象。同时证明引用类型传参不会产生临时变量，如char[]转换成string会报错，他们都是引用类型。

 

        临时变量不能作为非const引用参数，不是因为他是常量，而是因为c++编译器的一个关于语义的限制。如果一个参数是以非const引用传入，c++编译器就有理由认为程序员会在函数中修改这个值，并且这个被修改的引用在函数返回后要发挥作用。但如果你把一个临时变量当作非const引用参数传进来，由于临时变量的特殊性，程序员并不能操作临时变量，而且临时变量随时可能被释放掉，所以，一般说来，修改一个临时变量是毫无意义的，据此，c++编译器加入了临时变量不能作为非const引用的这个语义限制，意在限制这个非常规用法的潜在错误。

 

 

参考：

https://blog.csdn.net/wxn704414736/article/details/79972570

 

ps：

1、函数返回临时变量被编译器优化

class A
{
public:
    A(): m_b(new B()) { std::cout << "A Constructor" << std::endl; }

    A(const A& a) :
        m_b(new B(*(a.m_b)))
    {
        std::cout << "A Copy Constructor, new something" << std::endl;
    }

    A& operator =(const A& a)
    {
        std::cout << "A Assign Constructor, new anything" << std::endl;
        if(!m_b){
            delete m_b;
            m_b = nullptr;
        }
        m_b = new B(*(a.m_b));
        return *this;
    }

    A(A&& a) noexcept :
        m_b(a.m_b)
    {
        a.m_b = nullptr;
        std::cout << "A Move Copy Constructor, don't new anything" << std::endl;
    }

    A& operator = (A&& a)
    {
        std::cout << "A Move Assign Constructor, don't new anything" << std::endl;
        if(!m_b){
            delete m_b;
            m_b = nullptr;
        }
        m_b = a.m_b;
        a.m_b = nullptr;
        return *this;
    }

    ~A() { delete m_b; std::cout << "A Destructor" << std::endl;}

private:
    B* m_b = nullptr;
};

static A getA()
{
    return A();
}

int main()
{
    A b = getA();

    return 0;
}

A b = getA();//将一个临时变量初始化一个对象，本来会调用移动构造函数，但是实际打印【QtCreator】没有进行第二次构造，所以认为被编译器优化了。【这个地方想了很久没想通，参考：https://www.cnblogs.com/muxue/archive/2009/12/02/1615711.html】