【C++】——C++11新特性

前言

1.初始化列表

2.std::initializer_list

3.auto

前言

C++，这门在系统开发、游戏开发、嵌入式等众多领域都占据主导地位的编程语言，一直在不断进化。C++11就像是C++家族中的一颗璀璨明星，闪耀着无数令人惊叹的新特性。如果你还在使用传统的C++编码方式，那你可能正在错过许多现代编程的便捷与高效。想象一下，用更少的代码编写出性能更高的程序，轻松应对复杂的并发场景，还能享受更加简洁和安全的内存管理。C++11就能让这一切成为现实。在这篇博文中，我会一点点揭开C++11新特性的神秘面纱，让你看到C++在这次重大更新之后所蕴含的无限潜力。

1.初始化列表

在C++98标准中，允许使用花括号{ } 对数组或者结构体元素进行统一的列表初始化

例如：

cpp 复制代码

struct Point{
    int a;
    int b;
};

int main(){
    int arry[] = {1,2,3,4};//数组初始化
    Point p = {1,2};//结构体初始化
    return 0;
}

而C++11扩大了使用花括号{ } 进行初始化的使用范围，使其可以用于所有的内置类型和用户自定义的类型

cpp 复制代码

//对数组初始化
int arry1[]{1,2,3,4,5};
//对内置类型初始化
int x{9};
//对用户自定义类型初始化
Point p{9,9};
//对vector容器对象进行初始化
vector<int> vec = {1,2,3,4,5,6,7,8,9};

注意:

使用初始化列表时，可以添加等号 " = "，也可以不添加

2.std::initializer_list

initializer_list是什么？

看名字像一个容器，但我们学过的容器并没有这个，但并非没有见过

但C++11支持对各个容器进行初始化列表初始化，离不开它

std::initializer_list 是一个轻量级的模板类，用于在函数参数中传递初始化列表，从而使编译器能够正确解析和处理使用花括号 {} 进行初始化的对象。

我们在诸多容器的构造中，都可以看见它是身影

在vector构造中

在list构造中

std::initializer_list 是定义在 <initializer_list> 头文件中的一个模板类，用于表示一个初始化列表。

它的基本形式如下：

cpp 复制代码

std::initializer_list<T> init_list = { /* 初始化元素 */ };

std::initializer_list 提供了一种轻量级的、只读的视图来访问初始化列表中的元素。它常用于构造函数、函数参数以及返回类型，以支持统一初始化语法。

并不是所有的类型都会有std::initializer_list的构造函数，也并不是有std::initalizer_list才能使用花括号 { } 进行初始化

但只要你显式写了使用std::initializer_list的构造函数，则进行{ }初始化时，会优先调用该函数进行初始化

关于initializer_list的细节不过多赘述，知道有这个东西，和它的大致用途即可

3.auto

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto没有什么价值

C++11废弃auto的原本用法，将其用于实现自动类型推断，这一功能极大地简化了代码编写，特别是在处理复杂类型时。

举个例子：

当一个类型很复杂时，可以使用auto进行简写

cpp 复制代码

std::pair<int, std::string> get_user_info() {
    return {42, "Alice"};
}

int main() {
    // 使用 auto 简化返回类型的声明
    auto user = get_user_info();
    reutrn 0;
}

4.decltype

在C++11标准中，decltype 是一个新增的关键字，用于在编译时推导表达式的类型。与 auto 关键字类似，decltype 也用于类型推导，但两者的工作机制和应用场景有所不同。

decltype 的基本语法

cpp 复制代码

decltype(expression) variable_name;

说明：

expression 是任何有效的C++表达式，decltype 会根据这个表达式的类型来推导出 variable_name 的类型。

示例：

cpp 复制代码

int a = 5;
double b = 3.14;
decltype(a) c = a; // c 的类型为 int
decltype(b+b) d = b; // b+b表达式的结果类型为double,则b的类型为 double

注意:

decltype 不会实际计算表达式的值，它只在编译时进行类型推导。

5.nullptr

由于C++中的NULL被定义为字面量0，但这样可能会带来一些问题

因为 NULL 既能表示指针常量，又能表示整形常量

出于清晰和安全的考虑，C++11新增了nullptr，用于表示空指针

6.左值引用和右值引用

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用的语法特性

现在，引用就分为两种

左值引用
右值引用

什么是左值，什么是左值引用？

左值是一个表示数据的表达式，如变量名、指针等

++左值一般出现在赋值符号的左边++

cpp 复制代码

//下面的指针p ，变量b、c 均为左值
int* p = new int(0);
int b =1;
const int c =2;

左值引用就是给左值的引用，给左值取别名

cpp 复制代码

int*& rp = p;
int& rb = b;
const int& rc = c;

注意：

左值引用的类型一定是左值类型+& ，必须严格匹配

什么是右值？什么是右值引用

右值也是一个表示数据的表达式，如字面常量、表达式返回值、函数返回值等等

++右值只能出现在赋值符号的右边++

cpp 复制代码

//常见右值
10;//常量
x+y;//表达式
add(x,y)//函数返回值

右值引用就是对右值的引用，给右值取别名

cpp 复制代码

int&& rr1=10;
double&& rr2 = x + y;
double&& rr3 = fmin(x,y);

右值是不能取地址的，但给右值取别名后，会导致右值被存储到特定的位置(一般是栈区)，且可以取到该位置的地址

也就是说：++不能取字面量10的地址，但rr1引用后，可以对rr1取地址，也可以修改rr1++

误区：

习惯使用左值引用后

我们对右值引用也会有一个误解:可以通过修改右值引用来修改右值

这是不切实际的，我们修改的从来只是右值引用，而并非右值！

如上面的rr1，令rr1 = 11，并不会让 10 = 11！

巧记

区分左值和右值：左值在赋值操作符的左边，右值在赋值操作符的右边

区分左值引用和右值引用：左值引用是类型+&，右值引用是类型+&&

6.1右值引用的真面目

右值不能被修改，这是公认的，例如 10 永远不可能变成 11

但为什么被引用后，就可以被修改？10不是在常量区吗？难道被移到栈区了？

右值引用一个右值，右值本身并没有被"移动"到某个新的区域，而是右值引用的变量本身存储了右值的内容

具体来说：

右值引用的变量：右值引用本身是一个左值，它有自己的存储位置(通常是栈上的某个位置）。这个变量存储了右值的内容
右值的原始位置：右值的本身的原始位置(如字符常量存储在常量区）并不会因为右值引用而改变变。右值引用只是提供了一个访问右值内容的途径

++右值引用的真面目------左值，左值可以被取地址，非const左值可以被修改++

6.2左值引用和右值引用比较

左值引用总结：

左值引用不能引用左值，但不能引用右值
const 左值引用可以引用左值，也可以引用右值

右值引用总结：

右值引用可以引用右值，不能引用左值，但可以引用move后的左值

6.3右值引用的意义

const 左值引用既可以引用左值又可以引用右值，那为什么C++11还要提出右值引用呢？

是不是画蛇添足？

并不是，左值引用在一起场景下存在短板，而右值引用恰恰能解决这个短板

举个例子：

先今，我们自定义了一个string类

该类中有一个拷贝构造函数，并在类外定义了一个to_string函数

两者造型如下：

to_string函数

cpp 复制代码

bit::string to_string(int value) {
	bit::string str;
	//
	return str;
}

string的拷贝构造函数

cpp 复制代码

string(const string& s) : _str(nullptr) 
{        
    std::cout << "MyString(const MyString& s) -- 深拷贝" << std::endl;
    string tmp(s.str);
    swap(tmp);    
}

用to_string的返回值去构造一个string对象

这就体现左值引用的短板了

当函数返回对象是一个局部对象，出了函数作用域就不存在了，就会调用拷贝构造创建一个新的临时对象，再用这个临时对象去拷贝构造

一共会发生两次拷贝构造，其中，创建临时对象的时候，涉及开辟新的空间

开辟新空间，很浪费资源，太多次受不了

6.3.1移动构造

有没有什么简单，且不吃操作的方法规避深拷贝

有的，兄弟，有的

to_string的返回值是一个右值，用这个右值构造ret2，如果没有移动构造，调用就会匹配调用拷贝构造，因为const左值引用是可以引用右值的，这里就是一个深拷贝

此时我们在bit::string中增加一个移动构造，就是用右值引用充当形参

具体造型如下

cpp 复制代码

//移动构造
string(string&& s)
:_str(nullptr)
,_size(0)
,_capacity(0)
{
   swap(s);
}

此时再次构造ret2，如果既有拷贝构造，又有移动构造，则会调用更为匹配的移动构造

而移动构造中没有新开空间，拷贝数据，效率提高

移动构造的本质:将参数右值的资源窃取过来，占为己有，就不用创建临时对象，开辟空间，而是直接窃取别人的资源来构造自己。

为什么可以这样呢？

++右值引用可以延长右值的生命周期，使其生命周期向右值引用看齐++

这样函数中的返回值本来出了函数作用域就会被销毁，回收资源，右值引用后，就延长了生命周期，不会被回收，

可以直接拿来构造新的对象，不用再创建临时对象，造成额外开销。

6.4万能引用

"万能引用"（Universal Reference）是 C++ 编程中的一个术语，主要用于描述一种能够同时绑定到左值（lvalue）和右值（rvalue）的引用类型。

++万能引用通常出现在模板编程中，允许函数模板接受任意类型的参数，从而实现更灵活和通用的代码设计。++

来看以下例子

cpp 复制代码

// 接受左值引用
void Fun(int& x) {
    std::cout << "Fun(int&): "<< x << std::endl;
}

// 接受右值引用
void Fun(int&& x) {
    std::cout << "Fun(int&&): "<< x << std::endl;
}

// 万能引用的模板函数，调用相应的 Fun 函数
template<typename T>
void CallFun(T&& arg) {
    
    Fun(arg);
}

在main中进行调用模版函数

cpp 复制代码

int a = 10;
const int b = 20;


CallFun(a); // 传递左值，调用 Fun(int&)

CallFun(30); // 传递右值，调用 Fun(int&&)

运行结果:

按理说，应该会调用一个 Fun(int&&) 和一个Fun(int&)，但事实并不是这样

为什么？

模版的万能引用只是提供了能够同时接收左值引用和右值引用的能力

但在后续的使用中，统一当成左值来使用

即++进入模版函数体中，只有左值，没有右值++

所以，会调用两次 Fun(int&)

我们希望事情按照我们的期望发展

在模版函数体中，右值和左值也会保持原来的属性，不会变化

这时候，就需要完美转发

6.5完美转发------forward

完美转发 是 C++11 引入的一项重要特性，旨在函数模板中将参数以其原始的值类别（左值或右值）传递给其他函数，确保在转发过程中不改变参数的性质。

基本造型：

复制代码

std::forward<T>(arg)

说明：

arg即为要保持原始值类比的对象

示例：

在万能转发的模版函数中，添加完美转发

cpp 复制代码

template<typename T>
void CallFun(T&& arg) {
    Fun(std::forward<T>arg);
}

main照常

cpp 复制代码

int main() 
{
	
	int a = 10;
	const int b = 20;

	CallFun(a); // 传递左值，调用 Fun(int&)

	CallFun(30); // 传递右值，调用 Fun(int&&)
	return 0;
}

运行一下：

和我们的预期一致

右值引用和左值引用各有各的用法，并不是随意创造的，具体怎么用，需要结合实际情况进行分析选择。

结语

综上所述，C++11引入的初始化列表、右值引用以及nullptr等特性，为C++语言的发展注入了新的活力。初始化列表通过提供统一的初始化语法，增强了代码的可读性和可维护性；右值引用凭借其独特的语义，极大地优化了对象的移动语义和资源管理效率；nullptr则为指针类型提供了一个明确而安全的表示。这些特性的引入，不仅丰富了C++语言的编程范式，更为现代软件开发中的高效性、可靠性要求提供了有力支持，推动了面向对象编程向更高层次发展。