一些C++11的变化

cpp/C++11&14.md

@@ -0,0 +1,499 @@
+<!--
+ * @Author: your name
+ * @Date: 2021-10-21 10:56:48
+ * @LastEditTime: 2021-11-18 21:08:59
+ * @LastEditors: Please set LastEditors
+ * @FilePath: \MarkdownLog\cpp\C++11&14.md
+-->
+
+- C++的一些版本
+  - C++98(1.0)
+  - C++03
+  - C++11(2.0)
+  - C++14
+
+## Variadic Templates 可变参数模板
+
+```cpp
+void printX()
+{}
+
+template <typename T, typename... Types>
+void printX(const T& firstArg, const Types&... args)
+{
+    cout << firstArg << endl;
+    printX(args...);
+}
+```
+
+> 通过`sizeof...(args)`可以知道args中包括多少个参数
+
+通过可变参数模板，可以帮助我们使用递归做一些操作  
+
+```cpp
+// 可变参数模板的用例
+
+#include <functional>
+template<typename T>
+inline void hash_combine(size_t& seed. const T& val)// 函数_4
+{
+    seed ^= std::hash<T>()(val) + 0x9e3779b9 + (seed<<6) + (seed >> 2);
+}
+
+template<typename T>
+inline void hash_val(size_t& seed, const T& val){// 函数_3
+    hash_combine(seed, val);
+}
+
+template<typename T, typename... Types>
+inline void hash_val(size_t& seed, const T& val, const Types&... args)// 函数_2
+{
+    hash_combine(seed, val);
+    // 根据args...的参数个数来执行 函数_2 或者 函数_3
+    hash_val(seed, args... );
+}
+
+template<typename... Types>
+inline size_t hash_val(const Types&... args)// 函数_1
+{
+    size_t seed = 0;
+    // 虽然 函数_1 和 函数_2 都符合执行条件，但是 函数_2 相比而言更特化，所以执行 函数_2
+    hash_val(seed, args);
+    return seed;
+}
+
+class CustomerHash{
+    public:
+    std::size_t operator()(const Customer& c) const{
+        // 因为第一个fname不是size_t类型，所以执行的是 函数_1 hash_val
+        return hash_val(c.fname, c.lname, c.no);    
+    }
+}
+```
+
+> 这里用args配合递归不停的切分参数
+
+```cpp
+template<typename... Values> class tuple;
+template<> class tuple<> {}; // 作为中止点
+
+template<typename Head, typename... Tail>
+class tuple<Head, Tail...> : private tuple<Tail>
+{
+    typedef tuple<Tail...> inherited;
+public:
+    tuple() {}
+    tuple(Head v, Tail... vtail) : m_head(v), inherited(vtail) {}
+    typename Head::type head() {return m_head;}
+    inherited& tail() {return *this;}
+
+protected:
+    Head m_head;
+}
+
+// tuple<int, float, string> t(41, 6.3, "Niko");
+// t.head() -> 41
+// t.tail() -> tuple<float, string>(6.3, "Niko")
+// t.tail()->head() -> 6.3
+
+```
+
+> 这里最上面有个空的 tuple<>，是作为递归继承的中止点  
+> 这里用递归继承的方式做出了tuple  
+
+## 模板中的空格
+
+```cpp
+vector<list<int> > // 全版本支持
+vector<list<int>> // C++11之后没有空格也行
+```
+
+> 因为老版本一些编译器会将`>>`识别为操作符，所以需要加空格  
+> C++11之后不加空格也行  
+
+## nullptr ans std::nullptr_t
+
+`nullptr` 指的是 空指针，C++11允许用`nullptr`代替0或者`NULL`
+
+```cpp
+void f(int);
+void f(void*);
+f(0);               // 运行  f(int)
+f(NULL);            // 运行  f(int)，如果是其他数，就不清楚具体调用哪个了
+f(nullptr);         // 云心  f(void*)
+```
+
+```cpp
+#if defined(__cplusplus) && __cplusplus >= 201103L
+#ifndef __GXX_NULLPTR_T
+#define __GXX_NULLPTR_T
+    typedef decltype(nullptr) nullptr_t;
+```
+
+## auto
+
+```cpp
+auto i = 20;    // i 的 类型是 int
+
+double f();
+auto d = f();   // d 的 类型是 double
+
+vector<string> v;
+auto pos = v.begin();   // pos 的 类型是 vector<string>::iterator
+
+auto l = [](int x) -> bool {
+    // ...
+};              // l 的类型是 lambda表达式
+
+```
+
+> 使用`auto`主要是用在数据类型 **太长** 或者 **太复杂** 的情况 (比如迭代器、lambda的类型)  
+> 倒也不是什么情况都用`auto`
+
+```cpp
+// 标准库中对auto的使用
+#if __cplusplus >= 201103L
+    inline auto operator- (const reverse_iterator<_IteratorL> &__x, 
+        const reverse_iterator<_IteratorR> &__y)
+        -> decltype(__y.base() - __x.base())
+#else
+    inline typename reverse_iterator<_IteratorL>::difference_type 
+        operator- (const reverse_iterator<_IteratorL>& __x, 
+        const reverse_iteratror<_IteratorR>& __y)
+#endif
+```
+
+## unifor initialization 一致性初始化
+
+初始化可能发生在小括号、中括号、赋值中
+
+```cpp
+Rect r1 = {3, 4, 5};        // 大括号
+Rect r1(3, 4, 5);           // 小括号
+int values[5] = {1, 3, 4, 5};   // 赋值
+```
+
+C++11引入**一致性初始化**——大括号（虽然用以前的也没错）
+
+```cpp
+int values[]{1, 3, 4, 5}; 
+vector<int> v{1, 3 ,4 ,5};
+complex<duoble> c{3.0, 4.0};
+```
+
+> 变量之后直接加上大括号即表示初始化  
+
+当编译器看到`{t1, t2, t3...}`便做出一个`initializer_list<T>`，他关联至一个`array<T, n>`，调用函数（比如构造函数）时`arry`中的元素被逐个分解传给函数；如果调用函数的参数就是`initializer_list<T>`，就不会注意分解而是直接整个传给函数  
+
+比如：`vector<int> v{1, 3 ,4 ,5};` 中的初始化参数 `{1, 3 ,4 ,5}`转换成 `initlializer_list<int>`，而这个关联`array<int, 4>`容器
+
+## initalizer_list 初始化列表
+
+```cpp
+int i;          // 没有被初始化
+int j{};        // j被初始化为0
+int *p;         // p没有被初始化
+int *q{};       // q被初始化为nullptr
+```
+
+```cpp  
+int x1(4.3);            // ok
+int x2 = 4.3;           // ok
+int x3 {4.3};           // 部分平台Error，部分平台warning
+int x4 = {5.3};         // 部分平台Error，部分平台warning
+
+char c1{7};             // ok
+char c2{9999};          // 部分平台Error，部分平台warning
+
+std::vector<int> v1{1, 3, 4, 5};            // ok
+std::vector<int> v2{1.0, 3.0, 4.0, 5.0};    // 部分平台Error，部分平台warning
+```
+
+> 初始化列表的作用，还可以帮助检查一些错误
+
+```cpp
+
+void print(std::initlializer_list<int> vals)
+{
+    for(auto p = vals.begin(), p != vals.end(); ++p){
+        std::cout << *p << std::endl;
+    }
+}
+
+print({1, 3, 4, 5});
+```
+
+> 证明`{t1, t2, t3...}`被转换成`initializer_list<T>`  
+
+```cpp
+class P{
+public:
+    P(int a, int b){
+        std::cout << "(int ,int)" << std::endl;
+    }
+    P(initializer_list<int> initlist){
+        std::cout << "initializer_list" << std::endl;
+    }
+};
+
+P p(7, 7);          //  输出 (int ,int)
+P p{7, 7};          //  输出 initializer_list
+P r{7, 5, 4};       //  输出 initializer_list
+P p = {7, 7};       //  输出 initializer_list
+```
+
+> 如果不存在第二个`initializer_list`的构造函数，则第三个对象 r 将创建失败
+
+## explicit
+
+```cpp
+
+/**
+ * non-explicit-one-argument 只要一个实参就够了的构造函数
+ * 下面例子中：没有写oprator * (Fraction, int)的操作符重载也不会报错，因为编译器将4通过一个参数的构造变成Fraction(4, 1)类型
+ * 当构造函数前加上explicit关键字时，编译器不会进行隐式构造函数将4变成Fraction(4, 1)
+ * 
+ * ——————————————————————————————————————————————————————————————————————————————
+ * 如果构造函数不存在explicit，且有operator double()转换函数，编译器报错，因为存在二义性即两种方式都可以行得通且没有优先级这么一说
+ * 如果构造函数存在explicit，且有operator double()转换函数，编译器不报错，因为只有一条路可走，将Fraction转换成double计算
+ * 如果构造函数不存在explicit，且没有operator double()转换函数，编译器不报错，因为只有一条路可走，将4转换成Fraction计算
+ **/
+
+class Fraction
+{
+  public:
+    // 这里构造函数只需要一个参数其实也够
+    Fraction(int num, int den = 1) : m_numerator(num), m_denominator(den) {}
+    //explicit Fraction(int num, int den = 1) : m_numerator(num), m_denominator(den) {}
+
+    Fraction operator*(const Fraction &f)
+    {
+        return Fraction(f.m_numerator * this->m_numerator, f.m_denominator * this->m_denominator);
+    }
+    std::string getString()
+    {
+        char numerator[10];
+        char denominator[10];
+        memset(numerator, 0, sizeof(numerator));
+        memset(denominator, 0, sizeof(denominator));
+        itoa(m_numerator, numerator, 10);
+        itoa(m_denominator, denominator, 10);
+        return std::string(std::string(numerator) + std::string("/") + std::string(denominator));
+    }
+
+  private:
+    int m_denominator; // 分母
+    int m_numerator;   // 分子
+};
+
+int main()
+{
+    Fraction f(3, 5);
+    Fraction f2 = f * 4;
+    std::cout << f2.getString() << std::endl;
+    system("pause");
+    return 0;
+}
+```
+
+> explicit告诉编译器，不能发生相应的隐式类型转换，只能以显示的方式进行类型转换
+
+## range-based for statement
+
+```cpp
+// for(decl : coll){
+//     statement
+// }
+
+for(int i : {2, 3, 4, 5, 6}){
+    cout << i << endl;
+}
+
+vector<double> vec;
+//...
+for(auto elem : vec){
+    cout << elem << endl;
+}
+for(auto &elem : vec){
+    elem *= 3;
+}
+
+// range-based for 的底层实现类似
+
+for(auto _pos = coll.begin(), _end = coll.end(); _pos != _end; ++pos){
+    decl = *_pos;
+    // 对值的操作
+}
+// 或者
+for(auto _pos = begin(coll), _end = end(coll); _pos != _end; ++pos){
+    decl = *_pos;
+    // 对值的操作
+}
+```
+
+**下面的写法会报错**
+
+```cpp
+class C{
+public:
+    explicit C(const string& s); // 禁止string隐式转换成C
+    // ...
+}
+
+vector<string> vs;
+for(const C& elem : vs){
+    cout << elem << endl;   // 报错，因为字符串不能隐式的转换成C
+}
+```
+
+## =default, =delete
+
+如果自行定义一个构造函数，那么编译器不会再给一个默认构造函数
+
+如果强制加上 `=default` 就可以重新获得并使用默认构造函数
+
+```cpp
+class Zoo
+{
+public:
+    Zoo(int i1, int i2) : d1(i1), d2(i2) {}
+    Zoo(const Zoo&) =delete;    // 不允许拷贝构造
+    Zoo(Zoo &&) =default;       // 使用编译器给的
+    Zoo& operator=(const Zoo &) =default;
+    Zoo& operator=(const Zoo&&) =delete;
+    virtual ~Zoo(){}
+private:
+    int d1, d2;
+};
+```
+
+
+```cpp
+class Foo{
+public:
+    Foo(int i) : _i(i) {}
+    Foo() = default;    // 构造函数可以有多个，这里希望编译器提供默认构造
+
+    Foo(const Foo& x) : _i(x._i) {}
+    // Foo(const Foo&) = default;   // Error 拷贝构造函数不可被重载
+    // Foo(const Foo&) = delete;    // Error 拷贝构造函数不可被重载
+
+    Foo& operator=(const Foo& x) {_i = x._i; return *this;}
+    // Foo& operator=(const Foo& x) = default; // Error 赋值不可被重载
+    // Foo& operator=(const Foo& x) = delete;  // Error 赋值不可被重载
+
+    void func1() = default; // Error 不可作为default
+    void func2() = delete;  // ok 不过如果不需要可以不写这个函数…
+
+    ~Foo() = default;
+    // ~Foo() = delete // 可以new不可delete
+};
+```
+
+- `=default` 除了默认成员函数（构造、析构、拷贝、赋值等）之外，其他函数使用编译报错（很明显，其他函数也没有所谓的默认）
+- `=delete`可以用在任何函数上（`=0`只能用于`virtual`函数）
+
+> 一般而言，如果成员对象中存在指针，建议考虑深拷贝、浅拷贝的问题，需要自定义拷贝、赋值函数
+
+## Alias Templat (template typedef)化名模板
+
+```cpp
+template<typename T>
+using Vec = std::vector<T, MyAlloc<T>>;
+
+Vec<int> coll; // = std::vector<int, MyAlloc<int> coll;
+```
+
+## decltype
+
+使用该关键字可以找到表达式的参数类型
+
+```cpp
+map<string, float> coll;
+decltype(coll)::value_type elem;    // C++11可以通过对象使用
+map<string,float>::value_type elem; // C++11之前必须指明类型使用
+
+template<typename T1, typename T2>
+auto add(T1 x, T2 y) -> decltype(x+y);  // 通过decltype动态设置返回参数类型
+
+decltype(x+y) add(T1 x, T2 y);      // 这样写报错，因为decltype先不知道x、y是什么，在后面的函数参数中才知道
+
+auto cmp = [](const Person& p1, const Person& p2){
+    // 比较大小
+};
+std::set<Person, decltype(cmp)> coll(cmp);
+```
+
+## lambda表达式
+
+```cpp
+[]{
+    std::cout << "hello world" << std::endl;
+}(); // 输出 hello world
+
+auto l = []{
+    std::cout << "hello world" << std::endl;
+};
+l();// 输出 hello world
+
+[导入器](参数) mutable 异常 -> 返回类型 {
+    函数体
+}
+
+```
+
+> 导入器，取用的外部变量（传值、传引用）  
+> 参数，正常函数参数  
+> mutable 是否可以修改值  
+> 异常 一些特殊操作抛出异常  
+
+```cpp
+{
+    int id = 0;
+    // 值传递
+    auto f = [id]() mutable {
+        std::cout << "id : " << id << std::endl;
+        ++id;// 如果没有mutable，则id不可执行++操作
+    };
+
+    id = 42;
+    f();                            // 输出 id : 0
+    f();                            // 输出 id : 1
+    f();                            // 输出 id : 2
+    std::cout << id << std::endl;   // 输出 id : 42
+}
+
+{
+    int id = 0;
+    // 引用传递
+    auto f = [&id](int param)  {
+        std::cout << "id : " << id << std::endl;
+        ++id; ++param;
+    };
+
+    id = 42;
+    f(7);                            // 输出 id : 42
+    f(7);                            // 输出 id : 43
+    f(7);                            // 输出 id : 44
+    std::cout << id << std::endl;   // 输出 id : 45
+}
+
+{
+    int id = 0;
+    auto f = [id]() {
+        std::cout << "id : " << id << std::endl;
+        ++id;
+    };
+    // 报错 没有mutable 不可更改
+    id = 42;
+    f();                           
+    f();                           
+    f();                           
+    std::cout << id << std::endl;  
+}
+
+// 一个 = 表示 其他所有对象都是值传递， id为引用传递
+auto f = [=, &id]{ 
+    // ...
+};
+```