1 简介
C++自1979年首次实现带有类的C以来，已经存在了40年。
现在其C++ 的语法已经非常复杂。
其发展路径具有重要的参考意义，特别是像go，rust这样的类似的语言。
Rust从C++中学到了内存安全的重要性，Zig从C中选择了更细分的内存分配，Go则带上“指针”和“垃圾收集”两件法宝自成一派。
而其C++26已经在规划之中...
也就是 2026年将要发布的版本。
对于C++26，将努力在该标准中具有以下内容：
* 执行
* 代码范围
* 反射
在没有特定场景的情况下，将优化
合约
Contracts 类似 assert 和 static_assert 的语法，可以在函数声明时使用。
模式匹配
经常说C++需要像它这样的新控制语句头上需要一孔，图案匹配显示很多希望 提供比我们所能提供的更好的 过滤器/链/选择 近似于纯图书馆设施。
模式匹配 通过以下方式提高类型安全性 使编写类型安全代码比编写 传统的 C 型或传统的C++式替代品更好。
此外，它还将访问者置于 在许多情况下，模式。
这不仅仅是另一个控件结构;它与类型系统交互。
在这个领域有相当多的工作正在进行中，在 C++26 时间范围内给它播出时间。
如何运送，以及 以什么形式，目前还不完全清楚。
做为一个经典版本，C++ 11 出现了大量新特征，几乎成为一个新语言。
这里主要回顾C++11的新的特征。包括新的算法，新的容器类原子操作，类型特征，正则表达式，新的智能指针，async()功能多线程库。
C++11 延迟，
C++14 准时，
C++17 准时 ，
C++20 准时，
C++23 将准时，
C++26 将按时
而C++曾经也是一位昂扬向上的少年，现在只不过是经历了40年之久青年。
1 c++11更新
1.0，基于范围的for循环
int nArr[5] = {1,2,3,4,5};
for(int &x:nArr){
x *=2; //数组每个元素倍乘
}
1.1，Lambda表达式
允许定义本地功能， 消除大部分乏味而且有安全风险的函数对象。
[capture](parameters)->return-type{body}
[]指示lambda表达式的开始
int main()
{
char s [] = "hi";
int Uppercase = 0;
for_each(s, s+sizeof(s), [&Uppercase] (char c)){
if (isupper(c))
Uppercase++;
});
cout<< Uppercase<<"uppercase letters in:" << s<<end1;
}
类似与定义一个函数，将其主主体放置在另一个函数调用。[&Uppercase] &表示lambda主体获得对Uppercase的引用，如果没有&，
大写字母将按值传递，C++11 lambda也包括用于成员函数的构造。
1.2，自动类型推导 decltype， Automatic Type Deduction
编译器自动推断i为int类型
auto i = 1;
在v11 之前C++ 在声音对象时 必须指定对象类型，很多情况下，对象的声明包括初始化程序， C++11充分利用了这一点，可用在不指定对象类型的情况下声明对象。
auto x=0; //x has type int because 0 is int
auto c='a'; //char
auto d=0.5; //double
auto national_debt=14400000000000LL;//long long
auto不再指定具有自动存储类型的对象。相反，它声明一个对象，该对象的类型可从其初始值设定项推导， 声明一个迭代器
auto ci=vi.begin();
标准模板库容器的判断
vector<int> vec(6,10);
vector<int>::iterator iter=vec.iterator();
auto iterAuto = vec.iterator(); //相比较更方便
1.3，统一初始化语法
C++ 11 使用统一的大括号表示初始化
std::string s("hello");
int m=int(); //默认初始化 default initialization
在某些情况下，可用将 = 用于相同目的
std::string s="hello";
int x=5;
对于POD聚合，使用花括号
int arr [4] = {0,1,2,3};
today struct tm = {0};
最后构造函数使用成员初始化程序
structs {
int x;
s():x(0) {}};
}
1.4，删除函数 和 默认函数
默认函数
struct A {
A()=default; // C++11 only 指示编译器生成该函数的默认实现
public: C();
};
默认函数有两个优点：它们比手动实现更有效，并且使程序员摆脱了手动定义这些函数的麻烦。
删除函数
int func()=delete;
已删除的函数对于防止对象复制很有用
=delete:
struct NoCopy
{
NoCopy & operator =( const NoCopy & ) = delete;
NoCopy ( const NoCopy & ) = delete;
};
NoCopy a;
复制出错
NoCopy b(a); //compilation error, copy ctor is deleted
1.5，nullptr
一个关键字，它指定空指针常量。
nullptr替换了NULL多年来容易被用作空指针替代的易于出错的宏和立即数0（macro and the literal）。nullptr是强类型的
void f(int); //#1
void f(char *);//#2
//C++03
f(0); //which f is called?
//C++11
f(nullptr) //unambiguous, calls #2
nullptr 适用于所有指针类别，包括函数指针和成员指针
const char *pc=str.c_str(); //data pointers
if (pc!=nullptr)
cout<<pc<<endl;
int (A::*pmf)()=nullptr; //pointer to member function
void (*pmf)()=nullptr; //pointer to function
1.6，委托建造者 Delegating Constructors
C++11 中构造函数可调用同一类的另一个构造函数
class M //C++11 delegating constructors
{int x, y;
char *p;
public:
M(int v) : x(v), y(0), p(new char [MAX]) {} //#1 target
M(): M(0) {cout<<"delegating ctor"<<endl;} //#2 delegating };
委托构造器＃2调用目标构造器＃1
1.7， 右值参考
C ++ 03中的引用类型只能绑定到左值。C ++ 11引入了新的引用类型类别，称为rvalue引用。
右值引用可以绑定到右值，例如临时对象和文字
void naiveswap(string &a, string & b)
{string temp = a;
a=b;
b=temp; }
以上例子需要分配内存，使用右值引用可不分配内存，效率更高
void naiveswap(string &a, string & b)
{
伪代码
size_t sz = empty.size（）;
const char * p = empty.data（）;
将填充的资源移为空
empty.setsize（filled.size（））;
empty.setdata（filled.data（））;
填充为空
fill.setsize（sz）;
fill.setdata（p）;
}
1.8，新增标准库
TR1标准包括新的容器类
unordered_set, onordered_map,onordered_multiset, nordered_multimap
正则表达式，元组，功能对象包装，文档库
1.8.1，线程库 并发
promise 和 futures 线程类，在并发环境中用于同步的对象
用于启动并发任务的async()
声明线程tread_local存储类型
1.8.2 新的算法
可模仿集合理论运算的新算法 all_of()
none_of()
ispositive() 范围[first,first+n]
并使用all_of(), any_of()
#include <algorithm>
C ++ 11代码，所有元素都是积极的吗？
all_of（first，first + n，ispositive（））; //假
至少有一个积极因素？
any_of（first，first + n，ispositive（））; //真
这些元素都不是积极的吗？
none_of（first，first + n，ispositive（））; //假
复制数组copy_n()
#include
int source [5] = {0,12,34,50,80};
int target[5];
// copy 5 elements from source to target
copy_n(source, 5, target);
iota()创建一系列按顺序递增的值，就像通过将初始值分配给*first
然后使用 ++ 前缀递增该值。 下例中 iota()将连续值{10,11,12,13,14}分配给数组arr，并将{'a', 'b' 'c'} 分配给 char数组
include <numeric>
int a[5]={0};
char c[3]={0};
iota(a, a+5, 10); //changes a to {10,11,12,13,14}
iota(c, c+3, 'a'); //{'a','b','c'}
1.9, 后置返回类型 tailng-return-type
template Ret adding_func(const Lhs &lhs, Const Rhs &rhs){return lhs + rhs;}
C++11的合法语法，添加后置返回类型
template auto adding_func(const Lhs &lhs, const Rhs &rhs) -> decltype(lhs+rhs) {return lhs + rhs;}
更普遍的函数声明和定义
struct SomeStruct {
auto func_name(int x, int y) -> int;
};
auto SomeStruct::func_name(int x, int y) -> {
return x + y;
}
1.10, 显示重写 override final
struct Base{
virtual void some_func(float);
};
struct Derived:Base{
virtual void somt_func(int) override; // 错误，不会重写基类方法
};
override 编译器将检查基类中有没有一个具有相同签名的虚函数
final用于防止基类被继承和防止子类重写
struct Base1 final { };
struct Derived1 : Base1 { }; // 病态的, 因为类Base1被标记为final了
struct Base2 {
virtual void f() final;
};
struct Derived2 : Base2 {
void f(); // 病态的, 因为虚函数Base2::f 被标记为final了.
};
最大整型
long long int
1.11, 允许sizeof运算符可用在类型数据成员使用，无需明确对象
struct p {otherClass member;};
sizeof(p:member);
1.12, 元组 tuple
由预先确定数量的多种对象组成，元组可用看作时struct数据成员泛化。
使用可变参数模板，元组的定义时这样的
template <class ...Types> class tuple;
下面是定义和使用元组的一个例子:
typedef std::tuple <int, double, long &, const char *> test_tuple;
long lengthy = 12;
test_tuple proof (18, 6.5, lengthy, "Ciao!");
lengthy = std::get<0>(proof); // 把'lengthy' 赋值为18.
std::get<3>(proof) = " Beautiful!"; // 修改元组的第四个元素
1.13，常量constexpr
保证函数或者对象构造函数在编译器常量
constexpr int GetFive() {return 5;}
int some_value[GetFive() + 7]；
產生12個整數的陣列。合法的C++11寫法
2 小结
自2011年C++标准的重大修正以来，2020年的C++20被称为又一个里程碑。 而C++26也在计划之中。
C++一般被人认为是C的超集，但是这并不完全准确。
相比C语言，C++早期的新功能就包括
类，成员函数，派生类，单独的编译，
公共和私有访问控制，友元，函数参数的类型检查，默认参数，内联函数，重载运算符，
构造函数，析构函数，调用和返回函数，并发库，虚函数，复数，
引用，命名空间，异常处理，模板，容器，IO流等。
C++20更引入了检查程序实体，例如检查变量，枚举，类及其成员，lambda及其捕获功能等。
大部分C语言代码可以很轻易地在C++正确编译，但是仍有少数差异，导致某些有效C代码在C++失效。
如果需要混用它们，则需要在C++中调用，必须放在 extern "C"{/C代码/}内。
参考
https://en.wikipedia.org/wiki/C++11
https://www.open-std.org/
