【C++之C++11特性知识】

下课后泡实验室

于 2024-07-15 23:15:00 发布

阅读量350

点赞数 6

分类专栏： C++基础专栏文章标签： auto C++11 final override lambda decltype 右值引用

本文链接：https://blog.csdn.net/m0_69455439/article/details/140450366

版权

C++基础专栏专栏收录该内容

26 篇文章 0 订阅

订阅专栏

C++学习笔记---026

C++之C++11特性知识

C++之C++11特性知识

前言：
前面篇章学习了C++对unordered_set和unordered_map的认识和应用，接下来继续学习，C++11的知识。
/知识点汇总/

1、C++11特性知识介绍

C++11是C++编程语言的一个重要版本更新，它引入了许多新特性和改进，旨在提高C++的编程效率、安全性和性能。
以下是对C++11部分特性的一些详细介绍：

自动类型推导（auto关键字）
功能：允许编译器自动推导变量的类型，从而简化变量声明。
优势：减少代码中的类型冗余，提高代码的可读性和编写效率。
范围for循环（Range-based for loop）
功能：提供了一种更简洁的方式来遍历容器（如vector、list等）或数组。
语法：for (auto element : container) { … }
优势：代码更加简洁，易于理解和维护。
**Lambda表达式 **
功能：允许在函数内部定义匿名函数，并可以捕获局部变量。
优势：使函数定义更加灵活和简洁，特别适用于需要函数对象（如算法、回调函数等）的场景。
右值引用和移动语义
功能：通过引入右值引用（&&）和移动构造函数/赋值运算符，提高了资源管理的效率。
优势：在涉及到临时对象的场景中，可以减少不必要的拷贝，提高性能。
智能指针
种类：包括std::shared_ptr、std::unique_ptr和std::weak_ptr。
功能：提供了自动内存管理的机制，减少了内存泄漏的风险。
优势：std::shared_ptr和std::unique_ptr分别用于共享和独占资源的场景，std::weak_ptr则用于解决std::shared_ptr的循环引用问题。
nullptr关键字
功能：引入了一个明确的空指针常量nullptr，替代了之前的NULL宏。
优势：提高了代码的类型安全性和可读性。
并发编程支持
功能：引入了线程库和原子操作库，提供了并发编程的支持。
优势：可以更方便地实现多线程程序和处理并发任务。
新的标准库组件
组件：如正则表达式库、元组库、随机数据库等。
功能：增强了C++标准库的功能，方便处理一些常见的任务。
类型推导（decltype关键字）
功能：允许从表达式中推导出类型，用于模板编程和auto关键字中。
优势：提高了C++中类型推断的能力，减少了代码中的类型冗余。
其他特性
枚举类（enum class）：引入了强类型枚举，提高了类型安全。
constexpr关键字：允许将变量、函数等声明为编译时常量，有助于提高程序的性能。
委托构造函数：允许一个构造函数调用同一个类中的另一个构造函数，简化了构造函数的编写。
模板增强：包括外部模板、变长参数模板等特性，使模板编程更加强大和灵活。
统一初始化：提供了一种统一的语法来初始化任何对象，使初始化更加一致和简洁。

2、auto关键字

背景：
C++98中已经出现了auto,它的功能是将一个变量设置为临时的，自动申请，自动结束。我们在写代码时，发现不用加auto也是实现这个功能，我们就几乎不使用这个关键字了。
c++11赋予了auto新的含义，实现类型的自动推导，要求必须显式初始化，编译器在编译时根据对象的类型自动推导初始化类型。

比如：
auto a=10;10为整形，编译器就根据10进行推导，编译时auto设为int.
再比如:
vector< vector >::iterator i = v.begin(); --》 auto i = v.begin()即可.

3、范围for

范围for（Range-based for loop）是C++11中引入的一种语法，通常与auto一起使用，其底层实现也是迭代器，它提供了一种更简洁的方式来遍历容器（如std::vector、std::list、std::array等）或数组中的所有元素。以下是一个简单的范围for的示例，该示例遍历一个std::vector中的所有元素，并打印它们：

#include <iostream>  
#include <vector>  
int main() {  
    // 创建一个包含几个整数的vector  
    std::vector<int> nums = {1, 2, 3, 4, 5};    
    // 使用范围for遍历vector  
    for (int num : nums) {  
        std::cout << num << " ";  
    }   
    std::cout << std::endl;  
    return 0;  
}

4、列表初始化

背景;
在C++98中(Initializer list)，标准允许使用花括号{}对数组元素进行统一的列表初始值设定.


struct Point
{
	int _x;
	int _y;
};
int main()
{
	int array1[] = { 1, 2, 3, 4, 5 };
	int array2[5] = { 0 };
	Point p = { 1, 2 };
	return 0;
}

C++98对于自定义类型，无法使用列表初始化，在C++11中改进了
C++11中自定义类型也可以使用列表初始化，C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。即：C++11进一步扩展了 { } 的特性，一切皆可用 { }，无论是内置类型，还是自定义类型，其中赋值（=）可以省略。

内置类型

// 内置类型变量
int x1 = {10};
int x2{10};//建议使用原来的
int x3 = 1+2;
int x4 = {1+2};
int x5{1+2};
// 数组
int arr1[5] {1,2,3,4,5};
int arr2[]{1,2,3,4,5};
// 动态数组，在C++98中不支持
int* arr3 = new int[5]{1,2,3,4,5};
// 标准容器
vector<int> v{1,2,3,4,5};//这种初始化就很友好，不用push_back一个一个插入
map<int, int> m{{1,1}, {2,2,},{3,3},{4,4}};

自定义类型的列表初始化

class Point
{
public:
	Point(int x = 0, int y = 0): _x(x), _y(y)
{}
private:
	int _x;
	int _y;
};
int main()
{
	Pointer p = { 1, 2 };
	Pointer p{ 1, 2 };//不建议
return 0;
}

5、final 与 override关键字

final特性

1、final修饰类的时候，表示该类不能被继承

class A final //表示该类是最后一个类
{
private:
	int _year;
};
class B : public A //无法继承
{

};

2、final修饰虚函数时，这个虚函数不能被重写

class A 
{
public:
	virtual void fun() final//修饰虚函数
	{
		cout << "this is A" << endl;
	}
private:
	int _year;
};
class B : public A
{
public:
	virtual void fun()//父类虚函数用final修饰，表示最后一个虚函数，无法重写
	{
		cout << "this is B" << endl;
	}
};

override特性

检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错

class A 
{
public:
	virtual void fun()
	{
		cout << "this is A" << endl;
	}
private:
	int _year;
};
class B : public A
{
public:
	virtual void fun() override
	{
		cout << "this is B" << endl;
	}
};

6、lambda表达式

背景：
在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法

#include <algorithm>
#include <functional>
int main()
{
	int array[] = { 4,1,8,5,3,7,0,9,2,6 };
	// 默认按照小于比较，排出来结果是升序
	std::sort(array, array + sizeof(array) / sizeof(array[0]));
	// 如果需要降序，需要改变元素的比较规则
	std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
	return 0;
}

如果待排序元素为自定义类型，需要用户定义排序时的比较规则

struct Goods
{
	string _name; // 名字
	double _price; // 价格
	int _evaluate; // 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};
struct ComparePriceLess
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price < gr._price;
	}
};
struct ComparePriceGreater
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price > gr._price;
	}
};
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
	3 }, { "菠萝", 1.5, 4 } };
	sort(v.begin(), v.end(), ComparePriceLess());
	sort(v.begin(), v.end(), ComparePriceGreater());
}

随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，
都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，
这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。

struct Goods
{
	string _name; // 名字
	double _price; // 价格
	int _evaluate; // 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
	3 }, { "菠萝", 1.5, 4 } };
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._price < g2._price; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._price > g2._price; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._evaluate < g2._evaluate; });
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._evaluate > g2._evaluate; });
}

书写格式：
[ 捕捉列表] (参数列表 ) mutable ->返回值{ 函数体}
（1）捕捉列表：这个必须写，编译器根据[ ] 来判断接下来的代码是否为lambda表达式，捕捉列表能够捕捉上下文变量供lambda函数使用
（2）参数列表：与函数参数一致，如果我们不需要传参，可以与（）一起省略掉
（3）mutable:默认情况下，lambda是一个const函数，mutable可以取消const属性。如果我们使用mutable，即使参数为空，我们也不能省略（）
（4）->返回值：如果没有返回值可以省略，有返回值也可以省略，这是编译器根据返回的类型自动推导。
（5）函数体：函数体内,除了使用参数外，还可以使用捕捉列表中的变量。

实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如
果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。(仿函数形式处理)

class Rate
{
public:
	Rate(double rate) : _rate(rate)
	{}
	double operator()(double money, int year)
	{
		return money * _rate * year;
	}
private:
	double _rate;
};
int main()
{
	// 函数对象
	double rate = 0.49;
	Rate r1(rate);
	r1(10000, 2);
	// lamber
	auto r2 = [=](double monty, int year)->double {return monty * rate * year;	};
	r2(10000, 2);
	return 0;
}

7、右值引用和移动语义

背景：

左值和左值引用

之前使用的左值和左值引用，引用本质就是取别名，不开辟空间，但是底层是由指针实现的。左值就是一个表达式，其中包括变量名，解引用的变量等等，他们都有可以取地址，可以被赋值，位于赋值运算符的左边。但是如果被const修饰，就不能被赋值。左值引用就是对左值进行取别名。其中前置++也是左值。

//左值,其中ch,a,p都是左值
int ch=10;
const int a=ch;
int*p=new int(100);

//左值引用
int& rch=ch;
const int& ra=a;
int*&rp=p;

右值和右值引用

右值引用也是一个表达数据的表达式，包括字面常量，函数返回值，表达式结果等等，右值是不能被取地址的，也不能对他进行赋值操作。位于赋值运算符的右边。后置++
右值引用就是对右值进行取别名。

//常见右值
10；
x+y;
fun();

//右值引用
int&&ch1=10;
double&&ch2=x+y;
char&&ch3=fun();

注意:
右值不能被修改，也不能被取地址。但是被右值引用之后，就有了一块固定存储空间，我们就可以对他进行取地址，也可以对他修改。但如果不想进行修改，就加上const

左值引用与右值引用转换关系

1.左值引用能用左值来进行引用，不能用右值。但是const 既可以用左值引用，也可以用右值引用。左值引用存储的是当前地址。

int  main()
{
	//左值引用右值
	const int& ch1 = 10;
	
	//左值引用左值
	int a = 100;
	const int& ch2 = a;
	return 0;
}

2.右值引用能用来引用右值，但不能引用左值。但是右值引用可以引用move后的左值。
move唯一的功能就是将一个左值强制转换成右值引用，实现移动语义。
右值引用存储的是栈上的一个临时空间的地址。

int&& nn = move(a);

右值引用的意义：
不管左值还是右值，引用本质就是用来减少拷贝的；
之前的左值引用已经减少了很多拷贝，比如：传参数，函数返回值的返回。
但是左值引用有一种场景还没有解决！！！

string to_string()
{
	string ret;
	//.....

	return ret;
}
int main()
{

	string s = to_string();
	return 0;
}

如果使用正常的左值引用我们来看一下，会产生两次拷贝，如果是深拷贝，资源浪费巨大。并且拷贝的这块临时空间还会被释放。也就是说，这块空间，刚被拷贝构造之后，再次拷贝构造，就会被立即释放掉。C++编译器对这种情况做了处理，只是部分主流编译器会做这样的处理
构造·+拷贝构造----->直接构造，省去了那次临时对象的拷贝

如果函数的返回值是一个临时对象（将亡值），出了作用域就销毁了，我们就不能用左值引用减少拷贝了，只能进行传参返回，不能减少拷贝。右值引用就是解决这样场景的。

move
它的功能很简单，就是将某个左值强制转化为右值。基于 move() 函数特殊的功能，其常用于实现移动语义。

右值引用的移动语义move：
移动构造本质，将参数右值的资源窃取过来，占为己有。不用进行拷贝了。延长资源的生命周期。
而右值引用对着做了进一步的优化
它是通过对构造函数进行处理，根据参数的匹配原则，如果拷贝构造的是右值（临时值），就走这个右值引用的拷贝构造

string(string&&sp)
{
	swap(sp);
}

在这里插入图片描述
s1(sp);将sp的资源进行转移到自己这里，出了作用域sp自动释放。
我们按照这种方式，进行了一次拷贝构造，传给临时对象，在将这个临时对象移动构造给s。

但是再进行编译器的优化之后，构造和移动构造合二为一，变成直接移动构造
同时ret是左值，编译器会隐式的进行move(ret),变成右值。
在这里插入图片描述

这种实现方式是通过参数不同，函数不同的方式实现的（参数匹配）

void fun(int& ch)
{
	cout << "void fun(int& ch)" << endl;
}

void fun(int&& ch)
{
	cout << "void fun(int&& ch)" << endl;
}
int main()
{
	int a1 = 0;
	fun(a1);
	fun(1);
	return 0;
}

只有深拷贝的对象才需要移动拷贝

右值引用的移动语义还包括赋值，赋值也是同样的道理

string& operator=(string&& s)
{
	cout << "string& operator=(string&& s) -- 移动语义" << endl;
	swap(s);
	return *this;
}
string to_string()
{
	string ret;
	//.....

	return ret;
}
int main()
{
	bit::string ret1;
	ret1 = bit::to_string(1234);
	return 0;
}

在这里插入图片描述

右值引用还有一个重要应用：完美转发与万能引用

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

template<typename T>
void PerfectForward(T && t)
{
	Fun(t);
}

int main()
{
	PerfectForward(10); // 右值
	int a;
	PerfectForward(a); // 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b); // const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}

在这里插入图片描述
我们发现全都是左值引用，这是为什么呢？

1.我们写的模板可是右值引用的，为什么左值也可以调用呢？？

template< typename T>
void PerfectForward(T && t)

在函数模板中，我们的这个T&&t 是当作万能引用的，什么意思呢？？
我们不能单纯的把它理解为右值，只有传右值才进行调用，
而是传左值，就当作左值，传右值就当作右值。
只有与模板配合使用时才忽悠万能引用的功能

2.我们传的是右值，为什么也调用左值引用？？
我们传右值给t，右值引用，变为了左值的属性。
我们继续传递给Fun函数，也就是拿左值进行传递，当然调用左值。

如何解决？？
利用完美转发

完美转发是指在函数模板中，完全依照模板的参数的类型，将参数传递给函数模板中调用的另外一个函数。

void Func(int x)
{
	cout << x << endl;
}
template<typename T>
void PerfectForward(T&& t)
{
	Func(t);
}

完美转发就是在传参过程中保持原来的属性不变，forward

template<typename T>
void PerfectForward(T && t)
{
	Fun(forward<T>(t));
}

在这里插入图片描述

8、智能指针

和 unique_ptr、weak_ptr 不同之处在于，多个 shared_ptr 智能指针可以共同使用同一块堆内存。并且，由于该类型智能指针在实现上采用的是引用计数机制，即便有一个 shared_ptr 指针放弃了堆内存的“使用权”（引用计数减 1），也不会影响其他指向同一堆内存的 shared_ptr 指针
（只有引用计数为 0 时，堆内存才会被自动释放）。

#include <iostream>
#include <memory>
using namespace std;
int main()
{
  //构建 2 个智能指针
  std::shared_ptr<int> p1(new int(10));
  std::shared_ptr<int> p2(p1);
  //输出 p2 指向的数据
  cout << *p2 << endl;
  p1.reset();//引用计数减 1,p1为空指针
  if (p1) {
    cout << "p1 不为空" << endl;
 }
  else {
    cout << "p1 为空" << endl;
 }
  //以上操作，并不会影响 p2
  cout << *p2 << endl;
  //判断当前和 p2 同指向的智能指针有多少个
  cout << p2.use_count() << endl;
  return 0;
}

9、类型推导（decltype关键字）

decltype 是 C++11 新增的一个关键字，它和 auto 的功能一样，都用来在编译时期进行自动类型推导。
(1)为什么要有decltype
因为 auto 并不适用于所有的自动类型推导场景，在某些特殊情况下 auto 用起来非常不方便，甚至压根无法使用，所以 decltype 关键字也被引入到 C++11 中。
auto 和 decltype 关键字都可以自动推导出变量的类型，但它们的用法是有区别的：

decltype:将变量的类型声明为表达式指定的类型

auto varname = value;
decltype(exp) varname = value;

其中，varname 表示变量名，value 表示赋给变量的值，exp 表示一个表达式。
auto 根据"=“右边的初始值 value 推导出变量的类型，而 decltype 根据 exp 表达式推导出变量的类型，跟”="右边的 value 没有关系。
另外，auto 要求变量必须初始化，而 decltype 不要求。这很容易理解，auto 是根据变量的初始值来推导出变量类型的，如果不初始化，变量的类型也就无法推导了。decltype 可以写成下面的形式：

decltype(exp) varname;

decltype 用法举例

// decltype 用法举例
int a = 0;
decltype(a) b = 1;  //b 被推导成了 int
decltype(10.8) x = 5.5;  //x 被推导成了 double
decltype(x + 100) y;  //y 被推导成了 double

常用于这种情况下

template<class T1, class T2>
void fun(T1 t1, T2 t2)
{
	decltype(t1 + t2)ret;
	cout << typeid(ret).name();
}

10、参考文档

原文链接
 原文链接
 C++11特性（详细版）