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

ops/2025/2/9 4:29:54/

目录

 

1，C++11的发展历史

2，列表初始化

2.1C++98传统的{}

2.2，C++11中的{}

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

3，右值引用和移动语义 

3.1，左值和右值

3.2，左值引用和右值引用

 3.3，引用延长生命周期

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

 3.5，移动语义

为什么需要移动语义？

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

使用场景

常见问题与缺陷

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

 

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

3.7，引用折叠

3.8，完美转发 

 

1，C++11的发展历史

C++11是C++的第二个主要版本，并且是从C++98起的最重要更新。C++11是C++编程语言的一个重要版本，于2011年正式发布。它引入了许多新特性和改进，极大地增强了 C++ 的功能和易用性。下面介绍它的一些主要特性：

2，列表初始化

2.1C++98传统的{}

在C++98中一般数组和结构体支持使用{}初始化。

struct point
{
    int x;
    int y;
};
int main()
{
    int arr1[5] = {1,2,3,4,5};
    point p = { 1,2 };
    return 0;
}

2.2，C++11中的{}

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，左值和右值

  1. 左值是一个表示数据的表达式（如变量名或解引用 的指针），一般是持久状态，存储在内存中，我们可以获取它的地址。左值可以出现在赋值符号的左边，也可以是在右边。如果左值用const修饰，就不能给它赋值，但可以取它的地址。
  2. 右值也是一个表示数据的表达式，要么是常量或者是临时对象等，右值可以出现在赋值符号的右边，但不能出现在左边，右值不能取地址。
  3. 左值的英文简写为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::moveclass 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));
}

 

 


http://www.ppmy.cn/ops/156888.html

相关文章

PyTorch torch.unbind、torch.split 和 torch.chunk函数介绍

PyTorch torch.unbind、torch.split 和 torch.chunk函数介绍

pytorch中 torch.unbind、torch.split 和 torch.chunk等函数可用于张量的拆分操作。 1. torch.unbind 功能说明&#xff1a; torch.unbind 沿指定的维度将张量“解包”为多个张量&#xff0c;返回一个元组。解包后被操作的那个维度会消失&#xff0c;每个输出张量的维度数会比…
阅读更多...
VUE之插槽

VUE之插槽

1、默认插槽 <template><div class"father"></div><h3>父组件</h3><div class"content"><Category title"热门游戏列表"><ul><li v-for"g in games" :key"g.id">{{…
阅读更多...
基于ArcGIS的SWAT模型+CENTURY模型模拟流域生态系统水-碳-氮耦合过程研究

基于ArcGIS的SWAT模型+CENTURY模型模拟流域生态系统水-碳-氮耦合过程研究

流域是一个相对独立的自然地理单元&#xff0c;它是以水系为纽带&#xff0c;将系统内各自然地理要素连结成一个不可分割的整体。碳和氮是陆地生态系统中最重要的两种化学元素&#xff0c;而在流域系统内&#xff0c;水-碳-氮是相互联动、不可分割的耦合体。随着流域内人类活动…
阅读更多...
使用 Docker 部署 RabbitMQ 的详细指南

使用 Docker 部署 RabbitMQ 的详细指南

使用 Docker 部署 RabbitMQ 的详细指南 在现代应用程序开发中&#xff0c;消息队列系统是不可或缺的一部分。RabbitMQ 是一个流行的开源消息代理软件&#xff0c;它实现了高级消息队列协议&#xff08;AMQP&#xff09;。本文将详细介绍如何使用 Docker 部署 RabbitMQ&#xf…
阅读更多...
基于微信小程序的校园水电费管理平台设计与实现

基于微信小程序的校园水电费管理平台设计与实现

目录 摘要 系统展示 技术介绍 MySQL数据库 Vue框架 代码实现 管理员实现登录后端代码 连接数据库 前端代码实现 获取源码 摘要 随着社会的发展&#xff0c;社会的方方面面都在利用信息化时代的优势。互联网的优势和普及使得各种系统的开发成为必需。 本文以实际运用…
阅读更多...
快速上手——.net封装使用DeekSeek-V3 模型

快速上手——.net封装使用DeekSeek-V3 模型

📢欢迎点赞 ：👍 收藏 ⭐留言 📝 如有错误敬请指正，赐人玫瑰，手留余香！📢本文作者：由webmote 原创📢作者格言：新的征程，用爱发电，去丈量人心，是否能达到人机合一？开工大吉 新的一年就这么水灵灵的开始了，在这里，祝各位读者新春快乐，万事如意！ 新年伊…
阅读更多...
vulkan学习（一）

vulkan学习（一）

opengl相对与vulkan不是一个级别的东西&#xff0c;opengl几十行代码就可以绘制一个简单的物体&#xff0c;而vulkan需要几百行才能绘制&#xff0c;所以vulkan的学习曲线比较陡峭&#xff0c;本人经过也经过一个很长的时间的断断续续学习对vulkan有了一些认识&#xff0c;在这…
阅读更多...
C++中的pair，pair和map的结合

C++中的pair，pair和map的结合

文章目录 1. pair 的基本用法语法&#xff1a;示例&#xff1a; 2. pair 和 map 的结合map 的基本用法语法&#xff1a;示例&#xff1a; 3. pair 和 map 中的具体应用(1) map 中的 pair 存储(2) insert 方法插入 pair(3) 使用 auto 获取 pair 对象(4) 使用 pair 和 map 返回多…
阅读更多...
最新文章

Copyright @ 2022~2023