C++11新特性（一）：语言特性

2024-08-24 10:27 由 LemHou 发表于 #后端开发

C++11新特性

总结C++11特性时发现整个内容较多，建议查看前先查看目录。

语言特性

右值引用

右值的分类为将亡值和字面量。将亡值就是将要销毁的对象以及临时的变量，字面量就是常量。左值就是变量。
右值引用，通常使用&&表示。

// 字面量
int a = 1; // a变量，左值；b变量，右值
int Func(int a, int b){
    return a + b;
}
int res = Func(1, 2); // 此时Func(1, 2)返回的就是一个临时变量，即是右值。res变量是一个左值，\
延长了Func(1, 2)右值的生命周期。
int& b = a; // 左值引用
int&& c = a; // 右值引用

移动语义

移动语义指的是将一个对象的资源所有权转发给另一个对象。常用于类的移动构造函数和移动赋值运算符。
只要类中有任何构造函数，就不会生成默认构造函数

int a = 1;
int res = Func(1, 2);
int&& b = move(a); // move用来实现左值到右值转变 
int&& c = move(a); // std::move


class MyClass{
public:
    MyClass() = default; // 默认构造函数
    MyClass(MyClass& obj){ // 拷贝构造函数
        cout << "left value" << endl;
    }
    MyClass(MyClass&& obj){ // 移动构造函数
        cout << "right value" << endl;
    }
    ~MyClass(){}
};
int main()
{
    MyClass a;
    MyClass b(a); // left value
    MyClass&& xs = move(a); // 右值
    MyClass c(xs); // left value，此时为输出left value的原因是因为本身右值引用也是一个变量，\
    所以在调用构造函数时，会调用拷贝构造函数
    MyClass d(move(xs)); // 使用move直接转变为右值才会调用移动构造函数
}

通常拷贝构造函数实现的是对象的浅拷贝，浅拷贝指的是将两个对象的指针指向同一块资源。深拷贝指的是直接复制一份资源给新的对象。

浅拷贝的缺点是当旧对象析构时，会将资源一起释放掉，而新对象指针此时还指向被释放掉的资源，那么新对象进行释放的时候，就会发生double free这种重复释放问题。

移动语义的好处是，既不用像深拷贝一样复制一份资源而是将新对象指针指向旧对象指向的资源，然后将旧指针置为空即可。

移动语义实现：

class MyClass{
private:
    int* data
public:
    MyClass() = default; // 默认构造函数
#if 0
    MyClass(MyClass& obj){ // 拷贝构造函数，浅拷贝
        cout << "left value" << endl;
        data = obj.data; // 只复制指针的值
    }
#else
    MyClass(MyClass& obj){ // 拷贝构造函数，深拷贝
        cout << "left value" << endl;
        data = new int(*obj.data); // 分配内存、赋值为就对象的资源并返回一个指针给data
    }
#endif
    MyClass(MyClass&& obj){ // 移动构造函数，移动语义实现
        this.data = obj.data;
        obj.data = nullptr;
    }
    ~MyClass(){}
};

转发引用

转发引用的实现由T&&或者auto&&实现，T是一个模板参数。这能够用于实现完美转发，即传递参数的同时还能保证其值的类型（左值就是左值，暂时对象、变量传递作为右值）。如下代码，如果我们直接将右值传到构造函数中，那么构造函数会认为此右值变量是一个左值，从而调用拷贝构造函数，并不会调用移动构造函数。

class MyClass{
public:
    MyClass() = default; // 默认构造函数
    MyClass(MyClass& obj){ // 拷贝构造函数
        cout << "left value" << endl;
    }
    MyClass(MyClass&& obj){ // 移动构造函数
        cout << "right value" << endl;
    }
    ~MyClass(){}
};
int main()
{
    MyClass a;
    MyClass b(a); // left value
    MyClass&& xs = move(a); // 右值
    MyClass c(xs); // left value，此时为输出left value的原因是因为本身右值引用也是一个变量，\
    所以在调用构造函数时，会调用拷贝构造函数
    MyClass d(move(xs)); // 此时必须使用move直接转变为右值才能调用移动构造函数
}

当我们引入T&&就可以解决这个问题，此时会直接根据参数的类型自动推导类型。

T& &-->T&
T& &&-->T&
T&& &-->T&
T&& &&-->T&&

int a = 0; // int ： 左值
auto&& b = a; // int& : 左值
auto&& c = 0; // int&& ：右值

接下来我们可以借用T&&和auto&&来实现完美转发。注意完美转发解决的问题是参数传递时类型会发生转换的问题。

template<typename T>
void Func(T&){
    cout << "left value" << endl;
}

template<typename T>
void Func(T&&){
    cout << "right value" << endl;
}
int a = 0;
auto&& b = a;
auto&& c = 0;
Func(1); // 1 call Func(int&&)
Func(a); // a call Func(int&)
Func(c); // c vall Func(int&), 右值引用直接作为传递会发生退化，退化为左值，因为右值本身就是一个变量
Func(move(a)); // call Func(int&&)



// 完美转发：使用std::forward<T>(arg)实现
template<typename T>
void makeResource(T&& arg) {
  Func(forward<T>(arg));
}
makeResource<int>(c); // 此时传递右值引用到参数，forward就会保证参数的类型不变进行传递，从而调用Func(T&&)

可变参数模板

...语义创建一个参数包或者扩展参数包，模板参数包接受0或多个模板参数。有至少一个参数包的模板叫做可变参数模板。

template<typename... T>
void Func(){
    cout << "nihao";
}

#include <numeric>
template<typename T1, typename... Args>
auto Sum(T1 first, Args... args) -> decltype(first)
{
    auto values = {first, args...}; // ...扩展参数包
    return accumulate(values.begin(), values.end(), first);
}
cout << Sum(1, 22, 33, 66) << endl;

列表初始化

列表初始化，就是使用花括号进行初始化。{1, 2, 3}会创建一个整数序列，有着类型initial_list<int>
cpp std::vector<int> nums{1, 2, 3, 4, 5}; // 列表初始化 for (auto it : nums){ cout << it << endl; }

静态断言

编译时断言机制，允许在编译时检查某个条件是否为真。静态编译检查编译时的常量表达式。经常与类型特征type traits一起使用。因为静态断言是在编译时进行检验，所以可以用于不同编译平台进行运行前检验。

static_assert(<constant-expressions>, <error-message>);
static_assert(sizeof(int) >= 4, "Not support 32 bits integer");
template <typename T>
void CheckInt(T* co, size_t size)
{
    static_assert(std::is_integral<T>::value, "Not support 32 bits integer.");
}

类型推导

auto类型推导的使用，必须前面有可以隐式说明类型的语句。
cpp std::vector<int> nums; for (auto it : nums){ cout << it << endl; }

lambda表达式

形如[capture list](parameter){/* code */}，默认捕获到的值编译器会为其加const修饰符，内部无法修改，但是捕获到的引用可以修改。

[] // 什么都不捕获
[=] // 捕获局部对象值
[&] // 捕获局部对象的引用
[this] // 捕获this的引用
[a, &b] // 捕获a的值，捕获b的引用
auto g = [](int a, int b){ return a + b;};

`decltype`类型声明

decltype操作符将会返回传递给它的表达式得到的类型。

int a = 0;
decltype(a++) b;
// 以下函数定义方式是错误的，因为decltye无法推导函数返回类型，这是因为在函数外部，a和b是未定义
decltype(a + b) Func(int a, int b){
    return a + b;
}

// c++14后支持
auto Func(int a, int b) -> decltype(a + b){
    return a + b;
}
template<typename T>
auto void(T a, T b) -> decltype(T){ // auto推导函数返回值，最好指定返回类型
    return a + b;
}

类型别名

C++中using也可以声明别名，相较于typedef更易读。

template <typename T, typename T>
using u_map = std::map<T, T>;