C++

.gitignore

@@ -0,0 +1 @@
+*.exe

C++/C++基础/0 编写一个C++程序.md

@@ -0,0 +1,110 @@
+
+## 0 编译工具
+
+### Linux编译工具
+
+```
+gcc
+    gcc hello.c -o hello
+    gcc hello -o hello.i -E //预处理
+    gcc hello.i -o hello.s -S//编译成汇编语言
+    gcc hello.s -o hello.o -c//汇编成机器语言
+    gcc hello.o -o hello -lc -lgcc//链接各种库
+g++
+    g++ hello.cpp -o hello
+make
+    make makefile//识别gcc/g++编译脚本
+cmake
+    cmake . //识别make脚本，生成makefile
+    
+```
+### windows编译工具
+```
+msvc
+    cl //微软的命令行的编译工具
+mingw
+    gcc/g++/make//提供在windows环境下的Linux的编译工具
+```
+
+## 1 C++程序构成
+
+### 构成
+* 返回类型
+* 函数名
+* 形参列表
+* 函数体
+```C
+int main (){
+
+}
+```
+> tips：程序所处理的数据保存在变量中，每个变量都有自己的类型。
+
+
+## 2 输入输出
+
+* iostream库（istream类型、ostream类型）
+* cin，istream类型对象，标准输入
+* cout，ostream类型对象，标准输出
+* cerr、clog，ostream类型的对象，标准错误
+
+## 3 注释
+
+### 单行注释&多行注释
+* 注释界定福不能嵌套。
+
+```
+//单行注释
+/*
+多行注释
+*/
+```
+
+## 4 控制流
+
+### while语句
+
+### for语句
+```C
+#include <iostream>
+using namespace std;
+//std 命名空间，相当于包
+int main()
+{
+    int a=0, b = 0;
+    cout << "hello world" <<endl;
+
+    while(a<10){
+        a++;
+    }
+    for(b=1;b<11;b++){
+        b++;
+    }
+    cout<<"a:"<<a<<endl;
+    cout<<"b:"<<b<<endl;
+    return 0;
+}
+```
+
+### if语句
+
+
+### 常见错误类型
+
+* 类型错误type error
+* 声明错误declaration error
+* 语法错误 syntax error
+
+## 5 类简介
+
+### 简介
+* “类”是一种用户自定义的，复合“类型”。与内置类型一样。
+* 标准库文件中，定义了一些类类型，同时也定义了一些类类型的变量，如“cin”“cout”等标准对象。
+* 类类型的变量称为“对象”
+  
+
+
+> 那些常一起出现的名词*
+> * 类型、变量、常量、值，描述C++中所有的值。
+> * 变量、对象
+> * 函数、方法

C++/C++基础/0.cpp

@@ -0,0 +1,20 @@
+// #include <iostream>
+using namespace std;
+//std 命名空间，相当于包
+int fff = 10;
+// int main()
+// {
+//     int a=0, b = 0;
+//     cout << "hello world" <<endl;
+
+//     while(a<10){
+//         a++;
+//     }
+//     for(b=1;b<11;b++){
+//         b++;
+//     }
+//     cout<<"a:"<<a<<endl;
+//     cout<<"b:"<<b<<endl;
+
+//     return 0;
+// }

C++/C++基础/1 变量和基本类型.md

@@ -4,8 +4,10 @@
 
 ### 算术类型
 
-* 字符型  
+* 布尔型
 bool 1  
+
+* 字符型  
 char 1  
 wchar_t 2  
 char16_t  
@@ -15,7 +17,7 @@ char32_t
 short 2  
 int 4  
 long 4  
-long 8  
+long long 8  
 
 * 浮点型  
 float 4  
@@ -29,12 +31,13 @@ long double 16
 * unsigned 无符号
 
 
+
 ### 类型转换
 * 强制类型转换  
   可能会丢失精度。
 * 隐式类型转换  
   默认情况下会向上转换，即向位数更多的位置转换。
-* 避免无符号和有符号的混用。
+* 避免无符号和有符号的混用。带符号的数会自动转换成无符号的数。
 
 ### 字面值常量
 
@@ -47,32 +50,52 @@ long double 16
 * 转义序列
   \n\t\a\v\\\b\"\?\'\r\f  
   \7\0\12\115
-* 可以指定字面值常量的类型
-  常见前缀u U L u8
-  常见后缀u/U,l/L,ll/LL
+* 可以指定字面值常量的类型。字面值会有默认的常量类型。
+  常见前缀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
 
 ## 2 变量
 
-> 关于C++中常见的描述总结：对象object，存储数据并具有某种类型的内存空间。已经命名的对象叫变量。
+> 关于C++中常见的描述总结：对象object，存储数据并具有某种类型的内存空间。已经命名的对象叫变量。变量和对象通常通用。值表示只读的数据。变量和对象是可变的数据。
 
 ### 变量定义
 * 类型说明符+名称+初始化。
 * 初始值：可以直接初始化、复制初始化。不等同于赋值。
+* 直接初始化：使用=进行初始化。
 * 列表初始化：使用{}进行初始化。
 * 默认初始化：变量没有被显示初始化。
-### 变量的声明和定义。
-* 声明和定义可以分离。声明使得程序可以被程序所知道，定义负责创建与名字关联的实体。
-* extern可以声明，而不进行定义。变量可以被声明很多次，但只能被定义一次。不能再函数体中对extern声明的变量进行修改，extern声明的变量只能是外部变量。
+
+### 初始化和赋值
+* 初始化和赋值是两个不同点操作。使用等号能够表示赋值，也能够实现初始化。
 ```
-extern int i;
-int j;
+    int d = 1;//直接初始化
+    int e = {2};//直接初始化
+    int f{3};//花括号列表初始化
+    int g(4);//括号列表，列表初始化
 ```
 
+### 变量的声明和定义。
+* 分离式编译机制：声明和定义可以分离。声明使得程序可以被程序所知道，定义负责创建与名字关联的实体（变量空间）。多个文件可以独立编译。声明并没有申请对象空间（变量空间）。
+* extern可以声明，而不进行定义。变量可以被声明很多次，但只能被定义一次。不能再函数体中对extern声明的变量进行修改，extern声明的变量只能是外部变量。
+* 多次声明必须兼容，类型一致。
+```
+extern int i;//声明，但没有申请对象空间。
+int j;//声明并定义了，申请了兑现该控件
+```
+
+### 静态类型语言
+* 编译阶段，进行类型检查。
+
 ### 标识符与关键字。
+![](2021-03-03-17-45-17.png)
 
 ### 作用域
 * 名字在所有花括号之外，则成为全局作用域。
 * 名字在其他作用与内，则成为块作用域。
+* 内层作用域，外层作用域。
 
 ## 3 复合类型
 
@@ -80,16 +103,20 @@ int j;
 
 * 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类型。
 * 不能定义指向引用的指针，因为引用不是对象，没有内存空间。
-* 
+* 连续定义，必须都加*号
 ### 指针值的四种状态
 * 指向一个对象；
 * 指向紧邻对象所占空间的下一个位置；
@@ -102,5 +129,17 @@ int j;
 ```
 int *p1 = nullptr;
 ```
+### void*
+* 可以存放任意对象的地址。
 
+### 复合类型的声明
+
+int *p1,p2;
+p1是指向int的指针，p2是int类型的。
+
+### 指向指针的指针
+
+int i=0;
+int *p1=&i;
+int **p2 = &p1
 

C++/C++基础/1.cpp

@@ -0,0 +1,31 @@
+#include <iostream>
+using namespace std;
+
+int main()
+{
+    // unsigned int a =1;
+    // int b = -1;
+    // cout<<a*b<<endl;
+    // int c = 011;
+    // cout<<c<<endl;//cout会转换成十进制输出。格式化输出中有改变cout输出类型。
+    // int d = 1;//直接初始化
+    // int e = {2};//直接初始化
+    // int f{3};//花括号列表初始化
+    // int g(4);//括号列表，列表初始化
+    // extern int f; //表示这个变量是个外部变量，在外部定义。
+    // extern int f; //多次声明必须相互兼容。类型一致
+    // f = 5;
+
+    // int t =1;
+    // int* i=&t, *j= &t;
+    // cout<<*i<<endl;
+    // cout<<*j<<endl;
+
+    extern int fff;
+    fff=11;
+    cout << fff << endl;
+
+    // fff = 11;
+    // cout << fff << endl;
+    return 0;
+}

C++/C++基础/关键词解释.md

@@ -0,0 +1,32 @@
+## 1 include
+
+### 基本使用
+```
+include<iostream>
+include"a.cpp"
+```
+
+### 原理
+
+* #include是C++预处理器的一部分。预处理器处理程序的源代码，是在编译器之前运行。#include只接受一个参数：头文件名。预处理器用指定的头文件的内容替代每个include。
+* include的作用是从源代码上的复制粘贴。不会进行逻辑处理，而是直接插入引用的部分。
+* 一个程序的头文件.h不是为了给自己用的，而是为了给其他程序用的。所以，在给别人使用的.h中声明extern int的全局变量很重要。
+
+## 2 extern
+### 基本使用
+* 声明一个变量
+* 不带定义，不申请空间。
+
+```
+extern int i;
+```
+
+### 原理
+
+* 语句：extern int a; 仅仅是一个变量的声明，其并不是在定义变量a，也并未为a分配空间。变量a在所有模块中作为一种全局变量只能被定义一次，否则会出错。
+
+* 通常来说，在模块的头文件中对本模块提供给其他模块引用的函数和全局变量以关键字extern声明。例如，如果模块B要引用模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样模块B中调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数，但并不会报错；它会在链接阶段从模块A编译生成的目标代码中找到该函数。
+* 函数的声明extern关键词可有可无，因为函数本身不加修饰的话就是extern。全局变量在外部使用的时候，extern关键字是必须的。局部变量的声明不能有extern，且局部变量在运行时才在堆栈部分分配内存。
+* 全局变量是在函数外部声明的变量。函数名本身在函数外部，也是全局的。
+* 修饰声明全局变量或函数，其声明的变量和函数可以在其它模块（文件）中使用，注意，这只是一个声明而不是定义，具体的定义要在具体的模块中完成。
+

C++/面试/C++编译过程详解.md

@@ -0,0 +1,72 @@
+# 编译和链接的过程
+
+## 0 概述
+
+
+程序要运行起来，必须要经过四个步骤：预处理、编译、汇编和链接。接下来通过几个简单的例子来详细讲解一下这些过程。
+
+![](2021-03-03-19-44-57.png)
+
+对于上边用到的几个选项需要说明一下。
+
+* 使用 gcc 命令不跟任何的选项的话，会默认执行预处理、编译、汇编、链接这整个过程，如果程序没有错，就会得到一个可执行文件，默认为a.out
+
+* -E选项：提示编译器执行完预处理就停下来，后边的编译、汇编、链接就先不执行了。
+
+* -S选项：提示编译器执行完编译就停下来，不去执行汇编和链接了。
+
+* -c选项：提示编译器执行完汇编就停下来。
+
+* 所以，这三个选项相当于是限定了编译器执行操作的停止时间，而不是单独的将某一步拎出来执行。
+
+
+
+
+## 1 预处理：
+
+使用-E选项，表示只进行预编译，对应生成一个 .i 文件。
+
+预处理过程进行的操作：
+
+* 将所有的“#define”删除，并且展开所有的**宏定义**
+* 处理所有的**条件编译指令**，比如“#if”、“#ifdef”、“#elif”、“#else”、“#endif”
+* 处理“#include”**预编译指令**，将被包含的头文件插入到该编译指令的位置。（这个过程是递归进行的，因为被包含的文件可能还包含了其他文件）
+* 删除所有的注释“//”和“/* */”。
+* 添加行号和文件名标识，方便后边编译时编译器产生调试用的行号心意以及编译时产生编译错误或警告时能够显示行号。
+* 保留所有的#pragma编译指令，因为编译器需要使用它们。
+
+编写一个简单的程序，然后使用-E选项执行预处理过程，打开生成的 .i 文件与源文件进行比对，结果一目了然
+
+![](2021-03-03-19-49-02.png)
+
+对于给代码加上行号这个就不在这里演示了，我们在写代码的时候是不会手动添加行号的，我们看到的行号都是自己使用的编辑工具自动加上的，而这些行号编译系统是看不到的，但是呢，我们发现如果我们哪一行的代码出现了问题，编译的时候就会给出提示说哪行的代码有什么问题，这就已经证明，编译器是会自动添加行号的。
+
+## 2 编译
+
+使用-S选项，表示编译操作执行完就结束。对应生成一个 .s 文件。
+
+编译过程是整个程序构建的核心部分，编译成功，会将源代码由文本形式转换成机器语言，编译过程就是把预处理完的文件进行一系列词法分析、语法分析、语义分析以及优化后生成相应的汇编代码文件。
+
+* 词法分析：词法分析是使用一种叫做lex的程序实现词法扫描，它会按照用户之前描述好的词法规则将输入的字符串分割成一个个记号。产生的记号一般分为：关键字、标识符、字面量（包含数字、字符串等）和特殊符号（运算符、等号等），然后他们放到对应的表中。
+* 语法分析：语法分析器根据用户给定的语法规则，将词法分析产生的记号序列进行解析，然后将它们构成一棵语法树。对于不同的语言，只是其语法规则不一样。用于语法分析也有一个现成的工具，叫做：yacc。
+* 语义分析：语法分析完成了对表达式语法层面的分析，但是它不了解这个语句是否真正有意义。有的语句在语法上是合法的，但是却是没有实际的意义，比如说两个指针的做乘法运算，这个时候就需要进行语义分析，但是编译器能分析的语义也只有静态语义。
+    * 静态语义：在编译期就可以确定的语义。通常包括声明与类型的匹配、类型的转换。比如当一个浮点型的表达式赋值给一个整型的表达式时，其中隐含一个从浮点型到整型的转换，而语义分析就需要完成这个转换，再比如，将一个浮点型的表达式赋值给一个指针，这肯定是不行的，语义分析的时候就会发现两者类型不匹配，编译器就会报错。
+    * 动态语义：只有在运行期才能确定的语义。比如说两个整数做除法，语法上没问题，类型也匹配，听着好像没毛病，但是，如果除数是0的话，这就有问题了，而这个问题事先是不知道的，只有在运行的时候才能发现他是有问题的，这就是动态语义。
+
+* 中间代码生成：我们的代码是可以进行优化的，对于一些在编译期间就能确定的值，是会将它进行优化的，比如说上边例子中的 2+6，在编译期间就可以确定他的值为8了，但是直接在语法上进行优化的话比较困难，这时优化器会先将语法树转成中间代码。中间代码一般与目标机器和运行环境无关。（不包含数据的尺寸、变量地址和寄存器的名字等）。中间代码在不同的编译器中有着不同的形式，比较常见的有三地址码和P-代码。中间代码使得编译器可以分为前端和后端。编译器前端负责产生于机器无关的中间代码，编译器后端将中间代码换成机器代码。
+
+* 目标代码生成与优化：代码生成器将中间代码转成机器代码，这个过程是依赖于目标机器的，因为不同的机器有着不同的字长、寄存器、数据类型等。最后目标代码优化器对目标代码进行优化，比如选择合适的寻址方式、使用唯一来代替乘除法、删除出多余的指令等。
+
+三、汇编
+
+汇编过程调用汇编器as来完成，是用于将汇编代码转换成机器可以执行的指令，每一个汇编语句几乎都对应一条机器指令。
+
+使用命令as hello.s -o hello.o 或者使用gcc -c hello.s -o hello.o来执行到汇编过程结束，对应生成的文件是.o文件。
+
+## 4 链接
+
+链接的主要内容就是将各个模块之间相互引用的部分正确的衔接起来。它的工作就是把一些指令**对其他符号地址的引用加以修正**。链接过程主要包括了地址和空间分配、符号决议和重定向。
+
+* 符号决议：有时候也被叫做符号绑定、名称绑定、名称决议、或者地址绑定，其实就是指用符号来去标识一个地址。比如说 int a = 6;这样一句代码，用a来标识一个块4个字节大小的空间，空间里边存放的内容就是4.
+
+* 重定位：重新计算各个目标的地址过程叫做重定位。最基本的链接叫做静态链接，就是将每个模块的源代码文件编译成目标文件（Linux：.o  Windows：.obj），然后将目标文件和库一起链接形成最后的可执行文件。库其实就是一组目标文件的包，就是一些最常用的代码变异成目标文件后打包存放。最常见的库就是运行时库，它是支持程序运行的基本函数的集合。

C++/面试/a.cpp

@@ -0,0 +1,10 @@
+#include"a.h"
+
+#include<iostream>
+using namespace std;
+int a =10;
+int aa=3;
+int hello(){
+    cout<<a+100<<endl;
+    return 0;
+}

C++/面试/a.h

@@ -0,0 +1,20 @@
+#ifndef A
+#define A
+
+extern int a;//仅进行声明
+// int a=11;
+// int aaa=10;
+// class M;//仅进行声明
+// class N//对类类型进行了定义（当包含定义的时候，就应该尽量避免多次定义，使用条件编译进行控制）。类型定义并没有生成变量。
+// {
+//     int m;//仅进行声明
+//     int world();//仅进行声明
+// };
+// extern N k;//仅声明了了一个变量
+int hello();//仅仅进行声明，extern可有可无，省略了extern
+// int hhh(){return 0;};//声明并定义了方法，会报错。
+#endif
+
+//使用条件编译，b.cpp<-b.h<-a.h。b.cpp<-a.h。两次引入了同一段代码片段。防止出错。
+//使用extern，多个包含a的文件，使用了同一个a的声明。
+//.h文件中不应该包含变量的定义、方法的定义，可以包含变量的声明、方法的声明、类的声明、类的定义。

C++/面试/b.cpp

@@ -0,0 +1,11 @@
+#include"a.h"
+#include "b.h"
+#include <iostream>
+using namespace std;
+int main()
+{
+    cout<<a<<endl;
+    hello();
+    // a=12;
+    return 0;
+}

C++/面试/b.h

@@ -0,0 +1 @@
+#include "a.h"

C++/面试/全局变量和静态变量.md

@@ -0,0 +1,4 @@
+
+* 全局变量在main方法之前声明，不显示使用static关键字。作用域是整个工程。在定义的本文件内直接使用。而其他的文件加上extern关键字声明后，也可以使用。
+* 局部静态变量由static关键字声明，他的作用域只在定义的文件，外部的文件不能用extern的方式进行使用。
+* 也就是说全局变量一定是静态变量，而静态变量不一定是全局的。anyway，这两个变量都存储在全局静态区。

C++/面试/多文件编程的实例.md

@@ -0,0 +1,15 @@
+
+## a.h
+
+## a.cpp
+
+## b.h//只应该包含声明，而不应包含定义。变量的声明、函数的声明。
+
+## b.cpp
+
+
+## 说明——解决multiple definition的问题。
+### 使用条件编译
+* 使用条件编译控制被引入的文件，防止被多次编译。条件编译解决的是，预处理阶段，某一个文件，多次包含同一个文件。例如，b包含a，c包含a，c又包含b；#include的预处理阶段，c包含了两段a的代码，那么编译过程会出现include的错误。所以在所有的头文件中，应当加上条件编译，在给别人使用过程中，防止被直接或间接包含多次。
+### 使用extern
+* 使用extern对全局变量进行控制。extern解决的是，链接阶段，多个文件包含了同一文件，结果全局变量或函数多次定义的问题。使得头文件中的变量变为声明，在include过程中，被声明了多次。防止多次包含同一个全局变量起冲突。前提是这个模块会被外部使用。如果不可能被外部使用，则不需要使用extern声明。