move语义和完美转发

 

move语义

值类别（value category）如下：

 

 

 

lvalue：左值，在内存中有地址，可被程序员访问，可以放在赋值运算符左侧，也可以放在赋值运算符右侧，常见的左值有普通变量、字符串字面值“hello”等

xvalue：是个左值，但是可以被当做右值使用，需要显式的std::move将其转换为右值；

prvalue：纯右值，无地址，不可被程序员访问到，比如常数42、true、nullptr、this指针、lambda表达式对象等都是纯右值。 

 

右值引用做形参的时候，在函数体内部被当做左值使用：

void func(Object&& obj)
{
    // 函数体内部obj被当作左值 

}

 

 

类的move构造函数的两段式写法：

CObject(CObject&& other)
{
    // 第一段
    this->a = std::move(other.a);
    this->b = std::move(other.b);
    this->ptr = std::move(other.ptr);    
    // 第二段
    other.ptr = nullptr;
}
 

 

类的move operator=函数的四段式写法：

CObject& operator=(CObject&& other)
{
    // 第一段
    if (this == $other)
    {
        return *this;
    }
    // 第二段
    delete this->ptr;
    // 第三段
    this->a = std::move(other.a);
    this->b = std::move(other.b);
    this->ptr = std::move(other.ptr);    
    // 第四段
    other.ptr = nullptr;
}
 

 

 

编译器的返回值优化（RVO）：当在栈上定义了变量并且该变量类型和返回值类型一致时，编译器会做返回值优化：

//////// case1  返回值优化RVO /////////////////////
// （1）obj在栈上申请，该类型和返回值类型一致
CObject foo()
{
    return CObject(); 
}

// （2）基于以上原因，只会调用一次构造函数
CObject object = foo();


//////// case2  具名返回值优化NRVO /////////////////////
// （1）obj在栈上申请，该类型和返回值类型一致
CObject foo()
{
    CObject obj;
    return obj;
}

// （2）基于以上原因，只会调用一次构造函数
CObject object = foo();

 

注意：
（1）同一个变量只能move一次

（2）类的右值引用类新构造函数（转移构造函数）和operator=（转移赋值运算符）依赖其实现，所以在使用的时候要了解其这两个构造函数的实现细节，以免引起误用。

（3）一个变量在被std::move之后就不应该再使用，除了重新被赋值或者被析构掉。

 

 

 

完美转发

完美转发必须存在推理（也就是必须是模版），只有如下一种存在形式，其他形式都是右值引用而不是完美转发

引用折叠规则

• 若一个右值引用（即带有&&）参数被一个左值或左值引用初始化，那么引用将折叠为左值引用。（即：T&& & –> T&）
• 若一个右值引用参数被一个右值初始化，那么引用将折叠为右值引用。（即：T&& && 变成 T&&）。
• 若一个左值引用参数被一个左值或右值初始化，那么引用不能折叠，仍为左值引用（即：T& & –>T&，T& && –>T&）。

template<class T>
void foo(T&& value) // 实参传入会引发引用折叠！
{
　　   // (0) 这里的value是个左值（具名的右值引用是左值），而实参可能是左值或右值，因此完美转发就是保留实参的实际类型。
　　  // （1）传入左值或左值引用时，折叠结果T为T&
     // （2）传入右值或右值引用时，折叠结果T为T&&
    bar(std::forward<T>(value));
}

 

 

demo

#include <iostream>

class CTest
{
public:
        CTest()
        {
                std::cout << "CTest::CTest" << std::endl;
        }

        ~CTest()
        {
                std::cout << "CTest::~CTest" << std::endl;
        }

        CTest(const CTest& t)
        {
                std::cout << "CTest::const CTest&" << std::endl;
        }
        CTest(CTest& t)
        {
                std::cout << "CTest::move CTest&" << std::endl;
        }

};

void funcImpl(const CTest& t)
{
        std::cout << "funcImpl left" << std::endl;
}
void funcImpl(CTest&& t)
{
        std::cout << "funcImpl right" << std::endl;
}


template <typename T>
void func(T&& t)
{
　　　　　　// 这里t为左值（一个具有的右值引用为左值）
        funcImpl(std::forward<T>(t)); /// 关键的地方！！！
}

int main()
{
        CTest t1;
        func(t1); // t1为左值，左值与T&&的折叠结果T为左值引用T&

        std::cout << std::endl << "---------------------------" << std::endl;
        CTest t2;
        func(std::move(t2)); // std::move(t2)为右值，右值与右值引用折叠为T&&

        return 0;
}

 

 输出

CTest::CTest
funcImpl left

---------------------------
CTest::CTest
funcImpl right
CTest::~CTest
CTest::~CTest

 

 函数变参模板右值引用

Args可以接受0或多个各种类型的参数，此时可以适配T的各种类型的构造函数。

智能指针MySharedPtr的构造函数只跟T的各种形式有关，与T本身的构造函数无关。

#ifndef __ALGO__
#define __ALGO__

#include "mysharedptr.h"

template <class T, class ... Args>
MySharedPtr<T> make_shared(Args&&... args)
{
    return MySharedPtr<T>(new T(std::forward<Args>(args)...));
} 

#endif

　　

 

 

 

 

noexcept

noexcept声明的函数表示函数不会发生异常情况，在某些容器中，如果容器元素对象的move拷贝构造和move构造被声明为noexcept的，那么编译器就会优先使用move版本的拷贝构造和move构造，这样会加快插入速度（默认使用非move版本）；

什么时候应该用noexcept？

（1）move拷贝构造

（2）move构造

（3）swap函数

（4）内存分配器的deallocate函数

 

关于C++异常在工程实践里的使用建议：

（1）尽量不使用C++异常，因为写出C++异常安全的代码是困难的

（2）小内存申请默认成功

（3）大内存申请结果判空

（4）标注库异常直接崩溃即可