From 79914fb9b91b373a81ff0f964dd0b92643a1fbf3 Mon Sep 17 00:00:00 2001
From: walterzhaojr <519362600@qq.com>
Date: Thu, 4 Jun 2020 14:45:47 +0000
Subject: [PATCH 01/62] add producer_consumer design_pattern

---
 .../producer_consumer/producer_consumer.cpp   | 104 ++++++++++++++++++
 1 file changed, 104 insertions(+)
 create mode 100644 design_pattern/producer_consumer/producer_consumer.cpp

diff --git a/design_pattern/producer_consumer/producer_consumer.cpp b/design_pattern/producer_consumer/producer_consumer.cpp
new file mode 100644
index 0000000..534cff8
--- /dev/null
+++ b/design_pattern/producer_consumer/producer_consumer.cpp
@@ -0,0 +1,104 @@
+#include <iostream>
+#include <vector>
+#include <mutex>
+#include <thread>
+#include <condition_variable>
+#include <unistd.h>
+
+using namespace std;
+
+const int MAX_NUM = 10000;
+
+class BoundedBuffer
+{
+public:
+  BoundedBuffer(size_t n) {
+    array_.resize(n);
+    start_pos_ = 0;
+    end_pos_ = 0;
+    pos_ = 0;
+  }
+  void Produce(int n) {
+    {
+      std::unique_lock<std::mutex> lock(mtx_);
+      //wait for not full
+      not_full_.wait(lock, [=] { return pos_ < array_.size(); });
+
+      usleep(1000 * 400);
+      array_[end_pos_] = n;
+      end_pos_ = (end_pos_ + 1) % array_.size();
+      ++pos_;
+      cout << "Produce pos:" << pos_ << endl;
+    } //auto unlock
+
+    not_empty_.notify_one();
+  }
+  
+  int Consume() {
+    std::unique_lock<std::mutex> lock(mtx_);
+    //wait for not empty
+    not_empty_.wait(lock, [=] { return pos_ > 0; });
+    
+    usleep(1000 * 400);
+    int n = array_[start_pos_];
+    start_pos_ = (start_pos_ + 1) % array_.size();
+    --pos_;
+    cout << "Consume pos:" << pos_ << endl;
+    lock.unlock();
+
+    not_full_.notify_one();
+
+    return n;
+  }
+private:
+  std::vector<int> array_;
+  size_t start_pos_;
+  size_t end_pos_;
+  size_t pos_;
+  std::mutex mtx_;
+  std::condition_variable not_full_;
+  std::condition_variable not_empty_;
+};
+
+BoundedBuffer bb(10);
+std::mutex g_mtx;
+
+void Producer()
+{
+  int n = 0;
+  while(n < 100) {
+    bb.Produce(n);
+    cout << "Producer:" << n << endl;
+    n++;
+  }
+
+  bb.Produce(-1);
+}
+
+
+void Consumer()
+{
+  std::thread::id thread_id = std::this_thread::get_id();
+  int n = 0;
+  do {
+    n = bb.Consume();
+    cout << "Consumer thread:" << thread_id << "=====> " << n << endl;
+  } while(-1 != n);
+
+  bb.Produce(-1);
+}
+
+int main()
+{
+  std::vector<std::thread> t;
+  t.push_back(std::thread(&Producer));
+  t.push_back(std::thread(&Consumer));
+  t.push_back(std::thread(&Consumer));
+  t.push_back(std::thread(&Consumer));
+  
+  for (auto& one : t) {
+    one.join();
+  }
+
+  return 0;
+}

From d7486e76e5d3360f78b5bcc84a52c1c5e206c3d3 Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Sun, 7 Jun 2020 09:20:58 +0800
Subject: [PATCH 02/62] Update README.md

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 6754cfa..4b6bd94 100644
--- a/README.md
+++ b/README.md
@@ -219,6 +219,7 @@ C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
 ### 4.设计模式
 
 - [单例模式](./design_pattern/singleton)
+- [生产消费者模式](./design_pattern/producer_consumer)
 
 ### 5. [STL 源码剖析](./src_analysis/stl)
 

From 9e1c3a9abd2e5fe99b2b700fadc6eee1f472655b Mon Sep 17 00:00:00 2001
From: Aurelius84 <liujiezhangbupt@gmail.com>
Date: Mon, 8 Jun 2020 20:34:54 +0800
Subject: [PATCH 03/62] Reformat code and add cJSON_print function

---
 practical_exercises/10_day_practice/day9/异常例子/3.cpp | 6 +++---
 practical_exercises/10_day_practice/day9/异常例子/9.cpp | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/practical_exercises/10_day_practice/day9/异常例子/3.cpp b/practical_exercises/10_day_practice/day9/异常例子/3.cpp
index bad186e..3783762 100644
--- a/practical_exercises/10_day_practice/day9/异常例子/3.cpp
+++ b/practical_exercises/10_day_practice/day9/异常例子/3.cpp
@@ -3,11 +3,11 @@ using namespace std;
 void temperature(int t)
 {
     try{
-        if(t==100) throw "�е㣡";
-        else if(t==0) throw "���㣡";
+        if(t==100) throw "It's at the boiling point.";
+        else if(t==0) throw "It reached the freezing point";
         else cout<<"the temperature is OK..."<<endl;
     }
-    catch(int x){cout<<"temperatore="<<x<<endl;}
+    catch(int x){cout<<"temperature="<<x<<endl;}
     catch(char const*s){cout<<s<<endl;}
 }
 int main(){
diff --git a/practical_exercises/10_day_practice/day9/异常例子/9.cpp b/practical_exercises/10_day_practice/day9/异常例子/9.cpp
index 05abf22..09b0e2a 100644
--- a/practical_exercises/10_day_practice/day9/异常例子/9.cpp
+++ b/practical_exercises/10_day_practice/day9/异常例子/9.cpp
@@ -17,9 +17,9 @@ class DiskNotFound:public FileSysException{
     public:
         char *Where(){return "DiskNotFound...";}
 };
-void main(){
+int main(){
     try{
-         .....  //�������
+//         .....  //�������
          throw FileSysException();
     }
     catch(DiskNotFound p){cout<<p.Where()<<endl;}
@@ -27,7 +27,7 @@ void main(){
     catch(FileSysException p){cout<<p.Where()<<endl;}
     catch(BasicException p){cout<<p.Where()<<endl;}
     try{
-        .....  //�������
+//        .....  //�������
          throw DiskNotFound();
     }
     catch(BasicException p){cout<<p.Where()<<endl;}

From 5894e8cde0974ca549f34a9a580c028377021a37 Mon Sep 17 00:00:00 2001
From: Aurelius84 <liujiezhangbupt@gmail.com>
Date: Fri, 12 Jun 2020 20:30:35 +0800
Subject: [PATCH 04/62] refine content of abstract

---
 basic_content/abstract/README.md              | 126 +++++++++++++++---
 basic_content/abstract/abstract.cpp           |   8 +-
 basic_content/abstract/derived_full.cpp       |   2 +-
 basic_content/abstract/interesting_facts1.cpp |   1 -
 basic_content/abstract/interesting_facts3.cpp |   1 -
 basic_content/abstract/pure_virtual.cpp       |  13 +-
 6 files changed, 116 insertions(+), 35 deletions(-)

diff --git a/basic_content/abstract/README.md b/basic_content/abstract/README.md
index 5629dc1..e11aa35 100644
--- a/basic_content/abstract/README.md
+++ b/basic_content/abstract/README.md
@@ -8,51 +8,133 @@
 
 ## 1.纯虚函数与抽象类
 
-C++中的纯虚函数(或抽象函数)是我们没有实现的虚函数！我们只需声明它!通过声明中赋值0来声明纯虚函数！
+C++中的纯虚函数(或抽象函数)是我们没有实现的虚函数！我们只需声明它! 通过声明中赋值0来声明纯虚函数！
+```cpp
+// 抽象类
+Class A {
+public: 
+    virtual void show() = 0; // 纯虚函数
+    /* Other members */
+}; 
+```
 
-对应的代码：[test.cpp](./test.cpp)
-
- *  纯虚函数：没有函数体的虚函数
+ * 纯虚函数：没有函数体的虚函数
  * 抽象类：包含纯虚函数的类
 
-对应的代码：[pure_virtual.cpp](./pure_virtual.cpp)
-
 抽象类只能作为基类来派生新类使用，不能创建抽象类的对象,抽象类的指针和引用->由抽象类派生出来的类的对象！
 
+> 代码样例：[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(){}  // 构造函数
+};
 
-对应的代码：[abstract.cpp](./abstract.cpp)
+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; } // 普通成员函数
 
-对应的代码：[interesting_facts1.cpp](./interesting_facts1.cpp)
+private:
+     int x; 
+}; 
+```
 
-- 抽象类类型的指针和引用
+- [抽象类类型的指针和引用](./interesting_facts2.cpp)
+```cpp
+class Derived : public Base { 
+public: 
+    void show() { cout << "In Derived \n"; } // 实现抽象类的纯虚函数
+    Derived(){} // 构造函数
+}; 
 
-对应的代码：[interesting_facts2.cpp](./interesting_facts2.cpp)
+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_facts3.cpp](./interesting_facts3.cpp)
+- [抽象类可以有构造函数](./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;
+};
 
-对应的代码：[interesting_facts4.cpp](./interesting_facts4.cpp)
-
-- 构造函数不能是虚函数，而析构函数可以是虚析构函数。
-
-对应的代码：[interesting_facts5.cpp](./interesting_facts5.cpp)
-
-当基类指针指向派生类对象并删除对象时，我们可能希望调用适当的析构函数。如果析构函数不是虚拟的，则只能调用基类析构函数。
+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)
\ No newline at end of file
+> 代码样例：[derived_full.cpp](./derived_full.cpp)
\ No newline at end of file
diff --git a/basic_content/abstract/abstract.cpp b/basic_content/abstract/abstract.cpp
index 61e6665..3a26d99 100644
--- a/basic_content/abstract/abstract.cpp
+++ b/basic_content/abstract/abstract.cpp
@@ -7,16 +7,12 @@
  * @date 2019-07-20
  */
 
-
-
-
 #include<iostream>
-
-
 using namespace std;
+
 class A {
 public:
-    virtual void f() = 0;
+    virtual void f() = 0;  // 纯虚函数
     void g(){ this->f(); }
     A(){}
 };
diff --git a/basic_content/abstract/derived_full.cpp b/basic_content/abstract/derived_full.cpp
index 90a938f..176ace8 100644
--- a/basic_content/abstract/derived_full.cpp
+++ b/basic_content/abstract/derived_full.cpp
@@ -21,7 +21,7 @@ class Derived: public Base
 { 
     int y; 
     public: 
-    void fun() { cout << "fun() called"; }  ///< 实现了fun()函数
+    void fun() { cout << "fun() called"; }  // 实现了fun()函数
 }; 
 
 int main(void) 
diff --git a/basic_content/abstract/interesting_facts1.cpp b/basic_content/abstract/interesting_facts1.cpp
index c98690d..048ede7 100644
--- a/basic_content/abstract/interesting_facts1.cpp
+++ b/basic_content/abstract/interesting_facts1.cpp
@@ -9,7 +9,6 @@
 #include<iostream> 
 using namespace std; 
 
-
 /**
  * @brief 抽象类至少包含一个纯虚函数
  */
diff --git a/basic_content/abstract/interesting_facts3.cpp b/basic_content/abstract/interesting_facts3.cpp
index 6ff352b..fb76824 100644
--- a/basic_content/abstract/interesting_facts3.cpp
+++ b/basic_content/abstract/interesting_facts3.cpp
@@ -9,7 +9,6 @@
 #include<iostream> 
 using namespace std; 
 
-
 class Base
 { 
     int x; 
diff --git a/basic_content/abstract/pure_virtual.cpp b/basic_content/abstract/pure_virtual.cpp
index ab552d4..bfaf177 100644
--- a/basic_content/abstract/pure_virtual.cpp
+++ b/basic_content/abstract/pure_virtual.cpp
@@ -16,14 +16,19 @@ class A
 private:
     int a;
 public:
-    virtual void show()=0; //< 纯虚函数
+    virtual void show()=0; // 纯虚函数
 };
 
 
 int main()
 {
-    //  抽象类只能作为基类来派生新类使用，不能创建抽象类的对象,抽象类的指针和引用->由抽象类派生出来的类的对象！
-//    A a; // error 抽象类，不能创建对象
+    /*
+     * 1. 抽象类只能作为基类来派生新类使用
+     * 2. 抽象类的指针和引用->由抽象类派生出来的类的对象！
+     */
+    A a; // error 抽象类，不能创建对象
+
     A *a1; // ok 可以定义抽象类的指针
-//    A *a2 = new A; // error,A是抽象类，不能创建对象
+
+    A *a2 = new A(); // error, A是抽象类，不能创建对象
 }

From 360192df58aa1d2fa10870dd6e27bba1042ff5b2 Mon Sep 17 00:00:00 2001
From: Aurelius84 <liujiezhangbupt@gmail.com>
Date: Fri, 12 Jun 2020 21:01:48 +0800
Subject: [PATCH 05/62] refine content of assert and const

---
 basic_content/assert/assert | Bin 8664 -> 0 bytes
 basic_content/assert/iga    | Bin 8560 -> 0 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)
 delete mode 100755 basic_content/assert/assert
 delete mode 100755 basic_content/assert/iga

diff --git a/basic_content/assert/assert b/basic_content/assert/assert
deleted file mode 100755
index 7ece973cee8f7d7fe835e273ea108840cba44091..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8664
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

diff --git a/basic_content/assert/iga b/basic_content/assert/iga
deleted file mode 100755
index 618f153d55e8899cbf929ed9c24428806ece1eca..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8560
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


From ce125cfa5fef691131483a6a85de46d32243ff9b Mon Sep 17 00:00:00 2001
From: Aurelius84 <liujiezhangbupt@gmail.com>
Date: Fri, 12 Jun 2020 21:03:43 +0800
Subject: [PATCH 06/62] refine content of assert and const

---
 basic_content/assert/README.md       |  21 ++--
 basic_content/assert/ignore_assert.c |   4 +-
 basic_content/const/README.md        | 139 ++++++++++++---------------
 3 files changed, 78 insertions(+), 86 deletions(-)

diff --git a/basic_content/assert/README.md b/basic_content/assert/README.md
index 534fc49..8699eff 100644
--- a/basic_content/assert/README.md
+++ b/basic_content/assert/README.md
@@ -10,12 +10,17 @@
 
 ## 1.第一个断言案例
 
-断言，**是宏，而非函数**。assert 宏的原型定义在 <assert.h>（C）、<cassert>（C++）中，其作用是如果它的条件返回错误，则终止程序执行。可以通过定义 NDEBUG 来关闭 assert，但是需要在源代码的开头，include <assert.h> 之前。
+断言，**是宏，而非函数**。
+
+assert 宏的原型定义在 <assert.h>（C）、<cassert>（C++）中。其作用是如果它的条件返回错误，则终止程序执行。
+
+可以通过定义 `NDEBUG` 来关闭 assert，**但是需要在源代码的开头，include <assert.h> 之前。**
 
 ```c
 void assert(int expression);
 ```
-对应代码：[assert.c](./assert.c)
+
+> 代码样例：[assert.c](./assert.c)
 ```c
 #include <stdio.h> 
 #include <assert.h> 
@@ -35,22 +40,22 @@ int main()
 
     return 0; 
 } 
-
 ```
 输出：
 ```c
-assert: assert.c:13: main: Assertion `x==7' failed.
+assert: assert.c:13: main: Assertion 'x==7' failed.
 ```
 可以看到输出会把源码文件，行号错误位置，提示出来！
 
 ## 2.断言与正常错误处理
 
-断言主要用于检查逻辑上不可能的情况。例如，它们可用于检查代码在开始运行之前所期望的状态，或者在运行完成后检查状态。与正常的错误处理不同，断言通常在运行时被禁用。
++ 断言主要用于检查逻辑上不可能的情况。
 
-忽略断言：
+>例如，它们可用于检查代码在开始运行之前所期望的状态，或者在运行完成后检查状态。与正常的错误处理不同，断言通常在运行时被禁用。
 
-在代码开头加上：
++ 忽略断言，在代码开头加上：
 ```c++
 #define NDEBUG          // 加上这行，则 assert 不可用
 ```
-对应学习的代码：[ignore_assert.c](./ignore_assert.c)
+
+> 样例代码：[ignore_assert.c](./ignore_assert.c)
diff --git a/basic_content/assert/ignore_assert.c b/basic_content/assert/ignore_assert.c
index d3069e5..0a5a15e 100644
--- a/basic_content/assert/ignore_assert.c
+++ b/basic_content/assert/ignore_assert.c
@@ -6,12 +6,10 @@
  * @date 2019-07-25
  */
 
-# define NDEBUG
+# define NDEBUG // 忽略断言
 
 #include<assert.h>
 
-
-
 int main(){
     int x=7;
     assert(x==5);
diff --git a/basic_content/const/README.md b/basic_content/const/README.md
index 69af42c..c23e458 100644
--- a/basic_content/const/README.md
+++ b/basic_content/const/README.md
@@ -10,47 +10,45 @@
 
 ## 2.const作用
 
-（1）可以定义常量
++ 可以定义常量
 
-```c++
+```cpp
 const int a=100;
 ```
 
-（2）类型检查
++ 类型检查
 
-const常量与#define宏定义常量的区别：~~<u>**const常量具有类型，编译器可以进行安全检查；#define宏定义没有数据类型，只是简单的字符串替换，不能进行安全检查。**</u>~~感谢两位大佬指出这里问题，见：
+    + const常量与`#define`宏定义常量的区别：
+    > ~~<u>**const常量具有类型，编译器可以进行安全检查；#define宏定义没有数据类型，只是简单的字符串替换，不能进行安全检查。**</u>~~感谢两位大佬指出这里问题，见：[issue](https://github.com/Light-City/CPlusPlusThings/issues/5)
 
-> https://github.com/Light-City/CPlusPlusThings/issues/5
+    + const定义的变量只有类型为整数或枚举，且以常量表达式初始化时才能作为常量表达式。
+    + 其他情况下它只是一个 `const` 限定的变量，不要将与常量混淆。
 
-`const` 定义的变量只有类型为整数或枚举，且以常量表达式初始化时才能作为常量表达式。其他情况下它只是一个 `const` 限定的变量，不要将与常量混淆。
++ 防止修改，起保护作用，增加程序健壮性
 
-（3）防止修改，起保护作用，增加程序健壮性
-
-```c++
+```cpp
 void f(const int i){
     i++; //error!
 }
 ```
 
-（4）可以节省空间，避免不必要的内存分配
++ 可以节省空间，避免不必要的内存分配
 
-const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是像#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。
+    + const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是像`#define`一样给出的是立即数。
+    + const定义的常量在程序运行过程中只有一份拷贝，而`#define`定义的常量在内存中有若干个拷贝。
 
 ## 3.const对象默认为文件局部变量
 
 <p><font style="color:red">注意：非const变量默认为extern。要使const变量能够在其他文件中访问，必须在文件中显式地指定它为extern。</font></p>
+
 > 未被const修饰的变量在不同文件的访问
 
-```c++
+```cpp
 // file1.cpp
 int ext
 // file2.cpp
 #include<iostream>
-/**
- * by 光城
- * compile: g++ -o file file2.cpp file1.cpp
- * execute: ./file
- */
+
 extern int ext;
 int main(){
     std::cout<<(ext+10)<<std::endl;
@@ -59,23 +57,18 @@ int main(){
 
 > const常量在不同文件的访问
 
-```c++
+```cpp
 //extern_file1.cpp
 extern const int ext=12;
 //extern_file2.cpp
 #include<iostream>
-/**
- * by 光城
- * compile: g++ -o file const_file2.cpp const_file1.cpp
- * execute: ./file
- */
 extern const int ext;
 int main(){
     std::cout<<ext<<std::endl;
 }
 ```
 
-<p><font style="color:red">小结：可以发现未被const修饰的变量不需要extern显式声明！而const常量需要显式声明extern，并且需要做初始化！因为常量在定义后就不能被修改，所以定义时必须初始化。</font></p>
+> 小结：<br>可以发现未被const修饰的变量不需要extern显式声明！而const常量需要显式声明extern，并且需要做初始化！因为常量在定义后就不能被修改，所以定义时必须初始化。</font></p>
 
 ## 4.定义常量
 
@@ -86,7 +79,9 @@ const string s = "helloworld";
 const int i,j=0 // error: uninitialized const ‘i’
 ```
 
-上述有两个错误，第一：b为常量，不可更改！第二：i为常量，必须进行初始化！(因为常量在定义后就不能被修改，所以定义时必须初始化。)
+上述有两个错误：
++ b 为常量，不可更改！
++ i 为常量，必须进行初始化！(因为常量在定义后就不能被修改，所以定义时必须初始化。)
 
 ## 5.指针与const
 
@@ -99,13 +94,14 @@ char * const a; //指向类型对象的const指针。或者说常指针、const
 const char * const a; //指向const对象的const指针。
 ```
 
-小结：如果*const*位于`*`的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于`*`的右侧，*const*就是修饰指针本身，即指针本身是常量。
+> **小结：** <br>
+> 如果*const*位于`*`的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；<br>如果const位于`*`的右侧，*const*就是修饰指针本身，即指针本身是常量。
 
 具体使用如下：
 
-（1）指向常量的指针
+（1） **指向常量的指针**
 
-```c++
+```cpp
 const int *ptr;
 *ptr = 10; //error
 ```
@@ -140,12 +136,13 @@ int *ptr1 = &val;
 cout<<*ptr<<endl;
 ```
 
-<p><font style="color:red">小结：对于指向常量的指针，不能通过指针来修改对象的值。<br/>也不能使用void`*`指针保存const对象的地址，必须使用const void`*`类型的指针保存const对象的地址。<br/>允许把非const对象的地址赋值给const对象的指针，如果要修改指针所指向的对象值，必须通过其他方式修改，不能直接通过当前指针直接修改。</font></p>
-（2）常指针
+> 小结：<br>1.对于指向常量的指针，不能通过指针来修改对象的值。<br>2.不能使用void`*`指针保存const对象的地址，必须使用const void`*`类型的指针保存const对象的地址。<br>3.允许把非const对象的地址赋值给const对象的指针，如果要修改指针所指向的对象值，必须通过其他方式修改，不能直接通过当前指针直接修改。
+
+（2） **常指针**
 
 const指针必须进行初始化，且const指针的值不能修改。
 
-```c++
+```cpp
 #include<iostream>
 using namespace std;
 int main(){
@@ -162,7 +159,7 @@ int main(){
 
 最后，当把一个const常量的地址赋值给ptr时候，由于ptr指向的是一个变量，而不是const常量，所以会报错，出现：const int`*` -> int `*`错误！
 
-```c++
+```cpp
 #include<iostream>
 using namespace std;
 int main(){
@@ -174,11 +171,11 @@ int main(){
 
 上述若改为 const int `*`ptr或者改为const int `*`const ptr，都可以正常！
 
-（3）指向常量的常指针
+（3）**指向常量的常指针**
 
 理解完前两种情况，下面这个情况就比较好理解了：
 
-```c++
+```cpp
 const int p = 3;
 const int * const ptr = &p; 
 ```
@@ -191,17 +188,17 @@ ptr是一个const指针，然后指向了一个int 类型的const对象。
 
 这个跟const修饰普通变量以及指针的含义基本相同：
 
-（1）const int
+（1）**const int**
 
-```c++
+```cpp
 const int func1();
 ```
 
 这个本身无意义，因为参数返回本身就是赋值给其他的变量！
 
-（2）const int*
+（2）**const int***
 
-```c++
+```cpp
 const int* func2();
 ```
 
@@ -209,7 +206,7 @@ const int* func2();
 
 （3）int *const
 
-```c++
+```cpp
 int *const func2();
 ```
 
@@ -219,7 +216,7 @@ int *const func2();
 
 （1）传递过来的参数及指针本身在函数内不可变，无意义！
 
-```c++
+```cpp
 void func(const int var); // 传递过来的参数不可变
 void func(int *const var); // 指针本身不可变
 ```
@@ -228,60 +225,49 @@ void func(int *const var); // 指针本身不可变
 
 输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const 修饰。
 
-（2）参数指针所指内容为常量不可变
+（2）**参数指针所指内容为常量不可变**
 
-```c++
+```cpp
 void StringCopy(char *dst, const char *src);
 ```
 
 其中src 是输入参数，dst 是输出参数。给src加上const修饰后，如果函数体内的语句试图改动src的内容，编译器将指出错误。这就是加了const的作用之一。
 
-（3）参数为引用，为了增加效率同时防止修改。
+（3）**参数为引用，为了增加效率同时防止修改。**
 
-```c++
+```cpp
 void func(const A &a)
 ```
 
-对于非内部数据类型的参数而言，象void func(A a) 这样声明的函数注定效率比较低。因为函数体内将产生A 类型
-
-的临时对象用于复制参数a，而临时对象的构造、复制、析构过程都将消耗时间。
+对于非内部数据类型的参数而言，象void func(A a) 这样声明的函数注定效率比较低。因为函数体内将产生A 类型的临时对象用于复制参数a，而临时对象的构造、复制、析构过程都将消耗时间。
 
 为了提高效率，可以将函数声明改为void func(A &a)，因为“引用传递”仅借用一下参数的别名而已，不需要产生临
+时对象。
 
-时对象。但是函数void func(A &a) 存在一个缺点：
-
-“引用传递”有可能改变参数a，这是我们不期望的。解决这个问题很容易，加const修饰即可，因此函数最终成为
-
+> 但是函数void func(A &a) 存在一个缺点：<br><br>“引用传递”有可能改变参数a，这是我们不期望的。解决这个问题很容易，加const修饰即可，因此函数最终成为
 void func(const A &a)。
 
 以此类推，是否应将void func(int x) 改写为void func(const int &x)，以便提高效率？完全没有必要，因为内部数
 
 据类型的参数不存在构造、析构的过程，而复制也非常快，“值传递”和“引用传递”的效率几乎相当。
 
-<p><font style="color:red">小结：对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const 引用传递”，目的是提高效率。例如将void func(A a) 改为void func(const A &a)。<br/>对于内部数据类型的输入参数，不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void func(int x) 不应该改为void func(const int &x)。</font></p>
+> 小结：<br>1.对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const 引用传递”，目的是提高效率。例如将void func(A a) 改为void func(const A &a)。<br><br>2.对于内部数据类型的输入参数，不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void func(int x) 不应该改为void func(const int &x)。</font></p>
+
 以上解决了两个面试问题：
 
-（1）如果函数需要传入一个指针，是否需要为该指针加上const，把const加在指针不同的位置有什么区别；
-
-（2）如果写的函数需要传入的参数是一个复杂类型的实例，传入值参数或者引用参数有什么区别，什么时候需要为传入的引用参数加上const。 
++ 如果函数需要传入一个指针，是否需要为该指针加上const，把const加在指针不同的位置有什么区别；
++ 如果写的函数需要传入的参数是一个复杂类型的实例，传入值参数或者引用参数有什么区别，什么时候需要为传入的引用参数加上const。 
 
 ## 7.类中使用const
 
-在一个类中，任何不会修改数据成员的函数都应该声明为const类型。如果在编写const成员函数时，不慎修改
-
-数据成员，或者调用了其它非const成员函数，编译器将指出错误，这无疑会提高程序的健壮性。使用const关
-
-字进行说明的成员函数，称为常成员函数。只有常成员函数才有资格操作常量或常对象，没有使用const关键字
-
-明的成员函数不能用来操作常对象。
-
+在一个类中，任何不会修改数据成员的函数都应该声明为const类型。如果在编写const成员函数时，不慎修改 数据成员，或者调用了其它非const成员函数，编译器将指出错误，这无疑会提高程序的健壮性。
 
+使用const关键字进行说明的成员函数，称为常成员函数。只有常成员函数才有资格操作常量或常对象，没有使用const关键字进行说明的成员函数不能用来操作常对象。
 
 对于类中的const成员变量必须通过初始化列表进行初始化，如下所示：
 
-```c++
-class Apple
-{
+```cpp
+class Apple{
 private:
     int people[100];
 public:
@@ -299,7 +285,7 @@ const对象只能访问const成员函数,而非const对象可以访问任意的
 
 例如：
 
-```c++
+```cpp
 //apple.cpp
 class Apple
 {
@@ -347,8 +333,11 @@ int main(){
     b.add(100);
     return 0;
 }
-//编译： g++ -o main main.cpp apple.cpp
-//结果
+```
+> 编译： g++ -o main main.cpp apple.cpp<br>
+
+结果：
+```
 take func 1
 2
 take func 10
@@ -365,21 +354,21 @@ take func 100
 
 第一：将常量定义与static结合，也就是：
 
-```c++
+```cpp
 static const int apple_number
 ```
 
 第二：在外面初始化：
 
-```c++
+```cpp
 const int Apple::apple_number=10;
 ```
 
 当然，如果你使用c++11进行编译，直接可以在定义出初始化，可以直接写成：
 
-```c++
+```cpp
 static const int apple_number=10;
-或者
+// 或者
 const int apple_number=10;
 ```
 
@@ -393,13 +382,13 @@ const int apple_number=10;
 
 在类中声明：
 
-```c++
+```cpp
 static int ap;
 ```
 
 在类实现文件中使用：
 
-```c++
+```cpp
 int Apple::ap=666
 ```
 

From 6d40326e42045a050e29ef792a916747a0f69611 Mon Sep 17 00:00:00 2001
From: linbo0518 <linbo0518@gmail.com>
Date: Sat, 13 Jun 2020 17:15:59 -0500
Subject: [PATCH 07/62] fix typo: undered -> unordered

---
 src_analysis/stl/unordered_map.md | 46 +++++++++++++++----------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/src_analysis/stl/unordered_map.md b/src_analysis/stl/unordered_map.md
index bce0269..943dd94 100644
--- a/src_analysis/stl/unordered_map.md
+++ b/src_analysis/stl/unordered_map.md
@@ -9,8 +9,8 @@
 unordered_map与unordered_multimap的源码在`unordered_map.h`这个文件中。
 
 
-## 1.undered_map与unordered_multimap本质区别
-先来看一下undered_map源码：
+## 1.unordered_map与unordered_multimap本质区别
+先来看一下unordered_map源码：
 
 ```cpp
 template<class _Key, class _Tp,
@@ -51,13 +51,13 @@ typename _ExtractKey, typename _Equal,
 typename _H1, typename _H2, typename _Hash,
 typename _RehashPolicy, typename _Traits>
 ```
-默认情况下，undered_map采用：
+默认情况下，unordered_map采用：
 - H1为hash<key>
 - H2为_Mod_range_hashing
 - _Hash为_Default_ranged_hash
 - _RehashPolicy为_Prime_rehash_policy
 - _Traits为_Tr
-对于最后的_Tr,非常重要，因为正是因为这个参数，才有undered_multimap。
+对于最后的_Tr,非常重要，因为正是因为这个参数，才有unordered_multimap。
 具体分析看下面：
 
 
@@ -91,7 +91,7 @@ struct _Hashtable_traits
     using __unique_keys = __bool_constant<_Unique_keys>;
 };
 ```
-看到有三个using，理解为三个typedef，依次表示：hash code缓存与否，是否是常迭代器，是否是唯一的key，再往上回头看，传递进来的是三个模板参数，分别是false,false,true，也验证了undered_map是唯一的key，那么对应的undered_multimap就是不唯一的key，最后一个参数为false。我们翻阅到相应代码如下：
+看到有三个using，理解为三个typedef，依次表示：hash code缓存与否，是否是常迭代器，是否是唯一的key，再往上回头看，传递进来的是三个模板参数，分别是false,false,true，也验证了unordered_map是唯一的key，那么对应的unordered_multimap就是不唯一的key，最后一个参数为false。我们翻阅到相应代码如下：
 
 ```cpp
 /// Base types for unordered_multimap.
@@ -101,8 +101,8 @@ using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>;
 
 小结，在上面分析，我们知道了unordered_map与unordered_multimap的本质区别，也发现了如何在底层源码上用一个容器实现两个容器适配器！
 
-## 2.undered_set与unordered_multiset本质区别
-分析同前面一样，先看undered_set:
+## 2.unordered_set与unordered_multiset本质区别
+分析同前面一样，先看unordered_set:
 
 ```cpp
 template<class _Value,
@@ -129,35 +129,35 @@ using __uset_hashtable = _Hashtable<_Value, _Value, _Alloc,
                 __detail::_Default_ranged_hash,
                 __detail::_Prime_rehash_policy, _Tr>;
 ```
-可以看到传递给`_Hashtable_traits`的是false,true,true。对于undered_set来说使用的是const iterator与唯一的key,我们再看一下unordered_multiset：
+可以看到传递给`_Hashtable_traits`的是false,true,true。对于unordered_set来说使用的是const iterator与唯一的key,我们再看一下unordered_multiset：
 
 ```cpp
 template<bool _Cache>
 using __umset_traits = __detail::_Hashtable_traits<_Cache, true, false>;
 ```
-再将两者对比一下，本质就是undered_set不允许key重复，而undered_multiset允许key重复。
+再将两者对比一下，本质就是unordered_set不允许key重复，而unordered_multiset允许key重复。
 
 ## 3.三大结论
 
 现在，我们有了前面基础，依次列出前面四个容器适配器：
 
-(1) undered_map
+(1) unordered_map
 ```cpp
 template<bool _Cache>
 using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>;
 ```
-(2) undered_multimap
+(2) unordered_multimap
 ```cpp
 template<bool _Cache>
 using __umap_traits = __detail::_Hashtable_traits<_Cache, false, false>;
 ```
-(3) undered_set
+(3) unordered_set
 
 ```cpp
 template<bool _Cache>
 using __uset_traits = __detail::_Hashtable_traits<_Cache, true, true>;
 ```
-(4) undered_multiset
+(4) unordered_multiset
 
 ```cpp
 template<bool _Cache>
@@ -166,13 +166,13 @@ using __uset_traits = __detail::_Hashtable_traits<_Cache, true, false>;
 
 对比后，得出
 
-- 结论1：undered_map与undered_set不允许key重复,而带multi的则允许key重复；
-- 结论2：undered_map与undered_multimap采用的迭代器是iterator，而undered_set与undered_multiset采用的迭代器是const_iterator。
-- 结论3：undered_map与undered_multimap的key是key，value是key+value；而undered_set与undered_multiset的key是Value，Value也是Key。
+- 结论1：unordered_map与unordered_set不允许key重复,而带multi的则允许key重复；
+- 结论2：unordered_map与unordered_multimap采用的迭代器是iterator，而unordered_set与unordered_multiset采用的迭代器是const_iterator。
+- 结论3：unordered_map与unordered_multimap的key是key，value是key+value；而unordered_set与unordered_multiset的key是Value，Value也是Key。
 
 最后一个结论对比看下面(我们看传递给hashtable的第一与第二个参数)：
 
-undered_map与undered_multimap：
+unordered_map与unordered_multimap：
 ```cpp
 using __umap_hashtable = _Hashtable<_Key, 
 std::pair<const _Key, _Tp>,
@@ -182,7 +182,7 @@ __detail::_Mod_range_hashing,
 __detail::_Default_ranged_hash,
 __detail::_Prime_rehash_policy, _Tr>;
 ```
-undered_set与undered_multiset：
+unordered_set与unordered_multiset：
 ```cpp
 template<typename _Value,
 typename _Hash = hash<_Value>,
@@ -196,13 +196,13 @@ __detail::_Default_ranged_hash,
 __detail::_Prime_rehash_policy, _Tr>;
 ```
 
-## 4.undered_map重要函数
+## 4.unordered_map重要函数
 
 > 初始化
 
-可以在下面的构造函数中看到undered_map的默认桶数为10。
+可以在下面的构造函数中看到unordered_map的默认桶数为10。
 
-在undered_map的底层默认采用hasher(),也就是H1,也就是std::hash
+在unordered_map的底层默认采用hasher(),也就是H1,也就是std::hash
 
 ```cpp
 unordered_map(size_type __n = 10,
@@ -319,7 +319,7 @@ clear() noexcept
 ```
 > hash_function
 
-得到该undered_map的hash_function
+得到该unordered_map的hash_function
 ```cpp
 hasher
 hash_function() const
@@ -353,4 +353,4 @@ at(const key_type& __k)
 ```
 除了这些函数还有获取桶，最大桶数、加载因子、rehash等等，就是没有排序，因为hashtable没有提供排序功能。hashtable在查找、删除和插入节点是常数时间，优于RB-Tree红黑树。
 
-同理，unordered_set、unordered_multiset、unordered_multimap与undered_map一样的函数，所以就不阐述了。
\ No newline at end of file
+同理，unordered_set、unordered_multiset、unordered_multimap与unordered_map一样的函数，所以就不阐述了。
\ No newline at end of file

From e539d3c4b7a003a87e6d43852de6a16e75bda04e Mon Sep 17 00:00:00 2001
From: linbo0518 <linbo0518@gmail.com>
Date: Sat, 13 Jun 2020 17:18:45 -0500
Subject: [PATCH 08/62] fix typo: undered -> unordered

---
 src_analysis/stl/hashtable.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src_analysis/stl/hashtable.md b/src_analysis/stl/hashtable.md
index 7db3180..dcd6b39 100644
--- a/src_analysis/stl/hashtable.md
+++ b/src_analysis/stl/hashtable.md
@@ -2,7 +2,7 @@
 
 ## 0.导语
 
-哈希表，是作为`unordered_map`与`undered_set`等的底层容器，自gcc2.9后源码量大增！
+哈希表，是作为`unordered_map`与`unordered_set`等的底层容器，自gcc2.9后源码量大增！
 
 这次阅读的代码仍旧是gcc4.9.1，代码量非常多，就不全部展开，重点研究底层哈希的艺术与技术，似乎这两个词语很押韵哦，哈哈，进入正文～
 

From 619b9f77a7f623dbe22bba68739696636297e558 Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Sun, 14 Jun 2020 18:42:15 +0800
Subject: [PATCH 09/62] Update derived_base.cpp

---
 basic_content/using/derived_base.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/basic_content/using/derived_base.cpp b/basic_content/using/derived_base.cpp
index b25ec55..bc57800 100644
--- a/basic_content/using/derived_base.cpp
+++ b/basic_content/using/derived_base.cpp
@@ -21,7 +21,7 @@ class Base {
         Base():value(20) {}
         virtual ~Base() {}
         void test1() { cout << "Base test1..." << endl; }
-    protected:  //私有
+    private:  //私有
         int value;
 };
 

From 7e83a288bda102fa4a6357d86f03394cd436377e Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Sun, 14 Jun 2020 18:51:27 +0800
Subject: [PATCH 10/62] Update README.md

---
 basic_content/virtual/README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/basic_content/virtual/README.md b/basic_content/virtual/README.md
index 58d0f3d..44436bd 100644
--- a/basic_content/virtual/README.md
+++ b/basic_content/virtual/README.md
@@ -38,7 +38,7 @@ static成员函数不属于任何类对象或类实例，所以即使给此函
 
 （2）**构造函数可以为虚函数吗？**
 
-构造函数不可以声明为虚函数。同时除了inline之外，构造函数不允许使用其它任何关键字。
+构造函数不可以声明为虚函数。同时除了inline|explicit之外，构造函数不允许使用其它任何关键字。
 
 为什么构造函数不可以为虚函数？
 
@@ -86,7 +86,7 @@ static成员函数不属于任何类对象或类实例，所以即使给此函
 
 - [inline_virtual.cpp](./set3/inline_virtual.cpp)
 
- ## 5.RTTI与dynamic_cast
+## 5.RTTI与dynamic_cast
 
 RTTI（Run-Time Type Identification)，通过运行时类型信息程序能够使用[基类](https://baike.baidu.com/item/%E5%9F%BA%E7%B1%BB/9589663)的[指针](https://baike.baidu.com/item/%E6%8C%87%E9%92%88/2878304)或引用来检查这些指针或引用所指的对象的实际[派生类](https://baike.baidu.com/item/%E6%B4%BE%E7%94%9F%E7%B1%BB)型。
 
@@ -99,4 +99,4 @@ RTTI（Run-Time Type Identification)，通过运行时类型信息程序能够
 
 ## 6.纯虚函数和抽象类
 
-见[纯虚函数和抽象类那些事](../abstract)
\ No newline at end of file
+见[纯虚函数和抽象类那些事](../abstract)

From 93f3d96f039d24956ce2715600cb9f1c756edaad Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Sun, 14 Jun 2020 19:11:12 +0800
Subject: [PATCH 11/62] Update README.md

---
 basic_content/vptr_vtable/README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/basic_content/vptr_vtable/README.md b/basic_content/vptr_vtable/README.md
index 47f9df5..1b82cc6 100644
--- a/basic_content/vptr_vtable/README.md
+++ b/basic_content/vptr_vtable/README.md
@@ -114,9 +114,9 @@ int main(void)
     Base &p = d; // 基类引用指向派生类实例
     cout<<"基类对象直接调用"<<endl;
     ptr.fun1();
-    cout<<"基类引用指向派生类实例"<<endl;
+    cout<<"基类对象调用基类实例"<<endl;
     pp.fun1(); 
-    cout<<"基类指针指向派生类实例并调用虚函数"<<endl;
+    cout<<"基类指针指向基类实例并调用虚函数"<<endl;
     pt->fun1();
     cout<<"基类引用指向基类实例并调用虚函数"<<endl;
     p.fun1();

From 1ca9bceb6100ededfdecab5443f8ab78508283b4 Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Sun, 14 Jun 2020 19:25:27 +0800
Subject: [PATCH 12/62] =?UTF-8?q?Update=20=E5=8A=A8=E6=80=81=E6=95=B0?=
 =?UTF-8?q?=E7=BB=84.cpp?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 practical_exercises/key_exercises/动态数组.cpp | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/practical_exercises/key_exercises/动态数组.cpp b/practical_exercises/key_exercises/动态数组.cpp
index 7fb298a..5cb3343 100644
--- a/practical_exercises/key_exercises/动态数组.cpp
+++ b/practical_exercises/key_exercises/动态数组.cpp
@@ -1,5 +1,14 @@
 #include<iostream>
-char *sPtr;        		//����ַ�����ָ��       
-s="����"      
-sPtr = new char[strlen(s)+1];
-strncpy(sPtr,s;  
\ No newline at end of file
+#include<cstring>
+
+
+int main() {
+  
+  char *sPtr;        	 
+  const char* s="hello";
+  sPtr = new char[strlen(s)+1];
+  strncpy(sPtr,s,strlen(s)); 
+  std::cout << sPtr << std::endl;
+  delete sPtr;
+  return  0;
+}

From e4cf08593b66bfdb5bd857f1085703f58bc5c703 Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Sun, 14 Jun 2020 19:28:32 +0800
Subject: [PATCH 13/62] =?UTF-8?q?Update=20=E4=B8=AD=E6=8B=AC=E5=8F=B7?=
 =?UTF-8?q?=E9=87=8D=E8=BD=BD.cpp?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../key_exercises/中括号重载.cpp              | 91 ++++++++++---------
 1 file changed, 49 insertions(+), 42 deletions(-)

diff --git a/practical_exercises/key_exercises/中括号重载.cpp b/practical_exercises/key_exercises/中括号重载.cpp
index f89aaec..a9a2137 100644
--- a/practical_exercises/key_exercises/中括号重载.cpp
+++ b/practical_exercises/key_exercises/中括号重载.cpp
@@ -1,51 +1,58 @@
-//Eg8-9.cpp
 #include <iostream>
 #include <cstring>
 using namespace std;
-struct Person{                		//ְ��������Ϣ�Ľṹ
-		double salary;
-		char *name;
+struct Person
+{ //职工基本信息的结构
+    double salary;
+    char *name;
 };
-class SalaryManaege{
-		Person *employ;          	 //���ְ����Ϣ������
-		int max;                  		//�����±��Ͻ�
-		int n;                    		//�����е�ʵ��ְ������
+class SalaryManaege
+{
+    Person *employ; //存放职工信息的数组
+    int max;        //数组下标上界
+    int n;          //数组中的实际职工人数
 public:
-	SalaryManaege(int Max=0){
-		max=Max;
-		n=0;
-		employ=new Person[max];
-	}
-	//�������������ǿ���ֱ���ڷ�����ֵ��ֱ��ʹ��
-    double &operator[](char *Name) {       	//����[]����������
-		Person *p;
-		for(p=employ;p<employ+n;p++)   
-			//������ڴ���   	
-			if(strcmp(p->name,Name)==0) 
-				return p->salary;
-		//�������������
-		p=employ + n++; 
-		p->name=new char[strlen(Name)+1];
-		strcpy(p->name,Name);
-		p->salary=0;
-		return p->salary;
-	}
+    SalaryManaege(int Max = 0)
+    {
+        max = Max;
+        n = 0;
+        employ = new Person[max];
+    }
+    //返回引用特性是可以直接在放在左值，直接使用
+    double &operator[](char *Name)
+    { //重载[]，返回引用
+        Person *p;
+        for (p = employ; p < employ + n; p++)
+            //如果存在处理
+            if (strcmp(p->name, Name) == 0)
+                return p->salary;
+        //不存在情况处理
+        p = employ + n++;
+        p->name = new char[strlen(Name) + 1];
+        strcpy(p->name, Name);
+        p->salary = 0;
+        return p->salary;
+    }
 
-	void display(){      								
-		for(int i=0;i<n;i++)
-			cout<<employ[i].name<<"   "<<employ[i].salary<<endl;
-		}
+    void display()
+    {
+        for (int i = 0; i < n; i++)
+            cout << employ[i].name << "   " << employ[i].salary << endl;
+    }
+    ~SalaryManaege() {
+        delete employ;
+    }
 };
-int main(){
+int main()
+{
     SalaryManaege s(3);
-    s["����"]=2188.88;
-    s["��˹"]=1230.07;
-    s["����"]=3200.97;
-    cout<<"����\t"<<s["����"]<<endl;          cout<<"��˹\t"<<s["��˹"]<<endl;
-    cout<<"����\t"<<s["����"]<<endl;
-  
-    cout<<"-------��Ϊdisplay�����--------\n\n";
-    s.display();
-    system("pause");
-}
+    s["张三"] = 2188.88;
+    s["里斯"] = 1230.07;
+    s["王无"] = 3200.97;
+    cout << "张三\t" << s["张三"] << endl;
+    cout << "里斯\t" << s["里斯"] << endl;
+    cout << "王无\t" << s["王无"] << endl;
 
+    cout << "-------下为display的输出--------\n\n";
+    s.display();
+}

From 7e7ed43299d4324b098110d429933b19f3cc210b Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Sun, 14 Jun 2020 19:30:41 +0800
Subject: [PATCH 14/62] Update README.md

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index 4b6bd94..dafd70d 100644
--- a/README.md
+++ b/README.md
@@ -10,6 +10,8 @@ https://light-city.club/sc/
 
 ### 关于作者
 
+公众号已开放两大入口，分别是专辑与菜单，可以直接在微信公众号上阅读《C++那些事》内容，配上该仓库的代码，将会非常的爽，建议大家关注一波。
+
 个人公众号：guangcity
 
 ![](https://light-city.club/sc/assets/images/wechat.jpg)

From 993d42631e1dc6b87fb14a6a460c67307abdf8b2 Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Mon, 15 Jun 2020 16:40:56 +0800
Subject: [PATCH 15/62] Update README.md

---
 basic_content/enum/README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/basic_content/enum/README.md b/basic_content/enum/README.md
index 7ab270c..197203f 100644
--- a/basic_content/enum/README.md
+++ b/basic_content/enum/README.md
@@ -50,7 +50,7 @@ namespace Color
 
 这样之后就可以用 `Color::Type c = Color::RED;` 来定义新的枚举变量了。如果 `using namespace Color` 后，前缀还可以省去，使得代码简化。不过，因为命名空间是可以随后被扩充内容的，所以它提供的作用域封闭性不高。在大项目中，还是有可能不同人给不同的东西起同样的枚举类型名。
 
-更“有效”的办法是用一个类或结构体来限定其作用域，例如：定义新变量的方法和上面命名空间的相同。不过这样就不用担心类在别处被修改内容。这里用结构体而非类，一是因为本身希望这些常量可以公开访问，二是因为它只包含数据没有成员函数。
+更“有效”的办法是用一个类或结构体来限定其作用域，例如：定义新变量的方法和上面命名空间的相同。不过这样就不用担心类在别处被修改内容。这里用结构体而非类，是因为本身希望这些常量可以公开访问。
 
 ```c++
 struct Color1
@@ -153,4 +153,4 @@ public:
 
 枚举常量不会占用对象的存储空间，它们在编译时被全部求值。
 
-枚举常量的缺点是：它的隐含数据类型是整数，其最大值有限，且不能表示浮点。
\ No newline at end of file
+枚举常量的缺点是：它的隐含数据类型是整数，其最大值有限，且不能表示浮点。

From e582112da0181d0454f81428031bf22f07bbe941 Mon Sep 17 00:00:00 2001
From: SouthEast <shadowzou@qq.com>
Date: Fri, 3 Jul 2020 11:34:24 +0800
Subject: [PATCH 16/62] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=B8=80=E4=B8=AA?=
 =?UTF-8?q?=E5=AD=97=E8=AF=8D=E9=94=99=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

“内联是在编译期建议编译器内联”
---
 basic_content/inline/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/basic_content/inline/README.md b/basic_content/inline/README.md
index 3030e27..9f757a1 100644
--- a/basic_content/inline/README.md
+++ b/basic_content/inline/README.md
@@ -90,7 +90,7 @@ int main()
 ## 2.虚函数（virtual）可以是内联函数（inline）吗？
 
 - 虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能内联。
-- 内联是在编译器建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。
+- 内联是在编译期建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。
 - `inline virtual` 唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如 `Base::who()`），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。
 
 ```c++

From 5354c10742b008f4081004ea22d7bc52a0e47fba Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Mon, 6 Jul 2020 19:26:11 +0800
Subject: [PATCH 17/62] Update README.md

---
 design_pattern/singleton/README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/design_pattern/singleton/README.md b/design_pattern/singleton/README.md
index f593319..73bbf40 100644
--- a/design_pattern/singleton/README.md
+++ b/design_pattern/singleton/README.md
@@ -164,7 +164,7 @@ p = new singleton;
 - 线程A调用instance，执行第一次p的测试，获得锁，按照1,3,执行，然后被挂起。此时p是非空的，但是p指向的内存中还没有Singleton对象被构造。
 - 线程B调用instance，判定p非空， 将其返回给instance的调用者。调用者对指针解引用以获得singleton，噢，一个还没有被构造出的对象。bug就出现了。
 
-DCLP能够良好的工作仅当步骤一和二在步骤三之前被执行，但是并没有并没有方法在C或C++中表达这种限制。这就像是插在DCLP心脏上的一把匕首：我们需要在相对指令顺序上定义限制，但是我们的语言没有给出表达这种限制的方法。
+DCLP能够良好的工作仅当步骤一和二在步骤三之前被执行，但是并没有方法在C或C++中表达这种限制。这就像是插在DCLP心脏上的一把匕首：我们需要在相对指令顺序上定义限制，但是我们的语言没有给出表达这种限制的方法。
 
 ## 5.memory barrier指令
 
@@ -324,4 +324,4 @@ public:
 
 > https://www.cnblogs.com/liyuan989/p/4264889.html
 
-> https://segmentfault.com/a/1190000015950693
\ No newline at end of file
+> https://segmentfault.com/a/1190000015950693

From 423f31738badee2dd5a7184e8914da885cbf7025 Mon Sep 17 00:00:00 2001
From: guoliang <tswanggl@gmail.com>
Date: Fri, 17 Jul 2020 16:40:56 +0800
Subject: [PATCH 18/62] Mix the develop tools and compiler?

---
 README.md | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index dafd70d..2f570dc 100644
--- a/README.md
+++ b/README.md
@@ -28,9 +28,13 @@ https://light-city.club/sc/
 
   Ubuntu 18.04
 
-- **工具**
+- **编辑工具**
 
-  CLion  gcc/g++
+  CLion  
+
+- **编译器**
+
+> gcc/g++
 
 尽量用g++，因为一开始我用的vim写的，所以纯g++，后来用编译器CLion，部分有CMakeLists.txt文件，直接导入就行，后面会更新这个文件包含整个项目，持续关注~
 

From 31c5da6aa25e71e8f2f99c5f8c957dc8c66c950c Mon Sep 17 00:00:00 2001
From: xliu79 <liuxiyuan1993@gmail.com>
Date: Sat, 18 Jul 2020 17:09:29 +0800
Subject: [PATCH 19/62] english

---
 english/basic_content/const/README.md         | 382 ++++++++++++++++++
 .../const/class_const/c++11_example/apple.cpp |  15 +
 .../const/class_const/c++11_example/main      | Bin 0 -> 9656 bytes
 .../const/class_const/c++11_example/main.cpp  |  31 ++
 .../const/class_const/first_example/apple.cpp |  13 +
 .../const/class_const/first_example/main.cpp  |  32 ++
 .../class_const/overload_example/apple.cpp    |  13 +
 .../const/class_const/overload_example/main   | Bin 0 -> 9656 bytes
 .../class_const/overload_example/main.cpp     |  32 ++
 .../class_const/static_example/apple.cpp      |  14 +
 .../const/class_const/static_example/main     | Bin 0 -> 9704 bytes
 .../const/class_const/static_example/main.cpp |  34 ++
 .../basic_content/const/const_function.cpp    |  11 +
 english/basic_content/const/const_num.cpp     |   8 +
 .../const/extern_const/const_file1.cpp        |   1 +
 .../const/extern_const/const_file2.cpp        |  11 +
 .../const/extern_const/file1.cpp              |   1 +
 .../const/extern_const/file2.cpp              |  11 +
 .../funciton_const/condition1/condition1.cpp  |   8 +
 .../funciton_const/condition1/condition2.cpp  |   9 +
 .../funciton_const/condition1/condition3.cpp  |  12 +
 .../funciton_const/condition2/condition1      | Bin 0 -> 9232 bytes
 .../funciton_const/condition2/condition1.cpp  |  10 +
 .../funciton_const/condition2/condition2.cpp  |   8 +
 .../funciton_const/condition2/condition3      | Bin 0 -> 9232 bytes
 .../funciton_const/condition2/condition3.cpp  |   8 +
 .../funciton_const/condition3/condition1      | Bin 0 -> 9232 bytes
 .../funciton_const/condition3/condition1.cpp  |  10 +
 28 files changed, 674 insertions(+)
 create mode 100644 english/basic_content/const/README.md
 create mode 100644 english/basic_content/const/class_const/c++11_example/apple.cpp
 create mode 100755 english/basic_content/const/class_const/c++11_example/main
 create mode 100644 english/basic_content/const/class_const/c++11_example/main.cpp
 create mode 100644 english/basic_content/const/class_const/first_example/apple.cpp
 create mode 100644 english/basic_content/const/class_const/first_example/main.cpp
 create mode 100644 english/basic_content/const/class_const/overload_example/apple.cpp
 create mode 100755 english/basic_content/const/class_const/overload_example/main
 create mode 100644 english/basic_content/const/class_const/overload_example/main.cpp
 create mode 100644 english/basic_content/const/class_const/static_example/apple.cpp
 create mode 100755 english/basic_content/const/class_const/static_example/main
 create mode 100644 english/basic_content/const/class_const/static_example/main.cpp
 create mode 100644 english/basic_content/const/const_function.cpp
 create mode 100644 english/basic_content/const/const_num.cpp
 create mode 100644 english/basic_content/const/extern_const/const_file1.cpp
 create mode 100644 english/basic_content/const/extern_const/const_file2.cpp
 create mode 100644 english/basic_content/const/extern_const/file1.cpp
 create mode 100644 english/basic_content/const/extern_const/file2.cpp
 create mode 100644 english/basic_content/const/funciton_const/condition1/condition1.cpp
 create mode 100644 english/basic_content/const/funciton_const/condition1/condition2.cpp
 create mode 100644 english/basic_content/const/funciton_const/condition1/condition3.cpp
 create mode 100755 english/basic_content/const/funciton_const/condition2/condition1
 create mode 100644 english/basic_content/const/funciton_const/condition2/condition1.cpp
 create mode 100644 english/basic_content/const/funciton_const/condition2/condition2.cpp
 create mode 100755 english/basic_content/const/funciton_const/condition2/condition3
 create mode 100644 english/basic_content/const/funciton_const/condition2/condition3.cpp
 create mode 100755 english/basic_content/const/funciton_const/condition3/condition1
 create mode 100644 english/basic_content/const/funciton_const/condition3/condition1.cpp

diff --git a/english/basic_content/const/README.md b/english/basic_content/const/README.md
new file mode 100644
index 0000000..f324abc
--- /dev/null
+++ b/english/basic_content/const/README.md
@@ -0,0 +1,382 @@
+
+
+
+## 1.The Definition Of const
+
+Const type is that people use type specifier **const** signiture type to demonstrate，const variables or objects can not be updated。
+
+## 2. Effect Of Const
+
+（1）define variable
+
+```
+const int a=100;
+```
+
+(2) check type
+
+The difference between const variable and define variable: ~~<u>**Constants have types, which can be checked by the compiler; the define macro definition has no data type, it is just a simple string replacement, and cannot be checked for security
+**</u>~~ Thanks for point this bug out.
+> https://github.com/Light-City/CPlusPlusThings/issues/5
+
+Only variables of type integer or enumeration are defined by `const`. In other cases, it is only a 'const' qualified variable and should not be confused with constants.
+
+（3）prevent modification, protect and increase program robustness
+
+
+```
+void f(const int i){
+    i++; //error!
+}
+```
+（4）Save space and avoid unnecessary memory allocation
+
+From the compile point of view, the variables can be defined by const only give the corresponding memory address. Meanwhile the #define gives an immediate number.
+
+## 3.const object is the file local variable by default
+
+
+<p><font style="color:red">Attention：not const will be set as extern by default.For the const variable to be accessible in other files, it must be explicitly specified as extern in the file
+
+</font></p>
+> Access of variables not modified by const in different files
+
+
+```
+// file1.cpp
+int ext
+// file2.cpp
+#include<iostream>
+/**
+ * by 光城
+ * compile: g++ -o file file2.cpp file1.cpp
+ * execute: ./file
+ */
+extern int ext;
+int main(){
+    std::cout<<(ext+10)<<std::endl;
+}
+
+```
+
+You can find that variables that are not modified by const do not need to be explicitly declared by extern! Const constants need to be explicitly declared extern and need to be initialized! Because constants cannot be modified after they are defined, they must be initialized
+
+## 4.Define Variable
+
+```
+const int b = 10;
+b = 0; // error: assignment of read-only variable ‘b’
+const string s = "helloworld";
+const int i,j=0 // error: uninitialized const ‘i’
+```
+
+There are two errors above. First, B is a constant and cannot be changed! Second: I is a constant and must be initialized! (since constants cannot be modified after definition, they must be initialized. )
+
+## 5.Pointer and Const
+There are four kinds of pointer related consts
+
+```
+const char * a; //A pointer to a const object, or a pointer to a constant.
+char const * a; //same as above
+char * const a; //Const pointer to the type object. Or constant pointer, const pointer.
+const char * const a; //Const pointer to const object
+
+```
+Conclusion: If *const* is on the left of `*`, const is used to modify the variable that the pointer points to, that is, the pointer points to a constant. If *const* is on the right of `*`, then the const is used to modify the pointer itself, that is, the pointer itself is a constant.
+
+The specific method is as follows:
+(1) pointer to const:
+```
+const int *ptr;
+*ptr = 10; //error
+```
+ptr is a pointer to a const object of type int. Const defines the int type, that is, the type of object PTR points to, not the PTR itself.Therefore, ptr do not need to be assigned an initial value. However, the value of the object in question cannot be modified by ptr. Besides, we can not use void `*` pointer to save the address of const object
+
+```
+const int p = 10;
+const void * vp = &p;
+void *vp = &p; //error
+
+```
+
+Another key point is: we allow the address of a non const object to be assigned to a pointer to a const object.
+
+Example:
+```
+const int *ptr;
+int val = 3;
+ptr = &val; //ok
+```
+We can't change the val value through the ptr pointer, even if it points to a non const object
+
+```
+int *ptr1 = &val;
+*ptr1=4;
+cout<<*ptr<<endl;
+```
+We cannot modify the underlying object with a pointer to the const object
+
+However, if the pointer points to a non const object, the object it refers to can be modified in other ways.
+
+```
+int *ptr1 = &val;
+*ptr1=4;
+cout<<*ptr<<endl;
+```
+Conclusion: For a pointer to a constant, the value of the object cannot be modified by the pointer. And You cannot use the void `*` pointer to save the address of the const object. You must use a pointer of type const void `*` to hold the address of the const object.
+
+(2) Constant pointer
+
+The const pointer must be initialized and the value of the const pointer cannot be modified.
+
+```
+#include<iostream>
+using namespace std;
+int main(){
+
+    int num=0;
+    int * const ptr=&num; //const指针必须初始化！且const指针的值不能修改
+    int * t = &num;
+    *t = 1;
+    cout<<*ptr<<endl;
+}
+
+```
+
+Modify the value pointed by ptr pointer, which can be modified by non const pointer
+
+Finally, when the address of a const constant is assigned to ptr, an error will be reported because ptr points to a variable rather than const constant.
+
+```
+#include<iostream>
+using namespace std;
+int main(){
+    const int num=0;
+    int * const ptr=&num; //error! const int* -> int*
+    cout<<*ptr<<endl;
+}
+
+```
+If changed to const int `*`ptr or const int `*`const ptr, no errors have occurred.
+
+
+(3) Constant pointer to a constant
+
+```
+const int p = 3;
+const int * const ptr = &p; 
+```
+
+PTR is a const pointer and then points to a const object of type int
+
+## 6. Using const in function
+Return value of const decorated function
+
+The meaning of const modifying ordinary variables and pointers is basically the same
+
+（1）const int
+
+```
+const int func1();
+```
+It doesn't make sense, because the parameter return itself is assigned to other variables
+
+（2）const int*
+
+```
+const int* func2();
+
+```
+The pointer points to the same content
+
+（3）int *const
+
+```
+int *const func2();
+```
+The pointer itself is immutable
+
+Const modifier function parameters.
+
+The passed parameters and pointers themselves are immutable and meaningless in the function.
+
+
+```
+void func(const int var); // parameters are immutable
+void func(int *const var); // point itself is immutable
+
+```
+
+(2) Parameter pointer refers to a constant and is immutable
+
+
+```
+void StringCopy(char *dst, const char *src);
+
+```
+SRC is the input parameter and DST is the output parameter. After adding const modifier to SRC, if the statement in the function body tries to change the contents of SRC, the compiler will point out the error
+
+This is one of the effects of const.
+
+(3) The parameter is a reference. In order to increase efficiency and prevent modification at the same time
+
+```
+void func(const A &a)
+```
+
+For parameters of Non internal data types, Functions such as void func (A, a) are bound to be inefficient. Because a temporary object of type A will be generated in the function body to copy parameter a, and the process of constructing, copying and destructing the temporary object will take time
+
+To improve efficiency, you can change the function declaration to void func(A &a)，Because reference passing only uses aliases for parameters, there is no need to generate temporary objects
+
+void func(A &a) drawback:
+It is possible to change the parameter a, which we do not expect.
+It's easy to solve this problem by adding const modifier
+
+Finally, it will be : void func(const A &a).
+
+
+Should void func (int x) be rewritten to void func(const int &x),in order to improve efficiency? That operation was so needless.
+Because the internal data type parameters do not exist in the process of construction and deconstruction, and replication is very fast.
+
+Conclusion:For the input parameters of non internal data type, the mode of "value passing" should be changed to "const reference passing", in order to improve the efficiency. 
+For example, change void func (a a a) to void func (const A & A). It can not improve the efficiency and reduce the comprehensibility of the functionVoid func (int x) should not be changed to void func (const int & x).
+
+So Two interview problems were solved:
+
+
+(1)If a function needs to pass in a pointer, do you need to add const to the pointer? What is the difference between adding const at different positions of the pointer
+
+(2)If the function to be written needs to pass in an instance of a complex type, what is the difference between the passed in value parameter or reference parameter, and when to add const to the passed reference parameter
+## 7.Using const in Class
+In a class, any function that does not modify data members should be declared as const type. When writing const member functions, if you accidentally modify data members or call other non const member functions, the compiler will point out errors, which will undoubtedly improve the robustness of the program.The member function described by const is called constant member function
+
+Only constant member functions are qualified to operate constant or constant objects. Member functions without const keyword cannot be used to operate constant objects
+
+For const member variables in a class, they must be initialized through the initialization list:
+
+```
+class Apple
+{
+private:
+    int people[100];
+public:
+    Apple(int i); 
+    const int apple_number;
+};
+
+Apple::Apple(int i):apple_number(i)
+{
+
+}
+```
+Const objects can only access const member functions, while non const objects can access any member functions, including const member functions
+
+Such as:
+```
+//apple.cpp
+class Apple
+{
+private:
+    int people[100];
+public:
+    Apple(int i); 
+    const int apple_number;
+    void take(int num) const;
+    int add(int num);
+    int add(int num) const;
+    int getCount() const;
+
+};
+//main.cpp
+#include<iostream>
+#include"apple.cpp"
+using namespace std;
+
+Apple::Apple(int i):apple_number(i)
+{
+
+}
+int Apple::add(int num){
+    take(num);
+}
+int Apple::add(int num) const{
+    take(num);
+}
+void Apple::take(int num) const
+{
+    cout<<"take func "<<num<<endl;
+}
+int Apple::getCount() const
+{
+    take(1);
+//    add(); //error
+    return apple_number;
+}
+int main(){
+    Apple a(2);
+    cout<<a.getCount()<<endl;
+    a.add(10);
+    const Apple b(3);
+    b.add(100);
+    return 0;
+}
+//Compile： g++ -o main main.cpp apple.cpp
+//Result
+take func 1
+2
+take func 10
+take func 100
+```
+The getCount () method invokes a add method, and the add method is not const modifier, so run the wrong report. In other words, const objects can only access const member functions. Add method also calls const modified take method, which proves that non const objects can access any member function, including const member function.
+In addition, we also see an overloaded function of add, which also outputs two results, indicating that const objects call const member functions by default
+In addition to the above initialization const constant, we can also use the following methods:
+(1)Combining the definition of constants with static, i.e:
+```
+static const int apple_number
+```
+(2)Initialize outside:
+
+```
+const int Apple::apple_number=10;
+```
+Of course, if you use C + + 11 to compile, you can directly define the initialization, you can write:
+```
+static const int apple_number=10;
+or
+const int apple_number=10;
+```
+Both are supported in C + + 11.
+When compiling, just add '- STD = C + + 11'.
+Let's talk about static briefly:
+In C + +, static static member variables cannot be initialized inside a class.It is only declared inside the class, and the definition must be outside the class definition body, usually initialized in the class's implementation file
+
+Declared in the class:
+
+```
+static int ap;
+```
+Use in class implementation file
+```
+int Apple::ap=666
+```
+For this implement, C + + 11 cannot be declared and initialized.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/english/basic_content/const/class_const/c++11_example/apple.cpp b/english/basic_content/const/class_const/c++11_example/apple.cpp
new file mode 100644
index 0000000..e498864
--- /dev/null
+++ b/english/basic_content/const/class_const/c++11_example/apple.cpp
@@ -0,0 +1,15 @@
+class Apple
+{
+private:
+    int people[100];
+public:
+    Apple(int i);
+    //使用c++11标准编译
+    static const int apple_number=10;
+    //const int apple_number=10;
+    void take(int num) const;
+    int add(int num);
+    int add(int num) const;
+    int getCount() const;
+};
+
diff --git a/english/basic_content/const/class_const/c++11_example/main b/english/basic_content/const/class_const/c++11_example/main
new file mode 100755
index 0000000000000000000000000000000000000000..62017da688b455919b4730dc329a7da50fc82409
GIT binary patch
literal 9656
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
V{Cs}V{w&x3^Gc!4vSF<K{|8BL+!O!+

literal 0
HcmV?d00001

diff --git a/english/basic_content/const/class_const/c++11_example/main.cpp b/english/basic_content/const/class_const/c++11_example/main.cpp
new file mode 100644
index 0000000..a72adb8
--- /dev/null
+++ b/english/basic_content/const/class_const/c++11_example/main.cpp
@@ -0,0 +1,31 @@
+#include<iostream>
+#include"apple.cpp"
+using namespace std;
+Apple::Apple(int i)
+{
+
+}
+int Apple::add(int num){
+    take(num);
+}
+int Apple::add(int num) const{
+    take(num);
+}
+void Apple::take(int num) const
+{
+    cout<<"take func "<<num<<endl;
+}
+int Apple::getCount() const
+{
+    take(1);
+//    add(); //error
+    return apple_number;
+}
+int main(){
+    Apple a(2);
+    cout<<a.getCount()<<endl;
+    a.add(10);
+    const Apple b(3);
+    b.add(100);
+    return 0;
+}
diff --git a/english/basic_content/const/class_const/first_example/apple.cpp b/english/basic_content/const/class_const/first_example/apple.cpp
new file mode 100644
index 0000000..61e3538
--- /dev/null
+++ b/english/basic_content/const/class_const/first_example/apple.cpp
@@ -0,0 +1,13 @@
+class Apple
+{
+private:
+    int people[100];
+public:
+    Apple(int i);
+    const int apple_number;
+    void take(int num) const;
+    int add(int num);
+    int add(int num) const;
+    int getCount() const;
+};
+
diff --git a/english/basic_content/const/class_const/first_example/main.cpp b/english/basic_content/const/class_const/first_example/main.cpp
new file mode 100644
index 0000000..40056f2
--- /dev/null
+++ b/english/basic_content/const/class_const/first_example/main.cpp
@@ -0,0 +1,32 @@
+#include<iostream>
+#include"apple.cpp"
+using namespace std;
+
+Apple::Apple(int i):apple_number(i)
+{
+
+}
+int Apple::add(int num){
+    take(num);
+}
+int Apple::add(int num) const{
+    take(num);
+}
+void Apple::take(int num) const
+{
+    cout<<"take func "<<num<<endl;
+}
+int Apple::getCount() const
+{
+    take(1);
+//    add(); //error
+    return apple_number;
+}
+int main(){
+    Apple a(2);
+    cout<<a.getCount()<<endl;
+    a.add(10);
+    const Apple b(3);
+    b.add(100);
+    return 0;
+}
diff --git a/english/basic_content/const/class_const/overload_example/apple.cpp b/english/basic_content/const/class_const/overload_example/apple.cpp
new file mode 100644
index 0000000..f0d284f
--- /dev/null
+++ b/english/basic_content/const/class_const/overload_example/apple.cpp
@@ -0,0 +1,13 @@
+class Apple
+{
+private:
+    int people[100];
+public:
+    Apple(int i);
+    static const int apple_number;
+    void take(int num) const;
+    int add(int num);
+    int add(int num) const;
+    int getCount() const;
+};
+
diff --git a/english/basic_content/const/class_const/overload_example/main b/english/basic_content/const/class_const/overload_example/main
new file mode 100755
index 0000000000000000000000000000000000000000..562af2edb88d1ec9ad724c27b06e5ccc99cda293
GIT binary patch
literal 9656
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
D1Lo0U

literal 0
HcmV?d00001

diff --git a/english/basic_content/const/class_const/overload_example/main.cpp b/english/basic_content/const/class_const/overload_example/main.cpp
new file mode 100644
index 0000000..6db881a
--- /dev/null
+++ b/english/basic_content/const/class_const/overload_example/main.cpp
@@ -0,0 +1,32 @@
+#include<iostream>
+#include"apple.cpp"
+using namespace std;
+const int Apple::apple_number=10;
+Apple::Apple(int i)
+{
+
+}
+int Apple::add(int num){
+    take(num);
+}
+int Apple::add(int num) const{
+    take(num);
+}
+void Apple::take(int num) const
+{
+    cout<<"take func "<<num<<endl;
+}
+int Apple::getCount() const
+{
+    take(1);
+//    add(); //error
+    return apple_number;
+}
+int main(){
+    Apple a(2);
+    cout<<a.getCount()<<endl;
+    a.add(10);
+    const Apple b(3);
+    b.add(100);
+    return 0;
+}
diff --git a/english/basic_content/const/class_const/static_example/apple.cpp b/english/basic_content/const/class_const/static_example/apple.cpp
new file mode 100644
index 0000000..42afef3
--- /dev/null
+++ b/english/basic_content/const/class_const/static_example/apple.cpp
@@ -0,0 +1,14 @@
+class Apple
+{
+private:
+    int people[100];
+public:
+    Apple(int i);
+    static int ap; //在类实现文件中定义并初始化
+    static const int apple_number;
+    void take(int num) const;
+    int add(int num);
+    int add(int num) const;
+    int getCount() const;
+};
+
diff --git a/english/basic_content/const/class_const/static_example/main b/english/basic_content/const/class_const/static_example/main
new file mode 100755
index 0000000000000000000000000000000000000000..3c8391130c138e7355caaffcd713006144a2f252
GIT binary patch
literal 9704
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

literal 0
HcmV?d00001

diff --git a/english/basic_content/const/class_const/static_example/main.cpp b/english/basic_content/const/class_const/static_example/main.cpp
new file mode 100644
index 0000000..74ca4f0
--- /dev/null
+++ b/english/basic_content/const/class_const/static_example/main.cpp
@@ -0,0 +1,34 @@
+#include<iostream>
+#include"apple.cpp"
+using namespace std;
+const int Apple::apple_number=10;
+int Apple::ap=666;
+Apple::Apple(int i)
+{
+
+}
+int Apple::add(int num){
+    take(num);
+}
+int Apple::add(int num) const{
+    take(num);
+}
+void Apple::take(int num) const
+{
+    cout<<"take func "<<num<<endl;
+}
+int Apple::getCount() const
+{
+    take(1);
+//    add(); //error
+    return apple_number;
+}
+int main(){
+    Apple a(2);
+    cout<<a.getCount()<<endl;
+    cout<<a.ap<<endl;
+    a.add(10);
+    const Apple b(3);
+    b.add(100);
+    return 0;
+}
diff --git a/english/basic_content/const/const_function.cpp b/english/basic_content/const/const_function.cpp
new file mode 100644
index 0000000..d45c3bf
--- /dev/null
+++ b/english/basic_content/const/const_function.cpp
@@ -0,0 +1,11 @@
+#include<iostream>
+using namespace std;
+
+void f(const int i){
+    i=10; // error: assignment of read-only parameter ‘i’
+    cout<<i<<endl;
+}
+
+int main(){
+    f(1);
+}
diff --git a/english/basic_content/const/const_num.cpp b/english/basic_content/const/const_num.cpp
new file mode 100644
index 0000000..b71b98a
--- /dev/null
+++ b/english/basic_content/const/const_num.cpp
@@ -0,0 +1,8 @@
+#include<iostream>
+using namespace std;
+int main(){
+    const int b = 10;
+    b = 0; //error
+    const string s = "helloworld";
+    const int i,j=0;
+}
diff --git a/english/basic_content/const/extern_const/const_file1.cpp b/english/basic_content/const/extern_const/const_file1.cpp
new file mode 100644
index 0000000..7077ac9
--- /dev/null
+++ b/english/basic_content/const/extern_const/const_file1.cpp
@@ -0,0 +1 @@
+extern const int ext=12;
diff --git a/english/basic_content/const/extern_const/const_file2.cpp b/english/basic_content/const/extern_const/const_file2.cpp
new file mode 100644
index 0000000..53729f4
--- /dev/null
+++ b/english/basic_content/const/extern_const/const_file2.cpp
@@ -0,0 +1,11 @@
+#include<iostream>
+/**
+ * by 光城
+ * compile: g++ -o file const_file2.cpp const_file1.cpp
+ * execute: ./file
+ */
+extern const int ext;
+int main(){
+
+    std::cout<<ext<<std::endl;
+}
diff --git a/english/basic_content/const/extern_const/file1.cpp b/english/basic_content/const/extern_const/file1.cpp
new file mode 100644
index 0000000..05edfea
--- /dev/null
+++ b/english/basic_content/const/extern_const/file1.cpp
@@ -0,0 +1 @@
+int ext;
diff --git a/english/basic_content/const/extern_const/file2.cpp b/english/basic_content/const/extern_const/file2.cpp
new file mode 100644
index 0000000..471342a
--- /dev/null
+++ b/english/basic_content/const/extern_const/file2.cpp
@@ -0,0 +1,11 @@
+#include<iostream>
+/**
+ * by 光城
+ * compile: g++ -o file file2.cpp file1.cpp
+ * execute: ./file
+ */
+extern int ext;
+int main(){
+
+    std::cout<<(ext+10)<<std::endl;
+}
diff --git a/english/basic_content/const/funciton_const/condition1/condition1.cpp b/english/basic_content/const/funciton_const/condition1/condition1.cpp
new file mode 100644
index 0000000..b694639
--- /dev/null
+++ b/english/basic_content/const/funciton_const/condition1/condition1.cpp
@@ -0,0 +1,8 @@
+#include<iostream>
+using namespace std;
+
+
+int main(){
+    const int *ptr;
+    *ptr=10; //error
+}
diff --git a/english/basic_content/const/funciton_const/condition1/condition2.cpp b/english/basic_content/const/funciton_const/condition1/condition2.cpp
new file mode 100644
index 0000000..9db7339
--- /dev/null
+++ b/english/basic_content/const/funciton_const/condition1/condition2.cpp
@@ -0,0 +1,9 @@
+#include<iostream>
+using namespace std;
+
+
+int main(){
+    const int p = 10;
+    const void *vp = &p;
+    void *vp = &p; //error
+}
diff --git a/english/basic_content/const/funciton_const/condition1/condition3.cpp b/english/basic_content/const/funciton_const/condition1/condition3.cpp
new file mode 100644
index 0000000..5809e5f
--- /dev/null
+++ b/english/basic_content/const/funciton_const/condition1/condition3.cpp
@@ -0,0 +1,12 @@
+#include<iostream>
+using namespace std;
+
+int main(){
+    const int *ptr;
+    int val = 3;
+    ptr = &val; //ok
+    int *ptr1 = &val;
+    *ptr1=4;
+    cout<<*ptr<<endl;
+
+}
diff --git a/english/basic_content/const/funciton_const/condition2/condition1 b/english/basic_content/const/funciton_const/condition2/condition1
new file mode 100755
index 0000000000000000000000000000000000000000..b5dbf22a9e76b5d39bb8382360f1f803668ab1ac
GIT binary patch
literal 9232
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
N?^Ocxh(qbD|DP1Aq459!

literal 0
HcmV?d00001

diff --git a/english/basic_content/const/funciton_const/condition2/condition1.cpp b/english/basic_content/const/funciton_const/condition2/condition1.cpp
new file mode 100644
index 0000000..933a966
--- /dev/null
+++ b/english/basic_content/const/funciton_const/condition2/condition1.cpp
@@ -0,0 +1,10 @@
+#include<iostream>
+using namespace std;
+int main(){
+
+    int num=0;
+    int * const ptr=&num; //const指针必须初始化！且const指针的值不能修改
+    int * t = &num;
+    *t = 1;
+    cout<<*ptr<<endl;
+}
diff --git a/english/basic_content/const/funciton_const/condition2/condition2.cpp b/english/basic_content/const/funciton_const/condition2/condition2.cpp
new file mode 100644
index 0000000..91158a1
--- /dev/null
+++ b/english/basic_content/const/funciton_const/condition2/condition2.cpp
@@ -0,0 +1,8 @@
+#include<iostream>
+using namespace std;
+int main(){
+
+    const int num=0;
+    int * const ptr=&num; //error! const int* -> int*
+    cout<<*ptr<<endl;
+}
diff --git a/english/basic_content/const/funciton_const/condition2/condition3 b/english/basic_content/const/funciton_const/condition2/condition3
new file mode 100755
index 0000000000000000000000000000000000000000..d751dcbbf9e0c02cdb04d1a912758dc293a3dc78
GIT binary patch
literal 9232
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
G|33i^HI)Pa

literal 0
HcmV?d00001

diff --git a/english/basic_content/const/funciton_const/condition2/condition3.cpp b/english/basic_content/const/funciton_const/condition2/condition3.cpp
new file mode 100644
index 0000000..aed864c
--- /dev/null
+++ b/english/basic_content/const/funciton_const/condition2/condition3.cpp
@@ -0,0 +1,8 @@
+#include<iostream>
+using namespace std;
+int main(){
+
+    const int num=10;
+    const int * const ptr=&num; //error! const int* -> int*
+    cout<<*ptr<<endl;
+}
diff --git a/english/basic_content/const/funciton_const/condition3/condition1 b/english/basic_content/const/funciton_const/condition3/condition1
new file mode 100755
index 0000000000000000000000000000000000000000..73afdaae2299172e6b88ecb74d4949b0b2221dc9
GIT binary patch
literal 9232
zcmeHNZERat89ug?CQUoX>C%z4WA#Q0*+#siO+&^Qvy(WzuF^K-qZGF6#<88`Qpb+$
z>#nUBWXe`yb=|`FP^1Bx_>%ZB7*c->el#ha+D!tfLlhz4N151^Y#qy3nF87xp7-4I
zI@dQgOdx(B?X7&@^FHs#`MBqtd(NAFIo#9jcDV$TTYOrOG*cCnko6Rz_a-SStX-@Z
zL9tETB-R0`#4ji{#H|wZWfhuvwX*YoSK!y~wt#kbP!^bTb<DYi#Hqej3aX;TKefRU
znG4~U0Qpf{m#>o|_^>Q6pH%I5ni?j_FP{XHUxQbQ;KQ=O{IY5obM7DYjeY|v?tnW8
ziR2(L(Iua&oNS4DUoqoUetx|a!Gp5Eyqw=>;79FzzvNSfeX724<5I2K&s=p^+?g~+
z+FI{S#+#BxDtEN$XnR{zTWcVj4(ycurubyLXaAtAiO10oiTYQM9}P9>zm>S7v1Vh<
zuTNin=2G+4?Yq0qKQ&7_dX@a%gzyQM%W5^@8}Ym4y{qdR!<TwC&u;95Sd!iZx~YVQ
zBKb?;+sfd-0$wW4EofjVyuJ*+t4#a@WpGcKI1iU;&yxzDRO=U_Bm+-sXV8Ja0<2DK
z5mUZllrYMuPZHj5){MvQxP#tlo6z;KiF8WOn$e7@>q6gqMDI(C8Cf%t=}bnm*+f?8
zk%4`BJdsiGz`o98I+YlRjwBP7uC(U!`}@syBc0VpqS-`iBxRUgE#V_V2cAx5!@b>o
z{po%^44~g^O{C(<NUYy%X^D+TGrF0H8fG>U3y1rF?Lq`2rl+%JCJ~*84Cn*Rdbqz0
ztzBD3r&R|+#?m>nP@5sp?-+L(y^S5#W8;VQ(WsHc7{rc7^{AORYQRG$OEn-9Q6nYx
z^h7#3^__v%LTP7Uw^crLNZ$n<WGyE*=DxMjQ~<I5S;Ovv^mi0#em3J*Zy4CID#R|l
z7s7H|4D1XZagTaWF02qLl8(r{?MZAwZV^%X<=SD1)83$#vXuFK(_X5!M2R=3c~AvO
zg^;-4hVx!Uibfkwv6z}|xP4!0x8bygnSwT4ZGBRu+3*@R2Jf}uYRk9mr>|6NCo4a^
z-Y>LA=grE6rvPiy&sU$boL6>lf@)<)J)X7Of+&$ZPRhm0E1(@UBvaQHFG|@>G7a70
zyp;b@4Vhlv;<HlzE6Fq@i%(1WHIiv47H6dVGRZUqi&IkmJ;^k@i<45$KpvfeEUD#<
zNdBb<wEWB3^q-e{2O<~dpT!qIyKpur*@Y9;L9s9f$E%~Y+wd`XE{%a0)SAY@wCQE9
zmVf2Q*5@b`b-!+Cjub1GVf=`UKXi_IJsM#74Cx28hyNl2oW15j04=|yon5$BbDh^-
zx@K-JMBBj8YPX4@b5{LR_e3y0B3CyE$AuIcHgvwS4Up??S<{>kA53lfUXiPO{cG?m
z1bd4dRxS=L9)}N=wdpJVxOTE)M<X>pA6{;mzYxAc1FfA3UjeYBoeVFX6#4UWG<g>~
zuC1(`p>0mfUs(7C1S|B(!R5HNt6oOI>rX=Q;yD%Hmw)Kpd~SLAp?6)mk3Ia*^2!QY
ze)HT{>k!TZ!=Dc$@EH>4XrElD1vX=OpCQ{hnidN`p-!T6QxHVxv!R2b{7PsrG|+Qu
z#}6y~7|c^mKL+oQ<ll+pFZJ9;J*(EvzUNuc-&<MH9(}{~xBP*}zbF4%PyU@QL|Cc+
zqc(lcrQP*<?lqdQ_YH;a4-JJL2<hi$R^Qj#n8z}nn$omixVC!k4x%kIsXmS>9s~a+
z`2FC&Ko?Gf--<^627DO&D)<+{=^J$g{C@CyU_`FteZqCr=i0ils(Qv%<s+QVVB?5)
zI~gb{Z7;-j=*fQeT?`%BdVSsAhP|~L9;}`c_inlS_Fda=C75h5eZ@MoZx~#JyuK6e
z&g<5>??cU&J`T7W`cK>S$D~^N(~OQozuB(uwe%GG`}hq*pCEmQ*Y||G!`tw<C+zi~
zs_5`GK31uDn@_CMyzSFf`@F%7w>{)-4tX0pynfihzQbEB$K?v#zk)dS{gXm|Kp%|2
z|LX`0<2ypM9iJ7VppvD42kmr3PEKbNBK~$?To;rwpCL}GcsELv?pwpMv{lJ`PT8X5
zYJ47uXg?sr(wFqNYb$9g%({cb3U|JS3QOiQ#S3mru7M5Fpla|2OB4-?%RNGsiP3jO
z5_WtdUfc6hTHOz6PbK=0#e`4wm+{M$L8;+(H!HjKigW$gK4gDpls&dxDRaF`N=_-g
za{r$*zQ;N%T8Hl+(G7}!RPi>&yA?mE_^9GX6qnAn$DYp4Px>1NM{+4M=ieP@4Kz2k
z<)qZ|rIxlpb8Dcb<u*&<-`U*K*4);7m(9Io(SzC9?hdZedGIy|O5z@2mc%Ox^UNO1
zgIUM(s~BG=cpetxRif1U^I%r<doQ+MFL?eG<28kOR*Y{DyxxlOjbcg7%VPXGF;(Jy
zc!al*-zm1Q6}*0nai5r1>$(`PE957N@lB$-CTNFb*(0tm><4zG2VYs<2a55{f{u?)
z@`xJ>c^JFSgH_7+onjoTP_6S~{6=x8B))ndF1F`gY!#*Lrb4`h!(lPe{^$~G+fVzV
z8{<FkcrO&0aN*d80}6NU&s{S97BPdvDiQC~{j$7vJdXpX_`L6v577zyTqWMi4}h2I
z*J)|LMbIIci0j3%RK|Z*wO^jufW577{?70|TyET|pl~5m(Y_%F&sEwi@wMYg7Ny!r
zc^S%VaNdk0qE;Da?R?lP?XO=m5ARbrf5)sSLZoDzwe#>KHgvyOJFgyu{U&y{@y8|Z
z6?DrZ;_tx|C~UH=)7zz1i0{DOugZ4zOc{Ju#$UUx&q~}L!79I62CtOuS!=&d;X%iI
z?gH*#Yc7U?*CAWM`$>heNtdzD1NW5}&u>y3_l<(Ct#<mZjK8{mIiK}2WluLeJDmqk
z<4o6UqJ(@3@mt_N<i(uvUzYaD$i@z0+{k`btqWFND`S5X4j?oioO!x9aO$tKUblQN
zUP1SNqG9<I;-ZXS;=2&bm{~J7IvR)}RkgRXPw$EJ4<K{5nxNCo2|Y$BI;8IOcv>Gz
zrbnVlJ#MBmSv{INDq`u0$z;Mz!~>t$eOGH~BYo6J8G1C6i5}AvDKm3SjAo(}2|b>h
zm^cO(o20|iEHaIyQ*pyI(y5j}Y;sa&_<GuP-AI!q#MTy_5^N@tdW0C!q;VV)@{rL~
z9H~Ym`f@QTHyeh~_w*d-2=%}vH=;*$nUmA??!M5zupZvuMOjNZ5L`y;Sr2Q<K<nx&
z1US&$-5*BwFx1f#Ca0oy$BO}(5EXjY=k|y8MLJjWh{2#t2dc!MN*2blIXPYk@$a*#
zrE``g<62o+>abEH3rV?0d&1J8SsR_Qu8!#cGNF3_uO@D!^jtQ9F(K2^`CUC8HKSIZ
z6b(XFm|q6vb1C`is8o+<)A~4GFr|&HBrA=ZH6`?sY_<@qI6b@CK}=Og^4L+uf1F8n
z#7R)sga~AhO_<RUa5H1^aV{AtB*-U4AeA-~flx=J$&8LEX)KisjN}ab1;vPq07>J~
z?6?TTkEIaL;%3Iu97$xdnD#}24qYaZjFN*YO(sndkOLJ!F))^fh-@{Uv`S%=mJJRh
z#?`tUk0S_6maDZuEe|e#AqF#46P++(XhYhh@Ia{d0lX0rz*aGV<*zoS|ANsu2wPp@
zJILpI{yQPx6S)eqwbMr+(A^B%q9nct@ZaJ53TMXOAC_BCu>13U!Bhdav!UWn|1RL~
z;4a7Y&$@%sa#jI+KdhAK>U~#<Vm}IWcV&ORf4rc8Ue#f`|5B0fojB1*I*2DeAq9WF
zr!=UB^8MJdUOm6D`~V7cH|6^IK9f=n=JDtDvmNup@Ta>j%Y5&dQ4YPTB5FU`aQhW3
z=$uMTWq-aOT~_|(#*h2|i1P1H0r|e}Qwf84g;O~4;riMCabPsA%Diyjx~KroTfjt;
z8derX9woa!-^-Si|4hNsD)^Ml{Ob;XzQ0Y;qy%w$EorU%Z7A&Z&r}7a>5THfl?PS@
z;ChuPzK4R{pYMaGRYHUF8f@?E|BsYEpLO}1H?JI>_AE31sq*J$^7)<r9^S<jE6#ol
z&pG`09$H;vS<w04PR{Xs5lY;`3i%;E_w(P!o#W;7zXab}n?K)ct0^eRY44Q(1RH81
ztzja*|N7pi|Eut!smA`C-{Jqia9Q<VO~*oexL>pIwb#%0>1FB^$k|?&nZF4eyMN){
zttvPqqpUvIkNL90pYP{~ls~tVBd{OK*H9pg`#+`5`{T;7LG_>Q{ajF-{@zX|%?_OX
zcRO$n$Gi@DuG?<fsZs|U*-$ARqO6<ezTN+6)&6$1j&Fu?Cw|<2-oI#>m8$=DDuH>}
Ip>)>&Pq=@S(EtDd

literal 0
HcmV?d00001

diff --git a/english/basic_content/const/funciton_const/condition3/condition1.cpp b/english/basic_content/const/funciton_const/condition3/condition1.cpp
new file mode 100644
index 0000000..b58bca7
--- /dev/null
+++ b/english/basic_content/const/funciton_const/condition3/condition1.cpp
@@ -0,0 +1,10 @@
+#include<iostream>
+using namespace std;
+
+int main(){
+
+    const int p = 3;
+    const int * const ptr = &p;
+    cout<<*ptr<<endl;
+
+}

From f04d7db8e9e776c11df0c45b22d0370cc00e7552 Mon Sep 17 00:00:00 2001
From: xliu79 <liuxiyuan1993@gmail.com>
Date: Sat, 18 Jul 2020 19:32:55 +0800
Subject: [PATCH 20/62] english

---
 english/basic_content/enum/README.md          | 161 ++++++++++++++++++
 english/basic_content/enum/classic_practice   | Bin 0 -> 9328 bytes
 .../basic_content/enum/classic_practice.cpp   |  87 ++++++++++
 .../basic_content/enum/tradition_color.cpp    |  10 ++
 4 files changed, 258 insertions(+)
 create mode 100644 english/basic_content/enum/README.md
 create mode 100755 english/basic_content/enum/classic_practice
 create mode 100644 english/basic_content/enum/classic_practice.cpp
 create mode 100644 english/basic_content/enum/tradition_color.cpp

diff --git a/english/basic_content/enum/README.md b/english/basic_content/enum/README.md
new file mode 100644
index 0000000..9d91a7d
--- /dev/null
+++ b/english/basic_content/enum/README.md
@@ -0,0 +1,161 @@
+# From beginner to Master
+
+## About author：
+
+
+![](../img/wechat.jpg)
+
+
+## Traditional
+
+
+Enum has the following problems:
+
+- The scope is not limited, and it is easy to cause naming conflicts. For example：
+
+```c++
+#include <iostream>
+using namespace std;
+
+enum Color {RED,BLUE};
+enum Feeling {EXCITED,BLUE};
+
+int main() 
+{
+    return 0;
+}
+```
+- Implicit conversion to int
+
+- The actual type used to represent an enumerated variable cannot be explicitly specified, Therefore, forward declaration of enumeration types cannot be supported.
+Implementation：[tradition_color.cpp](tradition_color.cpp)
+
+## Classic Method
+
+A simple way to solve the problem of naming conflicts caused by unlimited scope is to prefix the enumeration variables. Change the above example to COLOR_BLUE and FEELING_BLUE。
+
+Generally speaking, we usually prefix all constants for uniformity.But the code for defining enumeration variables is cumbersome.This may have to be done in the C program. But C++ coder do not like this method。Alternatives is namespace:
+```c++
+namespace Color 
+{
+    enum Type
+    {
+        RED=15,
+        YELLOW,
+        BLUE
+    };
+};
+```
+
+Then you can use `Color::Type c = Color::RED;` to define the new enumeration。If after`using namespace Color` ，the prefix can also be omitted to simplify the code.However, the scope closure provided by a namespace is not high because it can be subsequently extended.In large projects, it is still possible for different people to give different things the same enumeration type names.
+
+A more "effective" approach is to limit its scope with a class or struct.For example：The new variable is defined in the same way as in the namespace above. This way, you don't have to worry about the class being modified elsewhere.We use structs instead of classes because we want these constants to be publicly accessible.
+
+```c++
+struct Color1
+{
+    enum Type
+    {
+        RED=102,
+        YELLOW,
+        BLUE
+    };
+};
+```
+
+Implementation：[classic_practice.cpp](classic_practice.cpp)
+
+## C++11 Enum class
+
+The above approach solves the first problem, but it can not do anything for the latter two.Fortunately，C ++ 11 standard introduces enum class. It can solve the above problems.
+
+- The scope of the new enum is no longer global
+
+- Cannot be implicitly converted to another type
+
+
+```c++
+/**
+ * @brief C++11 enum class
+ * Equals to enum class Color2:int
+ */
+enum class Color2
+{
+    RED=2,
+    YELLOW,
+    BLUE
+};
+r2 c2 = Color2::RED;
+cout << static_cast<int>(c2) << endl; //！
+```
+
+- You can specify a specific type to store enum
+
+```c++
+enum class Color3:char;  // Forward statement
+
+// Definition
+enum class Color3:char 
+{
+    RED='r',
+    BLUE
+};
+char c3 = static_cast<char>(Color3::RED);
+```
+
+Implementation：[classic_practice.cpp](classic_practice.cpp)
+
+## Enum types in class
+
+
+
+Sometimes we want certain constants to work only in classes. Because the macro constant defined by a is global, it can not achieve the purpose, so we want to use const to modify data members.The const data member does exist, but its meaning is not what we expected. 
+Data members are constants only for the lifetime of an objec. However, it is variable for the whole class, because the class can create multiple objects, and the values of const data members of different objects can be different.
+
+
+
+Cannot be initialized in a class declaration const data memeber。The following usage is incorrect，Because the compiler does not know what the value of size is when the object of the class is not created.(c++11)
+
+```c++
+class A 
+{
+  const int SIZE = 100;   // Error，Attempt to initialize const data member in class declaration 
+  int array[SIZE];  // Error，Unknown size 
+}; 
+```
+
+This should be done in the initialization list of the class's constructor:
+
+```c++
+class A 
+{
+  A(int size);  // Constructor 
+  const int SIZE ;
+}; 
+A::A(int size) : SIZE(size)  // The definition of Struct
+{ 
+
+} 
+A  a(100); // The size of Object A is 100 
+A  b(200); // The size of Object B is 200 
+```
+
+How can I establish constants that are constant throughout a class?
+
+It should be implemented with enumeration constants in the class. Such as:
+
+```c++
+class Person{
+public:
+    typedef enum {
+        BOY = 0,
+        GIRL
+    }SexType;
+};
+//Access via Person::BOY or Person::GIRL.
+```
+
+Enum constants do not take up the storage space of the object . They are all evaluated at compile time
+
+
+Drawback of Enum：Its implied data type is an integer, the maximum is limited, and it cannot represent floating point.
diff --git a/english/basic_content/enum/classic_practice b/english/basic_content/enum/classic_practice
new file mode 100755
index 0000000000000000000000000000000000000000..f9f67b7aad21345bab72ac320341410e3d763f7e
GIT binary patch
literal 9328
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

literal 0
HcmV?d00001

diff --git a/english/basic_content/enum/classic_practice.cpp b/english/basic_content/enum/classic_practice.cpp
new file mode 100644
index 0000000..f831521
--- /dev/null
+++ b/english/basic_content/enum/classic_practice.cpp
@@ -0,0 +1,87 @@
+/**
+ * @file classic_practice.cpp
+ * @brief g++ -o classic_practice classic_practice.cpp -std=c++11
+ * @author 光城
+ * @version v1
+ * @date 2019-08-07
+ */
+
+#include <iostream>
+using namespace std;
+/**
+ * @brief namespace解决作用域不受限
+ */
+namespace Color 
+{
+    enum Type
+    {
+        RED=15,
+        YELLOW,
+        BLUE
+    };
+};
+
+/**
+ * @brief 上述如果 using namespace Color 后，前缀还可以省去，使得代码简化。
+ * 不过，因为命名空间是可以随后被扩充内容的，所以它提供的作用域封闭性不高。
+ * 在大项目中，还是有可能不同人给不同的东西起同样的枚举类型名。
+ * 更“有效”的办法是用一个类或结构体来限定其作用域。
+ *
+ * 定义新变量的方法和上面命名空间的相同。
+ * 不过这样就不用担心类在别处被修改内容。
+ * 这里用结构体而非类，一是因为本身希望这些常量可以公开访问，
+ * 二是因为它只包含数据没有成员函数。
+ */
+struct Color1
+{
+    enum Type
+    {
+        RED=102,
+        YELLOW,
+        BLUE
+    };
+};
+
+/**
+ * @brief C++11的枚举类
+ * 下面等价于enum class Color2:int
+ */
+enum class Color2
+{
+    RED=2,
+    YELLOW,
+    BLUE
+};
+
+enum class Color3:char;  // 前向声明
+
+// 定义
+enum class Color3:char 
+{
+    RED='r',
+    BLUE
+};
+
+int main() 
+{
+    // 定义新的枚举变量
+    Color::Type c = Color::RED;
+    cout<<c<<endl;  
+    /**
+     * 上述的另一种方法：
+     * using namespace Color; // 定义新的枚举变量
+     * Type c = RED;
+     */
+    Color1 c1;
+    cout<<c1.RED<<endl;
+
+    Color1::Type c11 = Color1::BLUE;
+    cout<<c11<<endl;
+    
+    Color2 c2 = Color2::RED;
+    cout << static_cast<int>(c2) << endl;
+    
+    char c3 = static_cast<char>(Color3::RED);
+    cout<<c3<<endl;
+    return 0;
+}
diff --git a/english/basic_content/enum/tradition_color.cpp b/english/basic_content/enum/tradition_color.cpp
new file mode 100644
index 0000000..2136b32
--- /dev/null
+++ b/english/basic_content/enum/tradition_color.cpp
@@ -0,0 +1,10 @@
+#include <iostream>
+using namespace std;
+
+enum Color {RED,BLUE};
+enum Feeling {EXCITED,BLUE};
+
+int main() 
+{
+    return 0;
+}

From c6b3297af9c678751c6a183f4f655293c9e1d737 Mon Sep 17 00:00:00 2001
From: zgdgod <1092792570@qq.com>
Date: Sat, 18 Jul 2020 21:27:58 +0800
Subject: [PATCH 21/62] Update 2_5_id.cpp
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

主要是master_thread只进行了定义，没有赋值，进入main函数之后，才有master_thread_id; 其他就是加了一些输出，看起来直观一点
---
 concurrency/concurrency_v1/chapter2/2_5_id.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/concurrency/concurrency_v1/chapter2/2_5_id.cpp b/concurrency/concurrency_v1/chapter2/2_5_id.cpp
index 67b00d7..905aafb 100644
--- a/concurrency/concurrency_v1/chapter2/2_5_id.cpp
+++ b/concurrency/concurrency_v1/chapter2/2_5_id.cpp
@@ -27,8 +27,12 @@ void some_core_part_of_algorithm() {
 }
 
 int main() {
-    std::cout << std::this_thread::get_id() << endl;
+    master_thread = std::this_thread::get_id();
+    std::cout << "master_thread: " << master_thread << endl;
+    cout << "master_thread 中运行:" << endl;
+    some_core_part_of_algorithm();
+    cout << "thread 中运行:" << endl;
     thread t(some_core_part_of_algorithm);
     t.join();
     return 0;
-}
\ No newline at end of file
+}

From 9f6088a31e80fb0056a2947b754413cfcfe4328e Mon Sep 17 00:00:00 2001
From: xliu79 <liuxiyuan1993@gmail.com>
Date: Sat, 18 Jul 2020 23:30:56 +0800
Subject: [PATCH 22/62] english

---
 english/basic_content/c_poly/README.md     |  46 +++++++++++++++++
 english/basic_content/c_poly/c++_examp     | Bin 0 -> 8720 bytes
 english/basic_content/c_poly/c++_examp.cpp |  43 ++++++++++++++++
 english/basic_content/c_poly/c_examp       | Bin 0 -> 8720 bytes
 english/basic_content/c_poly/c_examp.c     |  55 +++++++++++++++++++++
 5 files changed, 144 insertions(+)
 create mode 100644 english/basic_content/c_poly/README.md
 create mode 100755 english/basic_content/c_poly/c++_examp
 create mode 100644 english/basic_content/c_poly/c++_examp.cpp
 create mode 100755 english/basic_content/c_poly/c_examp
 create mode 100644 english/basic_content/c_poly/c_examp.c

diff --git a/english/basic_content/c_poly/README.md b/english/basic_content/c_poly/README.md
new file mode 100644
index 0000000..59e7c6a
--- /dev/null
+++ b/english/basic_content/c_poly/README.md
@@ -0,0 +1,46 @@
+# Object oriented features of C + + implemented by C
+
+
+## About Author：
+
+
+![](../img/wechat.jpg)
+
+## 1.C++ 
+
+Polymorphism in C ++ :In C++, we usually maintain a virtual function table. According to the assignment compatibility rule, we know that the pointer or reference of the parent class can point to the child class object
+
+
+
+If the pointer or reference of a parent class calls the virtual function of the parent class, the pointer of the parent class will look up its function address in its own virtual function table.If the pointer or reference of the parent object points to an object of a subclass, and the subclass has overridden the virtual function of the parent class, the pointer will call the overridden virtual function of the subclass.
+
+Code Example:[c++_examp.cpp](./c++_examp.cpp)
+
+
+
+## 2.C Implement
+
+- Encapsulation
+
+There is no concept of class class in C language. But with struct structure, we can use struct to simulate；
+
+Encapsulating properties and methods into structures using function pointers.
+
+
+
+- Inherit
+
+Structure nesting
+
+
+- Polymorphic
+
+Class and subclass methods have different function pointers
+
+There is no member function in the structure of C language. How to realize the common function of parent structure and child structure? We can consider using function pointers to simulate. But there is a flaw in this approach：The function pointer between the parent and child does not point to the virtual function table maintained in C ++, but a piece of physical memory. If there are too many simulated functions, it will not be easy to maintain.
+
+In order to simulate polymorphism, function pointer variables must be aligned(They are completely consistent in content and alignment of variables).Otherwise, the parent class pointer points to the child class object, and the operation crashes!
+
+
+
+Code example :[c_examp.c](./c_examp.c)
diff --git a/english/basic_content/c_poly/c++_examp b/english/basic_content/c_poly/c++_examp
new file mode 100755
index 0000000000000000000000000000000000000000..fe986fd26f303345cb71edb58a029c5bf9672f44
GIT binary patch
literal 8720
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

literal 0
HcmV?d00001

diff --git a/english/basic_content/c_poly/c++_examp.cpp b/english/basic_content/c_poly/c++_examp.cpp
new file mode 100644
index 0000000..aee979b
--- /dev/null
+++ b/english/basic_content/c_poly/c++_examp.cpp
@@ -0,0 +1,43 @@
+/**
+ * @file c++_examp.cpp
+ * @brief c++中的多态
+ * @author 光城
+ * @version v1
+ * @date 2019-08-06
+ */
+
+#include <iostream>
+
+using namespace std;
+class A
+{
+    public:
+        virtual void f()//Implement a virtual function
+        {
+            cout << "Base A::f() " << endl;
+        }
+};
+
+class B:public A    // 必须为共有继承，否则后面调用不到，class默认为私有继承！
+{
+    public:
+        virtual void f()//Virtual function implementation, virtual keyword in subclass can not be appearence
+        {
+            cout << "Derived B::f() " << endl;
+        }
+};
+
+
+int main() 
+{
+    A a;//Base class object
+    B b;//an object of derived type
+
+    A* pa = &a;//The parent class pointer points to the parent object
+    pa->f();//Call the function of the parent class
+    pa = &b; //The parent class pointer points to the subclass object, which is implemented in polymorphism
+
+
+    pa->f();//Call the function with the same name of the derived class
+    return 0;
+}
diff --git a/english/basic_content/c_poly/c_examp b/english/basic_content/c_poly/c_examp
new file mode 100755
index 0000000000000000000000000000000000000000..458fb2a5db728b32f9b99b15c7b598fb0f65583a
GIT binary patch
literal 8720
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

literal 0
HcmV?d00001

diff --git a/english/basic_content/c_poly/c_examp.c b/english/basic_content/c_poly/c_examp.c
new file mode 100644
index 0000000..7798d3e
--- /dev/null
+++ b/english/basic_content/c_poly/c_examp.c
@@ -0,0 +1,55 @@
+/**
+ * @file c_examp.c
+ * @brief C实现多态
+ * @author 光城
+ * @version v1
+ * @date 2019-08-06
+ */
+
+#include <stdio.h>
+
+/// Define a pointer of function
+typedef void (*pf) ();
+
+/**
+ * @brief parent class
+ */ 
+typedef struct _A
+{
+    pf _f;
+}A;
+
+
+/**
+ * @brief child class
+ */
+typedef struct _B
+{ 
+    A _b; ///< The inheritance of the parent class can be realized by defining an object of the base class in the subclass 
+}B;
+
+void FunA() 
+{
+    printf("%s\n","Base A::fun()");
+}
+
+void FunB() 
+{
+    printf("%s\n","Derived B::fun()");
+}
+
+
+int main() 
+{
+    A a;
+    B b;
+
+    a._f = FunA;
+    b._b._f = FunB;
+
+    A *pa = &a;
+    pa->_f();
+    pa = (A *)&b;   /// The parent class pointer points to the object of the subclass. Because of the type mismatch, it needs to be forced
+    pa->_f();
+    return 0;
+}

From 2bdeea85d16ffb02359f437f44676f6b8e899073 Mon Sep 17 00:00:00 2001
From: xliu79 <liuxiyuan1993@gmail.com>
Date: Sun, 19 Jul 2020 10:38:38 +0800
Subject: [PATCH 23/62] english

---
 english/basic_content/abstract/README.md      | 140 ++++++++++
 english/basic_content/abstract/abstract.cpp   |  27 ++
 .../basic_content/abstract/derived_full.cpp   |  32 +++
 .../abstract/interesting_facts1.cpp           |  28 ++
 .../abstract/interesting_facts2.cpp           |  38 +++
 .../abstract/interesting_facts3.cpp           |  29 ++
 .../abstract/interesting_facts4.cpp           |  35 +++
 .../abstract/interesting_facts5.cpp           |  30 +++
 .../basic_content/abstract/pure_virtual.cpp   |  34 +++
 english/basic_content/abstract/test.cpp       |  23 ++
 english/basic_content/assert/README.md        |  61 +++++
 english/basic_content/assert/assert.c         |  18 ++
 english/basic_content/assert/ignore_assert.c  |  17 ++
 english/basic_content/bit/README.md           | 177 +++++++++++++
 english/basic_content/bit/learn.cpp           |  19 ++
 english/basic_content/decltype/README.md      | 138 ++++++++++
 english/basic_content/decltype/decltype       | Bin 0 -> 22080 bytes
 english/basic_content/decltype/decltype.cpp   |  60 +++++
 english/basic_content/explicit/README.md      |  16 ++
 english/basic_content/explicit/explicit       | Bin 0 -> 9288 bytes
 english/basic_content/explicit/explicit.cpp   |  46 ++++
 english/basic_content/extern/README.md        | 193 ++++++++++++++
 english/basic_content/extern/extern_c++/add.c |   5 +
 .../basic_content/extern/extern_c++/add.cpp   |   9 +
 english/basic_content/extern/extern_c++/add.h |   4 +
 english/basic_content/extern/extern_c++/add.o | Bin 0 -> 1248 bytes
 english/basic_content/extern/extern_c++/main  | Bin 0 -> 8960 bytes
 english/basic_content/extern/extern_c/add.c   |   5 +
 english/basic_content/extern/extern_c/add.cpp |   5 +
 english/basic_content/extern/extern_c/add.h   |   6 +
 english/basic_content/extern/extern_c/add.o   | Bin 0 -> 1248 bytes
 english/basic_content/extern/extern_c/main    | Bin 0 -> 8608 bytes
 english/basic_content/friend/README.md        | 115 ++++++++
 english/basic_content/friend/friend_class     | Bin 0 -> 9344 bytes
 english/basic_content/friend/friend_class.cpp |  28 ++
 english/basic_content/friend/friend_func      | Bin 0 -> 9336 bytes
 english/basic_content/friend/friend_func.cpp  |  33 +++
 english/basic_content/func_pointer/func1      | Bin 0 -> 9368 bytes
 .../func_pointer/func_pointer.cpp             |  33 +++
 english/basic_content/img/wechat.jpg          | Bin 0 -> 28028 bytes
 english/basic_content/inline/README.md        | 137 ++++++++++
 english/basic_content/inline/inline           | Bin 0 -> 9200 bytes
 english/basic_content/inline/inline.cpp       |  57 ++++
 english/basic_content/inline/inline.h         |  19 ++
 .../basic_content/inline/inline_virtual.cpp   |  35 +++
 english/basic_content/inline/iv               | Bin 0 -> 14376 bytes
 english/basic_content/macro/README.md         | 232 ++++++++++++++++
 english/basic_content/macro/do_while          | Bin 0 -> 9464 bytes
 english/basic_content/macro/do_while.cpp      |  76 ++++++
 english/basic_content/macro/sig_examp         | Bin 0 -> 14360 bytes
 english/basic_content/macro/sig_examp.cpp     |  86 ++++++
 english/basic_content/maohao/.README.md.un~   | Bin 0 -> 1052 bytes
 english/basic_content/maohao/README.md        |  14 +
 english/basic_content/maohao/README.md~       |  14 +
 english/basic_content/maohao/maohao.cpp       |  20 ++
 english/basic_content/pointer_refer/README.md | 174 ++++++++++++
 .../pointer_refer/copy_construct              | Bin 0 -> 9592 bytes
 .../pointer_refer/copy_construct.cpp          |  35 +++
 english/basic_content/pointer_refer/effec     | Bin 0 -> 20576 bytes
 english/basic_content/pointer_refer/effec.cpp |  22 ++
 english/basic_content/sizeof/README.md        | 191 ++++++++++++++
 english/basic_content/sizeof/blackclass.cpp   |  18 ++
 english/basic_content/sizeof/genA.cpp         |  29 ++
 english/basic_content/sizeof/geninhe.cpp      |  62 +++++
 english/basic_content/sizeof/moreinhe.cpp     |  43 +++
 english/basic_content/sizeof/morevir.cpp      |  24 ++
 english/basic_content/sizeof/static.cpp       |  33 +++
 english/basic_content/sizeof/virinhe.cpp      |  38 +++
 english/basic_content/sizeof/virmoreinhe.cpp  |  38 +++
 english/basic_content/static/README.md        | 248 ++++++++++++++++++
 english/basic_content/static/demo             | Bin 0 -> 9104 bytes
 .../basic_content/static/nostatic_class.cpp   |  28 ++
 english/basic_content/static/static_class.cpp |  28 ++
 english/basic_content/static/static_demo.cpp  |  24 ++
 .../static/static_error_variable.cpp          |  26 ++
 .../basic_content/static/static_funciton.cpp  |  20 ++
 .../basic_content/static/static_variable.cpp  |  24 ++
 english/basic_content/struct/README.md        | 228 ++++++++++++++++
 english/basic_content/struct/ext              | Bin 0 -> 14536 bytes
 .../basic_content/struct/ext_struct_func.cpp  |  33 +++
 english/basic_content/struct/sf               | Bin 0 -> 8992 bytes
 english/basic_content/struct/stff             | Bin 0 -> 9152 bytes
 english/basic_content/struct/struct_func      | Bin 0 -> 8768 bytes
 english/basic_content/struct/struct_func.c    |  27 ++
 english/basic_content/struct/struct_func.cpp  |  25 ++
 .../basic_content/struct/struct_func_func.cpp |  39 +++
 english/basic_content/struct/stu              | Bin 0 -> 9112 bytes
 english/basic_content/struct_class/README.md  |  19 ++
 english/basic_content/this/README.md          |  89 +++++++
 english/basic_content/this/img/constthis.png  | Bin 0 -> 28641 bytes
 english/basic_content/this/img/genthis.png    | Bin 0 -> 34264 bytes
 .../basic_content/this/img/thiscontrust.png   | Bin 0 -> 59227 bytes
 english/basic_content/this/person             | Bin 0 -> 33952 bytes
 english/basic_content/this/person.cpp         |  41 +++
 english/basic_content/union/README.md         |  18 ++
 english/basic_content/union/union             | Bin 0 -> 9704 bytes
 english/basic_content/union/union.cpp         |  50 ++++
 english/basic_content/using/README.md         | 120 +++++++++
 english/basic_content/using/derived_base      | Bin 0 -> 15168 bytes
 english/basic_content/using/derived_base.cpp  |  48 ++++
 english/basic_content/using/using_derived     | Bin 0 -> 9320 bytes
 english/basic_content/using/using_derived.cpp |  36 +++
 english/basic_content/using/using_global      | Bin 0 -> 9296 bytes
 english/basic_content/using/using_global.cpp  |  45 ++++
 english/basic_content/using/using_typedef     | Bin 0 -> 22024 bytes
 english/basic_content/using/using_typedef.cpp |  34 +++
 english/basic_content/virtual/README.md       | 102 +++++++
 english/basic_content/virtual/set1/emp        | Bin 0 -> 14464 bytes
 english/basic_content/virtual/set1/emp.cpp    |  52 ++++
 .../virtual/set2/default_arg.cpp              |  39 +++
 .../virtual/set3/copy_consrtuct.cpp           |  41 +++
 .../basic_content/virtual/set3/full_virde.cpp |  39 +++
 .../virtual/set3/inline_virtual.cpp           |  35 +++
 .../virtual/set3/static_error.cpp             |  13 +
 .../basic_content/virtual/set3/vir_con.cpp    | 206 +++++++++++++++
 english/basic_content/virtual/set3/vir_de.cpp |  41 +++
 .../virtual/set3/virtual_function.cpp         |  33 +++
 .../virtual/set3/virtual_function1.cpp        |  22 ++
 .../virtual/set3/virtual_inline.cpp           |  44 ++++
 english/basic_content/virtual/set4/rtti       | Bin 0 -> 14944 bytes
 english/basic_content/virtual/set4/rtti.cpp   |  34 +++
 .../basic_content/virtual/set4/warn_rtti.cpp  |  35 +++
 english/basic_content/volatile/README.md      | 122 +++++++++
 english/basic_content/volatile/noopt_vola.cpp |  15 ++
 english/basic_content/volatile/nv             | Bin 0 -> 8672 bytes
 english/basic_content/volatile/volatile.cpp   |  16 ++
 english/basic_content/vptr_vtable/README.md   | 219 ++++++++++++++++
 .../basic_content/vptr_vtable/img/base.jpg    | Bin 0 -> 136050 bytes
 english/basic_content/vptr_vtable/vptr1.cpp   | 105 ++++++++
 129 files changed, 5264 insertions(+)
 create mode 100644 english/basic_content/abstract/README.md
 create mode 100644 english/basic_content/abstract/abstract.cpp
 create mode 100644 english/basic_content/abstract/derived_full.cpp
 create mode 100644 english/basic_content/abstract/interesting_facts1.cpp
 create mode 100644 english/basic_content/abstract/interesting_facts2.cpp
 create mode 100644 english/basic_content/abstract/interesting_facts3.cpp
 create mode 100644 english/basic_content/abstract/interesting_facts4.cpp
 create mode 100644 english/basic_content/abstract/interesting_facts5.cpp
 create mode 100644 english/basic_content/abstract/pure_virtual.cpp
 create mode 100644 english/basic_content/abstract/test.cpp
 create mode 100644 english/basic_content/assert/README.md
 create mode 100644 english/basic_content/assert/assert.c
 create mode 100644 english/basic_content/assert/ignore_assert.c
 create mode 100644 english/basic_content/bit/README.md
 create mode 100644 english/basic_content/bit/learn.cpp
 create mode 100644 english/basic_content/decltype/README.md
 create mode 100755 english/basic_content/decltype/decltype
 create mode 100644 english/basic_content/decltype/decltype.cpp
 create mode 100644 english/basic_content/explicit/README.md
 create mode 100755 english/basic_content/explicit/explicit
 create mode 100644 english/basic_content/explicit/explicit.cpp
 create mode 100644 english/basic_content/extern/README.md
 create mode 100644 english/basic_content/extern/extern_c++/add.c
 create mode 100644 english/basic_content/extern/extern_c++/add.cpp
 create mode 100644 english/basic_content/extern/extern_c++/add.h
 create mode 100644 english/basic_content/extern/extern_c++/add.o
 create mode 100755 english/basic_content/extern/extern_c++/main
 create mode 100644 english/basic_content/extern/extern_c/add.c
 create mode 100644 english/basic_content/extern/extern_c/add.cpp
 create mode 100644 english/basic_content/extern/extern_c/add.h
 create mode 100644 english/basic_content/extern/extern_c/add.o
 create mode 100755 english/basic_content/extern/extern_c/main
 create mode 100644 english/basic_content/friend/README.md
 create mode 100755 english/basic_content/friend/friend_class
 create mode 100644 english/basic_content/friend/friend_class.cpp
 create mode 100755 english/basic_content/friend/friend_func
 create mode 100644 english/basic_content/friend/friend_func.cpp
 create mode 100755 english/basic_content/func_pointer/func1
 create mode 100644 english/basic_content/func_pointer/func_pointer.cpp
 create mode 100755 english/basic_content/img/wechat.jpg
 create mode 100644 english/basic_content/inline/README.md
 create mode 100755 english/basic_content/inline/inline
 create mode 100644 english/basic_content/inline/inline.cpp
 create mode 100644 english/basic_content/inline/inline.h
 create mode 100644 english/basic_content/inline/inline_virtual.cpp
 create mode 100755 english/basic_content/inline/iv
 create mode 100644 english/basic_content/macro/README.md
 create mode 100755 english/basic_content/macro/do_while
 create mode 100644 english/basic_content/macro/do_while.cpp
 create mode 100755 english/basic_content/macro/sig_examp
 create mode 100644 english/basic_content/macro/sig_examp.cpp
 create mode 100644 english/basic_content/maohao/.README.md.un~
 create mode 100644 english/basic_content/maohao/README.md
 create mode 100644 english/basic_content/maohao/README.md~
 create mode 100644 english/basic_content/maohao/maohao.cpp
 create mode 100644 english/basic_content/pointer_refer/README.md
 create mode 100755 english/basic_content/pointer_refer/copy_construct
 create mode 100644 english/basic_content/pointer_refer/copy_construct.cpp
 create mode 100755 english/basic_content/pointer_refer/effec
 create mode 100644 english/basic_content/pointer_refer/effec.cpp
 create mode 100644 english/basic_content/sizeof/README.md
 create mode 100644 english/basic_content/sizeof/blackclass.cpp
 create mode 100644 english/basic_content/sizeof/genA.cpp
 create mode 100644 english/basic_content/sizeof/geninhe.cpp
 create mode 100644 english/basic_content/sizeof/moreinhe.cpp
 create mode 100644 english/basic_content/sizeof/morevir.cpp
 create mode 100644 english/basic_content/sizeof/static.cpp
 create mode 100644 english/basic_content/sizeof/virinhe.cpp
 create mode 100644 english/basic_content/sizeof/virmoreinhe.cpp
 create mode 100644 english/basic_content/static/README.md
 create mode 100755 english/basic_content/static/demo
 create mode 100644 english/basic_content/static/nostatic_class.cpp
 create mode 100644 english/basic_content/static/static_class.cpp
 create mode 100644 english/basic_content/static/static_demo.cpp
 create mode 100644 english/basic_content/static/static_error_variable.cpp
 create mode 100644 english/basic_content/static/static_funciton.cpp
 create mode 100644 english/basic_content/static/static_variable.cpp
 create mode 100644 english/basic_content/struct/README.md
 create mode 100755 english/basic_content/struct/ext
 create mode 100644 english/basic_content/struct/ext_struct_func.cpp
 create mode 100755 english/basic_content/struct/sf
 create mode 100755 english/basic_content/struct/stff
 create mode 100755 english/basic_content/struct/struct_func
 create mode 100644 english/basic_content/struct/struct_func.c
 create mode 100644 english/basic_content/struct/struct_func.cpp
 create mode 100644 english/basic_content/struct/struct_func_func.cpp
 create mode 100755 english/basic_content/struct/stu
 create mode 100644 english/basic_content/struct_class/README.md
 create mode 100644 english/basic_content/this/README.md
 create mode 100644 english/basic_content/this/img/constthis.png
 create mode 100644 english/basic_content/this/img/genthis.png
 create mode 100644 english/basic_content/this/img/thiscontrust.png
 create mode 100755 english/basic_content/this/person
 create mode 100644 english/basic_content/this/person.cpp
 create mode 100644 english/basic_content/union/README.md
 create mode 100755 english/basic_content/union/union
 create mode 100644 english/basic_content/union/union.cpp
 create mode 100644 english/basic_content/using/README.md
 create mode 100755 english/basic_content/using/derived_base
 create mode 100644 english/basic_content/using/derived_base.cpp
 create mode 100755 english/basic_content/using/using_derived
 create mode 100644 english/basic_content/using/using_derived.cpp
 create mode 100755 english/basic_content/using/using_global
 create mode 100644 english/basic_content/using/using_global.cpp
 create mode 100755 english/basic_content/using/using_typedef
 create mode 100644 english/basic_content/using/using_typedef.cpp
 create mode 100644 english/basic_content/virtual/README.md
 create mode 100755 english/basic_content/virtual/set1/emp
 create mode 100644 english/basic_content/virtual/set1/emp.cpp
 create mode 100644 english/basic_content/virtual/set2/default_arg.cpp
 create mode 100644 english/basic_content/virtual/set3/copy_consrtuct.cpp
 create mode 100644 english/basic_content/virtual/set3/full_virde.cpp
 create mode 100644 english/basic_content/virtual/set3/inline_virtual.cpp
 create mode 100644 english/basic_content/virtual/set3/static_error.cpp
 create mode 100644 english/basic_content/virtual/set3/vir_con.cpp
 create mode 100644 english/basic_content/virtual/set3/vir_de.cpp
 create mode 100644 english/basic_content/virtual/set3/virtual_function.cpp
 create mode 100644 english/basic_content/virtual/set3/virtual_function1.cpp
 create mode 100644 english/basic_content/virtual/set3/virtual_inline.cpp
 create mode 100755 english/basic_content/virtual/set4/rtti
 create mode 100644 english/basic_content/virtual/set4/rtti.cpp
 create mode 100644 english/basic_content/virtual/set4/warn_rtti.cpp
 create mode 100644 english/basic_content/volatile/README.md
 create mode 100644 english/basic_content/volatile/noopt_vola.cpp
 create mode 100755 english/basic_content/volatile/nv
 create mode 100644 english/basic_content/volatile/volatile.cpp
 create mode 100644 english/basic_content/vptr_vtable/README.md
 create mode 100644 english/basic_content/vptr_vtable/img/base.jpg
 create mode 100644 english/basic_content/vptr_vtable/vptr1.cpp

diff --git a/english/basic_content/abstract/README.md b/english/basic_content/abstract/README.md
new file mode 100644
index 0000000..e11aa35
--- /dev/null
+++ b/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)
\ No newline at end of file
diff --git a/english/basic_content/abstract/abstract.cpp b/english/basic_content/abstract/abstract.cpp
new file mode 100644
index 0000000..3a26d99
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/abstract/derived_full.cpp b/english/basic_content/abstract/derived_full.cpp
new file mode 100644
index 0000000..176ace8
--- /dev/null
+++ b/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; 
+} 
diff --git a/english/basic_content/abstract/interesting_facts1.cpp b/english/basic_content/abstract/interesting_facts1.cpp
new file mode 100644
index 0000000..048ede7
--- /dev/null
+++ b/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; 
+} 
+
diff --git a/english/basic_content/abstract/interesting_facts2.cpp b/english/basic_content/abstract/interesting_facts2.cpp
new file mode 100644
index 0000000..84d293e
--- /dev/null
+++ b/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; 
+} 
+
diff --git a/english/basic_content/abstract/interesting_facts3.cpp b/english/basic_content/abstract/interesting_facts3.cpp
new file mode 100644
index 0000000..fb76824
--- /dev/null
+++ b/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; 
+} 
+
diff --git a/english/basic_content/abstract/interesting_facts4.cpp b/english/basic_content/abstract/interesting_facts4.cpp
new file mode 100644
index 0000000..028554b
--- /dev/null
+++ b/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; 
+} 
diff --git a/english/basic_content/abstract/interesting_facts5.cpp b/english/basic_content/abstract/interesting_facts5.cpp
new file mode 100644
index 0000000..e9152b9
--- /dev/null
+++ b/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;
+}
+
diff --git a/english/basic_content/abstract/pure_virtual.cpp b/english/basic_content/abstract/pure_virtual.cpp
new file mode 100644
index 0000000..bfaf177
--- /dev/null
+++ b/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是抽象类，不能创建对象
+}
diff --git a/english/basic_content/abstract/test.cpp b/english/basic_content/abstract/test.cpp
new file mode 100644
index 0000000..7797c90
--- /dev/null
+++ b/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 */
+}; 
diff --git a/english/basic_content/assert/README.md b/english/basic_content/assert/README.md
new file mode 100644
index 0000000..8699eff
--- /dev/null
+++ b/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)
diff --git a/english/basic_content/assert/assert.c b/english/basic_content/assert/assert.c
new file mode 100644
index 0000000..f66a2c0
--- /dev/null
+++ b/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; 
+} 
diff --git a/english/basic_content/assert/ignore_assert.c b/english/basic_content/assert/ignore_assert.c
new file mode 100644
index 0000000..0a5a15e
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/bit/README.md b/english/basic_content/bit/README.md
new file mode 100644
index 0000000..498ed23
--- /dev/null
+++ b/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/>
diff --git a/english/basic_content/bit/learn.cpp b/english/basic_content/bit/learn.cpp
new file mode 100644
index 0000000..505256b
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/decltype/README.md b/english/basic_content/decltype/README.md
new file mode 100644
index 0000000..4a8aa80
--- /dev/null
+++ b/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
diff --git a/english/basic_content/decltype/decltype b/english/basic_content/decltype/decltype
new file mode 100755
index 0000000000000000000000000000000000000000..fb9f578a277115e8c34da59ea4f0120b5dd4f17e
GIT binary patch
literal 22080
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
Ur1@Q_{ce7-;t2|FTXDAkzc8qMy8r+H

literal 0
HcmV?d00001

diff --git a/english/basic_content/decltype/decltype.cpp b/english/basic_content/decltype/decltype.cpp
new file mode 100644
index 0000000..4bf9876
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/explicit/README.md b/english/basic_content/explicit/README.md
new file mode 100644
index 0000000..740b7b0
--- /dev/null
+++ b/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
diff --git a/english/basic_content/explicit/explicit b/english/basic_content/explicit/explicit
new file mode 100755
index 0000000000000000000000000000000000000000..ab3a4124b4c8e2fc61e774ca575ca55d4998cb7a
GIT binary patch
literal 9288
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
W+#fp2h-jOYtG`(pL>x+I{r>_NIr^Xg

literal 0
HcmV?d00001

diff --git a/english/basic_content/explicit/explicit.cpp b/english/basic_content/explicit/explicit.cpp
new file mode 100644
index 0000000..f659635
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/extern/README.md b/english/basic_content/extern/README.md
new file mode 100644
index 0000000..41c1ebe
--- /dev/null
+++ b/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();
+```
+
diff --git a/english/basic_content/extern/extern_c++/add.c b/english/basic_content/extern/extern_c++/add.c
new file mode 100644
index 0000000..b347468
--- /dev/null
+++ b/english/basic_content/extern/extern_c++/add.c
@@ -0,0 +1,5 @@
+#include "add.h"
+
+int add(int x,int y) {
+    return x+y;
+}
diff --git a/english/basic_content/extern/extern_c++/add.cpp b/english/basic_content/extern/extern_c++/add.cpp
new file mode 100644
index 0000000..8ed76fa
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/extern/extern_c++/add.h b/english/basic_content/extern/extern_c++/add.h
new file mode 100644
index 0000000..6984cdf
--- /dev/null
+++ b/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
diff --git a/english/basic_content/extern/extern_c++/add.o b/english/basic_content/extern/extern_c++/add.o
new file mode 100644
index 0000000000000000000000000000000000000000..4c8c0166688e71a05f7f34c991ae4669b52a5660
GIT binary patch
literal 1248
zcmbtT%}T>S5S}#kw<=XU2=x$8D(I3(4eCKEr79u{VvZtd8xgcEG+R(Xy$RKekKiNt
z4qkfn=nMD&-g*#prrEXY8ZSDK{bs(MZ)f%=*M;r%gkgX*16H9MNfy9Lbp2e%%|QzK
z!P{)UHZR|sjrN`QephH4&j(Mik<YJKGhVS#<qd0*WtlziHad}W<+#kwGRK*XCaeY9
zac$RL7R!$dG%ohQI7=Iup}zimY-kdB`p7ytYa{8KM1Ht;7ZV~ncBH)|;q4=C(v00H
zfC<WG6`_eUab`kK9F5t%zwpT)d>=AnN<Z=(z%Q3siN;7`2_<#-txFc3SGZpU7V>(8
z$I|1$83$JOxeu%uhQLa-N+qZwSFQ1YZR~jSA@@rs!0N%N&w}H_qq<)SM5X^h2IX`I
z`bp%(vS0fYvHtd^kS9(*`F)YEgRY;(1bQET)z6`p*0k|cP1bi+5`9@;;-bQ-skdsN
z_);gSEp&+ccGno+i-aYC67+wefD`oEaxy{SqbM{X;sHduBdM4CD02GQk)$Q`@*IdG
i)BBI>o$^{VpuI!@gNRgHuTOo&)qfC$QbI35um1^?FiF+`

literal 0
HcmV?d00001

diff --git a/english/basic_content/extern/extern_c++/main b/english/basic_content/extern/extern_c++/main
new file mode 100755
index 0000000000000000000000000000000000000000..451dd010f25752b80536895e8fcedd4f53e1729b
GIT binary patch
literal 8960
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
OpHK&Ov##Lo`u_!uDgGb;

literal 0
HcmV?d00001

diff --git a/english/basic_content/extern/extern_c/add.c b/english/basic_content/extern/extern_c/add.c
new file mode 100644
index 0000000..6f8a3d8
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/extern/extern_c/add.cpp b/english/basic_content/extern/extern_c/add.cpp
new file mode 100644
index 0000000..b347468
--- /dev/null
+++ b/english/basic_content/extern/extern_c/add.cpp
@@ -0,0 +1,5 @@
+#include "add.h"
+
+int add(int x,int y) {
+    return x+y;
+}
diff --git a/english/basic_content/extern/extern_c/add.h b/english/basic_content/extern/extern_c/add.h
new file mode 100644
index 0000000..719b7c3
--- /dev/null
+++ b/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
diff --git a/english/basic_content/extern/extern_c/add.o b/english/basic_content/extern/extern_c/add.o
new file mode 100644
index 0000000000000000000000000000000000000000..564710ebe3dbd24f5d9b8af73bcde7d9a61defcd
GIT binary patch
literal 1248
zcmbtT%}T>S5T3ME>rbVM2caI~Nd>zk(gyV)l~OAr3Sy5UX&WhMe`pe@f_f8bFMR|b
z!FTY|qeoxB2k_QIL1)@syN&Up1KDrpo0*;2+0A|Ca4(=JAVh&37+Qh_Py<6f)mKw6
z4PnUbH{YALy{6l3<$A45S9v{qfowXxt*++sZpCrcBug+YZn%9*ztat-C77<S4IJu*
zrW=}}ZSn0FI4U<MpfsXNY-S?d#)g)Vr;nr`vpXAo2&5z9#~3i6eOEe52tGdjoI&4{
z0t7)itdtl;kDml#%#X(C@n87R4}KDvd8r>U2QZ68R;bkoDM_UTg*qJRlG)c~$IJt>
zo%#SvLUXK!1FUE|Ca}D111nU^WvhZ*rRrELdz6dYj#;<_R=2K9W|ht_>So#M*ZJ=f
z!wu*Typu@rjla*yZHkp;84cpRlRuS%B;A|8f<Ag5f6ZUVT-sB^PZm+%kV(`<eSt}d
zlS3b6L()Z_pbk(WZse}fZu5Xmjsm>@LIxf5+EOBb<1;U`$ZdLmbVnjz@N>v{XGbX=
oo-gJ=9ErDozuqaXLkr5=0ALD{YJ2NbUw-wUc%cZ-7vQb`1!_x5x&QzG

literal 0
HcmV?d00001

diff --git a/english/basic_content/extern/extern_c/main b/english/basic_content/extern/extern_c/main
new file mode 100755
index 0000000000000000000000000000000000000000..f026f11a1bf6d3141b9b93812b53981122ec3df5
GIT binary patch
literal 8608
zcmeHNU2Ggz6~4RczckKzohGgG0~xi6<Q6=&Q^(!VLT1-?GLD=$IP0Q9o$=bcwwKzw
z(e7-pL!m)Vqpm`NB~mFo^reUg1P`frAQDnj%P0XsB^Oa7AVLN;#ck8zQiv?nX8F#Y
zd-i9%sVXGie59Fk&(C+xxp(f&-aE6;b@%S~dOU*3E50O1TJ#xG<(wgJk)qNC#X4b#
z9b&tvfu<UVAuYt67V{Mqnt7e_^MP042znhw&}+yB^X-lr864sYiBrBJ8LH{<x2PZx
zb0IV-6OK#)zZAiTWP`b;>S$J+aU>G1S>c)$j`@Nrj5+s@`bI}Y#fx|iNF*D?M3+1l
zIr$PDxnakseL;2dLbX9^$PRx(N<uJa+?Rn<T~{8T%mT{Xukzh(T$WY;m@82{GLabW
zXn$lP)-sVuW~W-Ff*ma#?RqAq@0R_h_~d)w@PN$3<ETNRnm6H~IY9R7f2w(ENB6B4
zn_8Nm?Re(;Z;mzgR}q#EG(R=1hv&u$-k*U^tDqO?#|V|(AuNm9R>qE|ZEG@`NJ29<
znMx{+B@XoVggdR>`fhy>A~_e<gDR;`9?$I7#5%HlUgcV87?LfzHfkzJxhdf2YatPy
z$(*@aXP&Jdtk;D3{A+gg(&u0?XMR~X?|9_*^uv_j6~Vb-hk+K!<79kiF%R1H0OZkG
z$6JWD_j_`095Zu&GiTmfJ`(A<_Sz}TB=g!_K(cFps4~RT&w=~bXv2;!Aud0L!UoKi
zRxopB#c$?roY;1mqER`GgICCqUxf2%nPPCBsu<N-ewFM4=67z%0CRVI2w>)x&AFw0
zrst~p#vOZeA=-M5*04hi&O7-}eennDH6gN%0{|{1QP|+s>N8MzK9rfRXnrbepU76f
z_kG|B!9E~Beqr#PlfY2>RhnK`Xv~*rkfr0`JXvzz`Y4xOIXm#t+3pq30x}n>ADs<-
zCG=z{mk$kuBE9E!-Kx{jnR6|~kM`tl_vGH}edva~Mspwgmiq4G^XBvK+gjV7x&OVn
zcYAZUyAUD2>AE>H?=knjmwlHm;MWF2PlpCW$3oWpY%$}9xUMpuy2KvL63;f@<3W^6
zb7nhI&`9@!N5I4A-A}=v2LCPiv*0(uZ-TdDBGG+C<T=?dJW~PBw))z-Sx;?%^z<xU
z{y3k1m>d*U_7`F&?BqWSe~o<of&KobgAMDyQFlu0+xqy!kM4Yc)Z~L{BhI6~t)vL~
z182OQ8)^oS7$VtYI9`BV=3;xFV<+rsWsif4us`rUZ`j{--q-Ed&Q*o|&EKsy{jFze
zOn-2u_K@F5`-35WYslXm_G|Eif7o9q`%U9<33*EIGYYvzYa_5W0&63%HUeuSur>mp
zJOY=n9weGoTnaex8kKpyGR*o6+1jAw(^ys#@ph5-SKFjk2;LvbwE}caSk4jAI)RAo
z|Gtw?k$ll>5G(HaR6bf85nc8g#Kb-FjQynIv=1O^a+uhxI5S!tO2TrLh}R74&+8&u
zIuhOQFfpa_vwld)TsPyf36R7xmL;-3hVsX9P0AkSx2)u#vMcrfo$)@_o#^Ua>NwEZ
z`30?cU^tt!v)UfLU2kpa$V#d0+ie|sYrEdo_K;)HcDJ^5w05-ab;owgKFqG5*Kn(`
zKlB#%%cVviEOtfzs=|CJ_pdI@lX5*~QH6f`M6IZF9ekLbeErJftP?{O<J?o2FXjI0
z1>ZO2`g(DxVw??Pp`zYjcu!Lvr$O+2SgsF<S#^Jw>l+L27s~Y;#X?2@dkgPR%KbML
z?&os-W<lFFH~GYUc&}1Pf4|^;b1BA0ceA=*%k^7?R#CrI&^FXfKEY3;qQ!$|mG~fE
z)Hp4A&Ux_kaMw@IH?Q!Efa^I)kx75VrPr0-{amH}k4F^iq&kR>;_zTs!_P;l#OWjs
zihs!!|BUoseO-P8eWiZ=<SzQVjl<7m{EcF<#z3n`b7)o?AM&V__jL)qcU8asBIB%{
z4}Vww{5v8=oc<#ltLN<obih+#o;(QsMvNQ1{UGA!{iD!pQd55Vrqr*VSA8nZvKoK>
zoj3}80Ka<f`PL%+SKp6cmHP6WBu%S0?)iKMdTq74coF(W?-tSQn&&T*9u@KZUZt?F
zKu_a9uYZW-o*Vp+I0Bf5L06pTl>eg7fQJzL?qCjj@^|<5b>&a*m5BIv{&&!8Qd53<
z8+xkW9p|5S@&5(%8%2fZ=SbSl*xAuheFU%V4tDliy*)=GmL+2GbbKt4vEymWp0q|L
zQptD*9<h`)Hjx^RPFOKJmCjhv?35TuO&*_!+wqwG*q*)Zm7T27L^5GT)9L866;Imf
zX)&6PPR6ZRc5-qWkP^v)r(Nb6jm1!&JRd&}=l%VmL)}*Q;V#ta6wU22XiQjLPaO^&
z>gj}6iABDtgbMFat!`6AGrRhQb)dH|9O||D_U}L19kC*zaBnwdkncA~GFjOPVf91~
zS;gUr9O|UOiA0Ad;#8xs;<2b5WmxgGs9}`82*pss%Xvo%-?A5`uw_!#cr+P9NUNt0
zUa>^d%4Xt-UaW??1bH}<QDK~yuLn<9{p!+nPDC>qdEHPY4;Yot*S4&9p=YKi?dUML
zop$&*w-QOrgyTX_rtG*L3iq_w(J>{BCA0c)Hi1{#iI~ty8johig&vzuBA&zTv|~9D
zPiGRTWSL;WmX1$E37}fXCv2h1?&)aiV=0Jsd<tipMsP~WA=cyLYT}H?5QHTM>dYVq
z!R@b)zzu1llZg@3kg_Q}G<3amjHA#omnShl%Wt;-L89L?+;WBIC9l)?yA7|~IW+l}
z(t{9caq#mt;x!-@zl&&6DxUZ`#hNxWO7XnzvsJ*I?5MaK-v#|`tgSi!MXw<}FDeDs
zuRgaF_8-y-r^7gCFTwcBUIP;CJ0ugP!{obK>brX%@FaA!*I>Nx8IV9~0}^zk!r483
z$6%qo0^@mI8dUfih2;9#kNGpO)82z+L*+LVUQ>9AQ(C`L%k>70DdUF}en{b)lq2VN
z_y08Pgbyn}-ak!Mz*8(Y{ycP47x$Cb&9e&6zb`7h%*AcuIUJ>UUSD5w^`9~P9f$b^
z7oOMQ3kuKmGTtq}<iani@mo}Q`kgK%&da(VqET8uuj@~%0q1=t`_ovL(vKk!p1+Cl
zdSF)J-To{ye?{T>`tx^4{yzCcX)?4K$LcFCJnttKRQ^q_{=3KT*TB=KS2bLPeFuN9
zbo;yIH-T*^!Si~$iGqUM{%-lN@SzepKkoyyPl<mUSem<x=lu?UPhL>{=lRX~c^+JJ
z<>!6T3Uvy^{*F|XS^p0hO6xD|pHu>kfr>MZ`HBnA>rzeOxlRtlIF|3AK|1a~uk%_J
z(Cx2=gW<vl1?gG~8mGZ{`Vw18jAz~mBj+yl`@MQ_)w82Ax<r|q=YA=ET-86MF5G8f
Zq#C(DDm?xtQ91vw?sKBmyMnv({}&s>5i|e*

literal 0
HcmV?d00001

diff --git a/english/basic_content/friend/README.md b/english/basic_content/friend/README.md
new file mode 100644
index 0000000..64ba791
--- /dev/null
+++ b/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的私有或保护成员，也就是不存在“友元的友元”这种关系。
diff --git a/english/basic_content/friend/friend_class b/english/basic_content/friend/friend_class
new file mode 100755
index 0000000000000000000000000000000000000000..edc462927f3e0e9a1a2a631f274d6a4e69bd4498
GIT binary patch
literal 9344
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
XW?bBV-oI#>)vDjC44$wl?e+f~T^ijn

literal 0
HcmV?d00001

diff --git a/english/basic_content/friend/friend_class.cpp b/english/basic_content/friend/friend_class.cpp
new file mode 100644
index 0000000..bfa2372
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/friend/friend_func b/english/basic_content/friend/friend_func
new file mode 100755
index 0000000000000000000000000000000000000000..351dcc6c46fbbcab59e88fb6b79b6c07ff10504f
GIT binary patch
literal 9336
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
KVVlxk|GxpiINdt{

literal 0
HcmV?d00001

diff --git a/english/basic_content/friend/friend_func.cpp b/english/basic_content/friend/friend_func.cpp
new file mode 100644
index 0000000..8ef67cc
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/func_pointer/func1 b/english/basic_content/func_pointer/func1
new file mode 100755
index 0000000000000000000000000000000000000000..0849a185e9b02b79ca1986382422ce9b6cc00cb4
GIT binary patch
literal 9368
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
QZC0*+uQGVfrnJ}pFPw$%F8}}l

literal 0
HcmV?d00001

diff --git a/english/basic_content/func_pointer/func_pointer.cpp b/english/basic_content/func_pointer/func_pointer.cpp
new file mode 100644
index 0000000..60f8bb9
--- /dev/null
+++ b/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); 
+}
diff --git a/english/basic_content/img/wechat.jpg b/english/basic_content/img/wechat.jpg
new file mode 100755
index 0000000000000000000000000000000000000000..f0869eddeca24147ff0f164a95c9320ff9ea51a0
GIT binary patch
literal 28028
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
R2%B2+=>LE6zqqFG{{VNFESCTP

literal 0
HcmV?d00001

diff --git a/english/basic_content/inline/README.md b/english/basic_content/inline/README.md
new file mode 100644
index 0000000..9f757a1
--- /dev/null
+++ b/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;
+} 
+```
+
+
+
diff --git a/english/basic_content/inline/inline b/english/basic_content/inline/inline
new file mode 100755
index 0000000000000000000000000000000000000000..c45bdb69855f545715aec5b2f72d729e5547ebea
GIT binary patch
literal 9200
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

literal 0
HcmV?d00001

diff --git a/english/basic_content/inline/inline.cpp b/english/basic_content/inline/inline.cpp
new file mode 100644
index 0000000..5b1463b
--- /dev/null
+++ b/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）。
+ */
+
+
+
diff --git a/english/basic_content/inline/inline.h b/english/basic_content/inline/inline.h
new file mode 100644
index 0000000..7827c11
--- /dev/null
+++ b/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关键字。
+    
+};
diff --git a/english/basic_content/inline/inline_virtual.cpp b/english/basic_content/inline/inline_virtual.cpp
new file mode 100644
index 0000000..1ec1a06
--- /dev/null
+++ b/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;
+} 
diff --git a/english/basic_content/inline/iv b/english/basic_content/inline/iv
new file mode 100755
index 0000000000000000000000000000000000000000..e0b0e9501405bf0626321d3cd7f9f3847cce1749
GIT binary patch
literal 14376
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
CDd;c&

literal 0
HcmV?d00001

diff --git a/english/basic_content/macro/README.md b/english/basic_content/macro/README.md
new file mode 100644
index 0000000..d20b612
--- /dev/null
+++ b/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>
+
diff --git a/english/basic_content/macro/do_while b/english/basic_content/macro/do_while
new file mode 100755
index 0000000000000000000000000000000000000000..ce870355a31e584f8a9410bf0885232b45550550
GIT binary patch
literal 9464
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

literal 0
HcmV?d00001

diff --git a/english/basic_content/macro/do_while.cpp b/english/basic_content/macro/do_while.cpp
new file mode 100644
index 0000000..68af132
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/macro/sig_examp b/english/basic_content/macro/sig_examp
new file mode 100755
index 0000000000000000000000000000000000000000..b3423603ba11d3e62a3314c1f6e6bb20c5dc9dc3
GIT binary patch
literal 14360
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
U)qdwz!~QYecnwjur;3vOH|(?W-T(jq

literal 0
HcmV?d00001

diff --git a/english/basic_content/macro/sig_examp.cpp b/english/basic_content/macro/sig_examp.cpp
new file mode 100644
index 0000000..85290a7
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/maohao/.README.md.un~ b/english/basic_content/maohao/.README.md.un~
new file mode 100644
index 0000000000000000000000000000000000000000..a02eba88a2872e31c0401bb327dc447521b006f0
GIT binary patch
literal 1052
zcmWH`%$*;a=aT=Ff$98)zYBvJyCUCSI(9|yTI8m{OmPujiKjKrr9Y0(aBTX|z`(!<
z#7a+Fw?ElC`N{6Z&lfblSl;-4&#Y)GE4}1`f>;d*tqD}c3&f&8%m~CxKnwyP8ipC-
z64oiQfMgjN;xB+?fdHlu#0E*h3}N^W1Yi-6%qXBi2mqr)1{@s>3|}RH=JNnCD7HZu
z6ct3ox@jXgB0;K=0Vq;I5vd3g9F0g&D9{oBBT@mHudqg>8kX#vo0y-Gn2(Z$O&g!D
F0sz?-VnqM|

literal 0
HcmV?d00001

diff --git a/english/basic_content/maohao/README.md b/english/basic_content/maohao/README.md
new file mode 100644
index 0000000..d78b3e5
--- /dev/null
+++ b/english/basic_content/maohao/README.md
@@ -0,0 +1,14 @@
+# :: 范围解析运算符那些事
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+- 全局作用域符（::name）：用于类型名称（类、类成员、成员函数、变量等）前，表示作用域为全局命名空间
+- 类作用域符（class::name）：用于表示指定类型的作用域范围是具体某个类的
+- 命名空间作用域符（namespace::name）:用于表示指定类型的作用域范围是具体某个命名空间的
+
+具体代码见：[maohao.cpp](maohao.cpp)
+
diff --git a/english/basic_content/maohao/README.md~ b/english/basic_content/maohao/README.md~
new file mode 100644
index 0000000..228d627
--- /dev/null
+++ b/english/basic_content/maohao/README.md~
@@ -0,0 +1,14 @@
+# :: 范围解析运算符那些事
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+- 全局作用域符（::name）：用于类型名称（类、类成员、成员函数、变量等）前，表示作用域为全局命名空间
+- 类作用域符（class::name）：用于表示指定类型的作用域范围是具体某个类的
+- 命名空间作用域符（namespace::name）:用于表示指定类型的作用域范围是具体某个命名空间的
+
+具体代码见：[::.cpp](::.cpp)
+
diff --git a/english/basic_content/maohao/maohao.cpp b/english/basic_content/maohao/maohao.cpp
new file mode 100644
index 0000000..3460e76
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/pointer_refer/README.md b/english/basic_content/pointer_refer/README.md
new file mode 100644
index 0000000..ba4b0dd
--- /dev/null
+++ b/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/#>
diff --git a/english/basic_content/pointer_refer/copy_construct b/english/basic_content/pointer_refer/copy_construct
new file mode 100755
index 0000000000000000000000000000000000000000..fa57fa35baa5c641a48b72ad46bc334f7f32c8af
GIT binary patch
literal 9592
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
T`9=G)Q2#?p;U?RLvG@NUylS!)

literal 0
HcmV?d00001

diff --git a/english/basic_content/pointer_refer/copy_construct.cpp b/english/basic_content/pointer_refer/copy_construct.cpp
new file mode 100644
index 0000000..1fa28ba
--- /dev/null
+++ b/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()); //应该只调用一次拷贝构造函数
+}
diff --git a/english/basic_content/pointer_refer/effec b/english/basic_content/pointer_refer/effec
new file mode 100755
index 0000000000000000000000000000000000000000..a7bf86a27a0754eb4badaaf586b0dc4f4fb8abb3
GIT binary patch
literal 20576
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
QxPO%df}gbJhr;~-58i<ER{#J2

literal 0
HcmV?d00001

diff --git a/english/basic_content/pointer_refer/effec.cpp b/english/basic_content/pointer_refer/effec.cpp
new file mode 100644
index 0000000..677353a
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/sizeof/README.md b/english/basic_content/sizeof/README.md
new file mode 100644
index 0000000..7cfdbc0
--- /dev/null
+++ b/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;
+}
+```
+
diff --git a/english/basic_content/sizeof/blackclass.cpp b/english/basic_content/sizeof/blackclass.cpp
new file mode 100644
index 0000000..6c25a43
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/sizeof/genA.cpp b/english/basic_content/sizeof/genA.cpp
new file mode 100644
index 0000000..cfbc2a4
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/sizeof/geninhe.cpp b/english/basic_content/sizeof/geninhe.cpp
new file mode 100644
index 0000000..a0acaad
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/sizeof/moreinhe.cpp b/english/basic_content/sizeof/moreinhe.cpp
new file mode 100644
index 0000000..6cbd5ef
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/sizeof/morevir.cpp b/english/basic_content/sizeof/morevir.cpp
new file mode 100644
index 0000000..66292d2
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/sizeof/static.cpp b/english/basic_content/sizeof/static.cpp
new file mode 100644
index 0000000..35fe4d3
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/sizeof/virinhe.cpp b/english/basic_content/sizeof/virinhe.cpp
new file mode 100644
index 0000000..ed0a8ac
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/sizeof/virmoreinhe.cpp b/english/basic_content/sizeof/virmoreinhe.cpp
new file mode 100644
index 0000000..f6d69d7
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/static/README.md b/english/basic_content/static/README.md
new file mode 100644
index 0000000..669eda9
--- /dev/null
+++ b/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!
+```
+
diff --git a/english/basic_content/static/demo b/english/basic_content/static/demo
new file mode 100755
index 0000000000000000000000000000000000000000..fdd7a26994d71699bb7e0d3ce8f176a51e58c4c2
GIT binary patch
literal 9104
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
M0AiOT(^>vM0n>|1lK=n!

literal 0
HcmV?d00001

diff --git a/english/basic_content/static/nostatic_class.cpp b/english/basic_content/static/nostatic_class.cpp
new file mode 100644
index 0000000..b4e56d2
--- /dev/null
+++ b/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"; 
+} 
+
diff --git a/english/basic_content/static/static_class.cpp b/english/basic_content/static/static_class.cpp
new file mode 100644
index 0000000..007e400
--- /dev/null
+++ b/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"; 
+} 
+
diff --git a/english/basic_content/static/static_demo.cpp b/english/basic_content/static/static_demo.cpp
new file mode 100644
index 0000000..1910088
--- /dev/null
+++ b/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; 
+} 
diff --git a/english/basic_content/static/static_error_variable.cpp b/english/basic_content/static/static_error_variable.cpp
new file mode 100644
index 0000000..47b1319
--- /dev/null
+++ b/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; 
+} 
diff --git a/english/basic_content/static/static_funciton.cpp b/english/basic_content/static/static_funciton.cpp
new file mode 100644
index 0000000..3a221e9
--- /dev/null
+++ b/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(); 
+} 
+
diff --git a/english/basic_content/static/static_variable.cpp b/english/basic_content/static/static_variable.cpp
new file mode 100644
index 0000000..b14780e
--- /dev/null
+++ b/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; 
+} 
diff --git a/english/basic_content/struct/README.md b/english/basic_content/struct/README.md
new file mode 100644
index 0000000..cea8af9
--- /dev/null
+++ b/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定义！ |
diff --git a/english/basic_content/struct/ext b/english/basic_content/struct/ext
new file mode 100755
index 0000000000000000000000000000000000000000..45104f89893cae70439235bf4bab081661c77884
GIT binary patch
literal 14536
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
Y{Umm|_IuUF(_vnC4KuPmRh8g>07N*bO#lD@

literal 0
HcmV?d00001

diff --git a/english/basic_content/struct/ext_struct_func.cpp b/english/basic_content/struct/ext_struct_func.cpp
new file mode 100644
index 0000000..7ab1eb2
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/struct/sf b/english/basic_content/struct/sf
new file mode 100755
index 0000000000000000000000000000000000000000..321061d21e6b74b8b0d849adf04d1b76e15d119f
GIT binary patch
literal 8992
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

literal 0
HcmV?d00001

diff --git a/english/basic_content/struct/stff b/english/basic_content/struct/stff
new file mode 100755
index 0000000000000000000000000000000000000000..de4372784a1ac8ea9c10b399a4f029d1afecc810
GIT binary patch
literal 9152
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

literal 0
HcmV?d00001

diff --git a/english/basic_content/struct/struct_func b/english/basic_content/struct/struct_func
new file mode 100755
index 0000000000000000000000000000000000000000..8541eba04debc9e9e2a892f8ac02d5ba9654f50c
GIT binary patch
literal 8768
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
V!FL%F&d+M?yTpOlu;g5B|6hN!fb#$V

literal 0
HcmV?d00001

diff --git a/english/basic_content/struct/struct_func.c b/english/basic_content/struct/struct_func.c
new file mode 100644
index 0000000..6bea643
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/struct/struct_func.cpp b/english/basic_content/struct/struct_func.cpp
new file mode 100644
index 0000000..09bef26
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/struct/struct_func_func.cpp b/english/basic_content/struct/struct_func_func.cpp
new file mode 100644
index 0000000..bce3749
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/struct/stu b/english/basic_content/struct/stu
new file mode 100755
index 0000000000000000000000000000000000000000..6dabbe152c2f4faf6d091db222b375f2d752acfe
GIT binary patch
literal 9112
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

literal 0
HcmV?d00001

diff --git a/english/basic_content/struct_class/README.md b/english/basic_content/struct_class/README.md
new file mode 100644
index 0000000..119e039
--- /dev/null
+++ b/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 的。
diff --git a/english/basic_content/this/README.md b/english/basic_content/this/README.md
new file mode 100644
index 0000000..f950237
--- /dev/null
+++ b/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就是结构的指针了。
diff --git a/english/basic_content/this/img/constthis.png b/english/basic_content/this/img/constthis.png
new file mode 100644
index 0000000000000000000000000000000000000000..f21efe9a6db58f0196fd0c15cbc71d3491809b5f
GIT binary patch
literal 28641
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
VP?2H<PjLsxeo~UG6gT?*e*i*$siOb@

literal 0
HcmV?d00001

diff --git a/english/basic_content/this/img/genthis.png b/english/basic_content/this/img/genthis.png
new file mode 100644
index 0000000000000000000000000000000000000000..c7acbded85e6b7e433029ddc365cf4e2386ef4b0
GIT binary patch
literal 34264
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

literal 0
HcmV?d00001

diff --git a/english/basic_content/this/img/thiscontrust.png b/english/basic_content/this/img/thiscontrust.png
new file mode 100644
index 0000000000000000000000000000000000000000..94aa0d64f9b8d8cc9f57c80d5700c4f158c986b1
GIT binary patch
literal 59227
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
D_5-oZ

literal 0
HcmV?d00001

diff --git a/english/basic_content/this/person b/english/basic_content/this/person
new file mode 100755
index 0000000000000000000000000000000000000000..99a540ec8aaedaff282930946a1ea2071cc4a95a
GIT binary patch
literal 33952
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

literal 0
HcmV?d00001

diff --git a/english/basic_content/this/person.cpp b/english/basic_content/this/person.cpp
new file mode 100644
index 0000000..613dab9
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/union/README.md b/english/basic_content/union/README.md
new file mode 100644
index 0000000..5421d42
--- /dev/null
+++ b/english/basic_content/union/README.md
@@ -0,0 +1,18 @@
+# UNION那些事
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+联合（union）是一种节省空间的特殊的类，一个 union 可以有多个数据成员，但是在任意时刻只有一个数据成员可以有值。当某个成员被赋值后其他成员变为未定义状态。联合有如下特点：
+
+- 默认访问控制符为 public
+- 可以含有构造函数、析构函数
+- 不能含有引用类型的成员
+- 不能继承自其他类，不能作为基类
+- 不能含有虚函数
+- 匿名 union 在定义所在作用域可直接访问 union 成员
+- 匿名 union 不能包含 protected 成员或 private 成员
+- 全局匿名联合必须是静态（static）的
diff --git a/english/basic_content/union/union b/english/basic_content/union/union
new file mode 100755
index 0000000000000000000000000000000000000000..36082ab8cb5cf2b9dcc4e8ba6df29c1c71452ffe
GIT binary patch
literal 9704
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
G`~L#-8L!m<

literal 0
HcmV?d00001

diff --git a/english/basic_content/union/union.cpp b/english/basic_content/union/union.cpp
new file mode 100644
index 0000000..7439282
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/using/README.md b/english/basic_content/using/README.md
new file mode 100644
index 0000000..1e50179
--- /dev/null
+++ b/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)
diff --git a/english/basic_content/using/derived_base b/english/basic_content/using/derived_base
new file mode 100755
index 0000000000000000000000000000000000000000..952568af0a1cd97323845d08059ce62a05e48c01
GIT binary patch
literal 15168
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
N47`nMdtBAve*hnzhz9@w

literal 0
HcmV?d00001

diff --git a/english/basic_content/using/derived_base.cpp b/english/basic_content/using/derived_base.cpp
new file mode 100644
index 0000000..bc57800
--- /dev/null
+++ b/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;
+}
diff --git a/english/basic_content/using/using_derived b/english/basic_content/using/using_derived
new file mode 100755
index 0000000000000000000000000000000000000000..641ac8b671a8dd7bbec9bff9af71cb9a96e8fb1a
GIT binary patch
literal 9320
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
QtJQx&B}SjIDed+D8&p@<3;+NC

literal 0
HcmV?d00001

diff --git a/english/basic_content/using/using_derived.cpp b/english/basic_content/using/using_derived.cpp
new file mode 100644
index 0000000..eb7b5ae
--- /dev/null
+++ b/english/basic_content/using/using_derived.cpp
@@ -0,0 +1,36 @@
+/**
+ * @file using_derived.cpp
+ * @brief 函数重装
+ * @author 光城
+ * @version v1
+ * @date 2019-08-07
+ */
+
+#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;
+}
diff --git a/english/basic_content/using/using_global b/english/basic_content/using/using_global
new file mode 100755
index 0000000000000000000000000000000000000000..b4fc8d694c3df8539abe144324532a38c0edaf76
GIT binary patch
literal 9296
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

literal 0
HcmV?d00001

diff --git a/english/basic_content/using/using_global.cpp b/english/basic_content/using/using_global.cpp
new file mode 100644
index 0000000..b8fba2f
--- /dev/null
+++ b/english/basic_content/using/using_global.cpp
@@ -0,0 +1,45 @@
+/**
+ * @file using_global.cpp
+ * @brief using各种使用
+ * @author 光城
+ * @version v1
+ * @date 2019-08-07
+ */
+
+#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;
+}
diff --git a/english/basic_content/using/using_typedef b/english/basic_content/using/using_typedef
new file mode 100755
index 0000000000000000000000000000000000000000..93f563542c0ca84328bf39182ab6f0ab11ae47a1
GIT binary patch
literal 22024
zcmeHPeRNdSwZEAp5ClU|&=kK0D-^2?Ga<xSd3EwJa3cZpGKuAhcr%$9$Y?T?W^N#%
zqR|M;G18`1eLSD-W4-z;ugg~La#8AYNf4Gn>$2Dn7ptW{o{#oTL|f_yO|3QWx6j$<
z&Yhc?l(wt?an_pI_w2pTKKtym&pzj#d(XWq(74i7P@t*g(mt<I&VP<ypya=%m8=z6
z##L)GG{5H7F43j|Q;eTqPzcH^1;<&mf+fsX2v~$)wM!zZU4C();KdTHDX26gNcCls
zpD!hR$St!9YS5Arl_Oo#ODIRMEeq~rJ&urKBDuvsp{ZPnM`Qup#D#*VSTO}v`>1X7
zYhk%9E<bXV_Y=_S#eW78FQukmnGw3a??RCU^ot7xpXB-!ROS8=<w(ynO=Zm3%=P87
zOF8SWAXl#~?TocoRW9v}Ea{BJd;6C3RaY&ks`Mlio(j=!l25#=*0ze8lpWp3k<N4R
zBU2N7$5RWQX?f$Doy)(NIQi!Or(T`2e*fb{n}Z+8knJkd78I0;>Ir`yehdEe!HmU$
zpEb_iHLI?_;r6{i<xTA<NoAag^mIFs$X}KR|1IEi$#Lb8|ARdE$MfKq<*C=5hyTVr
z{Lkd!|5_gW-FezImIpsSkDRS}@ZV)Qr)KzZl}RyNl0AnV_;rvoN4rSd?QIjxvgbAJ
zLFU&uJ_#cI!5@=mBz)CX<bze3VQlJ3#EqmG>M;#NGj7;yG)FhZl4i80t}~QOMw6P+
z(6YveM0*(BvZk&x5s$Wn+B>6?mYZ_(+Mrn-OC*i<P%>KC5RaMlzQAV906x)~3^c85
z4km&|fHdgqGrFTa$wWNV88iEh&0cUtI-7_&XjVq!k<Ny2(DeDj9ibk>><PupWJ5R*
zXa;T>q{qTWB5C$SLtPCmMvK=71gp>z6!l$W7-mOLVhePL7@^M2L|7`|P^?ZW7T?k(
zighL%&aAd@3+h^KG_4LxO~Z*^6IZf<F*5b0aM(zarG1*w8s8F&M_}G$Z&#FvVbuk&
ze)x7H+;O|HF%;{BMZ$d{BV<PVVy4y=?dnQwhNTTE!5!5Vip8~6b#=xvk5^mO*ic(%
zRCp?_s|wF@t!~}An%V}#=UFDv>(+s}5)L2(l?$*?L>9^yBGwSbg%~2CnmY;*Svuik
zYWz1X>YquG=7+#hDgb|q>0adL#$xAE<oXHYdgsSxko;fT`00}5QToYKx1*|JZH)QN
zD<8zv;L<)|{_&-4f{$VwhggwU{!V(HFEH}2oX5d*WLbnDxNUef7Z72w4X@fvc&`m_
zpD(Iyc&bAszYTAXd%6t|Ls+TFhKE6|w9bZ~Wnnd~&4!18t<+(|ms(g&>$c%(9#E;z
zhNrnjr2!j$wn75lXTz&LBeFjDPKiEL{L4jdP2WCZ7N=*z+WO$3l7q7F#PT15G_mlf
z_@8~5A6Jy`AmZ5Z38aOuP@cMI?1;#}NO|hwu@RAfj`B3UjXf>$-=jQr-PmrC|2E~R
z%f^O9{@*E2T{Si!@{dw}I_0}X{z1yqvSX}G<nO0Eb;($h$lpWxb13f@`K^?vt{L-+
zd=KTROUB$He;ehgE5^!1zMb;a1!J1Xzqrt?Z5&2kB;UIYsn>7SQ*Y^mCr&lBG>ndP
zW5uG69?%3Bt(xiA($i7!gN?H<tJk!B--6*=^(DIj^uh5`J@u>27wscaWbQc|_7h>^
zIGFDh@;4kLD{u6u{0l^H)$jg|5OCm=LI}`Pr}P8q>-B<{^w&Qz=ULKbDrvJX(>5HG
z^$+~R56~X1cTOt`rsGg-!%M|a09Ek5sA<231)e^5z1CZN@@pt(3Hu!tm^iXwY%9vp
zbx^<i9im3`p`wM0sR5}#+BY&9I6|F28u%&o`DoxMb@gcA81?XI;5c>cXy63(r@k|=
zTThLqe*wmQ5;1o>@I*MG?_5!)?`++z@9f2OU_ej3uBSdC_7h-NMW4s@XkbJNJv3d&
zJ}gCTCvPDBJ4ie!q3^WBk4W(k3!a_5$dW3mhI>Q}mVhtF3ZcSw@;H4+0*GD;vA~j_
z*{~srm9n`C$&-466xs>;y(8u-eJ5i_({BJZq@}j&kTfLzQ!fcmNI&-R#Ka5R$(K;_
zx5(H^4WQJ?$6lZ%g=C%(bZW}>KB<!cD7l^5U}>tb-<R0Dn*J~74o$CSO&f)#^sh91
z?~gW31KFCs0YO=swu1g&+}BWdG`*X`jOgdl^h3B#9o2`{q$B#WS;Du>^(R~O)Ir%#
zqv=D`onS%1^;8p4tp55Ih$m;;xa)1QtLa*nT!514=b^QJ_aSoR^&1Y7Un2sRrM7*X
z>Kz~4_HjY)XYSrMJ~4q2bLswPd~I6#DinBb7Y5-Al-*D3w)8c?4Zkc(zd*eEQHhp*
z3dY%Ra9GLIQ`^S%p};sPO?QJRkdv0S(SlH>8U@i(41-kbVLi2G#4+F?6Sis{(WQ62
zP7NFa=g^uXf`ot`)KjlfwO3Jp4<0HT27zoV$E~^G<b1Lg$pO<|5+E%!@ewTaDE{=J
z4db$XWF31;DuoNZh{9-`j;Vtn%8U9I5|Nv1$Y!xM+>ikcGLd84Hv+BG=-^Y_kn?2W
zQ)tL|#t(|q=RhAzm)vp!kkeFRll77?3Pd|(z3>Mmi!5DEO2N{{p)=rU`a7anIkLwo
z`wfxR^lJ~!es~0SELR?*dKL}e*;FK3Tt<LBDnnQP0L*Z%Yln4@{Yf}hwx6VW(GD_m
zt1{L3S+>pe&yXM2+&7wj<%@dih<;$)W#MFZ$-erOG|@OU^o#IZ_Gg&IYndh0dUSH1
z9feV)#o%c*P2BagNK>vx-N&w0oL-I5q&%PPVvRfMO(=l&rQizGKH)qfY6fg=R9r*U
zqr%X7s?2Uro9&fFh1IeoS}h*MXk|wo_0vj1I_;=mER1a9G+V#HZKpKzLhcHvy9R0t
zxBoRH*h*#D53Pd1$e%>3#;CFsbtXJ+s1=PD=t{Dl=sEZyH4sE71^R)vTzUa@DF{uH
zf)4xcClmw^NJe0LxsK8FC3Z<oC7E6=vuvGhXDaaLxu$1vW!r^@F&RVjoiGTsl4a63
zTa2oYQbe;m6P6Abut1Nde<^zaZD>6Lb_!p@DnBAT!WX35W`^SQ_=h<o6!p01qj^G=
z%y1DCM6p=eWCfCp>!rw}CpF_=P(K%756tp8)Mw=f-*MQ4!rEy1%?~mI3nFac!S0?{
zs)1?^3|nVO!#)R9;32}g%Q9*?2J1_Ki2}3(hU5_{3t$<l+A&#A7-2NsMAEMdoSOaM
z2<HFd^j_!<BVw6(9MJ>o73A}nZnD{EC(l0O_aVAax?VO<c?299kryEb6#-(lA|=GU
z1kz}lc0#3(!%1MFH}%wy(hCSVcxbVT#A>t)-y2QeEUKnCr>2GKaoa-~>Jjc%2d0M9
zAyqBiOWUelh-@R4_f+3#+DF8}L+<r8x7a!lwK=+q>;E~LY1t_&4&><?%z2rv$tr+;
zlu`Cd<sBk!3~n3O%*&wrxV5~+=#Whl-toitMAzBKXm!Dnm-&96<_k49)ubkBT5DPw
zcP@P60yl0hb}o4nFxZef-H`fO<CU}`D$x)8sWAQDzk{sp@0xDkFVy`=W9se3)aiOi
zn3#J^A3Ru~Uwg9mZJ4NJ{f3%bYBto|T4Nj>&fLGee~=6adEmgM*k{n(fEN{BM|-+t
z{XM9LR!IAx`eDHDzCSVHhh=u0o|vdcd_DxY4)EuIbZ2=Q@IJuvem^m>2k>#gBY<hZ
zaX>GooN}yN?*Oa@+y}T0@F-v(;M;(^08az%19V|ka1`)Tz;VEOz;fKbJOt<mJO$VW
z_zB<u;9{&ub_1>i906<rJP!B`K-#STDWDthHY^kUfWv@ofO`Q408aq!23&~+>0!Wr
zT9^WU8?Xd-GtU7o27Coj2YeT>1Mv5N_W@prRl**?8o<MVJ%DMzX8}uaQ}h<#V!+dY
zI$$kki*CSM0EYpe1>6VtBH&TLV}Rp;=fZo-Vdp-;KEO2K2p}c3$561fSu5x(E4XOZ
z^pfF%>1Bkck(xd=G4WYq<dmCV)2;xW`1kx4wnATPrDZEi%Ws%Hb4$s9cK!V8KD+FS
z%SnXw9As-#qo{FuA#H&c%6g?7lC=@Oa}<4E6mk2tn$ofzuDWxl>4SxZKXgGuDdz$3
z-G&Hu5eZg2Hwm(+=Sh;2hfZ}+`F7B0FSh6|TRnlnLRW*Q>@J8RzGv}!6@2x?_kfL$
z7=WWh?YbE4PJ>S;gwn@VXX(2F^fJtGjal?n7X22`SAf34PKPc%;2`;TfW8iNx1GLT
z>Ol0zm@f8{RQ-(^`tzXQfbz6yV(GUsLq7(3)fDuPLBAaIeD=N={dFnmi|q14Qa;&{
z%3lFG%}PbXHaogjOD5o{9TCWB1mAjGTY9==#}fTs(C-6X?5C-AHe}lIIOv-}7k;bg
z(G2|%=mVf%Vwb-zLq7rfom0p!LM-V7y}@4IRWAgPepi702<Xf0^zMxOdeEN){SiCe
z^;N5U1oX=h3v<~~v>)`vQ_vp=-2=MEE<Yygr+zpD`U=q7?R4^awgI83o_D~v8GN)b
zvHBsNX~(Q0+~0#vlc`1T%+Rj}{ZY`xex>S%8#44p(C?pu-U<3v&_8XLe`}`v1E6mM
zoi+un`U4sIlb~+`-EF7a#>=Zr&*vxafc{04&)2?Li0$`)UTc@XEmQy1pg#`!5<9&k
zLvIBAd!UP$s_b*4q+fwDouEGfdRDxkeyWu`B$oQ=A@IEdzWIbua#}NTo&{aZwRZZd
z2MPy^TpS&woMYho0CMt;tB*l{D^ES7$Hkbdj)9)fUMoO<7xbuI4_BK|l*-=%`pVx-
zOnlx>@0aZ$`W>K0K%Zx)H%WRuaF2mLuH@I2mVL!lTU!3*!a%8eXHjkG;s=WLQtysw
zdTI6G^fjgap3>@?Qg2P^;@VO-_`qLVS|a8{+SPPp&4DnGl_n+%F8osQhedc;Qv4M>
z5^)_X_-3(ofARI22GWe?;x6r;0@w%{@yjZFHgnbjXDx8n0%t97)&gfOaMl86EpXNX
zXDx8n0%tAo7g?YT@8M8tES2ySHV^FyTTCK3A-y9<N#W_8I7+i5(8}=qpOSia%fzc1
zls+Z?v9GtJO<ak+FI<U7ih$yt8*rTIbe~E|?F)YR$wY$kyIg((8g36oI$Y!z5Vx8l
z9dY>u6nhzT#W$Z~uMXLALDe*I@5|Q&utg&i-ejPp?pei~Tga>ZT5JQ0#IIv(d#3wE
zUg7&Vuk`jxcDx@ild2zE%A!5v)BJ*ftz?l`dSJU)<PS5Qi~rq$dXL>%(Ms;un;33n
zxS8P&hL13Og5h3<FEM<B;jbB<W;l)g?*fL47&`U9%b=fgFK%t`jhnsh<(^89cS%*R
z$ocN{Re8LX9-r?@NpM$qeO2Bn@3l@D&U_)fx!UD-qTv%R>-~H?k=`dYbMhBi{+Z2R
ztSP_D#!u6f|7PQ-Yq|Qp5Til)OE&)uP5E6m{v69cv+*;nahi>vrFpqOvhn9?-W>f=
zsFhmhLbCa1<3#|!9VM;{G1>=m;^$cB8tjD%@g{inr*g?TU!%tv&Qyp|s^W{CR*2EA
z;z~CD0&MWM*-_%UP`l7N*I_3XB6_IzbhGh@ZX7qV@$<FeocPRp?AiP(>SeGLUW>Hf
z;U%i<MDeyjo2);@Sr_`H+tFVXZwddj15bO~gg@oL(>`DU-nV}mFLhB;@jfW7C);x?
z@FYjgD^!Nk4*Uvo^viz$pQ~Np7yM<~z3eBd-X9D6MH;<iMoHoS2iH_@DbHhK&l9*g
zU?9Aj-&DM(a=GeV2ton;t<B+A%LIP1ogpTtoa?CqoK#Tfb0|ltS;(2}Cvtw7JIO!$
zg`CO${D6=%**~Ah1mwmn>h!mV!GAgI@X9>D&_m6$^xit*pD2^~MS_ZFsElu(EAir)
z0cfAWgh>1+Sk5};4>G><e97O=_=kZ%kFV|ENr8uda{nSL(g^fF5Ayx&hvHcRDD*}v
z)mzK@%w~RiwnX@cFYpUYl<}X#1WNc<xm`_+znSqXSby;>0km%b?`9r5_)Z@D0hZ&m
z+pmDn)!sia|DCMQOs?dTBB`gJ@k)m;Fut7asrqFT<M++>3ki)ZXRom5<am1z^SAT3
zQ0uL)0G~_GXPN)CIa0oOc7ZzH%fmmXSn3~P`-^84;9tS`i&@Tk*7IJ*JMFNC@jIAb
z_4~_=KgM|Rj1aQ^2z)O6=V1Xz{eCsur=IKeF#eYF`~vd`<G%zv$)WdE?P)jj-_QM`
z?DiV)ZaX7izs+)-q^0m@(q|FZyPO$r1%8fg9)x*C>SF#rhy8a0?`9r5cn<io9OHeI
z<-E+}MfJ;jjIVHvqXi{WPp6%OjCYQsB;$M7KFXi}nelhAe5Lb8z|V2bx6W;;HcZ2U
znC$Z&+h-9IE(Jc<Ij`k}ha7s-*q&-x&eLo+@hln)1B~xxf6%$m*BQTp{Z{$;LB>1d
z%t_!WF46G?N>T9-KV<$p9pkG6Hy+e3=eV24c&DC0#uqsHYl!i^j7L_apW`Bz|NoZx
z|Bd-S%lwz1gK~|FD#ky``aj708-OpfowH-K7Gr*AT%uD_x%7EBkNoEu-^Ttkhbu5K
z?@+z_d~K>q0e_!I{=8Ya>%9(mYVYSce$x7eQk?lu&G3u7`rFI=&hdT%cp6`Hti+y9
zvK)HZ#-3)KE9-rY>s`jgYZ&kJlX}MA#`Do!=I;hRmpupb;Qy87e8l};%W__3d=cAu
z1>?_$E0cZh<a!$!zm)Me@VHRx1ULGH{GZP4P@;E<D19i##pL^lE|%kr4_dg#Oq#tL
zH+pb}(72(l*=TGCw%{aY=D?+4b{Szha*3muMkHZu>P)nUI*o{#=t&x(-aajy=<4o_
zn$d{on&sD4=4LWB#^Ny})YB8{H==Q~r(fIH6Y7c@k>0MZeiX6g3~-uRti8!te3N1J
zcSj>pDB9gEjypE`uI-LR!_h6VWYh>J;y8lY8>aJ*L9?;iFk%UkgKVYGpks?Bj%gAm
zhC`lPk;AFe5ROAeqOu(2y|I{PtZKZmwx$t9dfSZ#L!5LpjFrtbYXU}KZ9Sb)6=qV`
zI2dgNbY{@&n=Ju1u3Q-m;5=weZDW86Wwk1jjS$CQHKYEY*4C_Ps1r@_RTxHB498%_
z`PGJ|SODi)eLiDN28Yw1zGajRp(})W0>KJ8c}koW#!b;M;pzBmLo66-hy?<56@li}
zL9gJs76)JBy*TRG=UWz!Zjr}RNfH=+-bhp&SH&UFKvPT}OZ8RaU}&Pd-=OoLMyR5p
zvE2(I#06S>bnX?E2Yn<P2X7-d!W)W*qe}7R89n9sSyFy^B(`xQ4)%i2QeU-z&gjPc
zesQ>z&yMmD)Nry_coQ{rsz%^cEgCBnlBUaOFH~=A_XUDxMO6>nAkk%n!r^E#X=L;a
zZ3@7RWQ)moO)WTS8(e1KbZ@Y7N;B72@Ihm<!fP14am($Z5g`xN`vT}YMUzOFvcd=i
zV8|A#05!o${`~3aDSBHNK=d}9W_B2JYU8Q1(l!I*FmpW7(}kh0Y=q7YnpK;HpD7m$
zba!*($>U@nu(2GR%W$yT&T1Jg`_wiaj-I6Y>c3pCN*V}MpYtFy3&#m&I=3v&ZKG#w
zo}S;);a84ERa6*jGGPYsEtc#Knc)r^2Z7D9V`*^Wq;)647R9tb=f~_#7*s|*1*=3q
zgvEp~pV5qgO-Ig2NWM{@i3KqPYS|^^6}DsEP8&>am~x0oE%sfD7Gn%;irU(p)!Yj2
z#zfDSP*22i9K#H4k{W0CHB~aHug|Pm(n?c(Dga^WuQ*wM=IShi9h_ma;YLh7kyza5
zO-2#(r|2WH;-;u+v~*`8F?lPsDE9{rj7Z1~$piV23@cUVh%_9ZMNCoQSvm^)63yT;
z9$`p{$x!&0bXE#MQ|N5XF~YBGb4$K1Q%+<Xy_4o18t<|_h@F4SG%|H;hx@mzsZ&!r
zO<A_l#e++zQAuA_aCm_cNhXXA%p3FximX6-hCxyeLNzxzV#xA#eCi_3q0#htjRxB?
zfF|9*HAYa(>wz<v%jKL;Rms3d(<iTt){0euHCu7O7N4lF_0X9%N%TL@{|JLQ<~<`s
zGltiQ@gyf4QbaJHh+uFV)T?F}BaGF@rbG{gJF)o5xrVrA5<AWMSO)QjD{@3OUlp%y
zXw@WFBXW6EZLN8lp(U+)a>PMvnsW47T?O>qjQN`;Z(d~??O0Lp;tsNefrXi<H-NW&
zbt9uER?s=>t@BM5fAiYEVjhf$Nf0&Izk=fMZ;B>4zFp$vqCk?*mRU<kGN)Qb{&n9|
z$yK!#e(X!!?8#0BoG3*~SbXw_Ui^OBcS@!Tby#?-xEu{g&!FB^0nOeIlOkGmSE$cO
z#<ohs<0~(Y#$<h%1vLJyN_JqGEY)(>uBO$FF&n3K_oSIR5NK~+y*6l2*E&~n^20TO
zU=2lleDsEvKO}<|_gRyN2<-;$qbA*%tj*x^-<jCr%A^({Qf<bApJacR8EOYKdnD{o
zSFt#1?bbZ;gc<eV>oQAd86k7HmGQLq#_*l1SVZ$st|OG}&^(d;IOIua_DITReCr3d
zds!I+w4P{Zhzjskcc-a&M5OfK(z7XnEWU|@f4Y|iQ$o0vC)&YxuN@HxQ8`G*w|Am_
z;b^ys<qmzUNC=ZRwo-<=zAcP`s5sOW3!_}ZqzZu{uk|2=Xdc{Rcj2~K-sAr*|Fmz4
ztphxRkx4yYt!9MtNf+_j)2ETamZep`#pOpX^Zhip$YuW2KB~gdzNfvs>GBJb$@O0$
za+yD8`FfD>3VcH8zsuzp%)1y-DRP<j5U|aemDVDMtt(6aBQ8I38lD3SpwW3gO4vRY
zc2ecb1y<8;0>q;OtGs$nd{`-}6k~p;{cZ)G-YHOQ>Ur{Est`%-4`MrAB*mxT?ZDDI
z3M#LjJCAeu0a;AwPkJi-8LiRtKvGqeSI?*Ws8f)<5?JqXsPd})_kvF4Yne~IXR(LN
ztM@WUe|qNWEdOQT$R@0=^}M?b`&N|H{+7(iy3{qn6n^&d>bba=%L}5dKp9^v_>i;w
zIex+6#Xc=1rLW9Q&VL;Qd;NYc@8|Lr*x$1!Rj<N*6BqXK>Uq3*q2y4_Q2ffRRQ^A?
zyy`#o+<t(|b2lh<(N|Um7tc7#tLLHWJBD<&)t;R7?{}0}?*UX(XCqzhP{3)=m%&3-
zDE-y@0ueWmNXq|YPV%a2g1^8ITbb5-LF&B%^<6}#y`A;{AIj3RN*WuK)cXhHOJv^3
z@65jsHqu{}x876moLTvCu#xYp^6I@F_1#MKeM&VxRQ;-5yHM6%zk2UseCgEnD>?KD
zQG0po{RlSvuoPqct8xmS<0!A5YY%gIrKb|0%BehkACPdW{c0b7H<vFb<!s4qyQa%|
zTtBm0R8?L*&r<{?PQf`KsJayo!7<)&zf>_Y(UHyaU3>YXtk3|D|I0w6xk$BN#ZMaF
Sx$0lXFGzfqoZFV1_5VK+_sQ1)

literal 0
HcmV?d00001

diff --git a/english/basic_content/using/using_typedef.cpp b/english/basic_content/using/using_typedef.cpp
new file mode 100644
index 0000000..5807122
--- /dev/null
+++ b/english/basic_content/using/using_typedef.cpp
@@ -0,0 +1,34 @@
+/**
+ * @file using_typedef.cpp
+ * @brief g++ -o using_typedef using_typedef.cpp -std=c++11
+ * 取代typedef，使用using来定义别名
+ * @author 光城
+ * @version v1
+ * @date 2019-08-07
+ */
+
+#include <iostream>
+#include <vector>
+using namespace std;
+
+typedef vector<int> V1;
+using V2 = vector<int>;
+
+
+int main() 
+{
+    int nums1[] = {1,2,3,4,5,6};
+    V1 vec1(nums1,nums1+sizeof(nums1)/sizeof(int));
+    int nums2[] = {5,7,6};
+    V2 vec2(nums2,nums2+sizeof(nums2)/sizeof(int));
+    
+    for(auto i:vec1)
+        cout<<i<<" ";
+    cout<<endl;
+
+    for(auto i:vec2)
+        cout<<i<<" ";
+    cout<<endl;
+
+    return 0;
+}
diff --git a/english/basic_content/virtual/README.md b/english/basic_content/virtual/README.md
new file mode 100644
index 0000000..44436bd
--- /dev/null
+++ b/english/basic_content/virtual/README.md
@@ -0,0 +1,102 @@
+# virtual那些事
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+## 1.虚函数与运行多态
+
+对应的代码：[emp.cpp](./set1/emp.cpp)
+
+**虚函数的调用取决于指向或者引用的对象的类型，而不是指针或者引用自身的类型。**
+
+## 2.vptr与vtable
+
+见[vptr_vtable那些事](../vptr_vtable)
+
+## 3.虚函数中默认参数
+
+对应的代码：[default_arg.cpp](./set2/default_arg.cpp)
+
+**默认参数是静态绑定的，虚函数是动态绑定的。 默认参数的使用需要看指针或者引用本身的类型，而不是对象的类型**。
+
+## 4.可以不可以
+
+（1） **静态函数可以声明为虚函数吗？**
+
+原因主要有两方面：
+
+**静态函数不可以声明为虚函数，同时也不能被const 和 volatile关键字修饰**
+
+static成员函数不属于任何类对象或类实例，所以即使给此函数加上virutal也是没有任何意义
+
+虚函数依靠vptr和vtable来处理。vptr是一个指针，在类的构造函数中创建生成，并且只能用this指针来访问它，静态成员函数没有this指针，所以无法访问vptr。
+
+代码学习：[static_error.cpp  ](./set3/static_error.cpp  )
+
+（2）**构造函数可以为虚函数吗？**
+
+构造函数不可以声明为虚函数。同时除了inline|explicit之外，构造函数不允许使用其它任何关键字。
+
+为什么构造函数不可以为虚函数？
+
+尽管虚函数表vtable是在编译阶段就已经建立的，但指向虚函数表的指针vptr是在运行阶段实例化对象时才产生的。 如果类含有虚函数，编译器会在构造函数中添加代码来创建vptr。 问题来了，如果构造函数是虚的，那么它需要vptr来访问vtable，可这个时候vptr还没产生。 因此，构造函数不可以为虚函数。
+
+我们之所以使用虚函数，是因为需要在信息不全的情况下进行多态运行。而构造函数是用来初始化实例的，实例的类型必须是明确的。 因此，构造函数没有必要被声明为虚函数。
+
+代码学习：
+
+- [copy_consrtuct.cpp](./set3/copy_construct.cpp) 
+
+- [vir_con.cpp](./set3/vir_con.cpp) 
+
+（3）**析构函数可以为虚函数吗？**
+
+**析构函数可以声明为虚函数。如果我们需要删除一个指向派生类的基类指针时，应该把析构函数声明为虚函数。 事实上，只要一个类有可能会被其它类所继承， 就应该声明虚析构函数(哪怕该析构函数不执行任何操作)。**
+
+代码学习：
+
+- [full_virde.cpp](./set3/full_virde.cpp)
+
+- [vir_de.cpp ](./set3/vir_de.cpp)      
+
+（4）**虚函数可以为私有函数吗？**
+
+- 基类指针指向继承类对象，则调用继承类对象的函数；
+- int main()必须声明为Base类的友元，否则编译失败。 编译器报错： ptr无法访问私有函数。 当然，把基类声明为public， 继承类为private，该问题就不存在了。
+
+代码学习：
+
+- [virtual_function.cpp](./set3/virtual_function.cpp)
+- [virtual_function1.cpp](./set3/virtual_function1.cpp)
+
+（5）**虚函数可以被内联吗？**
+
+**通常类成员函数都会被编译器考虑是否进行内联。 但通过基类指针或者引用调用的虚函数必定不能被内联。 当然，实体对象调用虚函数或者静态调用时可以被内联，虚析构函数的静态调用也一定会被内联展开。**
+
+- 虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能内联。
+- 内联是在编译器建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。
+- `inline virtual` 唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如 `Base::who()`），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。
+
+代码学习：
+
+- [virtual_inline.cpp](./set3/virtual_inline.cpp)
+
+- [inline_virtual.cpp](./set3/inline_virtual.cpp)
+
+## 5.RTTI与dynamic_cast
+
+RTTI（Run-Time Type Identification)，通过运行时类型信息程序能够使用[基类](https://baike.baidu.com/item/%E5%9F%BA%E7%B1%BB/9589663)的[指针](https://baike.baidu.com/item/%E6%8C%87%E9%92%88/2878304)或引用来检查这些指针或引用所指的对象的实际[派生类](https://baike.baidu.com/item/%E6%B4%BE%E7%94%9F%E7%B1%BB)型。
+
+在面向对象程序设计中，有时我们需要在运行时查询一个对象是否能作为某种多态类型使用。与Java的instanceof，以及C#的as、is运算符类似，C++提供了dynamic_cast函数用于动态转型。相比C风格的强制类型转换和C++ reinterpret_cast，dynamic_cast提供了类型安全检查，是一种基于能力查询(Capability Query)的转换，所以在多态类型间进行转换更提倡采用dynamic_cast。
+
+代码学习：
+
+- [rtti.cpp](./set4/rtti.cpp)
+- [warn_rtti.cpp](./set4/warn_rtti.cpp)
+
+## 6.纯虚函数和抽象类
+
+见[纯虚函数和抽象类那些事](../abstract)
diff --git a/english/basic_content/virtual/set1/emp b/english/basic_content/virtual/set1/emp
new file mode 100755
index 0000000000000000000000000000000000000000..2f081b05858dbb9f3a26e82a91f7f8d8adcf68c6
GIT binary patch
literal 14464
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

literal 0
HcmV?d00001

diff --git a/english/basic_content/virtual/set1/emp.cpp b/english/basic_content/virtual/set1/emp.cpp
new file mode 100644
index 0000000..7d81040
--- /dev/null
+++ b/english/basic_content/virtual/set1/emp.cpp
@@ -0,0 +1,52 @@
+#include<iostream>
+using namespace std;
+
+
+class Employee 
+{ 
+    public: 
+        virtual void raiseSalary() 
+        {
+            cout<<0<<endl; 
+        }
+
+        virtual void promote() 
+        { /* common promote code */ } 
+}; 
+
+class Manager: public Employee { 
+    virtual void raiseSalary() 
+    {   
+        cout<<100<<endl;    
+    } 
+
+    virtual void promote() 
+    { /* Manager specific promote */ } 
+}; 
+class Engineer: public Employee { 
+    virtual void raiseSalary() 
+    {
+        cout<<200<<endl;    
+    }
+
+    virtual void promote() 
+    { /* Manager specific promote */ } 
+}; 
+
+// Similarly, there may be other types of employees 
+// We need a very simple function to increment salary of all employees 
+// Note that emp[] is an array of pointers and actual pointed objects can 
+// be any type of employees. This function should ideally be in a class  
+// like Organization, we have made it global to keep things simple 
+void globalRaiseSalary(Employee *emp[], int n) 
+{ 
+    for (int i = 0; i < n; i++) 
+        emp[i]->raiseSalary(); // Polymorphic Call: Calls raiseSalary()  
+    // according to the actual object, not  
+    // according to the type of pointer                                  
+} 
+int main(){
+    Employee *emp[]={new Manager(),new Engineer};
+    globalRaiseSalary(emp,2); 
+    return 0;
+}
diff --git a/english/basic_content/virtual/set2/default_arg.cpp b/english/basic_content/virtual/set2/default_arg.cpp
new file mode 100644
index 0000000..4797818
--- /dev/null
+++ b/english/basic_content/virtual/set2/default_arg.cpp
@@ -0,0 +1,39 @@
+/**
+ * @file first_example.cpp
+ * @brief 虚函数中默认参数
+ * 规则：虚函数是动态绑定的，默认参数是静态绑定的。默认参数的使用需要看指针或者应用本身的类型，而不是对象的类型！
+ * @author 光城
+ * @version v1
+ * @date 2019-07-24
+ */
+
+#include <iostream> 
+using namespace std; 
+
+class Base 
+{ 
+    public: 
+        virtual void fun ( int x = 10 ) 
+        { 
+            cout << "Base::fun(), x = " << x << endl; 
+        } 
+}; 
+
+class Derived : public Base 
+{ 
+    public: 
+        virtual void fun ( int x=20 ) 
+        { 
+            cout << "Derived::fun(), x = " << x << endl; 
+        } 
+}; 
+
+
+int main() 
+{ 
+    Derived d1; 
+    Base *bp = &d1; 
+    bp->fun();  // 10
+    return 0; 
+} 
+
diff --git a/english/basic_content/virtual/set3/copy_consrtuct.cpp b/english/basic_content/virtual/set3/copy_consrtuct.cpp
new file mode 100644
index 0000000..e65ca89
--- /dev/null
+++ b/english/basic_content/virtual/set3/copy_consrtuct.cpp
@@ -0,0 +1,41 @@
+#include <iostream> 
+using namespace std; 
+
+class Base 
+{ 
+    public: 
+
+}; 
+
+class Derived : public Base 
+{ 
+    public: 
+        Derived() 
+        { 
+            cout << "Derived created" << endl; 
+        } 
+
+        Derived(const Derived &rhs) 
+        { 
+            cout << "Derived created by deep copy" << endl; 
+        } 
+
+        ~Derived() 
+        { 
+            cout << "Derived destroyed" << endl; 
+        } 
+}; 
+
+int main() 
+{ 
+    Derived s1; 
+
+    Derived s2 = s1; // Compiler invokes "copy constructor" 
+    // Type of s1 and s2 are concrete to compiler 
+
+    // How can we create Derived1 or Derived2 object 
+    // from pointer (reference) to Base class pointing Derived object? 
+
+    return 0; 
+} 
+
diff --git a/english/basic_content/virtual/set3/full_virde.cpp b/english/basic_content/virtual/set3/full_virde.cpp
new file mode 100644
index 0000000..d4ef7a8
--- /dev/null
+++ b/english/basic_content/virtual/set3/full_virde.cpp
@@ -0,0 +1,39 @@
+/**
+ * @file full_virde.cpp
+ * @brief 将基类的析构函数声明为虚函数
+ * 输出结果：
+ *      Constructing base
+ *      Constructing derived
+ *      Destructing derived
+ *      Destructing base
+ * @author 光城
+ * @version v1
+ * @date 2019-07-24
+ */
+#include<iostream> 
+
+using namespace std; 
+
+class base { 
+    public: 
+        base()      
+        { cout<<"Constructing base \n"; } 
+        virtual ~base() 
+        { cout<<"Destructing base \n"; }      
+}; 
+
+class derived: public base { 
+    public: 
+        derived()      
+        { cout<<"Constructing derived \n"; } 
+        ~derived() 
+        { cout<<"Destructing derived \n"; } 
+}; 
+
+int main(void) 
+{ 
+    derived *d = new derived();   
+    base *b = d; 
+    delete b; 
+    return 0; 
+} 
diff --git a/english/basic_content/virtual/set3/inline_virtual.cpp b/english/basic_content/virtual/set3/inline_virtual.cpp
new file mode 100644
index 0000000..1ec1a06
--- /dev/null
+++ b/english/basic_content/virtual/set3/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;
+} 
diff --git a/english/basic_content/virtual/set3/static_error.cpp b/english/basic_content/virtual/set3/static_error.cpp
new file mode 100644
index 0000000..5a79667
--- /dev/null
+++ b/english/basic_content/virtual/set3/static_error.cpp
@@ -0,0 +1,13 @@
+/**
+ * @file static_error.cpp
+ * @brief 静态函数不可以声明为虚函数，同时也不能被const和volatile关键字修饰!
+ * 原因如下：
+ * static成员函数不属于任何类对象或类实例，所以即使给此函数加上virutal也是没有任何意义
+ * 虚函数依靠vptr和vtable来处理。vptr是一个指针，在类的构造函数中创建生成，并且只能用this指针来访问它，静态成员函数没有this指针，所以无法访问vptr。
+ * @author 光城
+ * @version v1
+ * @date 2019-07-24
+ */
+
+virtual static void fun()  { }
+static void fun() const { }
diff --git a/english/basic_content/virtual/set3/vir_con.cpp b/english/basic_content/virtual/set3/vir_con.cpp
new file mode 100644
index 0000000..78c4a07
--- /dev/null
+++ b/english/basic_content/virtual/set3/vir_con.cpp
@@ -0,0 +1,206 @@
+/**
+ * @file vir_con.cpp
+ * @brief 构造函数不可以声明为虚函数。同时除了inline之外，构造函数不允许使用其它任何关键字。
+ *
+ * 为什么构造函数不可以为虚函数？
+ *
+ * 尽管虚函数表vtable是在编译阶段就已经建立的，但指向虚函数表的指针vptr是在运行阶段实例化对象时才产生的。 如果类含有虚函数，编译器会在构造函数中添加代码来创建vptr。 问题来了，如果构造函数是虚的，那么它需要vptr来访问vtable，可这个时候vptr还没产生。 因此，构造函数不可以为虚函数。
+ * 我们之所以使用虚函数，是因为需要在信息不全的情况下进行多态运行。而构造函数是用来初始化实例的，实例的类型必须是明确的。
+ * 因此，构造函数没有必要被声明为虚函数。
+ * 尽管构造函数不可以为虚函数，但是有些场景下我们确实需要 “Virtual Copy Constructor”。 “虚复制构造函数”的说法并不严谨，其只是一个实现了对象复制的功能的类内函数。 举一个应用场景，比如剪切板功能。 复制内容作为基类，但派生类可能包含文字、图片、视频等等。 我们只有在程序运行的时候才知道我们需要复制的具体是什么类型的数据。
+ *
+ * @author 光城
+ * @version v1
+ * @date 2019-07-24
+ */
+
+#include <iostream> 
+using namespace std; 
+
+//// LIBRARY SRART 
+class Base 
+{ 
+    public: 
+        Base() { } 
+
+        virtual // Ensures to invoke actual object destructor 
+            ~Base() { } 
+
+        virtual void ChangeAttributes() = 0; 
+
+        // The "Virtual Constructor" 
+        static Base *Create(int id); 
+
+        // The "Virtual Copy Constructor" 
+        virtual Base *Clone() = 0; 
+}; 
+
+class Derived1 : public Base 
+{ 
+    public: 
+        Derived1() 
+        { 
+            cout << "Derived1 created" << endl; 
+        } 
+
+        Derived1(const Derived1& rhs) 
+        { 
+            cout << "Derived1 created by deep copy" << endl; 
+        } 
+
+        ~Derived1() 
+        { 
+            cout << "~Derived1 destroyed" << endl; 
+        } 
+
+        void ChangeAttributes() 
+        { 
+            cout << "Derived1 Attributes Changed" << endl; 
+        } 
+
+        Base *Clone() 
+        { 
+            return new Derived1(*this); 
+        } 
+}; 
+
+class Derived2 : public Base 
+{ 
+    public: 
+        Derived2() 
+        { 
+            cout << "Derived2 created" << endl; 
+        } 
+
+        Derived2(const Derived2& rhs) 
+        { 
+            cout << "Derived2 created by deep copy" << endl; 
+        } 
+
+        ~Derived2() 
+        { 
+            cout << "~Derived2 destroyed" << endl; 
+        } 
+
+        void ChangeAttributes() 
+        { 
+            cout << "Derived2 Attributes Changed" << endl; 
+        } 
+
+        Base *Clone() 
+        { 
+            return new Derived2(*this); 
+        } 
+}; 
+
+class Derived3 : public Base 
+{ 
+    public: 
+        Derived3() 
+        { 
+            cout << "Derived3 created" << endl; 
+        } 
+
+        Derived3(const Derived3& rhs) 
+        { 
+            cout << "Derived3 created by deep copy" << endl; 
+        } 
+
+        ~Derived3() 
+        { 
+            cout << "~Derived3 destroyed" << endl; 
+        } 
+
+        void ChangeAttributes() 
+        { 
+            cout << "Derived3 Attributes Changed" << endl; 
+        } 
+
+        Base *Clone() 
+        { 
+            return new Derived3(*this); 
+        } 
+}; 
+
+// We can also declare "Create" outside Base. 
+// But is more relevant to limit it's scope to Base 
+Base *Base::Create(int id) 
+{ 
+    // Just expand the if-else ladder, if new Derived class is created 
+    // User need not be recompiled to create newly added class objects 
+
+    if( id == 1 ) 
+    { 
+        return new Derived1; 
+    } 
+    else if( id == 2 ) 
+    { 
+        return new Derived2; 
+    } 
+    else
+    { 
+        return new Derived3; 
+    } 
+} 
+//// LIBRARY END 
+
+//// UTILITY SRART 
+class User 
+{ 
+    public: 
+        User() : pBase(0) 
+    { 
+        // Creates any object of Base heirarchey at runtime 
+
+        int input; 
+
+        cout << "Enter ID (1, 2 or 3): "; 
+        cin >> input; 
+
+        while( (input != 1) && (input != 2) && (input != 3) ) 
+        { 
+            cout << "Enter ID (1, 2 or 3 only): "; 
+            cin >> input; 
+        } 
+
+        // Create objects via the "Virtual Constructor" 
+        pBase = Base::Create(input); 
+    } 
+
+        ~User() 
+        { 
+            if( pBase ) 
+            { 
+                delete pBase; 
+                pBase = 0; 
+            } 
+        } 
+
+        void Action() 
+        { 
+            // Duplicate current object 
+            Base *pNewBase = pBase->Clone(); 
+
+            // Change its attributes 
+            pNewBase->ChangeAttributes(); 
+
+            // Dispose the created object 
+            delete pNewBase; 
+        } 
+
+    private: 
+        Base *pBase; 
+}; 
+
+//// UTILITY END 
+
+//// Consumer of User (UTILITY) class 
+int main() 
+{ 
+    User *user = new User(); 
+
+    user->Action(); 
+
+    delete user; 
+} 
+
diff --git a/english/basic_content/virtual/set3/vir_de.cpp b/english/basic_content/virtual/set3/vir_de.cpp
new file mode 100644
index 0000000..79c7c65
--- /dev/null
+++ b/english/basic_content/virtual/set3/vir_de.cpp
@@ -0,0 +1,41 @@
+/**
+ * @file vir_de.cpp
+ * @brief 派生类的析构函数没有被调用!
+ * 输出结果：
+ *      Constructing base
+ *      Constructing derived
+ *      Destructing base
+ * @author 光城
+ * @version v1
+ * @date 2019-07-24
+ */
+
+// CPP program without virtual destructor  
+// causing undefined behavior 
+#include<iostream> 
+
+using namespace std; 
+
+class base { 
+    public: 
+        base()      
+        { cout<<"Constructing base \n"; } 
+        ~base() 
+        { cout<<"Destructing base \n"; }      
+}; 
+
+class derived: public base { 
+    public: 
+        derived()      
+        { cout<<"Constructing derived \n"; } 
+        ~derived() 
+        { cout<<"Destructing derived \n"; } 
+}; 
+
+int main(void) 
+{ 
+    derived *d = new derived();   
+    base *b = d; 
+    delete b; 
+    return 0; 
+} 
diff --git a/english/basic_content/virtual/set3/virtual_function.cpp b/english/basic_content/virtual/set3/virtual_function.cpp
new file mode 100644
index 0000000..1b6d039
--- /dev/null
+++ b/english/basic_content/virtual/set3/virtual_function.cpp
@@ -0,0 +1,33 @@
+/**
+ * @file virtual_function.cpp
+ * @brief 虚函数可以被私有化，但有一些细节需要注意。
+ * 基类指针指向继承类对象，则调用继承类对象的函数；
+ * int main()必须声明为Base类的友元，否则编译失败。 编译器报错： ptr无法访问私有函数。 
+ * 当然，把基类声明为public， 继承类为private，该问题就不存在了。----> 见另外一个例子！
+ * @author 光城
+ * @version v1
+ * @date 2019-07-24
+ */
+
+#include<iostream> 
+using namespace std; 
+
+class Derived; 
+
+class Base { 
+    private: 
+        virtual void fun() { cout << "Base Fun"; } 
+        friend int main(); 
+}; 
+
+class Derived: public Base { 
+    public: 
+        void fun() { cout << "Derived Fun"; } 
+}; 
+
+int main() 
+{ 
+    Base *ptr = new Derived; 
+    ptr->fun(); 
+    return 0; 
+}
diff --git a/english/basic_content/virtual/set3/virtual_function1.cpp b/english/basic_content/virtual/set3/virtual_function1.cpp
new file mode 100644
index 0000000..27648e1
--- /dev/null
+++ b/english/basic_content/virtual/set3/virtual_function1.cpp
@@ -0,0 +1,22 @@
+#include<iostream> 
+using namespace std; 
+
+class Derived; 
+
+class Base { 
+    public: 
+        virtual void fun() { cout << "Base Fun"; } 
+     //   friend int main(); 
+}; 
+
+class Derived: public Base { 
+    private: 
+        void fun() { cout << "Derived Fun"; } 
+}; 
+
+int main() 
+{ 
+    Base *ptr = new Derived; 
+    ptr->fun(); 
+    return 0; 
+}
diff --git a/english/basic_content/virtual/set3/virtual_inline.cpp b/english/basic_content/virtual/set3/virtual_inline.cpp
new file mode 100644
index 0000000..ac89964
--- /dev/null
+++ b/english/basic_content/virtual/set3/virtual_inline.cpp
@@ -0,0 +1,44 @@
+/**
+ * @file virtual_inline.cpp
+ * @brief 通常类成员函数都会被编译器考虑是否进行内联。 
+ * 但通过基类指针或者引用调用的虚函数必定不能被内联。
+ * 当然，实体对象调用虚函数或者静态调用时可以被内联，虚析构函数的静态调用也一定会被内联展开。
+ * @author 光城
+ * @version v1
+ * @date 2019-07-24
+ */
+
+#include <iostream> 
+using namespace std; 
+class Base 
+{ 
+    public: 
+        virtual void who() 
+        { 
+            cout << "I am Base\n"; 
+        } 
+}; 
+class Derived: public Base 
+{ 
+    public: 
+        void who() 
+        {  
+            cout << "I am Derived\n"; 
+        } 
+}; 
+
+int main() 
+{ 
+    // note here virtual function who() is called through 
+    // object of the class (it will be resolved at compile 
+    // time) so it can be inlined. 
+    Base b; 
+    b.who(); 
+
+    // Here virtual function is called through pointer, 
+    // so it cannot be inlined 
+    Base *ptr = new Derived(); 
+    ptr->who(); 
+
+    return 0; 
+} 
diff --git a/english/basic_content/virtual/set4/rtti b/english/basic_content/virtual/set4/rtti
new file mode 100755
index 0000000000000000000000000000000000000000..c7cb891947c159533e2642f0e4a220670dcf1fcf
GIT binary patch
literal 14944
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
Nc;HR8SZ~FO{{~3pA-Mnm

literal 0
HcmV?d00001

diff --git a/english/basic_content/virtual/set4/rtti.cpp b/english/basic_content/virtual/set4/rtti.cpp
new file mode 100644
index 0000000..649687e
--- /dev/null
+++ b/english/basic_content/virtual/set4/rtti.cpp
@@ -0,0 +1,34 @@
+/**
+ * @file rtti.cpp
+ * @brief 在面向对象程序设计中，有时我们需要在运行时查询一个对象是否能作为某种多态类型使用。与Java的instanceof，以及C#的as、is运算符类似，C++提供了dynamic_cast函数用于动态转型。相比C风格的强制类型转换和C++ reinterpret_cast，dynamic_cast提供了类型安全检查，是一种基于能力查询(Capability Query)的转换，所以在多态类型间进行转换更提倡采用dynamic_cast
+ * @author 光城
+ * @version v1
+ * @date 2019-07-24
+ */
+
+// CPP program to illustrate  
+// // Run Time Type Identification  
+#include<iostream>
+#include<typeinfo>
+using namespace std; 
+class B { virtual void fun() {} }; 
+class D: public B { }; 
+
+int main() 
+{ 
+    B *b = new D;  // 向上转型
+    B &obj = *b;
+    D *d = dynamic_cast<D*>(b);   // 向下转型
+    if(d != NULL) 
+        cout << "works"<<endl; 
+    else
+        cout << "cannot cast B* to D*"; 
+ 
+    try {
+        D& dobj = dynamic_cast<D&>(obj);  
+        cout << "works"<<endl; 
+    } catch (bad_cast bc) { // ERROR
+        cout<<bc.what()<<endl;
+    }
+    return 0;
+}
diff --git a/english/basic_content/virtual/set4/warn_rtti.cpp b/english/basic_content/virtual/set4/warn_rtti.cpp
new file mode 100644
index 0000000..bdc193e
--- /dev/null
+++ b/english/basic_content/virtual/set4/warn_rtti.cpp
@@ -0,0 +1,35 @@
+// 在使用时需要注意：被转换对象obj的类型T1必须是多态类型，即T1必须公有继承自其它类，或者T1拥有虚函数（继承或自定义）。若T1为非多态类型，使用dynamic_cast会报编译错误。
+
+// A为非多态类型 
+
+class A{
+
+};
+
+//B为多态类型
+
+class B{ 
+
+    public: virtual ~B(){}
+
+};
+
+//D为多态类型
+
+class D: public A{
+
+};
+
+//E为非多态类型
+
+class E : private A{
+
+};
+
+//F为多态类型
+
+class F : private B{
+
+}
+
+
diff --git a/english/basic_content/volatile/README.md b/english/basic_content/volatile/README.md
new file mode 100644
index 0000000..1090d42
--- /dev/null
+++ b/english/basic_content/volatile/README.md
@@ -0,0 +1,122 @@
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+## 1.volatile
+
+被 `volatile` 修饰的变量，在对其进行读写操作时，会引发一些**可观测的副作用**。而这些可观测的副作用，是由**程序之外的因素决定的**。
+
+## 2.volatile应用
+（1）并行设备的硬件寄存器（如状态寄存器）。
+假设要对一个设备进行初始化，此设备的某一个寄存器为0xff800000。
+
+```c++
+int  *output = (unsigned  int *)0xff800000; //定义一个IO端口；  
+int   init(void)  
+{  
+    int i;  
+    for(i=0;i< 10;i++)
+    {  
+    *output = i;  
+    }  
+}
+```
+经过编译器优化后，编译器认为前面循环半天都是废话，对最后的结果毫无影响，因为最终只是将output这个指针赋值为 9，所以编译器最后给你编译编译的代码结果相当于：
+```c++
+int  init(void)  
+{  
+    *output = 9;  
+}
+```
+如果你对此外部设备进行初始化的过程是必须是像上面代码一样顺序的对其赋值，显然优化过程并不能达到目的。反之如果你不是对此端口反复写操作，而是反复读操作，其结果是一样的，编译器在优化后，也许你的代码对此地址的读操作只做了一次。然而从代码角度看是没有任何问题的。这时候就该使用volatile通知编译器这个变量是一个不稳定的，在遇到此变量时候不要优化。
+
+（2）一个中断服务子程序中访问到的变量；
+
+```c++
+static int i=0;
+
+int main()
+{
+    while(1)
+    {
+    if(i) dosomething();
+    }
+}
+
+/* Interrupt service routine */
+void IRS()
+{
+	i=1;
+}
+```
+上面示例程序的本意是产生中断时，由中断服务子程序IRS响应中断，变更程序变量i，使在main函数中调用dosomething函数，但是，由于编译器判断在main函数里面没有修改过i，因此可能只执行一次对从i到某寄存器的读操作，然后每次if判断都只使用这个寄存器里面的“i副本”，导致dosomething永远不会被调用。如果将变量i加上volatile修饰，则编译器保证对变量i的读写操作都不会被优化，从而保证了变量i被外部程序更改后能及时在原程序中得到感知。
+
+（3）多线程应用中被多个任务共享的变量。
+当多个线程共享某一个变量时，该变量的值会被某一个线程更改，应该用 volatile 声明。作用是防止编译器优化把变量从内存装入CPU寄存器中，当一个线程更改变量后，未及时同步到其它线程中导致程序出错。volatile的意思是让编译器每次操作该变量时一定要从内存中真正取出，而不是使用已经存在寄存器中的值。示例如下：
+```c++
+volatile  bool bStop=false;  //bStop 为共享全局变量  
+//第一个线程
+void threadFunc1()
+{
+    ...
+    while(!bStop){...}
+}
+//第二个线程终止上面的线程循环
+void threadFunc2()
+{
+    ...
+    bStop = true;
+}
+```
+要想通过第二个线程终止第一个线程循环，如果bStop不使用volatile定义，那么这个循环将是一个死循环，因为bStop已经读取到了寄存器中，寄存器中bStop的值永远不会变成FALSE，加上volatile，程序在执行时，每次均从内存中读出bStop的值，就不会死循环了。
+
+是否了解volatile的应用场景是区分C/C++程序员和嵌入式开发程序员的有效办法，搞嵌入式的家伙们经常同硬件、中断、RTOS等等打交道，这些都要求用到volatile变量，不懂得volatile将会带来程序设计的灾难。
+
+## 3.volatile常见问题
+下面的问题可以看一下面试者是不是直正了解volatile。
+（1）一个参数既可以是const还可以是volatile吗？为什么？
+可以。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
+
+（2）一个指针可以是volatile吗？为什么？
+可以。尽管这并不常见。一个例子是当一个中断服务子程序修该一个指向一个buffer的指针时。
+
+（3）下面的函数有什么错误？
+```c++
+int square(volatile int *ptr) 
+{ 
+return *ptr * *ptr; 
+} 
+```
+这段代码有点变态，其目的是用来返回指针ptr指向值的平方，但是，由于ptr指向一个volatile型参数，编译器将产生类似下面的代码：
+```c++
+int square(volatile int *ptr) 
+{ 
+int a,b; 
+a = *ptr; 
+b = *ptr; 
+return a * b; 
+} 
+```
+由于*ptr的值可能被意想不到地改变，因此a和b可能是不同的。结果，这段代码可能返回的不是你所期望的平方值！正确的代码如下：
+```c++
+long square(volatile int *ptr) 
+{ 
+int a=*ptr; 
+return a * a; 
+} 
+```
+## 4.volatile使用
+
+- volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素（操作系统、硬件、其它线程等）更改。所以使用 volatile 告诉编译器不应对这样的对象进行优化。
+
+- volatile 关键字声明的变量，每次访问时都必须从内存中取出值（没有被 volatile 修饰的变量，可能由于编译器的优化，从 CPU 寄存器中取值）
+- const 可以是 volatile （如只读的状态寄存器）
+- 指针可以是 volatile
+
+代码学习：
+
+- [noopt_vola.cpp](./noopt_vola.cpp)
+- [volatile.cpp](./volatile.cpp)
+
diff --git a/english/basic_content/volatile/noopt_vola.cpp b/english/basic_content/volatile/noopt_vola.cpp
new file mode 100644
index 0000000..58ceae6
--- /dev/null
+++ b/english/basic_content/volatile/noopt_vola.cpp
@@ -0,0 +1,15 @@
+/* Compile code without optimization option */
+#include <stdio.h> 
+int main(void) 
+{ 
+    const int local = 10; 
+    int *ptr = (int*) &local; 
+
+    printf("Initial value of local : %d \n", local); 
+
+    *ptr = 100; 
+
+    printf("Modified value of local: %d \n", local); 
+
+    return 0; 
+} 
diff --git a/english/basic_content/volatile/nv b/english/basic_content/volatile/nv
new file mode 100755
index 0000000000000000000000000000000000000000..b5eb220e6d350b522a09a8eefe268b6282a9a874
GIT binary patch
literal 8672
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

literal 0
HcmV?d00001

diff --git a/english/basic_content/volatile/volatile.cpp b/english/basic_content/volatile/volatile.cpp
new file mode 100644
index 0000000..fcf6115
--- /dev/null
+++ b/english/basic_content/volatile/volatile.cpp
@@ -0,0 +1,16 @@
+/* Compile code with optimization option */
+#include <stdio.h> 
+
+int main(void) 
+{ 
+    const volatile int local = 10; 
+    int *ptr = (int*) &local; 
+
+    printf("Initial value of local : %d \n", local); 
+
+    *ptr = 100; 
+
+    printf("Modified value of local: %d \n", local); 
+
+    return 0; 
+} 
diff --git a/english/basic_content/vptr_vtable/README.md b/english/basic_content/vptr_vtable/README.md
new file mode 100644
index 0000000..1b82cc6
--- /dev/null
+++ b/english/basic_content/vptr_vtable/README.md
@@ -0,0 +1,219 @@
+# 深入浅出C++虚函数的vptr与vtable
+
+## 关于作者：
+
+个人公众号：
+
+![](../img/wechat.jpg)
+
+
+
+## 1.基础理论
+
+为了实现虚函数，C ++使用一种称为虚拟表的特殊形式的后期绑定。该虚拟表是用于解决在动态/后期绑定方式的函数调用函数的查找表。虚拟表有时会使用其他名称，例如“vtable”，“虚函数表”，“虚方法表”或“调度表”。
+
+虚拟表实际上非常简单，虽然用文字描述有点复杂。首先，**每个使用虚函数的类（或者从使用虚函数的类派生）都有自己的虚拟表**。该表只是编译器在编译时设置的静态数组。虚拟表包含可由类的对象调用的每个虚函数的一个条目。此表中的每个条目只是一个函数指针，指向该类可访问的派生函数。
+
+其次，编译器还会添加一个隐藏指向基类的指针，我们称之为vptr。vptr在创建类实例时自动设置，以便指向该类的虚拟表。与this指针不同，this指针实际上是编译器用来解析自引用的函数参数，vptr是一个真正的指针。
+
+因此，它使每个类对象的分配大一个指针的大小。这也意味着vptr由派生类继承，这很重要。
+
+## 2.实现与内部结构
+
+下面我们来看自动与手动操纵vptr来获取地址与调用虚函数！
+
+开始看代码之前，为了方便大家理解，这里给出调用图：
+
+![base](./img/base.jpg)
+
+代码全部遵循标准的注释风格，相信大家看了就会明白，不明白的话，可以留言！
+
+```c++
+/**
+ * @file vptr1.cpp
+ * @brief C++虚函数vptr和vtable
+ * 编译：g++ -g -o vptr vptr1.cpp -std=c++11
+ * @author 光城
+ * @version v1
+ * @date 2019-07-20
+ */
+
+#include <iostream>
+#include <stdio.h>
+using namespace std;
+
+/**
+ * @brief 函数指针
+ */
+typedef void (*Fun)();
+
+/**
+ * @brief 基类
+ */
+class Base
+{
+    public:
+        Base(){};
+        virtual void fun1()
+        {
+            cout << "Base::fun1()" << endl;
+        }
+        virtual void fun2()
+        {
+            cout << "Base::fun2()" << endl;
+        }
+        virtual void fun3(){}
+        ~Base(){};
+};
+
+/**
+ * @brief 派生类
+ */
+class Derived: public Base
+{
+    public:
+        Derived(){};
+        void fun1()
+        {
+            cout << "Derived::fun1()" << endl;
+        }
+        void fun2()
+        {
+            cout << "DerivedClass::fun2()" << endl;
+        }
+        ~Derived(){};
+};
+/**
+ * @brief 获取vptr地址与func地址,vptr指向的是一块内存，这块内存存放的是虚函数地址，这块内存就是我们所说的虚表
+ *
+ * @param obj
+ * @param offset
+ *
+ * @return 
+ */
+Fun getAddr(void* obj,unsigned int offset)
+{
+    cout<<"======================="<<endl;
+    void* vptr_addr = (void *)*(unsigned long *)obj;  //64位操作系统，占8字节，通过*(unsigned long *)obj取出前8字节，即vptr指针
+    printf("vptr_addr:%p\n",vptr_addr);
+    
+    /**
+     * @brief 通过vptr指针访问virtual table，因为虚表中每个元素(虚函数指针)在64位编译器下是8个字节，因此通过*(unsigned long *)vptr_addr取出前8字节，
+     * 后面加上偏移量就是每个函数的地址！
+     */
+    void* func_addr = (void *)*((unsigned long *)vptr_addr+offset);
+    printf("func_addr:%p\n",func_addr);
+    return (Fun)func_addr;
+}
+int main(void)
+{
+    Base ptr;
+    Derived d;
+    Base *pt = new Derived(); // 基类指针指向派生类实例
+    Base &pp = ptr; // 基类引用指向基类实例
+    Base &p = d; // 基类引用指向派生类实例
+    cout<<"基类对象直接调用"<<endl;
+    ptr.fun1();
+    cout<<"基类对象调用基类实例"<<endl;
+    pp.fun1(); 
+    cout<<"基类指针指向基类实例并调用虚函数"<<endl;
+    pt->fun1();
+    cout<<"基类引用指向基类实例并调用虚函数"<<endl;
+    p.fun1();
+    
+    // 手动查找vptr 和 vtable
+    Fun f1 = getAddr(pt, 0);
+    (*f1)();
+    Fun f2 = getAddr(pt, 1);
+    (*f2)();
+    delete pt;
+    return 0;
+}
+```
+
+运行结果：
+
+```
+基类对象直接调用
+Base::fun1()
+基类引用指向派生类实例
+Base::fun1()
+基类指针指向派生类实例并调用虚函数
+Derived::fun1()
+基类引用指向基类实例并调用虚函数
+Derived::fun1()
+=======================
+vptr_addr:0x401130
+func_addr:0x400ea8
+Derived::fun1()
+=======================
+vptr_addr:0x401130
+func_addr:0x400ed4
+DerivedClass::fun2()
+```
+
+我们发现C++的动态多态性是通过虚函数来实现的。简单的说，通过virtual函数，指向子类的基类指针可以调用子类的函数。例如，上述通过基类指针指向派生类实例，并调用虚函数，将上述代码简化为：
+
+```c++
+Base *pt = new Derived(); // 基类指针指向派生类实例
+cout<<"基类指针指向派生类实例并调用虚函数"<<endl;
+pt->fun1();
+```
+
+其过程为：首先程序识别出fun1()是个虚函数，其次程序使用pt->vptr来获取Derived的虚拟表。第三，它查找Derived虚拟表中调用哪个版本的fun1()。这里就可以发现调用的是Derived::fun1()。因此pt->fun1()被解析为Derived::fun1()!
+
+除此之外，上述代码大家会看到，也包含了手动获取vptr地址，并调用vtable中的函数，那么我们一起来验证一下上述的地址与真正在自动调用vtable中的虚函数，比如上述`pt->fun1()`的时候，是否一致！
+
+这里采用gdb调试，在编译的时候记得加上`-g`。
+
+通过`gdb vptr`进入gdb调试页面，然后输入`b Derived::fun1`对fun1打断点，然后通过输入r运行程序到断点处，此时我们需要查看调用栈中的内存地址，通过`disassemable fun1`可以查看当前有关fun1中的相关汇编代码，我们看到了`0x0000000000400ea8`，然后再对比上述的结果会发现与手动调用的fun1一致，fun2类似，以此证明代码正确!
+
+gdb调试信息如下：
+
+```c++
+(gdb) b Derived::fun1
+Breakpoint 1 at 0x400eb4: file vptr1.cpp, line 23.
+(gdb) r
+Starting program: /home/light/Program/CPlusPlusThings/virtual/pure_virtualAndabstract_class/vptr 
+基类对象直接调用
+Base::fun1()
+基类引用指向派生类实例
+Base::fun1()
+基类指针指向派生类实例并调用虚函数
+
+Breakpoint 1, Derived::fun1 (this=0x614c20) at vptr1.cpp:23
+23	            cout << "Derived::fun1()" << endl;
+(gdb) disassemble fun1
+Dump of assembler code for function Derived::fun1():
+   0x0000000000400ea8 <+0>:	push   %rbp
+   0x0000000000400ea9 <+1>:	mov    %rsp,%rbp
+   0x0000000000400eac <+4>:	sub    $0x10,%rsp
+   0x0000000000400eb0 <+8>:	mov    %rdi,-0x8(%rbp)
+=> 0x0000000000400eb4 <+12>:	mov    $0x401013,%esi
+   0x0000000000400eb9 <+17>:	mov    $0x602100,%edi
+   0x0000000000400ebe <+22>:	callq  0x4009d0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
+   0x0000000000400ec3 <+27>:	mov    $0x400a00,%esi
+   0x0000000000400ec8 <+32>:	mov    %rax,%rdi
+   0x0000000000400ecb <+35>:	callq  0x4009f0 <_ZNSolsEPFRSoS_E@plt>
+   0x0000000000400ed0 <+40>:	nop
+   0x0000000000400ed1 <+41>:	leaveq 
+   0x0000000000400ed2 <+42>:	retq   
+End of assembler dump.
+(gdb) disassemble fun2
+Dump of assembler code for function Derived::fun2():
+   0x0000000000400ed4 <+0>:	push   %rbp
+   0x0000000000400ed5 <+1>:	mov    %rsp,%rbp
+   0x0000000000400ed8 <+4>:	sub    $0x10,%rsp
+   0x0000000000400edc <+8>:	mov    %rdi,-0x8(%rbp)
+   0x0000000000400ee0 <+12>:	mov    $0x401023,%esi
+   0x0000000000400ee5 <+17>:	mov    $0x602100,%edi
+   0x0000000000400eea <+22>:	callq  0x4009d0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
+   0x0000000000400eef <+27>:	mov    $0x400a00,%esi
+   0x0000000000400ef4 <+32>:	mov    %rax,%rdi
+   0x0000000000400ef7 <+35>:	callq  0x4009f0 <_ZNSolsEPFRSoS_E@plt>
+   0x0000000000400efc <+40>:	nop
+   0x0000000000400efd <+41>:	leaveq 
+   0x0000000000400efe <+42>:	retq   
+End of assembler dump.
+```
+
diff --git a/english/basic_content/vptr_vtable/img/base.jpg b/english/basic_content/vptr_vtable/img/base.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..669f2a053c32663bb767dd3cbe2cfdc21463f661
GIT binary patch
literal 136050
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
QwxG;`WBX%%x^Vq}0ox`K<p2Nx

literal 0
HcmV?d00001

diff --git a/english/basic_content/vptr_vtable/vptr1.cpp b/english/basic_content/vptr_vtable/vptr1.cpp
new file mode 100644
index 0000000..31f9209
--- /dev/null
+++ b/english/basic_content/vptr_vtable/vptr1.cpp
@@ -0,0 +1,105 @@
+/**
+ * @file vptr1.cpp
+ * @brief C++虚函数vptr和vtable
+ * 编译：g++ -g -o vptr vptr1.cpp -std=c++11
+ * @author 光城
+ * @version v1
+ * @date 2019-07-20
+ */
+
+#include <iostream>
+#include <stdio.h>
+using namespace std;
+
+/**
+ * @brief 函数指针
+ */
+typedef void (*Fun)();
+
+
+/**
+ * @brief 基类
+ */
+class Base
+{
+    public:
+        Base(){};
+        virtual void fun1()
+        {
+            cout << "Base::fun1()" << endl;
+        }
+        virtual void fun2()
+        {
+            cout << "Base::fun2()" << endl;
+        }
+        virtual void fun3(){}
+        ~Base(){};
+};
+
+
+/**
+ * @brief 派生类
+ */
+class Derived: public Base
+{
+    public:
+        Derived(){};
+        void fun1()
+        {
+            cout << "Derived::fun1()" << endl;
+        }
+        void fun2()
+        {
+            cout << "DerivedClass::fun2()" << endl;
+        }
+        ~Derived(){};
+};
+
+/**
+ * @brief 获取vptr地址与func地址,vptr指向的是一块内存，这块内存存放的是虚函数地址，这块内存就是我们所说的虚表
+ *
+ * @param obj
+ * @param offset
+ *
+ * @return 
+ */
+Fun getAddr(void* obj,unsigned int offset)
+{
+    cout<<"======================="<<endl;
+    void* vptr_addr = (void *)*(unsigned long *)obj;  //64位操作系统，占8字节，通过*(unsigned long *)obj取出前8字节，即vptr指针
+    printf("vptr_addr:%p\n",vptr_addr);
+
+    /**
+     * @brief 通过vptr指针访问virtual table，因为虚表中每个元素(虚函数指针)在64位编译器下是8个字节，因此通过*(unsigned long *)vptr_addr取出前8字节，
+     * 后面加上偏移量就是每个函数的地址！
+     */
+    void* func_addr = (void *)*((unsigned long *)vptr_addr+offset);
+    printf("func_addr:%p\n",func_addr);
+    return (Fun)func_addr;
+}
+int main(void)
+{
+    Base ptr;
+    Derived d;
+    Base *pt = new Derived(); // 基类指针指向派生类实例
+    Base &pp = ptr; // 基类引用指向基类实例
+    Base &p = d; // 基类引用指向派生类实例
+    cout<<"基类对象直接调用"<<endl;
+    ptr.fun1();
+    cout<<"基类引用指向基类实例"<<endl;
+    pp.fun1(); 
+    cout<<"基类指针指向派生类实例并调用虚函数"<<endl;
+    pt->fun1();
+    cout<<"基类引用指向基类实例并调用虚函数"<<endl;
+    p.fun1();
+
+
+    // 手动查找vptr 和 vtable
+    Fun f1 = getAddr(pt, 0);
+    (*f1)();
+    Fun f2 = getAddr(pt, 1);
+    (*f2)();
+
+    delete pt;
+    return 0;
+}

From be7e775e8c5527181e58845e99654bd38fd51ccf Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Sun, 19 Jul 2020 11:41:39 +0800
Subject: [PATCH 24/62] Update README.md

---
 english/basic_content/abstract/README.md | 66 ++++++++++++------------
 1 file changed, 34 insertions(+), 32 deletions(-)

diff --git a/english/basic_content/abstract/README.md b/english/basic_content/abstract/README.md
index e11aa35..9040d49 100644
--- a/english/basic_content/abstract/README.md
+++ b/english/basic_content/abstract/README.md
@@ -1,40 +1,42 @@
-# 纯虚函数和抽象类
+# Pure virtual functions and abstract classes
+
+## About Author：
 
-## 关于作者：
 
-个人公众号：
 
 ![](../img/wechat.jpg)
 
-## 1.纯虚函数与抽象类
+## 1.Pure virtual function and abstract class
 
-C++中的纯虚函数(或抽象函数)是我们没有实现的虚函数！我们只需声明它! 通过声明中赋值0来声明纯虚函数！
+
+Pure virtual functions (or abstract functions) in C + + are virtual functions that we have not implemented!We just need to state it! 
+example:
 ```cpp
-// 抽象类
+// abstract class
 Class A {
 public: 
-    virtual void show() = 0; // 纯虚函数
+    virtual void show() = 0; // pure virtual function
     /* Other members */
 }; 
 ```
 
- * 纯虚函数：没有函数体的虚函数
- * 抽象类：包含纯虚函数的类
+ * Pure virtual function: virtual function without function body
+ * Abstract classes: classes containing pure virtual functions
 
-抽象类只能作为基类来派生新类使用，不能创建抽象类的对象,抽象类的指针和引用->由抽象类派生出来的类的对象！
+Abstract classes can only be used as base classes to derive new classes. Objects, pointers and references of abstract classes cannot be created->An object of a class derived from an abstract class!
 
-> 代码样例：[test.cpp](./test.cpp)、[pure_virtual.cpp](./pure_virtual.cpp)
+> Code example：[test.cpp](./test.cpp)、[pure_virtual.cpp](./pure_virtual.cpp)
 
-## 2.实现抽象类
+## 2.Implement abstract classes
 
-抽象类中：在成员函数内可以调用纯虚函数，在构造函数/析构函数内部不能使用纯虚函数。
+Abstract class：Pure virtual functions can be called within member functions.Pure virtual functions cannot be used inside constructors / destructors.
 
-如果一个类从抽象类派生而来，它必须实现了基类中的所有纯虚函数，才能成为非抽象类。
+If a class derives from an abstract class, it must implement all pure virtual functions in the base class to become a non abstract class.
 ```cpp
-// A为抽象类
+// A is abstract class
 class A {
 public:
-    virtual void f() = 0;  // 纯虚函数
+    virtual void f() = 0;  // pure virtual function
     void g(){ this->f(); }
     A(){}  // 构造函数
 };
@@ -45,13 +47,13 @@ public:
 };
 ```
 
-> 代码样例：[abstract.cpp](./abstract.cpp)
+> Code Example：[abstract.cpp](./abstract.cpp)
 
-## 3.重要点
+## 3.Key point
 
-- [纯虚函数使一个类变成抽象类](./interesting_facts1.cpp)
+- [Pure virtual functions make a class abstract](./interesting_facts1.cpp)
 ```cpp
-// 抽象类至少包含一个纯虚函数
+// Abstract class contains at least one pure virtual function
 class Base{
 public: 
     virtual void show() = 0; // 纯虚函数
@@ -62,7 +64,7 @@ private:
 }; 
 ```
 
-- [抽象类类型的指针和引用](./interesting_facts2.cpp)
+- [Pointers and references to abstract class types](./interesting_facts2.cpp)
 ```cpp
 class Derived : public Base { 
 public: 
@@ -81,7 +83,7 @@ int main(void)
 }
 ```
 
-- [如果我们不在派生类中覆盖纯虚函数，那么派生类也会变成抽象类](./interesting_facts3.cpp)
+- [If we do not override pure virtual functions in the derived class, the derived class will also become an abstract class](./interesting_facts3.cpp)
 ```cpp
 // Derived为抽象类
 class Derived: public Base 
@@ -91,27 +93,27 @@ public:
 }; 
 ```
 
-- [抽象类可以有构造函数](./interesting_facts4.cpp)
+- [Abstract classes can have constructors](./interesting_facts4.cpp)
 ```cpp
-// 抽象类
+// abstract class
 class Base { 
     protected: 
         int x; 
     public: 
         virtual void fun() = 0; 
-        Base(int i) { x = i; }  // 构造函数
+        Base(int i) { x = i; }  // constructor function
 }; 
 // 派生类
 class Derived: public Base 
 { 
     int y; 
 public: 
-    Derived(int i, int j) : Base(i) { y = j; } // 构造函数
+    Derived(int i, int j) : Base(i) { y = j; } // constructor function
     void fun() { cout << "x = " << x << ", y = " << y; }
 }; 
 ```
 
-- [构造函数不能是虚函数，而析构函数可以是虚析构函数](./interesting_facts5.cpp)
+- [A constructor cannot be a virtual function, and a destructor can be a virtual destructor](./interesting_facts5.cpp)
 ```cpp
 // 抽象类
 class Base  {
@@ -130,11 +132,11 @@ public:
     void func(){cout << "In Derived.func()." << endl;}
 };
 ```
->当基类指针指向派生类对象并删除对象时，我们可能希望调用适当的析构函数。
-> 如果析构函数不是虚拟的，则只能调用基类析构函数。
+>When the base class pointer points to a derived class object and removes the object, we may want to call the appropriate destructor.
+>The destructor can only be called if it is not a virtual destructor.
 
-## 4.完整实例
+## 4.Complete example
 
-抽象类由派生类继承实现！
+Abstract classes are inherited and implemented by derived classes!
 
-> 代码样例：[derived_full.cpp](./derived_full.cpp)
\ No newline at end of file
+> Code Example：[derived_full.cpp](./derived_full.cpp)

From 4779d5de5547375c477dd15aa9ac74e388d7537c Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Sun, 19 Jul 2020 15:10:07 +0800
Subject: [PATCH 25/62] Update README.md

---
 english/basic_content/assert/README.md | 30 ++++++++++++--------------
 1 file changed, 14 insertions(+), 16 deletions(-)

diff --git a/english/basic_content/assert/README.md b/english/basic_content/assert/README.md
index 8699eff..1647518 100644
--- a/english/basic_content/assert/README.md
+++ b/english/basic_content/assert/README.md
@@ -1,26 +1,25 @@
-# assert那些事
+# Things about assert
 
-## 关于作者：
+## About Author：
 
-个人公众号：
 
 ![](../img/wechat.jpg)
 
 
 
-## 1.第一个断言案例
+## 1.First assertion case
 
-断言，**是宏，而非函数**。
+assert，**is macro，rather than function**。
 
-assert 宏的原型定义在 <assert.h>（C）、<cassert>（C++）中。其作用是如果它的条件返回错误，则终止程序执行。
+assert The prototype of a macro is defined in  <assert.h>（C）、<cassert>（C++）.If its condition returns an error，Program execution is terminated.
 
-可以通过定义 `NDEBUG` 来关闭 assert，**但是需要在源代码的开头，include <assert.h> 之前。**
+You can close assert by defining 'ndebug', **But it needs to be at the beginning of the source code，before include <assert.h>.**
 
 ```c
 void assert(int expression);
 ```
 
-> 代码样例：[assert.c](./assert.c)
+> Code Example：[assert.c](./assert.c)
 ```c
 #include <stdio.h> 
 #include <assert.h> 
@@ -41,21 +40,20 @@ int main()
     return 0; 
 } 
 ```
-输出：
+Output：
 ```c
 assert: assert.c:13: main: Assertion 'x==7' failed.
 ```
-可以看到输出会把源码文件，行号错误位置，提示出来！
 
-## 2.断言与正常错误处理
+## 2.Assertion and normal error handling
 
-+ 断言主要用于检查逻辑上不可能的情况。
++ Assertions are mainly used to check for logically impossible situations.
 
->例如，它们可用于检查代码在开始运行之前所期望的状态，或者在运行完成后检查状态。与正常的错误处理不同，断言通常在运行时被禁用。
+>For example, they can be used to check the state that code expects before it starts to run, or after the run is complete. Unlike normal error handling, assertions are usually disabled at run time.
 
-+ 忽略断言，在代码开头加上：
++ Ignore the assertion and add at the beginning of the code：
 ```c++
-#define NDEBUG          // 加上这行，则 assert 不可用
+#define NDEBUG          // Adding this line，then you do not need the assert
 ```
 
-> 样例代码：[ignore_assert.c](./ignore_assert.c)
+> Code Example：[ignore_assert.c](./ignore_assert.c)

From 2ff9a4a640dd06e78c3ad667cf6a03f98aedc27a Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Sun, 19 Jul 2020 15:58:34 +0800
Subject: [PATCH 26/62] Update README.md

---
 english/basic_content/decltype/README.md | 66 ++++++++++++------------
 1 file changed, 33 insertions(+), 33 deletions(-)

diff --git a/english/basic_content/decltype/README.md b/english/basic_content/decltype/README.md
index 4a8aa80..ff7c72a 100644
--- a/english/basic_content/decltype/README.md
+++ b/english/basic_content/decltype/README.md
@@ -1,29 +1,28 @@
-# decltype那些事
+# Things about decltype
 
-## 关于作者：
+## About Author：
 
-个人公众号：
 
 ![](../img/wechat.jpg)
 
-## 1.基本使用
-decltype的语法是:
+## 1.Basic
+The syntax of decltype is:
 
 ```
 decltype (expression)
 ```
 
-这里的括号是必不可少的,decltype的作用是“查询表达式的类型”，因此，上面语句的效果是，返回 expression 表达式的类型。注意，decltype 仅仅“查询”表达式的类型，并不会对表达式进行“求值”。
+Brackets are essential here.The function of decltype is "the type of query expression".Therefore, the effect of the above statement is to return the type of the expression expression.Note that decltype only "queries" the type of the expression and does not "evaluate" the expression.
 
 
-### 1.1 推导出表达式类型
+### 1.1 Deduce expression type
 
 ```
 int i = 4;
-decltype(i) a; //推导结果为int。a的类型为int。
+decltype(i) a; //The result is int. The type of a is int
 ```
 
-### 1.2 与using/typedef合用，用于定义类型。
+### 1.2 Used with using / typedef to define types.
 
 ```c++
 using size_t = decltype(sizeof(0));//sizeof(a)的返回值为size_t类型
@@ -37,11 +36,12 @@ for (vectype i = vec.begin; i != vec.end(); i++)
 }
 ```
 
-这样和auto一样，也提高了代码的可读性。
+like auto, improves the readability of the code.
 
-### 1.3 重用匿名类型
 
-在C++中，我们有时候会遇上一些匿名类型，如:
+### 1.3 Reuse anonymous types
+
+In C + +, we sometimes encounter some anonymous types, such as:
 
 ```c++
 struct 
@@ -51,15 +51,13 @@ struct
 }anon_s;
 ```
 
-而借助decltype，我们可以重新使用这个匿名的结构体：
-
+With decltype, we can reuse this anonymous structure:
 ```c++
-decltype(anon_s) as ;//定义了一个上面匿名的结构体
+decltype(anon_s) as ;//Defines an anonymous structure above
 ```
 
-### 1.4 泛型编程中结合auto，用于追踪函数的返回值类型
+### 1.4 In generic programming, auto is used to trace the return value type of function
 
-这也是decltype最大的用途了。
 
 ```c++
 template <typename T>
@@ -69,24 +67,26 @@ auto multiply(T x, T y)->decltype(x*y)
 }
 ```
 
-完整代码见：[decltype.cpp](decltype.cpp)
+Code：[decltype.cpp](decltype.cpp)
 
-## 2.判别规则
+## 2.Discriminant rules
 
-对于decltype(e)而言，其判别结果受以下条件的影响：
 
-如果e是一个没有带括号的标记符表达式或者类成员访问表达式，那么的decltype（e）就是e所命名的实体的类型。此外，如果e是一个被重载的函数，则会导致编译错误。
-否则 ，假设e的类型是T，如果e是一个将亡值，那么decltype（e）为T&&
-否则，假设e的类型是T，如果e是一个左值，那么decltype（e）为T&。
-否则，假设e的类型是T，则decltype（e）为T。
 
-标记符指的是除去关键字、字面量等编译器需要使用的标记之外的程序员自己定义的标记，而单个标记符对应的表达式即为标记符表达式。例如：
+For decltype (E), the results are affected by the following conditions:
+If e is a marker expression or class member access expression without parentheses, decltype (E) of is the type of entity named by E.In addition, if e is an overloaded function, it will result in compilation errors.
+Otherwise, assume that the type of E is t, and if e is a dying value, then decltype (E) is t&&
+Otherwise, assume that the type of E is t, and if e is a dying value, then decltype (E) is t&&
+Otherwise, assuming that the type of E is t, decltype (E) is t.
+
+Markers are defined by programmers except for keywords, literals and other tags that the compiler needs to use. The expression corresponding to a single marker is a marker expression. For example:
+
 ```c++
 int arr[4]
 ```
-则arr为一个标记符表达式，而arr[3]+0不是。
+Then arr is a marker expression，ranther than arr[3]+0
 
-举例如下：
+Example：
 
 ```c++
 int i = 4;
@@ -94,11 +94,11 @@ int arr[5] = { 0 };
 int *ptr = arr;
 struct S{ double d; }s ;
 void Overloaded(int);
-void Overloaded(char);//重载的函数
+void Overloaded(char);// reload function
 int && RvalRef();
 const bool Func(int);
 
-//规则一：推导为其类型
+//Rule 1: derivation is its type
 decltype (arr) var1; //int 标记符表达式
 
 decltype (ptr) var2;//int *  标记符表达式
@@ -111,11 +111,11 @@ decltype(s.d) var3;//doubel 成员访问表达式
 
 decltype (RvalRef()) var5 = 1;
 
-//规则三：左值，推导为类型的引用。
+//规则三：Lvalue, derived as a reference to the type
 
 decltype ((i))var6 = i;     //int&
 
-decltype (true ? i : i) var7 = i; //int&  条件表达式返回左值。
+decltype (true ? i : i) var7 = i; //int&  A conditional expression returns an lvalue
 
 decltype (++i) var8 = i; //int&  ++i返回i的左值。
 
@@ -126,7 +126,7 @@ decltype(*ptr)var10 = i;//int& *操作返回左值
 decltype("hello")var11 = "hello"; //const char(&)[9]  字符串字面常量为左值，且为const左值。
 
 
-//规则四：以上都不是，则推导为本类型
+//Rule 4: if none of the above is true, this type is derived
 
 decltype(1) var12;//const int
 
@@ -135,4 +135,4 @@ decltype(Func(1)) var13=true;//const bool
 decltype(i++) var14 = i;//int i++返回右值
 ```
 
-学习参考：https://www.cnblogs.com/QG-whz/p/4952980.html
+From：https://www.cnblogs.com/QG-whz/p/4952980.html

From 5fd8656977a16b9c101756a387ce2d2ee6936b52 Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Sun, 19 Jul 2020 16:02:03 +0800
Subject: [PATCH 27/62] Update README.md

---
 english/basic_content/explicit/README.md | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/english/basic_content/explicit/README.md b/english/basic_content/explicit/README.md
index 740b7b0..58c3b45 100644
--- a/english/basic_content/explicit/README.md
+++ b/english/basic_content/explicit/README.md
@@ -1,16 +1,15 @@
-# explicit(显式)关键字那些事
+# Things about explicit
 
-## 关于作者：
+## About Author：
 
-个人公众号：
 
 ![](../img/wechat.jpg)
 
-- explicit 修饰构造函数时，可以防止隐式转换和复制初始化
-- explicit 修饰转换函数时，可以防止隐式转换，但按语境转换除外
+- explicit When decorating a constructor, you can prevent implicit conversion and copy initialization
+- explicit When modifying a conversion function, you can prevent implicit conversion, except for context conversion
 
 
-代码参见:[.explicit.cpp](./explicit.cpp)
+Code :[.explicit.cpp](./explicit.cpp)
 
-参考链接：
+Reference Link：
 > https://stackoverflow.com/questions/4600295/what-is-the-meaning-of-operator-bool-const

From 5d654355a3db5486fb2e4083e7e67e2f8be823ce Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Sun, 19 Jul 2020 16:18:50 +0800
Subject: [PATCH 28/62] Update README.md

---
 english/basic_content/extern/README.md | 52 +++++++++++++-------------
 1 file changed, 27 insertions(+), 25 deletions(-)

diff --git a/english/basic_content/extern/README.md b/english/basic_content/extern/README.md
index 41c1ebe..8402ad6 100644
--- a/english/basic_content/extern/README.md
+++ b/english/basic_content/extern/README.md
@@ -1,24 +1,24 @@
 # extern "C"
 
-## 关于作者：
+## About Author：
 
-个人公众号：
 
 ![](../img/wechat.jpg)
 
-## 1.C++与C编译区别
+## 1. Compiler difference between C and C ++
 
-在C++中常在头文件见到extern "C"修饰函数，那有什么作用呢？ 是用于C++链接在C语言模块中定义的函数。
+In C + +, we often see extern "C" modifier function in the header file. What's the effect. Is a function defined in C language module for C + + link.
 
-C++虽然兼容C，但C++文件中函数编译后生成的符号与C语言生成的不同。因为C++支持函数重载，C++函数编译后生成的符号带有函数参数类型的信息，而C则没有。
+Although C + + is compatible with C, the symbols generated by function compilation in C + + files are different from those generated by C language.Because C + + supports function overloading, the symbols generated by C + + function compilation have the information of function parameter type, while C does not.
 
-例如`int add(int a, int b)`函数经过C++编译器生成.o文件后，`add`会变成形如`add_int_int`之类的, 而C的话则会是形如`_add`, 就是说：相同的函数，在C和C++中，编译后生成的符号不同。
 
-这就导致一个问题：如果C++中使用C语言实现的函数，在编译链接的时候，会出错，提示找不到对应的符号。此时`extern "C"`就起作用了：告诉链接器去寻找`_add`这类的C语言符号，而不是经过C++修饰的符号。
+Take `int add(int a, int b)` for example. The C + + compiler generates the. O file, `add` becomes `add_int_int` and so on, while C would be like this `_add`, that is：For the same function, in C and C + +, the symbols generated after compilation are different.
 
-## 2.C++调用C函数
+This leads to a problem: if the function implemented in C + + is implemented in C language, an error will occur when compiling the link, indicating that the corresponding symbol cannot be found. At this time`extern "C"` works：Tell the linker to find its `_ C `language symbols such as `add` are not modified by C ++.
 
-C++调用C函数的例子: 引用C的头文件时，需要加`extern "C"`
+## 2.C ++ calls C functions
+
+When referring to the header file of C, you need to add `extern "C"`
 
 ```c++
 //add.h
@@ -44,20 +44,20 @@ int main() {
 }
 ```
 
-编译：
+Compile：
 
 ```
 //Generate add.o file
 gcc -c add.c
 ```
 
-链接：
+Link：
 
 ```
 g++ add.cpp add.o -o main
 ```
 
-没有添加extern "C" 报错：
+Without extern "C"：
 
 ```c++
 > g++ add.cpp add.o -o main                                   
@@ -71,7 +71,7 @@ add.cpp:(.text+0xf)：对‘add(int, int)’未定义的引用
 collect2: error: ld returned 1 exit status
 ```
 
-添加extern "C"后：
+With extern "C"：
 
 `add.cpp`
 
@@ -86,20 +86,20 @@ int main() {
     return 0;
 }
 ```
+When compiling, you must pay attention to generating intermediate files add.o through GCC
 
-编译的时候一定要注意，先通过gcc生成中间文件add.o。
 
 ```
 gcc -c add.c 
 ```
 
-然后编译：
+Compile：
 
 ```
 g++ add.cpp add.o -o main
 ```
 
-上述案例源代码见：
+Code：
 
 - [add.h](extern_c++/add.h)
 
@@ -107,9 +107,10 @@ g++ add.cpp add.o -o main
 
 - [add.cpp](extern_c++/add.cpp)
 
-## 2.C中调用C++函数
+## 2.Calling C++ function in C
 
-`extern "C"`在C中是语法错误，需要放在C++头文件中。
+
+`extern "C"` It is a syntax error in C, which needs to be put in the C + + header file.
 
 ```c
 // add.h
@@ -135,19 +136,19 @@ int main() {
 }
 ```
 
-编译：
+Compile：
 
 ```c
 g++ -c add.cpp
 ```
 
-链接：
+Link：
 
 ```
 gcc add.c add.o -o main
 ```
 
-上述案例源代码见：
+Code：
 
 - [add.h](extern_c/add.h)
 
@@ -155,11 +156,12 @@ gcc add.c add.o -o main
 
 - [add.cpp](extern_c/add.cpp)
 
-综上，总结出使用方法，在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern "C"时会出现编译语法错误。所以使用extern "C"全部都放在于cpp程序相关文件或其头文件中。
+In the header file of C language, the external function can only be specified as extern type. The declaration of extern "C" is not supported in C language. There will be compiler syntax error when the. C file contains extern "C". Therefore, the use of external "C" is all placed in CPP program related files or its header files.
 
-总结出如下形式：
 
-（1）C++调用C函数：
+The following forms are summarized:
+
+（1）C + + calls C functions:
 
 ```c++
 //xx.h
@@ -176,7 +178,7 @@ extern "C" {
 }
 ```
 
-（2）C调用C++函数
+（2）C calls C + + functions
 
 ```c
 //xx.h

From 104b59c0202d9d1061d73c8e23a733f87f99e4e0 Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Sun, 19 Jul 2020 16:39:36 +0800
Subject: [PATCH 29/62] Update README.md

---
 english/basic_content/friend/README.md | 37 ++++++++++++--------------
 1 file changed, 17 insertions(+), 20 deletions(-)

diff --git a/english/basic_content/friend/README.md b/english/basic_content/friend/README.md
index 64ba791..bcc7009 100644
--- a/english/basic_content/friend/README.md
+++ b/english/basic_content/friend/README.md
@@ -1,20 +1,19 @@
-# 友元函数与友元类
+# Friend and Friend Class
 
-## 关于作者：
+## About Author：
 
-个人公众号：
 
 ![](../img/wechat.jpg)
 
-## 0.概述
+## 0.Summary
 
-友元提供了一种 普通函数或者类成员函数 访问另一个类中的私有或保护成员 的机制。也就是说有两种形式的友元：
+Friends provide a mechanism for ordinary functions or class member functions to access private or protected members in another class.In other words, there are two forms of friends:
 
-（1）友元函数：普通函数对一个访问某个类中的私有或保护成员。
+（1）Friend Function：Ordinary functions access a private or protected member of a class.
 
-（2）友元类：类A中的成员函数访问类B中的私有或保护成员
+（2）Friend Class：Member functions in class a access private or protected members in class B
 
-优点：提高了程序的运行效率。
+Advantages: improve the efficiency of the program.
 
 缺点：破坏了类的封装性和数据的透明性。
 
@@ -65,16 +64,15 @@ int main()
 }
 ```
 
-## 2.友元类
-友元类的声明在该类的声明中，而实现在该类外。
+## 2.Friend Class
+The declaration of a friend class is in the declaration of the class, and the implementation is outside the class.
 
 ```
-friend class <友元类名>;
+friend class <friend class name>;
 ```
 
-类B是类A的友元，那么类B可以直接访问A的私有成员。
-
-具体代码见：[friend_class.cpp](friend_class.cpp)
+Class B is a friend of class A, so class B can directly access private members of A.
+Code：[friend_class.cpp](friend_class.cpp)
 ```c++
 #include <iostream>
 
@@ -107,9 +105,8 @@ int main()
 ```
 
 
-## 3.注意
-- 友元关系没有继承性
-假如类B是类A的友元，类C继承于类A，那么友元类B是没办法直接访问类C的私有或保护成员。
-
-- 友元关系没有传递性
-假如类B是类A的友元，类C是类B的友元，那么友元类C是没办法直接访问类A的私有或保护成员，也就是不存在“友元的友元”这种关系。
+## 3.Attention
+- Friendship has no inheritance
+If class B is a friend of class A and class C inherits from Class A, then friend class B cannot directly access private or protected members of class C.
+- Friendship is not transitive
+If class B is a friend of class A and class C is a friend of class B, then friend class C cannot directly access private or protected members of class A, that is, there is no such relationship as "friend of friend".

From 6ff263d6583275fd3ce4f04c1385e0bf20afac19 Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Sun, 19 Jul 2020 23:02:37 +0800
Subject: [PATCH 30/62] Update README.md

---
 README.md | 357 +++++++++++++++++++++++++-----------------------------
 1 file changed, 163 insertions(+), 194 deletions(-)

diff --git a/README.md b/README.md
index dafd70d..999bc3c 100644
--- a/README.md
+++ b/README.md
@@ -1,151 +1,124 @@
-# C++ 那些事
+# Stories About C Plus Plus
+
+Thanks for all the support about << Stories About C ++ >>, right now you could open this link(https://light-city.club/sc/) to read this article.
+Any star, retweet or pr will be weclomed.
 
 
-感谢各位对《C++ 那些事》的支持，现将内容也同步至网站，可以打开网站直接阅读~欢迎大家 star、转发、PR。
-
-[直通点](https://light-city.club/sc/)
-
-https://light-city.club/sc/
+-----------------------
 
 
-### 关于作者
+### 0. Directory
 
-公众号已开放两大入口，分别是专辑与菜单，可以直接在微信公众号上阅读《C++那些事》内容，配上该仓库的代码，将会非常的爽，建议大家关注一波。
+- Chinese version：**C++ 那些事**
+- English version：**Stories About C Plus Plus**
 
-个人公众号：guangcity
+This repository meets the need of people who wants to really know about C++, and may help you in the interview. Besides, it also provides
+other details,such as in-depth source code analysis and multi-threaded concurrency. It is a comprehensive C ++ repository from entry to advanced improvement
 
-![](https://light-city.club/sc/assets/images/wechat.jpg)
+### 1.Foundation
 
-欢迎大家反馈及C++交流，本人在微信创建了C++那些事交流群，优质的C++资源交流区，期待大家关注上面公众号，点击公众号右下角->联系我，拉你入群。
+- [Stories About const](./basic_content/const)
+- [Stories About static](./basic_content/static)
+- [Stories about this](./basic_content/this)
+- [Stories About inline](./basic_content/inline)
+- [Stories About sizeof](./basic_content/sizeof)
+- [Stories About pointer of function](./basic_content/func_pointer)
+- [Stories About pure virtual function and abstract](./basic_content/abstract)
+- [Stories About vptr_vtable](./basic_content/vptr_vtable)
+- [Stories About virtual](./basic_content/virtual)
+- [Stories About volatile](./basic_content/volatile)
+- [Stories About assert](./basic_content/assert)
+- [Stories About bit](./basic_content/bit)
+- [Stories About extern](./basic_content/extern)
+- [Stories About struct](./basic_content/struct)
+- [Stories About struct and class](./basic_content/struct_class)
+- [Stories About union](./basic_content/union)
+- [Stories About polymorphism](./basic_content/c_poly)
+- [Stories About explicit](./basic_content/explicit)
+- [Stories About friend](./basic_content/friend)
+- [Stories About using](./basic_content/using)
+- [Stories About :: ](./basic_content/maohao)
+- [Stories About enum](./basic_content/enum)
+- [Stories About decltype](./basic_content/decltype)
+- [Stories About pointer_refer](./basic_content/pointer_refer)
+- [Stories About macro](./basic_content/macro)
 
----
+### 2.Code Samples
 
+#### 2.1 10 Days Practice
 
+- [x] day1
 
-### 项目运行
+Basic Grammar About C ++
+- [x] day2
 
-- **代码环境**
+Recursive、Structor、Enumerate、Static Variable
 
-  Ubuntu 18.04
+- [x] day3
 
-- **工具**
+Function
 
-  CLion  gcc/g++
+- [x] day4
 
-尽量用g++，因为一开始我用的vim写的，所以纯g++，后来用编译器CLion，部分有CMakeLists.txt文件，直接导入就行，后面会更新这个文件包含整个项目，持续关注~
+Thorough About Function 
 
-### 0.项目概要
+- [x] day5
 
-- 中文名：**C++ 那些事**
-- 英文名：**Stories About C Plus Plus**
+Inheritance and Polymorphism 
 
-这是一个适合初学者从<u>**入门到进阶**</u>的仓库，解决了<u>**面试者与学习者**</u>想要<u>**深入 C++**</u>及如何<u>**入坑 C++**</u>的问题。除此之外，本仓库拓展了更加深入的源码分析，多线程并发等的知识，是一个比较全面的 C++ 学习从入门到进阶提升的仓库。
+- [x] day6
 
-### 1.基础进阶
+Vitrual Function、Abstruct 
 
-- [const 那些事](./basic_content/const)
-- [static 那些事](./basic_content/static)
-- [this 那些事](./basic_content/this)
-- [inline 那些事](./basic_content/inline)
-- [sizeof 那些事](./basic_content/sizeof)
-- [函数指针那些事](./basic_content/func_pointer)
-- [纯虚函数和抽象类那些事](./basic_content/abstract)
-- [vptr_vtable 那些事](./basic_content/vptr_vtable)
-- [virtual 那些事](./basic_content/virtual)
-- [volatile 那些事](./basic_content/volatile)
-- [assert 那些事](./basic_content/assert)
-- [位域那些事](./basic_content/bit)
-- [extern 那些事](./basic_content/extern)
-- [struct 那些事](./basic_content/struct)
-- [struct 与 class 那些事](./basic_content/struct_class)
-- [union 那些事](./basic_content/union)
-- [c 实现 c++ 多态那些事](./basic_content/c_poly)
-- [explicit 那些事](./basic_content/explicit)
-- [friend 那些事](./basic_content/friend)
-- [using 那些事](./basic_content/using)
-- [:: 那些事](./basic_content/maohao)
-- [enum 那些事](./basic_content/enum)
-- [decltype 那些事](./basic_content/decltype)
-- [引用与指针那些事](./basic_content/pointer_refer)
-- [宏那些事](./basic_content/macro)
+- [x] day7
 
-### 2.实战系列
+Operator overloading
 
-#### 2.1 [10日狂练](./practical_exercises/10_day_practice)
+- [x] day8
 
-- [x] [day1](practical_exercises/10_day_practice/day1)
+Template And STL
 
-基本c++语法
+- [x] day9
 
-- [x] [day2](practical_exercises/10_day_practice/day2)
+Exception
 
-递归、结构体、枚举、静态变量等
+- [x] day10
 
-- [x] [day3](practical_exercises/10_day_practice/day3)
+File And Stream
 
-函数
+#### 2.2 Practical Exercises
 
-- [x] [day4](practical_exercises/10_day_practice/day4)
+├── [Square brackets overload .cpp](./practical_exercises/key_exercises/中括号重载.cpp)
+├── [Clock++operator overloading.cpp](./practical_exercises/key_exercises/时钟++运算符重载.cpp)
+├── [Mandatory conversion of operator overloading.cpp](./practical_exercises/key_exercises/运算符重载之强制转换.cpp)
+└── [Clock with overloaded parenthesis.cpp](./practical_exercises/key_exercises/重载圆括号的时钟.cpp)
 
-函数深入
+├── [Template of Function.cpp](./practical_exercises/key_exercises/函数模板.cpp)
 
-- [x] [day5](practical_exercises/10_day_practice/day5)
+├── [Dynamic array.cpp](./practical_exercises/key_exercises/动态数组.cpp)
 
-继承多态
+├── [Dictionary insertion and search.cpp](./practical_exercises/key_exercises/字典插入与查找.cpp)
 
-- [x] [day6](practical_exercises/10_day_practice/day6)
+├── [Catch Exception.cpp](./practical_exercises/key_exercises/异常捕获.cpp)
 
-虚函数、抽象类
+├── [Template of Stack.cpp](./practical_exercises/key_exercises/类模板之栈.cpp)
 
-- [x] [day7](practical_exercises/10_day_practice/day7)
+├── [Template of Array.cpp](./practical_exercises/key_exercises/类模板特化之数组.cpp)
 
-运算符重载
+├── [Inheritance And Package.cpp](./practical_exercises/key_exercises/继承与封装.cpp)
 
-- [x] [day8](practical_exercises/10_day_practice/day8)
+├── [Read And Write files.cpp](./practical_exercises/key_exercises/读写文件综合题.cpp)
+├── [Operator Overloading About Input and Output.cpp](./practical_exercises/key_exercises/输入输出运算符重载.cpp)
+├── [Input And Output Overloading.cpp](./practical_exercises/key_exercises/输入输出重载.cpp)
+├── [Input Format.cpp](./practical_exercises/key_exercises/输出格式.cpp)
 
-模板与STL
+### 2.[C++2.0 New Features](./c++2.0)
 
-- [x] [day9](practical_exercises/10_day_practice/day9)
+#### 2.0 Overview
 
-异常
+C++2.0 is an Abbreviation, meaning「modern C++」，including C++11/14/17/20.
 
-- [x] [day10](practical_exercises/10_day_practice/day10)
-
-文件与流
-
-#### 2.2 [重点实战练习](./practical_exercises/key_exercises/)
-
-├── [中括号重载.cpp](./practical_exercises/key_exercises/中括号重载.cpp)
-├── [时钟++运算符重载.cpp](./practical_exercises/key_exercises/时钟++运算符重载.cpp)
-├── [运算符重载之强制转换.cpp](./practical_exercises/key_exercises/运算符重载之强制转换.cpp)
-└── [重载圆括号的时钟.cpp](./practical_exercises/key_exercises/重载圆括号的时钟.cpp)
-
-├── [函数模板.cpp](./practical_exercises/key_exercises/函数模板.cpp)
-
-├── [动态数组.cpp](./practical_exercises/key_exercises/动态数组.cpp)
-
-├── [字典插入与查找.cpp](./practical_exercises/key_exercises/字典插入与查找.cpp)
-
-├── [异常捕获.cpp](./practical_exercises/key_exercises/异常捕获.cpp)
-
-├── [类模板之栈.cpp](./practical_exercises/key_exercises/类模板之栈.cpp)
-
-├── [类模板特化之数组.cpp](./practical_exercises/key_exercises/类模板特化之数组.cpp)
-
-├── [继承与封装.cpp](./practical_exercises/key_exercises/继承与封装.cpp)
-
-├── [读写文件综合题.cpp](./practical_exercises/key_exercises/读写文件综合题.cpp)
-├── [输入输出运算符重载.cpp](./practical_exercises/key_exercises/输入输出运算符重载.cpp)
-├── [输入输出重载.cpp](./practical_exercises/key_exercises/输入输出重载.cpp)
-├── [输出格式.cpp](./practical_exercises/key_exercises/输出格式.cpp)
-
-### 3.[C++2.0 新特性](./c++2.0)
-
-#### 3.0 概况
-
-C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
-
-#### 3.1 [C++11 新特性](./c++2.0/c++11)
+#### 2.1 [C++11 New Features](./c++2.0/c++11)
 
 - [Variadic Templates](./c++2.0/variadic)
 
@@ -153,7 +126,7 @@ C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
 
   ```cpp
   vector<list<int> > //ok in each C++ version
-  vector<list<int>> // before c++ 11 error error: ‘>>’ should be ‘> >’ within a nested template argument list,c++11后可以正常通过
+  vector<list<int>> // before c++ 11 error error: ‘>>’ should be ‘> >’ within a nested template argument list,version beyond c++ 11 could   compile successfully
   ```
 
 - [nullptr and nullptr_t](./c++2.0/nullptr.cpp)
@@ -176,8 +149,8 @@ C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
 
 - [=default,=delete](./c++2.0/default_delete.cpp)
 
-  如果你自行定义了一个 ctor,那么编译器就不会给你一个 default ctor
-  如果强制加上 =default,就可以重新获得并使用 default ctor.
+  If you define a ctor by yourself, compiler won't compile the default ctor.
+  If you add =default, you could recatch and use default ctor.
 
 - Alias(化名)Template(template typedef)
 
@@ -202,30 +175,29 @@ C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
 
 - [move aware class](./c++2.0/move.cpp)
 
-- 容器-结构与分类
+- Container-Struct And Classify
 
-  - (1) 序列式容器包括：`array`(C++2.0 新引入),`vector`,`deque`,`list`,`forward_list`(C++2.0 新引入)
-  - (2) 关联式容器包括：`set/multiset`,`map/multimap`
-  - (3) 无序容器(C++2.0 新引入,更换原先 `hash_xxx` 为 `unordered_xxx`)包括：`unordered_map/unordered_multimap,unordered_set/unordered_multiset`
+  - (1) Serial containers include：`array`(C++2.0 Newly Introduced),`vector`,`deque`,`list`,`forward_list`(C++2.0 Newly Introduced)
+  - (2) Associated containers include：`set/multiset`,`map/multimap`
+  - (3) Unordered container(C++2.0 Newly Introduced,replace `hash_xxx` to `unordered_xxx`) include：`unordered_map/unordered_multimap,unordered_set/unordered_multiset`
 
 - [Hash Function](./c++2.0/hash.cpp)
 
 - [tuple](./c++2.0/tuple.cpp)
 
-  学习资料：https://www.bilibili.com/video/av51863195?from=search&seid=3610634846288253061
+  Learning Material：https://www.bilibili.com/video/av51863195?from=search&seid=3610634846288253061
 
-#### 3.2 C++14/17/20
+### 2.2 C++14/17/20
 
-待更新...
+To Be Continued ...
 
-### 4.设计模式
+### 3.Design Pattern
 
-- [单例模式](./design_pattern/singleton)
-- [生产消费者模式](./design_pattern/producer_consumer)
+- [Singleton pattern](./design_pattern/singleton)
 
-### 5. [STL 源码剖析](./src_analysis/stl)
+### 4. [STL Source Code Analysis](./src_analysis/stl)
 
-**STL 源码剖析：gcc 4.9.1**
+**STL Source Code Analysis：gcc 4.9.1**
 
 - [array](./src_analysis/stl/array.md)
 - [deque](./src_analysis/stl/deque.md)
@@ -235,83 +207,83 @@ C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
 - [typename](./src_analysis/stl/typename.md)
 - [traits](./src_analysis/stl/traits.md)
 - [iterator](./src_analysis/stl/iterator.md)
-- [谈谈 STL 设计之 EBO 优化](./src_analysis/stl/谈谈STL设计之EBO优化.md)
+- [Talking about STL design and EBO optimization](./src_analysis/stl/谈谈STL设计之EBO优化.md)
 - [rb_tree](./src_analysis/stl/rb_tree.md)
 - [set and multiset](set_multiset.md)
 - [map and multimap](./src_analysis/stl/map_multimap.md)
 - [hashtable](./src_analysis/stl/hashtable.md)
-- [myhashtable](./src_analysis/stl/myhashtable.md)
+- [myhashtable](./src_analysis/stl/myPhashtable.md)
 - [unordered_map](./src_analysis/stl/unordered_map.md)
 
-### 6. [并发编程](./concurrency)
+### 4. [Concurrent Programming](./concurrency)
 
-#### 6.1 C++ Concurrency in Action
+#### 4.1 C++ Concurrency in Action
 
-- [第一章](./concurrency/concurrency_v1/chapter1)
-- [第二章](./concurrency/concurrency_v1/chapter2)
+- [Chapter One](./concurrency/concurrency_v1/chapter1)
+- [Chapter Two](./concurrency/concurrency_v1/chapter2)
 
-学习资料：https://chenxiaowei.gitbook.io/cpp_concurrency_in_action/
+Learning materials: https://chenxiaowei.gitbook.io/cpp_concurrency_in_action/
 
-#### 6.2 多线程与多进程
+#### 4.2 Multithreading And Multiprocess
 
-##### 6.2.1 Threading In C++
+##### 4.2.1 Threading In C++
 
-- [介绍](./concurrency/Threading_In_CPlusPlus/1.thread)
-- [创建线程的五种类型](./concurrency/Threading_In_CPlusPlus/2.create_type)
-- [Join 与 Detachs](./concurrency/Threading_In_CPlusPlus/3.join_detach)
+- [Introduction](./concurrency/Threading_In_CPlusPlus/1.thread)
+- [Five Types of Thread Creation](./concurrency/Threading_In_CPlusPlus/2.create_type)
+- [Join And Detachs](./concurrency/Threading_In_CPlusPlus/3.join_detach)
 - [mutex in C++ Threading](./concurrency/Threading_In_CPlusPlus/4.mutex)
 
-> 学习自：
+> From：
 >
 > https://www.youtube.com/watch?v=eZ8yKZo-PGw&list=PLk6CEY9XxSIAeK-EAh3hB4fgNvYkYmghp&index=4
 
-### 7. [C++ 惯用法](./codingStyleIdioms)
+### 5. [C++ Conventional method](./codingStyleIdioms)
 
-##### 你最喜欢的 c++ 编程风格惯用法是什么?
+##### What is your favorite custom for c ++ programming style?
 
-- [1.类初始化列表](./codingStyleIdioms/1_classInitializers)
-- [2.枚举类替换命名空间](./codingStyleIdioms/2_enumclass_namespace)
-- [3.RAII(资源获取即初始化)](./codingStyleIdioms/3_RAII)
-- [4.copy and swap](./codingStyleIdioms/4_copy-swap)
-- [5.pImpl(指针指向具体实现)](./codingStyleIdioms/5_pImpl)
+- [1.ClassInitializers](./codingStyleIdioms/1_classInitializers)
+- [2.Replace Enumclass with Namespace](./codingStyleIdioms/2_enumclass_namespace)
+- [3.RAII(Resource Acquisition Initialization)](./codingStyleIdioms/3_RAII)
+- [4.Copy and Swap](./codingStyleIdioms/4_copy-swap)
+- [5.pImpl(Pointer Implement)](./codingStyleIdioms/5_pImpl)
 
-### 8.学习课程
+### 6.Learning Courses
 
-#### 8.1 [极客时间《现代 C++ 实战 30 讲》](https://time.geekbang.org/channel/home)
+#### 6.1 [Chinese Name:极客时间《现代 C++ 实战 30 讲》](https://time.geekbang.org/channel/home)
 
-- [堆、栈、RAII：C++ 里该如何管理资源？](./learn_class/modern_C++_30/RAII)
-  - [堆](./modern_++_30/RAII/heap.cpp)
-  - [栈](./learn_class/modern_C++_30/RAII/stack.cpp)
+- [heap、stack、RAII：How to manage resources for C ++ ?](./learn_class/modern_C++_30/RAII)
+  - [heap](./modern_++_30/RAII/heap.cpp)
+  - [stack](./learn_class/modern_C++_30/RAII/stack.cpp)
   - [RAII](./learn_class/modern_C++_30/RAII/RAII.cpp)
-- [自己动手，实现 C++ 的智能指针](./learn_class/modern_C++_30/smart_ptr)
+- [Implementing smart pointers for C ++](./learn_class/modern_C++_30/smart_ptr)
   - [auto_ptr、scope_ptr](./learn_class/modern_C++_30/smart_ptr/auto_scope.cpp)
   - [unique_ptr](./learn_class/modern_C++_30/smart_ptr/unique_ptr.cpp)
   - [shared_ptr](./learn_class/modern_C++_30/smart_ptr/shared_ptr.cpp)
-- [右值和移动究竟解决了什么问题？](./learn_class/modern_C++_30/reference)
-  - [左值与右值](./learn_class/modern_C++_30/reference/reference.cpp)
-  - [延长声明周期](./learn_class/modern_C++_30/reference/lifetime.cpp)
-  - [引用折叠](./learn_class/modern_C++_30/reference/collapses.cpp)
-  - [完美转发](./learn_class/modern_C++_30/reference/forward.cpp)
-  - [不要返回本地变量的引用](./learn_class/modern_C++_30/reference/don'treturnReference.cpp)
-- [容器 1](./learn_class/modern_C++_30/container1)
-- [容器 2](./learn_class/modern_C++_30/container2)
-- [异常](./learn_class/modern_C++_30/exception)
-- [字面量、静态断言和成员函数说明符](./learn_class/modern_C++_30/literalAssert)
-- [是不是应该返回对象？](./learn_class/modern_C++_30/returnObj)
-- [编译期多态：泛型编程和模板入门](./learn_class/modern_C++_30/compilerpoly)
-- [译期能做些什么？一个完整的计算世界](./learn_class/modern_C++_30/compilercompute)
-- [SFINAE：不是错误的替换失败是怎么回事?](./learn_class/modern_C++_30/SFINAE)
-- [constexpr：一个常态的世界](./learn_class/modern_C++_30/constexpr)
-- [函数对象和 lambda：进入函数式编程](./learn_class/modern_C++_30/functionLambda)
-- [内存模型和 atomic：理解并发的复杂性](./learn_class/modern_C++_30/memorymodel_atomic)
+- [What exactly does r value and move solve？](./learn_class/modern_C++_30/reference)
+  - [L value and R value](./learn_class/modern_C++_30/reference/reference.cpp)
+  - [Extend the declaration cycle](./learn_class/modern_C++_30/reference/lifetime.cpp)
+  - [Reference folding](./learn_class/modern_C++_30/reference/collapses.cpp)
+  - [Perfect forward](./learn_class/modern_C++_30/reference/forward.cpp)
+  - [Do not return Reference](./learn_class/modern_C++_30/reference/don'treturnReference.cpp)
+- [Container 1](./learn_class/modern_C++_30/container1)
+- [Container 2](./learn_class/modern_C++_30/container2)
+- [Exception](./learn_class/modern_C++_30/exception)
+- [Literal、Static Assertion And Member Function Specifier](./learn_class/modern_C++_30/literalAssert)
+- [Return Object？](./learn_class/modern_C++_30/returnObj)c
+- [Getting started with generic programming and templates](./learn_class/modern_C++_30/compilerpoly)
+- [A whole Compiler Compute World](./learn_class/modern_C++_30/compilercompute)
+- [SFINAE：What is it if it is not replace error?](./learn_class/modern_C++_30/SFINAE)
+- [constexpr：A Normal World](./learn_class/modern_C++_30/constexpr)
+- [Function object and Lambda：functionLambda](./learn_class/modern_C++_30/functionLambda)
+- [Memory Model and Atomic：Understangding the complexity of concurrency](./learn_class/modern_C++_30/memorymodel_atomic)
 
-### 9.工具篇
+### 7.Tools
 
-#### 9.1 [容器快捷输出工具](./tool/output)
+#### 7.1 [Container shortcut output tool](./tool/output)
 
-对吴老师的代码进行了修改，[点击此处直通代码](./tool/output/output_container.h)
+Modified the code, [Click here for the code](./tool/output/output_container.h)
 
-输入：
+Input：
 
 ```cpp
 map<int, int> mp{
@@ -321,31 +293,42 @@ map<int, int> mp{
     cout << mp << endl;
 ```
 
-输出结果显示：
+Output：
 
 ```cpp
 { 1 => 1, 2 => 4, 3 => 9 }
 ```
 
-#### 9.2 像 Python 一样简单输出（Jupyter Notebook）
+#### 7.2 Output Like Python（Jupyter Notebook）
 
-- [像 Python 一样玩 C/C++](./tool/像Python一样玩CC++.md)
+- [How to output like python in C/C++](./tool/像Python一样玩CC++.md)
 
-#### 9.3 观察编译过程变化
+#### 7.3 Observe the changes in the compilation process
 
 -  [https://cppinsights.io](https://cppinsights.io/)
 
-#### 9.4 C++ 的 Debug 工具 dbg-macro
+#### 7.4 Debug Tools For C ++：dbg-macro
 
-- [C++ 的 Debug 工具 dbg-macro](./tool/C++的Debug工具dbg-macro.md)
+- [Debug Tool: dbg-macro](./tool/C++的Debug工具dbg-macro.md)
 
-### 10.拓展部分
+### 8.Expansion
 
-#### 10.1 一些问题
+#### 8.1 Other Problems
+- [How to convert string to in C ++？](./extension/some_problem/string_int.md)
 
-- [C++ 中如何将 string 类型转换为 int 类型？](./extension/some_problem/string_int.md)
 
-### 11.贡献者
+### 9.Circumstance
+
+
+- **Running Circumstance**
+
+  Ubuntu 18.04
+
+- **IDE**
+
+  CLion  gcc/g++
+
+### 10.Contributor
 
 <table>
   <tbody>
@@ -366,22 +349,8 @@ map<int, int> mp{
   </tbody>
 </table>
 
-### 12.赞助我
+### 11.About The Writer
 
-如果觉得不错，赞助我吧~
-
-<table>
-  <tbody>
-    <tr>
-      <th align="center" style="height=200 width="200">
-          <img src="https://light-city.club/sc/assets/images/alipay.jpg" height="200" width="200" ><br>
-          支付宝
-      </th>
-      <th align="center" style="height=200 width="200">
-          <img src="https://light-city.club/sc/assets/images/wechat.png" height="200" width="200" ><br>
-          微信
-      </th>
-    </tr>
-  </tbody>
-</table>
+个人公众号：
 
+![](./img/wechat.jpg)

From 9113730b26596551d52917f151e456e9ea8fd35f Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Mon, 20 Jul 2020 00:39:30 +0800
Subject: [PATCH 31/62] Update README.md

---
 english/basic_content/macro/README.md | 94 ++++++++++++++-------------
 1 file changed, 49 insertions(+), 45 deletions(-)

diff --git a/english/basic_content/macro/README.md b/english/basic_content/macro/README.md
index d20b612..18022cf 100644
--- a/english/basic_content/macro/README.md
+++ b/english/basic_content/macro/README.md
@@ -1,22 +1,22 @@
-# 宏那些事
+# Story about Macro
 
-## 关于作者：
 
-个人公众号：
 
 ![](../img/wechat.jpg)
 
-## 1.宏中包含特殊符号
+## 1.The macro contains special symbols
 
-分为几种：`#`，`##`，`\`
+Several type：`#`，`##`，`\`
 
-### 1.1 字符串化操作符（#）
+### 1.1 String operator（#）
 
-**在一个宏中的参数前面使用一个#,预处理器会把这个参数转换为一个字符数组**，换言之就是：**#是“字符串化”的意思，出现在宏定义中的#是把跟在后面的参数转换成一个字符串**。
+**Using a # before macro parameter,The preprocessor converts this parameter into an array of characters**，In other words：**# is “stringlize”，The#, which appears in the macro definition, is to convert the following parameter into a string
 
-**注意：其只能用于有传入参数的宏定义中，且必须置于宏定义体中的参数名前。**
+**。
 
-例如：
+**Attention：It can only be used in macro definitions that have passed in parameters, and must be placed before the parameter name in the macro definition body.**
+
+For example：
 
 ```c++
 #define exp(s) printf("test s is:%s\n",s)
@@ -29,7 +29,7 @@ int main() {
     string str = exp2(   bac );
     cout<<str<<" "<<str.size()<<endl;
     /**
-     * 忽略传入参数名前面和后面的空格。
+     * Ignore spaces before and after the passed in parameter name
      */
     string str1 = exp2( asda  bac );
     /**
@@ -41,47 +41,47 @@ int main() {
 }
 ```
 
-上述代码给出了基本的使用与空格处理规则，空格处理规则如下：
+The above code gives the basic use and space handling rules，The space handling rules are as follows：
 
-- 忽略传入参数名前面和后面的空格。
+- Ignore spaces before and after the passed in parameter name
 
 ```c++
 string str = exp2(   bac );
 cout<<str<<" "<<str.size()<<endl;
 ```
 
-输出：
+Output：
 
 ```
 bac 3
 ```
 
-- 当传入参数名间存在空格时，编译器将会自动连接各个子字符串，用每个子字符串之间以一个空格连接，忽略剩余空格。
+- When there are spaces between the input parameter names, the compiler will automatically connect each substring with a space between each substring, ignoring the remaining spaces.
 
 ```c++
 string str1 = exp2( asda  bac );
 cout<<str1<<" "<<str1.size()<<endl;
 ```
 
-输出：
+Output：
 
 ```
 asda bac 8
 ```
 
-### 1.2 符号连接操作符（##）
+### 1.2 Symbolic join operator（##）
 
-**“##”是一种分隔连接方式，它的作用是先分隔，然后进行强制连接。将宏定义的多个形参转换成一个实际参数名。**
+**“##” It's a separate connection. Its function is to separate and then force the connection.Converts multiple parameters defined by a macro to an actual parameter name.**
 
-注意事项：
+Attention：
 
-**（1）当用##连接形参时，##前后的空格可有可无。**
+**（1）When use ## connecting parameters，##The space before and after is optional**
 
-**（2）连接后的实际参数名，必须为实际存在的参数名或是编译器已知的宏定义。**
+**（2）Actual parameter name after connection，Must be an actual parameter name or a macro definition known to the compiler**
 
-**（3）如果##后的参数本身也是一个宏的话，##会阻止这个宏的展开。**
+**（3）If ## the parameter itself is a macro，## will prevent the macro from expanding.**
 
-示例：
+ex：
 
 ```c++
 
@@ -98,11 +98,11 @@ int main() {
 }
 ```
 
-### 1.3 续行操作符（\） 
+### 1.3 Continuation operator（\） 
 
-**当定义的宏不能用一行表达完整时，可以用”\”表示下一行继续此宏的定义。**
+**When the defined macro cannot be expressed completely in one line, you can use "\" to indicate the next line to continue the macro definition **
 
-**注意 \ 前留空格。**
+**Leave a space before \ **
 
 ```c++
 #define MAX(a,b) ((a)>(b) ? (a) \
@@ -113,13 +113,13 @@ int main() {
 }
 ```
 
-上述代码见：[sig_examp.cpp](sig_examp.cpp)
+From：[sig_examp.cpp](sig_examp.cpp)
 
-## 2.do{...}while(0)的使用
+## 2.do{...}while(0)
 
-### 2.1 避免语义曲解
+### 2.1 Avoid semantic misinterpretation
 
-例如：
+Such as ：
 
 ```
 #define fun() f1();f2();
@@ -127,7 +127,7 @@ if(a>0)
 	fun()
 ```
 
-这个宏被展开后就是：
+When this macro is expanded, it will be：
 
 ```
 if(a>0)
@@ -135,11 +135,12 @@ if(a>0)
 	f2();
 ```
 
-本意是a>0执行f1 f2，而实际是f2每次都会执行，所以就错误了。
 
-为了解决这种问题，在写代码的时候，通常可以采用`{}`块。
+In order to solve this problem, when writing code, usually can adopt
 
-如：
+`{}`。
+
+ex：
 
 ```c++
 #define fun() {f1();f2();}
@@ -153,11 +154,12 @@ if(a>0)
 };
 ```
 
-但是会发现上述宏展开后多了一个分号，实际语法不太对。(虽然编译运行没问题，正常没分号)。
+However, you will find that there is a semicolon after the macro is expanded, so the actual syntax is not correct.(Although the compiler runs well, there is no semicolon).
 
-### 2.2避免使用goto控制流
+### 2.2 Avoid using goto to control flow
+
+In some functions, we may need to do some cleaning before the return statement, such as releasing the memory space requested by malloc at the beginning of the function. Using goto is always a simple method:
 
-在一些函数中，我们可能需要在return语句之前做一些清理工作，比如释放在函数开始处由malloc申请的内存空间，使用goto总是一种简单的方法：
 
 ```c++
 int f() {
@@ -177,7 +179,8 @@ END:
 }
 ```
 
-但由于goto不符合软件工程的结构化，而且有可能使得代码难懂，所以很多人都不倡导使用，这个时候我们可以使用do{...}while(0)来做同样的事情：
+However, because go to does not conform to the structure of software engineering and may make the code difficult to understand, many people do not advocate using goto. At this time, we can use do {...} while (0) to do the same thing
+
 
 ```c++
 int ff() {
@@ -198,20 +201,21 @@ int ff() {
 }
 ```
 
-这里将函数主体部分使用do{...}while(0)包含起来，使用break来代替goto，后续的清理工作在while之后，现在既能达到同样的效果，而且代码的可读性、可维护性都要比上面的goto代码好的多了。
+The main part of function using do{...}while(0),using break instead of goto.The subsequent cleaning is after while. Now we can achieve the same effect, and the readability and maintainability of the code are better than the goto code above
 
-### 2.3 避免由宏引起的警告
+### 2.3 Avoid warnings caused by macros
 
-内核中由于不同架构的限制，很多时候会用到空宏，。在编译的时候，这些空宏会给出warning，为了避免这样的warning，我们可以使用do{...}while(0)来定义空宏：
+
+Due to the limitation of different architectures in the kernel，Empty macros are often used. While compiling，These empty macros give warning. In order to avoid warning，we could use do{...}while(0) to define empty macro：
 
 ```
 #define EMPTYMICRO do{}while(0)
 ```
 
-### 2.4 **定义单一的函数块来完成复杂的操作**
+### 2.4 **Define a single function block to perform complex operations**
 
-如果你有一个复杂的函数，变量很多，而且你不想要增加新的函数，可以使用do{...}while(0)，将你的代码写在里面，里面可以定义变量而不用考虑变量名会同函数之前或者之后的重复。
-这种情况应该是指一个变量多处使用（但每处的意义还不同），我们可以在每个do-while中缩小作用域，比如：
+If you have a complex function. There are many variables，And you don't want to add new functions。You could use do {...}while(0)，Write your code in it. You can define variables without considering the repetition of variable names and functions.
+This should mean that a variable is used in multiple place(But the meaning of each is different)，We can narrow down the scope in each do while，for example：
 
 ```c++
 int fc()
@@ -226,7 +230,7 @@ int fc()
 }
 ```
 
-上述代码见：[do_while.cpp](do_while.cpp)
+From：[do_while.cpp](do_while.cpp)
 
-学习文章：<https://www.cnblogs.com/lizhenghn/p/3674430.html>
+Article：<https://www.cnblogs.com/lizhenghn/p/3674430.html>
 

From c95a9e2b8b2fb2a7b1d7a54d9af9b3eb9d20efa4 Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Mon, 20 Jul 2020 09:17:33 +0800
Subject: [PATCH 32/62] Update README.md

---
 english/basic_content/friend/README.md | 27 +++++++++++++-------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/english/basic_content/friend/README.md b/english/basic_content/friend/README.md
index bcc7009..01ebcbe 100644
--- a/english/basic_content/friend/README.md
+++ b/english/basic_content/friend/README.md
@@ -15,26 +15,25 @@ Friends provide a mechanism for ordinary functions or class member functions to
 
 Advantages: improve the efficiency of the program.
 
-缺点：破坏了类的封装性和数据的透明性。
+Disadvantages: it destroys the encapsulation of classes and the transparency of data.
+Conclusion：
+- Access to private members
+- Breaking encapsulation
+- Friendship is not transitive
+- The unidirectionality of friend relationship
+- There are no restrictions on the form and number of friend declarations
 
-总结：
-- 能访问私有成员
-- 破坏封装性
-- 友元关系不可传递
-- 友元关系的单向性
-- 友元声明的形式及数量不受限制
+## 1.Friend function
 
-## 1.友元函数
-
-在类声明的任何区域中声明，而定义则在类的外部。
+It is declared in any region of the class declaration, and the definition is outside the class.
 
 ```
-friend <类型><友元函数名>(<参数表>);
+friend <type><name>(<Parameter table>);
 ```
 
-注意，友元函数只是一个普通函数，并不是该类的类成员函数，它可以在任何地方调用，友元函数中通过对象名来访问该类的私有或保护成员。
+Note that the friend function is only a common function, not a class member function of this class. It can be called anywhere. In the friend function, private or protected members of the class can be accessed through the object name.
 
-具体代码见：[friend_func.cpp](friend_func.cpp)
+Code：[friend_func.cpp](friend_func.cpp)
 
 ```c++
 #include <iostream>
@@ -45,7 +44,7 @@ class A
 {
 public:
     A(int _a):a(_a){};
-    friend int geta(A &ca);  ///< 友元函数
+    friend int geta(A &ca);  ///< Friend function
 private:
     int a;
 };

From c5e370d660d837cfd7e97795f256baac5dc51703 Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Mon, 20 Jul 2020 09:39:18 +0800
Subject: [PATCH 33/62] Update README.md

---
 english/basic_content/inline/README.md | 46 ++++++++++++++------------
 1 file changed, 25 insertions(+), 21 deletions(-)

diff --git a/english/basic_content/inline/README.md b/english/basic_content/inline/README.md
index 9f757a1..0bb2e91 100644
--- a/english/basic_content/inline/README.md
+++ b/english/basic_content/inline/README.md
@@ -1,14 +1,15 @@
-# inline那些事
+# Story About Inline
+
+## About Author：
 
-## 关于作者：
 
-个人公众号：
 
 ![](../img/wechat.jpg)
 
-## 1.类中内联
+## 1.Inline in Class
+
+Declaration method in header file
 
-头文件中声明方法
 
 ```c++
 
@@ -18,20 +19,21 @@ public:
     void f1(int x); 
 
     /**
-     * @brief 类中定义了的函数是隐式内联函数,声明要想成为内联函数，必须在实现处(定义处)加inline关键字。
+     * @brief The function defined in the class is an implicit inline function. If you want to be an inline function, you must add the inline keyword at the implementation (definition)
      *
      * @param x
      * @param y
      */
-    void Foo(int x,int y) ///< 定义即隐式内联函数！
+    void Foo(int x,int y) ///< The definition is implicit inline function
     {
     
     };
-    void f1(int x); ///< 声明后，要想成为内联函数，必须在定义处加inline关键字。  
+    void f1(int x); ///< To be an inline function after declaration, you must add the inline keyword to the definition  
 };
 ```
 
-实现文件中定义内联函数：
+The inline function is defined in the implementation file:
+
 
 ```c++
 #include <iostream>
@@ -40,20 +42,22 @@ public:
 using namespace std;
 
 /**
- * @brief inline要起作用,inline要与函数定义放在一起,inline是一种“用于实现的关键字,而不是用于声明的关键字”
+ * @brief To work, inline should be placed with function definition. Inline is a kind of "keyword for implementation, not for declaration"
  *
  * @param x
  * @param y
  *
  * @return 
  */
-int Foo(int x,int y);  // 函数声明
-inline int Foo(int x,int y) // 函数定义
+int Foo(int x,int y);  // Function declaration
+
+
+inline int Foo(int x,int y) // Function definition
 {
     return x+y;
 }
 
-// 定义处加inline关键字，推荐这种写法！
+// It is recommended to add the keyword "inline" to the definition！
 inline void A::f1(int x){
 
 }
@@ -87,11 +91,11 @@ int main()
 
 （2）如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。
 
-## 2.虚函数（virtual）可以是内联函数（inline）吗？
+## 2.Could virtual be inline function?
 
-- 虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能内联。
-- 内联是在编译期建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。
-- `inline virtual` 唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如 `Base::who()`），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。
+- Virtual functions can be inline functions, which can modify virtual functions, but cannot be inlined when they are polymorphic
+- Inline means that the compiler is advised to inline at compile time. However, due to the polymorphism of virtual functions, the compiler cannot know which code to call at runtime. Therefore, when the virtual function is polymorphic (runtime), it cannot be inlined.
+- `inline virtual` The only time you can inline is when the compiler knows which class the object is calling（such as: `Base::who()`），This only happens if the compiler has an actual object instead of a pointer or reference to the object.
 
 ```c++
 #include <iostream>  
@@ -108,7 +112,7 @@ public:
 class Derived : public Base
 {
 public:
-    inline void who()  // 不写inline时隐式内联
+    inline void who()  //
     {
         cout << "I am Derived\n";
     }
@@ -116,15 +120,15 @@ public:
 
 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;
 

From a4d0f84c0addf327c2a77a8390bca9941a175d0b Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Mon, 20 Jul 2020 10:01:30 +0800
Subject: [PATCH 34/62] Update README.md

---
 english/basic_content/inline/README.md | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/english/basic_content/inline/README.md b/english/basic_content/inline/README.md
index 0bb2e91..81fd28a 100644
--- a/english/basic_content/inline/README.md
+++ b/english/basic_content/inline/README.md
@@ -70,26 +70,26 @@ int main()
 
 }
 /**
- * 编译器对 inline 函数的处理步骤
- * 将 inline 函数体复制到 inline 函数调用点处；
- * 为所用 inline 函数中的局部变量分配内存空间；
- * 将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中；
- * 如果 inline 函数有多个返回点，将其转变为 inline 函数代码块末尾的分支（使用 GOTO）。
+ * Compiler's processing steps for inline function
+ * Copy the body of the inline function to the call point of the inline function;
+ * Allocate memory space for local variables in the inline function used
+ * The input parameters and return values of the inline function are mapped to the local variable space of the calling method
+ * If the inline function has multiple return points, convert it to a branch at the end of the inline function code block (using goto)
  */
 
 ```
 
-内联能提高函数效率，但并不是所有的函数都定义成内联函数！内联是以代码膨胀(复制)为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。
+Inline can improve the efficiency of functions, but not all functions are defined as inline functions！内联是以代码膨胀(复制)为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。
 
-- 如果执行函数体内代码的时间相比于函数调用的开销较大，那么效率的收货会更少！
+-If the execution time of the code in the function body is higher than the cost of function call, the efficiency of receiving goods will be less！
 
-- 另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。
+- On the other hand, every call of inline function will copy the code, which will increase the total code of the program and consume more memory space
 
-以下情况不宜用内联：
+Inline is not suitable for the following situations：
 
-（1）如果函数体内的代码比较长，使得内联将导致内存消耗代价比较高。
+（1）If the code in the function body is long, it will lead to high memory consumption
 
-（2）如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。
+（2）If there is a loop in the function body, it takes more time to execute the code in the function body than the cost of the function call。
 
 ## 2.Could virtual be inline function?
 

From 8ab626f55768303cd9ef02f9b01bd72e8b2c2d4c Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Mon, 20 Jul 2020 10:02:07 +0800
Subject: [PATCH 35/62] Update README.md

---
 english/basic_content/inline/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/english/basic_content/inline/README.md b/english/basic_content/inline/README.md
index 81fd28a..7a3191e 100644
--- a/english/basic_content/inline/README.md
+++ b/english/basic_content/inline/README.md
@@ -79,7 +79,7 @@ int main()
 
 ```
 
-Inline can improve the efficiency of functions, but not all functions are defined as inline functions！内联是以代码膨胀(复制)为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。
+Inline can improve the efficiency of functions, but not all functions are defined as inline functions！
 
 -If the execution time of the code in the function body is higher than the cost of function call, the efficiency of receiving goods will be less！
 

From 93faa13d7bda9c615d7325c8afd2cc95e875afc8 Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Mon, 20 Jul 2020 10:08:07 +0800
Subject: [PATCH 36/62] Update README.md

---
 english/basic_content/maohao/README.md | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/english/basic_content/maohao/README.md b/english/basic_content/maohao/README.md
index d78b3e5..b7b2b34 100644
--- a/english/basic_content/maohao/README.md
+++ b/english/basic_content/maohao/README.md
@@ -1,14 +1,13 @@
-# :: 范围解析运算符那些事
+# :: Story about range resolution operators
 
-## 关于作者：
+## Abput Author：
 
-个人公众号：
 
 ![](../img/wechat.jpg)
 
-- 全局作用域符（::name）：用于类型名称（类、类成员、成员函数、变量等）前，表示作用域为全局命名空间
-- 类作用域符（class::name）：用于表示指定类型的作用域范围是具体某个类的
-- 命名空间作用域符（namespace::name）:用于表示指定类型的作用域范围是具体某个命名空间的
+- Global scope（::name）：Used before a type name (class, class member, member function, variable, etc.), indicates that the scope is a global namespace
+- Class scope（class::name）：The scope used to represent the specified type is class specific
+- Namespace scope（namespace::name）: The scope used to represent the specified type is a namespace specific
 
-具体代码见：[maohao.cpp](maohao.cpp)
+Code ：[maohao.cpp](maohao.cpp)
 

From 2df250cd8f2158200d36b1c95504045448d9a312 Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Mon, 20 Jul 2020 15:29:43 +0800
Subject: [PATCH 37/62] Update README.md

---
 english/basic_content/pointer_refer/README.md | 110 +++++++++---------
 1 file changed, 58 insertions(+), 52 deletions(-)

diff --git a/english/basic_content/pointer_refer/README.md b/english/basic_content/pointer_refer/README.md
index ba4b0dd..f5258a8 100644
--- a/english/basic_content/pointer_refer/README.md
+++ b/english/basic_content/pointer_refer/README.md
@@ -2,87 +2,93 @@
 
 ## 关于作者：
 
-个人公众号：
+：
 
 ![](../img/wechat.jpg)
 
-## 1.引用与指针
+## 1.References and pointers
 
-总论：
+Conclusion：
 
-| 引用         | 指针         |
-| ------------ | ------------ |
-| 必须初始化   | 可以不初始化 |
-| 不能为空     | 可以为空     |
-| 不能更换目标 | 可以更换目标 |
+| Reference         | Pointer              |
+| ------------ | ------------              |
+| Must be initialized   | No initialization is allowed    |
+| cannot be empty     | could be empty     |
+| Target cannot be changed | 可以更换目标   |
 
-> 引用必须初始化，而指针可以不初始化。
+> References must be initialized, and pointers can be uninitialized
 
-我们在定义一个引用的时候必须为其指定一个初始值，但是指针却不需要。
+When we define a reference, we must specify an initial value for it, but the pointer does not
 
 ```c++
-int &r;    //不合法，没有初始化引用
-int *p;    //合法，但p为野指针，使用需要小心
+int &r;    //Illegal, no initialization reference
+int *p;    //It is legal, but p is a wild pointer. You should be careful when using it
 ```
 
-> 引用不能为空，而指针可以为空。
-
-由于引用不能为空，所以我们在使用引用的时候不需要测试其合法性，而在使用指针的时候需要首先判断指针是否为空指针，否则可能会引起程序崩溃。
+> Reference cannot be null and pointer can be null
 
+Since the reference cannot be null, we do not need to test its validity when using a reference. When using a pointer, we need to first judge whether the pointer is a null pointer, otherwise it may cause the program to crash.
 ```c++
 void test_p(int* p)
 {
-  	if(p != null_ptr)    //对p所指对象赋值时需先判断p是否为空指针
+  	if(p != null_ptr)    //
     	*p = 3;
     return;
 }
 void test_r(int& r)
 {
-    r = 3;    //由于引用不能为空，所以此处无需判断r的有效性就可以对r直接赋值
+    r = 3;    //
     return;
 }
 ```
 
-> 引用不能更换目标
+> References cannot change targets
+
+
+
+The pointer can be changed at any time, but the reference can only point to the object pointed to during initialization, and cannot be changed.
 
-指针可以随时改变指向，但是引用只能指向初始化时指向的对象，无法改变。
 
 ```
 int a = 1;
 int b = 2;
 
-int &r = a;    //初始化引用r指向变量a
-int *p = &a;   //初始化指针p指向变量a
+int &r = a;    //
+int *p = &a;   //
 
-p = &b;        //指针p指向了变量b
-r = b;         //引用r依然指向a，但a的值变成了b
+p = &b;        //
+r = b;         //引
 ```
 
-## 2.引用
+## 2.Reference
 
-#### 左值引用
+#### lvalue reference
 
-常规引用，一般表示对象的身份。
+General reference, which generally represents the identity of an object.
 
-#### 右值引用
 
-右值引用就是必须绑定到右值（一个临时对象、将要销毁的对象）的引用，一般表示对象的值。
+#### rvalue reference
 
-右值引用可实现转移语义（Move Sementics）和精确传递（Perfect Forwarding），它的主要目的有两个方面：
 
-- 消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率。
-- 能够更简洁明确地定义泛型函数。
 
-#### 引用折叠
+An R-value reference is a reference that must be bound to an R-value (a temporary object, an object to be destroyed), and generally represents the value of an object.
 
-- `X& &`、`X& &&`、`X&& &` 可折叠成 `X&`
-- `X&& &&` 可折叠成 `X&&`
 
-C++的引用**在减少了程序员自由度的同时提升了内存操作的安全性和语义的优美性**。比如引用强制要求必须初始化，可以让我们在使用引用的时候不用再去判断引用是否为空，让代码更加简洁优美，避免了指针满天飞的情形。除了这种场景之外引用还用于如下两个场景：
+An R-value reference is a reference that must be bound to an R-value (a temporary object, an object to be destroyed), and generally represents the value of an object.
 
-> 引用型参数
+- It eliminates unnecessary copy of objects when two objects interact, saves operation storage resources and improves efficiency
+- It can define generic functions more concisely and clearly
 
-一般我们使用const reference参数作为只读形参，这种情况下既可以避免参数拷贝还可以获得与传值参数一样的调用方式。
+#### Reference collapse
+
+- `X& &`、`X& &&`、`X&& &` can be folded into `X&`
+- `X&& &&` can be floded into `X&&`
+
+The reference of C ++ **At the same time, it improves the security of memory operation and the beauty of semantics**。For example, the mandatory requirement of reference must be initialized, so that we don't have to judge whether the reference is empty when using the reference, which makes the code more concise and elegant, and avoids the situation of pointer flying all over the sky. In addition to this scenario, references are used for the following two scenarios：
+
+> Reference type parameter
+
+In general, we use const reference parameter as a read-only formal parameter. In this case, we can not only avoid parameter copy, but also get the same call method as value passing parameter.
 
 ```c++
 void test(const vector<int> &data)
@@ -96,20 +102,20 @@ int main()
 }
 ```
 
-> 引用型返回值
+> Reference type return value
 
-C++提供了重载运算符的功能，我们在重载某些操作符的时候，使用引用型返回值可以获得跟该操作符原来语法相同的调用方式，保持了操作符语义的一致性。一个例子就是operator []操作符，这个操作符一般需要返回一个引用对象，才能正确的被修改。
+C++ Provides the ability to overload operators.The syntax of the overloaded operator is the same as that of the original operator.An example is the operator [] operator, which generally needs to return a reference object in order to be modified correctly.
 
 ```c++
 vector<int> v(10);
-v[5] = 10;    //[]操作符返回引用，然后vector对应元素才能被修改
-              //如果[]操作符不返回引用而是指针的话，赋值语句则需要这样写
-*v[5] = 10;   //这种书写方式，完全不符合我们对[]调用的认知，容易产生误解
+v[5] = 10;    //[]Operator returns the reference, and then the corresponding element of vector can be modified
+              //If[] operator do not return a reference but a pointer, the assignment statement needs to be written like this
+*v[5] = 10;   // This way of writing is totally inconsistent with our understanding of the call of [], which is easy to be misunderstood
 ```
 
-## 3.指针与引用的性能差距
+## 3.Performance gap between pointer and reference
 
-指针与引用之间有没有性能差距呢？这种问题就需要进入汇编层面去看一下。我们先写一个test1函数，参数传递使用指针：
+Is there a performance gap between pointers and references？This kind of problem needs to enter the assembly level to have a look. Let's first write a test1 function, which uses pointers for parameter passing：
 
 ```c++
 void test1(int* p)
@@ -119,7 +125,7 @@ void test1(int* p)
 }
 ```
 
-该代码段对应的汇编代码如下：
+The assembly code corresponding to this code segment is as follows：
 
 ```c++
 (gdb) disassemble 
@@ -136,9 +142,9 @@ 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。
+The above code lines 1 and 2 are the field operation of parameter calling and saving；The third line is parameter passing. The first parameter of the function call is usually placed in the RDI register. This line of code writes the RDI register value (the value of pointer P) to the stack；Line 4 writes the value of P in the stack to the rax register；Line 5 is to write the immediate number 3 to the**Memory pointed to by the value of the rax register**.
 
-我们再写出参数传递使用引用的C++代码段test2：
+Let's write out the reference C + + code segment test2 for parameter passing：
 
 ```c++
 void test2(int& r)
@@ -148,7 +154,7 @@ void test2(int& r)
 }
 ```
 
-这段代码对应的汇编代码如下：
+This code corresponds to the following assembly code：
 
 ```c++
 (gdb) disassemble 
@@ -165,10 +171,10 @@ End of assembler dump.
 
 ```
 
-我们发现test2对应的汇编代码和test1对应的汇编代码完全相同，这说明C++编译器在编译程序的时候将指针和引用编译成了完全一样的机器码。所以C++中的引用只是C++对指针操作的一个“语法糖”，在底层实现时C++编译器实现这两种操作的方法完全相同。
+We find that the assembly code corresponding to test2 is exactly the same as that of test1.This shows that the C + + compiler compiles the pointer and reference into exactly the same machine code when compiling the program. Therefore, the reference in C + + is just a "syntax sugar" of pointer operation in C ++，In the underlying implementation, the C + + compiler implements these two operations in the same way.
 
-## 3.总结
+## 3. Conclusion
 
-C++中引入了引用操作，在对引用的使用加了更多限制条件的情况下，保证了引用使用的安全性和便捷性，还可以保持代码的优雅性。在适合的情况使用适合的操作，引用的使用可以一定程度避免“指针满天飞”的情况，对于提升程序稳定性也有一定的积极意义。最后，指针与引用底层实现都是一样的，不用担心两者的性能差距。
+The introduction of reference operation in C + + ensures the security and convenience of reference use and maintains the elegance of code under the condition of adding more restrictions on the use of reference. The use of reference can avoid the situation of "pointer flying all over the sky" to a certain extent, and it has a positive significance to improve the stability of the program. Finally, the underlying implementations of pointers and references are the same, and there is no need to worry about the performance gap between them.
 
-上述部分参考自：<http://irootlee.com/juicer_pointer_reference/#>
+From：<http://irootlee.com/juicer_pointer_reference/#>

From c6c62199d7c45d33268688817b2b82311918450e Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Mon, 20 Jul 2020 15:34:39 +0800
Subject: [PATCH 38/62] Update README.md

---
 english/basic_content/pointer_refer/README.md | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/english/basic_content/pointer_refer/README.md b/english/basic_content/pointer_refer/README.md
index f5258a8..a9fd60f 100644
--- a/english/basic_content/pointer_refer/README.md
+++ b/english/basic_content/pointer_refer/README.md
@@ -1,8 +1,7 @@
-# 引用与指针那些事
+# Reference and Pointer
 
-## 关于作者：
+## About Author：
 
-：
 
 ![](../img/wechat.jpg)
 
@@ -149,7 +148,7 @@ Let's write out the reference C + + code segment test2 for parameter passing：
 ```c++
 void test2(int& r)
 {
-    r = 3;    //赋值前无需判断reference是否为空
+    r = 3;    // do not need to judge whether reference is null.
     return;
 }
 ```

From 03fc659f6581d6292b938755cde9635ea1017da6 Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Mon, 20 Jul 2020 15:38:43 +0800
Subject: [PATCH 39/62] Update README.md

---
 english/basic_content/pointer_refer/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/english/basic_content/pointer_refer/README.md b/english/basic_content/pointer_refer/README.md
index a9fd60f..a108e95 100644
--- a/english/basic_content/pointer_refer/README.md
+++ b/english/basic_content/pointer_refer/README.md
@@ -13,7 +13,7 @@ Conclusion：
 | ------------ | ------------              |
 | Must be initialized   | No initialization is allowed    |
 | cannot be empty     | could be empty     |
-| Target cannot be changed | 可以更换目标   |
+| Target cannot be changed | could change target   |
 
 > References must be initialized, and pointers can be uninitialized
 

From 671537426d8e5019533505d9c868bfc25e240a16 Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Mon, 20 Jul 2020 17:13:45 +0800
Subject: [PATCH 40/62] Update README.md

---
 english/basic_content/sizeof/README.md | 52 +++++++++++++-------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/english/basic_content/sizeof/README.md b/english/basic_content/sizeof/README.md
index 7cfdbc0..8d14741 100644
--- a/english/basic_content/sizeof/README.md
+++ b/english/basic_content/sizeof/README.md
@@ -1,20 +1,20 @@
-# 类大小计算
+# Class size calculation
 
-首先来个总结，然后下面给出实际例子，实战！
+First of all, let's make a summary, and then we will give an actual example
 
-- 空类的大小为1字节
-- 一个类中，虚函数本身、成员函数（包括静态与非静态）和静态数据成员都是不占用类对象的存储空间。
-- 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。
-- 普通继承，派生类继承了所有基类的函数与成员，要按照字节对齐来计算大小
-- 虚函数继承，不管是单继承还是多继承，都是继承了基类的vptr。(32位操作系统4字节，64位操作系统 8字节)！
-- 虚继承,继承基类的vptr。
+- The size of the empty class is 1 byte
+- In a class, the virtual function itself, member functions (including static and non-static) and static data members do not occupy the storage space of class objects
+- For classes containing virtual functions, no matter how many virtual functions there are, there is only one virtual pointer, the size of VPTR
+- Ordinary inheritance, derived class inherits all the functions and members of the base class, and the size is calculated according to byte alignment
+- Virtual function inheritance, whether single inheritance or multi inheritance, inherits the VPTR of the base class(32 bit operating system 4 bytes, 64 bit operating system 8 bytes)！
+- Virtual inheritance inherits the VPTR of the base class
 
-## 1.原则1
+## 1.Rule 1
 
 ```c++
 /**
  * @file blackclass.cpp
- * @brief 空类的大小为1字节
+ * @brief The size of the empty class is 1 byte
  * @author 光城
  * @version v1
  * @date 2019-07-21
@@ -29,13 +29,13 @@ int main()
 }
 ```
 
-## 2.原则2
+## 2.Rule 2
 
 ```c++
 /**
  * @file static.cpp
- * @brief 静态数据成员
- * 静态数据成员被编译器放在程序的一个global data members中，它是类的一个数据成员，但不影响类的大小。不管这个类产生了多少个实例，还是派生了多少新的类，静态数据成员只有一个实例。静态数据成员，一旦被声明，就已经存在。 
+ * @brief
+ * 
  * @author 光城
  * @version v1
  * @date 2019-07-21
@@ -55,20 +55,20 @@ class A
 int main()
 {
     /**
-     * @brief 16  字节对齐、静态变量不影响类的大小、vptr指针=8
+     * @brief 16 
      */
     cout<<sizeof(A)<<endl; 
     return 0;
 }
 ```
 
-## 3.原则3
+## 3.Rule 3
 
 ```c++
 /**
  * @file morevir.cpp
- * @brief 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。
- * @author 光城
+ * @brief 
+ * @author 
  * @version v1
  * @date 2019-07-21
  */
@@ -87,14 +87,14 @@ int main()
 }
 ```
 
-## 4.原则4与5
+## 4.Rule 4 and 5
 
 ```c++
 /**
  * @file geninhe.cpp
- * @brief 1.普通单继承,继承就是基类+派生类自身的大小(注意字节对齐)
- * 注意：类的数据成员按其声明顺序加入内存，与访问权限无关，只看声明顺序。
- * 2.虚单继承，派生类继承基类vptr
+ * @brief 
+ * 
+ * 
  * @author 光城
  * @version v1
  * @date 2019-07-21
@@ -112,7 +112,7 @@ class A
 };
 
 /**
- * @brief 此时B按照顺序：
+ * @brief 
  * char a
  * int b
  * short a
@@ -144,19 +144,19 @@ int main()
     cout<<sizeof(B)<<endl; // 24
     cout<<sizeof(C)<<endl; // 12
     /**
-     * @brief 对于虚单函数继承，派生类也继承了基类的vptr，所以是8字节
+     * @brief 
      */
     cout<<sizeof(C1)<<endl; // 8 
     return 0;
 }
 ```
 
-## 5.原则6
+## 5.Rule 6
 
 ```c++
 /**
  * @file virnhe.cpp
- * @brief 虚继承
+ * @brief 
  * @author 光城
  * @version v1
  * @date 2019-07-21
@@ -181,7 +181,7 @@ class C : virtual public  A, virtual public B
 int main()
 {
     /**
-     * @brief 8 8 16  派生类虚继承多个虚函数，会继承所有虚函数的vptr
+     * @brief 8 8 16  The derived class inherits multiple virtual functions and inherits the VPTR of all virtual functions
      */
     cout<<sizeof(A)<<" "<<sizeof(B)<<" "<<sizeof(C);
 

From f1da94e08ab70b1135292abdb996d20ebe1e4c33 Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Mon, 20 Jul 2020 18:31:47 +0800
Subject: [PATCH 41/62] Update README.md

---
 english/basic_content/static/README.md | 62 ++++++++++++--------------
 1 file changed, 29 insertions(+), 33 deletions(-)

diff --git a/english/basic_content/static/README.md b/english/basic_content/static/README.md
index 669eda9..8696264 100644
--- a/english/basic_content/static/README.md
+++ b/english/basic_content/static/README.md
@@ -1,24 +1,18 @@
-# static那些事
+# Story about static
 
-## 关于作者
+The static keyword has different meanings when used with different types. We can use the static keyword：
 
-微信公众号：
+**Static variable：** Variables in functions, variables in classes
 
-![](../img/wechat.jpg)
+**Members of a static class：** Class objects and functions in classes
 
-当与不同类型一起使用时，Static关键字具有不同的含义。我们可以使用static关键字：
+Now let's take a closer look at these static usages：
 
-**静态变量：** 函数中的变量，类中的变量
+**Static variable**
 
-**静态类的成员：** 类对象和类中的函数
+- Static variables in functions
 
-现在让我们详细看一下静态的这些用法：
-
-**静态变量**
-
-- 函数中的静态变量
-
-当变量声明为static时，空间**将在程序的生命周期内分配**。即使多次调用该函数，静态变量的空间也**只分配一次**，前一次调用中的变量值通过下一次函数调用传递。这对于在C / C ++或需要存储先前函数状态的任何其他应用程序非常有用。
+When the variable is declared static，space **Will be allocated over the life cycle of the program**。Even if the function is called multiple times, the space for the static variable is allocated**only once**，The value of the variable in the previous call is passed through the next function call. This is useful in C / C + + or any other application that needs to store the state of previous functions. 
 
 ```c++
 #include <iostream> 
@@ -45,17 +39,17 @@ int main()
 } 
 ```
 
-输出：
+Output：
 
 ```
 0 1 2 3 4 
 ```
 
-您可以在上面的程序中看到变量count被声明为static。因此，它的值通过函数调用来传递。每次调用函数时，都不会对变量计数进行初始化。
+You can see in the above program that the variable count is declared static.So, Its value is passed through a function call. The variable count is not initialized each time the function is called.
 
-- 类中的静态变量
+- Static variables in class
 
-由于声明为static的变量只被初始化一次，因为它们在单独的静态存储中分配了空间，因此类中的静态变量**由对象共享。**对于不同的对象，不能有相同静态变量的多个副本。也是因为这个原因，静态变量不能使用构造函数初始化。
+Because variables declared static are initialized only once，Because they allocate space in separate static storage。Therefore, static variables in a class are **shared by objects。**You cannot have multiple copies of the same static variable for different objects. For this reason, static variables cannot be initialized with constructors.
 
 ```c++
 
@@ -85,7 +79,8 @@ cout << obj1.i<<" "<<obj2.i;
 } 
 ```
 
-您可以在上面的程序中看到我们已经尝试为多个对象创建静态变量i的多个副本。但这并没有发生。因此，类中的静态变量应由用户使用类外的类名和范围解析运算符显式初始化，如下所示：
+You can see in the above program that we have tried to create multiple copies of static variable i for multiple objects. But it didn't happen.
+Therefore, static variables in a class should be explicitly initialized by the user using class names and range resolution operators outside the class, as shown below
 
 ```c++
 
@@ -113,19 +108,19 @@ int main()
 } 
 ```
 
-输出：
+Output：
 
 ```
 1
 ```
 
-**静态成员**
+**Static member**
 
-- 类对象为静态
+- Class objects are static
 
-就像变量一样，对象也在声明为static时具有范围，直到程序的生命周期。
+Just like variables, objects have scope when declared static until the life cycle of the program
 
-考虑以下程序，其中对象是非静态的。
+Consider the following program, where the object is non static
 
 ```c++
 #include<iostream> 
@@ -159,7 +154,7 @@ int main()
 ```
 
 
-输出：
+Output：
 
 ```c++
 Inside Constructor
@@ -167,8 +162,9 @@ Inside Destructor
 End of main
 ```
 
-在上面的程序中，对象在if块内声明为非静态。因此，变量的范围仅在if块内。因此，当创建对象时，将调用构造函数，并且在if块的控制权越过析构函数的同时调用，因为对象的范围仅在声明它的if块内。
-如果我们将对象声明为静态，现在让我们看看输出的变化。
+In the above program, the object is declared non static within the if block. Therefore, the scope of the variable is only within the if block. Therefore, when an object is created, the constructor is called, and is called when the control of the if block passes over the destructor, because the scope of the object is only within the if block in which it is declared.
+
+If we declare the object static, now let's look at the changes in the output.
 
 ```c++
 #include<iostream> 
@@ -202,7 +198,7 @@ int main()
 ```
 
 
-输出：
+Output：
 
 ```
 Inside Constructor
@@ -210,13 +206,13 @@ End of main
 Inside Destructor
 ```
 
-您可以清楚地看到输出的变化。现在，在main结束后调用析构函数。这是因为静态对象的范围是贯穿程序的生命周期。
+You can clearly see the output change. Now, call the destructor function after the end of main.This is because the scope of static objects is throughout the life cycle of the program.
 
-- 类中的静态函数
+- Static functions in class
 
-就像类中的静态数据成员或静态变量一样，静态成员函数也不依赖于类的对象。我们被允许使用对象和'.'来调用静态成员函数。但建议使用类名和范围解析运算符调用静态成员。
+Just like static data members or static variables in a class, Static member functions are also independent of class objects.We are allowed to use objects and "." to call static member functions. However, it is recommended to call static members using class names and range resolution operators.
 
-允许静态成员函数仅访问静态数据成员或其他静态成员函数，它们无法访问类的非静态数据成员或成员函数。
+Allows static member functions to access only static data members or other static member functions that cannot access non static data members or member functions of a class.
 
 ```c++
 #include<iostream> 
@@ -240,7 +236,7 @@ int main()
 } 
 ```
 
-输出：
+Output：
 
 ```
 Welcome to Apple!

From f8372b35d8e99e4fe3e614c28bb107634798b9ea Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Mon, 20 Jul 2020 19:03:46 +0800
Subject: [PATCH 42/62] Update README.md

---
 english/basic_content/struct/README.md | 72 +++++++++++++-------------
 1 file changed, 35 insertions(+), 37 deletions(-)

diff --git a/english/basic_content/struct/README.md b/english/basic_content/struct/README.md
index cea8af9..200c698 100644
--- a/english/basic_content/struct/README.md
+++ b/english/basic_content/struct/README.md
@@ -1,20 +1,18 @@
-# 一文搞懂C和C++中struct
+# Understand C and C + + struct
 
-## 关于作者：
 
-个人公众号：
 
 ![](../img/wechat.jpg)
 
-## 1.C中struct
+## 1.Struct In C
 
-- 在C中struct只单纯的用作数据的复合类型，也就是说，在结构体声明中只能将数据成员放在里面，而不能将函数放在里面。 
-- 在C结构体声明中不能使用C++访问修饰符，如：public、protected、private 而在C++中可以使用。
-- 在C中定义结构体变量，如果使用了下面定义必须加struct。
-- C的结构体不能继承（没有这一概念）。
-- 若结构体的名字与函数名相同，可以正常运行且正常的调用！例如：可以定义与 struct Base 不冲突的 void Base() {}。
+- In C, struct is only used as the composite type of data, that is, in the structure declaration, only data members can be placed inside, but not functions 
+- C + + access modifiers cannot be used in C structure declarations,such as：public、protected、private. But they can be used in C + +
+- Define the structure variable in C. If you use the following definition, you must add struct
+- The structure of C cannot be inherited (there is no such concept)
+- If the structure name is the same as the function name, it can run normally and call normally! For example, you can define void base() that does not conflict with struct base{}。
 
-完整案例：
+Example：
 
 ```c
 #include<stdio.h>
@@ -45,30 +43,30 @@ int main() {
 }
 ```
 
-最后输出：
+Finally Output：
 
 ```
 1
 I am Base func
 ```
 
-完整代码见：[struct_func.c](./struct_func.c)
+Code：[struct_func.c](./struct_func.c)
 
-## 2.C++中struct
+## 2.C++ struct
 
-与C对比如下：
+The comparison with C is as follows：
 
-- C++结构体中不仅可以定义数据，还可以定义函数。
-- C++结构体中可以使用访问修饰符，如：public、protected、private 。
-- C++结构体使用可以直接使用不带struct。
-- C++继承
-- 若结构体的名字与函数名相同，可以正常运行且正常的调用！但是定义结构体变量时候只用用带struct的！
+- In C + + structure, not only data can be defined, but also functions can be defined.
+- Access modifiers can be used in C + + structures, such as ：public、protected、private 。
+- C + + structure can be used directly without struct.
+- C + + inheritance
+- If the structure name is the same as the function name, it can run normally and call normally！However, when defining the structure variable, we only use the structure with struct！
 
-例如：
+Example：
 
-> 情形1：不适用typedef定义结构体别名
+> Case 1：
 
-未添加同名函数前：
+Before adding a function with the same name：
 
 ```c++
 struct Student {
@@ -79,7 +77,7 @@ Struct Student s; //ok
 Student s;  //ok
 ```
 
-添加同名函数后：
+After adding a function with the same name：
 
 ```c++
 struct Student {
@@ -90,7 +88,7 @@ Struct Student s; //ok
 Student s;  //error
 ```
 
-> 情形二：使用typedef定义结构体别名
+> Case 2：
 
 ```c++
 typedef struct Base1 {         
@@ -106,7 +104,7 @@ typedef struct Base1 {
 //void B() {}  //error! 符号 "B" 已经被定义为一个 "struct Base1" 的别名
 ```
 
-> 前三种案例
+> The first three cases
 
 ```c++
 #include<iostream>
@@ -136,9 +134,9 @@ int main() {
 }
 ```
 
-完整代码见：[struct_func.cpp](struct_func.cpp)
+Code ：[struct_func.cpp](struct_func.cpp)
 
-> 继承案例
+> Inheritance cases
 
 ```c++
 #include<iostream>
@@ -168,9 +166,9 @@ int main() {
 }
 ```
 
-完整代码见：[ext_struct_func.cpp](./ext_struct_func.cpp)
+Code：[ext_struct_func.cpp](./ext_struct_func.cpp)
 
-> 同名函数
+> Functions with the same name
 
 ```c++
 #include<iostream>
@@ -213,16 +211,16 @@ int main() {
     return 0;
 }
 ```
-完整代码见：[struct_func_func.cpp](./struct_func_func.cpp)
+Code：[struct_func_func.cpp](./struct_func_func.cpp)
 
-## 3.总结
+## 3.Conclusion
 
-### C和C++中的Struct区别
+### The difference of structure between C and C + +
 
 | C                                                      | C++                                                          |
 | ------------------------------------------------------ | ------------------------------------------------------------ |
-| 不能将函数放在结构体声明                               | 能将函数放在结构体声明                                       |
-| 在C结构体声明中不能使用C++访问修饰符。                 | public、protected、private 在C++中可以使用。                 |
-| 在C中定义结构体变量，如果使用了下面定义必须加struct。  | 可以不加struct                                               |
-| 结构体不能继承（没有这一概念）。                       | 可以继承                                                     |
-| 若结构体的名字与函数名相同，可以正常运行且正常的调用！ | 若结构体的名字与函数名相同，使用结构体，只能使用带struct定义！ |
+| You cannot place a function in a structure declaration | Function can be declared in structure                                       |
+| C + + access modifiers cannot be used in C structure declarations.            | public、protected、private They can be used in C + +                 |
+| Define the structure variable in C. If you use the following definition, you must add struct  | You can do without struct                            |
+|Not inheritance                       | you could use inheritance                                                     |
+| If the structure name is the same as the function name, it can run normally and call normally | If the structure name is the same as the function name, the structure can only be defined with struct |

From 4be086d0aa1183306ae579ea45ed37d61a4bf06f Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Mon, 20 Jul 2020 19:19:31 +0800
Subject: [PATCH 43/62] Update README.md

---
 english/basic_content/struct_class/README.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/english/basic_content/struct_class/README.md b/english/basic_content/struct_class/README.md
index 119e039..aeca0f5 100644
--- a/english/basic_content/struct_class/README.md
+++ b/english/basic_content/struct_class/README.md
@@ -1,19 +1,19 @@
-# struct与class区别
+# The difference struct and class
 
-## 关于作者：
 
-个人公众号：
 
 ![](../img/wechat.jpg)
 
-关于C与C++中struct内容：见[struct那些事](../struct)
+More detail about struct [Story about struct](../struct)
 
-总的来说，struct 更适合看成是一个数据结构的实现体，class 更适合看成是一个对象的实现体。
+Generally speaking, struct is more suitable to be regarded as an implementation body of data structure, and class is more suitable to be regarded as the implementation body of an object. 
 
-区别:
+Dif:
 
-最本质的一个区别就是默认的访问控制
+One of the essential differences is the default access control
 
-默认的继承访问权限。struct 是 public 的，class 是 private 的。
 
-struct 作为数据结构的实现体，它默认的数据访问控制是 public 的，而 class 作为对象的实现体，它默认的成员变量访问控制是 private 的。
+
+Default inherited access.Struct is public, while class is private.
+
+Structure as the implementation body of data structure.Its default data access control is public, while class is the implementation body of the object, and its default member variable access control is private.

From 41c131169200c91cf8e44e08f081be750bea7ba4 Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Mon, 20 Jul 2020 23:17:16 +0800
Subject: [PATCH 44/62] Update README.md

---
 english/basic_content/this/README.md | 36 +++++++++++++---------------
 1 file changed, 17 insertions(+), 19 deletions(-)

diff --git a/english/basic_content/this/README.md b/english/basic_content/this/README.md
index f950237..1ce99f3 100644
--- a/english/basic_content/this/README.md
+++ b/english/basic_content/this/README.md
@@ -1,30 +1,28 @@
-# this指针那些事
+# Story about this
 
-## 关于作者
+## About Author
 
-微信公众号：
 
 ![](../img/wechat.jpg)
 
-## 1.this指针
+## 1.This pointer
 
-相信在坐的很多人，都在学Python，对于Python来说有self，类比到C++中就是this指针，那么下面一起来深入分析this指针在类中的使用！
+I believe that many people sitting here are learning python. For Python, there is self. Analogy to C + + is this pointer. Let's analyze the use of this pointer in class.
 
-首先来谈谈this指针的用处：
+Let's first talk about the use of this pointer：
 
-（1）一个对象的this指针并不是对象本身的一部分，不会影响sizeof(对象)的结果。
+（1）This pointer to an object is not part of the object itself and does not affect the result of sizeof.
 
-（2）this作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说，即使你没有写上this指针，编译器在编译的时候也是加上this的，它作为非静态成员函数的隐含形参，对各成员的访问均通过this进行。
+（2）This scope is within the class. When accessing the non static members of the class in the non static member function of the class, the compiler will automatically pass the address of the object itself to the function as an implicit parameter. That is to say, even if you don't write this pointer, the compiler will add this when compiling. As the implicit formal parameter of non static member function, the access to each member is carried out through this.
 
-其次，this指针的使用：
+Second, the use of this pointer:
 
-（1）在类的非静态成员函数中返回类对象本身的时候，直接使用 return *this。
+（1）When the class object itself is returned in a class's non static member function, directly use return *this。
 
-（2）当参数与成员变量名相同时，如this->n = n （不能写成n = n)。
+（2）When the parameter is the same as the member variable name, 如this->n = n （不能写成n = n)。
 
-另外，在网上大家会看到this会被编译器解析成`A *const `，`A const * `，究竟是哪一个呢？下面通过断点调试分析：
 
-现有如下例子：
+The following examples are available:
 
 ```c++
 #include<iostream>
@@ -70,20 +68,20 @@ int main(){
 }
 ```
 
-对于这个简单的程序，相信大家没得问题吧，就是定义了一个类，然后初始化构造函数，并获取这个人的年龄，设置后，再获取！
 
-为了验证this指针是哪一个，现在在`add_age`处添加断点，运行后如下：
+In order to verify which this pointer is, now in 'Add'_ Add a breakpoint at "age". After running, it is as follows ：
 
 ![thiscontrust](./img/thiscontrust.png)
 
 ![genthis](./img/genthis.png)
 
-会发现编译器自动为我们加上`A* const`，而不是`A const *this`！
+You'll find that the compiler adds it to us automatically `A* const`，rather than `A const *this`！
 
-紧接着，上述还有个常函数，那么我们在对`get_age`添加断点，如下：
+Closely.There is also a constant function above，so we try to add a breakpoint at`get_age` as following：
 
 ![constthis](./img/constthis.png)
 
-会发现编译器把上述的this，变为`const A* const`，这个大家也能想到，因为这个函数是const函数，那么针对const函数，它只能访问const变量与const函数，不能修改其他变量的值，所以需要一个this指向不能修改的变量，那就是`const A*`,又由于本身this是`const`指针，所以就为`const A* const`!
+You'll find that the compiler takes the this，then it changed to`const A* const`. Because this is the const function，It can only access const variables and const functions
 
-总结：this在成员函数的开始执行前构造，在成员的执行结束后清除。上述的get_age函数会被解析成`get_age(const A * const this)`,`add_age`函数会被解析成`add_age(A* const this,int a)`。在C++中类和结构是只有一个区别的：类的成员默认是private，而结构是public。this是类的指针，如果换成结构，那this就是结构的指针了。
+，You cannot modify the values of other variables. So you need a this to point to a variable that cannot be modified，that is `const A*`,and because this is`const` pointer.
+Conclusion：This is constructed before the start of member function execution. Clear after member execution. Get above_ The age function is resolved to `get_age(const A * const this)`,`add_age`function will be paresed as `add_age(A* const this,int a)`. In C + +, there is only one difference between a class and a structure: the member of a class is private by default, while the structure is public. This is the pointer of the class. If it is replaced by a structure, this is the pointer of the structure.

From 282e93f21aa8591771a34c8b98e2f46925a60e8d Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Mon, 20 Jul 2020 23:54:33 +0800
Subject: [PATCH 45/62] Update README.md

---
 english/basic_content/union/README.md | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/english/basic_content/union/README.md b/english/basic_content/union/README.md
index 5421d42..337b429 100644
--- a/english/basic_content/union/README.md
+++ b/english/basic_content/union/README.md
@@ -1,18 +1,19 @@
-# UNION那些事
+# Story About Union
+
 
-## 关于作者：
 
-个人公众号：
 
 ![](../img/wechat.jpg)
 
-联合（union）是一种节省空间的特殊的类，一个 union 可以有多个数据成员，但是在任意时刻只有一个数据成员可以有值。当某个成员被赋值后其他成员变为未定义状态。联合有如下特点：
+（Union）is a space saving special class.A union can have multiple data members.However, only one data member can have a value at any time. When a member is assigned a value, other members become undefined.
+
+- The default access control character is public
+- It can contain constructors and destructors
+- Cannot contain a member of a reference type
+- Cannot inherit from other classes, cannot be a base class
+- Cannot contain virtual functions
+- Anonymous union can directly access union members in the scope of definition
+- Anonymous union cannot contain protected or private members
+- Global anonymous union must be static
+
 
-- 默认访问控制符为 public
-- 可以含有构造函数、析构函数
-- 不能含有引用类型的成员
-- 不能继承自其他类，不能作为基类
-- 不能含有虚函数
-- 匿名 union 在定义所在作用域可直接访问 union 成员
-- 匿名 union 不能包含 protected 成员或 private 成员
-- 全局匿名联合必须是静态（static）的

From 94b367df131c068be5e4a7fecf864e163081f79f Mon Sep 17 00:00:00 2001
From: xliu79 <31554245+xliu79@users.noreply.github.com>
Date: Tue, 21 Jul 2020 00:06:53 +0800
Subject: [PATCH 46/62] Update README.md

---
 english/basic_content/using/README.md | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/english/basic_content/using/README.md b/english/basic_content/using/README.md
index 1e50179..f5efec6 100644
--- a/english/basic_content/using/README.md
+++ b/english/basic_content/using/README.md
@@ -1,13 +1,12 @@
-# using那些事
-## 关于作者：
+# Story About using
+## About Author：
 
-个人公众号：
 
 ![](../img/wechat.jpg)
 
-## 基本使用
+## Basic use
 
-局部与全局using，具体操作与使用见下面案例：
+Local and global using. See the following cases for specific operation and use：
 
 ```c++
 #include <iostream>
@@ -28,9 +27,9 @@ namespace ns1 {
 
 namespace ns2 {
 #ifdef isNs1 
-    using ns1::func;    /// ns1中的函数
+    using ns1::func;    /// function in ns1
 #elif isGlobal
-    using ::func; /// 全局中的函数
+    using ::func; /// global function
 #else
     void func() 
     {
@@ -48,8 +47,8 @@ int main()
     return 0;
 }
 ```
-完整代码见：[using_global.cpp](using_global.cpp)
-## 改变访问性
+Code：[using_global.cpp](using_global.cpp)
+## Changing accessibility
 
 ```
 class Base{
@@ -67,7 +66,7 @@ protected:
 ```
 
 类Derived私有继承了Base，对于它来说成员变量n和成员函数size都是私有的，如果使用了using语句，可以改变他们的可访问性，如上述例子中，size可以按public的权限访问，n可以按protected的权限访问。
-完整代码见：[derived_base.cpp](derived_base.cpp)
+Code：[derived_base.cpp](derived_base.cpp)
 ## 函数重载
 
 在继承过程中，派生类可以覆盖重载函数的0个或多个实例，一旦定义了一个重载版本，那么其他的重载版本都会变为不可见。
@@ -107,9 +106,10 @@ int main()
 如上代码中，在派生类中使用using声明语句指定一个名字而不指定形参列表，所以一条基类成员函数的using声明语句就可以把该函数的所有重载实例添加到派生类的作用域中。此时，派生类只需要定义其特有的函数就行了，而无需为继承而来的其他函数重新定义。
 
 完整代码见：[using_derived.cpp](using_derived.cpp)
-## 取代typedef
+## Replace typedef
+
+The syntax of typedef a B is often used in C, which defines B as type A, that is, giving type a an alias B
 
-C中常用typedef A B这样的语法，将B定义为A类型，也就是给A类型一个别名B
 
 对应typedef A B，使用using B=A可以进行同样的操作。
 
@@ -117,4 +117,4 @@ C中常用typedef A B这样的语法，将B定义为A类型，也就是给A类
 typedef vector<int> V1; 
 using V2 = vector<int>;
 ```
-完整代码见：[using_typedef.cpp](using_typedef.cpp)
+Code：[using_typedef.cpp](using_typedef.cpp)

From 42f2b8c5b72f3de1018750bee75071b1b74d027b Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Tue, 21 Jul 2020 14:24:15 +0800
Subject: [PATCH 47/62] Create README1.md

---
 README1.md | 387 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 387 insertions(+)
 create mode 100644 README1.md

diff --git a/README1.md b/README1.md
new file mode 100644
index 0000000..dafd70d
--- /dev/null
+++ b/README1.md
@@ -0,0 +1,387 @@
+# C++ 那些事
+
+
+感谢各位对《C++ 那些事》的支持，现将内容也同步至网站，可以打开网站直接阅读~欢迎大家 star、转发、PR。
+
+[直通点](https://light-city.club/sc/)
+
+https://light-city.club/sc/
+
+
+### 关于作者
+
+公众号已开放两大入口，分别是专辑与菜单，可以直接在微信公众号上阅读《C++那些事》内容，配上该仓库的代码，将会非常的爽，建议大家关注一波。
+
+个人公众号：guangcity
+
+![](https://light-city.club/sc/assets/images/wechat.jpg)
+
+欢迎大家反馈及C++交流，本人在微信创建了C++那些事交流群，优质的C++资源交流区，期待大家关注上面公众号，点击公众号右下角->联系我，拉你入群。
+
+---
+
+
+
+### 项目运行
+
+- **代码环境**
+
+  Ubuntu 18.04
+
+- **工具**
+
+  CLion  gcc/g++
+
+尽量用g++，因为一开始我用的vim写的，所以纯g++，后来用编译器CLion，部分有CMakeLists.txt文件，直接导入就行，后面会更新这个文件包含整个项目，持续关注~
+
+### 0.项目概要
+
+- 中文名：**C++ 那些事**
+- 英文名：**Stories About C Plus Plus**
+
+这是一个适合初学者从<u>**入门到进阶**</u>的仓库，解决了<u>**面试者与学习者**</u>想要<u>**深入 C++**</u>及如何<u>**入坑 C++**</u>的问题。除此之外，本仓库拓展了更加深入的源码分析，多线程并发等的知识，是一个比较全面的 C++ 学习从入门到进阶提升的仓库。
+
+### 1.基础进阶
+
+- [const 那些事](./basic_content/const)
+- [static 那些事](./basic_content/static)
+- [this 那些事](./basic_content/this)
+- [inline 那些事](./basic_content/inline)
+- [sizeof 那些事](./basic_content/sizeof)
+- [函数指针那些事](./basic_content/func_pointer)
+- [纯虚函数和抽象类那些事](./basic_content/abstract)
+- [vptr_vtable 那些事](./basic_content/vptr_vtable)
+- [virtual 那些事](./basic_content/virtual)
+- [volatile 那些事](./basic_content/volatile)
+- [assert 那些事](./basic_content/assert)
+- [位域那些事](./basic_content/bit)
+- [extern 那些事](./basic_content/extern)
+- [struct 那些事](./basic_content/struct)
+- [struct 与 class 那些事](./basic_content/struct_class)
+- [union 那些事](./basic_content/union)
+- [c 实现 c++ 多态那些事](./basic_content/c_poly)
+- [explicit 那些事](./basic_content/explicit)
+- [friend 那些事](./basic_content/friend)
+- [using 那些事](./basic_content/using)
+- [:: 那些事](./basic_content/maohao)
+- [enum 那些事](./basic_content/enum)
+- [decltype 那些事](./basic_content/decltype)
+- [引用与指针那些事](./basic_content/pointer_refer)
+- [宏那些事](./basic_content/macro)
+
+### 2.实战系列
+
+#### 2.1 [10日狂练](./practical_exercises/10_day_practice)
+
+- [x] [day1](practical_exercises/10_day_practice/day1)
+
+基本c++语法
+
+- [x] [day2](practical_exercises/10_day_practice/day2)
+
+递归、结构体、枚举、静态变量等
+
+- [x] [day3](practical_exercises/10_day_practice/day3)
+
+函数
+
+- [x] [day4](practical_exercises/10_day_practice/day4)
+
+函数深入
+
+- [x] [day5](practical_exercises/10_day_practice/day5)
+
+继承多态
+
+- [x] [day6](practical_exercises/10_day_practice/day6)
+
+虚函数、抽象类
+
+- [x] [day7](practical_exercises/10_day_practice/day7)
+
+运算符重载
+
+- [x] [day8](practical_exercises/10_day_practice/day8)
+
+模板与STL
+
+- [x] [day9](practical_exercises/10_day_practice/day9)
+
+异常
+
+- [x] [day10](practical_exercises/10_day_practice/day10)
+
+文件与流
+
+#### 2.2 [重点实战练习](./practical_exercises/key_exercises/)
+
+├── [中括号重载.cpp](./practical_exercises/key_exercises/中括号重载.cpp)
+├── [时钟++运算符重载.cpp](./practical_exercises/key_exercises/时钟++运算符重载.cpp)
+├── [运算符重载之强制转换.cpp](./practical_exercises/key_exercises/运算符重载之强制转换.cpp)
+└── [重载圆括号的时钟.cpp](./practical_exercises/key_exercises/重载圆括号的时钟.cpp)
+
+├── [函数模板.cpp](./practical_exercises/key_exercises/函数模板.cpp)
+
+├── [动态数组.cpp](./practical_exercises/key_exercises/动态数组.cpp)
+
+├── [字典插入与查找.cpp](./practical_exercises/key_exercises/字典插入与查找.cpp)
+
+├── [异常捕获.cpp](./practical_exercises/key_exercises/异常捕获.cpp)
+
+├── [类模板之栈.cpp](./practical_exercises/key_exercises/类模板之栈.cpp)
+
+├── [类模板特化之数组.cpp](./practical_exercises/key_exercises/类模板特化之数组.cpp)
+
+├── [继承与封装.cpp](./practical_exercises/key_exercises/继承与封装.cpp)
+
+├── [读写文件综合题.cpp](./practical_exercises/key_exercises/读写文件综合题.cpp)
+├── [输入输出运算符重载.cpp](./practical_exercises/key_exercises/输入输出运算符重载.cpp)
+├── [输入输出重载.cpp](./practical_exercises/key_exercises/输入输出重载.cpp)
+├── [输出格式.cpp](./practical_exercises/key_exercises/输出格式.cpp)
+
+### 3.[C++2.0 新特性](./c++2.0)
+
+#### 3.0 概况
+
+C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
+
+#### 3.1 [C++11 新特性](./c++2.0/c++11)
+
+- [Variadic Templates](./c++2.0/variadic)
+
+- Spaces in Template Expressions
+
+  ```cpp
+  vector<list<int> > //ok in each C++ version
+  vector<list<int>> // before c++ 11 error error: ‘>>’ should be ‘> >’ within a nested template argument list,c++11后可以正常通过
+  ```
+
+- [nullptr and nullptr_t](./c++2.0/nullptr.cpp)
+
+- [Automatic Type Deduction with auto](./c++2.0/auto.cpp)
+
+- [Uniform Initialization ](./c++2.0/uniform_initialization.cpp)
+
+- [initializer_list](./c++2.0/initializer.cpp)
+
+- [explicit for ctors taking more than one argument](./c++2.0/explicit.cpp)
+
+- [range-based for statement](./c++2.0/auto.cpp)
+
+  ```cpp
+  for(decl:col) {
+      statement
+  }
+  ```
+
+- [=default,=delete](./c++2.0/default_delete.cpp)
+
+  如果你自行定义了一个 ctor,那么编译器就不会给你一个 default ctor
+  如果强制加上 =default,就可以重新获得并使用 default ctor.
+
+- Alias(化名)Template(template typedef)
+
+  - [alias.cpp](./c++2.0/alias.cpp) 
+  - [template_template.cpp](./c++2.0/template_template.cpp)
+
+- [template template parameter](./c++2.0/template_template.cpp)
+
+- [type alias](./c++2.0/type_alias.cpp)
+
+- [noexcept](./c++2.0/noexcept.cpp)
+
+- [override](./c++2.0/override.cpp)
+
+- [final](./c++2.0/final.cpp)
+
+- [decltype](./c++2.0/decltype.cpp)
+
+- [lambda](./c++2.0/lambda.cpp)
+
+- [Rvalue reference](./c++2.0/rvalue.cpp)
+
+- [move aware class](./c++2.0/move.cpp)
+
+- 容器-结构与分类
+
+  - (1) 序列式容器包括：`array`(C++2.0 新引入),`vector`,`deque`,`list`,`forward_list`(C++2.0 新引入)
+  - (2) 关联式容器包括：`set/multiset`,`map/multimap`
+  - (3) 无序容器(C++2.0 新引入,更换原先 `hash_xxx` 为 `unordered_xxx`)包括：`unordered_map/unordered_multimap,unordered_set/unordered_multiset`
+
+- [Hash Function](./c++2.0/hash.cpp)
+
+- [tuple](./c++2.0/tuple.cpp)
+
+  学习资料：https://www.bilibili.com/video/av51863195?from=search&seid=3610634846288253061
+
+#### 3.2 C++14/17/20
+
+待更新...
+
+### 4.设计模式
+
+- [单例模式](./design_pattern/singleton)
+- [生产消费者模式](./design_pattern/producer_consumer)
+
+### 5. [STL 源码剖析](./src_analysis/stl)
+
+**STL 源码剖析：gcc 4.9.1**
+
+- [array](./src_analysis/stl/array.md)
+- [deque](./src_analysis/stl/deque.md)
+- [queue and stack](./src_analysis/stl/queue_stack.md)
+- [list](./src_analysis/stl/list.md)
+- [vector](./src_analysis/stl/vector.md)
+- [typename](./src_analysis/stl/typename.md)
+- [traits](./src_analysis/stl/traits.md)
+- [iterator](./src_analysis/stl/iterator.md)
+- [谈谈 STL 设计之 EBO 优化](./src_analysis/stl/谈谈STL设计之EBO优化.md)
+- [rb_tree](./src_analysis/stl/rb_tree.md)
+- [set and multiset](set_multiset.md)
+- [map and multimap](./src_analysis/stl/map_multimap.md)
+- [hashtable](./src_analysis/stl/hashtable.md)
+- [myhashtable](./src_analysis/stl/myhashtable.md)
+- [unordered_map](./src_analysis/stl/unordered_map.md)
+
+### 6. [并发编程](./concurrency)
+
+#### 6.1 C++ Concurrency in Action
+
+- [第一章](./concurrency/concurrency_v1/chapter1)
+- [第二章](./concurrency/concurrency_v1/chapter2)
+
+学习资料：https://chenxiaowei.gitbook.io/cpp_concurrency_in_action/
+
+#### 6.2 多线程与多进程
+
+##### 6.2.1 Threading In C++
+
+- [介绍](./concurrency/Threading_In_CPlusPlus/1.thread)
+- [创建线程的五种类型](./concurrency/Threading_In_CPlusPlus/2.create_type)
+- [Join 与 Detachs](./concurrency/Threading_In_CPlusPlus/3.join_detach)
+- [mutex in C++ Threading](./concurrency/Threading_In_CPlusPlus/4.mutex)
+
+> 学习自：
+>
+> https://www.youtube.com/watch?v=eZ8yKZo-PGw&list=PLk6CEY9XxSIAeK-EAh3hB4fgNvYkYmghp&index=4
+
+### 7. [C++ 惯用法](./codingStyleIdioms)
+
+##### 你最喜欢的 c++ 编程风格惯用法是什么?
+
+- [1.类初始化列表](./codingStyleIdioms/1_classInitializers)
+- [2.枚举类替换命名空间](./codingStyleIdioms/2_enumclass_namespace)
+- [3.RAII(资源获取即初始化)](./codingStyleIdioms/3_RAII)
+- [4.copy and swap](./codingStyleIdioms/4_copy-swap)
+- [5.pImpl(指针指向具体实现)](./codingStyleIdioms/5_pImpl)
+
+### 8.学习课程
+
+#### 8.1 [极客时间《现代 C++ 实战 30 讲》](https://time.geekbang.org/channel/home)
+
+- [堆、栈、RAII：C++ 里该如何管理资源？](./learn_class/modern_C++_30/RAII)
+  - [堆](./modern_++_30/RAII/heap.cpp)
+  - [栈](./learn_class/modern_C++_30/RAII/stack.cpp)
+  - [RAII](./learn_class/modern_C++_30/RAII/RAII.cpp)
+- [自己动手，实现 C++ 的智能指针](./learn_class/modern_C++_30/smart_ptr)
+  - [auto_ptr、scope_ptr](./learn_class/modern_C++_30/smart_ptr/auto_scope.cpp)
+  - [unique_ptr](./learn_class/modern_C++_30/smart_ptr/unique_ptr.cpp)
+  - [shared_ptr](./learn_class/modern_C++_30/smart_ptr/shared_ptr.cpp)
+- [右值和移动究竟解决了什么问题？](./learn_class/modern_C++_30/reference)
+  - [左值与右值](./learn_class/modern_C++_30/reference/reference.cpp)
+  - [延长声明周期](./learn_class/modern_C++_30/reference/lifetime.cpp)
+  - [引用折叠](./learn_class/modern_C++_30/reference/collapses.cpp)
+  - [完美转发](./learn_class/modern_C++_30/reference/forward.cpp)
+  - [不要返回本地变量的引用](./learn_class/modern_C++_30/reference/don'treturnReference.cpp)
+- [容器 1](./learn_class/modern_C++_30/container1)
+- [容器 2](./learn_class/modern_C++_30/container2)
+- [异常](./learn_class/modern_C++_30/exception)
+- [字面量、静态断言和成员函数说明符](./learn_class/modern_C++_30/literalAssert)
+- [是不是应该返回对象？](./learn_class/modern_C++_30/returnObj)
+- [编译期多态：泛型编程和模板入门](./learn_class/modern_C++_30/compilerpoly)
+- [译期能做些什么？一个完整的计算世界](./learn_class/modern_C++_30/compilercompute)
+- [SFINAE：不是错误的替换失败是怎么回事?](./learn_class/modern_C++_30/SFINAE)
+- [constexpr：一个常态的世界](./learn_class/modern_C++_30/constexpr)
+- [函数对象和 lambda：进入函数式编程](./learn_class/modern_C++_30/functionLambda)
+- [内存模型和 atomic：理解并发的复杂性](./learn_class/modern_C++_30/memorymodel_atomic)
+
+### 9.工具篇
+
+#### 9.1 [容器快捷输出工具](./tool/output)
+
+对吴老师的代码进行了修改，[点击此处直通代码](./tool/output/output_container.h)
+
+输入：
+
+```cpp
+map<int, int> mp{
+            {1, 1},
+            {2, 4},
+            {3, 9}};
+    cout << mp << endl;
+```
+
+输出结果显示：
+
+```cpp
+{ 1 => 1, 2 => 4, 3 => 9 }
+```
+
+#### 9.2 像 Python 一样简单输出（Jupyter Notebook）
+
+- [像 Python 一样玩 C/C++](./tool/像Python一样玩CC++.md)
+
+#### 9.3 观察编译过程变化
+
+-  [https://cppinsights.io](https://cppinsights.io/)
+
+#### 9.4 C++ 的 Debug 工具 dbg-macro
+
+- [C++ 的 Debug 工具 dbg-macro](./tool/C++的Debug工具dbg-macro.md)
+
+### 10.拓展部分
+
+#### 10.1 一些问题
+
+- [C++ 中如何将 string 类型转换为 int 类型？](./extension/some_problem/string_int.md)
+
+### 11.贡献者
+
+<table>
+  <tbody>
+    <tr>
+      <th align="center" style="width: 80px;">
+        <a href="https://github.com/Light-City">
+          <img src="https://avatars2.githubusercontent.com/u/25699850?s=50&v=4" style="width: 50px;"><br>
+          <sub>Francis</sub>
+        </a><br>
+      </th>
+      <th align="center" style="width: 80px;">
+        <a href="https://github.com/ChungZH">
+          <img src="https://avatars1.githubusercontent.com/u/42088872?s=50&v=4" style="width: 50px;"><br>
+          <sub>ChungZH</sub>
+        </a><br>
+      </th>
+    </tr>
+  </tbody>
+</table>
+
+### 12.赞助我
+
+如果觉得不错，赞助我吧~
+
+<table>
+  <tbody>
+    <tr>
+      <th align="center" style="height=200 width="200">
+          <img src="https://light-city.club/sc/assets/images/alipay.jpg" height="200" width="200" ><br>
+          支付宝
+      </th>
+      <th align="center" style="height=200 width="200">
+          <img src="https://light-city.club/sc/assets/images/wechat.png" height="200" width="200" ><br>
+          微信
+      </th>
+    </tr>
+  </tbody>
+</table>
+

From 2210beb6f5a96f2cde2f389e8f73131ed5d13786 Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Tue, 21 Jul 2020 14:24:43 +0800
Subject: [PATCH 48/62] Rename README.md to README_EN.md

---
 README.md => README_EN.md | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename README.md => README_EN.md (100%)

diff --git a/README.md b/README_EN.md
similarity index 100%
rename from README.md
rename to README_EN.md

From c286a16d099478323bcc8959d3db561cf4eed67d Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Tue, 21 Jul 2020 14:25:26 +0800
Subject: [PATCH 49/62] Rename README.md~ to README.md

---
 README.md~ => README.md | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename README.md~ => README.md (100%)

diff --git a/README.md~ b/README.md
similarity index 100%
rename from README.md~
rename to README.md

From 8293b95b7c2f289cc45b8c3e60527fa4685de0c4 Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Tue, 21 Jul 2020 14:25:48 +0800
Subject: [PATCH 50/62] Delete README1.md

---
 README1.md | 387 -----------------------------------------------------
 1 file changed, 387 deletions(-)
 delete mode 100644 README1.md

diff --git a/README1.md b/README1.md
deleted file mode 100644
index dafd70d..0000000
--- a/README1.md
+++ /dev/null
@@ -1,387 +0,0 @@
-# C++ 那些事
-
-
-感谢各位对《C++ 那些事》的支持，现将内容也同步至网站，可以打开网站直接阅读~欢迎大家 star、转发、PR。
-
-[直通点](https://light-city.club/sc/)
-
-https://light-city.club/sc/
-
-
-### 关于作者
-
-公众号已开放两大入口，分别是专辑与菜单，可以直接在微信公众号上阅读《C++那些事》内容，配上该仓库的代码，将会非常的爽，建议大家关注一波。
-
-个人公众号：guangcity
-
-![](https://light-city.club/sc/assets/images/wechat.jpg)
-
-欢迎大家反馈及C++交流，本人在微信创建了C++那些事交流群，优质的C++资源交流区，期待大家关注上面公众号，点击公众号右下角->联系我，拉你入群。
-
----
-
-
-
-### 项目运行
-
-- **代码环境**
-
-  Ubuntu 18.04
-
-- **工具**
-
-  CLion  gcc/g++
-
-尽量用g++，因为一开始我用的vim写的，所以纯g++，后来用编译器CLion，部分有CMakeLists.txt文件，直接导入就行，后面会更新这个文件包含整个项目，持续关注~
-
-### 0.项目概要
-
-- 中文名：**C++ 那些事**
-- 英文名：**Stories About C Plus Plus**
-
-这是一个适合初学者从<u>**入门到进阶**</u>的仓库，解决了<u>**面试者与学习者**</u>想要<u>**深入 C++**</u>及如何<u>**入坑 C++**</u>的问题。除此之外，本仓库拓展了更加深入的源码分析，多线程并发等的知识，是一个比较全面的 C++ 学习从入门到进阶提升的仓库。
-
-### 1.基础进阶
-
-- [const 那些事](./basic_content/const)
-- [static 那些事](./basic_content/static)
-- [this 那些事](./basic_content/this)
-- [inline 那些事](./basic_content/inline)
-- [sizeof 那些事](./basic_content/sizeof)
-- [函数指针那些事](./basic_content/func_pointer)
-- [纯虚函数和抽象类那些事](./basic_content/abstract)
-- [vptr_vtable 那些事](./basic_content/vptr_vtable)
-- [virtual 那些事](./basic_content/virtual)
-- [volatile 那些事](./basic_content/volatile)
-- [assert 那些事](./basic_content/assert)
-- [位域那些事](./basic_content/bit)
-- [extern 那些事](./basic_content/extern)
-- [struct 那些事](./basic_content/struct)
-- [struct 与 class 那些事](./basic_content/struct_class)
-- [union 那些事](./basic_content/union)
-- [c 实现 c++ 多态那些事](./basic_content/c_poly)
-- [explicit 那些事](./basic_content/explicit)
-- [friend 那些事](./basic_content/friend)
-- [using 那些事](./basic_content/using)
-- [:: 那些事](./basic_content/maohao)
-- [enum 那些事](./basic_content/enum)
-- [decltype 那些事](./basic_content/decltype)
-- [引用与指针那些事](./basic_content/pointer_refer)
-- [宏那些事](./basic_content/macro)
-
-### 2.实战系列
-
-#### 2.1 [10日狂练](./practical_exercises/10_day_practice)
-
-- [x] [day1](practical_exercises/10_day_practice/day1)
-
-基本c++语法
-
-- [x] [day2](practical_exercises/10_day_practice/day2)
-
-递归、结构体、枚举、静态变量等
-
-- [x] [day3](practical_exercises/10_day_practice/day3)
-
-函数
-
-- [x] [day4](practical_exercises/10_day_practice/day4)
-
-函数深入
-
-- [x] [day5](practical_exercises/10_day_practice/day5)
-
-继承多态
-
-- [x] [day6](practical_exercises/10_day_practice/day6)
-
-虚函数、抽象类
-
-- [x] [day7](practical_exercises/10_day_practice/day7)
-
-运算符重载
-
-- [x] [day8](practical_exercises/10_day_practice/day8)
-
-模板与STL
-
-- [x] [day9](practical_exercises/10_day_practice/day9)
-
-异常
-
-- [x] [day10](practical_exercises/10_day_practice/day10)
-
-文件与流
-
-#### 2.2 [重点实战练习](./practical_exercises/key_exercises/)
-
-├── [中括号重载.cpp](./practical_exercises/key_exercises/中括号重载.cpp)
-├── [时钟++运算符重载.cpp](./practical_exercises/key_exercises/时钟++运算符重载.cpp)
-├── [运算符重载之强制转换.cpp](./practical_exercises/key_exercises/运算符重载之强制转换.cpp)
-└── [重载圆括号的时钟.cpp](./practical_exercises/key_exercises/重载圆括号的时钟.cpp)
-
-├── [函数模板.cpp](./practical_exercises/key_exercises/函数模板.cpp)
-
-├── [动态数组.cpp](./practical_exercises/key_exercises/动态数组.cpp)
-
-├── [字典插入与查找.cpp](./practical_exercises/key_exercises/字典插入与查找.cpp)
-
-├── [异常捕获.cpp](./practical_exercises/key_exercises/异常捕获.cpp)
-
-├── [类模板之栈.cpp](./practical_exercises/key_exercises/类模板之栈.cpp)
-
-├── [类模板特化之数组.cpp](./practical_exercises/key_exercises/类模板特化之数组.cpp)
-
-├── [继承与封装.cpp](./practical_exercises/key_exercises/继承与封装.cpp)
-
-├── [读写文件综合题.cpp](./practical_exercises/key_exercises/读写文件综合题.cpp)
-├── [输入输出运算符重载.cpp](./practical_exercises/key_exercises/输入输出运算符重载.cpp)
-├── [输入输出重载.cpp](./practical_exercises/key_exercises/输入输出重载.cpp)
-├── [输出格式.cpp](./practical_exercises/key_exercises/输出格式.cpp)
-
-### 3.[C++2.0 新特性](./c++2.0)
-
-#### 3.0 概况
-
-C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
-
-#### 3.1 [C++11 新特性](./c++2.0/c++11)
-
-- [Variadic Templates](./c++2.0/variadic)
-
-- Spaces in Template Expressions
-
-  ```cpp
-  vector<list<int> > //ok in each C++ version
-  vector<list<int>> // before c++ 11 error error: ‘>>’ should be ‘> >’ within a nested template argument list,c++11后可以正常通过
-  ```
-
-- [nullptr and nullptr_t](./c++2.0/nullptr.cpp)
-
-- [Automatic Type Deduction with auto](./c++2.0/auto.cpp)
-
-- [Uniform Initialization ](./c++2.0/uniform_initialization.cpp)
-
-- [initializer_list](./c++2.0/initializer.cpp)
-
-- [explicit for ctors taking more than one argument](./c++2.0/explicit.cpp)
-
-- [range-based for statement](./c++2.0/auto.cpp)
-
-  ```cpp
-  for(decl:col) {
-      statement
-  }
-  ```
-
-- [=default,=delete](./c++2.0/default_delete.cpp)
-
-  如果你自行定义了一个 ctor,那么编译器就不会给你一个 default ctor
-  如果强制加上 =default,就可以重新获得并使用 default ctor.
-
-- Alias(化名)Template(template typedef)
-
-  - [alias.cpp](./c++2.0/alias.cpp) 
-  - [template_template.cpp](./c++2.0/template_template.cpp)
-
-- [template template parameter](./c++2.0/template_template.cpp)
-
-- [type alias](./c++2.0/type_alias.cpp)
-
-- [noexcept](./c++2.0/noexcept.cpp)
-
-- [override](./c++2.0/override.cpp)
-
-- [final](./c++2.0/final.cpp)
-
-- [decltype](./c++2.0/decltype.cpp)
-
-- [lambda](./c++2.0/lambda.cpp)
-
-- [Rvalue reference](./c++2.0/rvalue.cpp)
-
-- [move aware class](./c++2.0/move.cpp)
-
-- 容器-结构与分类
-
-  - (1) 序列式容器包括：`array`(C++2.0 新引入),`vector`,`deque`,`list`,`forward_list`(C++2.0 新引入)
-  - (2) 关联式容器包括：`set/multiset`,`map/multimap`
-  - (3) 无序容器(C++2.0 新引入,更换原先 `hash_xxx` 为 `unordered_xxx`)包括：`unordered_map/unordered_multimap,unordered_set/unordered_multiset`
-
-- [Hash Function](./c++2.0/hash.cpp)
-
-- [tuple](./c++2.0/tuple.cpp)
-
-  学习资料：https://www.bilibili.com/video/av51863195?from=search&seid=3610634846288253061
-
-#### 3.2 C++14/17/20
-
-待更新...
-
-### 4.设计模式
-
-- [单例模式](./design_pattern/singleton)
-- [生产消费者模式](./design_pattern/producer_consumer)
-
-### 5. [STL 源码剖析](./src_analysis/stl)
-
-**STL 源码剖析：gcc 4.9.1**
-
-- [array](./src_analysis/stl/array.md)
-- [deque](./src_analysis/stl/deque.md)
-- [queue and stack](./src_analysis/stl/queue_stack.md)
-- [list](./src_analysis/stl/list.md)
-- [vector](./src_analysis/stl/vector.md)
-- [typename](./src_analysis/stl/typename.md)
-- [traits](./src_analysis/stl/traits.md)
-- [iterator](./src_analysis/stl/iterator.md)
-- [谈谈 STL 设计之 EBO 优化](./src_analysis/stl/谈谈STL设计之EBO优化.md)
-- [rb_tree](./src_analysis/stl/rb_tree.md)
-- [set and multiset](set_multiset.md)
-- [map and multimap](./src_analysis/stl/map_multimap.md)
-- [hashtable](./src_analysis/stl/hashtable.md)
-- [myhashtable](./src_analysis/stl/myhashtable.md)
-- [unordered_map](./src_analysis/stl/unordered_map.md)
-
-### 6. [并发编程](./concurrency)
-
-#### 6.1 C++ Concurrency in Action
-
-- [第一章](./concurrency/concurrency_v1/chapter1)
-- [第二章](./concurrency/concurrency_v1/chapter2)
-
-学习资料：https://chenxiaowei.gitbook.io/cpp_concurrency_in_action/
-
-#### 6.2 多线程与多进程
-
-##### 6.2.1 Threading In C++
-
-- [介绍](./concurrency/Threading_In_CPlusPlus/1.thread)
-- [创建线程的五种类型](./concurrency/Threading_In_CPlusPlus/2.create_type)
-- [Join 与 Detachs](./concurrency/Threading_In_CPlusPlus/3.join_detach)
-- [mutex in C++ Threading](./concurrency/Threading_In_CPlusPlus/4.mutex)
-
-> 学习自：
->
-> https://www.youtube.com/watch?v=eZ8yKZo-PGw&list=PLk6CEY9XxSIAeK-EAh3hB4fgNvYkYmghp&index=4
-
-### 7. [C++ 惯用法](./codingStyleIdioms)
-
-##### 你最喜欢的 c++ 编程风格惯用法是什么?
-
-- [1.类初始化列表](./codingStyleIdioms/1_classInitializers)
-- [2.枚举类替换命名空间](./codingStyleIdioms/2_enumclass_namespace)
-- [3.RAII(资源获取即初始化)](./codingStyleIdioms/3_RAII)
-- [4.copy and swap](./codingStyleIdioms/4_copy-swap)
-- [5.pImpl(指针指向具体实现)](./codingStyleIdioms/5_pImpl)
-
-### 8.学习课程
-
-#### 8.1 [极客时间《现代 C++ 实战 30 讲》](https://time.geekbang.org/channel/home)
-
-- [堆、栈、RAII：C++ 里该如何管理资源？](./learn_class/modern_C++_30/RAII)
-  - [堆](./modern_++_30/RAII/heap.cpp)
-  - [栈](./learn_class/modern_C++_30/RAII/stack.cpp)
-  - [RAII](./learn_class/modern_C++_30/RAII/RAII.cpp)
-- [自己动手，实现 C++ 的智能指针](./learn_class/modern_C++_30/smart_ptr)
-  - [auto_ptr、scope_ptr](./learn_class/modern_C++_30/smart_ptr/auto_scope.cpp)
-  - [unique_ptr](./learn_class/modern_C++_30/smart_ptr/unique_ptr.cpp)
-  - [shared_ptr](./learn_class/modern_C++_30/smart_ptr/shared_ptr.cpp)
-- [右值和移动究竟解决了什么问题？](./learn_class/modern_C++_30/reference)
-  - [左值与右值](./learn_class/modern_C++_30/reference/reference.cpp)
-  - [延长声明周期](./learn_class/modern_C++_30/reference/lifetime.cpp)
-  - [引用折叠](./learn_class/modern_C++_30/reference/collapses.cpp)
-  - [完美转发](./learn_class/modern_C++_30/reference/forward.cpp)
-  - [不要返回本地变量的引用](./learn_class/modern_C++_30/reference/don'treturnReference.cpp)
-- [容器 1](./learn_class/modern_C++_30/container1)
-- [容器 2](./learn_class/modern_C++_30/container2)
-- [异常](./learn_class/modern_C++_30/exception)
-- [字面量、静态断言和成员函数说明符](./learn_class/modern_C++_30/literalAssert)
-- [是不是应该返回对象？](./learn_class/modern_C++_30/returnObj)
-- [编译期多态：泛型编程和模板入门](./learn_class/modern_C++_30/compilerpoly)
-- [译期能做些什么？一个完整的计算世界](./learn_class/modern_C++_30/compilercompute)
-- [SFINAE：不是错误的替换失败是怎么回事?](./learn_class/modern_C++_30/SFINAE)
-- [constexpr：一个常态的世界](./learn_class/modern_C++_30/constexpr)
-- [函数对象和 lambda：进入函数式编程](./learn_class/modern_C++_30/functionLambda)
-- [内存模型和 atomic：理解并发的复杂性](./learn_class/modern_C++_30/memorymodel_atomic)
-
-### 9.工具篇
-
-#### 9.1 [容器快捷输出工具](./tool/output)
-
-对吴老师的代码进行了修改，[点击此处直通代码](./tool/output/output_container.h)
-
-输入：
-
-```cpp
-map<int, int> mp{
-            {1, 1},
-            {2, 4},
-            {3, 9}};
-    cout << mp << endl;
-```
-
-输出结果显示：
-
-```cpp
-{ 1 => 1, 2 => 4, 3 => 9 }
-```
-
-#### 9.2 像 Python 一样简单输出（Jupyter Notebook）
-
-- [像 Python 一样玩 C/C++](./tool/像Python一样玩CC++.md)
-
-#### 9.3 观察编译过程变化
-
--  [https://cppinsights.io](https://cppinsights.io/)
-
-#### 9.4 C++ 的 Debug 工具 dbg-macro
-
-- [C++ 的 Debug 工具 dbg-macro](./tool/C++的Debug工具dbg-macro.md)
-
-### 10.拓展部分
-
-#### 10.1 一些问题
-
-- [C++ 中如何将 string 类型转换为 int 类型？](./extension/some_problem/string_int.md)
-
-### 11.贡献者
-
-<table>
-  <tbody>
-    <tr>
-      <th align="center" style="width: 80px;">
-        <a href="https://github.com/Light-City">
-          <img src="https://avatars2.githubusercontent.com/u/25699850?s=50&v=4" style="width: 50px;"><br>
-          <sub>Francis</sub>
-        </a><br>
-      </th>
-      <th align="center" style="width: 80px;">
-        <a href="https://github.com/ChungZH">
-          <img src="https://avatars1.githubusercontent.com/u/42088872?s=50&v=4" style="width: 50px;"><br>
-          <sub>ChungZH</sub>
-        </a><br>
-      </th>
-    </tr>
-  </tbody>
-</table>
-
-### 12.赞助我
-
-如果觉得不错，赞助我吧~
-
-<table>
-  <tbody>
-    <tr>
-      <th align="center" style="height=200 width="200">
-          <img src="https://light-city.club/sc/assets/images/alipay.jpg" height="200" width="200" ><br>
-          支付宝
-      </th>
-      <th align="center" style="height=200 width="200">
-          <img src="https://light-city.club/sc/assets/images/wechat.png" height="200" width="200" ><br>
-          微信
-      </th>
-    </tr>
-  </tbody>
-</table>
-

From 3a3f91b4e88e1294ee730d3a36524b9900d56a00 Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Tue, 21 Jul 2020 14:26:15 +0800
Subject: [PATCH 51/62] Update README.md

---
 README.md | 124 +++++++++++++++++++++++++++++++++---------------------
 1 file changed, 77 insertions(+), 47 deletions(-)

diff --git a/README.md b/README.md
index 44cd0bb..dafd70d 100644
--- a/README.md
+++ b/README.md
@@ -5,9 +5,35 @@
 
 [直通点](https://light-city.club/sc/)
 
------------------------
+https://light-city.club/sc/
 
 
+### 关于作者
+
+公众号已开放两大入口，分别是专辑与菜单，可以直接在微信公众号上阅读《C++那些事》内容，配上该仓库的代码，将会非常的爽，建议大家关注一波。
+
+个人公众号：guangcity
+
+![](https://light-city.club/sc/assets/images/wechat.jpg)
+
+欢迎大家反馈及C++交流，本人在微信创建了C++那些事交流群，优质的C++资源交流区，期待大家关注上面公众号，点击公众号右下角->联系我，拉你入群。
+
+---
+
+
+
+### 项目运行
+
+- **代码环境**
+
+  Ubuntu 18.04
+
+- **工具**
+
+  CLion  gcc/g++
+
+尽量用g++，因为一开始我用的vim写的，所以纯g++，后来用编译器CLion，部分有CMakeLists.txt文件，直接导入就行，后面会更新这个文件包含整个项目，持续关注~
+
 ### 0.项目概要
 
 - 中文名：**C++ 那些事**
@@ -45,49 +71,49 @@
 
 ### 2.实战系列
 
-#### 2.1 10日狂练
+#### 2.1 [10日狂练](./practical_exercises/10_day_practice)
 
-- [x] day1
+- [x] [day1](practical_exercises/10_day_practice/day1)
 
 基本c++语法
 
-- [x] day2
+- [x] [day2](practical_exercises/10_day_practice/day2)
 
 递归、结构体、枚举、静态变量等
 
-- [x] day3
+- [x] [day3](practical_exercises/10_day_practice/day3)
 
 函数
 
-- [x] day4
+- [x] [day4](practical_exercises/10_day_practice/day4)
 
 函数深入
 
-- [x] day5
+- [x] [day5](practical_exercises/10_day_practice/day5)
 
 继承多态
 
-- [x] day6
+- [x] [day6](practical_exercises/10_day_practice/day6)
 
 虚函数、抽象类
 
-- [x] day7
+- [x] [day7](practical_exercises/10_day_practice/day7)
 
 运算符重载
 
-- [x] day8
+- [x] [day8](practical_exercises/10_day_practice/day8)
 
 模板与STL
 
-- [x] day9
+- [x] [day9](practical_exercises/10_day_practice/day9)
 
 异常
 
-- [x] day10
+- [x] [day10](practical_exercises/10_day_practice/day10)
 
 文件与流
 
-#### 2.2 重点实战练习
+#### 2.2 [重点实战练习](./practical_exercises/key_exercises/)
 
 ├── [中括号重载.cpp](./practical_exercises/key_exercises/中括号重载.cpp)
 ├── [时钟++运算符重载.cpp](./practical_exercises/key_exercises/时钟++运算符重载.cpp)
@@ -113,13 +139,13 @@
 ├── [输入输出重载.cpp](./practical_exercises/key_exercises/输入输出重载.cpp)
 ├── [输出格式.cpp](./practical_exercises/key_exercises/输出格式.cpp)
 
-### 2.[C++2.0 新特性](./c++2.0)
+### 3.[C++2.0 新特性](./c++2.0)
 
-#### 2.0 概况
+#### 3.0 概况
 
 C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
 
-#### 2.1 [C++11 新特性](./c++2.0/c++11)
+#### 3.1 [C++11 新特性](./c++2.0/c++11)
 
 - [Variadic Templates](./c++2.0/variadic)
 
@@ -188,15 +214,16 @@ C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
 
   学习资料：https://www.bilibili.com/video/av51863195?from=search&seid=3610634846288253061
 
-### 2.2 C++14/17/20
+#### 3.2 C++14/17/20
 
 待更新...
 
-### 3.设计模式
+### 4.设计模式
 
 - [单例模式](./design_pattern/singleton)
+- [生产消费者模式](./design_pattern/producer_consumer)
 
-### 4. [STL 源码剖析](./src_analysis/stl)
+### 5. [STL 源码剖析](./src_analysis/stl)
 
 **STL 源码剖析：gcc 4.9.1**
 
@@ -216,18 +243,18 @@ C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
 - [myhashtable](./src_analysis/stl/myhashtable.md)
 - [unordered_map](./src_analysis/stl/unordered_map.md)
 
-### 4. [并发编程](./concurrency)
+### 6. [并发编程](./concurrency)
 
-#### 4.1 C++ Concurrency in Action
+#### 6.1 C++ Concurrency in Action
 
 - [第一章](./concurrency/concurrency_v1/chapter1)
 - [第二章](./concurrency/concurrency_v1/chapter2)
 
 学习资料：https://chenxiaowei.gitbook.io/cpp_concurrency_in_action/
 
-#### 4.2 多线程与多进程
+#### 6.2 多线程与多进程
 
-##### 4.2.1 Threading In C++
+##### 6.2.1 Threading In C++
 
 - [介绍](./concurrency/Threading_In_CPlusPlus/1.thread)
 - [创建线程的五种类型](./concurrency/Threading_In_CPlusPlus/2.create_type)
@@ -238,7 +265,7 @@ C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
 >
 > https://www.youtube.com/watch?v=eZ8yKZo-PGw&list=PLk6CEY9XxSIAeK-EAh3hB4fgNvYkYmghp&index=4
 
-### 5. [C++ 惯用法](./codingStyleIdioms)
+### 7. [C++ 惯用法](./codingStyleIdioms)
 
 ##### 你最喜欢的 c++ 编程风格惯用法是什么?
 
@@ -248,9 +275,9 @@ C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
 - [4.copy and swap](./codingStyleIdioms/4_copy-swap)
 - [5.pImpl(指针指向具体实现)](./codingStyleIdioms/5_pImpl)
 
-### 6.学习课程
+### 8.学习课程
 
-#### 6.1 [极客时间《现代 C++ 实战 30 讲》](https://time.geekbang.org/channel/home)
+#### 8.1 [极客时间《现代 C++ 实战 30 讲》](https://time.geekbang.org/channel/home)
 
 - [堆、栈、RAII：C++ 里该如何管理资源？](./learn_class/modern_C++_30/RAII)
   - [堆](./modern_++_30/RAII/heap.cpp)
@@ -278,9 +305,9 @@ C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
 - [函数对象和 lambda：进入函数式编程](./learn_class/modern_C++_30/functionLambda)
 - [内存模型和 atomic：理解并发的复杂性](./learn_class/modern_C++_30/memorymodel_atomic)
 
-### 7.工具篇
+### 9.工具篇
 
-#### 7.1 [容器快捷输出工具](./tool/output)
+#### 9.1 [容器快捷输出工具](./tool/output)
 
 对吴老师的代码进行了修改，[点击此处直通代码](./tool/output/output_container.h)
 
@@ -300,35 +327,25 @@ map<int, int> mp{
 { 1 => 1, 2 => 4, 3 => 9 }
 ```
 
-#### 7.2 像 Python 一样简单输出（Jupyter Notebook）
+#### 9.2 像 Python 一样简单输出（Jupyter Notebook）
 
 - [像 Python 一样玩 C/C++](./tool/像Python一样玩CC++.md)
 
-#### 7.3 观察编译过程变化
+#### 9.3 观察编译过程变化
 
 -  [https://cppinsights.io](https://cppinsights.io/)
 
-#### 7.4 C++ 的 Debug 工具 dbg-macro
+#### 9.4 C++ 的 Debug 工具 dbg-macro
 
 - [C++ 的 Debug 工具 dbg-macro](./tool/C++的Debug工具dbg-macro.md)
 
-### 8.拓展部分
+### 10.拓展部分
 
-#### 8.1 一些问题
+#### 10.1 一些问题
 
 - [C++ 中如何将 string 类型转换为 int 类型？](./extension/some_problem/string_int.md)
 
-### 9.代码运行
-
-- **代码环境**
-
-  Ubuntu 18.04
-
-- **工具**
-
-  CLion  gcc/g++
-
-### 10.贡献者
+### 11.贡献者
 
 <table>
   <tbody>
@@ -349,9 +366,22 @@ map<int, int> mp{
   </tbody>
 </table>
 
-### 11.关于作者
+### 12.赞助我
 
-个人公众号：
+如果觉得不错，赞助我吧~
 
-![](./img/wechat.jpg)
+<table>
+  <tbody>
+    <tr>
+      <th align="center" style="height=200 width="200">
+          <img src="https://light-city.club/sc/assets/images/alipay.jpg" height="200" width="200" ><br>
+          支付宝
+      </th>
+      <th align="center" style="height=200 width="200">
+          <img src="https://light-city.club/sc/assets/images/wechat.png" height="200" width="200" ><br>
+          微信
+      </th>
+    </tr>
+  </tbody>
+</table>
 

From c750783744c390462d942a44ca65f8d8bb65ef4f Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Tue, 21 Jul 2020 14:27:05 +0800
Subject: [PATCH 52/62] Update README.md

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index dafd70d..7816bb9 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,7 @@
 # C++ 那些事
 
+[English version is here](./README_EN.md)
+
 
 感谢各位对《C++ 那些事》的支持，现将内容也同步至网站，可以打开网站直接阅读~欢迎大家 star、转发、PR。
 

From d399f00f4ee80625ee10ffce95eb3a80b65c9c22 Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Tue, 21 Jul 2020 14:28:50 +0800
Subject: [PATCH 53/62] Update README.md

---
 README.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/README.md b/README.md
index 7816bb9..10edcbe 100644
--- a/README.md
+++ b/README.md
@@ -364,6 +364,12 @@ map<int, int> mp{
           <sub>ChungZH</sub>
         </a><br>
       </th>
+      <th align="center" style="width: 80px;">
+        <a href="https://github.com/xliu79">
+          <img src="https://avatars2.githubusercontent.com/u/31554245?s=50&v=4" style="width: 50px;"><br>
+          <sub>ChungZH</sub>
+        </a><br>
+      </th>
     </tr>
   </tbody>
 </table>

From 0a9f8534db3fb1d1d874a31f6f77e8b8e31635b9 Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Tue, 21 Jul 2020 14:29:08 +0800
Subject: [PATCH 54/62] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 10edcbe..cd2a2b0 100644
--- a/README.md
+++ b/README.md
@@ -367,7 +367,7 @@ map<int, int> mp{
       <th align="center" style="width: 80px;">
         <a href="https://github.com/xliu79">
           <img src="https://avatars2.githubusercontent.com/u/31554245?s=50&v=4" style="width: 50px;"><br>
-          <sub>ChungZH</sub>
+          <sub>xliu79</sub>
         </a><br>
       </th>
     </tr>

From 22216e01d92618a06e42d41d4165151035c61260 Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Tue, 21 Jul 2020 14:30:51 +0800
Subject: [PATCH 55/62] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index cd2a2b0..ac8a5dc 100644
--- a/README.md
+++ b/README.md
@@ -366,7 +366,7 @@ map<int, int> mp{
       </th>
       <th align="center" style="width: 80px;">
         <a href="https://github.com/xliu79">
-          <img src="https://avatars2.githubusercontent.com/u/31554245?s=50&v=4" style="width: 50px;"><br>
+          <img src="https://avatars2.githubusercontent.com/u/31554245?s=50&v=4" style="width: 50px; height: 50px"><br>
           <sub>xliu79</sub>
         </a><br>
       </th>

From a2d143d6ab4a7327cda16de4935615eae23a79ef Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Tue, 21 Jul 2020 14:52:38 +0800
Subject: [PATCH 56/62] Update README.md

---
 README.md | 33 +++++++++------------------------
 1 file changed, 9 insertions(+), 24 deletions(-)

diff --git a/README.md b/README.md
index ac8a5dc..5d22673 100644
--- a/README.md
+++ b/README.md
@@ -349,30 +349,15 @@ map<int, int> mp{
 
 ### 11.贡献者
 
-<table>
-  <tbody>
-    <tr>
-      <th align="center" style="width: 80px;">
-        <a href="https://github.com/Light-City">
-          <img src="https://avatars2.githubusercontent.com/u/25699850?s=50&v=4" style="width: 50px;"><br>
-          <sub>Francis</sub>
-        </a><br>
-      </th>
-      <th align="center" style="width: 80px;">
-        <a href="https://github.com/ChungZH">
-          <img src="https://avatars1.githubusercontent.com/u/42088872?s=50&v=4" style="width: 50px;"><br>
-          <sub>ChungZH</sub>
-        </a><br>
-      </th>
-      <th align="center" style="width: 80px;">
-        <a href="https://github.com/xliu79">
-          <img src="https://avatars2.githubusercontent.com/u/31554245?s=50&v=4" style="width: 50px; height: 50px"><br>
-          <sub>xliu79</sub>
-        </a><br>
-      </th>
-    </tr>
-  </tbody>
-</table>
+
+
+| 贡献人  | 地址                          |
+| ------- | ----------------------------- |
+| 光城    | https://github.com/Light-City |
+| ChungZH | https://github.com/ChungZH    |
+| xliu79  | https://github.com/xliu79     |
+
+
 
 ### 12.赞助我
 

From c7ffb8b04ad2bbe3c3855a8f42b96042902aafee Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Tue, 21 Jul 2020 14:53:08 +0800
Subject: [PATCH 57/62] Update README_EN.md

---
 README_EN.md | 27 +++++++++------------------
 1 file changed, 9 insertions(+), 18 deletions(-)

diff --git a/README_EN.md b/README_EN.md
index 999bc3c..3651c82 100644
--- a/README_EN.md
+++ b/README_EN.md
@@ -330,24 +330,15 @@ Output：
 
 ### 10.Contributor
 
-<table>
-  <tbody>
-    <tr>
-      <th align="center" style="width: 80px;">
-        <a href="https://github.com/Light-City">
-          <img src="https://avatars2.githubusercontent.com/u/25699850?s=50&v=4" style="width: 50px;"><br>
-          <sub>Francis</sub>
-        </a><br>
-      </th>
-      <th align="center" style="width: 80px;">
-        <a href="https://github.com/ChungZH">
-          <img src="https://avatars1.githubusercontent.com/u/42088872?s=50&v=4" style="width: 50px;"><br>
-          <sub>ChungZH</sub>
-        </a><br>
-      </th>
-    </tr>
-  </tbody>
-</table>
+
+
+| 贡献人  | 地址                          |
+| ------- | ----------------------------- |
+| 光城    | https://github.com/Light-City |
+| ChungZH | https://github.com/ChungZH    |
+| xliu79  | https://github.com/xliu79     |
+
+
 
 ### 11.About The Writer
 

From bb139ef4194420c6b6789e7e8a9e0d1f8c478941 Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Tue, 21 Jul 2020 14:53:17 +0800
Subject: [PATCH 58/62] Update README_EN.md


From 0c337b49cfa9f03670d74eb001bd331c8033e261 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=88=E6=9C=9B?= <huyanbingcn@gmail.com>
Date: Fri, 24 Jul 2020 18:53:52 +0800
Subject: [PATCH 59/62] Update README.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

示例常规做法及其原因。
---
 basic_content/extern/README.md | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/basic_content/extern/README.md b/basic_content/extern/README.md
index 41c1ebe..dd75f50 100644
--- a/basic_content/extern/README.md
+++ b/basic_content/extern/README.md
@@ -99,6 +99,21 @@ gcc -c add.c
 g++ add.cpp add.o -o main
 ```
 
+而通常为了C代码能够通用，即既能被C调用，又能被C++调用，头文件通常会有如下写法：
+
+```c
+#ifdef __cplusplus
+extern "C"{
+#endif
+int add(int x,int y);
+#ifdef __cplusplus
+}
+#endif
+```
+
+即在C++调用该接口时，会以C接口的方式调用。这种方式使得C++者不需要额外的extern C，而标准库头文件通常也是类似的做法，否则你为何不需要extern C就可以直接使用stdio.h中的C函数呢？
+
+
 上述案例源代码见：
 
 - [add.h](extern_c++/add.h)
@@ -191,3 +206,5 @@ int add(){
 extern int add();
 ```
 
+
+不过与C++调用C接口不同，C++确实是能够调用编译好的C函数，而这里C调用C++，不过是把C++代码当成C代码编译后调用而已。也就是说，C并不能直接调用C++库函数。

From f03eafdfe8617a1c47d5169996de45180120308a Mon Sep 17 00:00:00 2001
From: GongXiangShun <54074643+GongXiangShun@users.noreply.github.com>
Date: Tue, 28 Jul 2020 10:34:30 +0800
Subject: [PATCH 60/62] =?UTF-8?q?Update=20=E4=BE=8B1.cpp?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 practical_exercises/10_day_practice/day8/函数模板/例1.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/practical_exercises/10_day_practice/day8/函数模板/例1.cpp b/practical_exercises/10_day_practice/day8/函数模板/例1.cpp
index 702a0fd..28cb4b3 100644
--- a/practical_exercises/10_day_practice/day8/函数模板/例1.cpp
+++ b/practical_exercises/10_day_practice/day8/函数模板/例1.cpp
@@ -1,17 +1,17 @@
-//����ģ���������������������Ҳ���԰�����ͨ���͵IJ���
+//函数模板参数可以是类属参数，也可以包括普通类型的参数
 #include<iostream>
 using namespace std;
 
 
 template <class T>
-//ʵ�ֽ���
+//实现降序
 void sort(T &a, int n){
     for (int i=0;i<n;i++){
         int p=i;
         for (int j=i;j<n;j++)
             if(a[p]<a[j])
                 p=j;
-        int t=a[i];	
+        T t=a[i];	
         a[i]=a[p];		
         a[p]=t;
     }

From 682b6ce7d85f9d89a5b2558e0e935bdb6ad3052e Mon Sep 17 00:00:00 2001
From: Weite Zhang <zhang.weit@northeastern.edu>
Date: Fri, 14 Aug 2020 08:11:56 -0400
Subject: [PATCH 61/62] Update README.md

---
 basic_content/decltype/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/basic_content/decltype/README.md b/basic_content/decltype/README.md
index 4a8aa80..02d38f4 100644
--- a/basic_content/decltype/README.md
+++ b/basic_content/decltype/README.md
@@ -47,7 +47,7 @@ for (vectype i = vec.begin; i != vec.end(); i++)
 struct 
 {
     int d ;
-    doubel b;
+    double b;
 }anon_s;
 ```
 

From ccf8808cc07ccde17840f56405a8c8320ffbf54d Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Sat, 22 Aug 2020 11:05:48 +0800
Subject: [PATCH 62/62] Update README.md

---
 README.md | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/README.md b/README.md
index 5d22673..d1ecc00 100644
--- a/README.md
+++ b/README.md
@@ -149,7 +149,7 @@ C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
 
 #### 3.1 [C++11 新特性](./c++2.0/c++11)
 
-- [Variadic Templates](./c++2.0/variadic)
+- [Variadic Templates](./c++2.0/c++11/variadic)
 
 - Spaces in Template Expressions
 
@@ -158,17 +158,17 @@ C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
   vector<list<int>> // before c++ 11 error error: ‘>>’ should be ‘> >’ within a nested template argument list,c++11后可以正常通过
   ```
 
-- [nullptr and nullptr_t](./c++2.0/nullptr.cpp)
+- [nullptr and nullptr_t](./c++2.0/c++11/nullptr.cpp)
 
-- [Automatic Type Deduction with auto](./c++2.0/auto.cpp)
+- [Automatic Type Deduction with auto](./c++2.0/c++11/auto.cpp)
 
-- [Uniform Initialization ](./c++2.0/uniform_initialization.cpp)
+- [Uniform Initialization ](./c++2.0/c++11/uniform_initialization.cpp)
 
-- [initializer_list](./c++2.0/initializer.cpp)
+- [initializer_list](./c++2.0/c++11/initializer.cpp)
 
-- [explicit for ctors taking more than one argument](./c++2.0/explicit.cpp)
+- [explicit for ctors taking more than one argument](./c++2.0/c++11/explicit.cpp)
 
-- [range-based for statement](./c++2.0/auto.cpp)
+- [range-based for statement](./c++2.0/c++11/auto.cpp)
 
   ```cpp
   for(decl:col) {
@@ -176,33 +176,33 @@ C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
   }
   ```
 
-- [=default,=delete](./c++2.0/default_delete.cpp)
+- [=default,=delete](./c++2.0/c++11/default_delete.cpp)
 
   如果你自行定义了一个 ctor,那么编译器就不会给你一个 default ctor
   如果强制加上 =default,就可以重新获得并使用 default ctor.
 
 - Alias(化名)Template(template typedef)
 
-  - [alias.cpp](./c++2.0/alias.cpp) 
-  - [template_template.cpp](./c++2.0/template_template.cpp)
+  - [alias.cpp](./c++2.0/c++11/alias.cpp) 
+  - [template_template.cpp](./c++2.0/c++11/template_template.cpp)
 
 - [template template parameter](./c++2.0/template_template.cpp)
 
-- [type alias](./c++2.0/type_alias.cpp)
+- [type alias](./c++2.0/c++11/type_alias.cpp)
 
-- [noexcept](./c++2.0/noexcept.cpp)
+- [noexcept](./c++2.0/c++11/noexcept.cpp)
 
-- [override](./c++2.0/override.cpp)
+- [override](./c++2.0/c++11/override.cpp)
 
-- [final](./c++2.0/final.cpp)
+- [final](./c++2.0/c++11/final.cpp)
 
-- [decltype](./c++2.0/decltype.cpp)
+- [decltype](./c++2.0/c++11/decltype.cpp)
 
-- [lambda](./c++2.0/lambda.cpp)
+- [lambda](./c++2.0/c++11/lambda.cpp)
 
-- [Rvalue reference](./c++2.0/rvalue.cpp)
+- [Rvalue reference](./c++2.0/c++11/rvalue.cpp)
 
-- [move aware class](./c++2.0/move.cpp)
+- [move aware class](./c++2.0/c++11/move.cpp)
 
 - 容器-结构与分类
 
@@ -210,9 +210,9 @@ C++2.0 是一个简称，意为「现代 C++」，包括 C++11/14/17/20。
   - (2) 关联式容器包括：`set/multiset`,`map/multimap`
   - (3) 无序容器(C++2.0 新引入,更换原先 `hash_xxx` 为 `unordered_xxx`)包括：`unordered_map/unordered_multimap,unordered_set/unordered_multiset`
 
-- [Hash Function](./c++2.0/hash.cpp)
+- [Hash Function](./c++2.0/c++11/hash.cpp)
 
-- [tuple](./c++2.0/tuple.cpp)
+- [tuple](./c++2.0c++11//tuple.cpp)
 
   学习资料：https://www.bilibili.com/video/av51863195?from=search&seid=3610634846288253061