english

english/basic_content/abstract/README.md

@@ -0,0 +1,140 @@
+# 纯虚函数和抽象类
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+## 1.纯虚函数与抽象类
+
+C++中的纯虚函数(或抽象函数)是我们没有实现的虚函数！我们只需声明它! 通过声明中赋值0来声明纯虚函数！
+```cpp
+// 抽象类
+Class A {
+public: 
+    virtual void show() = 0; // 纯虚函数
+    /* Other members */
+}; 
+```
+
+ * 纯虚函数：没有函数体的虚函数
+ * 抽象类：包含纯虚函数的类
+
+抽象类只能作为基类来派生新类使用，不能创建抽象类的对象,抽象类的指针和引用->由抽象类派生出来的类的对象！
+
+> 代码样例：[test.cpp](./test.cpp)、[pure_virtual.cpp](./pure_virtual.cpp)
+
+## 2.实现抽象类
+
+抽象类中：在成员函数内可以调用纯虚函数，在构造函数/析构函数内部不能使用纯虚函数。
+
+如果一个类从抽象类派生而来，它必须实现了基类中的所有纯虚函数，才能成为非抽象类。
+```cpp
+// A为抽象类
+class A {
+public:
+    virtual void f() = 0;  // 纯虚函数
+    void g(){ this->f(); }
+    A(){}  // 构造函数
+};
+
+class B : public A{
+public:
+    void f(){ cout<<"B:f()"<<endl;}  // 实现了抽象类的纯虚函数
+};
+```
+
+> 代码样例：[abstract.cpp](./abstract.cpp)
+
+## 3.重要点
+
+- [纯虚函数使一个类变成抽象类](./interesting_facts1.cpp)
+```cpp
+// 抽象类至少包含一个纯虚函数
+class Base{
+public: 
+    virtual void show() = 0; // 纯虚函数
+    int getX() { return x; } // 普通成员函数
+
+private:
+     int x; 
+}; 
+```
+
+- [抽象类类型的指针和引用](./interesting_facts2.cpp)
+```cpp
+class Derived : public Base { 
+public: 
+    void show() { cout << "In Derived \n"; } // 实现抽象类的纯虚函数
+    Derived(){} // 构造函数
+}; 
+
+int main(void) 
+{ 
+    //Base b;  // error! 不能创建抽象类的对象
+    //Base *b = new Base(); error!
+    
+    Base *bp = new Derived(); // 抽象类的指针和引用 -> 由抽象类派生出来的类的对象
+    bp->show();
+    return 0; 
+}
+```
+
+- [如果我们不在派生类中覆盖纯虚函数，那么派生类也会变成抽象类](./interesting_facts3.cpp)
+```cpp
+// Derived为抽象类
+class Derived: public Base 
+{ 
+public: 
+//    void show() {}
+}; 
+```
+
+- [抽象类可以有构造函数](./interesting_facts4.cpp)
+```cpp
+// 抽象类
+class Base { 
+    protected: 
+        int x; 
+    public: 
+        virtual void fun() = 0; 
+        Base(int i) { x = i; }  // 构造函数
+}; 
+// 派生类
+class Derived: public Base 
+{ 
+    int y; 
+public: 
+    Derived(int i, int j) : Base(i) { y = j; } // 构造函数
+    void fun() { cout << "x = " << x << ", y = " << y; }
+}; 
+```
+
+- [构造函数不能是虚函数，而析构函数可以是虚析构函数](./interesting_facts5.cpp)
+```cpp
+// 抽象类
+class Base  {
+public:
+    Base(){ cout << "Constructor: Base" << endl; }
+    virtual ~Base(){ cout << "Destructor : Base" << endl; }
+    
+    virtual void func() = 0;
+};
+
+class Derived: public Base {
+public:
+    Derived(){ cout << "Constructor: Derived" << endl; }
+    ~Derived(){ cout << "Destructor : Derived" << endl;}
+    
+    void func(){cout << "In Derived.func()." << endl;}
+};
+```
+>当基类指针指向派生类对象并删除对象时，我们可能希望调用适当的析构函数。
+> 如果析构函数不是虚拟的，则只能调用基类析构函数。
+
+## 4.完整实例
+
+抽象类由派生类继承实现！
+
+> 代码样例：[derived_full.cpp](./derived_full.cpp)

english/basic_content/abstract/abstract.cpp

@@ -0,0 +1,27 @@
+/**
+ * @file abstract.cpp
+ * @brief 抽象类中：在成员函数内可以调用纯虚函数，在构造函数/析构函数内部不能使用纯虚函数
+ * 如果一个类从抽象类派生而来，它必须实现了基类中的所有纯虚函数，才能成为非抽象类
+ * @author 光城
+ * @version v1
+ * @date 2019-07-20
+ */
+
+#include<iostream>
+using namespace std;
+
+class A {
+public:
+    virtual void f() = 0;  // 纯虚函数
+    void g(){ this->f(); }
+    A(){}
+};
+class B:public A{
+public:
+    void f(){ cout<<"B:f()"<<endl;}
+};
+int main(){
+    B b;
+    b.g();
+    return 0;
+}

english/basic_content/abstract/derived_full.cpp

@@ -0,0 +1,32 @@
+/**
+ * @file derived_full.cpp
+ * @brief 完整示例！抽象类由派生类继承实现！
+ * @author 光城
+ * @version v1
+ * @date 2019-07-20
+ */
+
+#include<iostream> 
+using namespace std; 
+
+class Base 
+{ 
+    int x; 
+    public: 
+    virtual void fun() = 0; 
+    int getX() { return x; } 
+}; 
+
+class Derived: public Base 
+{ 
+    int y; 
+    public: 
+    void fun() { cout << "fun() called"; }  // 实现了fun()函数
+}; 
+
+int main(void) 
+{ 
+    Derived d; 
+    d.fun(); 
+    return 0; 
+} 

english/basic_content/abstract/interesting_facts1.cpp

@@ -0,0 +1,28 @@
+/**
+ * @file interesting_facts1.cpp
+ * @brief 纯虚函数使一个类变成抽象类
+ * @author 光城
+ * @version v1
+ * @date 2019-07-20
+ */
+
+#include<iostream> 
+using namespace std; 
+
+/**
+ * @brief 抽象类至少包含一个纯虚函数
+ */
+class Test 
+{ 
+    int x; 
+public: 
+    virtual void show() = 0; 
+    int getX() { return x; } 
+}; 
+
+int main(void) 
+{ 
+    Test t;  //error! 不能创建抽象类的对象
+    return 0; 
+} 
+

english/basic_content/abstract/interesting_facts2.cpp

@@ -0,0 +1,38 @@
+/**
+ * @file interesting_facts2.cpp
+ * @brief 抽象类类型的指针和引用
+ * @author 光城
+ * @version v1
+ * @date 2019-07-20
+ */
+
+#include<iostream> 
+using namespace std; 
+
+
+/**
+ * @brief 抽象类至少包含一个纯虚函数
+ */
+class Base
+{ 
+    int x; 
+public: 
+    virtual void show() = 0; 
+    int getX() { return x; } 
+    
+}; 
+class Derived: public Base 
+{ 
+public: 
+    void show() { cout << "In Derived \n"; } 
+    Derived(){}
+}; 
+int main(void) 
+{ 
+    //Base b;  //error! 不能创建抽象类的对象
+    //Base *b = new Base(); error!
+    Base *bp = new Derived(); // 抽象类的指针和引用 -> 由抽象类派生出来的类的对象
+    bp->show();
+    return 0; 
+} 
+

english/basic_content/abstract/interesting_facts3.cpp

@@ -0,0 +1,29 @@
+/**
+ * @file interesting_facts3.cpp
+ * @brief 如果我们不在派生类中覆盖纯虚函数，那么派生类也会变成抽象类。
+ * @author 光城
+ * @version v1
+ * @date 2019-07-20
+ */
+
+#include<iostream> 
+using namespace std; 
+
+class Base
+{ 
+    int x; 
+public: 
+    virtual void show() = 0; 
+    int getX() { return x; } 
+}; 
+class Derived: public Base 
+{ 
+public: 
+//    void show() { } 
+}; 
+int main(void) 
+{ 
+    Derived d;  //error! 派生类没有实现纯虚函数，那么派生类也会变为抽象类，不能创建抽象类的对象
+    return 0; 
+} 
+

english/basic_content/abstract/interesting_facts4.cpp

@@ -0,0 +1,35 @@
+/**
+ * @file interesting_facts4.cpp
+ * @brief 抽象类可以有构造函数
+ * @author 光城
+ * @version v1
+ * @date 2019-07-20
+ */
+
+#include<iostream> 
+using namespace std; 
+
+// An abstract class with constructor 
+class Base 
+{ 
+    protected: 
+        int x; 
+    public: 
+        virtual void fun() = 0; 
+        Base(int i) { x = i; } 
+}; 
+
+class Derived: public Base 
+{ 
+    int y; 
+    public: 
+    Derived(int i, int j):Base(i) { y = j; } 
+    void fun() { cout << "x = " << x << ", y = " << y; } 
+}; 
+
+int main(void) 
+{ 
+    Derived d(4, 5); 
+    d.fun(); 
+    return 0; 
+} 

english/basic_content/abstract/interesting_facts5.cpp

@@ -0,0 +1,30 @@
+
+/**
+ * @file interesting_facts5.cpp
+ * @brief 构造函数不能是虚函数，而析构函数可以是虚析构函数。
+ * 例如：当基类指针指向派生类对象并删除对象时，我们可能希望调用适当的析构函数。如果析构函数不是虚拟的，则只能调用基类析构函数。
+ * @author 光城
+ * @version v1
+ * @date 2019-07-20
+ */
+#include<iostream>
+using namespace std;
+
+class Base  {
+    public:
+        Base()    { cout << "Constructor: Base" << endl; }
+        virtual ~Base()   { cout << "Destructor : Base" << endl; }
+};
+
+class Derived: public Base {
+    public:
+        Derived()   { cout << "Constructor: Derived" << endl; }
+        ~Derived()   { cout << "Destructor : Derived" << endl; }
+};
+
+int main()  {
+    Base *Var = new Derived();
+    delete Var;
+    return 0;
+}
+

english/basic_content/abstract/pure_virtual.cpp

@@ -0,0 +1,34 @@
+/**
+ * @file pure_virtual.cpp
+ * @brief 纯虚函数：没有函数体的虚函数
+ * 抽象类：包含纯虚函数的类
+ * 
+ * @author 光城
+ * @version v1
+ * @date 2019-07-20
+ */
+
+#include<iostream>
+
+using namespace std;
+class A
+{
+private:
+    int a;
+public:
+    virtual void show()=0; // 纯虚函数
+};
+
+
+int main()
+{
+    /*
+     * 1. 抽象类只能作为基类来派生新类使用
+     * 2. 抽象类的指针和引用->由抽象类派生出来的类的对象！
+     */
+    A a; // error 抽象类，不能创建对象
+
+    A *a1; // ok 可以定义抽象类的指针
+
+    A *a2 = new A(); // error, A是抽象类，不能创建对象
+}

english/basic_content/abstract/test.cpp

@@ -0,0 +1,23 @@
+/**
+ * @file test.cpp
+ * @brief C++中的纯虚函数(或抽象函数)是我们没有实现的虚函数！我们只需声明它!通过声明中赋值0来声明纯虚函数！
+ * 纯虚函数：没有函数体的虚函数
+ * @author 光城
+ * @version v1
+ * @date 2019-07-20
+ */
+
+
+
+/**
+ * @brief 抽象类
+ */
+class Test 
+{    
+    // Data members of class 
+public: 
+    // Pure Virtual Function 
+    virtual void show() = 0; 
+
+    /* Other members */
+}; 

english/basic_content/assert/README.md

@@ -0,0 +1,61 @@
+# assert那些事
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+
+
+## 1.第一个断言案例
+
+断言，**是宏，而非函数**。
+
+assert 宏的原型定义在 <assert.h>（C）、<cassert>（C++）中。其作用是如果它的条件返回错误，则终止程序执行。
+
+可以通过定义 `NDEBUG` 来关闭 assert，**但是需要在源代码的开头，include <assert.h> 之前。**
+
+```c
+void assert(int expression);
+```
+
+> 代码样例：[assert.c](./assert.c)
+```c
+#include <stdio.h> 
+#include <assert.h> 
+
+int main() 
+{ 
+    int x = 7; 
+
+    /*  Some big code in between and let's say x  
+    is accidentally changed to 9  */
+    x = 9; 
+
+    // Programmer assumes x to be 7 in rest of the code 
+    assert(x==7); 
+
+    /* Rest of the code */
+
+    return 0; 
+} 
+```
+输出：
+```c
+assert: assert.c:13: main: Assertion 'x==7' failed.
+```
+可以看到输出会把源码文件，行号错误位置，提示出来！
+
+## 2.断言与正常错误处理
+
++ 断言主要用于检查逻辑上不可能的情况。
+
+>例如，它们可用于检查代码在开始运行之前所期望的状态，或者在运行完成后检查状态。与正常的错误处理不同，断言通常在运行时被禁用。
+
++ 忽略断言，在代码开头加上：
+```c++
+#define NDEBUG          // 加上这行，则 assert 不可用
+```
+
+> 样例代码：[ignore_assert.c](./ignore_assert.c)

english/basic_content/assert/assert.c

@@ -0,0 +1,18 @@
+#include <stdio.h> 
+#include <assert.h> 
+
+int main() 
+{ 
+    int x = 7; 
+
+    /*  Some big code in between and let's say x  
+     *         is accidentally changed to 9  */
+    x = 9; 
+
+    // Programmer assumes x to be 7 in rest of the code 
+    assert(x==7); 
+
+    /* Rest of the code */
+
+    return 0; 
+} 

english/basic_content/assert/ignore_assert.c

@@ -0,0 +1,17 @@
+/**
+ * @file ignore_assert.c
+ * @brief 忽略断言
+ * @author 光城
+ * @version v1
+ * @date 2019-07-25
+ */
+
+# define NDEBUG // 忽略断言
+
+#include<assert.h>
+
+int main(){
+    int x=7;
+    assert(x==5);
+    return 0;
+}

english/basic_content/bit/README.md

@@ -0,0 +1,177 @@
+## About Author：
+
+
+![](../img/wechat.jpg)
+
+## What is Bit field ？
+
+“ Bit field is a kind of data structure.Data can be stored compactly in bits, And allows the programmer to operate on the bits of this structure. One of the advantages of this data structure is that it can save storage space in data units, which is particularly important when programs need thousands of data units. The second advantage is that bit segments can easily access part of the contents of an integer value, which can simplify the program source code. The disadvantage of this data structure is that bit segment implementation depends on specific machines and systems, and different results may be obtained in different platforms, which leads to the fact that bit segments are not portable in nature
+
+- The layout of bit fields in memory is machine dependent
+- The type of bit field must be integer or enumeration type. The behavior of bit field in signed type depends on the implementation
+- The addressing operator (&) cannot be applied to a bit field, and no pointer can point to a bit field of a class
+
+## Bit field usage
+
+Bit fields usually use struct declarations, which set the name of each bit field member and determine its width:
+
+```
+struct bit_field_name
+{
+	type member_name : width;
+};
+```
+
+
+
+| Elements       | Description                                                  |
+| -------------- | ------------------------------------------------------------ |
+| bit_field_name | Bit field structure name                                     |
+| type           | must be int、signed int or unsigned int type                 |
+| member_name    |                                                              |
+| width          |                                                              |
+
+For example, declare the following bit field:
+
+```
+struct _PRCODE
+{
+	unsigned int code1: 2;
+	unsigned int cdde2: 2;
+	unsigned int code3: 8;
+};
+struct _PRCODE prcode;
+```
+
+This definition makes' prcode 'contain two 2-bit fields and one 8-bit field. We can use the member operator of the structure to assign values to it
+
+```
+prcode.code1 = 0;
+prcode.code2 = 3;
+procde.code3 = 102;
+```
+
+When assigning a value, it should be noted that the size of the value should not exceed the capacity of the bit field member，For example prcode.code3 Is a bit domain member of 8 bits. Its capacity is 2^8 = 256，Assignment range should be [0,255]。
+
+## Size and alignment of bit fields
+
+### Size of bit field
+
+For example, the following bit field：
+
+```
+struct box 
+{
+	unsigned int a: 1;
+	unsigned int  : 3;
+	unsigned int b: 4;
+};
+```
+There is an unnamed bit field in the middle of the bit field structure, which occupies 3 bits and only plays a filling role and has no practical significance. The padding makes the structure use 8 bits in total. But C language uses unsigned int as the basic unit of bit field，Even if the only member of a structure is a bit field of 1 bit, the size of the structure is the same as that of an unsigned int.In some systems, the unsigned int is 16 bits, and in x86 systems it is 32 bits.For the following articles, the default value of unsigned int is 32 bits.
+
+### Alignment of bit fields
+
+A bit field member is not allowed to cross the boundary of two unsigned ints. If the total number of bits declared by a member exceeds the size of an unsigned int, the editor will automatically shift the bit field members to align them according to the boundary of the unsigned int
+
+For example：
+
+```
+struct stuff 
+{
+	unsigned int field1: 30;
+	unsigned int field2: 4;
+	unsigned int field3: 3;
+};
+```
+
+
+
+`field1` + `field2` = 34 Bits，beyond 32 Bits, Complier`field2` move to the next unsigned int unit. stuff.field1 and stuff.field2 will leave the 2 Bits space， stuff.field3 follow closely stuff.field2.The structure is now of size 2 * 32 = 64 Bits。
+
+This hole can be filled with the unnamed bit field member mentioned earlier, or we can use an unnamed bit field member with a width of 0 to align the next field member with the next integer.
+For example:
+
+```
+struct stuff 
+{
+	unsigned int field1: 30;
+	unsigned int       : 2;
+	unsigned int field2: 4;
+	unsigned int       : 0;
+	unsigned int field3: 3; 
+};
+```
+
+
+
+Between stuff.field1 and stuff.field2 there is a 2 Bits space. Stuff.field3 will be stored in the next unsigned in. The size of this structure is 3 * 32 = 96 Bits。
+
+Code：[learn.cpp](learn.cpp)
+
+## Initialization of bit field and remapping of bit
+
+### Initialization
+
+
+The initialization method of bit field is the same as that of ordinary structure. Here, two methods are listed as follows:
+
+```
+struct stuff s1= {20,8,6};
+```
+
+Or directly assign values to the bit field members:
+
+```
+struct stuff s1;
+s1.field1 = 20;
+s1.field2 = 8;
+s1.field3 = 4;
+```
+
+### Re-mapping of bit field
+
+Declare a bit field with a size of 32 bits
+
+```
+struct box {
+	unsigned int ready:     2;
+	unsigned int error:     2;
+	unsigned int command:   4;
+	unsigned int sector_no: 24;
+}b1;
+```
+
+#### Zeroing bit field by remapping
+
+```
+int* p = (int *) &b1;  // 将 "位域结构体的地址" 映射至 "整形（int*) 的地址" 
+*p = 0;                // clear s1, set all members to zero
+```
+
+#### The 32 bits bit field is remapped to the unsigned int type by union
+
+Let's briefly introduce the alliance
+
+> "Union" is a special class and a data structure of construction type.Many different data types can be defined in a "union". Any kind of data defined by the "union" can be loaded into a variable described as the "union" type. These data share the same memory to save space
+>
+> There are some similarities between "union" and "structure". But there are essential differences between them.In a structure, each member has its own memory space. The total length of a structure variable is the sum of the length of each member (except for empty structure, and boundary adjustment is not considered).In Union, members share a certain amount of memory space, and the length of a union variable is equal to the longest length of each member.It should be noted that the so-called sharing does not mean that multiple members are loaded into a joint variable at the same time, but that the joint variable can be assigned any member value, but only one value can be assigned at a time.
+
+We can declare the following Union:
+
+```
+union u_box {
+  struct box st_box;
+  unsigned int ui_box;
+};
+```
+
+
+
+In x86 system, unsigned int and box are 32 Bits, Through this combination, St_ Box and UI_ Box shares a piece of memory.Which bit in the specific bit field corresponds to which bit of the unsigned int depends on the compiler and hardware.Use union to return the bit field to zero. The code is as follows:
+
+```
+union u_box u;
+u.ui_box = 0;
+```
+
+> From：<http://www.yuan-ji.me/C-C-%E4%BD%8D%E5%9F%9F-Bit-fields-%E5%AD%A6%E4%B9%A0%E5%BF%83%E5%BE%97/>

english/basic_content/bit/learn.cpp

@@ -0,0 +1,19 @@
+#include<iostream>
+
+using namespace std;
+struct stuff 
+{
+    unsigned int field1: 30;
+    unsigned int       : 2;
+    unsigned int field2: 4;
+    unsigned int       : 0;
+    unsigned int field3: 3; 
+};
+int main(){
+    struct stuff s={1,3,5};
+    cout<<s.field1<<endl;
+    cout<<s.field2<<endl;
+    cout<<s.field3<<endl;
+    cout<<sizeof(s)<<endl;
+    return 0;
+}

english/basic_content/decltype/README.md

@@ -0,0 +1,138 @@
+# decltype那些事
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+## 1.基本使用
+decltype的语法是:
+
+```
+decltype (expression)
+```
+
+这里的括号是必不可少的,decltype的作用是“查询表达式的类型”，因此，上面语句的效果是，返回 expression 表达式的类型。注意，decltype 仅仅“查询”表达式的类型，并不会对表达式进行“求值”。
+
+
+### 1.1 推导出表达式类型
+
+```
+int i = 4;
+decltype(i) a; //推导结果为int。a的类型为int。
+```
+
+### 1.2 与using/typedef合用，用于定义类型。
+
+```c++
+using size_t = decltype(sizeof(0));//sizeof(a)的返回值为size_t类型
+using ptrdiff_t = decltype((int*)0 - (int*)0);
+using nullptr_t = decltype(nullptr);
+vector<int >vec;
+typedef decltype(vec.begin()) vectype;
+for (vectype i = vec.begin; i != vec.end(); i++)
+{
+//...
+}
+```
+
+这样和auto一样，也提高了代码的可读性。
+
+### 1.3 重用匿名类型
+
+在C++中，我们有时候会遇上一些匿名类型，如:
+
+```c++
+struct 
+{
+    int d ;
+    doubel b;
+}anon_s;
+```
+
+而借助decltype，我们可以重新使用这个匿名的结构体：
+
+```c++
+decltype(anon_s) as ;//定义了一个上面匿名的结构体
+```
+
+### 1.4 泛型编程中结合auto，用于追踪函数的返回值类型
+
+这也是decltype最大的用途了。
+
+```c++
+template <typename T>
+auto multiply(T x, T y)->decltype(x*y)
+{
+	return x*y;
+}
+```
+
+完整代码见：[decltype.cpp](decltype.cpp)
+
+## 2.判别规则
+
+对于decltype(e)而言，其判别结果受以下条件的影响：
+
+如果e是一个没有带括号的标记符表达式或者类成员访问表达式，那么的decltype（e）就是e所命名的实体的类型。此外，如果e是一个被重载的函数，则会导致编译错误。
+否则 ，假设e的类型是T，如果e是一个将亡值，那么decltype（e）为T&&
+否则，假设e的类型是T，如果e是一个左值，那么decltype（e）为T&。
+否则，假设e的类型是T，则decltype（e）为T。
+
+标记符指的是除去关键字、字面量等编译器需要使用的标记之外的程序员自己定义的标记，而单个标记符对应的表达式即为标记符表达式。例如：
+```c++
+int arr[4]
+```
+则arr为一个标记符表达式，而arr[3]+0不是。
+
+举例如下：
+
+```c++
+int i = 4;
+int arr[5] = { 0 };
+int *ptr = arr;
+struct S{ double d; }s ;
+void Overloaded(int);
+void Overloaded(char);//重载的函数
+int && RvalRef();
+const bool Func(int);
+
+//规则一：推导为其类型
+decltype (arr) var1; //int 标记符表达式
+
+decltype (ptr) var2;//int *  标记符表达式
+
+decltype(s.d) var3;//doubel 成员访问表达式
+
+//decltype(Overloaded) var4;//重载函数。编译错误。
+
+//规则二：将亡值。推导为类型的右值引用。
+
+decltype (RvalRef()) var5 = 1;
+
+//规则三：左值，推导为类型的引用。
+
+decltype ((i))var6 = i;     //int&
+
+decltype (true ? i : i) var7 = i; //int&  条件表达式返回左值。
+
+decltype (++i) var8 = i; //int&  ++i返回i的左值。
+
+decltype(arr[5]) var9 = i;//int&. []操作返回左值
+
+decltype(*ptr)var10 = i;//int& *操作返回左值
+
+decltype("hello")var11 = "hello"; //const char(&)[9]  字符串字面常量为左值，且为const左值。
+
+
+//规则四：以上都不是，则推导为本类型
+
+decltype(1) var12;//const int
+
+decltype(Func(1)) var13=true;//const bool
+
+decltype(i++) var14 = i;//int i++返回右值
+```
+
+学习参考：https://www.cnblogs.com/QG-whz/p/4952980.html

english/basic_content/decltype/decltype.cpp

@@ -0,0 +1,60 @@
+/**
+ * @file decltype.cpp
+ * @brief g++ -o decltype decltype.cpp -std=c++11
+ * @author 光城
+ * @version v1
+ * @date 2019-08-08
+ */
+
+#include <iostream>
+#include <vector>
+using namespace std;
+/**
+ * 泛型编程中结合auto，用于追踪函数的返回值类型
+ */
+template <typename T>
+
+auto multiply(T x, T y)->decltype(x*y)
+{
+    return x*y;
+}
+
+int main()
+{
+    int nums[] = {1,2,3,4};
+    vector<int> vec(nums,nums+4);
+    vector<int>::iterator it;
+
+    for(it=vec.begin();it!=vec.end();it++)
+        cout<<*it<<" ";
+    cout<<endl;
+
+
+    using nullptr_t = decltype(nullptr);
+    nullptr_t  nu;
+    int * p =NULL;
+    if(p==nu)
+        cout<<"NULL"<<endl;
+
+
+    typedef decltype(vec.begin()) vectype;
+
+    for(vectype i=vec.begin();i!=vec.end();i++)
+        cout<<*i<<" ";
+    cout<<endl;
+
+    /**
+     * 匿名结构体
+     */
+    struct
+    {
+        int d ;
+        double b;
+    }anon_s;
+
+    decltype(anon_s) as; // 定义了一个上面匿名的结构体
+
+    cout<<multiply(11,2)<<endl;
+
+    return 0;
+}

english/basic_content/explicit/README.md

@@ -0,0 +1,16 @@
+# explicit(显式)关键字那些事
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+- explicit 修饰构造函数时，可以防止隐式转换和复制初始化
+- explicit 修饰转换函数时，可以防止隐式转换，但按语境转换除外
+
+
+代码参见:[.explicit.cpp](./explicit.cpp)
+
+参考链接：
+> https://stackoverflow.com/questions/4600295/what-is-the-meaning-of-operator-bool-const

english/basic_content/explicit/explicit.cpp

@@ -0,0 +1,46 @@
+#include <iostream>
+
+using namespace std;
+
+struct A
+{
+    A(int) { }
+    operator bool() const { return true; }
+};
+
+struct B
+{
+    explicit B(int) {}
+    explicit operator bool() const { return true; }
+};
+
+void doA(A a) {}
+
+void doB(B b) {}
+
+int main()
+{
+    A a1(1);        // OK：直接初始化
+    A a2 = 1;        // OK：复制初始化
+    A a3{ 1 };        // OK：直接列表初始化
+    A a4 = { 1 };        // OK：复制列表初始化
+    A a5 = (A)1;        // OK：允许 static_cast 的显式转换 
+    doA(1);            // OK：允许从 int 到 A 的隐式转换
+    if (a1);        // OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换
+    bool a6(a1);        // OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换
+    bool a7 = a1;        // OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换
+    bool a8 = static_cast<bool>(a1);  // OK ：static_cast 进行直接初始化
+
+    B b1(1);        // OK：直接初始化
+//    B b2 = 1;        // 错误：被 explicit 修饰构造函数的对象不可以复制初始化
+    B b3{ 1 };        // OK：直接列表初始化
+//    B b4 = { 1 };        // 错误：被 explicit 修饰构造函数的对象不可以复制列表初始化
+    B b5 = (B)1;        // OK：允许 static_cast 的显式转换
+//    doB(1);            // 错误：被 explicit 修饰构造函数的对象不可以从 int 到 B 的隐式转换
+    if (b1);        // OK：被 explicit 修饰转换函数 B::operator bool() 的对象可以从 B 到 bool 的按语境转换
+    bool b6(b1);        // OK：被 explicit 修饰转换函数 B::operator bool() 的对象可以从 B 到 bool 的按语境转换
+//    bool b7 = b1;        // 错误：被 explicit 修饰转换函数 B::operator bool() 的对象不可以隐式转换
+    bool b8 = static_cast<bool>(b1);  // OK：static_cast 进行直接初始化
+
+    return 0;
+}

english/basic_content/extern/README.md

@@ -0,0 +1,193 @@
+# extern "C"
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+## 1.C++与C编译区别
+
+在C++中常在头文件见到extern "C"修饰函数，那有什么作用呢？ 是用于C++链接在C语言模块中定义的函数。
+
+C++虽然兼容C，但C++文件中函数编译后生成的符号与C语言生成的不同。因为C++支持函数重载，C++函数编译后生成的符号带有函数参数类型的信息，而C则没有。
+
+例如`int add(int a, int b)`函数经过C++编译器生成.o文件后，`add`会变成形如`add_int_int`之类的, 而C的话则会是形如`_add`, 就是说：相同的函数，在C和C++中，编译后生成的符号不同。
+
+这就导致一个问题：如果C++中使用C语言实现的函数，在编译链接的时候，会出错，提示找不到对应的符号。此时`extern "C"`就起作用了：告诉链接器去寻找`_add`这类的C语言符号，而不是经过C++修饰的符号。
+
+## 2.C++调用C函数
+
+C++调用C函数的例子: 引用C的头文件时，需要加`extern "C"`
+
+```c++
+//add.h
+#ifndef ADD_H
+#define ADD_H
+int add(int x,int y);
+#endif
+
+//add.c
+#include "add.h"
+
+int add(int x,int y) {
+    return x+y;
+}
+
+//add.cpp
+#include <iostream>
+#include "add.h"
+using namespace std;
+int main() {
+    add(2,3);
+    return 0;
+}
+```
+
+编译：
+
+```
+//Generate add.o file
+gcc -c add.c
+```
+
+链接：
+
+```
+g++ add.cpp add.o -o main
+```
+
+没有添加extern "C" 报错：
+
+```c++
+> g++ add.cpp add.o -o main                                   
+add.o：在函数‘main’中：
+add.cpp:(.text+0x0): `main'被多次定义
+/tmp/ccH65yQF.o:add.cpp:(.text+0x0)：第一次在此定义
+/tmp/ccH65yQF.o：在函数‘main’中：
+add.cpp:(.text+0xf)：对‘add(int, int)’未定义的引用
+add.o：在函数‘main’中：
+add.cpp:(.text+0xf)：对‘add(int, int)’未定义的引用
+collect2: error: ld returned 1 exit status
+```
+
+添加extern "C"后：
+
+`add.cpp`
+
+```c++
+#include <iostream>
+using namespace std;
+extern "C" {
+    #include "add.h"
+}
+int main() {
+    add(2,3);
+    return 0;
+}
+```
+
+编译的时候一定要注意，先通过gcc生成中间文件add.o。
+
+```
+gcc -c add.c 
+```
+
+然后编译：
+
+```
+g++ add.cpp add.o -o main
+```
+
+上述案例源代码见：
+
+- [add.h](extern_c++/add.h)
+
+- [add.c](extern_c++/add.c)
+
+- [add.cpp](extern_c++/add.cpp)
+
+## 2.C中调用C++函数
+
+`extern "C"`在C中是语法错误，需要放在C++头文件中。
+
+```c
+// add.h
+#ifndef ADD_H
+#define ADD_H
+extern "C" {
+    int add(int x,int y);
+}
+#endif
+
+// add.cpp
+#include "add.h"
+
+int add(int x,int y) {
+    return x+y;
+}
+
+// add.c
+extern int add(int x,int y);
+int main() {
+    add(2,3);
+    return 0;
+}
+```
+
+编译：
+
+```c
+g++ -c add.cpp
+```
+
+链接：
+
+```
+gcc add.c add.o -o main
+```
+
+上述案例源代码见：
+
+- [add.h](extern_c/add.h)
+
+- [add.c](extern_c/add.c)
+
+- [add.cpp](extern_c/add.cpp)
+
+综上，总结出使用方法，在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern "C"时会出现编译语法错误。所以使用extern "C"全部都放在于cpp程序相关文件或其头文件中。
+
+总结出如下形式：
+
+（1）C++调用C函数：
+
+```c++
+//xx.h
+extern int add(...)
+
+//xx.c
+int add(){
+    
+}
+
+//xx.cpp
+extern "C" {
+    #include "xx.h"
+}
+```
+
+（2）C调用C++函数
+
+```c
+//xx.h
+extern "C"{
+    int add();
+}
+//xx.cpp
+int add(){
+    
+}
+//xx.c
+extern int add();
+```
+

english/basic_content/extern/extern_c++/add.c

@@ -0,0 +1,5 @@
+#include "add.h"
+
+int add(int x,int y) {
+    return x+y;
+}

english/basic_content/extern/extern_c++/add.cpp

@@ -0,0 +1,9 @@
+#include <iostream>
+using namespace std;
+extern "C" {
+    #include "add.h"
+}
+int main() {
+    add(2,3);
+    return 0;
+}

english/basic_content/extern/extern_c++/add.h

@@ -0,0 +1,4 @@
+#ifndef ADD_H
+#define ADD_H
+extern int add(int x,int y);
+#endif

english/basic_content/extern/extern_c/add.c

@@ -0,0 +1,5 @@
+extern int add(int x,int y);
+int main() {
+    add(2,3);
+    return 0;
+}

english/basic_content/extern/extern_c/add.cpp

@@ -0,0 +1,5 @@
+#include "add.h"
+
+int add(int x,int y) {
+    return x+y;
+}

english/basic_content/extern/extern_c/add.h

@@ -0,0 +1,6 @@
+#ifndef ADD_H
+#define ADD_H
+extern "C" {
+    int add(int x,int y);
+}
+#endif

english/basic_content/friend/README.md

@@ -0,0 +1,115 @@
+# 友元函数与友元类
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+## 0.概述
+
+友元提供了一种 普通函数或者类成员函数 访问另一个类中的私有或保护成员 的机制。也就是说有两种形式的友元：
+
+（1）友元函数：普通函数对一个访问某个类中的私有或保护成员。
+
+（2）友元类：类A中的成员函数访问类B中的私有或保护成员
+
+优点：提高了程序的运行效率。
+
+缺点：破坏了类的封装性和数据的透明性。
+
+总结：
+- 能访问私有成员
+- 破坏封装性
+- 友元关系不可传递
+- 友元关系的单向性
+- 友元声明的形式及数量不受限制
+
+## 1.友元函数
+
+在类声明的任何区域中声明，而定义则在类的外部。
+
+```
+friend <类型><友元函数名>(<参数表>);
+```
+
+注意，友元函数只是一个普通函数，并不是该类的类成员函数，它可以在任何地方调用，友元函数中通过对象名来访问该类的私有或保护成员。
+
+具体代码见：[friend_func.cpp](friend_func.cpp)
+
+```c++
+#include <iostream>
+
+using namespace std;
+
+class A
+{
+public:
+    A(int _a):a(_a){};
+    friend int geta(A &ca);  ///< 友元函数
+private:
+    int a;
+};
+
+int geta(A &ca) 
+{
+    return ca.a;
+}
+
+int main()
+{
+    A a(3);    
+    cout<<geta(a)<<endl;
+
+    return 0;
+}
+```
+
+## 2.友元类
+友元类的声明在该类的声明中，而实现在该类外。
+
+```
+friend class <友元类名>;
+```
+
+类B是类A的友元，那么类B可以直接访问A的私有成员。
+
+具体代码见：[friend_class.cpp](friend_class.cpp)
+```c++
+#include <iostream>
+
+using namespace std;
+
+class A
+{
+public:
+    A(int _a):a(_a){};
+    friend class B;
+private:
+    int a;
+};
+
+class B
+{
+public:
+    int getb(A ca) {
+        return  ca.a; 
+    };
+};
+
+int main() 
+{
+    A a(3);
+    B b;
+    cout<<b.getb(a)<<endl;
+    return 0;
+}
+```
+
+
+## 3.注意
+- 友元关系没有继承性
+假如类B是类A的友元，类C继承于类A，那么友元类B是没办法直接访问类C的私有或保护成员。
+
+- 友元关系没有传递性
+假如类B是类A的友元，类C是类B的友元，那么友元类C是没办法直接访问类A的私有或保护成员，也就是不存在“友元的友元”这种关系。

english/basic_content/friend/friend_class.cpp

@@ -0,0 +1,28 @@
+#include <iostream>
+
+using namespace std;
+
+class A
+{
+public:
+    A(int _a):a(_a){};
+    friend class B;
+private:
+    int a;
+};
+
+class B
+{
+public:
+    int getb(A ca) {
+        return  ca.a; 
+    };
+};
+
+int main() 
+{
+    A a(3);
+    B b;
+    cout<<b.getb(a)<<endl;
+    return 0;
+}

english/basic_content/friend/friend_func.cpp

@@ -0,0 +1,33 @@
+/**
+ * @file friend_func.cpp
+ * @brief 友元函数
+ * @author 光城
+ * @version v1
+ * @date 2019-08-06
+ */
+
+#include <iostream>
+
+using namespace std;
+
+class A
+{
+public:
+    A(int _a):a(_a){};
+    friend int geta(A &ca);  ///< 友元函数
+private:
+    int a;
+};
+
+int geta(A &ca) 
+{
+    return ca.a;
+}
+
+int main()
+{
+    A a(3);    
+    cout<<geta(a)<<endl;
+
+    return 0;
+}

english/basic_content/func_pointer/func_pointer.cpp

@@ -0,0 +1,33 @@
+/**
+ * @file func_pointer.cpp
+ * @brief 函数指针的使用！
+ * @author 光城
+ * @version v1
+ * @date 2019-07-20
+ */
+
+#include<iostream>
+using namespace std;
+
+/**
+ * @brief 定义了一个变量pFun，这个变量是个指针，指向返回值和参数都是空的函数的指针！
+ */
+void (*pFun)(int); 
+
+/**
+ * @brief 代表一种新类型，不是变量！所以与上述的pFun不一样！
+ */
+typedef void (*func)(void);  
+
+void myfunc(void)
+{
+    cout<<"asda"<<endl;
+}
+
+void glFun(int a){ cout<<a<<endl;} 
+int main(){
+    func pfun = myfunc;/*赋值*/  
+    pfun();/*调用*/  
+    pFun = glFun; 
+    (*pFun)(2); 
+}

english/basic_content/inline/README.md

@@ -0,0 +1,137 @@
+# inline那些事
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+## 1.类中内联
+
+头文件中声明方法
+
+```c++
+
+class A
+{
+public:
+    void f1(int x); 
+
+    /**
+     * @brief 类中定义了的函数是隐式内联函数,声明要想成为内联函数，必须在实现处(定义处)加inline关键字。
+     *
+     * @param x
+     * @param y
+     */
+    void Foo(int x,int y) ///< 定义即隐式内联函数！
+    {
+    
+    };
+    void f1(int x); ///< 声明后，要想成为内联函数，必须在定义处加inline关键字。  
+};
+```
+
+实现文件中定义内联函数：
+
+```c++
+#include <iostream>
+#include "inline.h"
+
+using namespace std;
+
+/**
+ * @brief inline要起作用,inline要与函数定义放在一起,inline是一种“用于实现的关键字,而不是用于声明的关键字”
+ *
+ * @param x
+ * @param y
+ *
+ * @return 
+ */
+int Foo(int x,int y);  // 函数声明
+inline int Foo(int x,int y) // 函数定义
+{
+    return x+y;
+}
+
+// 定义处加inline关键字，推荐这种写法！
+inline void A::f1(int x){
+
+}
+
+int main()
+{
+
+    
+    cout<<Foo(1,2)<<endl;
+
+}
+/**
+ * 编译器对 inline 函数的处理步骤
+ * 将 inline 函数体复制到 inline 函数调用点处；
+ * 为所用 inline 函数中的局部变量分配内存空间；
+ * 将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中；
+ * 如果 inline 函数有多个返回点，将其转变为 inline 函数代码块末尾的分支（使用 GOTO）。
+ */
+
+```
+
+内联能提高函数效率，但并不是所有的函数都定义成内联函数！内联是以代码膨胀(复制)为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。
+
+- 如果执行函数体内代码的时间相比于函数调用的开销较大，那么效率的收货会更少！
+
+- 另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。
+
+以下情况不宜用内联：
+
+（1）如果函数体内的代码比较长，使得内联将导致内存消耗代价比较高。
+
+（2）如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。
+
+## 2.虚函数（virtual）可以是内联函数（inline）吗？
+
+- 虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能内联。
+- 内联是在编译期建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。
+- `inline virtual` 唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如 `Base::who()`），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。
+
+```c++
+#include <iostream>  
+using namespace std;
+class Base
+{
+public:
+    inline virtual void who()
+    {
+        cout << "I am Base\n";
+    }
+    virtual ~Base() {}
+};
+class Derived : public Base
+{
+public:
+    inline void who()  // 不写inline时隐式内联
+    {
+        cout << "I am Derived\n";
+    }
+};
+
+int main()
+{
+    // 此处的虚函数 who()，是通过类（Base）的具体对象（b）来调用的，编译期间就能确定了，所以它可以是内联的，但最终是否内联取决于编译器。 
+    Base b;
+    b.who();
+
+    // 此处的虚函数是通过指针调用的，呈现多态性，需要在运行时期间才能确定，所以不能为内联。  
+    Base *ptr = new Derived();
+    ptr->who();
+
+    // 因为Base有虚析构函数（virtual ~Base() {}），所以 delete 时，会先调用派生类（Derived）析构函数，再调用基类（Base）析构函数，防止内存泄漏。
+    delete ptr;
+    ptr = nullptr;
+
+    system("pause");
+    return 0;
+} 
+```
+
+
+

english/basic_content/inline/inline.cpp

@@ -0,0 +1,57 @@
+#include <iostream>
+#include "inline.h"
+
+
+
+using namespace std;
+
+/**
+ * @brief inline要起作用,inline要与函数定义放在一起,inline是一种“用于实现的关键字,而不是用于声明的关键字”
+ *
+ * @param x
+ * @param y
+ *
+ * @return 
+ */
+int Foo(int x,int y);  // 函数声明
+inline int Foo(int x,int y) // 函数定义
+{
+    return x+y;
+}
+
+
+
+// 定义处加inline关键字，推荐这种写法！
+inline void A::f1(int x){
+
+
+}
+
+
+
+/**
+ * @brief 内联能提高函数效率，但并不是所有的函数都定义成内联函数！内联是以代码膨胀(复制)为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。
+ * 如果执行函数体内代码的时间相比于函数调用的开销较大，那么效率的收货会更少！另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。
+ * 以下情况不宜用内联：
+ *  （1） 如果函数体内的代码比较长，使得内联将导致内存消耗代价比较高。
+ *   (2)  如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。
+ *
+ * @return 
+ */
+int main()
+{
+
+    
+    cout<<Foo(1,2)<<endl;
+
+}
+/**
+ * 编译器对 inline 函数的处理步骤
+ * 将 inline 函数体复制到 inline 函数调用点处；
+ * 为所用 inline 函数中的局部变量分配内存空间；
+ * 将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中；
+ * 如果 inline 函数有多个返回点，将其转变为 inline 函数代码块末尾的分支（使用 GOTO）。
+ */
+
+
+

english/basic_content/inline/inline.h

@@ -0,0 +1,19 @@
+
+class A
+{
+public:
+    void f1(int x); 
+
+    /**
+     * @brief 类中定义了的函数是隐式内联函数,声明要想成为内联函数，必须在实现处(定义处)加inline关键字。
+     *
+     * @param x
+     * @param y
+     */
+    void Foo(int x,int y) ///< 定义即隐式内联函数！
+    {
+    
+    };
+    void f1(int x); ///< 声明后，要想成为内联函数，必须在定义处加inline关键字。
+    
+};

english/basic_content/inline/inline_virtual.cpp

@@ -0,0 +1,35 @@
+#include <iostream>  
+using namespace std;
+class Base
+{
+    public:
+        inline virtual void who()
+        {
+            cout << "I am Base\n";
+        }
+        virtual ~Base() {}
+};
+class Derived : public Base
+{
+    public:
+        inline void who()  // 不写inline时隐式内联
+        {
+            cout << "I am Derived\n";
+        }
+};
+
+int main()
+{
+    // 此处的虚函数 who()，是通过类（Base）的具体对象（b）来调用的，编译期间就能确定了，所以它可以是内联的，但最终是否内联取决于编译器。 
+    Base b;
+    b.who();
+
+    // 此处的虚函数是通过指针调用的，呈现多态性，需要在运行时期间才能确定，所以不能为内联。  
+    Base *ptr = new Derived();
+    ptr->who();
+
+    // 因为Base有虚析构函数（virtual ~Base() {}），所以 delete 时，会先调用派生类（Derived）析构函数，再调用基类（Base）析构函数，防止内存泄漏。
+    delete ptr;
+
+    return 0;
+} 

english/basic_content/macro/README.md

@@ -0,0 +1,232 @@
+# 宏那些事
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+## 1.宏中包含特殊符号
+
+分为几种：`#`，`##`，`\`
+
+### 1.1 字符串化操作符（#）
+
+**在一个宏中的参数前面使用一个#,预处理器会把这个参数转换为一个字符数组**，换言之就是：**#是“字符串化”的意思，出现在宏定义中的#是把跟在后面的参数转换成一个字符串**。
+
+**注意：其只能用于有传入参数的宏定义中，且必须置于宏定义体中的参数名前。**
+
+例如：
+
+```c++
+#define exp(s) printf("test s is:%s\n",s)
+#define exp1(s) printf("test s is:%s\n",#s)
+#define exp2(s) #s 
+int main() {
+    exp("hello");
+    exp1(hello);
+
+    string str = exp2(   bac );
+    cout<<str<<" "<<str.size()<<endl;
+    /**
+     * 忽略传入参数名前面和后面的空格。
+     */
+    string str1 = exp2( asda  bac );
+    /**
+     * 当传入参数名间存在空格时，编译器将会自动连接各个子字符串，
+     * 用每个子字符串之间以一个空格连接，忽略剩余空格。
+     */
+    cout<<str1<<" "<<str1.size()<<endl;
+    return 0;
+}
+```
+
+上述代码给出了基本的使用与空格处理规则，空格处理规则如下：
+
+- 忽略传入参数名前面和后面的空格。
+
+```c++
+string str = exp2(   bac );
+cout<<str<<" "<<str.size()<<endl;
+```
+
+输出：
+
+```
+bac 3
+```
+
+- 当传入参数名间存在空格时，编译器将会自动连接各个子字符串，用每个子字符串之间以一个空格连接，忽略剩余空格。
+
+```c++
+string str1 = exp2( asda  bac );
+cout<<str1<<" "<<str1.size()<<endl;
+```
+
+输出：
+
+```
+asda bac 8
+```
+
+### 1.2 符号连接操作符（##）
+
+**“##”是一种分隔连接方式，它的作用是先分隔，然后进行强制连接。将宏定义的多个形参转换成一个实际参数名。**
+
+注意事项：
+
+**（1）当用##连接形参时，##前后的空格可有可无。**
+
+**（2）连接后的实际参数名，必须为实际存在的参数名或是编译器已知的宏定义。**
+
+**（3）如果##后的参数本身也是一个宏的话，##会阻止这个宏的展开。**
+
+示例：
+
+```c++
+
+#define expA(s) printf("前缀加上后的字符串为:%s\n",gc_##s)  //gc_s必须存在
+// 注意事项2
+#define expB(s) printf("前缀加上后的字符串为:%s\n",gc_  ##  s)  //gc_s必须存在
+// 注意事项1
+#define gc_hello1 "I am gc_hello1"
+int main() {
+    // 注意事项1
+    const char * gc_hello = "I am gc_hello";
+    expA(hello);
+    expB(hello1);
+}
+```
+
+### 1.3 续行操作符（\） 
+
+**当定义的宏不能用一行表达完整时，可以用”\”表示下一行继续此宏的定义。**
+
+**注意 \ 前留空格。**
+
+```c++
+#define MAX(a,b) ((a)>(b) ? (a) \
+   :(b))  
+int main() {
+    int max_val = MAX(3,6);
+    cout<<max_val<<endl;
+}
+```
+
+上述代码见：[sig_examp.cpp](sig_examp.cpp)
+
+## 2.do{...}while(0)的使用
+
+### 2.1 避免语义曲解
+
+例如：
+
+```
+#define fun() f1();f2();
+if(a>0)
+	fun()
+```
+
+这个宏被展开后就是：
+
+```
+if(a>0)
+	f1();
+	f2();
+```
+
+本意是a>0执行f1 f2，而实际是f2每次都会执行，所以就错误了。
+
+为了解决这种问题，在写代码的时候，通常可以采用`{}`块。
+
+如：
+
+```c++
+#define fun() {f1();f2();}
+if(a>0)
+	fun();
+// 宏展开
+if(a>0)
+{
+    f1();
+    f2();
+};
+```
+
+但是会发现上述宏展开后多了一个分号，实际语法不太对。(虽然编译运行没问题，正常没分号)。
+
+### 2.2避免使用goto控制流
+
+在一些函数中，我们可能需要在return语句之前做一些清理工作，比如释放在函数开始处由malloc申请的内存空间，使用goto总是一种简单的方法：
+
+```c++
+int f() {
+    int *p = (int *)malloc(sizeof(int));
+    *p = 10; 
+    cout<<*p<<endl;
+#ifndef DEBUG
+    int error=1;
+#endif
+    if(error)
+        goto END;
+    // dosomething
+END:
+    cout<<"free"<<endl;
+    free(p);
+    return 0;
+}
+```
+
+但由于goto不符合软件工程的结构化，而且有可能使得代码难懂，所以很多人都不倡导使用，这个时候我们可以使用do{...}while(0)来做同样的事情：
+
+```c++
+int ff() {
+    int *p = (int *)malloc(sizeof(int));
+    *p = 10; 
+    cout<<*p<<endl;
+    do{ 
+#ifndef DEBUG
+        int error=1;
+#endif
+        if(error)
+            break;
+        //dosomething
+    }while(0);
+    cout<<"free"<<endl;
+    free(p);
+    return 0;
+}
+```
+
+这里将函数主体部分使用do{...}while(0)包含起来，使用break来代替goto，后续的清理工作在while之后，现在既能达到同样的效果，而且代码的可读性、可维护性都要比上面的goto代码好的多了。
+
+### 2.3 避免由宏引起的警告
+
+内核中由于不同架构的限制，很多时候会用到空宏，。在编译的时候，这些空宏会给出warning，为了避免这样的warning，我们可以使用do{...}while(0)来定义空宏：
+
+```
+#define EMPTYMICRO do{}while(0)
+```
+
+### 2.4 **定义单一的函数块来完成复杂的操作**
+
+如果你有一个复杂的函数，变量很多，而且你不想要增加新的函数，可以使用do{...}while(0)，将你的代码写在里面，里面可以定义变量而不用考虑变量名会同函数之前或者之后的重复。
+这种情况应该是指一个变量多处使用（但每处的意义还不同），我们可以在每个do-while中缩小作用域，比如：
+
+```c++
+int fc()
+{
+    int k1 = 10;
+    cout<<k1<<endl;
+    do{
+        int k1 = 100;
+        cout<<k1<<endl;
+    }while(0);
+    cout<<k1<<endl;
+}
+```
+
+上述代码见：[do_while.cpp](do_while.cpp)
+
+学习文章：<https://www.cnblogs.com/lizhenghn/p/3674430.html>
+

english/basic_content/macro/do_while.cpp

@@ -0,0 +1,76 @@
+#include <iostream>
+#include <malloc.h>
+
+using namespace std;
+#define f1() cout<<"f1()"<<endl;
+#define f2() cout<<"f2()"<<endl;
+
+#define fun() {f1();f2();}
+#define fun1() \
+    do{ \
+        f1();\
+        f2();\
+    }while(0)
+
+int f() {
+    int *p = (int *)malloc(sizeof(int));
+    *p = 10;
+    cout<<*p<<endl;
+#ifndef DEBUG
+    int error=1;
+#endif
+    if(error)
+        goto END;
+
+    // dosomething
+END:
+    cout<<"free"<<endl;
+    free(p);
+    return 0;
+}
+
+int ff() {
+
+    int *p = (int *)malloc(sizeof(int));
+    *p = 10;
+    cout<<*p<<endl;
+
+    do{
+#ifndef DEBUG
+        int error=1;
+#endif
+        if(error)
+            break;
+        //dosomething
+    }while(0);
+
+    cout<<"free"<<endl;
+    free(p);
+    return 0;
+}
+
+
+int fc()
+{
+    int k1 = 10;
+    cout<<k1<<endl;
+    do{
+        int k1 = 100;
+        cout<<k1<<endl;
+    }while(0);    
+    cout<<k1<<endl;
+}
+
+int main() {
+
+    if(1>0)
+        fun();
+
+    if(2>0)
+        fun1();
+
+    f();
+    ff();
+    fc();
+    return 0;
+}

english/basic_content/macro/sig_examp.cpp

@@ -0,0 +1,86 @@
+#include <iostream>
+#include <string>
+#include <cstring>
+#include <stdio.h>
+
+using namespace std;
+
+///===========================================
+/**
+ * (#)字符串操作符
+ */
+///===========================================
+#define exp(s) printf("test s is:%s\n",s)
+#define exp1(s) printf("test s is:%s\n",#s)
+
+#define exp2(s) #s 
+
+
+///===========================================
+/**
+ *（##）符号连接操作符
+ */
+///===========================================
+#define expA(s) printf("前缀加上后的字符串为:%s\n",gc_##s)  //gc_s必须存在
+
+#define expB(s) printf("前缀加上后的字符串为:%s\n",gc_  ##  s)  //gc_s必须存在
+
+#define gc_hello1 "I am gc_hello1"
+
+
+///===========================================
+/**
+ * (\)续行操作符
+ */
+///===========================================
+#define MAX(a,b) ((a)>(b) ? (a) \
+   :(b))  
+
+int main() { 
+    ///===========================================
+    /**
+     * (#)字符串操作符
+     */
+    ///===========================================
+    exp("hello");
+    exp1(hello);
+
+    string str = exp2(   bac );
+    cout<<str<<" "<<str.size()<<endl;
+    /**
+     * 忽略传入参数名前面和后面的空格。
+     */
+    string str1 = exp2( asda  bac );
+    /**
+     * 当传入参数名间存在空格时，编译器将会自动连接各个子字符串，
+     * 用每个子字符串之间以一个空格连接，忽略剩余空格。
+     */
+    cout<<str1<<" "<<str1.size()<<endl;
+
+    ///===========================================
+    /**
+     * (#)字符串操作符
+     */
+    ///===========================================
+
+    const char * gc_hello = "I am gc_hello";
+    expA(hello);
+    expB(hello1);
+
+    char var1_p[20];
+    char var2_p[20];
+
+    // 连接后的实际参数名赋值
+    strcpy(var1_p, "aaaa");
+    strcpy(var2_p, "bbbb");
+
+
+    ///===========================================
+    /**
+     * (\)续行操作符
+     */
+    ///===========================================
+    int max_val = MAX(3,6);
+    cout<<max_val<<endl;
+    return 0;
+}

english/basic_content/maohao/README.md

@@ -0,0 +1,14 @@
+# :: 范围解析运算符那些事
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+- 全局作用域符（::name）：用于类型名称（类、类成员、成员函数、变量等）前，表示作用域为全局命名空间
+- 类作用域符（class::name）：用于表示指定类型的作用域范围是具体某个类的
+- 命名空间作用域符（namespace::name）:用于表示指定类型的作用域范围是具体某个命名空间的
+
+具体代码见：[maohao.cpp](maohao.cpp)
+

english/basic_content/maohao/README.md~

@@ -0,0 +1,14 @@
+# :: 范围解析运算符那些事
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+- 全局作用域符（::name）：用于类型名称（类、类成员、成员函数、变量等）前，表示作用域为全局命名空间
+- 类作用域符（class::name）：用于表示指定类型的作用域范围是具体某个类的
+- 命名空间作用域符（namespace::name）:用于表示指定类型的作用域范围是具体某个命名空间的
+
+具体代码见：[::.cpp](::.cpp)
+

english/basic_content/maohao/maohao.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+using namespace std;
+
+int count=0;    // 全局(::)的count
+
+class A {
+public:
+    static int count;  // 类A的count (A::count)
+
+};
+// 静态变量必须在此处定义
+int A::count;
+int main() {
+    ::count=1; // 设置全局的count为1
+    A::count=5; // 设置类A的count为2
+    cout<<A::count<<endl;
+//    int count=3; // 局部count
+//    count=4;     // 设置局部的count为4
+    return 0;
+}

english/basic_content/pointer_refer/README.md

@@ -0,0 +1,174 @@
+# 引用与指针那些事
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+## 1.引用与指针
+
+总论：
+
+| 引用         | 指针         |
+| ------------ | ------------ |
+| 必须初始化   | 可以不初始化 |
+| 不能为空     | 可以为空     |
+| 不能更换目标 | 可以更换目标 |
+
+> 引用必须初始化，而指针可以不初始化。
+
+我们在定义一个引用的时候必须为其指定一个初始值，但是指针却不需要。
+
+```c++
+int &r;    //不合法，没有初始化引用
+int *p;    //合法，但p为野指针，使用需要小心
+```
+
+> 引用不能为空，而指针可以为空。
+
+由于引用不能为空，所以我们在使用引用的时候不需要测试其合法性，而在使用指针的时候需要首先判断指针是否为空指针，否则可能会引起程序崩溃。
+
+```c++
+void test_p(int* p)
+{
+  	if(p != null_ptr)    //对p所指对象赋值时需先判断p是否为空指针
+    	*p = 3;
+    return;
+}
+void test_r(int& r)
+{
+    r = 3;    //由于引用不能为空，所以此处无需判断r的有效性就可以对r直接赋值
+    return;
+}
+```
+
+> 引用不能更换目标
+
+指针可以随时改变指向，但是引用只能指向初始化时指向的对象，无法改变。
+
+```
+int a = 1;
+int b = 2;
+
+int &r = a;    //初始化引用r指向变量a
+int *p = &a;   //初始化指针p指向变量a
+
+p = &b;        //指针p指向了变量b
+r = b;         //引用r依然指向a，但a的值变成了b
+```
+
+## 2.引用
+
+#### 左值引用
+
+常规引用，一般表示对象的身份。
+
+#### 右值引用
+
+右值引用就是必须绑定到右值（一个临时对象、将要销毁的对象）的引用，一般表示对象的值。
+
+右值引用可实现转移语义（Move Sementics）和精确传递（Perfect Forwarding），它的主要目的有两个方面：
+
+- 消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率。
+- 能够更简洁明确地定义泛型函数。
+
+#### 引用折叠
+
+- `X& &`、`X& &&`、`X&& &` 可折叠成 `X&`
+- `X&& &&` 可折叠成 `X&&`
+
+C++的引用**在减少了程序员自由度的同时提升了内存操作的安全性和语义的优美性**。比如引用强制要求必须初始化，可以让我们在使用引用的时候不用再去判断引用是否为空，让代码更加简洁优美，避免了指针满天飞的情形。除了这种场景之外引用还用于如下两个场景：
+
+> 引用型参数
+
+一般我们使用const reference参数作为只读形参，这种情况下既可以避免参数拷贝还可以获得与传值参数一样的调用方式。
+
+```c++
+void test(const vector<int> &data)
+{
+    //...
+}
+int main()
+{
+  	vector<int> data{1,2,3,4,5,6,7,8};
+    test(data);
+}
+```
+
+> 引用型返回值
+
+C++提供了重载运算符的功能，我们在重载某些操作符的时候，使用引用型返回值可以获得跟该操作符原来语法相同的调用方式，保持了操作符语义的一致性。一个例子就是operator []操作符，这个操作符一般需要返回一个引用对象，才能正确的被修改。
+
+```c++
+vector<int> v(10);
+v[5] = 10;    //[]操作符返回引用，然后vector对应元素才能被修改
+              //如果[]操作符不返回引用而是指针的话，赋值语句则需要这样写
+*v[5] = 10;   //这种书写方式，完全不符合我们对[]调用的认知，容易产生误解
+```
+
+## 3.指针与引用的性能差距
+
+指针与引用之间有没有性能差距呢？这种问题就需要进入汇编层面去看一下。我们先写一个test1函数，参数传递使用指针：
+
+```c++
+void test1(int* p)
+{
+    *p = 3;    //此处应该首先判断p是否为空，为了测试的需要，此处我们没加。
+    return;
+}
+```
+
+该代码段对应的汇编代码如下：
+
+```c++
+(gdb) disassemble 
+Dump of assembler code for function test1(int*):
+   0x0000000000400886 <+0>:  push   %rbp
+   0x0000000000400887 <+1>:  mov    %rsp,%rbp
+   0x000000000040088a <+4>:  mov    %rdi,-0x8(%rbp)
+=> 0x000000000040088e <+8>:  mov    -0x8(%rbp),%rax
+   0x0000000000400892 <+12>: movl   $0x3,(%rax)
+   0x0000000000400898 <+18>: nop
+   0x0000000000400899 <+19>: pop    %rbp
+   0x000000000040089a <+20>: retq   
+End of assembler dump.
+
+```
+
+上述代码1、2行是参数调用保存现场操作；第3行是参数传递，函数调用第一个参数一般放在rdi寄存器，此行代码把rdi寄存器值（指针p的值）写入栈中；第4行是把栈中p的值写入rax寄存器；第5行是把立即数3写入到**rax寄存器值所指向的内存**中，此处要注意(%rax)两边的括号，这个括号并并不是可有可无的，(%rax)和%rax完全是两种意义，(%rax)代表rax寄存器中值所代表地址部分的内存，即相当于C++代码中的*p，而%rax代表rax寄存器，相当于C++代码中的p值，所以汇编这里使用了(%rax)而不是%rax。
+
+我们再写出参数传递使用引用的C++代码段test2：
+
+```c++
+void test2(int& r)
+{
+    r = 3;    //赋值前无需判断reference是否为空
+    return;
+}
+```
+
+这段代码对应的汇编代码如下：
+
+```c++
+(gdb) disassemble 
+Dump of assembler code for function test2(int&):
+   0x000000000040089b <+0>:  push   %rbp
+   0x000000000040089c <+1>:  mov    %rsp,%rbp
+   0x000000000040089f <+4>:  mov    %rdi,-0x8(%rbp)
+=> 0x00000000004008a3 <+8>:  mov    -0x8(%rbp),%rax
+   0x00000000004008a7 <+12>: movl   $0x3,(%rax)
+   0x00000000004008ad <+18>: nop
+   0x00000000004008ae <+19>: pop    %rbp
+   0x00000000004008af <+20>: retq   
+End of assembler dump.
+
+```
+
+我们发现test2对应的汇编代码和test1对应的汇编代码完全相同，这说明C++编译器在编译程序的时候将指针和引用编译成了完全一样的机器码。所以C++中的引用只是C++对指针操作的一个“语法糖”，在底层实现时C++编译器实现这两种操作的方法完全相同。
+
+## 3.总结
+
+C++中引入了引用操作，在对引用的使用加了更多限制条件的情况下，保证了引用使用的安全性和便捷性，还可以保持代码的优雅性。在适合的情况使用适合的操作，引用的使用可以一定程度避免“指针满天飞”的情况，对于提升程序稳定性也有一定的积极意义。最后，指针与引用底层实现都是一样的，不用担心两者的性能差距。
+
+上述部分参考自：<http://irootlee.com/juicer_pointer_reference/#>

english/basic_content/pointer_refer/copy_construct.cpp

@@ -0,0 +1,35 @@
+/**
+ * @file copy_construct.cpp
+ * @brief g++ -o copy_construct copy_construct.cpp -fno-elide-constructors
+ * -fno-elide-constructors选项(关闭返回值优化)
+ * @author 光城
+ * @version v1
+ * @date 2019-08-09
+ */
+
+#include <iostream>
+using namespace std;
+
+class Copyable {
+public:
+    Copyable(){}
+    Copyable(const Copyable &o) {
+        cout << "Copied" << endl;
+    }
+};
+Copyable ReturnRvalue() {
+    return Copyable(); //返回一个临时对象
+}
+void AcceptVal(Copyable a) {
+
+}
+void AcceptRef(const Copyable& a) {
+
+}
+
+int main() {
+    cout << "pass by value: " << endl;
+    AcceptVal(ReturnRvalue()); // 应该调用两次拷贝构造函数
+    cout << "pass by reference: " << endl;
+    AcceptRef(ReturnRvalue()); //应该只调用一次拷贝构造函数
+}

english/basic_content/pointer_refer/effec.cpp

@@ -0,0 +1,22 @@
+#include<iostream>
+using namespace std;
+void test1(int* p)
+{
+    *p = 3;    //此处应该首先判断p是否为空，为了测试的需要，此处我们没加。
+    return;
+}
+
+void test2(int& p)
+{
+    p = 3;    //此处应该首先判断p是否为空，为了测试的需要，此处我们没加。
+    return;
+}
+
+int main() {
+    int a=10;
+    int *p=&a;
+    test1(p);
+    test2(a);
+    cout<<a<<endl;
+    return 0;
+}

english/basic_content/sizeof/README.md

@@ -0,0 +1,191 @@
+# 类大小计算
+
+首先来个总结，然后下面给出实际例子，实战！
+
+- 空类的大小为1字节
+- 一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间。
+- 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。
+- 普通继承，派生类继承了所有基类的函数与成员，要按照字节对齐来计算大小
+- 虚函数继承，不管是单继承还是多继承，都是继承了基类的vptr。(32位操作系统4字节，64位操作系统 8字节)！
+- 虚继承,继承基类的vptr。
+
+## 1.原则1
+
+```c++
+/**
+ * @file blackclass.cpp
+ * @brief 空类的大小为1字节
+ * @author 光城
+ * @version v1
+ * @date 2019-07-21
+ */
+#include<iostream>
+using namespace std;
+class A{};
+int main()
+{
+    cout<<sizeof(A)<<endl;
+    return 0;
+}
+```
+
+## 2.原则2
+
+```c++
+/**
+ * @file static.cpp
+ * @brief 静态数据成员
+ * 静态数据成员被编译器放在程序的一个global data members中，它是类的一个数据成员，但不影响类的大小。不管这个类产生了多少个实例，还是派生了多少新的类，静态数据成员只有一个实例。静态数据成员，一旦被声明，就已经存在。 
+ * @author 光城
+ * @version v1
+ * @date 2019-07-21
+ */
+#include<iostream>
+using namespace std;
+class A
+{
+    public:
+        char b;
+        virtual void fun() {};
+        static int c;
+        static int d;
+        static int f;
+};
+
+int main()
+{
+    /**
+     * @brief 16  字节对齐、静态变量不影响类的大小、vptr指针=8
+     */
+    cout<<sizeof(A)<<endl; 
+    return 0;
+}
+```
+
+## 3.原则3
+
+```c++
+/**
+ * @file morevir.cpp
+ * @brief 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。
+ * @author 光城
+ * @version v1
+ * @date 2019-07-21
+ */
+#include<iostream>
+using namespace std;
+class A{
+    virtual void fun();
+    virtual void fun1();
+    virtual void fun2();
+    virtual void fun3();
+};
+int main()
+{
+    cout<<sizeof(A)<<endl; // 8
+    return 0;
+}
+```
+
+## 4.原则4与5
+
+```c++
+/**
+ * @file geninhe.cpp
+ * @brief 1.普通单继承,继承就是基类+派生类自身的大小(注意字节对齐)
+ * 注意：类的数据成员按其声明顺序加入内存，与访问权限无关，只看声明顺序。
+ * 2.虚单继承，派生类继承基类vptr
+ * @author 光城
+ * @version v1
+ * @date 2019-07-21
+ */
+
+#include<iostream>
+
+using namespace std;
+
+class A
+{
+    public:
+        char a;
+        int b;
+};
+
+/**
+ * @brief 此时B按照顺序：
+ * char a
+ * int b
+ * short a
+ * long b
+ * 根据字节对齐4+4=8+8+8=24
+ */
+class B:A
+{
+    public:
+        short a;
+        long b;
+};
+class C
+{
+    A a;
+    char c;
+};
+class A1
+{
+    virtual void fun(){}
+};
+class C1:public A1
+{
+};
+
+int main()
+{
+    cout<<sizeof(A)<<endl; // 8
+    cout<<sizeof(B)<<endl; // 24
+    cout<<sizeof(C)<<endl; // 12
+    /**
+     * @brief 对于虚单函数继承，派生类也继承了基类的vptr，所以是8字节
+     */
+    cout<<sizeof(C1)<<endl; // 8 
+    return 0;
+}
+```
+
+## 5.原则6
+
+```c++
+/**
+ * @file virnhe.cpp
+ * @brief 虚继承
+ * @author 光城
+ * @version v1
+ * @date 2019-07-21
+ */
+
+#include<iostream>
+using namespace std;
+class A
+{
+    virtual void fun() {}
+};
+class B
+{
+    virtual void fun2() {}
+};
+class C : virtual public  A, virtual public B
+{
+    public:
+        virtual void fun3() {}
+};
+
+int main()
+{
+    /**
+     * @brief 8 8 16  派生类虚继承多个虚函数，会继承所有虚函数的vptr
+     */
+    cout<<sizeof(A)<<" "<<sizeof(B)<<" "<<sizeof(C);
+
+    return 0;
+}
+```
+

english/basic_content/sizeof/blackclass.cpp

@@ -0,0 +1,18 @@
+/**
+ * @file blackclass.cpp
+ * @brief 空类的大小为1字节
+ * @author 光城
+ * @version v1
+ * @date 2019-07-21
+ */
+
+#include<iostream>
+
+using namespace std;
+
+class A{};
+int main()
+{
+    cout<<sizeof(A)<<endl;
+    return 0;
+}

english/basic_content/sizeof/genA.cpp

@@ -0,0 +1,29 @@
+/**
+ * @file genA.cpp
+ * @brief 普通成员函数，大小为1,一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间。
+ * @author 光城
+ * @version v1
+ * @date 2019-07-21
+ */
+
+#include<iostream>
+
+
+using namespace std;
+
+class A
+{
+    public:
+        A();
+        ~A();
+        static int a;
+        static void fun3();
+        void fun();
+        void fun1();
+};
+
+int main()
+{
+    cout<<sizeof(A)<<endl; // 1
+    return 0;
+}

english/basic_content/sizeof/geninhe.cpp

@@ -0,0 +1,62 @@
+/**
+ * @file geninhe.cpp
+ * @brief 1.普通单继承,继承就是基类+派生类自身的大小(注意字节对齐)
+ * 注意：类的数据成员按其声明顺序加入内存，无访问权限无关，只看声明顺序。
+ * 2.虚单继承，派生类继承基类vptr
+ * @author 光城
+ * @version v1
+ * @date 2019-07-21
+ */
+
+#include<iostream>
+
+using namespace std;
+
+class A
+{
+    public:
+        char a;
+        int b;
+};
+
+/**
+ * @brief 此时B按照顺序：
+ * char a
+ * int b
+ * short a
+ * long b
+ * 根据字节对齐4+4=8+8+8=24
+ */
+class B:A
+{
+    public:
+        short a;
+        long b;
+};
+class C
+{
+    A a;
+    char c;
+};
+
+class A1
+{
+    virtual void fun(){}
+};
+class C1:public A
+{
+};
+
+
+int main()
+{
+    cout<<sizeof(A)<<endl; // 8
+    cout<<sizeof(B)<<endl; // 24
+    cout<<sizeof(C)<<endl; // 12
+
+    /**
+     * @brief 对于虚单函数继承，派生类也继承了基类的vptr，所以是8字节
+     */
+    cout<<sizeof(C1)<<endl; // 8 
+    return 0;
+}

english/basic_content/sizeof/moreinhe.cpp

@@ -0,0 +1,43 @@
+/**
+ * @file moreinhe.cpp
+ * @brief 普通多继承与虚函数多继承
+ * @author 光城
+ * @version v1
+ * @date 2019-07-21
+ */
+
+#include<iostream>
+
+using namespace std;
+
+class A
+{
+    public:
+        char a;
+        int b;
+};
+
+class B
+{
+    public:
+        short a;
+        long b;
+};
+
+/**
+ * @brief 8+16+8=32
+ */
+class C:A,B
+{
+    char c;
+};
+
+
+int main()
+{
+    cout<<sizeof(A)<<endl; // 8
+    cout<<sizeof(B)<<endl; // 16
+    cout<<sizeof(C)<<endl; // 32
+
+    return 0;
+}

english/basic_content/sizeof/morevir.cpp

@@ -0,0 +1,24 @@
+/**
+ * @file morevir.cpp
+ * @brief 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。
+ * @author 光城
+ * @version v1
+ * @date 2019-07-21
+ */
+
+#include<iostream>
+
+using namespace std;
+
+class A{
+
+    virtual void fun();
+    virtual void fun1();
+    virtual void fun2();
+    virtual void fun3();
+};
+int main()
+{
+    cout<<sizeof(A)<<endl;
+    return 0;
+}

english/basic_content/sizeof/static.cpp

@@ -0,0 +1,33 @@
+/**
+ * @file static.cpp
+ * @brief 静态数据成员
+ * 静态数据成员被编译器放在程序的一个global data members中，它是类的一个数据成员，但不影响类的大小。不管这个类产生了多少个实例，还是派生了多少新的类，静态数据成员只有一个实例。静态数据成员，一旦被声明，就已经存在。 
+ * @author 光城
+ * @version v1
+ * @date 2019-07-21
+ */
+
+#include<iostream>
+using namespace std;
+class A
+{
+    public:
+        char b;
+        virtual void fun() {};
+        static int c;
+        static int d;
+        static int f;
+};
+
+
+
+int main()
+{
+
+    /**
+     * @brief 16  字节对齐、静态变量不影响类的大小、vptr指针=8
+     */
+    cout<<sizeof(A)<<endl; 
+
+    return 0;
+}

english/basic_content/sizeof/virinhe.cpp

@@ -0,0 +1,38 @@
+/**
+ * @file virnhe.cpp
+ * @brief 虚继承
+ * @author 光城
+ * @version v1
+ * @date 2019-07-21
+ */
+
+#include<iostream>
+
+using namespace std;
+
+class A
+{
+    virtual void fun() {}
+};
+
+class B
+{
+    virtual void fun2() {}
+};
+class C : virtual public  A, virtual public B
+{
+    public:
+        virtual void fun3() {}
+};
+
+
+int main()
+{
+
+    /**
+     * @brief 8 8 16  派生类虚继承多个虚函数，会继承所有虚函数的vptr
+     */
+    cout<<sizeof(A)<<" "<<sizeof(B)<<" "<<sizeof(C);
+
+    return 0;
+}

english/basic_content/sizeof/virmoreinhe.cpp

@@ -0,0 +1,38 @@
+/**
+ * @file virmoreinhe.cpp
+ * @brief 虚函数多继承
+ * @author 光城
+ * @version v1
+ * @date 2019-07-21
+ */
+
+#include<iostream>
+
+using namespace std;
+
+class A
+{
+    virtual void fun() {}
+};
+
+class B
+{
+    virtual void fun2() {}
+};
+class C : public  A, public B
+{
+    public:
+        virtual void fun3() {}
+};
+
+
+int main()
+{
+
+    /**
+     * @brief 8 8 16  派生类继承多个虚函数，会继承所有虚函数的vptr
+     */
+    cout<<sizeof(A)<<" "<<sizeof(B)<<" "<<sizeof(C);
+
+    return 0;
+}

english/basic_content/static/README.md

@@ -0,0 +1,248 @@
+# static那些事
+
+## 关于作者
+
+微信公众号：
+
+![](../img/wechat.jpg)
+
+当与不同类型一起使用时，Static关键字具有不同的含义。我们可以使用static关键字：
+
+**静态变量：** 函数中的变量，类中的变量
+
+**静态类的成员：** 类对象和类中的函数
+
+现在让我们详细看一下静态的这些用法：
+
+**静态变量**
+
+- 函数中的静态变量
+
+当变量声明为static时，空间**将在程序的生命周期内分配**。即使多次调用该函数，静态变量的空间也**只分配一次**，前一次调用中的变量值通过下一次函数调用传递。这对于在C / C ++或需要存储先前函数状态的任何其他应用程序非常有用。
+
+```c++
+#include <iostream> 
+#include <string> 
+using namespace std; 
+
+void demo() 
+{ 
+	// static variable 
+	static int count = 0; 
+	cout << count << " "; 
+	
+	// value is updated and 
+	// will be carried to next 
+	// function calls 
+	count++; 
+} 
+
+int main() 
+{ 
+	for (int i=0; i<5; i++)	 
+		demo(); 
+	return 0; 
+} 
+```
+
+输出：
+
+```
+0 1 2 3 4 
+```
+
+您可以在上面的程序中看到变量count被声明为static。因此，它的值通过函数调用来传递。每次调用函数时，都不会对变量计数进行初始化。
+
+- 类中的静态变量
+
+由于声明为static的变量只被初始化一次，因为它们在单独的静态存储中分配了空间，因此类中的静态变量**由对象共享。**对于不同的对象，不能有相同静态变量的多个副本。也是因为这个原因，静态变量不能使用构造函数初始化。
+
+```c++
+
+#include<iostream> 
+using namespace std; 
+
+class Apple 
+{ 
+public: 
+	static int i; 
+	
+	Apple() 
+	{ 
+		// Do nothing 
+	}; 
+}; 
+
+int main() 
+{ 
+Apple obj1; 
+Apple obj2; 
+obj1.i =2; 
+obj2.i = 3; 
+	
+// prints value of i 
+cout << obj1.i<<" "<<obj2.i; 
+} 
+```
+
+您可以在上面的程序中看到我们已经尝试为多个对象创建静态变量i的多个副本。但这并没有发生。因此，类中的静态变量应由用户使用类外的类名和范围解析运算符显式初始化，如下所示：
+
+```c++
+
+#include<iostream> 
+using namespace std; 
+
+class Apple 
+{ 
+public: 
+	static int i; 
+	
+	Apple() 
+	{ 
+		// Do nothing 
+	}; 
+}; 
+
+int Apple::i = 1; 
+
+int main() 
+{ 
+	Apple obj; 
+	// prints value of i 
+	cout << obj.i; 
+} 
+```
+
+输出：
+
+```
+1
+```
+
+**静态成员**
+
+- 类对象为静态
+
+就像变量一样，对象也在声明为static时具有范围，直到程序的生命周期。
+
+考虑以下程序，其中对象是非静态的。
+
+```c++
+#include<iostream> 
+using namespace std; 
+
+class Apple 
+{ 
+	int i; 
+	public: 
+		Apple() 
+		{ 
+			i = 0; 
+			cout << "Inside Constructor\n"; 
+		} 
+		~Apple() 
+		{ 
+			cout << "Inside Destructor\n"; 
+		} 
+}; 
+
+int main() 
+{ 
+	int x = 0; 
+	if (x==0) 
+	{ 
+		Apple obj; 
+	} 
+	cout << "End of main\n"; 
+} 
+
+```
+
+
+输出：
+
+```c++
+Inside Constructor
+Inside Destructor
+End of main
+```
+
+在上面的程序中，对象在if块内声明为非静态。因此，变量的范围仅在if块内。因此，当创建对象时，将调用构造函数，并且在if块的控制权越过析构函数的同时调用，因为对象的范围仅在声明它的if块内。
+如果我们将对象声明为静态，现在让我们看看输出的变化。
+
+```c++
+#include<iostream> 
+using namespace std; 
+
+class Apple 
+{ 
+	int i; 
+	public: 
+		Apple() 
+		{ 
+			i = 0; 
+			cout << "Inside Constructor\n"; 
+		} 
+		~Apple() 
+		{ 
+			cout << "Inside Destructor\n"; 
+		} 
+}; 
+
+int main() 
+{ 
+	int x = 0; 
+	if (x==0) 
+	{ 
+		static Apple obj; 
+	} 
+	cout << "End of main\n"; 
+} 
+
+```
+
+
+输出：
+
+```
+Inside Constructor
+End of main
+Inside Destructor
+```
+
+您可以清楚地看到输出的变化。现在，在main结束后调用析构函数。这是因为静态对象的范围是贯穿程序的生命周期。
+
+- 类中的静态函数
+
+就像类中的静态数据成员或静态变量一样，静态成员函数也不依赖于类的对象。我们被允许使用对象和'.'来调用静态成员函数。但建议使用类名和范围解析运算符调用静态成员。
+
+允许静态成员函数仅访问静态数据成员或其他静态成员函数，它们无法访问类的非静态数据成员或成员函数。
+
+```c++
+#include<iostream> 
+using namespace std; 
+
+class Apple 
+{ 
+    public: 
+        // static member function 
+        static void printMsg() 
+        {
+            cout<<"Welcome to Apple!"; 
+        }
+}; 
+
+// main function 
+int main() 
+{ 
+    // invoking a static member function 
+    Apple::printMsg(); 
+} 
+```
+
+输出：
+
+```
+Welcome to Apple!
+```
+

english/basic_content/static/nostatic_class.cpp

@@ -0,0 +1,28 @@
+#include<iostream> 
+using namespace std; 
+
+class Apple 
+{ 
+    int i; 
+    public: 
+    Apple() 
+    { 
+        i = 0; 
+        cout << "Inside Constructor\n"; 
+    } 
+    ~Apple() 
+    { 
+        cout << "Inside Destructor\n"; 
+    } 
+}; 
+
+int main() 
+{ 
+    int x = 0; 
+    if (x==0) 
+    { 
+        Apple obj; 
+    } 
+    cout << "End of main\n"; 
+} 
+

english/basic_content/static/static_class.cpp

@@ -0,0 +1,28 @@
+#include<iostream> 
+using namespace std; 
+
+class Apple 
+{ 
+    int i; 
+    public: 
+    Apple() 
+    { 
+        i = 0; 
+        cout << "Inside Constructor\n"; 
+    } 
+    ~Apple() 
+    { 
+        cout << "Inside Destructor\n"; 
+    } 
+}; 
+
+int main() 
+{ 
+    int x = 0; 
+    if (x==0) 
+    { 
+        static Apple obj; 
+    } 
+    cout << "End of main\n"; 
+} 
+

english/basic_content/static/static_demo.cpp

@@ -0,0 +1,24 @@
+// the use of static Static 
+// variables in a Function 
+#include <iostream> 
+#include <string> 
+using namespace std; 
+
+void demo() 
+{ 
+    // static variable 
+    static int count = 0; 
+    cout << count << " "; 
+
+    // value is updated and 
+    // will be carried to next 
+    // function calls 
+    count++; 
+} 
+
+int main() 
+{ 
+    for (int i=0; i<5; i++)  
+        demo(); 
+    return 0; 
+} 

english/basic_content/static/static_error_variable.cpp

@@ -0,0 +1,26 @@
+// variables inside a class 
+
+#include<iostream> 
+using namespace std; 
+
+class Apple 
+{ 
+    public: 
+        static int i; 
+
+        Apple() 
+        { 
+            // Do nothing 
+        }; 
+}; 
+
+int main() 
+{ 
+    Apple obj1; 
+    Apple obj2; 
+    obj1.i =2; 
+    obj2.i = 3; 
+
+    // prints value of i 
+    cout << obj1.i<<" "<<obj2.i; 
+} 

english/basic_content/static/static_funciton.cpp

@@ -0,0 +1,20 @@
+#include<iostream> 
+using namespace std; 
+
+class Apple 
+{ 
+    public: 
+        // static member function 
+        static void printMsg() 
+        { 
+            cout<<"Welcome to Apple!"; 
+        } 
+}; 
+
+// main function 
+int main() 
+{ 
+    // invoking a static member function 
+    Apple::printMsg(); 
+} 
+

english/basic_content/static/static_variable.cpp

@@ -0,0 +1,24 @@
+// variables inside a class 
+
+#include<iostream> 
+using namespace std; 
+
+class GfG 
+{ 
+    public: 
+        static int i; 
+
+        GfG() 
+        { 
+            // Do nothing 
+        }; 
+}; 
+
+int GfG::i = 1; 
+
+int main() 
+{ 
+    GfG obj; 
+    // prints value of i 
+    cout << obj.i; 
+} 

english/basic_content/struct/README.md

@@ -0,0 +1,228 @@
+# 一文搞懂C和C++中struct
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+## 1.C中struct
+
+- 在C中struct只单纯的用作数据的复合类型，也就是说，在结构体声明中只能将数据成员放在里面，而不能将函数放在里面。 
+- 在C结构体声明中不能使用C++访问修饰符，如：public、protected、private 而在C++中可以使用。
+- 在C中定义结构体变量，如果使用了下面定义必须加struct。
+- C的结构体不能继承（没有这一概念）。
+- 若结构体的名字与函数名相同，可以正常运行且正常的调用！例如：可以定义与 struct Base 不冲突的 void Base() {}。
+
+完整案例：
+
+```c
+#include<stdio.h>
+
+struct Base {            // public
+    int v1; 
+//    public:      //error
+        int v2; 
+    //private:
+        int v3; 
+    //void print(){       // c中不能在结构体中嵌入函数
+    //    printf("%s\n","hello world");
+    //};    //error!
+};
+
+void Base(){
+    printf("%s\n","I am Base func");
+}
+//struct Base base1;  //ok
+//Base base2; //error
+int main() {
+    struct Base base;
+    base.v1=1;
+    //base.print();
+    printf("%d\n",base.v1);
+    Base();
+    return 0;
+}
+```
+
+最后输出：
+
+```
+1
+I am Base func
+```
+
+完整代码见：[struct_func.c](./struct_func.c)
+
+## 2.C++中struct
+
+与C对比如下：
+
+- C++结构体中不仅可以定义数据，还可以定义函数。
+- C++结构体中可以使用访问修饰符，如：public、protected、private 。
+- C++结构体使用可以直接使用不带struct。
+- C++继承
+- 若结构体的名字与函数名相同，可以正常运行且正常的调用！但是定义结构体变量时候只用用带struct的！
+
+例如：
+
+> 情形1：不适用typedef定义结构体别名
+
+未添加同名函数前：
+
+```c++
+struct Student {
+    
+};
+Student(){}
+Struct Student s; //ok
+Student s;  //ok
+```
+
+添加同名函数后：
+
+```c++
+struct Student {
+    
+};
+Student(){}
+Struct Student s; //ok
+Student s;  //error
+```
+
+> 情形二：使用typedef定义结构体别名
+
+```c++
+typedef struct Base1 {         
+    int v1;
+//    private:   //error!
+        int v3;
+    public:     //显示声明public
+        int v2;
+    void print(){       
+        printf("%s\n","hello world");
+    };    
+}B;
+//void B() {}  //error! 符号 "B" 已经被定义为一个 "struct Base1" 的别名
+```
+
+> 前三种案例
+
+```c++
+#include<iostream>
+#include<stdio.h>
+
+struct Base {         
+    int v1;
+//    private:   //error!
+        int v3;
+    public:     //显示声明public
+        int v2;
+    void print(){       
+        printf("%s\n","hello world");
+    };    
+};
+
+int main() {
+    struct Base base1;  //ok
+    Base base2; //ok
+    Base base;
+    base.v1=1;
+    base.v3=2;
+    base.print();
+    printf("%d\n",base.v1);
+    printf("%d\n",base.v3);
+    return 0;
+}
+```
+
+完整代码见：[struct_func.cpp](struct_func.cpp)
+
+> 继承案例
+
+```c++
+#include<iostream>
+#include<stdio.h>
+struct Base {         
+    int v1;
+//    private:   //error!
+        int v3;
+    public:   //显示声明public
+        int v2;
+    virtual void print(){       
+        printf("%s\n","Base");
+    };    
+};
+struct Derived:Base {         
+
+    public:
+        int v2;
+    void print(){       
+        printf("%s\n","Derived");
+    };    
+};
+int main() {
+    Base *b=new Derived();
+    b->print();
+    return 0;
+}
+```
+
+完整代码见：[ext_struct_func.cpp](./ext_struct_func.cpp)
+
+> 同名函数
+
+```c++
+#include<iostream>
+#include<stdio.h>
+
+struct Base {         
+    int v1;
+//    private:   //error!
+        int v3;
+    public:     //显示声明public
+        int v2;
+    void print(){       
+        printf("%s\n","hello world");
+    };    
+};
+
+typedef struct Base1 {         
+    int v1;
+//    private:   //error!
+        int v3;
+    public:     //显示声明public
+        int v2;
+    void print(){       
+        printf("%s\n","hello world");
+    };    
+}B;
+void Base(){
+    printf("%s\n","I am Base func");
+}
+//void B() {}  //error! 符号 "B" 已经被定义为一个 "struct Base1" 的别名
+int main() {
+    struct Base base;  //ok
+    //Base base1;  // error!
+    base.v1=1;
+    base.v3=2;
+    base.print();
+    printf("%d\n",base.v1);
+    printf("%d\n",base.v3);
+    Base();
+    return 0;
+}
+```
+完整代码见：[struct_func_func.cpp](./struct_func_func.cpp)
+
+## 3.总结
+
+### C和C++中的Struct区别
+
+| C                                                      | C++                                                          |
+| ------------------------------------------------------ | ------------------------------------------------------------ |
+| 不能将函数放在结构体声明                               | 能将函数放在结构体声明                                       |
+| 在C结构体声明中不能使用C++访问修饰符。                 | public、protected、private 在C++中可以使用。                 |
+| 在C中定义结构体变量，如果使用了下面定义必须加struct。  | 可以不加struct                                               |
+| 结构体不能继承（没有这一概念）。                       | 可以继承                                                     |
+| 若结构体的名字与函数名相同，可以正常运行且正常的调用！ | 若结构体的名字与函数名相同，使用结构体，只能使用带struct定义！ |

english/basic_content/struct/ext_struct_func.cpp

@@ -0,0 +1,33 @@
+#include<iostream>
+#include<stdio.h>
+using namespace std;
+struct Base {         
+    int v1;
+//    private:   //error!
+        int v3;
+    public:   //显示声明public
+        int v2;
+    virtual void print(){       
+        printf("%s\n","Base");
+    };    
+    Base(){cout<<"Base construct"<<endl;};
+    virtual ~Base(){cout<<"Base deconstruct"<<endl;};
+};
+
+struct Derived:Base {         
+
+    Derived(){cout<<"Derived construct"<<endl;};
+    virtual ~Derived(){cout<<"Derived deconstruct"<<endl;};
+    public:
+        int v2;
+    void print(){       
+        printf("%s\n","Derived");
+    };    
+};
+
+int main() {
+    Base *b=new Derived();
+    b->print();
+    delete b;
+    return 0;
+}

english/basic_content/struct/struct_func.c

@@ -0,0 +1,27 @@
+#include<stdio.h>
+
+struct Base {            // public
+    int v1;
+//    public:      //error
+        int v2;
+    //private:
+        int v3;
+    //void print(){       // c中不能在结构体中嵌入函数
+    //    printf("%s\n","hello world");
+    //};    //error!
+};
+
+void Base(){
+    printf("%s\n","I am Base func");
+}
+//struct Base base1;  //ok
+//Base base2; //error
+
+int main() {
+    struct Base base;
+    base.v1=1;
+    //base.print();
+    printf("%d\n",base.v1);
+    Base();
+    return 0;
+}

english/basic_content/struct/struct_func.cpp

@@ -0,0 +1,25 @@
+#include<iostream>
+#include<stdio.h>
+
+struct Base {         
+    int v1;
+//    private:   //error!
+        int v3;
+    public:     //显示声明public
+        int v2;
+    void print(){       
+        printf("%s\n","hello world");
+    };    
+};
+
+int main() {
+    struct Base base1;  //ok
+    Base base2; //ok
+    Base base;
+    base.v1=1;
+    base.v3=2;
+    base.print();
+    printf("%d\n",base.v1);
+    printf("%d\n",base.v3);
+    return 0;
+}

english/basic_content/struct/struct_func_func.cpp

@@ -0,0 +1,39 @@
+#include<iostream>
+#include<stdio.h>
+
+struct Base {         
+    int v1;
+//    private:   //error!
+        int v3;
+    public:     //显示声明public
+        int v2;
+    void print(){       
+        printf("%s\n","hello world");
+    };    
+};
+
+typedef struct Base1 {         
+    int v1;
+//    private:   //error!
+        int v3;
+    public:     //显示声明public
+        int v2;
+    void print(){       
+        printf("%s\n","hello world");
+    };    
+}B;
+void Base(){
+    printf("%s\n","I am Base func");
+}
+//void B() {}  //error! 符号 "B" 已经被定义为一个 "struct Base1" 的别名
+int main() {
+    struct Base base;  //ok
+    //Base base1;  // error!
+    base.v1=1;
+    base.v3=2;
+    base.print();
+    printf("%d\n",base.v1);
+    printf("%d\n",base.v3);
+    Base();
+    return 0;
+}

english/basic_content/struct_class/README.md

@@ -0,0 +1,19 @@
+# struct与class区别
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+关于C与C++中struct内容：见[struct那些事](../struct)
+
+总的来说，struct 更适合看成是一个数据结构的实现体，class 更适合看成是一个对象的实现体。
+
+区别:
+
+最本质的一个区别就是默认的访问控制
+
+默认的继承访问权限。struct 是 public 的，class 是 private 的。
+
+struct 作为数据结构的实现体，它默认的数据访问控制是 public 的，而 class 作为对象的实现体，它默认的成员变量访问控制是 private 的。

english/basic_content/this/README.md

@@ -0,0 +1,89 @@
+# this指针那些事
+
+## 关于作者
+
+微信公众号：
+
+![](../img/wechat.jpg)
+
+## 1.this指针
+
+相信在坐的很多人，都在学Python，对于Python来说有self，类比到C++中就是this指针，那么下面一起来深入分析this指针在类中的使用！
+
+首先来谈谈this指针的用处：
+
+（1）一个对象的this指针并不是对象本身的一部分，不会影响sizeof(对象)的结果。
+
+（2）this作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说，即使你没有写上this指针，编译器在编译的时候也是加上this的，它作为非静态成员函数的隐含形参，对各成员的访问均通过this进行。
+
+其次，this指针的使用：
+
+（1）在类的非静态成员函数中返回类对象本身的时候，直接使用 return *this。
+
+（2）当参数与成员变量名相同时，如this->n = n （不能写成n = n)。
+
+另外，在网上大家会看到this会被编译器解析成`A *const `，`A const * `，究竟是哪一个呢？下面通过断点调试分析：
+
+现有如下例子：
+
+```c++
+#include<iostream>
+#include<cstring>
+
+
+using namespace std;
+class Person{
+public:
+    typedef enum {
+        BOY = 0, 
+        GIRL 
+    }SexType;
+    Person(char *n, int a,SexType s){
+        name=new char[strlen(n)+1];
+        strcpy(name,n);
+        age=a;
+        sex=s;
+    }
+    int get_age() const{
+    
+        return this->age; 
+    }
+    Person& add_age(int a){
+        age+=a;
+        return *this; 
+    }
+    ~Person(){
+        delete [] name;
+    }
+private:
+    char * name;
+    int age;
+    SexType sex;
+};
+
+
+int main(){
+    Person p("zhangsan",20,Person::BOY); 
+    cout<<p.get_age()<<endl;
+	cout<<p.add_age(10).get_age()<<endl;
+    return 0;
+}
+```
+
+对于这个简单的程序，相信大家没得问题吧，就是定义了一个类，然后初始化构造函数，并获取这个人的年龄，设置后，再获取！
+
+为了验证this指针是哪一个，现在在`add_age`处添加断点，运行后如下：
+
+![thiscontrust](./img/thiscontrust.png)
+
+![genthis](./img/genthis.png)
+
+会发现编译器自动为我们加上`A* const`，而不是`A const *this`！
+
+紧接着，上述还有个常函数，那么我们在对`get_age`添加断点，如下：
+
+![constthis](./img/constthis.png)
+
+会发现编译器把上述的this，变为`const A* const`，这个大家也能想到，因为这个函数是const函数，那么针对const函数，它只能访问const变量与const函数，不能修改其他变量的值，所以需要一个this指向不能修改的变量，那就是`const A*`,又由于本身this是`const`指针，所以就为`const A* const`!
+
+总结：this在成员函数的开始执行前构造，在成员的执行结束后清除。上述的get_age函数会被解析成`get_age(const A * const this)`,`add_age`函数会被解析成`add_age(A* const this,int a)`。在C++中类和结构是只有一个区别的：类的成员默认是private，而结构是public。this是类的指针，如果换成结构，那this就是结构的指针了。

english/basic_content/this/person.cpp

@@ -0,0 +1,41 @@
+#include<iostream>
+#include<cstring>
+
+
+using namespace std;
+class Person{
+public:
+    typedef enum {
+        BOY = 0, 
+        GIRL 
+    }SexType;
+    Person(char *n, int a,SexType s){
+        name=new char[strlen(n)+1];
+        strcpy(name,n);
+        age=a;
+        sex=s;
+    }
+    int get_age() const{
+    
+        return this->age; 
+    }
+    Person& add_age(int a){
+        age+=a;
+        return *this; 
+    }
+    ~Person(){
+        delete [] name;
+    }
+private:
+    char * name;
+    int age;
+    SexType sex;
+};
+
+
+int main(){
+    Person p("zhangsan",20,Person::BOY); 
+    cout<<p.get_age()<<endl;
+
+    return 0;
+}

english/basic_content/union/README.md

@@ -0,0 +1,18 @@
+# UNION那些事
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+联合（union）是一种节省空间的特殊的类，一个 union 可以有多个数据成员，但是在任意时刻只有一个数据成员可以有值。当某个成员被赋值后其他成员变为未定义状态。联合有如下特点：
+
+- 默认访问控制符为 public
+- 可以含有构造函数、析构函数
+- 不能含有引用类型的成员
+- 不能继承自其他类，不能作为基类
+- 不能含有虚函数
+- 匿名 union 在定义所在作用域可直接访问 union 成员
+- 匿名 union 不能包含 protected 成员或 private 成员
+- 全局匿名联合必须是静态（static）的

english/basic_content/union/union.cpp

@@ -0,0 +1,50 @@
+/**
+ * @file union.cpp
+ * @brief UNION
+ * @author 光城
+ * @version v1
+ * @date 2019-08-06
+ */
+
+#include<iostream>
+/**
+ * 默认访问控制符为public
+ */
+union UnionTest {
+    /**
+     * 可以含有构造函数、析构函数
+     */
+    UnionTest() : i(10) {print(i);};
+    ~UnionTest(){};
+    int i; 
+private:
+    void print(int i){std::cout<<i<<std::endl;};
+};
+/**
+ * 全局匿名联合必须是静态的 
+ */
+static union {
+    int i;
+    double d;
+};
+
+int main() {
+    UnionTest u;
+
+    union {
+        int i;
+        double d;
+    };
+
+    std::cout << u.i << std::endl;  // 输出 UnionTest 联合的 10
+
+    ::i = 20;
+    std::cout << ::i << std::endl;  // 输出全局静态匿名联合的 20
+    /**
+     * 匿名union在定义所在作用域可直接访问union成员
+     */
+    i = 30;
+    std::cout << i << std::endl;    // 输出局部匿名联合的 30
+
+    return 0;
+}

english/basic_content/using/README.md

@@ -0,0 +1,120 @@
+# using那些事
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+## 基本使用
+
+局部与全局using，具体操作与使用见下面案例：
+
+```c++
+#include <iostream>
+#define isNs1 1
+//#define isGlobal 2
+using namespace std;
+void func() 
+{
+    cout<<"::func"<<endl;
+}
+
+namespace ns1 {
+    void func()
+    {
+        cout<<"ns1::func"<<endl; 
+    }
+}
+
+namespace ns2 {
+#ifdef isNs1 
+    using ns1::func;    /// ns1中的函数
+#elif isGlobal
+    using ::func; /// 全局中的函数
+#else
+    void func() 
+    {
+        cout<<"other::func"<<endl; 
+    }
+#endif
+}
+
+int main() 
+{
+    /**
+     * 这就是为什么在c++中使用了cmath而不是math.h头文件
+     */
+    ns2::func(); // 会根据当前环境定义宏的不同来调用不同命名空间下的func()函数
+    return 0;
+}
+```
+完整代码见：[using_global.cpp](using_global.cpp)
+## 改变访问性
+
+```
+class Base{
+public:
+ std::size_t size() const { return n;  }
+protected:
+ std::size_t n;
+};
+class Derived : private Base {
+public:
+ using Base::size;
+protected:
+ using Base::n;
+};
+```
+
+类Derived私有继承了Base，对于它来说成员变量n和成员函数size都是私有的，如果使用了using语句，可以改变他们的可访问性，如上述例子中，size可以按public的权限访问，n可以按protected的权限访问。
+完整代码见：[derived_base.cpp](derived_base.cpp)
+## 函数重载
+
+在继承过程中，派生类可以覆盖重载函数的0个或多个实例，一旦定义了一个重载版本，那么其他的重载版本都会变为不可见。
+
+如果对于基类的重载函数，我们需要在派生类中修改一个，又要让其他的保持可见，必须要重载所有版本，这样十分的繁琐。
+
+```c++
+#include <iostream>
+using namespace std;
+
+class Base{
+    public:
+        void f(){ cout<<"f()"<<endl;
+        }
+        void f(int n){
+            cout<<"Base::f(int)"<<endl;
+        }
+};
+
+class Derived : private Base {
+    public:
+        using Base::f;
+        void f(int n){
+            cout<<"Derived::f(int)"<<endl;
+        }
+};
+
+int main()
+{
+    Base b;
+    Derived d;
+    d.f();
+    d.f(1);
+    return 0;
+}
+```
+如上代码中，在派生类中使用using声明语句指定一个名字而不指定形参列表，所以一条基类成员函数的using声明语句就可以把该函数的所有重载实例添加到派生类的作用域中。此时，派生类只需要定义其特有的函数就行了，而无需为继承而来的其他函数重新定义。
+
+完整代码见：[using_derived.cpp](using_derived.cpp)
+## 取代typedef
+
+C中常用typedef A B这样的语法，将B定义为A类型，也就是给A类型一个别名B
+
+对应typedef A B，使用using B=A可以进行同样的操作。
+
+```c++
+typedef vector<int> V1; 
+using V2 = vector<int>;
+```
+完整代码见：[using_typedef.cpp](using_typedef.cpp)

english/basic_content/using/derived_base.cpp

@@ -0,0 +1,48 @@
+#include <iostream>
+
+using namespace std;
+
+class Base1 {
+    public:
+        Base1():value(10) {}
+        virtual ~Base1() {}
+        void test1() { cout << "Base test1..." << endl; }
+    protected: // 保护
+        int value;
+};
+// 默认为私有继承
+class Derived1 : Base1 {
+    public:
+        void test2() { cout << "value is " << value << endl; }
+};
+
+class Base {
+    public:
+        Base():value(20) {}
+        virtual ~Base() {}
+        void test1() { cout << "Base test1..." << endl; }
+    private:  //私有
+        int value;
+};
+
+/**
+ * 子类对父类成员的访问权限跟如何继承没有任何关系，
+ * “子类可以访问父类的public和protected成员，不可以访问父类的private成员”——这句话对任何一种继承都是成立的。
+ *
+ */
+class Derived : Base {
+    public:
+        using Base::value;
+        void test2() { cout << "value is " << value << endl; }
+};
+
+
+int main() 
+{
+    Derived1 d1;
+    d1.test2();
+
+    Derived d;
+    d.test2();
+    return 0;
+}