408/notes_estom
1
0
Fork 0
mirror of https://github.com/Estom/notes.git synced 2026-04-03 19:07:41 +08:00
Code Issues Packages Projects Releases Wiki Activity

C++

Browse Source
This commit is contained in:
yinkanglong_lab
2021-03-04 14:43:28 +08:00
parent 11e4f1c31b
commit b37104b2e9
23 changed files with 1249 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
.vscode/settings.json vendored
View File

@@ -1,5 +1,8 @@
{
"python.linting.pylintEnabled": true,
"python.linting.enabled": true,
"python.pythonPath": "C:\\Python\\python.exe"
"python.pythonPath": "C:\\Python\\python.exe",
"files.associations": {
"xstring": "cpp"
}
}

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

@@ -1,7 +1,7 @@
# 变量和基本类型
## 1基本内置类型
> 数据类型主要包含内置数据类型（算数类型（整型，浮点型），指针类型），自定义数据类型（vector=C数组类型，string=C字符串类型）
### 算术类型
* 布尔型
@@ -77,7 +77,7 @@ long double 16
int g(4);//括号列表，列表初始化
```
### 变量的声明和定义。
### 变量的声明(extern)
* 分离式编译机制：声明和定义可以分离。声明使得程序可以被程序所知道，定义负责创建与名字关联的实体（变量空间）。多个文件可以独立编译。声明并没有申请对象空间（变量空间）。
* extern可以声明，而不进行定义。变量可以被声明很多次，但只能被定义一次。不能再函数体中对extern声明的变量进行修改，extern声明的变量只能是外部变量。
* 多次声明必须兼容，类型一致。
@@ -143,3 +143,119 @@ int i=0;
int *p1=&i;
int **p2 = &p1
## 4 const限定符
### 特点
* 它的值不能被改变。
* 仅在文件内有效。多个文件出现了同名的const变量时，等同于在不同文件中分别定义了独立变量。
### 使用
* const的值是常量表达式，则直接在头文件中定义`const a = 3*5`，include这个头文件就能使用const a的值。
* const的初始值通过函数计算得出，不是常量表达式；const变量需要在不同的文件间共享，需要在头文件中extern声明，在cpp文件中进行定义。
![](2021-03-04-10-42-02.png)
### const 引用
* const引用，可以引用一个常量、变量，生成一个只读的变量。
```
int i =1;
const int &r2 =i;
```
### 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 int max = 20;//是
const int limt = max +1;//是
int a =27//不是，左值不是常量表达式
const int sz = get_size();//不是，右值不是常量表达式
```
## 5 处理类型
### 类型别名——typedef
* typedef使用最后一个名词作为名字
```
typedef double hello;
typedef double* p;
typedef int h[81];
typedef　struct　tag
{
int　iNum;
long　lLength;
}MyStruct;//定义了结构体；typedef struct tag MyStruct
```
### 类型别名——using
* 类型别名和类型等价
```
using SI = Sales_item;
```
### auto类型说明符
* 编译器自动分析类型
```
auto item = val1 +val2
```
## 6 自定义数据结构
### 定义一个类型。
```
struct data{
std::string bookNo;
unsigned sold = 0;
double revenue = 0.0;
};
```
### 类成员
* 数据成员
* 成员函数
### 定义类的对象
```
data a,b;
```
### 访问类对象
```
a.sold =1;
```

90
C++/C++基础/2 字符串、向量和数组.md
View File

@@ -0,0 +1,90 @@
# 字符串、向量和数组
> 这里讲的是 C++中的处理，置于 C 中的字符串向量和数组，可以自己去复习。
## 1 命名空间的 using 声明
### 基本使用
```
//独立使用名字
using namespace::name;
//声明空间
using namespace
```
### 使用规则
头文件中不应包含 using 声明。因为会破坏包含该文件的源文件的命名空间。
## 2 标准库类型 string
### 定义和初始化 string 对象
![](2021-03-04-11-40-28.png)
![](2021-03-04-11-41-01.png)
- 默认初始化
- 直接初始化
- 复制初始化
- 函数初始化
### string 对象上的操作
![](2021-03-04-11-43-30.png)
### 处理 string 对象中的字符
- C++11 新特性的 for 容器遍历。
```C++
string str("hello world!");
for(auto c :str){
cout<<c<<endl;
}
```
- 使用下标遍历
```
string s("helo");
for(int index =0;index != s.size();++index){
cout<<s[index];
s[index]=toupper(s[index]);
}
cout<<s<<endl;
```
> 三种循环方式：while 条件循环；for 条件循环；for 容器循环。
## 3 标准库类型 vector
### 定义和初始化 vector 对象
![](2021-03-04-14-18-52.png)
- 直接初始化。不适用等号，而是使用{}
- 复制初始化。使用等号，进行初始化
- 函数初始化。使用小括号（），进行初始化，小括号内为参数。
- 列表初始化。使用中括号进行列表初始化。
### 向 vector 对象中添加元素
- 与 C 中初始化数组的方式一样，通过循环对 vector 进行初始化
```
vector<int> p;
for(int i=0;i!=100;i++){
p.push_back(i);
}
```
### 其他 vector 操作
![](2021-03-04-14-38-39.png)
- 使用下表访问 vector 元素的索引
- 不能使用下标形式向 vector 中添加元素
## 4 迭代器

47
C++/C++基础/2.cpp Normal file
View File

@@ -0,0 +1,47 @@
#include <iostream>
#include <string>
#include <cctype>
#include <vector>
using namespace std;
int main()
{
// const char* cc("abc\0");
// char cc2[]={"abc\0"};
// string a = "abc";
// string b = "abc\0";
// string c(cc2);
// cout << a << a.size() << sizeof(a) << endl;
// cout << b << b.size() << sizeof(b) <<endl;
// cout << c << c.size() << sizeof(c) <<endl;
// string str("hello world!");
// int punc =0;
// for(auto &c :str){
// if(ispunct(c)){
// punc++;
// }
// c = toupper(c);
// cout<<c<<endl;
// cout<<str<<endl;
// }
// string s("helo");
// for(int index =0;index != s.size();++index){
// cout<<s[index];
// s[index]=toupper(s[index]);
// }
// 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;
vector<int> p;
for(int i=0;i!=100;i++){
p.push_back(i);
}
return 0;
}

BIN
C++/C++基础/2021-03-04-10-42-02.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 31 KiB

BIN
C++/C++基础/2021-03-04-10-48-02.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 39 KiB

BIN
C++/C++基础/2021-03-04-11-40-28.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 31 KiB

BIN
C++/C++基础/2021-03-04-11-41-01.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 94 KiB

BIN
C++/C++基础/2021-03-04-11-43-30.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 138 KiB

BIN
C++/C++基础/2021-03-04-14-18-52.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 117 KiB

BIN
C++/C++基础/2021-03-04-14-38-39.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 122 KiB

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

@@ -30,3 +30,69 @@ extern int i;
* 全局变量是在函数外部声明的变量。函数名本身在函数外部，也是全局的。
* 修饰声明全局变量或函数，其声明的变量和函数可以在其它模块（文件）中使用，注意，这只是一个声明而不是定义，具体的定义要在具体的模块中完成。
## 3 const
### 基本使用
```
const int bufersize = 512
```
### 原理
* 它的值不能被改变，不能进行赋值操作，只能进行初始化。
* 默认情况下，const值尽在文件中有效。编译器在编译过程中会把用到该变量的地方都替换成对应的值。
## 4 typedef
### 基本使用
typedef使用最后一个名词作为名字
```
typedef double hello;
typedef double* p;
typedef int h[81];
typedef　struct　tag
{
int　iNum;
long　lLength;
}MyStruct;//定义了结构体；typedef struct tag MyStruct
```
### 原理
* typedef使用最后一个名词作为名字
## 5 using
### 基本使用
```
using SI = Sales_item;
```
### 原理
* 类型别名和类型等价
## 6 auto
### 基本使用
* 编译器自动分析类型
```
auto item = val1 +val2
```
## 7 decltype
### 基本使用
```
decltype(f()) sum =x;
```
### 原理
* 根据表达式推断类型，而不会计算表达式。类型推断。
> 略过的constexp,

0
C++/面试/C++编译过程详解.md → C++/面试/1.C++编译过程详解.md
View File

0
C++/面试/全局变量和静态变量.md → C++/面试/2.全局变量和静态变量.md
View File

BIN
C++/面试/2021-03-04-10-30-35.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 477 KiB

5
C++/面试/多文件编程的实例.md → C++/面试/3.多文件编程的实例.md
View File

@@ -12,4 +12,7 @@
### 使用条件编译
* 使用条件编译控制被引入的文件，防止被多次编译。条件编译解决的是，预处理阶段，某一个文件，多次包含同一个文件。例如，b包含a，c包含a，c又包含b；#include的预处理阶段，c包含了两段a的代码，那么编译过程会出现include的错误。所以在所有的头文件中，应当加上条件编译，在给别人使用过程中，防止被直接或间接包含多次。
### 使用extern
* 使用extern对全局变量进行控制。extern解决的是，链接阶段，多个文件包含了同一文件，结果全局变量或函数多次定义的问题。使得头文件中的变量变为声明，在include过程中，被声明了多次。防止多次包含同一个全局变量起冲突。前提是这个模块会被外部使用。如果不可能被外部使用，则不需要使用extern声明。
* 使用extern对全局变量进行控制。extern解决的是，链接阶段，多个文件包含了同一文件，结果全局变量或函数多次定义的问题。使得头文件中的变量变为声明，在include过程中，被声明了多次。防止多次包含同一个全局变量起冲突。前提是这个模块会被外部使用。如果不可能被外部使用，则不需要使用extern声明。
### 使用const
* 使用const定义的常量。旨在文件中内有效，编译器在编译过程中，把用到该常量的地方都替换成了对应的值。

4
C++/面试/4.空间分配的说明.md Normal file
View File

@@ -0,0 +1,4 @@
* 字面常量与const限定的常量，在编译器编译阶段，会把用到该变量的地方都替换成对应的值。
* 变量，在编译阶段分配空间，在执行阶段修改变量的值。根据变量的名称或地址索引分配到的空间。
* 动态变量，在执行阶段动态分配内存空间，在执行阶段修改动态变量的值。

45
C++/面试/5.C++内存分配.md Normal file
View File

@@ -0,0 +1,45 @@
## 内存分配
### 内存分配示意图
![](2021-03-04-10-30-35.png)
* Unused Memory：用于程序代码块对齐
Read-only code segment：只读，存代码和一些其他的东西
* Read/Write data segment:
* .data：存初始化的全局变量和static变量，另外还有文字常量区，常量字符串就是放在这里，程序结束后有系统释放
* .bss：存未初始化的全局变量和static变量
* Heap：通过new和malloc由低到高分配，由delete或free手动释放或者程序结束自动释放
* Shared libraries：调用的库文件，位于堆和栈之间
* Stack：由高向低增长，和堆的增长方式相对，对不同的OS来说，栈的初始大小有规定，可以修改，目前默认一般为2M，由编译器自动分配释放
* Kernel virtual memory：用户不可见不能访问
### 内存分配说明
C/C++编译的程序所占用内存区域一般分为以下5个部分：
* 栈区（stack）：由编译器自动分配和释放，用来存放函数的参数、局部变量等。其操作方式类似于数据结构中的栈。
* 堆区（heap）：一般由程序员分配和释放（通过malloc/free、new/delete），若程序员没有释放，则程序结束时由操作系统回收。它与数据结构中的堆是两回事，分配方式类似于链表。
* 全局/静态区：全局变量和静态变量的存储是放在一块的，初始化的全局变量和初始化的静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域，程序结束后由操作系统回收。
* 文字常量区：存放常量值，如常量字符串等，不允许修改，程序结束后由操作系统回收。
* 程序代码区：存放函数体的二进制代码。
### 例子
```
#include <stdlib.h>
#include <string.h>
int a = 0; // 全局初始化区
char* p1; // 全局未初始化区
int main() {
int a; // 栈区
char s[] = "abc"; // 栈区
char* p2; // 栈区
char* p3 = "123456"; // 123456\0在常量区，p3在栈区
static int c = 0; // 全局/静态初始化区
p1 = (char*) malloc(10);
p2 = (char*) malloc(20); // 分配得来的10和20字节在堆区
strcpy(p1, "123456"); // 123456\0放在常量区，编译器可能将它与p3所指向的"123456"优化成一个地方
return 0;
}
```

57
C++/面试/6.高低地址与高低位.md Normal file
View File

@@ -0,0 +1,57 @@
## 1 高低地址
### 基础
可以把主存看成一本空白bai的作业本，你现在要在笔记本上记录一些内容，他的页码排序是
```
第一页 : 0x0000001
第二页 : 0x0000002
...
最后一页: 0x0000092
```
1. 如果你选择`从前向后记录`(用完第一页，用第二页,类推)这就是先使用低地址，后使用高地址.业内表述:动态分配内存时堆空间向高地址增长,说的就是这种情况.这个向高地址增长就是先使用低地址,后使用高地址的意思.
```
0x0000001 -> 0x0000002-> ... -> 0x0000092
```
1. 如果你选择`从后往前记录`(先用笔记本的最后一页,用完后使用倒数第二页，类推) 这就是先使用高地址,后使用低地址.业内表述：`0xbfac 5000-0xbfad a000`是栈空间，其中高地址的部分保存着进程的环境变量和命令行参数，低地址的部分保存函数栈帧，**栈空间是向低地址增长的**.这个向低地址增长就是先使用高地址,后使用低地址的意思.
```
0x0000092 -> ... ->0x0000002 -> 0x0000001
```
## 2 高低位
### 基础
* 这个`高地址`与`低地址`容易与`高位``低位`产生混淆.比如我这个月工资为`1234`(一千二百叁拾肆块),那么这串数字的左边我们称呼为高位，右边称为低位.(这个高低来自于人类的阅读习惯,数字从左向右,表示由大到小)
### 实例
* 在计算机中以`int`类型存储工资,假设`int`占用四个字节,每个字节地址如下
```
0x00008
0x00009
0x0000a
0x0000b
```
* 把工资加载到内存中时，就会有两种存储方式，如下:
```
// 大端法
0x00008 => 1
0x00009 => 2
0x0000a => 3
0x0000b => 4
```
* 或者
```
// 小端法
0x00008 => 4
0x00009 => 3
0x0000a => 2
0x0000b => 1
```
* 内存中的低地址存储工资中的高位这种方式称为`大端法`.如果把上边的存储方式反过来,内存中的高地址存储工资中的高位,则称为`小端法 little endian`.
* 主机采用大端还是小端表示数据由CPU的架构决定,如果两个主机只见交互数据,但是字节序表示不同,需要同化.

1
C++/面试/7.C++函数调用栈.md Normal file
View File

@@ -0,0 +1 @@
## 1

785
C++/面试/8.标准库-头文件md Normal file
View File

@@ -0,0 +1,785 @@
## 1 C 标准库
其中包含的引用头文件如下：
```C
#include <assert.h> //设定插入点
#include <ctype.h> //字符处理
#include <errno.h> //定义错误码
#include <float.h> //浮点数处理
#include <fstream.h> //文件输入/输出
#include <iomanip.h> //参数化输入/输出
#include <iostream.h> //数据流输入/输出
#include <limits.h> //定义各种数据类型最值常量
#include <locale.h> //定义本地化函数
#include <math.h> //定义数学函数
#include <stdio.h> //定义输入/输出函数
#include <stdlib.h> //定义杂项函数及内存分配函数
#include <string.h> //字符串处理
#include <strstrea.h> //基于数组的输入/输出
#include <time.h> //定义关于时间的函数
#include <wchar.h> //宽字符处理及输入/输出
#include <wctype.h> //宽字符分类
```
## 2 C++标准库
### 分类
C++标准库由三组库构成：
- C 库：由 C 标准库扩展而来，强调结构、函数和过程，不支持面向对象技术。
- C++库：增加了面向对象的库，包含了既有关键功能的类
- 标准模板库（STL）：高效的 C++程序库。该库包含了诸多在计算机科学领域里所常用的基本数据结构和基本算法。
以上库文件都被定义在 namespace std 中。C++库可以不规定头文件的扩展名。
### C1. 标准库中与语言支持功能相关的头文件
<table border="1" cellpadding="0" cellspacing="0">
<thead>
<tr>
<td>
<p align="center">头文件</p>
</td>
<td>
<p align="center">描&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 述</p>
</td>
</tr>
</thead>
<tbody>
<tr>
<td>
<p>&lt;cstddef&gt;</p>
</td>
<td>
<p>定义宏NULL和offsetof，以及其他标准类型size_t和ptrdiff_t。与对应的标准C头文件的区别是，NULL是C++空指针常量的补充定义，宏offsetof接受结构或者联合类型参数，只要他们没有成员指针类型的非静态成员即可。
</p>
</td>
</tr>
<tr>
<td>
<p>&lt;limits&gt;</p>
</td>
<td>
<p>提供与基本数据类型相关的定义。例如，对于每个数值数据类型，它定义了可以表示出来的最大值和最小值以及二进制数字的位数。</p>
</td>
</tr>
<tr>
<td>
<p>&lt;climits&gt;</p>
</td>
<td>
<p>提供与基本整数数据类型相关的C样式定义。这些信息的C++样式定义在&lt;limits&gt;中</p>
</td>
</tr>
<tr>
<td>
<p>&lt;cfloat&gt;</p>
</td>
<td>
<p>提供与基本浮点型数据类型相关的C样式定义。这些信息的C++样式定义在&lt;limits&gt;中</p>
</td>
</tr>
<tr>
<td>
<p>&lt;cstdlib&gt;</p>
</td>
<td>
<p>提供支持程序启动和终止的宏和函数。这个头文件还声明了许多其他杂项函数，例如搜索和排序函数，从字符串转换为数值等函数。它与对应的标准C头文件stdlib.h不同，定义了abort(void)。abort()函数还有额外的功能，它不为静态或自动对象调用析构函数，也不调用传给atexit()函数的函数。它还定义了exit()函数的额外功能，可以释放静态对象，以注册的逆序调用用atexit()注册的函数。清除并关闭所有打开的C流，把控制权返回给主机环境。
</p>
</td>
</tr>
<tr>
<td>
<p>&lt;new&gt;</p>
</td>
<td>
<p>支持动态内存分配</p>
</td>
</tr>
<tr>
<td>
<p>&lt;typeinfo&gt;</p>
</td>
<td>
<p>支持变量在运行期间的类型标识</p>
</td>
</tr>
<tr>
<td>
<p>&lt;exception&gt;</p>
</td>
<td>
<p>支持异常处理，这是处理程序中可能发生的错误的一种方式</p>
</td>
</tr>
<tr>
<td>
<p>&lt;cstdarg&gt;</p>
</td>
<td>
<p>支持接受数量可变的参数的函数。即在调用函数时，可以给函数传送数量不等的数据项。它定义了宏va_arg、va_end、va_start以及va_list类型</p>
</td>
</tr>
<tr>
<td>
<p>&lt;csetjmp&gt;</p>
</td>
<td>
<p>为C样式的非本地跳跃提供函数。这些函数在C++中不常用</p>
</td>
</tr>
<tr>
<td>
<p>&lt;csignal&gt;</p>
</td>
<td>
<p>为中断处理提供C样式支持</p>
</td>
</tr>
</tbody>
</table>
### C2. 支持流输入/输出的头文件
<table border="1" cellpadding="0" cellspacing="0">
<tbody>
<tr>
<td>
<p align="center">头文件</p>
</td>
<td>
<p align="center">描&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 述</p>
</td>
</tr>
<tr>
<td>
<p>&lt;iostream&gt;</p>
</td>
<td>
<p>支持标准流cin、cout、cerr和clog的输入和输出，它还支持多字节字符标准流wcin、wcout、wcerr和wclog。</p>
</td>
</tr>
<tr>
<td>
<p>&lt;iomanip&gt;</p>
</td>
<td>
<p>提供操纵程序，允许改变流的状态，从而改变输出的格式。</p>
</td>
</tr>
<tr>
<td>
<p>&lt;ios&gt;</p>
</td>
<td>
<p>定义iostream的基类</p>
</td>
</tr>
<tr>
<td>
<p>&lt;istream&gt;</p>
</td>
<td>
<p>为管理输出流缓存区的输入定义模板类</p>
</td>
</tr>
<tr>
<td>
<p>&lt;ostream&gt;</p>
</td>
<td>
<p>为管理输出流缓存区的输出定义模板类</p>
</td>
</tr>
<tr>
<td>
<p>&lt;sstream&gt;</p>
</td>
<td>
<p>支持字符串的流输入输出</p>
</td>
</tr>
<tr>
<td>
<p>&lt;fstream&gt;</p>
</td>
<td>
<p>支持文件的流输入输出</p>
</td>
</tr>
<tr>
<td>
<p>&lt;iosfwd&gt;</p>
</td>
<td>
<p>为输入输出对象提供向前的声明</p>
</td>
</tr>
<tr>
<td>
<p>&lt;streambuf&gt;</p>
</td>
<td>
<p>支持流输入和输出的缓存</p>
</td>
</tr>
<tr>
<td>
<p>&lt;cstdio&gt;</p>
</td>
<td>
<p>为标准流提供C样式的输入和输出</p>
</td>
</tr>
<tr>
<td>
<p>&lt;cwchar&gt;</p>
</td>
<td>
<p>支持多字节字符的C样式输入输出</p>
</td>
</tr>
</tbody>
</table>
### C3. 与诊断功能相关的头文件
<table border="1" cellpadding="0" cellspacing="0">
<tbody>
<tr>
<td>
<p align="center">头文件</p>
</td>
<td>
<p align="center">描&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 述</p>
</td>
</tr>
<tr>
<td>
<p>&lt;stdexcept&gt;</p>
</td>
<td>
<p>定义标准异常。异常是处理错误的方式</p>
</td>
</tr>
<tr>
<td>
<p>&lt;cassert&gt;</p>
</td>
<td>
<p>定义断言宏，用于检查运行期间的情形</p>
</td>
</tr>
<tr>
<td>
<p>&lt;cerrno&gt;</p>
</td>
<td>
<p>支持C样式的错误信息</p>
</td>
</tr>
</tbody>
</table>
### C4. 定义工具函数的头文件
<table border="1" cellpadding="0" cellspacing="0">
<tbody>
<tr>
<td>
<p align="center">头文件</p>
</td>
<td>
<p align="center">描&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 述</p>
</td>
</tr>
<tr>
<td>
<p>&lt;utility&gt;</p>
</td>
<td>
<p>定义重载的关系运算符，简化关系运算符的写入，它还定义了pair类型，该类型是一种模板类型，可以存储一对值。这些功能在库的其他地方使用</p>
</td>
</tr>
<tr>
<td>
<p>&lt;functional&gt;</p>
</td>
<td>
<p>定义了许多函数对象类型和支持函数对象的功能，函数对象是支持operator()()函数调用运算符的任意对象</p>
</td>
</tr>
<tr>
<td>
<p>&lt;memory&gt;</p>
</td>
<td>
<p>给容器、管理内存的函数和auto_ptr模板类定义标准内存分配器</p>
</td>
</tr>
<tr>
<td>
<p>&lt;ctime&gt;</p>
</td>
<td>
<p>支持系统时钟函数</p>
</td>
</tr>
</tbody>
</table>
### C5. 支持字符串处理的头文件
<table width="669" border="1" cellpadding="0" cellspacing="0">
<thead>
<tr>
<td>
<p align="center">头文件</p>
</td>
<td>
<p align="center">描&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 述</p>
</td>
</tr>
</thead>
<tbody>
<tr>
<td>
<p>&lt;string&gt;</p>
</td>
<td>
<p>为字符串类型提供支持和定义，包括单字节字符串(由char组成)的string和多字节字符串(由wchar_t组成)</p>
</td>
</tr>
<tr>
<td>
<p>&lt;cctype&gt;</p>
</td>
<td>
<p>单字节字符类别</p>
</td>
</tr>
<tr>
<td>
<p>&lt;cwctype&gt;</p>
</td>
<td>
<p>多字节字符类别</p>
</td>
</tr>
<tr>
<td>
<p>&lt;cstring&gt;</p>
</td>
<td>
<p>为处理非空字节序列和内存块提供函数。这不同于对应的标准C库头文件，几个C样式字符串的一般C库函数被返回值为const和非const的函数对替代了</p>
</td>
</tr>
<tr>
<td>
<p>&lt;cwchar&gt;</p>
</td>
<td>
<p>为处理、执行I/O和转换多字节字符序列提供函数，这不同于对应的标准C库头文件，几个多字节C样式字符串操作的一般C库函数被返回值为const和非const的函数对替代了。</p>
</td>
</tr>
<tr>
<td>
<p>&lt;cstdlib&gt;</p>
</td>
<td>
<p>为把单字节字符串转换为数值、在多字节字符和多字节字符串之间转换提供函数</p>
</td>
</tr>
</tbody>
</table>
### C6. 定义容器类的模板的头文件
<table border="1" cellpadding="0" cellspacing="0">
<tbody>
<tr>
<td>
<p align="center">头文件</p>
</td>
<td>
<p align="center">描&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 述</p>
</td>
</tr>
<tr>
<td>
<p>&lt;vector&gt;</p>
</td>
<td>
<p>定义vector序列模板，这是一个大小可以重新设置的数组类型，比普通数组更安全、更灵活</p>
</td>
</tr>
<tr>
<td>
<p>&lt;list&gt;</p>
</td>
<td>
<p>定义list序列模板，这是一个序列的链表，常常在任意位置插入和删除元素</p>
</td>
</tr>
<tr>
<td>
<p>&lt;deque&gt;</p>
</td>
<td>
<p>定义deque序列模板，支持在开始和结尾的高效插入和删除操作</p>
</td>
</tr>
<tr>
<td>
<p>&lt;queue&gt;</p>
</td>
<td>
<p>为队列(先进先出)数据结构定义序列适配器queue和priority_queue</p>
</td>
</tr>
<tr>
<td>
<p>&lt;stack&gt;</p>
</td>
<td>
<p>为堆栈(后进先出)数据结构定义序列适配器stack</p>
</td>
</tr>
<tr>
<td>
<p>&lt;map&gt;</p>
</td>
<td>
<p>map是一个关联容器类型，允许根据键值是唯一的，且按照升序存储。multimap类似于map，但键不是唯一的。</p>
</td>
</tr>
<tr>
<td>
<p>&lt;set&gt;</p>
</td>
<td>
<p>set是一个关联容器类型，用于以升序方式存储唯一值。multiset类似于set，但是值不必是唯一的。</p>
</td>
</tr>
<tr>
<td>
<p>&lt;bitset&gt;</p>
</td>
<td>
<p>为固定长度的位序列定义bitset模板，它可以看作固定长度的紧凑型bool数组</p>
</td>
</tr>
</tbody>
</table>
### C7. 支持迭代器的头文件
<table border="1" cellpadding="0" cellspacing="0">
<tbody>
<tr>
<td>
<p align="center">头文件</p>
</td>
<td>
<p align="center">描&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 述</p>
</td>
</tr>
<tr>
<td>
<p>&lt;iterator&gt;</p>
</td>
<td>
<p>给迭代器提供定义和支持</p>
</td>
</tr>
</tbody>
</table>
### C8. 有关算法的头文件
<table border="1" cellpadding="0" cellspacing="0">
<tbody>
<tr>
<td>
<p align="center">头文件</p>
</td>
<td>
<p align="center">描&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 述</p>
</td>
</tr>
<tr>
<td>
<p>&lt;algorithm&gt;</p>
</td>
<td>
<p>提供一组基于算法的函数，包括置换、排序、合并和搜索</p>
</td>
</tr>
<tr>
<td>
<p>&lt;cstdlib&gt;</p>
</td>
<td>
<p>声明C标准库函数bsearch()和qsort()，进行搜索和排序</p>
</td>
</tr>
<tr>
<td>
<p>&lt;ciso646&gt;</p>
</td>
<td>
<p>允许在代码中使用and代替&amp;&amp;</p>
</td>
</tr>
</tbody>
</table>
### C9. 有关数值操作的头文件
<table border="1" cellpadding="0" cellspacing="0">
<tbody>
<tr>
<td>
<p align="center">头文件</p>
</td>
<td>
<p align="center">描&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 述</p>
</td>
</tr>
<tr>
<td>
<p>&lt;complex&gt;</p>
</td>
<td>
<p>支持复杂数值的定义和操作</p>
</td>
</tr>
<tr>
<td>
<p>&lt;valarray&gt;</p>
</td>
<td>
<p>支持数值矢量的操作</p>
</td>
</tr>
<tr>
<td>
<p>&lt;numeric&gt;</p>
</td>
<td>
<p>在数值序列上定义一组一般数学操作，例如accumulate和inner_product</p>
</td>
</tr>
<tr>
<td>
<p>&lt;cmath&gt;</p>
</td>
<td>
<p>这是C数学库，其中还附加了重载函数，以支持C++约定</p>
</td>
</tr>
<tr>
<td>
<p>&lt;cstdlib&gt;</p>
</td>
<td>
<p>提供的函数可以提取整数的绝对值，对整数进行取余数操作</p>
</td>
</tr>
</tbody>
</table>
### C10. 有关本地化的头文件
<table border="1" cellpadding="0" cellspacing="0">
<tbody>
<tr>
<td>
<p align="center">头文件</p>
</td>
<td>
<p align="center">描&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 述</p>
</td>
</tr>
<tr>
<td>
<p>&lt;locale&gt;</p>
</td>
<td>
<p>提供的本地化包括字符类别、排序序列以及货币和日期表示。</p>
</td>
</tr>
<tr>
<td>
<p>&lt;clocale&gt;</p>
</td>
<td>
<p>对本地化提供C样式支持</p>
</td>
</tr>
</tbody>
</table>
## 3 C++标准模板库
STL（Standard Template Library，标准模板库)是惠普实验室开发的一系列软件的统称。现然主要出现在 C++中，但在被引入 C++之前该技术就已经存在了很长的一段时间。
STL 的代码从广义上讲分为三类：algorithm（算法）、container（容器）和 iterator（迭代器），几乎所有的代码都采 用了模板类和模版函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。在 C++标准中，STL 被组织为下面的 13 个头文 件：`<algorithm>、<deque>、<functional>、<iterator>、<vector>、<list>、<map>、<memory>、<numeric>、<queue>、<set>、<stack> 和<utility>`。
1、算法
函数库对数据类型的选择对其可重用性起着至关重要的作用。举例来说，一个求方根的函数，在使用浮点数作为其参数类型的情况下的可重用性肯定比使 用整型作为它的参数类性要高。而 C++通过模板的机制允许推迟对某些类型的选择，直到真正想使用模板或者说对模板进行特化的时候，STL 就利用了这一点提 供了相当多的有用算法。它是在一个有效的框架中完成这些算法的——可以将所有的类型划分为少数的几类，然后就可以在模版的参数中使用一种类型替换掉同一种 类中的其他类型。
STL 提供了大约 100 个实现算法的模版函数，比如算法 for_each 将为指定序列中的每一个元素调用指定的函数，stable_sort 以 你所指定的规则对序列进行稳定性排序等等。这样一来，只要熟悉了 STL 之后，许多代码可以被大大的化简，只需要通过调用一两个算法模板，就可以完成所需要 的功能并大大地提升效率。
算法部分主要由头文件<algorithm>，<numeric>和<functional>组 成。<algorithm>是所有 STL 头文件中最大的一个（尽管它很好理解），它是由一大堆模版函数组成的，可以认为每个函数在很大程度上 都是独立的，其中常用到的功能范围涉及到比较、交换、查找、遍历操作、复制、修改、移除、反转、排序、合并等等。<numeric>体积很 小，只包括几个在序列上面进行简单数学运算的模板函数，包括加法和乘法在序列上的一些操作。<functional>中则定义了一些模板类， 用以声明函数对象。
2、容器
在实际的开发过程中，数据结构本身的重要性不会逊于操作于数据结构的算法的重要性，当程序中存在着对时间要求很高的部分时，数据结构的选择就显得更加重要。
经典的数据结构数量有限，但是我们常常重复着一些为了实现向量、链表等结构而编写的代码，这些代码都十分相似，只是为了适应不同数据的变化而在 细节上有所出入。STL 容器就为我们提供了这样的方便，它允许我们重复利用已有的实现构造自己的特定类型下的数据结构，通过设置一些模版类，STL 容器对 最常用的数据结构提供了支持，这些模板的参数允许我们指定容器中元素的数据类型，可以将我们许多重复而乏味的工作简化。
容器部分主要由头文件`<vector>,<list>,<deque>,<set>,<map>,<stack> 和<queue>`组成。对于常用的一些容器和容器适配器（可以看作由其它容器实现的容器），可以通过下表总结一下它们和相应头文件的对应关 系。
<table border="1" cellpadding="0" cellspacing="0">
<tbody>
<tr>
<td>
<p align="center"><span style="color:black">数据结构</span></p>
</td>
<td>
<p align="center"><span style="color:black">描述</span></p>
</td>
<td>
<p align="center"><span style="color:black">实现头文件</span></p>
</td>
</tr>
<tr>
<td>
<p align="left"><span style="color:black">向量</span><span style="color:black">(vector)</span></p>
</td>
<td>
<p align="left"><span style="color:black">连续存储的元素</span></p>
</td>
<td>
<p align="left"><span style="color:black">&lt;vector&gt;</span></p>
</td>
</tr>
<tr>
<td>
<p align="left"><span style="color:black">列表</span><span style="color:black">(list)</span></p>
</td>
<td>
<p align="left"><span style="color:black">由节点组成的双向链表，每个结点包含着一个元素</span></p>
</td>
<td>
<p align="left"><span style="color:black">&lt;list&gt;</span></p>
</td>
</tr>
<tr>
<td>
<p align="left"><span style="color:black">双队列</span><span style="color:black">(deque)</span></p>
</td>
<td>
<p align="left"><span style="color:black">连续存储的指向不同元素的指针所组成的数组</span></p>
</td>
<td>
<p align="left"><span style="color:black">&lt;deque&gt;</span></p>
</td>
</tr>
<tr>
<td>
<p align="left"><span style="color:black">集合</span><span style="color:black">(set)</span></p>
</td>
<td>
<p align="left"><span
style="color:black">由节点组成的红黑树，每个节点都包含着一个元素，节点之间以某种作用于元素对的谓词排列，没有两个不同的元素能够拥有相同的次序</span></p>
</td>
<td>
<p align="left"><span style="color:black">&lt;set&gt;</span></p>
</td>
</tr>
<tr>
<td>
<p align="left"><span style="color:black">多重集合</span><span style="color:black">(multiset)</span></p>
</td>
<td>
<p align="left"><span style="color:black">允许存在两个次序相等的元素的集合</span></p>
</td>
<td>
<p align="left"><span style="color:black">&lt;set&gt;</span></p>
</td>
</tr>
<tr>
<td>
<p align="left"><span style="color:black">栈</span><span style="color:black">(stack)</span></p>
</td>
<td>
<p align="left"><span style="color:black">后进先出的值的排列</span></p>
</td>
<td>
<p align="left"><span style="color:black">&lt;stack&gt;</span></p>
</td>
</tr>
<tr>
<td>
<p align="left"><span style="color:black">队列</span><span style="color:black">(queue)</span></p>
</td>
<td>
<p align="left"><span style="color:black">先进先出的执的排列</span></p>
</td>
<td>
<p align="left"><span style="color:black">&lt;queue&gt;</span></p>
</td>
</tr>
<tr>
<td>
<p align="left"><span style="color:black">优先队列</span><span style="color:black">(priority_queue)</span>
</p>
</td>
<td>
<p align="left"><span style="color:black">元素的次序是由作用于所存储的值对上的某种谓词决定的的一种队列</span></p>
</td>
<td>
<p align="left"><span style="color:black">&lt;queue&gt;</span></p>
</td>
</tr>
<tr>
<td>
<p align="left"><span style="color:black">映射</span><span style="color:black">(map)</span></p>
</td>
<td>
<p align="left"><span style="color:black">由</span><span style="color:black">{
<!-- -->
</span><span style="color:black">键，值</span><span style="color:black">}</span><span
style="color:black">对组成的集合，以某种作用于键对上的谓词排列</span></p>
</td>
<td>
<p align="left"><span style="color:black">&lt;map&gt;</span></p>
</td>
</tr>
<tr>
<td>
<p align="left"><span style="color:black">多重映射</span><span style="color:black">(multimap)</span></p>
</td>
<td>
<p align="left"><span style="color:black">允许键对有相等的次序的映射</span></p>
</td>
<td>
<p align="left"><span style="color:black">&lt;map&gt;</span></p>
</td>
</tr>
</tbody>
</table>
3、迭代器
迭代器从作用上来说是最基本的部分，可是理解起来比前两者都要费力一些。软件设计有一个基本原则，所有的问题都可以通过引进一个间接层来简化， 这种简化在 STL 中就是用迭代器来完成的。概括来说，迭代器在 STL 中用来将算法和容器联系起来，起着一种黏和剂的作用。几乎 STL 提供的所有算法都是通 过迭代器存取元素序列进行工作的，每一个容器都定义了其本身所专有的迭代器，用以存取容器中的元素。
迭代器部分主要由头文件<utility>,<iterator>和<memory>组 成。<utility>是一个很小的头文件，它包括了贯穿使用在 STL 中的几个模板的声明，<iterator>中提供了迭代器 使用的许多方法，而对于<memory>的描述则十分的困难，它以不同寻常的方式为容器中的元素分配存储空间，同时也为某些算法执行期间产生 的临时对象提供机制,<memory>中的主要部分是模板类 allocator，它负责产生所有容器中的默认分配器。

22
C++/面试/9.C&C++字符串数组相互转换.md Normal file
View File

@@ -0,0 +1,22 @@
## 字符串转换
## 2 数组转换
### 数组转 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));
```
### vector 转数组
由于 vector 内部的数据是存放在连续的存储空间，vector 转数组事实上只需要获取 vector 中第一个数据的地址和数据的长度即可。如果仅仅是传参，无需任何操作，直接传地址即可，如果要进行数据复制，可以借用内存拷贝函数“memcpy”。例如：
```
float *buffer = new float[sizeof(arrHeight)];
if (!vecHeight.empty())
{
memcpy(buffer, &vecHeight[0], vecHeight.size()*sizeof(float));
}
```

12
C++/面试/a.h
View File

@@ -3,13 +3,13 @@
extern int a;//仅进行声明
// int a=11;
// int aaa=10;
const int aaa=10;//定义常量，在文件内部有效。
// class M;//仅进行声明
// class N//对类类型进行了定义（当包含定义的时候，就应该尽量避免多次定义，使用条件编译进行控制）。类型定义并没有生成变量。
// {
// int m;//仅进行声明
// int world();//仅进行声明
// };
class N//对类类型进行了定义（当包含定义的时候，就应该尽量避免多次定义，使用条件编译进行控制）。类型定义并没有生成变量。
{
int m;//仅进行声明
int world();//仅进行声明
};
// extern N k;//仅声明了了一个变量
int hello();//仅仅进行声明，extern可有可无，省略了extern
// int hhh(){return 0;};//声明并定义了方法，会报错。