c++编程规范 C++语言之父Bjarne Stroustrup

╰+哭是因爲堅強的太久メ 2023-06-28 08:46 21阅读 0赞

[C++ Core Guidelines (Bjarne Stroustrup Herb Sutter)][C_ Core Guidelines _Bjarne Stroustrup Herb Sutter]

很多简单的我就不翻译不描述了  
还有很多也是primer++里面经常有描述的我也就没翻译描述

下面很多地方说什么`GSL`  
[GSL: Guidelines support library指的是这个][GSL_ Guidelines support library]

### P: Philosophy ###

*  见名思意
 *  尽量使用标准库
 *  可以编译时检查的尽量编译时检查 比如使用static\_assert等等
 *  资源一定要释放
 *  const的合理使用
 *  使用合适的工具以及一些工具库避免重复造轮子

--------------------

###### P.1: Express ideas directly in code ######

`所见即所得 代码要见名思意`

class Date { 
    public:
        Month month() const;  // do
        int month();          // don't
        // ...
    };
    
    1. const 成员函数
    2. 返回值问题 int可能隐士构造一个Month 直接返回Month更优

// bad example
    void f(vector<string>& v)
    { 
        string val;
        cin >> val;
        // ...
        int index = -1;                    // bad, plus should use gsl::index
        for (int i = 0; i < v.size(); ++i) { 
            if (v[i] == val) { 
                index = i;
                break;
            }
        }
        // ...
    }
    
    // good example
    void f(vector<string>& v)
    { 
        string val;
        cin >> val;
        // ...
        auto p = find(begin(v), end(v), val);  // better
        // ...
    }
    
    1. 一个好的设计是表现出意图而不是做了什么
    2. 编程人员需要知道基本的c++标准库或使用的库提供了哪些功能以及本身项目提供了哪些基础接口 尽量使用这些接口
    3. 这里的第一个f函数不过是std::find的一个受限制版本

change_speed(double s);   // bad: what does s signify?
    // ...
    change_speed(2.3);
    
    change_speed(Speed s);    // better: the meaning of s is specified
    // ...
    change_speed(2.3);        // error: no unit
    change_speed(23m / 10s);  // meters per second
    
    1. 第一个接收double不明确是接收的绝度速度还是delta速度差意义不明

Enforcement Very hard in general.

*  成员函数以及参数对const的使用
 *  casts的类型转换
 *  尽量使用标准库而不是使用语言特性进行硬编码 参见第二个例子

###### P.2: Write in ISO Standard C++ ######

`尽量使用标准库`

###### P.3: Express intent ######

`表达意图`

// bad
    gsl::index i = 0;
    while (i < v.size()) { 
        // ... do something with v[i] ...
    }
    
    // Better
    for (const auto& x : v) {  /* do something with the value of x */ }
    
    for (auto& x : v) {  /* modify x */ }
    
    for_each(v, [](int x) {  /* do something with the value of x */ });
    for_each(par, v, [](int x) {  /* do something with the value of x */ });
    
    1. 第一种文档上这样描述的
    	1.1 便利v的元素进行处理的意图并没有表现出来
    	1.2 直接使用语言特性尽心编码 索引的实现细节被公开 可能会导致滥用
    	1.3 索引idx超出了循环范围 可能是是在循环体内部有意的 也可能是无意的 因此这里无法猜测确定其意图(1.1)
    2. 最后一个foreach明确的表达了我们对v元素的顺序不关心
    3. 还是尽量使用标准库吧

###### P.4: Ideally, a program should be statically type safe ######

`静态类型安全 但是做到这一点基本不可能`  
`以下几个方面可能是一系列问题的来源 后面有建议用一些其他技术代替`

1.  unions(联合体) - use variant(c++17)
2.  casts(类型转换) - 使用模板或者其他方式减少使用
3.  array decay - 使用 span (from the GSL)
4.  range erros - 使用 span
5.  narrowing conversions - 尽量减少使用 在必要的地方使用 narrow 或者 narrow\_cast (from the GSL)

###### P.5: Prefer compile-time checking to run-time checking ######

`比起运行时检查 编译时检查跟优`

// Int is an alias used for integers
    int bits = 0;         // don't: avoidable code
    for (Int i = 1; i; i <<= 1)
        ++bits;
    if (bits < 32)
        cerr << "Int too small\n";
    
    // Int is an alias used for integers
    static_assert(sizeof(Int) >= 4);    // do: compile-time check
    
    1. 使用static_assert的编译时检查更好
    2. 或者使用int32_t替代int

// bad
    void read(int* p, int n);   // read max n integers into *p
    
    int a[100];
    read(a, 1000);    // bad, off the end
    
    // better
    void read(span<int> r); // read into the range of integers r
    
    int a[100];
    read(a);        // better: let the compiler figure out the number of elements

Enforcement

1.  检查指针参数 `Look for pointer arguments.`
2.  检查运行时的range合法性检查 `Look for run-time checks for range violations.`

###### P.6: What cannot be checked at compile time should be checkable at run time ######

`只能在运行时检查的不要再编译时检查`  
还是尽量使用标准库

// separately compiled, possibly dynamically loaded
    extern void f(int* p);
    
    void g(int n)
    { 
        // bad: the number of elements is not passed to f()
        f(new int[n]);
    }
    
    1. 没有传递大小
    2. 可能没有delete
    
    // separately compiled, possibly dynamically loaded
    extern void f2(int* p, int n);
    
    void g2(int n)
    { 
        f2(new int[n], m);  // bad: a wrong number of elements can be passed to f()
    }
    
    1. 传递了错误的大小
    2. 可能没有delete
    
    // Example, bad The standard library resource management pointers fail to pass the size when they point to an object
    // 当标准库资源对象管理指针指向一个对象时无法传递大小 例子如下
    
    // separately compiled, possibly dynamically loaded
    // NB: this assumes the calling code is ABI-compatible, using a
    // compatible C++ compiler and the same stdlib implementation
    extern void f3(unique_ptr<int[]>, int n);
    
    void g3(int n)
    { 
        f3(make_unique<int[]>(n), m);    // bad: pass ownership and size separately
    }
    
    //
    vector<int> f5(int n)    // OK: move
    { 
        vector<int> v(n);
        // ... initialize v ...
        return v;
    }
    
    1.正确的OK
    
    unique_ptr<int[]> f6(int n)    // bad: loses n
    { 
        auto p = make_unique<int[]>(n);
        // ... initialize *p ...
        return p;
    }
    
    1. 不能返回大小n
    
    owner<int*> f7(int n)    // bad: loses n and we might forget to delete
    { 
        owner<int*> p = new int[n];
        // ... initialize *p ...
        return p;
    }
    
    1. 可能未delete泄露

// Example We need to pass the pointer and the number of elements as an integral object
    // 正确的应该是将指针和大小当做一个完整对象传递 比如用vector span 等等标准库结构
    
    extern void f4(vector<int>&);   // separately compiled, possibly dynamically loaded
    extern void f4(span<int>);      // separately compiled, possibly dynamically loaded
                                    // NB: this assumes the calling code is ABI-compatible, using a
                                    // compatible C++ compiler and the same stdlib implementation
    
    void g3(int n)
    { 
        vector<int> v(n);
        f4(v);                     // pass a reference, retain ownership
        f4(span<int>{ v});          // pass a view, retain ownership
    }

###### P.7: Catch run-time errors early ######

`尽早进行合法性检查`  
Enforcement  
Look at pointers and arrays: Do range-checking early and not repeatedly  
`检查指针和数组的有效性`  
Look at conversions: Eliminate or mark narrowing conversions  
`尽量减少或者标记narrowing conversions`  
Look for unchecked values coming from input  
`检查输入合法性`  
Look for structured data (objects of classes with invariants) being converted into strings  
`检查转变成string的结构化数据(具有不变性的类对象)`

###### P.8: Don’t leak any resources ######

`一定要释放资源`  
Enforcement

1.  检查指针
2.  检查new和delete
3.  检查一直的可以分配资源返回原始指针的操作比如fopen malloc strdup等操作

###### P.9: Don’t waste time or space ######

`尽量高效`

// Example, bad
    void lower(zstring s)
    { 
        for (int i = 0; i < strlen(s); ++i) s[i] = tolower(s[i]);
    }
    
    1. 每次循环都会对strlen求值 假设在lower函数不改变长度 可以在循环外部对strlen求值

###### P.10: Prefer immutable data to mutable data ######

`相比可变数据优先选择不可变数据`

###### P.11: Encapsulate messy constructs, rather than spreading through the code ######

`封装混乱的结构 避免代码分散 纯看自己面向对象设计能力ggg`

###### P.12: Use supporting tools as appropriate ######

`适当使用辅助工具`

###### P.13: Use support libraries as appropriate ######

`适当使用合适的工具库`

--------------------

### I: Interfaces ###

###### I.1: Make interfaces explicit ######

int round(double d)
    { 
        return (round_up) ? ceil(d) : d;    // don't: "invisible" dependency
    }
    依赖全局变量

*  一个函数不应该基于在名字空间范围内声明的变量的值来控制决策流
 *  一个函数不应该在写入在名字空间范围内声明的变量
 *  可以抛出异常 不能忽略异常

###### I.2: Avoid non-const global variables ######

*  因为非cosnt全局变量会有不可预知的修改 很容易gg
 *  这规则也适用于名字空间的变量 毕竟同样会有不可预知的修改
 *  注意这里是尽量避免 并不是不可以使用

###### I.3: Avoid singletons ######

*  避免单例 因为这其实和`I.2`理解为一个复杂的全局对象
 *  还有很多其他复杂的理由
 *  同理该用还是要用

###### I.4: Make interfaces precisely and strongly typed ######

*  精确的创建强类型的接口 其实还是给函数参数一个好的类型以及参数名字和注释`见名思意`
 *  不会传一个参数猜来猜去什么意思

###### I.5: State preconditions (if any) ######

###### I.6: Prefer Expects() for expressing preconditions ######

先决条件  
`Expects`是`GSL库`的东西

int area(int height, int width)
    { 
        Expects(height > 0 && width > 0);            // good
        if (height <= 0 || width <= 0) my_error();   // obscure
        // ...
    }

###### I.7: State postconditions ######

###### I.8: Prefer Ensures() for expressing postconditions ######

后置条件  
后置条件也有很多种方式 比如 if assert 等等 建议使用 Ensures()

Example, bad
    
    Consider a famous security bug:
    
    void f()    // problematic
    { 
        char buffer[MAX];
        // ...
        memset(buffer, 0, sizeof(buffer));
    }
    
    There was no postcondition stating that the buffer should be cleared and the optimizer eliminated the apparently redundant memset() call:
    
    void f()    // better
    { 
        char buffer[MAX];
        // ...
        memset(buffer, 0, sizeof(buffer));
        Ensures(buffer[0] == 0);
    }

###### I.9: If an interface is a template, document its parameters using concepts ######

还是见名思意等等

###### I.10: Use exceptions to signal a failure to perform a required task ######

对于必要的任务 可以抛出异常 上面有说过 异常不可忽略 可以被抛出  
这很明显对比必要的任务失败了 需要告知失败 而不是隐藏问题

###### I.11: Never transfer ownership by a raw pointer (T\*) or reference (T&) ######

暂时不太清楚ownership是个啥 跳过

###### I.12: Declare a pointer that must not be null as not\_null ######

not\_null 也是GSL库的玩意

int length(const char* p);            // it is not clear whether length(nullptr) is valid
    
    length(nullptr);                      // OK?
    
    int length(not_null<const char*> p);  // better: we can assume that p cannot be nullptr
    
    int length(const char* p);            // we must assume that p can be nullptr

###### I.13: Do not pass an array as a single pointer ######

还是推荐用`GSL`的span

Example
    
    Consider:
    
    void copy_n(const T* p, T* q, int n); // copy from [p:p+n) to [q:q+n)
    
    q可能不足n位导致错误异常
    
    What if there are fewer than n elements in the array pointed to by q? Then, we overwrite some probably unrelated memory. What if there are fewer than n elements in the array pointed to by p? Then, we read some probably unrelated memory. Either is undefined behavior and a potentially very nasty bug.
    Alternative
    
    Consider using explicit spans:
    
    void copy(span<const T> r, span<T> r2); // copy r to r2

###### I.22: Avoid complex initialization of global objects ######

复杂的初始化会导致未定义的执行顺序 就是会有比较多恶心的初始化顺序问题 不建议这样处理

// file1.c
    
    extern const X x;
    
    const Y y = f(x);   // read x; write y
    
    // file2.c
    
    extern const Y y;
    
    const X x = g(y);   // read y; write x

###### I.23: Keep the number of function arguments low ######

函数参数尽量少一点 参数过多 极其容易混淆

*  抽象封装做的不够好 实际上可能几个参数可以组合为一个对象
 *  参数太多也肯有可能违背了函数的单一原则 这函数可能做的事情太多 大概率会被重构

###### I.24: Avoid adjacent unrelated parameters of the same type ######

避免相邻不相关的同类型参数 即使很容易搞混  
还有一些其他的例子 其实也还是建议用GSL的span 就不在这里写了

Example, bad
    
    Consider:
    
    void copy_n(T* p, T* q, int n);  // copy from [p:p + n) to [q:q + n)
    
    This is a nasty variant of a K&R C-style interface. It is easy to reverse the “to” and “from” arguments.
    
    很容易把p和q那个是from那个是to搞混 将p用const表示成from
    
    Use const for the “from” argument:
    
    void copy_n(const T* p, T* q, int n);  // copy from [p:p + n) to [q:q + n)

###### I.25: Prefer abstract classes as interfaces to class hierarchies ######

尽量使用抽象类作为接口

###### I.26: If you want a cross-compiler ABI, use a C-style subset ######

###### I.27: For stable library ABI, consider the Pimpl idiom ######

###### I.30: Encapsulate rule violations ######

--------------------

### F: Functions ###

###### F.1: “Package” meaningful operations as carefully named functions ######

见名思意

###### F.2: A function should perform a single logical operation ######

单一职责

###### F.3: Keep functions short and simple ######

简单简洁就是美 不要绕来绕去

###### F.4: If a function may have to be evaluated at compile time, declare it constexpr ######

使用常量表达式constexpr

###### F.5: If a function is very small and time-critical, declare it inline ######

小函数内联可以减少函数调用开销

###### F.6: If your function may not throw, declare it noexcept ######

如果函数不会抛出异常 可以指明 noexcept 因为编译器可能会为可能出现的异常做一些额外的处理

###### F.7: For general use, take T\* or T& arguments rather than smart pointers ######

这意思是通常情况避免使用智能指针 智能指针会增加运行时开销 但是智能指针确实有其优势该用的时候还是要用的

###### F.8: Prefer pure functions ######

###### F.9: Unused parameters should be unnamed ######

不使用的参数不需要命名

###### F.15: Prefer simple and conventional ways of passing information ######

使用简单且传统的参数传递方式 使用过多的一些技巧或者特性会增加理解成本且易错

###### F.16: For “in” parameters, pass cheaply-copied types by value and others by reference to const ######

简单的参数可以值传递 其他的尽量const &可以避免拷贝和对原实参的修改

###### F.17: For “in-out” parameters, pass by reference to non-const ######

可以使用非const引用进行更多信息的返回

###### F.18: For “will-move-from” parameters, pass by X&& and std::move the parameter ######

合理利用右值引用和std::move函数减少开销

void sink(vector<int>&& v) {    // sink takes ownership of whatever the argument owned
        // usually there might be const accesses of v here
        store_somewhere(std::move(v));
        // usually no more use of v here; it is moved-from
    }

###### F.19: For “forward” parameters, pass by TP&& and only std::forward the parameter ######

右值引用和forward可以完美的保持实参的原类型 可以进行参数的传递

###### F.20: For “out” output values, prefer return values to output parameters ######

可以用return返回值时 就没必要用引用将结果带出 因为引用既可以是 in\_out 也可以是 out\_only 比较容易混淆这引用  
到底是纯输入还是输入输出都算还是仅输出 可以用return值是用return  
非要返回多个值 也可以用`tuple`类型

// OK: return pointers to elements with the value x
    vector<const int*> find_all(const vector<int>&, int x);
    
    // Bad: place pointers to elements with value x in-out
    void find_all(const vector<int>&, vector<const int*>& out, int x);

###### F.21: To return multiple “out” values, prefer returning a struct or tuple ######

差不多同上 可以用struct或者tuple返回多个数据

###### F.22: Use T\* or owner<T\*> to designate a single object ######

这里不是很明白 跳过吧 可以自己去原文看看

###### F.23: Use a not\_null to indicate that “null” is not a valid value ######

如果明确已知一个参数不会是null可以用GSL的not\_null

###### F.24: Use a span or a span\_p to designate a half-open sequence ######

使用GSL的span 虽然我还不知道这是个啥

###### F.25: Use a zstring or a not\_null to designate a C-style string ######

还是GSL库

###### F.26: Use a unique\_ptr to transfer ownership where a pointer is needed ######

返回一个函数内部分配内存的指针最好使用智能指针unique\_ptr或者shared\_ptr

###### F.27: Use a shared\_ptr to share ownership ######

###### F.60: Prefer T\* over T& when “no argument” is a valid option ######

允许no argument的建议用T\*因为可以有空指针 但是没有空引用

###### F.42: Return a T\* to indicate a position (only) ######

不知道这ownership是个啥  
That’s what pointers are good for. Returning a T\* to transfer ownership is a misuse.

###### F.43: Never (directly or indirectly) return a pointer or a reference to a local object ######

常见了 不要返回局部变量的指针或者引用

###### F.44: Return a T& when copy is undesirable and “returning no object” isn’t needed ######

还是引用的一些使用避免拷贝 当然引用是没有空引用的 所以上面说 “returning no object” isn’t needed 有空可能的话只能`F.60`用指针了

###### F.45: Don’t return a T&& ######

不要返回右值引用 右值引用马上会被销毁

###### F.46: int is the return type for main() ######

###### F.47: Return T& from assignment operators ######

###### F.48: Don’t return std::move(local) ######

###### F.50: Use a lambda when a function won’t do (to capture local variables, or to write a local function) ######

###### F.51: Where there is a choice, prefer default arguments over overloading ######

###### F.52: Prefer capturing by reference in lambdas that will be used locally, including passed to algorithms ######

###### F.53: Avoid capturing by reference in lambdas that will be used non-locally, including returned, stored on the heap, or passed to another thread ######

###### F.54: If you capture this, capture all variables explicitly (no default capture) ######

使用=后者&捕获全部时 也会捕获this不太建议这样处理 最好显示指定怎么捕获

class My_class { 
        int x = 0;
        // ...
    
        void f() { 
            int i = 0;
            // ...
    
            auto lambda = [=]{  use(i, x); };   // BAD: "looks like" copy/value capture
            // [&] has identical semantics and copies the this pointer under the current rules
            // [=,this] and [&,this] are not much better, and confusing
    
            x = 42;
            lambda(); // calls use(0, 42);
            x = 43;
            lambda(); // calls use(0, 43);
    
            // ...
    
            auto lambda2 = [i, this]{  use(i, x); }; // ok, most explicit and least confusing
    
            // ...
        }
    };

###### F.55: Don’t use va\_arg arguments ######

不要使用可变参这想想就很麻烦 不过实际上文档不是这么解释的哈 自己去看吧

--------------------

### C: Classes and class hierarchies ###

###### C.1: Organize related data into structures (structs or classes) ######

没哈好说的 良好的封装

###### C.2: Use class if the class has an invariant; use struct if the data members can vary independently ######

酌情使用 class struct

*  尽量数据自由
 *  少暴露成员
 *  接口一般类的前面 方便一些
 *  避免protect数据

###### C.3: Represent the distinction between an interface and an implementation using a class ######

注意接口和实现的区别 在设计模式中也有面向接口不要面向实现

###### C.4: Make a function a member only if it needs direct access to the representation of a class ######

仅仅需要直接访问class的函数才定义为成员函数 这些不需要直接访问的定义为普通函数比成员函数可以减少耦合

###### C.5: Place helper functions in the same namespace as the class they support ######

类相关工具函数辅助函数与类在用一个命名空间

###### C.7: Don’t define a class or enum and declare a variable of its type in the same statement ######

不要再定义class或者enun的时候同时定义变量

###### C.8: Use class rather than struct if any member is non-public ######

###### C.9: Minimize exposure of members ######

减少成员的暴露 protecct并不是一个什么很友好的方案尽量避免protect

###### `C.concrete: Concrete types` ######

###### C.10: Prefer concrete types over class hierarchies ######

###### C.11: Make concrete types regular ######

具体类比类层次结构更好 具体类最好常规一些不要搞奇淫巧技 增长理解维护成本也易错  
还是看封装抽象设计

###### `C.ctor: Constructors, assignments, and destructors` ######

*  a default constructor: X()
 *  a copy constructor: X(const X&)
 *  a copy assignment: operator=(const X&)
 *  a move constructor: X(X&&)
 *  a move assignment: operator=(X&&)
 *  a destructor: ~X()

###### `C.defop: Default Operations` ######

###### C.20: If you can avoid defining default operations, do ######

不需要定义默认构造函数的情况 就没必要搞一个

###### C.21: If you define or =delete any default operation, define or =delete them all ######

定义了一个删除 最好全部定义为删除 也可以=default  
最好入`C.22`保持一致

###### C.22: Make default operations consistent ######

默认操作保持一致

###### `C.dtor: Destructors` ######

###### C.30: Define a destructor if a class needs an explicit action at object destruction ######

必要时定义析构函数

###### C.31: All resources acquired by a class must be released by the class’s destructor ######

记住释放资源

###### C.32: If a class has a raw pointer (T\*) or reference (T&), consider whether it might be owning ######

时刻牢记T\*和T&的所有权

###### C.33: If a class has an owning pointer member, define a destructor ######

还是要注意释放

###### C.35: A base class destructor should be either public and virtual, or protected and non-virtual ######

基类class的析构函数virtual和public最好

###### C.36: A destructor may not fail ######

析构函数不能失败 意思是要我们表明 `noexcept` 可以看到下一条规则就是这

###### C.37: Make destructors noexcept ######

###### `C.ctor: Constructors` ######

###### C.40: Define a constructor if a class has an invariant ######

###### C.41: A constructor should create a fully initialized object ######

构造函数一定要构造一个完整初始化的对象 保证可用 不知道这点有啥好单独说的

###### C.42: If a constructor cannot construct a valid object, throw an exception ######

构造函数无法构造失败的话 直接抛出异常 很明显构造函数的异常不能忽略 比如在构造函数openfile失败 可以抛出异常而不是隐藏问题

###### C.43: Ensure that a copyable (value type) class has a default constructor ######

可以拷贝的话提供一个默认构造函数

###### C.44: Prefer default constructors to be simple and non-throwing ######

构造函数尽量简单

###### C.45: Don’t define a default constructor that only initializes data members; use in-class member initializers instead ######

仅仅是初始化数据的构造函数 完全可以用类内初始值

###### C.46: By default, declare single-argument constructors explicit ######

单参数的构造函数声明为 explicit 避免隐式的转换

###### C.47: Define and initialize member variables in the order of member declaration ######

实际初始化的顺序是声明的顺序而不是初始化的时候你写的顺序 所以建议这俩顺序保持一致

###### C.48: Prefer in-class initializers to member initializers in constructors for constant initializers ######

还是建议使用类内初始值

###### C.49: Prefer initialization to assignment in constructors ######

建议使用初始化列表

###### C.50: Use a factory function if you need “virtual behavior” during initialization ######

使用工厂函数 但是没法直接在构造函数调用虚函数(原因这里不解释罗) 下面是一个文档里面的示例

class B { 
    protected:
        class Token { };
    
    public:
        explicit B(Token) {  /* ... */ }  // create an imperfectly initialized object
        virtual void f() = 0;
    
        template<class T>
        static shared_ptr<T> create()    // interface for creating shared objects
        { 
            auto p = make_shared<T>(typename T::Token{ });
            p->post_initialize();
            return p;
        }
    
    protected:
        virtual void post_initialize()   // called right after construction
            {  /* ... */ f(); /* ... */ } // GOOD: virtual dispatch is safe
    };
    
    class D : public B {                  // some derived class
    protected:
        class Token { };
    
    public:
        explicit D(Token) : B{  B::Token{ } } { }
        void f() override {  /* ... */ };
    
    protected:
        template<class T>
        friend shared_ptr<T> B::create();
    };
    
    shared_ptr<D> p = D::create<D>();  // creating a D object

###### C.51: Use delegating constructors to represent common actions for all constructors of a class ######

共同的操作可以委托给同一个函数

###### C.52: Use inheriting constructors to import constructors into a derived class that does not need further explicit initialization ######

###### `C.copy: Copy and move` ######

###### C.60: Make copy assignment non-virtual, take the parameter by const&, and return by non-const& ######

###### C.61: A copy operation should copy ######

###### C.62: Make copy assignment safe for self-assignment ######

在primer++里面说了很多次 要保证自我赋值正确

###### C.63: Make move assignment non-virtual, take the parameter by &&, and return by non-const & ######

###### C.64: A move operation should move and leave its source in a valid state ######

###### C.65: Make move assignment safe for self-assignment ######

###### C.66: Make move operations noexcept ######

move操作需要标明 noexcept 这里书上也有说

###### C.67: A polymorphic class should suppress copying ######

多态的话避免提供拷贝构造很赋值运算符 `一旦以外的出现非引用的值传递 拷贝就可能只拷贝派生类的部分基类数据`  
后面又说建议使用`clone() C.130`

###### `C.other: Other default operation rules` ######

###### C.80: Use =default if you have to be explicit about using the default semantics ######

使用default 而不是直接定义一个和default一样的玩意

###### C.81: Use =delete when you want to disable default behavior (without wanting an alternative) ######

使用delete

###### C.82: Don’t call virtual functions in constructors and destructors ######

构造函数和析构函数中不要使用虚函数 这点primerc++有说明

###### C.83: For value-like types, consider providing a noexcept swap function ######

考虑提供swap函数 书上也有说明

###### C.84: A swap function may not fail ######

###### C.85: Make swap noexcept ######

###### C.86: Make == symmetric with respect to operand types and noexcept ######

###### C.87: Beware of == on base classes ######

###### C.89: Make a hash noexcept ######

这个其实c++primer也有说明

###### C.90: Rely on constructors and assignment operators, not memset and memcpy ######

信赖构造函数和赋值运算符 而不是使用 memset memcpy

###### `C.con: Containers and other resource handles` ######

###### C.100: Follow the STL when defining a container ######

定义容器进来那个遵循STL的规则 毕竟很多地方以STL为基准

###### C.101: Give a container value semantics ######

给出容器定义语义

###### C.102: Give a container move operations ######

尽量给容器一个移动构造函数 不然容器过大拷贝移动代价都很昂贵 诱导使用指针而陷入资源管理问题

###### C.103: Give a container an initializer list constructor ######

给容器初始化列表的构造函数

###### C.104: Give a container a default constructor that sets it to empty ######

给容器一个默认的构造函数将其置空

###### C.109: If a resource handle has pointer semantics, provide \* and -> ######

资源管理指针时 可以提供`*`和`->`方便使用

--------------------

这文档是在是太多了 是在是看不去了  
这文档是在是太多了 是在是看不去了  
这文档是在是太多了 是在是看不去了  
这文档是在是太多了 是在是看不去了  
这文档是在是太多了 是在是看不去了  
这文档是在是太多了 是在是看不去了  
这文档是在是太多了 是在是看不去了  
这文档是在是太多了 是在是看不去了  
这文档是在是太多了 是在是看不去了

这个后面的更新随缘吧  
这个后面的更新随缘吧  
这个后面的更新随缘吧  
这个后面的更新随缘吧  
这个后面的更新随缘吧  
这个后面的更新随缘吧

大概率不会更新了  
大概率不会更新了  
大概率不会更新了  
大概率不会更新了  
大概率不会更新了  
大概率不会更新了  
大概率不会更新了  
大概率不会更新了

哈哈一下  
哈哈一下  
哈哈一下  
哈哈一下  
哈哈一下  
哈哈一下  
哈哈一下

[C_ Core Guidelines _Bjarne Stroustrup Herb Sutter]: http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#S-philosophy
[GSL_ Guidelines support library]: https://github.com/Microsoft/GSL