diff --git a/C++/C++基础/1 变量和基本类型.md b/C++/C++基础/1 变量和基本类型.md
index 20acc647..c3f4b22c 100644
--- a/C++/C++基础/1 变量和基本类型.md	
+++ b/C++/C++基础/1 变量和基本类型.md	
@@ -1,75 +1,95 @@
 # 变量和基本类型
 
-## 1基本内置类型
-> 数据类型主要包含内置数据类型（算数类型（整型，浮点型），指针类型），自定义数据类型（vector=C数组类型，string=C字符串类型）
+## 0 类型树
+
+- 简单类型
+  - 算术类型
+    - 整型 int、long、bool、char
+    - 浮点型 float、double
+- 复合类型
+  - 引用&a
+  - 指针\*pointer
+  - 数组 a[]
+  - 字符串"hello world"
+- 类类型
+  - string
+  - vector
+
+## 1 基本内置类型
+
+> 数据类型主要包含内置数据类型（算数类型（整型，浮点型），指针类型），自定义数据类型（vector=C 数组类型，string=C 字符串类型）
+
 ### 算术类型
 
-* 布尔型
-bool 1  
+- 布尔型
+  bool 1
 
-* 字符型  
-char 1  
-wchar_t 2  
-char16_t  
-char32_t  
+- 字符型  
+  char 1  
+  wchar_t 2  
+  char16_t  
+  char32_t
 
-* 整型  
-short 2  
-int 4  
-long 4  
-long long 8  
+- 整型  
+  short 2  
+  int 4  
+  long 4  
+  long long 8
 
-* 浮点型  
-float 4  
-double 8  
-long double 16  
+- 浮点型  
+  float 4  
+  double 8  
+  long double 16
+
+### 类型修饰符-signed 与 unsigned
 
-### 类型修饰符-signed与unsigned
 > 常见的类型修饰符：signed、unsigned、long、short、const、static、extern、auto、register、mutable、thread_local、volatile、restrict
 
-* signed 有符号
-* unsigned 无符号
-
-
+- signed 有符号
+- unsigned 无符号
 
 ### 类型转换
-* 强制类型转换  
+
+- 强制类型转换  
   可能会丢失精度。
-* 隐式类型转换  
+- 隐式类型转换  
   默认情况下会向上转换，即向位数更多的位置转换。
-* 避免无符号和有符号的混用。带符号的数会自动转换成无符号的数。
+- 避免无符号和有符号的混用。带符号的数会自动转换成无符号的数。
 
 ### 字面值常量
 
-* 整型字面常量
+- 整型字面常量
   不同进制指的是字面格式，其转化为存储格式时，都会变成二进制存储。不必担心十进制与二进制之间的运算。字面常量只是一种数字的表示方法。24，,024，,0x24。会自动选用尺寸最小的整型进行存储；负号是对字面值取相反数，不是字面值的一部分。
-* 浮点型字面值常量
-  默认情况下使用double存储。3.14,3.14E0,10e4
-* 字符和字符串的字面常量
+- 浮点型字面值常量
+  默认情况下使用 double 存储。3.14,3.14E0,10e4
+- 字符和字符串的字面常量
   'a'"adbd"字符串的字面值是由字符数组构成的。编译器会在每个字符串常量的末尾添加一个'\0'
-* 转义序列
+- 转义序列
   \n\t\a\v\\\b\"\?\'\r\f  
   \7\0\12\115
-* 可以指定字面值常量的类型。字面值会有默认的常量类型。
-  常见前缀u（Unicode 16）U（unicode32） L（宽字符） u8（utf-8）
-  常见后缀u/U（unsigned）,l/L（long）,ll/LL（longlong）,f/F（float）,
+- 可以指定字面值常量的类型。字面值会有默认的常量类型。
+  常见前缀 u（Unicode 16）U（unicode32） L（宽字符） u8（utf-8）
+  常见后缀 u/U（unsigned）,l/L（long）,ll/LL（longlong）,f/F（float）,
 
-* bool字面值：false，true
-* 指针字面值：nullptr
+- bool 字面值：false，true
+- 指针字面值：nullptr
 
 ## 2 变量
 
-> 关于C++中常见的描述总结：对象object，存储数据并具有某种类型的内存空间。已经命名的对象叫变量。变量和对象通常通用。值表示只读的数据。变量和对象是可变的数据。
+> 关于 C++中常见的描述总结：对象 object，存储数据并具有某种类型的内存空间。已经命名的对象叫变量。变量和对象通常通用。值表示只读的数据。变量和对象是可变的数据。
 
 ### 变量定义
-* 类型说明符+名称+初始化。
-* 初始值：可以直接初始化、复制初始化。不等同于赋值。
-* 直接初始化：使用=进行初始化。
-* 列表初始化：使用{}进行初始化。
-* 默认初始化：变量没有被显示初始化。
+
+- 类型说明符+名称+初始化。
+- 初始值：可以直接初始化、复制初始化。不等同于赋值。
+- 直接初始化：使用=进行初始化。
+- 列表初始化：使用{}进行初始化。
+- 默认初始化：变量没有被显示初始化。
 
 ### 初始化和赋值
-* 初始化和赋值是两个不同点操作。使用等号能够表示赋值，也能够实现初始化。
+
+- 初始化和赋值是两个不同点操作。使用等号能够表示赋值，也能够实现初始化。
+
 ```
     int d = 1;//直接初始化
     int e = {2};//直接初始化
@@ -78,122 +98,138 @@ long double 16
 ```
 
 ### 变量的声明(extern)
-* 分离式编译机制：声明和定义可以分离。声明使得程序可以被程序所知道，定义负责创建与名字关联的实体（变量空间）。多个文件可以独立编译。声明并没有申请对象空间（变量空间）。
-* extern可以声明，而不进行定义。变量可以被声明很多次，但只能被定义一次。不能再函数体中对extern声明的变量进行修改，extern声明的变量只能是外部变量。
-* 多次声明必须兼容，类型一致。
+
+- 分离式编译机制：声明和定义可以分离。声明使得程序可以被程序所知道，定义负责创建与名字关联的实体（变量空间）。多个文件可以独立编译。声明并没有申请对象空间（变量空间）。
+- extern 可以声明，而不进行定义。变量可以被声明很多次，但只能被定义一次。不能再函数体中对 extern 声明的变量进行修改，extern 声明的变量只能是外部变量。
+- 多次声明必须兼容，类型一致。
+
 ```
 extern int i;//声明，但没有申请对象空间。
 int j;//声明并定义了，申请了兑现该控件
 ```
 
 ### 静态类型语言
-* 编译阶段，进行类型检查。
+
+- 编译阶段，进行类型检查。
 
 ### 标识符与关键字。
+
 ![](2021-03-03-17-45-17.png)
 
 ### 作用域
-* 名字在所有花括号之外，则成为全局作用域。
-* 名字在其他作用与内，则成为块作用域。
-* 内层作用域，外层作用域。
+
+- 名字在所有花括号之外，则成为全局作用域。
+- 名字在其他作用与内，则成为块作用域。
+- 内层作用域，外层作用域。
 
 ## 3 复合类型
 
 ### 引用
-
-* int &ref=a.表示对a的引用。引用本身并非对象，只是已经存在的对象的别名
-* 引用必须在定义的时候被初始化。
-* 引用是变量的别名，具有同一个变量地址（变量空间）。
-* 允许多个连续的引用
-  int &r=i,r2=i2.表示r是i的引用，但r2是int
-* 连续定义必须都加引用符号。
+- 由基本类型组合而来。不能单独存在。
+- int &ref=a.表示对 a 的引用。引用本身并非对象，只是已经存在的对象的别名
+- 引用必须在定义的时候被初始化。
+- 引用是变量的别名，具有同一个变量地址（变量空间）。
+- 允许多个连续的引用
+  int &r=i,r2=i2.表示 r 是 i 的引用，但 r2 是 int
+- 连续定义必须都加引用符号。
   int &r=i,&r2=i2;
-> 编译过程解释：一般初始化的时候（变量定义），编译器会将一个值拷贝到新建的变量空间中，然后与变量绑定。引用变量在初始化的时候，不进行拷贝，而是将原来的变量空间与新的对象绑定在一起。
-
+  > 编译过程解释：一般初始化的时候（变量定义），编译器会将一个值拷贝到新建的变量空间中，然后与变量绑定。引用变量在初始化的时候，不进行拷贝，而是将原来的变量空间与新的对象绑定在一起。
 
 ### 指针
-* 实现了间接访问。本身是一个对象。与引用不同，指针有自己的变量空间。
-* 允许对指针进行复制和copy。
-* int* dp,dp1.其中dp是int指针，dp1是int类型。
-* 不能定义指向引用的指针，因为引用不是对象，没有内存空间。
-* 连续定义，必须都加*号
+
+- 实现了间接访问。本身是一个对象。与引用不同，指针有自己的变量空间。
+- 允许对指针进行复制和 copy。
+- int\* dp,dp1.其中 dp 是 int 指针，dp1 是 int 类型。
+- 不能定义指向引用的指针，因为引用不是对象，没有内存空间。
+- 连续定义，必须都加\*号
+
 ### 指针值的四种状态
-* 指向一个对象；
-* 指向紧邻对象所占空间的下一个位置；
-* 空指针意味着指针没有指向任何对象；
-* 无效指针，指针指向的位置被释放。
+
+- 指向一个对象；
+- 指向紧邻对象所占空间的下一个位置；
+- 空指针意味着指针没有指向任何对象；
+- 无效指针，指针指向的位置被释放。
 
 ### 指针访问
-* 利用指针运算符访问指针指向的对象（*p）
-* 空指针的生成方法
+
+- 利用指针运算符访问指针指向的对象（\*p）
+- 空指针的生成方法
+
 ```
 int *p1 = nullptr;
 ```
-### void*
-* 可以存放任意对象的地址。
+
+### void\*
+
+- 可以存放任意对象的地址。
 
 ### 复合类型的声明
 
-int *p1,p2;
-p1是指向int的指针，p2是int类型的。
+int \*p1,p2;
+p1 是指向 int 的指针，p2 是 int 类型的。
 
 ### 指向指针的指针
 
 int i=0;
-int *p1=&i;
-int **p2 = &p1
+int \*p1=&i;
+int \*\*p2 = &p1
 
-## 4 const限定符
+## 4 const 限定符
 
 ### 特点
-* 它的值不能被改变。
-* 仅在文件内有效。多个文件出现了同名的const变量时，等同于在不同文件中分别定义了独立变量。
+
+- 它的值不能被改变。
+- 仅在文件内有效。多个文件出现了同名的 const 变量时，等同于在不同文件中分别定义了独立变量。
 
 ### 使用
-* const的值是常量表达式，则直接在头文件中定义`const a = 3*5`，include这个头文件就能使用const a的值。
-* const的初始值通过函数计算得出，不是常量表达式；const变量需要在不同的文件间共享，需要在头文件中extern声明，在cpp文件中进行定义。
-![](2021-03-04-10-42-02.png)
+
+- const 的值是常量表达式，则直接在头文件中定义`const a = 3*5`，include 这个头文件就能使用 const a 的值。
+- const 的初始值通过函数计算得出，不是常量表达式；const 变量需要在不同的文件间共享，需要在头文件中 extern 声明，在 cpp 文件中进行定义。
+  ![](2021-03-04-10-42-02.png)
 
 ### const 引用
 
-* const引用，可以引用一个常量、变量，生成一个只读的变量。
+- const 引用，可以引用一个常量、变量，生成一个只读的变量。
 
 ```
 int i =1;
 const int &r2 =i;
 ```
 
-### const与指针
+### const 与指针
+
+- “指向常量的指针”
+  > 指针指向的值不能修改。
 
-* “指向常量的指针”
-> 指针指向的值不能修改。
 ```
 const double * cptr = π
 ```
+
 ![](2021-03-04-10-48-02.png)
 
-* 指向非常量的“指向常量的指针”
+- 指向非常量的“指向常量的指针”
+
 ```
 double a = 3;
 const double *b = &a
 ```
 
-* 指针常量。
-> 指针本身的地址不能被修改。
+- 指针常量。
+  > 指针本身的地址不能被修改。
 
 ```
 int n = 0;
 int *const nptr = &n;
 ```
 
-* 顶层const表示指针本身是个常量。
-* 底层const表示指针所指向的对象是一个常量。
+- 顶层 const 表示指针本身是个常量。
+- 底层 const 表示指针所指向的对象是一个常量。
 
 ### 常量表达式
 
-* 常量表达式值不会改变，并且在编译过程中就能得到计算结果的表达式。
-* 字面值是常量表达式
-* 用常量表达式初始化const变量也是常量表达式。
+- 常量表达式值不会改变，并且在编译过程中就能得到计算结果的表达式。
+- 字面值是常量表达式
+- 用常量表达式初始化 const 变量也是常量表达式。
 
 ```
 const int max = 20;//是
@@ -201,11 +237,13 @@ const int limt = max +1;//是
 int a =27//不是，左值不是常量表达式
 const int sz = get_size();//不是，右值不是常量表达式
 ```
+
 ## 5 处理类型
 
 ### 类型别名——typedef
 
-* typedef使用最后一个名词作为名字
+- typedef 使用最后一个名词作为名字
+
 ```
 typedef double hello;
 typedef double* p;
@@ -218,14 +256,16 @@ long　lLength;
 ```
 
 ### 类型别名——using
-* 类型别名和类型等价
+
+- 类型别名和类型等价
+
 ```
 using SI = Sales_item;
 ```
 
-### auto类型说明符
+### auto 类型说明符
 
-* 编译器自动分析类型
+- 编译器自动分析类型
 
 ```
 auto item = val1 +val2
@@ -245,8 +285,8 @@ struct data{
 
 ### 类成员
 
-* 数据成员
-* 成员函数
+- 数据成员
+- 成员函数
 
 ### 定义类的对象
 
@@ -258,4 +298,4 @@ data a,b;
 
 ```
 a.sold =1;
-```
\ No newline at end of file
+```
diff --git a/C++/C++基础/2 字符串、向量和数组.md b/C++/C++基础/2 字符串、向量和数组.md
index 7d6c6a9c..e9c62821 100644
--- a/C++/C++基础/2 字符串、向量和数组.md	
+++ b/C++/C++基础/2 字符串、向量和数组.md	
@@ -88,3 +88,144 @@ using namespace
 - 不能使用下标形式向 vector 中添加元素
 
 ## 4 迭代器
+
+### 迭代器的使用
+
+```
+    vector<int> v{1,2,3,4,5,6,7};
+    auto b =v.begin(),e=v.end();
+
+    while(b != e){
+        cout<<*b<<endl;
+        b++;
+    }
+```
+
+![](2021-03-04-15-29-22.png)
+
+- 使用特定的函数返回容器对象（集合对象）的迭代器
+- 使用解引用操作返回迭代器指针指向的元素
+
+### 迭代器运算
+
+![](2021-03-04-15-42-38.png)
+
+- 两个迭代器相减的结果使他们两个之间的距离，是一个整型常数，返回值不是一个迭代器。所以需要使用 beg+(end-beg)/2 来表示中间 mid 迭代器。end-beg 是一个整数。
+
+```
+    // 二分查找实例
+    int aim =3;
+    vector<int> text ={1,2,3,4,5,6};
+    auto beg = text.begin(),end=text.end();
+    auto mid = text.begin()+(end-beg)/2;
+    while(mid != end && *mid != aim){
+        if(aim<*mid){
+            end=mid;
+        }else{
+            beg=mid+1;
+        }
+        mid =beg+(end-beg)/2;
+    }
+    cout<<mid-text.begin()<<endl;
+```
+
+## 5 数组
+
+### 定义和初始化内置数组
+
+```
+int arr[10];//含有10个整型的数组
+int *arr[20];//含有20个整形指针的数组。指针数组
+int (*ptr)[10];指向含有是个整数的数组的指针。数组的指针（常量的指针和指针类型的常量类似）
+
+string arr[10];//含有10个string对象的数组C++11允许数组为对象类型。
+```
+
+### 数组的初始化（仅有两种方法）
+
+```
+int arr[3]={1,2,3};
+int arr[]={1,2,3,4};
+char a3[]="c++"//自动添加表示字符串结束的空字符
+```
+
+### 数组的遍历
+
+- C++11 数组也可以使用容器遍历（集合遍历）
+
+```
+//下标遍历
+
+//容器遍历
+    int k[] = {1,2,3};
+    for (auto l:k){
+        cout<<l<<endl;
+    }
+```
+
+### 指针和数组
+
+- 数组变量是指向数组第一个元素的指针。
+
+```
+string nums[]={"a","b","c"};
+string *p2 = &num[0];
+string *p3 = num;//相互等价
+```
+
+- 数组指针本身也是迭代器。可以使用 begin 函数和 end 函数，实现容器遍历。
+
+```
+int ia[]={1,2,3};
+int *beg = begin(ia);
+int *last = end(ia);
+```
+
+- 下标访问和指针运算等价
+
+```
+int ia[]={1,2,3};
+ia[2];
+*(ia+2);//相互等价
+```
+
+### C 风格的字符串
+
+> 尽量不要使用 C 风格的字符串.C++风格的字符串可以完全替代 C 风格的字符串，并且可以使用字符数组代替 C 风格的字符串。
+
+### 多维数组定义和初始化
+
+* 列表初始化支持只初始化局部元素
+```
+int ia[2][3]={
+    {1,2,3},
+    {4,5,6}
+};//等价
+int ib[2][3]={1,2,3,4,5,6}//等价
+```
+### 多维数组的引用
+
+
+```
+ia[2][3]
+```
+### 多维数组的遍历
+* 两层for循环处理多维数组
+```
+int ia[row_cnt][col_cnt]
+for(int i=0;i<row_cnt;i++){
+    for(int j=0;j<col_cnt;j++){
+        ia[i][j];
+    }
+}
+```
+
+* 两层容器遍历，遍历多维数组。
+
+```
+for(auto &row : ia){
+    for (auto &col:row){
+        *col;
+    }
+}
+```
\ No newline at end of file
diff --git a/C++/C++基础/2.cpp b/C++/C++基础/2.cpp
index 4467986b..381465d9 100644
--- a/C++/C++基础/2.cpp
+++ b/C++/C++基础/2.cpp
@@ -32,16 +32,59 @@ int main()
     // }
     // cout<<s<<endl;
 
-    int t{3};
-    cout<<t<<endl;
-    string m{"3,4,5"};
-    cout<<m<<endl;
-    int a[]{3,4,5};
-    cout<<a[1]<<a[2]<<endl;
+    // int t{3};
+    // cout<<t<<endl;
+    // string m{"3,4,5"};
+    // cout<<m<<endl;
+    // int a[]{3,4,5};
+    // cout<<a[1]<<a[2]<<endl;
 
-    vector<int> p;
-    for(int i=0;i!=100;i++){
-        p.push_back(i);
+    // vector<int> p;
+    // for(int i=0;i!=100;i++){
+    //     p.push_back(i);
+    // }
+
+    //迭代器的使用
+    // vector<int> v{1,2,3,4,5,6,7};
+    // auto b =v.begin(),e=v.end();
+
+    // while(b != e){
+    //     cout<<*e<<endl;
+    //     cout<<(*b)<<endl;
+    //     b++;
+    // }
+
+    // // 二分查找实例
+    // int aim =3;
+    // vector<int> text ={1,2,3,4,5,6};
+    // auto beg = text.begin(),end=text.end();
+    // auto mid = text.begin()+(end-beg)/2;
+    // while(mid != end && *mid != aim){
+    //     if(aim<*mid){
+    //         end=mid;
+    //     }else{
+    //         beg=mid+1;
+    //     }
+    //     mid =beg+(end-beg)/2;
+    // }
+    // cout<<mid-text.begin()<<endl;
+    // class helo{
+    //     int m;
+    //     int n;
+    // };
+    // helo a[10];
+    
+    // int k[] = {1,2,3};
+    // for (auto l:k){
+    //     cout<<l<<endl;
+    // }
+    // cout<<*(k+1)<<endl;
+
+    int ia[2][3]={1,2,3,4,5,6};
+    for(auto &row:ia){
+        for(auto col:row){
+            cout<<col<<endl;
+        }
     }
     return 0;
 }
\ No newline at end of file
diff --git a/C++/C++基础/2021-03-04-15-29-22.png b/C++/C++基础/2021-03-04-15-29-22.png
new file mode 100644
index 00000000..f49069bd
Binary files /dev/null and b/C++/C++基础/2021-03-04-15-29-22.png differ
diff --git a/C++/C++基础/2021-03-04-15-42-38.png b/C++/C++基础/2021-03-04-15-42-38.png
new file mode 100644
index 00000000..e5c6d583
Binary files /dev/null and b/C++/C++基础/2021-03-04-15-42-38.png differ
diff --git a/C++/面试/9.C&C++字符串数组相互转换.md b/C++/面试/9.风格转换.md
similarity index 50%
rename from C++/面试/9.C&C++字符串数组相互转换.md
rename to C++/面试/9.风格转换.md
index 89495cf6..ac0c8db5 100644
--- a/C++/面试/9.C&C++字符串数组相互转换.md
+++ b/C++/面试/9.风格转换.md
@@ -1,12 +1,30 @@
-## 字符串转换
+## 1 字符串转换
+
+### C 字符串转 string
+
+```
+str ="helloworld";
+string s(str);
+```
+
+### string 转 C 风格字符串
+
+```
+string s("helloworld");
+const char * str = s.c_str();
+```
 
 ## 2 数组转换
 
+> 数组也是 C++中很重要的复杂类型之一。vector 是对象类型。可以不用相互转换。C++支持数组的迭代器运算。
+> 建议尽量使用标准库类型，而非数组。
+
 ### 数组转 vector
 
 ```
-float arrHeight[] = { 1.68,1.72,1.83,2.05,2.35,1.78,2.1,1.96 };
-vector<float> vecHeight(arrHeight, arrHeight+sizeof(arrHeight)/sizeof(float));
+int arr[] = { 1,2,3,5,5,8,2,6};
+vector<int> vec(arr, arr+sizeof(arr)/sizeof(int));
+vector<int> vec2(begin(arr),end(arr));//使用数组初始化vector
 ```
 
 ### vector 转数组