From edfbd9446046f8e032a76305ddd9229572c7ed9a Mon Sep 17 00:00:00 2001 From: Menghui Xie Date: Tue, 19 Jun 2018 19:54:08 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BD=BF=E7=94=A8
=E9=9A=90?= =?UTF-8?q?=E8=97=8F=E4=B8=8D=E9=87=8D=E8=A6=81=E7=9A=84=E4=BB=A3=E7=A0=81?= =?UTF-8?q?=E5=92=8C=E5=9B=BE=E7=89=87?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 285 +++++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 228 insertions(+), 57 deletions(-) diff --git a/README.md b/README.md index 141481f..e26c83f 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,18 @@ ## C/C++ -

const


+### const + +#### 作用 + +1. 修饰变量，说明该变量不可以被改变； +2. 修饰指针，分为指向常量的指针和指针常量； +3. 常量引用，经常用于形参类型，即避免了拷贝，又避免了函数对值的修改； +4. 修饰成员函数，说明该成员函数内不能修改成员变量。 + +#### 使用 + +
const 使用 ```cpp // 类 @@ -77,17 +88,8 @@ const int* function6(); // 返回一个指向常量的指针变量，使用 int* const function7(); // 返回一个指向变量的常指针，使用：int* const p = function7(); ``` -#### 作用 - -1. 修饰变量，说明该变量不可以被改变； -2. 修饰指针，分为指向常量的指针和指针常量； -3. 常量引用，经常用于形参类型，即避免了拷贝，又避免了函数对值的修改； -4. 修饰成员函数，说明该成员函数内不能修改成员变量。 - -
- ### volatile ```cpp @@ -132,6 +134,9 @@ volatile int i = 10; #### 使用 +
inline 使用 + + ```cpp // 声明1（加 inline，建议使用） inline int functionName(int first, int secend,...); @@ -143,6 +148,8 @@ int functionName(int first, int secend,...); inline int functionName(int first, int secend,...) {/****/}; ``` +
+ #### 编译器对inline函数的处理步骤 1. 将 inline 函数体复制到 inline 函数调用点处； @@ -173,6 +180,9 @@ inline int functionName(int first, int secend,...) {/****/}; * 内联是在编译器建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。 * `inline virtual` 唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如 `Base::who()`），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。 +
虚函数内联使用 + + ```cpp #include using namespace std; @@ -213,6 +223,8 @@ int main() } ``` +
+ ### assert() 断言，是宏，而非函数。assert 宏的原型定义在``（C）、``（C++）中，其作用是如果它的条件返回错误，则终止程序执行。 @@ -232,7 +244,8 @@ assert( p != NULL ); 设定结构体、联合以及类成员变量以 n 字节方式对齐 -如 +
#pragma pack(n) 使用 + ```cpp #pragma pack(push) // 保存对齐状态 @@ -248,6 +261,8 @@ struct test #pragma pack(pop) // 恢复对齐状态 ``` +
+ ### extern "C" * 被 extern 限定的函数或变量是 extern 类型的 @@ -255,6 +270,8 @@ struct test `extern "C"` 的作用是让 C++ 编译器将 `extern "C"` 声明的代码当作 C 语言代码处理，可以避免 C++ 因符号修饰导致代码不能和C语言库中的符号进行链接的问题。 +
extern "C" 使用 + ```cpp #ifdef __cplusplus extern "C" { @@ -267,6 +284,8 @@ void *memset(void *, int, size_t); #endif ``` +
+ ### struct 和 typedef struct #### C 中 @@ -346,7 +365,7 @@ int main() { explicit 修饰的构造函数可用来防止隐式转换 -如下 +
explicit 使用 ```cpp class Test1 @@ -380,6 +399,8 @@ int main() } ``` +
+ ### friend 友元类和友元函数 * 能访问私有成员 @@ -388,23 +409,37 @@ int main() * 友元关系的单向性 * 友元声明的形式及数量不受限制 -### using 引入命名空间成员 +### using + +#### using 声明 + +一条 `using 声明` 语句一次只引入命名空间的一个成员。它使得我们可以清楚知道程序中所引用的到底是哪个名字。如： ```cpp -using namespace_name::name +using namespace_name::name; ``` -#### 尽量不要使用 `using namespace std;` 污染命名空间 +#### using 指示 + +`using 指示` 使得某个特定命名空间中所有名字都可见，这样我们就无需再为它们添加任何前缀限定符了。如： + +```cpp +using namespace_name name; +``` + +#### 尽量少使用 `using 指示` 污染命名空间 > 一般说来，使用 using 命令比使用 using 编译命令更安全，这是由于它**只导入了制定的名称**。如果该名称与局部名称发生冲突，编译器将**发出指示**。using编译命令导入所有的名称，包括可能并不需要的名称。如果与局部名称发生冲突，则**局部名称将覆盖名称空间版本**，而编译器**并不会发出警告**。另外，名称空间的开放性意味着名称空间的名称可能分散在多个地方，这使得难以准确知道添加了哪些名称。 -尽量不要使用 +
using 使用 + +尽量少使用 `using 指示` ```cpp using namespace std; ``` -应该使用 +应该多使用 `using 声明` ```cpp int x; @@ -423,23 +458,40 @@ cin >> x; cout << x << endl; ``` +
+ ### :: 范围解析运算符 -`::` 可以加在类型名称（类、类成员、成员函数、变量等）前，表示作用域为全局命名空间 +#### 分类 -如 +1. 全局作用域符（`::name`）：用于类型名称（类、类成员、成员函数、变量等）前，表示作用域为全局命名空间 +2. 类作用域符（`class::name`）：用于表示指定类型的作用域范围是具体某个类的 +3. 命名空间作用域符（`namespace::name`）:用于表示指定类型的作用域范围是具体某个命名空间的 + +
:: 使用 ```cpp -int count = 0; // global count +int count = 0; // 全局（::）的 count + +class A { +public: + static int count; // 类 A 的 count（A::count） +}; int main() { - int count = 0; // local count - ::count = 1; // set global count to 1 - count = 2; // set local count to 2 - return 0; + ::count = 1; // 设置全局的 count 的值为 1 + + A::count = 2; // 设置类 A 的 count 为 2 + + int count = 0; // 局部的 count + count = 3; // 设置局部的 count 的值为 3 + + return 0; } ``` +
+ ### 宏 * 宏定义可以实现类似于函数的功能，但是它终归不是函数，而宏定义中括弧中的“参数”也不是真的参数，在宏展开的时候对 “参数” 进行的是一对一的替换。 @@ -509,6 +561,8 @@ public: * 构造函数不能是虚函数（因为在调用构造函数时，虚表指针并没有在对象的内存空间中，必须要构造函数调用完成后才会形成虚表指针） * 内联函数不能是表现多态性时的虚函数，解释见：[虚函数（virtual）可以是内联函数（inline）吗？](https://github.com/huihut/interview#%E8%99%9A%E5%87%BD%E6%95%B0virtual%E5%8F%AF%E4%BB%A5%E6%98%AF%E5%86%85%E8%81%94%E5%87%BD%E6%95%B0inline%E5%90%97) +
动态多态使用 + ```cpp class Shape // 形状类 { @@ -545,7 +599,13 @@ int main() } ``` -* 虚析构函数 +
+ +### 虚析构函数 + +虚析构函数是为了解决基类的指针指向派生类对象，并用基类的指针删除派生类对象。 + +
虚析构函数使用 ```cpp class Shape @@ -571,33 +631,16 @@ int main() } ``` -* 纯虚函数 （含有纯虚函数的类叫做抽象类） +
+ +### 纯虚函数 + +纯虚函数是一种特殊的虚函数，在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，它的实现留给该基类的派生类去做。 ```cpp virtual int A() = 0; ``` -### 抽象类、接口类、聚合类 - -* 抽象类：含有纯虚函数的类 -* 接口类：仅含有纯虚函数的抽象类 -* 聚合类：用户可以直接访问其成员，并且具有特殊的初始化语法形式。满足如下特点： - * 所有成员都是 public - * 没有有定于任何构造函数 - * 没有类内初始化 - * 没有基类，也没有 virtual 函数 - * 如： - ```cpp - // 定义 - struct Date - { - int ival; - string s; - } - // 初始化 - Data vall = { 0, "Anna" }; - ``` - ### 虚函数、纯虚函数 [CSDN . C++ 中的虚函数、纯虚函数区别和联系](https://blog.csdn.net/u012260238/article/details/53610462) @@ -612,9 +655,7 @@ virtual int A() = 0; * 虚函数指针：在含有虚函数类的对象中，指向虚函数表，在运行时确定。 * 虚函数表：在程序只读数据段（`.rodata section`，见：[目标文件存储结构](#%E7%9B%AE%E6%A0%87%E6%96%87%E4%BB%B6%E5%AD%98%E5%82%A8%E7%BB%93%E6%9E%84)），存放虚函数指针，如果派生类实现了基类的某个虚函数，则在虚表中覆盖原本基类的那个虚函数指针，在编译时根据类的声明创建。 -### 虚继承、虚函数 - -#### 虚继承 +### 虚继承 虚继承用于解决多继承条件下的菱形继承问题（浪费存储空间、存在二义性）。 @@ -622,7 +663,7 @@ virtual int A() = 0; 实际上，vbptr 指的是虚基类表指针（virtual base table pointer），该指针指向了一个虚基类表（virtual table），虚表中记录了虚基类与本类的偏移地址；通过偏移地址，这样就找到了虚基类成员，而虚继承也不用像普通多继承那样维持着公共基类（虚基类）的两份同样的拷贝，节省了存储空间。 -#### 虚继承与虚函数 +### 虚继承、虚函数 * 相同之处：都利用了虚指针（均占用类的存储空间）和虚表（均不占用类的存储空间） * 不同之处： @@ -633,6 +674,16 @@ virtual int A() = 0; * 虚函数不占用存储空间 * 虚函数表存储的是虚函数地址 +### 抽象类、接口类、聚合类 + +* 抽象类：含有纯虚函数的类 +* 接口类：仅含有纯虚函数的抽象类 +* 聚合类：用户可以直接访问其成员，并且具有特殊的初始化语法形式。满足如下特点： + * 所有成员都是 public + * 没有有定于任何构造函数 + * 没有类内初始化 + * 没有基类，也没有 virtual 函数 + ### 内存分配和管理 #### malloc、calloc、realloc、alloca @@ -644,6 +695,10 @@ virtual int A() = 0; #### malloc、free +用于分配、释放内存 + +
malloc、free 使用 + 申请内存，确认是否申请成功 ```cpp @@ -658,12 +713,18 @@ free(p); p = nullptr; ``` +
+ #### new、delete 1. new/new[]：完成两件事，先底层调用 malloc 分了配内存，然后调用构造函数（创建对象）。 2. delete/delete[]：也完成两件事，先调用析构函数（清理资源），然后底层调用 free 释放空间。 3. new 在申请内存时会自动计算所需字节数，而 malloc 则需我们自己输入申请内存空间的字节数。 +
new、delete 使用 + +申请内存，确认是否申请成功 + ```cpp int main() { @@ -673,7 +734,9 @@ int main() } ``` -##### delete this 合法吗？ +
+ +### delete this 合法吗？ [Is it legal (and moral) for a member function to say delete this?](https://isocpp.org/wiki/faq/freestore-mgmt#delete-this) @@ -684,17 +747,17 @@ int main() 3. 必须保证成员函数的 `delete this ` 后面没有调用 this 了 4. 必须保证 `delete this` 后没有人使用了 -#### 如何定义一个只能在堆上（栈上）生成对象的类？ +### 如何定义一个只能在堆上（栈上）生成对象的类？ [如何定义一个只能在堆上（栈上）生成对象的类?](https://www.nowcoder.com/questionTerminal/0a584aa13f804f3ea72b442a065a7618) -##### 只能在堆上 +#### 只能在堆上 方法：将析构函数设置为私有 原因：C++ 是静态绑定语言，编译器管理栈上对象的生命周期，编译器在为类对象分配栈空间时，会先检查类的析构函数的访问性。若析构函数不可访问，则不能在栈上创建对象。 -##### 只能在栈上 +#### 只能在栈上 方法：将 new 和 delete 重载为私有 @@ -787,6 +850,8 @@ unique_ptr 是 C++11 才开始提供的类型，是一种在异常时可以帮 * 由于强制转换为引用类型失败，dynamic_cast 运算符引发 bad_cast 异常。 +
bad_cast 使用 + ```cpp try { Circle& ref_circle = dynamic_cast(ref_shape); @@ -796,6 +861,8 @@ catch (bad_cast b) { } ``` +
+ ### 运行时类型信息 (RTTI) #### dynamic_cast @@ -814,7 +881,7 @@ catch (bad_cast b) { * type_info 类描述编译器在程序中生成的类型信息。 此类的对象可以有效存储指向类型的名称的指针。 type_info 类还可存储适合比较两个类型是否相等或比较其排列顺序的编码值。 类型的编码规则和排列顺序是未指定的，并且可能因程序而异。 * 头文件：`typeinfo` -#### 例子 +
typeid、type_info 使用 ```cpp class Flyable // 能飞的 @@ -866,6 +933,8 @@ class doSomething(Flyable *obj) // 做些事情 }; ``` +
+ ### Effective C++ 1. 视 C++ 为一个语言联邦（C、Object-Oriented C++、Template C++、STL） @@ -900,10 +969,14 @@ class doSomething(Flyable *obj) // 做些事情 ### Google C++ Style Guide +
Google C++ Style Guide 图 + ![Google C++ Style Guide](http://img.blog.csdn.net/20140713220242000) > 图片来源于：[CSDN . 一张图总结Google C++编程规范(Google C++ Style Guide)](http://blog.csdn.net/voidccc/article/details/37599203) +
+ ## STL ### 索引 @@ -943,6 +1016,8 @@ hash_multimap|hash表|无序|可重复| [SqStack.cpp](DataStructure/SqStack.cpp) +
顺序栈数据结构和图片 + ```cpp typedef struct { ElemType *elem; @@ -954,8 +1029,12 @@ typedef struct { ![](images/SqStack.png) +
+ #### 队列（Sequence Queue） +
队列数据结构 + ```cpp typedef struct { ElemType * elem; @@ -965,22 +1044,34 @@ typedef struct { }SqQueue; ``` +
+ ##### 非循环队列 +
非循环队列图片 + ![](images/SqQueue.png) `SqQueue.rear++` +
+ ##### 循环队列 +
循环队列图片 + ![](images/SqLoopStack.png) `SqQueue.rear = (SqQueue.rear + 1) % SqQueue.maxSize` +
+ #### 顺序表（Sequence List） [SqList.cpp](DataStructure/SqList.cpp) +
顺序表数据结构和图片 + ```cpp typedef struct { ElemType *elem; @@ -992,12 +1083,17 @@ typedef struct { ![](images/SqList.png) +
+ + ### 链式结构 [LinkList.cpp](DataStructure/LinkList.cpp) [LinkList_with_head.cpp](DataStructure/LinkList_with_head.cpp) +
链式数据结构 + ```cpp typedef struct LNode { ElemType data; @@ -1005,24 +1101,43 @@ typedef struct LNode { } LNode, *LinkList; ``` +
+ #### 链队列（Link Queue） +
链队列图片 + ![](images/LinkQueue.png) +
+ #### 线性表的链式表示 ##### 单链表（Link List） +
单链表图片 + ![](images/LinkList.png) +
+ + ##### 双向链表（Du-Link-List） +
双向链表图片 + ![](images/DuLinkList.png) +
+ ##### 循环链表（Cir-Link-List） +
循环链表图片 + ![](images/CirLinkList.png) +
+ ### 哈希表 [HashTable.cpp](DataStructure/HashTable.cpp) @@ -1049,8 +1164,9 @@ typedef struct LNode { #### 线性探测的哈希表数据结构 -```cpp +
线性探测的哈希表数据结构和图片 +```cpp typedef char KeyType; typedef struct { @@ -1064,8 +1180,12 @@ typedef struct { bool *tag; }HashTable; ``` + ![](images/HashTable.png) +
+ + ### 递归 #### 概念 @@ -1091,6 +1211,8 @@ typedef struct { ##### 头尾链表存储表示 +
广义表的头尾链表存储表示和图片 + ```cpp // 广义表的头尾链表存储表示 typedef enum {ATOM, LIST} ElemTag; @@ -1112,8 +1234,12 @@ typedef struct GLNode { ![](images/GeneralizedList1.png) +
+ ##### 扩展线性链表存储表示 +
扩展线性链表存储表示和图片 + ```cpp // 广义表的扩展线性链表存储表示 typedef enum {ATOM, LIST} ElemTag; @@ -1133,6 +1259,8 @@ typedef struct GLNode1 { ![](images/GeneralizedList2.png) +
+ ### 二叉树 [BinaryTree.cpp](DataStructure/BinaryTree.cpp) @@ -1150,6 +1278,8 @@ typedef struct GLNode1 { #### 存储结构 +
二叉树数据结构 + ```cpp typedef struct BiTNode { @@ -1158,14 +1288,25 @@ typedef struct BiTNode }BiTNode, *BiTree; ``` +
+ + ##### 顺序存储 +
二叉树顺序存储图片 + ![](images/SqBinaryTree.png) +
+ ##### 链式存储 +
二叉树链式存储图片 + ![](images/LinkBinaryTree.png) +
+ #### 遍历方式 * 先序遍历 @@ -1207,8 +1348,12 @@ typedef struct BiTNode * 平衡二叉树必定是二叉搜索树，反之则不一定 * 最小二叉平衡树的节点的公式：`F(n)=F(n-1)+F(n-2)+1` （1 是根节点，F(n-1) 是左子树的节点数量，F(n-2) 是右子树的节点数量） +
平衡二叉树图片 + ![](images/Self-balancingBinarySearchTree.png) +
+ ##### 最小失衡树 平衡二叉树插入新结点导致失衡的子树 @@ -1247,8 +1392,12 @@ typedef struct BiTNode #### B 树（B-tree）、B+ 树（B+-tree） +
B 树、B+ 树图片 + ![B 树（B-tree）、B+ 树（B+-tree）](https://i.stack.imgur.com/l6UyF.png) +
+ ##### 特点 * 一般化的二叉查找树（binary search tree） @@ -1276,8 +1425,12 @@ typedef struct BiTNode #### 八叉树 +
八叉树图片 + ![](https://upload.wikimedia.org/wikipedia/commons/thumb/3/35/Octree2.png/400px-Octree2.png) +
+ 八叉树（octree），或称八元树，是一种用于描述三维空间（划分空间）的树状数据结构。八叉树的每个节点表示一个正方体的体积元素，每个节点有八个子节点，这八个子节点所表示的体积元素加在一起就等于父节点的体积。一般中心点作为节点的分叉中心。 ##### 用途 @@ -1524,11 +1677,18 @@ B树/B+树 |O(log2n) | | 大端|12|34|56|78 小端|78|56|34|12 + +
大端小端图片 + ![大端序](images/CPU-Big-Endian.svg.png) ![小端序](images/CPU-Little-Endian.svg.png) +
+ ##### 判断大端小端 +
判断大端小端 + 可以这样判断自己 CPU 字节序是大端还是小端： ```cpp @@ -1547,6 +1707,9 @@ int main() return 0; } ``` + +
+ ##### 各架构处理器的字节序 * x86（Intel、AMD）、MOS Technology 6502、Z80、VAX、PDP-11 等处理器为小端序； @@ -1860,8 +2023,12 @@ TCP 是一个基于字节流的传输服务（UDP 基于报文的），“流” #### TCP 有限状态机 +
TCP 有限状态机图片 + ![TCP 的有限状态机](images/TCP的有限状态机.png) +
+ ### 应用层 #### DNS @@ -2199,6 +2366,8 @@ Linux 下的共享库就是普通的 ELF 共享对象。 ### Windows 的动态链接库（Dynamic-Link Library） +
Windows 动态链接库例子 + DLL 头文件 ```cpp #ifdef __cplusplus @@ -2234,6 +2403,8 @@ MODULE_API int module_init() } ``` +
+ ### 运行库（Runtime Library） #### 典型程序运行步骤