【C++篇】C++11新特性总结1

struct point
{
   int x;
   int y;
};

class Date
{
public:
   Date(int year = 1, int month = 1, int day = 1)
       :_year(year)
       , _month(month)
       , _day(day)
   {
       cout << "Date(int year int month , int day)" << endl;
   }

   Date(const Date& d)
       :_year(d._year)
       ,_month(d._month)
       ,_day(d._day)
   {
       cout << "Date(const Date& d)" << endl;
   }
private:
   int _year;
   int _month;
   int _day;
};

C++11后想统一初始化的方式，试图一切对象皆可使用{}初始化，{}初始化也叫列表初始化。
内置类型支持，自定义类型也支持，自定义类型本质是类型转换，中间会产生临时对象，经过编译器优化后变成直接构造。

//C++11

//内置类型支持{}初始化
int x = { 2 };

//自定义类型
//本质是{2025，1，1}构造出临时对象，再拷贝给d1，但是编译器优化为直接用{2025，1，1}构造d1
Date d1 = { 2025,1,1 };

//这里的d2引用的是{2024，7，2}的临时对象
const Date& d2 = { 2024,7,2 };

//需要注意的是C++98支持单参数时类型转换，也可以不用加{}
Date d3 = { 2025 };
Date d4 = 2025;

{}初始化可以省略=

   //可以省略掉=
   int x2{ 2 };
   point p1{ 1,2 };
   Date d6{ 2025,1,2 };
   const Date& d7{ 2024,8,15 };

C++11的列表初始化在许多场景下会带来不少的便利，如容器push/insert多参数构造的对象时，用{}会很方便。

vector<Date> v;
//有名对象传参
v.push_back(d6);

//匿名对象传参
v.push_back(Date(2025, 1, 2));

//比起有名对象和匿名对象，{}初始化更有性价比
v.push_back({ 2025,1,2 });

2.3，C++11中的std::initializer_list

上面的初始化已经很方便，但是对于一个容器的初始化来说，还是不太方便。比如一个vector对象，我们想用N个值去初始化，那么我们需要实现多个构造函数才能支持:vector<int> v1={1,2,3}，vector<int> v2={1,2,3,4}，vector<int> v3={1,2,3,4,5};
C++11库中提供了一个std::initializer_list ，这个类的本质是底层开一个数组，将数据拷贝过来，std::initializer_list 中有两个指针分别指向数组的开始和结束。
这时只要我们的容器支持一个std::initializer_list的构造函数，就可以支持多个值的{x1,x2,x3......}的初始化。STL中的容器支持多个值构成的{x1,x2,x3,......}的初始化，就是通过底层支持std::initiaalizer_list的构造实现的。如下图list和vector的构造函数中都增添了支持std::initializer_list的构造函数。

vector<int> v1 = { 1,2,3,4,5 };
vector<int> v2 = { 1,2,3,4,5,6 };

//这里pair对象的{}初始化和map的initializer_list构造结合到一起了
map<string, string> dict = { {"sort","排序 "},{"string","字符串"} };

3，右值引用和移动语义

C++98中就有引用的语法，而C++11中新增了右值引用的语法特性，之前的引用叫做左值引用。无论左值引用还是右值引用，都可以理解为是在给变量取别名。

3.1，左值和右值

左值是一个表示数据的表达式（如变量名或解引用的指针），一般是持久状态，存储在内存中，我们可以获取它的地址。左值可以出现在赋值符号的左边，也可以是在右边。如果左值用const修饰，就不能给它赋值，但可以取它的地址。
右值也是一个表示数据的表达式，要么是常量或者是临时对象等，右值可以出现在赋值符号的右边，但不能出现在左边，右值不能取地址。
左值的英文简写为lvalue，右值的英文简写为rvalue。传统认为它们分别是left value、right value 的缩写。现代C++中，lvalue被解释为loactor value的缩写，可意为存储在内存中、有明确存储地址可以取地址的对象，而rvalue被解释为read value，指的是那些可以提供数据值，但是不可以寻址，例如：临时变量，常量，存储于寄存器中的变量等，也就是说左值和右值的核心区别就是能否取地址。

//左值，可以取地址
//以下均为左值
int* p = new int(0);
int b = 1;
const int c = b;
*p = 10;
string s("1111111");
s[0] = 'x';

double x = 1.1, y = 2.2;
//右值，不能取地址
//以下几个均为右值
10;
x + y;
string("111111");

3.2，左值引用和右值引用

Type& r1=x，Type&& r2=y。其中第一个语句就是左值引用，本质是给左值取别名。同理第二个语句就是给右值引用，本质是给右值取别名。
左值引用不能直接引用右值，需加上const修饰。

//左值，可以取地址
//以下均为左值
int* p = new int(0);
int b = 1;
const int c = b;
*p = 10;
string s("1111111");
s[0] = 'x';

double x = 1.1, y = 2.2;

//右值，不能取地址
//以下几个均为右值
10;
x + y;
string("111111");

//左值引用，给左值取别名
int& r1 = b;
int*& r2 = p;
int& r3 = *p;
string& r4 = s;
char& r5 = s[0];

//左值引用不能直接引用右值，需加上cosnt
const int& rx1 = 10;
const double& rx2 = x + y;
const string& rx3 = string("111111");

右值引用不能直接引用左值，但可以引用move(左值）。

//左值，可以取地址
//以下均为左值
int* p = new int(0);
int b = 1;
const int c = b;
*p = 10;
string s("1111111");
s[0] = 'x';

double x = 1.1, y = 2.2;

//右值，不能取地址
//以下几个均为右值
10;
x + y;
string("111111");

//右值引用
int&& rr1 = 10;
double&& rr2 = x + y;
string&& rr3 = string("111111");

//右值引用不能直接引用左值，但可以引用 move(左值)
int&& rrx1 = move(b);
int*&& rrx2 = move(p);
int&& rrx3 = move(*p);
string&& rrx4 = (move)(s);
string&& rrx5 = (string&&)s;

move是库里面的一个函数模板，本质内部做了强制类型转换，涉及到一些引用折叠的知识

需要注意的是，变量表达式都是左值属性，也就意味着一个右值被右值引用绑定后，右值引用变量是一个左值。

//右值引用
int&& rr1 = 10;
double&& rr2 = x + y;
string&& rr3 = string("111111");

//这里要注意的是，rr1的属性是左值，要想被右值引用绑定，除非move一下
int&& a = move(rr1);

3.3，引用延长生命周期

右值引用可用于为临时对象延长生命周期，const的左值引用也能延长临时对象生存期，但这些对象无法被修改。

string s1 = "Test";
//s1+s1生成临时对象
const string& s2 = s1 + s1; //const左值引用延长生命周期
string&& s3 = s1 + s1; //右值引用延长生命周期

s3 += "Test";
cout << s3 <<endl;

3.4，左值和右值的参数匹配

C++98中，在函数的形参部分，我们会用const 修饰左值引用的方式，这样实参在传递左值和右值时都可以匹配。
C++11后，分别重载左值引用，const左值引用和右值引用作为形参的f函数，那么实参时左值，会调用f(左值引用），实参是const 左值引用时，会调用f(const 左值引用），实参是右值引用时，会调用f(右值引用）。

void f(int& x)
{
   cout << "f(int& x)" << endl;
}

void f(const int& x)
{
   cout << "f(const int& x)" << endl;
}

void f(int&& x)
{
   cout << "f(int&& x)" << endl;
}

int main()
{

        int x = 1;
        const int y = x;

        f(x);//调用f(int& x)
        f(y);//调用f(const int& x)
        f(3);//调用f(int&& x)
        f(move(x));//调用f(int&& x)

        //右值引用变量是左值属性的
        int&& z = 1;
        f(z); //调用f(int& x)
        f(move(z));//调用f(int&& x)

return 0;

}

3.5，移动语义

移动语义是现代编程语言（如C++11及更高版本、Rust）中用于优化资源管理的重要机制。其核心目标是避免不必要的拷贝，通过转移资源所有权（而非复制）提升程序性能，尤其在处理动态内存、文件句柄等资源时效果显著。

为什么需要移动语义？

传统拷贝的缺陷：

对于包含动态内存或系统资源的对象（如std::vector,std::string等），拷贝构造函数会深度复制所有数据，导致性能开销。

移动语义的优化：

直接窃取临时对象（如右值）的资源，避免复制。

移动构造函数与移动赋值运算符

移动构造函数：接受右值引用参数，转移资源。

class MyClass {
public:
    // 移动构造函数
    MyClass(MyClass&& other) noexcept 
        : data_(other.data_) 
        ,size_(other.size_) 
    {
        other.data_ = nullptr; // 置空原对象，避免重复释放
        other.size_ = 0;
    }
private:
    int* data_;
    size_t size_;
};

移动赋值运算符：类似移动构造，处理对象赋值。

MyClass& operator=(MyClass&& other) noexcept {
    if (this != &other) 
    {
        delete[] data_;       // 释放当前资源
        data_ = other.data_;  // 转移资源
        size_ = other.size_;
        other.data_ = nullptr;
        other.size_ = 0;
    }
    return *this;
}

使用场景

1，显示触发移动语义

使用std:move将左值转化为右值：

std::vector<int> a = {1, 2, 3};
std::vector<int> b = std::move(a); // a变为空，资源转移给b

注意：被移动后的对象处于有效但未定义状态（通常为空），不可再使用其值。

2，返回值优化

编译器自动优化函数返回的临时对象，避免拷贝：

std::vector<int> createVector() {
    std::vector<int> v = {1, 2, 3};
    return v; // 编译器可能直接构造v到调用方，无需移动或拷贝
}

3，STL容器的移动支持

标准库容器（如std::vector、std::string）已实现移动语义：

std::vector<std::string> vec;
std::string s = "data";
vec.push_back(std::move(s)); // 移动s到容器，避免拷贝字符串内容

常见问题与缺陷

1，误用std:move

对局部变量过早移动，导致后续访问未定义

std::vector<int> a = {1, 2, 3};
std::vector<int> b = std::move(a);
std::cout << a.size(); // 未定义行为，a可能为空

2，未实现移动语义的类

若类未定义移动操作，编译器可能回退到拷贝（即使使用std::move）。
规则：若用户定义了拷贝构造函数、拷贝赋值或析构函数，编译器不会自动生成移动操作。

3，异常安全

移动操作应标记为noexcept，否则某些容器（如std::vector）可能仍选择拷贝。

代码示例：自定义类的移动语义

#include <iostream>
#include <utility> // for std::move

class Buffer {
public:
    Buffer(size_t size) : size_(size), data_(new int[size]) {}
    
    // 移动构造函数
    Buffer(Buffer&& other) noexcept 
        : size_(other.size_), data_(other.data_) {
        other.size_ = 0;
        other.data_ = nullptr;
    }
    
    // 移动赋值运算符
    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {
            delete[] data_;
            data_ = other.data_;
            size_ = other.size_;
            other.data_ = nullptr;
            other.size_ = 0;
        }
        return *this;
    }
    
    ~Buffer() { delete[] data_; }

private:
    size_t size_;
    int* data_;
};

int main() {
    Buffer a(100);
    Buffer b = std::move(a); // 调用移动构造函数
    Buffer c(200);
    c = std::move(b);        // 调用移动赋值运算符
    return 0;
}

3.6，右值引用和移动语义在传参中的提效

C++11以后，STL容器的push和insert接口增加了右值引用版本。

以vector容器的push_back为例：

当实参是一个左值时，继续调用拷贝构造进行拷贝；当实参是一个右值时，容器内部调用移动构造，提高效率。

3.7，引用折叠

C++中不能直接定义引用的引用，如int& && r1=i；这样写会直接报错，通过模板或typedef的类型操作可以构成引用的引用。
通过模板或typedef中的类型操作构成引用的引用时，这时C++11给出了一个引用折叠的规则：右值引用的右值引用折叠成右值引用，所有其他组合均折叠成左值引用。

int main()
{
   typedef int& lref;
   typedef int&& rref;
   int n = 0;

   lref& r1 = n; //r1的类型是int&
   lref&& r2 = n; //r2的类型是int&
   rref& r3 = n; //r3的类型是int&
   rref&& r4 = 3; //r4的类型是int&&

   return 0;
}

Function(T&& t)函数模板程序中，假设实参是int右值，模板参数T推导出是int；实参是int左值，模板参数T推导出是int&，再结合引用折叠规则，就实现了实参是左值，实例化出左值引用版本形参的 Function，实参是右值，实例化出右值引用版本形参的Function。

//根据引用折叠规则，f1实例化后总是一个左值引用
template <class T>
void f1(T& x)
{}

//根据引用折叠规则，f2实例化后可以是一个左值引用，也可以是一个右值引用
template <class T>
void f2(T&& x)
{}

int main()
{

   //折叠->实例化为 f1(int& x)
   f1<int>(n);
   //f1(0)； //报错

   //折叠->实例化为 f1(int& x)
   f1<int&>(n);
   //f1<int&>(0)； //报错

   //折叠->实例化为 f1(int& x)
   f1<int&&>(n);
   //f1<int&&>(0); //报错

   //折叠->实例化为 f1(const int& x)
   f1<const int&>(n);
   f1<const int&>(0);

   //折叠->实例化为 f1(const int& x)
   f1<const int&&>(n);
   f1<const int&&>(0);

   //没有折叠->实例化为 f2(int&& x)
   //f2<int>(n); //报错
   f2<int>(0);

   //折叠->实例化为 f2(int& x)
   f2<int&>(n);
   //f2<int&>(0); //报错

   //折叠->实例化为 f2(int&& x)
   //f2<int&&>(n); //报错
   f2<int&&>(0);

   return 0;
}

像f2这样的函数模板中，（T&& x）参数看起来是右值引用参数，但是由于引用折叠的规则，他传递左值时就是左值引用，传递右值时就是右值引用，有些地方也把这种函数模板的参数叫做万能引用。

3.8，完美转发

Function(T&& t)函数模板程序中，传左值实例化以后就是左值引用的Function函数，传右值实例化以后就是右值引用的Function函数。
但是我们在前面讲过，一个变量表达式都是左值属性，也就是一个右值被右值引用表达式绑定以后，右值引用变量表达式是左值属性的。也就是说Function函数中的 t 是左值属性的。如果Function函数中调用一个func函数，那么我们把t传给下一层函数func，那么匹配的都是左值引用的func函数。这里想要保持t对象的原属性，就需要使用完美转发实现。

std::forward：用于在转发参数时保持其原始的类别 。
完美转发forwrad本质是一个函数模板，它主要还是通过引用折叠的方式实现。

void func(int& x)
{
   cout << "左值引用" << endl;
}

void func(const int& x)
{
   cout << "const 左值引用" << endl;
}

void func(int&& x)
{
   cout << "右值引用" << endl;
}

void func(const int&& x)
{
   cout << "const 右值引用" << endl;
}

template <class T>
void Function(T&& t)
{
   func(t);
}

int main()
{
   Function(10); //10是右值 Function(int&& t) 右值

   int a;、
   Function(a); //a是左值 Function(int& t) 左值

   Function(move(a)); // Function(int&& t) 右值

   const int b = 8;

   Function(b); //Function(const int& t) const左值
   Function(move(b)); //Function(const int&& t) const 右值

   return 0;
}

上面的代码是没有使用完美转发的场景，运行结果如下：

可以看出，在将t传给下一层的func函数时，匹配的都是左值引用。

经过完美转发后的代码和运行结果：

template <class T>
void Function(T&& t)
{
//func(t);
func(forward<T>(t));
}