C++学习笔记---026
- C++之C++11特性知识
- 1、C++11特性知识介绍
- 2、auto关键字
- 3、范围for
- 4、列表初始化
- 5、final 与 override关键字
- 6、lambda表达式
- 7、右值引用和移动语义
- 8、智能指针
- 9、类型推导（decltype关键字）
- 10、参考文档
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特性（详细版）
