在前面曾用静态、动态顺序表两种方式实现通讯录，但每次运行程序我们都得重新输入，之前输入的成员信息并不会保存，而现实中，通讯录里的信息创建后是永久保存的，除非你删除它，今天我们就来模拟一下如何将数据存储在文件中，当下一次运行时加载一下即可，这种做法更贴合实际。
程序中会用到与文件操作相关的函数，提前介绍一下：
- fopen 它的函数原型为：FILEfopen(const char filename,const char *mode) ，filename:创建文件的名字；mode:允许进入文件的类型;简单来说这个文件的作用就是打开一个文件流；与fclose:关闭文件流配套使用.
- perror: 它的函数原型为：void perror(const char * string) ,这是一种报告文件错误的函数；后面包括一个分号和一个空格，然后打印出一条用于解释errno当前错误代码的信息;
- fwrite: 它的函数原型为：size_t fwrite(const void buffer,size_t size,size_t count,FILEstream) ,buffer:数据写入的体格缓冲区；
- 初始化通讯录
- 添加联系人
- 查找联系人
- 删除联系人
- 修改联系人
- 按姓名排序
- 清空联系人
- 联系人列表
- 检查容量
- 加载文件
- 保存文件
- 销毁通讯录
- 退出
1 | /*********************************************************** |
1 |
|
1 |
|
]]>最初的自己是个编程菜鸟，然而通过努力的学习，现在也能逐渐的自己写小程序了，相信这就是一种进步，暂不希望自己能有多强大。只要每一步走的充实，我相信一定会有好的回报，且行且努力！
有一个字符数组的内容为: student a am i ,请将数组的内容改为 i am a student
要求：
不能使用库函数。只能开辟有限个空间（空间个数和字符串的长度无关）。
先将整个字符串整体逆置，再以每个单词为对象局部逆置（这时判断条件复杂一些）；这里逆置时，需要一个逆置函数，需要两个参数，首指针和尾指针，由这两个指针锁定一个区域，将里面的字符从头至尾逆置
注意：
- 最后一次跳出while循环时，相当于*pcur==’\0’,所以最后这个单词没有逆置，需要再次调用逆置函数
- if(表达式){语句1}语句2；这样的结构，无论if表达式成立与否，语句2都会执行的
1 |
|
结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。
1 | struct tag |
注意：程序应尽可能少定义全局变量，在程序中到处引用全局变量，会导致程序难以控制，容易出错。且声明不占用内存
例如描述一个学生1
2
3
4
5
6
7
8struct Stu
{
char name[20];//名字
int age;//年龄
char sex[5];//姓名
char telp[11];//电话号
char id[20];//学号
};//分号不能丢
特殊声明就是不完全声明又叫匿名结构体类型声明
1 | //匿名结构体类型声明 |
对于上面声明，均省略了结构体标签，而对于匿名结构体类型声明，编译器会把上面两个声明当成完全不同的 两个类型，所以对于p = &x是非法的
结构的成员可以是标量，数组，指针，甚至是其他结构体。
- 结构体变量访问成员： 结构变量成员通过点操作符（.）访问，点操作符接收两个操作数。
- 结构体访问指向变量的成员： 有时候我们得到不是一个结构体变量，而是一个指向结构体的指针，就应该用（->）操作符。
1 | struct Stu |
简而言之就是在结构中包含一个类型为结构本身的成员
1 | typedef struct Node |
1 | struct B; |
有了结构体类型，定义及初始化就很简单了
1 | struct Stu |
目前，我们已经掌握了结构体的基本使用了，现在来开始讨论一个问题：计算结构的大小。当然也是一个热门考点：结构体内存对齐
如何计算？
结构体内存对齐规则：
- 第一个成员在与结构体变量偏移量为0的地址处；
- 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。对齐数=编译器默认对齐数 与该成员自身大小中的最小值。VS默认值为8，linux中gcc默认值为4.
- 结构体总大小为最大对齐数的整数倍；
- 如果嵌套了结构体的情况，嵌套的结构体对齐到自己最大对齐数的整数倍处，结构体的大小就是所有对齐数中最大对齐数的整数倍。
注意：1
2
3
...
为什么存在内存对齐？
平台原因(移植原因):
- 不是所有硬件平台都能访问任意地址上的数据，某些硬件平台只能在某些地址处取某些特定类型的数据，否则肯呢个抛出硬件异常。
性能原因：
- 数据结构（尤其是栈）应该尽可能的在自然边界上对齐，原因在于：访问未对齐的内存，处理器需要两次访问，而访问对齐内存，处理器只需访问一次。
总的来说：结构体内存对齐就是用空间换取时间的做法，而我们在设计的时候既要满足内存对齐，还要满足节省空间，那么唯一做法：让占用空间小的成员尽可能集中在一起。
1 | //练习一 |
附加：
1 | //宏，表示结构体成员变量在内存中偏移量包含于头文件#include <stddef.h> |
讲解函数栈桢的时候，我们知道函数传参是需要参数压栈的，如果传递的是一个结构体对象，而结构体过大，参数压栈的系统开销就会很大，所以导致系统性能下降。
结论
结构体传参的时候要传结构体指针。
位段声明与结构体类型相似，有两个不同：
- 位段成员必须int 、unsigned int 或 signed int。
- 位段成员名后面有一个冒号和一个数字。
- 位段成员可以是int 、unsigned int、signed int、或者char(整形家族)类型。
- 位段的空间上按四个字节（int）或者一个字节（char）方式开辟
- 位段涉及很多不确定因素，位段是不跨平台的，注重可移植性程序因避免使用位段。
eg：1
2
3
4
5
6
7
8struct A
{
int a:2;
int b:5;
int c:10;
int d:30;
};
printf("%d",sizeof(struct A)); //8
- int位段当成有符号还是无符号是不确定的
- 位段中最大位数目不确定的
- 位段中成员是从左到右还是从右到左是不确定的
- 当一个结构体包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的还是利用，是不确定的
跟结构相比，位段可以达到同样的效果，还节省空间，但是因为存在跨平台问题，所以运用的就不是很多了。
枚举顾名思义就是一一列举。
比如：星期、颜色、性别等；
1 | enum Color |
以上定义的enum Color 就是枚举类型，{}中内容就是可能取值，也叫枚举常量，默认从零开始一次递增1，当然有时候也可以自定义赋值：1
2
3
4
5
6enum Color
{
RED = 1,
GREEN = 4,
BLUE = 8
};
- 增加代码可读性与可维护性
- 与#define相比有类型检查，更加严谨
- 防止命名污染
- 便于调试
- 使用方便，一次可定义多个常量
联合也是一种特殊自定义类型，该类型定义变量也包含一系列成员，特征是这些成员公用一块空间。
eg
1 | //联合类型声明 |
联合成员公用一块内存空间，这样一个联合变量大小，至少是最大成员大小。
判断当前计算机大小端存储：
1 | int CheckSystem（） |
- 联合大小至少是最大成员大小
- 当最大成员大小不是最大对齐数整数倍时，就要对齐到最大对齐数的整数倍
eg1
2
3
4
5
6
7
8
9
10
11
12union UN1
{
char arr[5];
int i;
};
union UN2
{
short c[7];
int i;
};
printf("%d",sizeof(union UN1)); //8
printf("%d",sizeof(union UN2)); //16
1 | //将long类型ip地址，转换为电分十进制形式 |
]]>通过自定义类型学习，掌握了内存对齐等相关运用，以及如何检验大小端问题。
好好学习，天天编程
- 初始化通讯录
- 添加联系人
- 查找联系人
- 删除联系人
- 修改联系人
- 按姓名排序
- 清空联系人
- 联系人列表
- 退出
1 | /*********************************************************** |
1 |
|
1 |
|
1 | /*********************************************************** |
1 |
|
1 |
|
今天简单实现了基于静态（动态）顺序表的通讯录，需再努力继续实现链表通讯录。
不忘初心，方得始终！
]]>二分查找，最基本的算法之一，也是面试中常被考察的重点，因为基本的算法最能反映出一个人的基础是否扎实。本文对二分查找相关题目做一个总结。
1 | int bin_search(int arr[], int n, int key) |
给定一个有序（非降序）数组A，求任意一个i使得A[i]等于key，不存在则返回-1
这个是最原始的二分查找题目，利用数组的有序特性，拆半查找，使得查找时间复杂度为O(logN)。请参考实现代码与注释。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16int search(int arr[], int n, int key)
{
int low = 0, high = n-1;
while(low <= high)
{
// 注意：若使用(low+high)/2求中间位置容易溢出
int mid = low+((high-low)>>1);
if(A[mid] == key)
return mid;
else if(A[mid] < key)
low = mid+1;
else // A[mid] > key
high = mid-1;
}
return -1;
}
给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]等于key，不存在则返回-1
此题也就是求key在数组中第一次出现的位置。这里可能会有人想先直接用原始的二分查找，如果不存在直接返回-1，如果存在，然后再顺序找到这个等于key值区间的最左位置，这样的话，最坏情况下的复杂度就是O（n）了，没有完全发挥出二分查找的优势。这里的解法具体过程请参考实现代码与注释。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23int searchFirstPos(int arr[], int n, int key)
{
if(n <= 0) return -1;
int low = 0, high = n-1;
while(low < high)
{
int mid = low+((high-low)>>1);
if(A[mid] < key)
low = mid+1;
else // A[mid] >= key
high = mid;
}
/*
循环过程中，当low大于0时，A[low-1]是小于key的，因为A[mid] < key时，
low=mid+1；当high小于n-1时，A[high]是大于等于key的，因为A[mid] >= key时，
high = mid；循环结束时，low 等于 high，所以，如果A[low](A[high])等于key，
那么low(high)就是key出现的最小位置，否则key在数组中不存在。
*/
if(A[low] != key)
return -1;
else
return low;
}
给定一个有序（非降序）数组A，可含有重复元素，求最大的i使得A[i]等于key，不存在则返回-1
此题也就是求key在数组中最后一次出现的位置。与上一题基本一样，但是有个地方要注意，具体请参考实现代码与注释。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28int searchLastPos(int arr[], int n, int key)
{
if(n <= 0) return -1;
int low = 0, high = n-1;
while(low < high)
{
/*
这里中间位置的计算就不能用low+((high-low)>>1)了，因为当low+1等于high
且A[low] <= key时，会死循环；所以这里要使用low+((high-low+1)>>1)，
这样能够保证循环会正常结束。
*/
int mid = low+((high-low+1)>>1);
if(A[mid] > key)
high = mid-1;
else // A[mid] <= key
low = mid;
}
/*
循环过程中，当high小于n-1时，A[high+1]是大于key的，因为A[mid] > key时，
high=mid-1；当low大于0时，A[low]是小于等于key的，因为A[mid] <= key时，
low = mid；循环结束时，low 等于 high，所以，如果A[high](A[low])等于key，
那么high(low)就是key出现的最大位置，否则key在数组中不存在。
*/
if(A[high] != key)
return -1;
else
return high;
}
给定一个有序（非降序）数组A，可含有重复元素，求最大的i使得A[i]小于key，不存在则返回-1
也就是求小于key的最大元素的位置。请参考实现代码与注释。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20int searchLastPosLessThan(int arr[], int n, int key)
{
if(n <= 0) return -1;
int low = 0, high = n-1;
while(low < high)
{
int mid = low+((high-low+1)>>1); // 注意，不要导致死循环
if(A[mid] < key)
low = mid;
else // A[mid] >= key
high = mid-1;
}
/*
循环过程中，当low大于0时，A[low]是小于key的，因为A[mid] < key时，
low=mid；当high小于n-1时，A[high+1]是大于等于key的，因为A[mid] >= key时，
high = mid-1；循环结束时，low 等于 high，所以，如果A[low](A[high])小于key，
那么low(high)就是要找的位置，否则不存在这样的位置（A[0] >= key时）。
*/
return A[low] < key ? low : -1;
}
给定一个有序（非降序）数组A，可含有重复元素，求最小的i使得A[i]大于key，不存在则返回-1。
也就是求大于key的最小元素的位置。请参考实现代码与注释。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20int searchFirstPosGreaterThan(int arr[], int n, int key)
{
if(n <= 0) return -1;
int low = 0, high = n-1;
while(low < high)
{
int mid = low+((high-low)>>1);
if(A[mid] > key)
high = mid;
else // A[mid] <= key
low = mid+1;
}
/*
循环过程中，当low大于0时，A[low-1]是小于等于key的，因为A[mid] <= key时，
low=mid+1；当high小于n-1时，A[high]是大于key的，因为A[mid] > key时，
high = mid；循环结束时，low 等于 high，所以，如果A[high](A[low])大于key，
那么high(low)就是要找的位置，否则不存在这样的位置（A[n-1] <= key时）。
*/
return A[high] > key ? high : -1;
}
给定一个有序（非降序）数组A，可含有重复元素，求key在数组中出现的次数
求出第一次出现位置和最后一次出现位置。由于前面都已实现，这里不多解释。请参考实现代码与注释1
2
3
4
5
6
7
8int count(int arr[], int n, int key)
{
int firstPos = searchFirstPos(A, n, key); // 第一次出现位置
if(firstPos == -1)
return 0;
int lastPos = searchLastPos(A, n, key); // 最后一次出现位置
return lastPos-firstPos+1; // 出现次数
}
给定一个有序（非降序）数组A，若key在数组中出现，返回位置，若不存在，返回它应该插入的位置
如 [1,3,5,6], 5 → 2
[1,3,5,6], 2 → 1
[1,3,5,6], 7 → 4
[1,3,5,6], 0 → 01
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21int searchInsert(int arr[], int n, int key) {
// 如果比最大值还大，那插入位置就是位置n
if(A[n-1] < key)
return n;
int low = 0, high = n-1;
while(low < high)
{
int mid = low+((high-low)>>1);
if(A[mid] >= key)
high = mid;
else // A[mid] < key
low = mid+1;
}
/*
循环过程中，当low大于0时，A[low-1]是小于key的，因为A[mid] < key时，
low=mid+1；当high小于n-1时，A[high]是大于等于key的，因为A[mid] >= key时，
high = mid；循环结束时，low 等于 high，所以，如果A[low](A[high])等于key，
那么low(high)就是key出现的位置，否则low就是key在数组中应该插入的位置。
*/
return high;
}
给定一个有序（非降序）数组A，可含有重复元素，求绝对值最小的元素的位置
找第一个大于等于0的位置，然后和前一个元素的绝对值比较，返回绝对值较小的元素的位置。请参考实现代码与注释1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17int searchMinAbs(int arr[], int n)
{
int low = 0, high = n-1;
while(low < high)
{
int mid = low+((high-low)>>1);
if(A[mid] < 0)
low = mid+1;
else // A[mid] >= 0
high = mid;
}
/* 循环结束时，如果low != n-1，A[low] >= 0，如果low>0，A[low-1] < 0 */
if(low > 0 && abs(A[low-1]) < abs(A[low]))
return low-1;
else
return low;
}
给定一个有序（非降序）数组A和一个有序（非降序）数组B，可含有重复元素，求两个数组合并结果中的第k(k>=0)个数字
这个题目出现了两个数组，有序的，不管怎样我们就应该首先考虑二分查找是否可行。若使用顺序查找，时间复杂度最低为O(k)，就是类似归并排序中的归并过程。使用用二分查找时间复杂度为O(logM+logN)。二分查找的具体实现过程请参考实现代码与注释。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43int findKthIn2SortedArrays(int arr[], int m, int B[], int n, int k)
{
if(m <= 0) // 数组A中没有元素，直接在B中找第k个元素
return B[k];
if(n <= 0) // 数组B中没有元素，直接在A中找第k个元素
return A[k];
int i = (m-1)>>1; // 数组A的中间位置
int j = (n-1)>>1; // 数组B的中间位置
if(A[i] <= B[j]) // 数组A的中间元素小于等于数组B的中间元素
{
/*
设x为数组A和数组B中小于B[j]的元素数目，则i+1+j+1小于等于x，
因为A[i+1]到A[m-1]中还可能存在小于等于B[j]的元素；
如果k小于i+1+j+1，那么要查找的第k个元素肯定小于等于B[j]，
因为x大于等于i+1+j+1；既然第k个元素小于等于B[j]，那么只
需要在A[0]~A[m-1]和B[0]~B[j]中查找第k个元素即可，递归调用下去。
*/
if(k < i+1+j+1)
{
if(j > 0)
return findKthIn2SortedArrays(A, m, B, j+1, k);
else // j == 0时特殊处理，防止死循环
{
if(k == 0)
return min(A[0], B[0]);
if(k == m)
return max(A[m-1], B[0]);
return A[k] < B[0] ? A[k] : max(A[k-1], B[0]);
}
}
/*
设y为数组A和数组B中小于于等于A[i]的元素数目，则i+1+j+1大于等于y；
如果k大于等于i+1+j+1，那么要查找到第k个元素肯定大于A[i]，因为
i+1+j+1大于等于y；既然第k个元素大于A[i]，那么只需要在A[i+1]~A[m-1]
和B[0]~B[n-1]中查找第k-i-1个元素，递归调用下去。
*/
else
return findKthIn2SortedArrays(A+i+1, m-i-1, B, n, k-i-1);
}
// 如果数组A的中间元素大于数组B的中间元素，那么交换数组A和B，重新调用即可
else
return findKthIn2SortedArrays(B, n, A, m, k);
}
一个有序（升序）数组，没有重复元素，在某一个位置发生了旋转后，求key在变化后的数组中出现的位置，不存在则返回-1
如 0 1 2 4 5 6 7 可能变成 4 5 6 7 0 1 2.
我们先比较中间元素是否是目标值，如果是返回位置。如果不是，我们就应该想办法将搜索区间减少一半。因为存在旋转变化，所以我们要多做一些判断。我们知道因为只有一次旋转变化，所以中间元素两边的子数组肯定有一个是有序的，那么我们可以判断key是不是在这个有序的子数组中，从而决定是搜索这个子数组还是搜索另一个子数组。具体请参考实现代码与注释。
1 | int searchInRotatedArray(int arr[], int n, int key) |
如果这样的数组中存在重复元素，还能使用二分吗？答案是不能。请看几个栗子：
[1, 2, 2, 2, 2], [2, 1, 2, 2, 2], [2, 2, 1, 2, 2], [2, 2, 2, 1, 2], [2, 2, 2, 2, 1]这些都是有第一个数组旋转一次变化来的，我们不能通过二分确定是否存在元素1.
一个有序（升序）数组，没有重复元素，在某一个位置发生了旋转后，求最小值所在位置
如果中间元素小于左端元素，则最小值在左半区间内（包含中间元素）；如果中间元素大于右端元素，则最小值在右半区间内（包含中间元素）。请参考实现代码与注释。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15int searchMinInRotatedArray(int arr[], int n)
{
if(n == 1)
return 0;
int low = 0, high = n-1;
while(low < high-1) // 保证mid != low且mid != high
{
int mid = low+((high-low)>>1);
if(A[mid] < A[low]) // 最小值在low~mid
high = mid;
else // A[mid] > A[low], // 最小值在mid和high之间
low = mid;
}
return A[low] < A[low+1] ? low : low+1;
}
一个有序（升序）数组，没有重复元素，在某一个位置发生了旋转后，求第k(k > 0)小元素的位置
我们可以利用上一题的解答，求出最小值所在位置后，便可以求出第k小元素。请参考实现代码与注释 1
2
3
4
5int searchKthInRotatedArray(int arr[], int n, int k)
{
int posMin = searchMinInRotatedArray(A, n);
return (posMin+k-1)%n;
}
查找数组中第一个比k大的数的下标
当low和high都是非负数时，使用 mid = low + (high - low) / 2;这种形式可以避免溢出。
当low和high一个为负另一个为非负时，用mid = (low + high) / 2;这种形式可以避免溢出。
1 |
|
]]>二分查找是个普遍考查点，只要深入了解某几个点就可以对二分查找运用自如。
要实现三子棋，首先思考三子棋怎么样实现的，如一下几点：
- 实现三子棋，在一个3*3的二维数组下把二维数组都初始化为 ‘ *’
- 电脑随机生成坐标，判断该坐标是否合法，合法赋值为 ‘0’
- 玩家输入合法坐标，该坐标赋值为 ‘X’
- 判断输赢，每一行，每一列，或者对角线上的值相等，则为赢。如果棋盘满了，还没有赢家，则为平局！返回 ‘Q’
1 | /********************************************************* |
1 |
|
1 |
|
]]>天天编程，天天向上！
栈帧也叫过程活动记录，是编译器用来实现函数调用过程的一种数据结构。C语言中，每个栈帧对应着一个未运行完的函数。从逻辑上讲，栈帧就是一个函数执行的环境：函数调用框架、函数参数、函数的局部变量、函数执行完后返回到哪里等等。栈是从高地址向低地址延伸的。每个函数的每次调用，都有它自己独立的一个栈帧，这个栈帧中维持着所需要的各种信息。寄存器ebp指向当前的栈帧的底部（高地址），寄存器esp指向当前的栈帧的顶部（低地址）。
我们以Add（）函数为例深入的研究一下函数的调用过程。
先看一段简单的代码：
1 |
|
当开始剖析程序调试的时候， 查看【调用堆栈】（按F10进入调试->窗口->调用堆栈，或快捷键ctrl+alt+C），用VS2013调试 如下图：
我们发现其实main函数在 tmai nCRTStartup 函数中调用的，而 tmai nCRTStartup 函数是在 mai nCRTStartup 被调用的。我们知道每一次函数调用都是一个过程。这个过程我们通常称之为： 函数的调用过程。这个过程要为函数开辟栈空间（运行时堆栈）， 用于本次函数的调用中临时变量的保存、 现场保护。 这块栈空间我们称之为函数栈帧。所以函数调用过程实际上就是函数栈桢创建与销毁。
而栈帧的维护我们必须了解ebp和esp两个寄存器。 在函数调用的过程中这两个寄存器存放了维护这个栈的栈底和栈顶指针。比如：调用main函数， 我们为main函数分配栈帧空间， 那么栈帧维护如下：
ebp存放了指向函数栈帧栈底的地址。esp存放了指向函数栈帧栈顶的地址。
注意：ebp指向当前位于系统栈最上边一个栈帧的底部，而不是系统栈的底部。严格说来，“栈帧底部”和“栈底”是不同的概念;esp所指的栈帧顶部和系统栈的顶部是同一个位置。
1 . main函数开始。 要展开main函数的调用就得为main函数创建栈帧， 那我们先来看main函数栈帧的创建。转到反汇编可以更清晰的看到过程：
过程分析：
- 首先mainCRTStartup()，__mainCRTStartup()函数的调用，调main()函数；
- 将ebp压栈处理，保存指向栈底的ebp的地址（方便函数返回之后的现场恢复），此时esp指向新的栈顶位置；
- 将esp的值赋给ebp，产生新的ebp；
- 给esp减去一个16进制数0E4H（为main函数预开辟空间）；
- push ebx、esi、edi；
- lea指令，加载有效地址；
- 初始化预开辟的空间为0xcccccccc；
- 创建变量a与b。
2. 接下来Add函数的调用。
参数传递过程：(从右到左传参)
过程分析：
- 将b存入寄存器eax,对b进行实例化_b ;
- 将a存入寄存器ecx,对a进行实例化_a ;
- call指令的调用，先要压栈call指令下一条指令的地址，然后跳转到Add()函数的地方。
执行call指令的时候按F11 ， 来到了这里。
再按F11 就进入Add函数的执行代码处。Add函数栈帧的创建：
过程分析：
- 首先将main()函数ebp压栈处理，保存指向main()函数栈帧底部的ebp的地址（方便函数返回之后的现场恢复），此时esp指向新的栈顶位置；
- 将esp的值赋给ebp，产生新的ebp，即Add()函数栈帧的ebp；
给esp减去一个16进制数0E4H（为Add()函数预开辟空间）；- push ebx、esi、edi；
- lea指令，加载有效地址；
- 初始化预开辟的空间为0xcccccccc；
- 创建变量z；
- 获取形参的a和b再相加，将结果存储到z中；
- 将结果存储到eax寄存器，通过寄存器带回函数的返回值。
剩下的就是是函数返回部分：
过程分析：
- pop 3次，edi、esi、ebx依次出栈,esp 向下移动；
- 将ebp赋给esp，使esp指向ebp指向的地方;
- ebp 出栈，将出栈的内容给ebp（即main()函数ebp），回到main()函数的栈帧；
- ret 指令，出栈一次，并将出栈的内容当做地址，并跳转到该地址处 。
注： 栈帧这部分内容在不同的编译器上实现存在差异， 但是思想都是一致的。
对于函数调用具体过程剖析完了，我们来个小测验：
在VC6.0环境中， 下面代码的结果是什么？
1 |
|
事实上在不同平台下这段代码有不同的输出，可自行验证。
此处提供VS编译器答案：20
堆和栈的关系
我们平时说的堆栈其实是指栈，而实际上堆和栈是两种不同的内存分配。简单罗列如下各方面的异同点。
- 堆需要用户在程序中显式申请，栈不用，由系统自动完成。申请/释放堆内存的API，在C中是malloc/free，在C++中是new/delete。申请与释放一定要配对使用，否则会造成内存泄漏(memory leak)，久而久之系统就无内存可用了，出现OOM（Out Of Memory）错误。一般在return/exit或break/continue等语句时容易忘记释放内存，所以检查内存泄漏的代码时要关注这些语句，看它们前面是否有必要的释放语句free/delete。
堆的空间比较大，栈比较小。所以申请大的内存一般在堆中申请；栈上不要有较大的内存使用，比如大的静态数组；而且除非算法必要，否则一般不要使用较深的迭代函数调用，那样栈消耗内存会随着迭代次数的增加飞涨。
关于生命周期。栈较短，随着函数退出或返回，本函数的栈就完成了使用；堆就要看什么时候释放，生命周期就什么时候结束。
关于函数调用即栈桢创建与销毁就浅析到此！
]]>平均数:平均数是指在一组数据中所有数据之和再除以数据的个数。平均数是表示一组数据集中趋势的量数，它是反映数据集中趋势的一项指标。今天就简单讲解一下编程界平均数几种简要解法。
这种方法最为简单，弊端是如果a和b非常大的话，a+b的值可能超过了整型的储存范围（最大值为2147483647），导致溢出，得到错误的结果。
1 |
|
用一个较大值减去另一个较小值得到二者之差，将差除2后加上较小值即得到了二者平均值，可有效防止溢出的情况的出现。
步骤如图：
1 |
|
将两个数的二进制位分为相同部分和不同部分，利用按位与求出相同部分的平均数，然后再用按位异或求出不同部分的平均数，加起来就是两个数的平均数。
这里举个栗子：
- a = 10,b = 12;
- 10&12可得到 1000
- 10^12可得到 0110
计算a与b的平均值C语言表达式:
- avg = (a&b) + (a^b)>>1
1 |
|
]]>知识在于汇总，方法在于总结。
不忘初心，励志前行！
本文摘录自谷歌开源项目开源指南。
详见 —>谷歌开源项目开源指南
每通常一个 .c/.cpp文件都有一个对应的 .h 文件。也有一些常见例外，如单元测试代码和只包含 main() 函数的 .c/.cpp文件。正确使用头文件可令代码在可读性，文件大小和性能上大为改观。
下面的规则将引导你规避使用头文件时的各种陷阱。
头文件应该能够自给自足（自包含的，也就是可以作为第一个头文件被引入），以 .h 结尾。至于用来插入文本的文件，说到底它们并不是头文件，所以以应 .inc 结尾不允许。出分离 -inl.h 头文件的做法。所有头文件要能够自给自足。换言之，用户和重构工具不需要为特别场合而包含额外的头文件。详言之，一个头文件要有 1.2。#define保护，统计包含它所需要的其它头文件，也不要求定义任何特别的符号。
不过有一个例外，即一个文件并不是自足的，而是作为文本插入到代码某处。或者，文件内容实际上是其它头文件的特定平台（特定于平台）扩展部分，这些文件就要用 .inc 文件扩展名。
如果 .h 文件声明了一个模板或内联函数，同时也在该文件加以定义。有用凡是到这些的 .cpp 文件，就得统统包含该头文件，否则程序可能会在构建中链接失败。不要把这些定义放到分离的 -inl.h 文件里（译者注：过去该规范曾提倡把定义放到-inl.h里过）。
有个例外：如果某函数模板为所有相关模板参数显式实例化，或本身就是某类的一个私有成员，它就那么定义只能在实例化该模板的 .cpp 文件里。
所有头文件都应该使用 #define 来防止头文件被多重包含，命名格式当是：
_H_ 。
为保证唯一性，头文件的命名应该基于所有项目源代码树的全路径。例如，项目 foo 中的头文件 foo/src/bar/baz.h 可按如下方式保护：
#ifndef FOO_BAR_BAZ_H_
#define FOO_BAR_BAZ_H_
…
#endif // FOO_BAR_BAZ_H_
尽可能地避免使用前置声明。使用 #include 所有游戏需要的头文件即可。
定义：
所谓「前置声明」（forward declaration）是类，函数和模板的纯粹声明，没伴随着其定义。
优点：
前置声明能够节省编译时间，的多余 #include 会迫使compile-器展开更多的文件，处理更多的输入。
前置声明能够节省不必要的重新编译的时间。 #include 使代码因为头文件中无关的改动而被重新编译多次。
缺点：
前置声明隐藏了依赖关系，头文件改动时，用户的代码会跳过必要的重新编译过程。
前置声明可能会被库的后续更改所破坏。前置声明函数或模板有时会妨碍头文件开发者变动其API。例如扩大形参类型，加个自带默认参数的模板形参等等。
前置声明来自命名空间 std:: 的符号时，其行为未定义。
很难判断什么时候该用前置声明，时候什么用该 #include 极端情况下，用前置声明代替。 includes 甚至都会暗暗地改变代码的含义：
// bh：
struct B {};
struct D ： B {}
// good_user.cpp：
＃包括 “BH”
void f （B ）;
void f （void ）;
void test （D * x ） { f （x ）; }
//调用f（B ）
如果 #include 被 B 状语从句： D 的前置声明替代， test() 就会调用 f(void) 。
前置声明了include 不少来自头文件的符号时，就会比单单一行的 冗长。
仅仅为了能前置声明而重构代码（比如用指针成员代替对象成员）会使代码变得更慢更复杂。
结论：
尽量避免前置声明那些定义在其他项目中的实体。
函数：总是使用 #include。
类模板：优先使用 #include。
至于什么时候包含头文件，参见 1.5。#include的路径及顺序 。
只有当函数只有10行甚至更少时才将其定义为内联函数。
定义：当函数被声明为内联函数之后，编译器会将其内联展开，而不是按通常的函数调用机制进行调用。
优点：
只要内联的函数体小小，内联该函数可以令目标代码更加高效。对于存取函数以及其它函数体比较短，性能关键的函数，鼓励使用内联。
缺点：
滥用内联将导致程序变得更慢。内联可能使目标代码量或增或减，这取决于内联函数的大小。内联非常短小的存取函数通常会减少代码大小，但内联一个相当大的函数将戏剧性的增加代码大小。现代处理器由于更好的利用了指令缓存，小巧的代码往往执行更快。
结论：
一个较为合理的经验准则是，不要内联超过10行的函数。谨谨对待析构函数，析构函数往往比其表面看起来要更长，因为有隐含的成员和基类析构函数被调用！
另一个实用的经验准则：内联那些包含循环或 switch 语句的函数常常是得不偿失（除非在大多数情况下，这些循环或 switch 语句从不被执行）。
有些函数即使声明为内联的也不一定会被编译器内联，这点很重要; 比如虚函数和递归函数就不会被正常内联。通常，递归函数不应该声明成内联函数。（YuleFox注：递归调用堆栈的展开并不像循环那么简单，比如递进层数在编译时可能是未知的，大多数编译器都不支持内联递归函数）。虚函数内联的主要原因是想把它的函数体放在类定义内，为了图个方便，抑或是当作文件描述其行为，比如精短的存取函数。
使用标准的头文件包含顺序可增强可读性，避免隐藏依赖：相关头文件，C库，C ++库，其他库的 .h，本项目内的 .h。
项目内部文件应按照项目源代码目录树结构排列，避免使用UNIX特殊的快捷目录 .（当前目录）或 .. （上级目录）。
例如， google-awesome-project/src/base/logging.h 应该按如下方式包含：#include “base / logging.h”
又如， dir/foo.cpp 或 dir/foo_test.cpp 的主要作用英文的英文实现或测试 dir2/foo2.h 的功能， foo.cpp 中包含头文件的次序如下：dir2/foo2.h （优先位置，详情如下）
C系统文件
C ++系统文件
库其他的 .h 文件
项目本。内 .h 文件
优先这种顺序的排序保证当 dir2/foo2.h 遗漏某些必要的库时， dir/foo.cpp 或 dir/foo_test.cpp 的构建会立刻中止。因此这一条规则保证维护这些文件的人们首先看到构建中止的消息而不是维护其他包的人们。
dir/foo.cpp 和 dir2/foo2.h 通常位于同一目录下(如base/basictypes_unittest.cpp 和 base/basictypes.h），但也可放在不同目录下。按字母顺序分别对每种类型的头文件进行二次排序是不错的主意。注意较老的代码可不符合这条规则，要在方便的时候改正它们。
您所依赖的符号（符号）被哪些头文件所定义，您就应该包含（包括）哪些头文件，前置声明 （向前声明）情况除外。您比如要用到 bar.h 中的某个符号，哪怕您所包含的 foo.h 已经包含了 bar.h，也照样得包含 bar.h，除非foo.h 有明确 说明它会自动向您提供 bar.h 中符号。不过，凡是cc文件所对应的「相关头文件」已经包含的，就不用再重复包含进其cc文件里面了，就像 foo.cpp 只包含 foo.h就够了，不用再管后者所包含的其它内容。
总述:函数的参数顺序为：输入参数在先，后跟输出参数。
说明
C / C ++中的函数参数或者是函数的输入，或者是函数的输出，或兼而有之。输入参数通常是值参或 const 引用，输出参数或输入/输出参数则一般为非 const 指针。在排列参数顺序时，将所有的输入参数置于输出参数之前。特别要注意，在加入新参数时不要因为它们是新参数就置于参数列表最后，而是仍然要按照前述的规则，即将新的输入参数也置于输出参数之前。
这并非一个硬性规定。输入/输出参数（通常是类或结构体）让这个问题变得复杂。并且，有时候为了其他函数保持一致，你可能不得不不所有变通。
总述:我们倾向于编写简短，凝练的函数。
说明
我们承认长函数有时是合理的，因此并不硬限制函数的长度。如果函数超过40行，可以思索一下能不能在不影响程序结构的前提下对其进行分割。
即使一个长函数现在工作的非常好，一旦有人对其修改，有可能出现新的问题，甚至导致难以发现的错误。使函数尽量简短，以便于他在他人阅读和修改代码。
在处理代码时，你可能会发现复杂的长函数。不要害怕修改现有代码：如果证实这些代码使用/调试起来很困难，或者你只需要使用其中的一小段代码，考虑将其分割为更加简短并易于管理的若干函数。
总述:所有按引用传递的参数必须加上 const。
说明
》在C语言中，如果函数需要修改变量的值，参数必须为指针，如 。在C ++中，函数还可以声明为引用参数： 。int foo(int *pval)int foo(int &val)
优点
引用定义参数可以防止出现 (*pval)++ 这样丑陋的代码。引用参数对于拷贝构造函数这样的应用也是必需的。同时也更明确地不接受空指针。
缺点
容易引起误解，因为引用在语法上是值变量却拥有指针的语义。
结论
函数参数列表中，所有引用参数都必须是 const：void Foo （const string ＆in ， string * out ）;
事实上这在Google Code是一个硬性约定：输入参数是值参或 const 引用，输出参数为指针。输入参数可以是 const 指针，但决不能是非 const 引用参数，除非特殊要求，比如 swap()。
有时候，在输入形参中用针指更明智。比如：const Tconst T&可能会传递空指针。
函数要把指针或对地址的引用赋值给输入形参。
总而言之，大多时候输入形参往往是 。用若 则说明输入侧另有处理。所以若要使用 ，则应给出相应的理由，否则会使读者感到迷惑。const T&const Tconst T*
总述
》若要使用函数重载，则必须能让读者一看调用点就胸有成竹，而不用花心思猜测调用的重载函数到底是哪一种。这一规则也适用于构造函数。
定义
你可以编写一个参数类型的函数，然后用另一个参数类型函数对其进行重载：
1 | const string&const char* class MyClass { |
优点
通过重载参数不同的同名函数，可以令代码更直观。模板化代码需要重载，这同时也能为使用者带来便利。
缺点
如果函数单靠不同的参数类型而重载（acgtyrant注：这意味着参数数量不变），读者就得十分熟悉C ++五花八门的匹配规则，以了解匹配过程具体到底如何。另外，如果派生类只重载了某个函数的部分变体，继承语义就容易令人困惑。
结论
如果打算重载一个函数，可以试试改在函数名里加参数信息。例如，用 AppendString()和 AppendInt() 等，而不是一口气重载多个 Append()。如果重载函数的目的是为了支持不同数量的同一类型参数，则优先考虑使用 std::vector 以便使用者可以用 列表初始化指定参数。
总述
只允许在非虚函数中使用缺省参数，且必须保证缺省参数的值始终一致。参数缺省与 函数重载 遵循同样的规则。一般情况下建议使用函数重载，尤其是在缺省函数带来的可读性提升不能弥补下文中所提到的缺点的情况下。
优点
有些函数一般情况下使用默认参数，但有时需要又使用非默认的参数。缺省参数为这样的情形提供了便利，使程序员不需要为了极少的例外情况编写大量的函数。和函数重载相比，缺省参数的语法更简洁明了，减少了大量的样板代码，也更好地区别了“必要参数”和“可选参数”。
缺点
- 缺省参数实际上是函数重载语义的另一种实现方式，因此所有 不应当使用函数重载的理由 也都适用于缺省参数。
- 虚函数调用的缺省参数取决于目标对象的静态类型，此时无法保证给定函数的所有重载声明的都是同样的缺省参数。
- 缺省参数是在每个调用点都要进行重新求值的，这会造成生成的代码迅速膨胀。作为读者，一般来说也更希望缺省的参数在声明时就已经被固定了，而不是在每次调用时都可能会有不同的取值。
- 缺省参数会干扰函数指针，导致函数签名与调用点的签名不一致。而函数重载不会导致这样的问题。
结论
对于虚函数，不允许使用缺省参数，因为在虚函数中缺省参数不一定能正常工作。如果在每个调用点缺省参数的值都有可能不同，在这种情况下缺省函数也不允许使用。（例如，不要写像 这样的代码。）void f(int n = counter++);
在其他情况下，如果缺省参数对可读性的提升远远超过了以上提及的缺点的话，可以使用缺省参数。如果仍有疑惑，就使用函数重载。
总述
只有在常规写法（返回类型前置）不便于书写或不便于阅读时使用返回类型后置语法。
定义
C ++现在允许两种不同的函数声明方式。以往的写法是将返回类型置于函数名之前。例如：
1 | int foo （int x ）; |
C ++ 11引入了这一新的形式。现在可以在函数名前使用 auto 关键字，在参数列表之后后置返回类型。例如：
1 | auto foo （int x ） - > int ; |
后置返回类型为函数作用域。对于像 int 这样简单的类型，两种写法没有区别。但对于复杂的情况，例如类域中的类型声明或者以函数参数的形式书写的类型，写法的不同会造成区别。
优点
后置返回类型是显式地指定 Lambda表达式 的返回值的唯一方式。某些情况下，编译器可以自动推导出Lambda表达式的返回类型，但并不是在所有的情况下都能实现。即使编译器能够自动推导，显式地指定返回类型也能让读者更明了。
有时在已经出现了的函数参数列表之后指定返回类型，能够让书写更简单，也更易读，尤其是在返回类型依赖于模板参数时。
例如：
1 | template < class T ， class U > auto add （T t ， U u ） - > |
对比下面的例子：1
template < class T ， class U > decltype （declval < T ＆> （） + declval < U ＆gt ;） add （T t ， U u ）;
缺点
后置返回类型相对来说是非常新的语法，而且在C和Java中都没有相似的写法，因此可能对读者来说比较陌生。
在已有的代码中有大量的函数声明，你不可能把它们都用新的语法重写一遍。因此实际的做法只能是使用旧的语法或者新旧混用。在这种情况下，只使用一种版本是相对来说更规整的形式。
结论
在大部分情况下，应当继续使用以往的函数声明写法，即将返回类型置于函数名前。只有在必要的时候（如Lambda表达式）或者使用后置语法能够简化书写并且提高易读性的时候才使用新的返回类型后置语法。但是后一种情况一般来说是很少见的，大部分时候都出现在相当复杂的模板代码中，而多数情况下不鼓励写这样 复杂的模板代码。
最重要的一致性规则是命名管理。命名的风格能让我们在不需要去查找类型声明的条件下快速地了解某个名字代表的含义：类型，变量，函数，常量，宏，等等，甚至。我们大脑中的模式匹配引擎非常依赖这些命名规则。
命名规则具有一定随意性，但相比按个人喜好命名，一致性更重要，所以无论你认为它们是否重要，规则总归是规则。
总述
函数命名，变量命名，文件命名要有描述性; 少用缩写。
说明
尽可能使用描述性的命名，别心疼空间，毕竟相比之下让代码易于新读者理解更重要。不要用只有项目开发者能理解的缩写，也不要通过砍掉几个字母来缩写单词。
1 | int price_count_reader ; //无缩写 |
注意，一些特定的广为人知的缩写是允许的，例如用 i 表示迭代变量和用 T 表示模板参数。
模板参数的命名应当遵循对应的分类：类型模板参数应当遵循 类型命名 的规则，而非类型模板应当 遵循变量命名 的规则。
总述
文件名要全部小写，可以包含下划线（_）或连-字符（），依照项目的约定。如果没有约定，那么“ _” 更好。
说明
可接受的文件命名示例：
1 | my_useful_class.cpp |
C ++文件要以 .cpp结尾，头文件以 .h 结尾。专门插入文本的文件则以 .inc 结尾，参见 头文件自足。
不要使用已经存在于 /usr/include 下的文件名（Yang.Y注：即编译器搜索系统头文件的路径），如 db.h。
通常应尽量让文件名更加明确。 http_server_logs.h 就比 logs.h 要好。定义类时文件名一般成对出现，如 foo_bar.h 和 foo_bar.cpp，对应于类 FooBar。
联内必须函数放在 .h 文件中。如果内联函数比较短，就直接放在 .h 中。
总述
类型名称的每个单词首字母均大写，不包含下划线： MyExcitingClass， MyExcitingEnum。
说明
所有类型命名 - 类，结构体，类型定义（typedef），枚举，类型模板参数 - 均使用相同约定，即以大写字母开始，每个单词首字母均大写，不包含下划线。例如：
1 | //类和结构体 |
总述
变量（包括函数参数）和数据成员名一律小写，单词之间用下划线连接。类的成员变量以下划线结尾，但结构体的就不用，如： a_local_variable， a_struct_data_member， a_class_data_member_。
说明
普通变量命名
举例：
字符串 table_name ; //好 - 用下划线。
字符串 表名; //好 - 全小写。
字符串 tableName ; //差 - 混合大小写
类数据成员
不管是静态的还是非静态的，类数据成员都可以和普通变量一样，但要接下划线。1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
类 TableInfo {
...
private ：
string table_name_ ; //好 - 后加下划线。
字符串 tablename_ ; //好。
静态 池< TableInfo > * pool_ ; //好。
};
结构体变量
不管是静态的还是非静态的，结构体数据成员都可以和普通变量一样，不用像类那样接下划线：
struct UrlTableProperties {
string name ;
int num_entries ;
静态 池< UrlTableProperties > * 池;
};
结构体与类的使用讨论，参考 结构体与类。
总述
声明为 constexpr 或 const 的变量，或在程序运行期间其值始始保持不变的，命名时以“k”开头，大小写混合。例如：
说明
所有具有静态存储类型的变量（例如静态变量或全局变量，参见 存储类型）都应当以此方式命名。对于其他存储类型的变量，如自动变量等，这条规则是可选的。如果不采用这条规则，就按照一般的变量命名规则。
总述
命名空间以小写字母命名。最高级命名空间的名字取决于项目名称。要注意避免嵌套命名空间的名字之间和常见的顶级命名空间的名字之间发生冲突。
顶级命名空间的名称应当是项目名或者是该命名空间中的代码所属的团队的名字。命名空间中的代码，应当存放于和命名空间的名字匹配的文件夹或其子文件夹中。
注意 不使用缩写作为名称 的规则同样适用于命名空间。命名空间中的代码极少需要涉及命名空间的名称，因此没有必要在命名空间中使用缩写。
要避免嵌套的命名空间与常见的顶级命名空间发生名称冲突。由于名称查找规则的存在，命名空间之间的冲突完全有可能导致编译失败。尤其是，不要创建嵌套的 std 命名空间。建议使用更独特的项目标识符（websearch::index， websearch::index_util）而非常见的极易发生冲突的名称（比如 websearch::util）。
对于 internal 命名空间，要当心加入到同一 internal 命名空间的代码之间发生冲突（由于内部维护人员通常来自同一团队，因此常有可能导致冲突）。在这种情况下，请使用文件名以使内部名称独一无二（例如对于 frobber.h，使用 websearch::index::frobber_internal）。
总述
枚举命名应当状语从句： 常量 或 宏 harmony和谐： kEnumName 或是 ENUM_NAME。
说明
单独枚举值应该优先采用 常量 的命名方式。但 宏 方式的命名也可以接受。
枚举名 UrlTableErrors （以及 AlternateUrlTableErrors）是类型，所以要用大小写混合的方式。
1 |
|
总述
你并不打算 使用宏，对吧？如果你一定要用，像这样命名： MY_MACRO_THAT_SCARES_SMALL_CHILDREN。
说明
参考 预处理宏 ; 通常 不应该 使用宏。如果不得不使用，其命名像枚举命名一样全部大写，使用下划线：
1 |
总述
如果你命名的实体与已有C / C ++实体相似，可参考现有命名策略。
1 |
|
注释虽然写起来很痛苦，但对保证代码可读性至关重要。下面的规则描述了如何注释以及在哪儿注释。当然也要记住：注释固然很重要，但最好的代码应当本身就是文档。有意义的类型名和变量名，要远胜过要用注释解释的含糊不清的名字。
你写的注释是给代码读者看的，也就是下一个需要理解你的代码的人。所以慷慨些吧，下一个读者可能就是你！
总述
使用 // 或 /* */ 统一就好。
说明
// 或 /* */ 都可以; 但 //更 常用。要在如何注释及注释风格上确保统一。
总述
在每一个文件开头加入版权公告。
文件注释描述了该文件的内容。如果一个文件只声明，或实现或测试了一个对象，并且这个对象已经在它的声明处进行了详细的注释，那么就没有必要再加上文件注释。除此之外的其他文件都需要文件注释。
说明
法律公告和作者信息
每个文件都应该包含许可证引用。为项目选择合适的许可证版本（比如，Apache 2.0，BSD，LGPL，GPL）
如果你对原始作者的文件做了重大修改，请考虑删除原作者信息。
文件内容
如果一个 .h 文件声明了多个概念，则文件注释应当对文件的内容做一个大致的说明，同时说明各个概念之间的联系。一个一到两行的文件注释就足够了，对于每个概念的详细文档应当放在各个概念中，而不是文件注释中。
不要在 .h 和 .cpp 之间复制注释，这样的注释偏离了注释的实际意义。
总述
每个类的定义都要附带一份注释，描述类的功能和用法，除非它的功能相当明显。
1 |
|
说明
类注释应当为读者理解如何使用与何时使用类提供足够的信息，同时应当提醒读者在正确使用此类时应当考虑的因素。如果类有任何同步前提，请用文档说明。如果该类的实例可被多线程访问，要特别注意文档说明多线程环境下相关的规则和常量使用。
如果你想用一小段代码演示这个类的基本用法或通常用法，放在类注释里也非常合适。
如果类的声明和定义分开了（例如分别放在了 .h 和 .cpp 文件中），此时，描述类用法的注释应当和接口定义放在一起，描述类的操作和实现的注释应当和实现放在一起。
总述
函数声明处的注释描述函数功能; 定义处的注释描述函数实现。
说明
函数声明:基本上每个函数声明处前都应当加上注释，描述函数的功能和用途。只有在函数的功能简单而明显时才能省略这些注释（例如，简单的取值和设值函数）。注释使用叙述式（“打开文件”）而非指令式（“打开文件”）; 注释只是为了描述函数，而不是命令函数做什么。通常，注释不会描述函数如何工作。那是函数定义部分的事情。
函数声明处注释的内容：
函数的输入输出。
对类成员函数而言：函数调用期间对象是否需要保持引用参数，是否会释放这些参数。
函数是否分配了必须由调用者释放的空间。
参数是否可以为空指针。
是否存在函数使用上的性能隐患。
如果函数是可重入的，其同步提提是什么？
举例如下：
//返回此表的迭代器。
当迭代器完成时，它是
客户端的责任//并且一旦
创建
迭代器的GargantuanTable对象被删除，它就不能使用迭代器。//
//迭代器最初位于表的开始位置。
//
//此方法等同于：
// Iterator iter = table-> NewIterator（）;
// iter-> Seek（“”）;
//返回iter;
//如果您要立即寻找到
返回的迭代器
中的其他位置，则使用NewIterator（）会更快，并避免额外的查找。
Iterator GetIterator （） const;
但也要避免罗罗嗦嗦，或者对显着易见的内容进行说明。下面的注释就没有必要加上“否则返回false”，因为已经暗含其中了：
//如果表不能包含更多条目，则返回true。
bool IsTableFull （）;
注释函数重载时，注释的重点应该是函数中被重载的部分，而不是简单的重复被重载的函数的注释。多数情况下，函数重载不需要额外的文档，因此也没有必要加上注释。
注释构造/析构函数，切记读代码的人知道构造/析构函数的所有功能，所以“销毁这一对象”这样的注释是没有意义的。你应该注意的是注意构造函数对参数做了什么（例如，是否取得指针所有权）以及析构函数清理了什么。如果都是些无关紧要的内容，直接省掉注释。析构函数前没有注释是很正常的。
函数定义
如果函数的实现过程中用到了很巧妙的方式，那么在函数定义处应当加上解释性的注释。例如，你所使用的编程技巧，实现的大致步骤，或解释如此实现的理由。举个例子，你可以说明为什么函数的前半部分要加锁而后半部分不需要。
不要 从 .h 文件或其他地方的函数声明处直接复制注释。简要重述函数功能是可以的，但注释重点要放在如何实现上。
总述
通常变量名本身足以很好说明变量用途。某些情况下，也需要额外的注释说明。
说明
类数据成员:每个类数据成员（也叫实例变量或成员变量）都应该用注释说明用途。如果有非变量的参数（例如特殊值，数据成员之间的关系，生命周期等）不能够使用类型与变量名明确表达，则应当加上注释。然而，如果变量类型与变量名已经足够描述一个变量，那么就不需要加上注释。
特别地，如果变量可以接受 NULL 或 -1 等警戒值，须加以说明。比如：1
2
3
4
5
6
7
8
9
10
11
private ：
//用于限制检查表访问。-1意味着
//我们还不知道表中有多少个条目。
int num_total_entries_ ;
全局变量
和数据成员一样，所有全局变量也要注释说明含义及用途，以及作为全局变量的原因。比如：
//在此回归测试中我们经历的测试用例的总数。
const int kNumTestCases = 6 ;
总述
对于代码中巧妙的，晦涩的，有趣的，重要的地方加以注释。
说明
代码前注释:巧妙或复杂的代码段前要加注释。比如：
1 | //将结果除以2，考虑到x |
函数参数注释
如果函数参数的意义不明显，考虑用下面的方式进行弥补：
如果参数是一个字面常量，并且这一常量在多处函数调用中被使用，用以推断它们一致，你应该用一个常量名让这个约定变得更明显，并且保证这一约定不会被打破。
考虑更改函数的签名，让某个 bool 类型的参数变为 enum 类型，这样可以让这个参数的值表达其意义。
如果某个函数有多个配置选项，你可以考虑定义一个类或结构体以保存所有的选项，并传入类或结构体的实例。这样的方法有许多优点，例如这样的选项可以在调用处用变量名引用，这样就能清晰地表明其意义。同时也减少了函数参数的数量，使得函数调用更易读也易写。除此之外，以这样的方式，如果你使用其他的选项，就无需对调用点进行更改。
用具名变量代替大段而复杂的嵌套表达式。
万不得已时，才考虑在调用点用注释阐明参数的意义。
不允许的行为
不要描述显而易见的现象， 永远不要 用自然语言翻译代码作为注释，除非即使对深入理解C ++的读者来说代码的行为都是不明显的。要假设读代码的人C ++水平比你高，即便他/她可能不知道你的用意.
你所提供的注释应当解释代码 为什么 要这么做和代码的目的，或者最好是让代码自文档化.
总述
注意标点，拼写和语法; 写的好的注释比差的要易读的多。
说明
注释的通常写法是包含正确大小写和结尾句号的完整叙述性语句。大多数情况下，完整的句子比句子片段可读性更高。短一点的注释，比如代码行尾注释，可以随意点，但依然要注意风格的一致性。
虽然被别人指出该用分号时却用了逗号多少有些尴尬，但清晰易读的代码还是很重要的。正确的标点，拼写和语法对此会有很大帮助。
总述
每一行代码字符数不超过80。
我们也认识到这条规则是有争议的，但很多已有代码都遵照这一规则，因此我们感觉一致性更重要。
优点
提倡该原则的人认为强迫他们调整编辑器窗口大小是很野蛮的行为。很多人同时并排开几个代码窗口，根本没有多余的空间拉伸窗口。大家都把窗口最大尺寸加以限定，并且80列宽是传统标准。那么为什么要改变呢？
缺点
反对该原则的人则认为更宽的代码行更易阅读。80列的限制是上个世纪60年代的大型机的古板缺陷;现代设备具有更宽的显示屏，可以很轻松地显示更多代码。
结论
80个字符是最大值。
如果无法在不伤害易读性的条件下进行断行，那么注释行可以超过80个字符，这样可以方便复制粘贴。例如，带有命令示例或URL的行可以超过80个字符。长所有游戏的路径 #include 语句可以超出80列。
文件头保护 可以无视该原则。
总述
要么一行写完函数调用，要么在圆括号里对参数分行，要么参数另起一行且缩进四格。如果没有其它顾虑的话，尽可能精简行数，比如把多个参数适当地放在同一行里。
说明
1 | 函数调用遵循如下形式： |
把多个参数放在同一行以减少函数调用所需的行数，除非影响到可读性。有人认为把每个参数都独立成行，不仅更好读，而且方便编辑参数。
总述
switch 语句可以使用大括号分段，以表明cases之间不是连在一起的。在单语句循环里，括号可用可不用。循环空应行业释义体育使用 {} 或 continue。
说明
switch 语句中的 case 块可以使用大括号也可以不用，取决于你的个人喜好。如果用的话，要按照下文所述的方法。
如果有不满足 case 条件的枚举值， switch 应该default 总是包含一个 匹配（如果有输入值没有case去处理，编译器将给出警告）。如果 default 应该永远执行不到，简单的加条 assert：
1 |
|
在单语句循环里，括号可用可不用：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
for （int i = 0 ; i < kSomeNumber ; ++ i ）
printf （“我爱你\ n ” ）;
for （int i = 0 ; i < kSomeNumber ; ++ i ） {
printf （“我拿回来\ n ” ）;
}
空循环体应使用 {} 或 continue，而不是一个简单的分号。
while （condition ） {
//反复循环直到条件失效。
}
for （int i = 0 ; i < kSomeNumber ; ++ i ） {} //可 - 空循环体。
同时 （条件） 继续; //可 - contunue表明没有逻辑。
while （condition ）; //差 - 看起来仅仅只是while / loop的部分之一。
总述*
构造函数初始化列表放在同一行或按四格缩进并排多行。
说明
下面两种初始值列表方式都可以接受：
1 |
|
]]>代码规范是项目开发非常重要的一点，作为一名合格的程序猿应该将代码规范熟记于心。
扫雷，是一个Windows平台下一个经典的小游戏，今有兴趣玩了几把后，就利用所学二维数组的相关知识模拟实现了一个“扫雷游戏”。由于学识浅薄，界面有点简陋，尽请谅解！
是不是很有意思？当然重中之重的是：
要注意需要用二维数组来打印两个棋盘，假如我们要打印10X10的棋盘，那我们的二维数组元素也要为10X10个吗？，不能，因为我们在设计算法时需要统计坐标周围8个方位雷的个数，假如要统计边界坐标周围雷的个数，那么就会有数组越界的问题，那我们就要在10X10的边界多上一圈元素，也就要定义12X12的数组元素，这些元素我们不要打印出来，心里有数就行。
1 | /********************************************************************************************* |
1 |
|
1 |
|
]]>简单利用C语言做了一个小游戏，如有不正之处，欢迎双击评论！
经过搜集、整理，现得到以下Git相关知识，相互学习，相互促进。
$ git config –global user.name “your name”
$ git config –global user.email “your email@example.com“
//–global是全局参数，表示这个账户上所以的Git仓库都使用这个配置
$ git config –global alias.st status
$ git config –global color.ui true
$ mkdir <文件名>
$ cd <文件名>
$ git init//初始化一个仓库
$ ls -ah//此命令用于看见隐藏的.git
$ git add <文件名>
//第一步，把文件放到暂存区
$ git commit -m”本次提交的说明”
//把暂存区的所有内容提交到当前分支
$ git status
$ git diff
补充：查看工作区和版本库最新版本的区别
$ git diff HEAD – 文件名
$ git reset –hard HEAD^
//回退上一个版本
$ git reset –hard HEAD^^
//回退上上个版本
$ git reset –hard HEAD~100
//回退上100个版本
$ git reset –hard commit_id
//在历史版本里任意穿梭
$ git log//查看提交历史
$ git log –pretty=oneline
//查看简单的提交历史
$ git reflog//查看命令历史
$ git checkout – 文件名
//在没有添加到暂存区内
$ git reset HEAD 文件名
$ git checkout – 文件名
//添加到暂存区内
$ rm 文件名
$ git rm 文件名
//确实要删除这个文件
$ git checkout – 文件名
//误删
补充：强制删除未被合并的分支
$ git branch -D 分支名
$ ssh-keygen -t rsa -C”youremail@example.com“
$ git remote add origin git@githup.com:<账户名>/<仓库名>.git
$ git push -u origin master
//第一次推送需要加 -u参数
$ git push origin master
//以后操作不用 -u参数
$ git clone git@githup.com:<账户名>/<仓库名>.git
$ git branch 分支名
//创建一个新的分支
$ git checkout 分支名
//切换分支
$ git checkout -b 分支名
//创建并切换分支
$ git branch
//查看当前分支
$ git merge 分支名
//合并此分支到当前分支(Fast forward模式)
$ git merge –no-ff -m”说明文字” 分支名（禁用Fast forward模式）
$ git branch -d 分支名
$ git log –graph=oneline –abbrev-commit
$ git stash
//储存工作现场
$ git stash
//储存工作现场的列表
$ git stash apply
//恢复工作现场，stash内容不删除
$ git stash drop
//删除stash的内容
$ git stash pop
//恢复工作现场的同时删除stash内容
$ git stash apply stash@{0}
//恢复指定stash
$ git remote
$ git remote -v
//查看更详细的信息
$ git push origin 分支名
$ git pull
$ git checkout -b 分支名 origin/分支名
$ git checkout -set-upstream 分支名 origin/分支名
$ git tag 标签名
//打一个新的标签
$ git tag
//查看所有标签
$ git tag 标签名 commit_id
//给任意提交过的版本打标签
$ git show 标签名
//查看标签信息
$ git tag -a 标签名 -m”说明文字” commit_id
//创建带有说明的标签 -a指定标签名 -m指定说明文字
$ git push origin 标签名
//推送指定标签
$ git push origin –tags
//一次性推送所有标签到远程库
$ git tag -d 标签名
//删除指定标签
$ git push origin:refs/tags/标签名
//删除远程库的标签
git push origin –delete HEAD
//删除分支 HEAD
$ sudo rm test
$ git add -u
$ git commit -m “delete test”
$ git push
//删除服务器文件
]]>算法思想：用移的步数作为while循环条件(每移1位完了减1)，1位1位的移动，即只需要一个空的变量来存移出去的字符，而这时变量i已经到了数组最后的空位置，此时把先前移出去的字符再补回来即可1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
void left_move(char *str, int k)
{
assert(str);
char temp = 0;
int len = strlen(str);
k = k%len;
while (k--)
{
char *cur = str;
temp = *cur;
while (*(cur + 1) != '\0')
{
*cur = *(cur + 1);
cur++;
}
*cur = temp;
}
}
int main()
{
char arr[] = "abcdef";
int k = 0;
scanf("%d", &k);
left_move(arr, k);
printf("%s", arr);
return 0;
}
算法思想：以移动的步数为界限，左边字符串整体逆置，右边字符串整体逆置，再整个字符串整体逆置，即需要调用3次整体逆置字符串函数，要注意各个逆置区间的定义
1 |
|
算法思想：(相当于穷举法)申请一个是原来2倍+1(算上\0)的数组空间，将原来的字符串复制一遍存在这个空间里，然后从原来的首元素加上移动的步数开始输出len个长度的字符串，完成左旋效果(先后用到strcpy strcat strncpy函数)
(1)变量定义一定要放在表达式前面，否则乱报错；
(2)用malloc函数申请完空间记得释放，头文件<stdlib.h>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
void reverse_string(char *str, int k)
{
int len = strlen(str);
char *tmp = (char*)malloc(2 * len + 1); //申请2倍的原数组空间
assert(str);
strcpy(tmp, str); //把原来的字符串拷贝到这个大空间里
strcat(tmp, str); //把原来的字符串再拼接到后面(复制2遍)
strncpy(str, tmp + k, len); //从要移动的位数后一位起，获取原来长度的字符串，达到左旋效果
free(tmp);
}
int main()
{
char arr[] = "abcdef";
int k = 0;
scanf("%d", &k);
reverse_string(arr, k);
printf("%s", arr);
return 0;
}
考查字符串和字符数组的相关操作，注意在没有明确指定是否允许使用库函数的时候，就默认允许使用库函数，在不允许的情况下需要自定义实现这些函数（本题中只需要自定义实现strlen()、strstr()、strcat()这些函数），这样就很OK了！
]]>● 命令行参数是控制命令执行的一种方式。
● 命令行参数类似于函数的参数，只是命令行参数是传送给命令的。命令执行时，内核已经将命令行参数放入命令的栈中，命令执行时则可以获取命令行参数，解析，执行。
1 |
|
在这个例子中，我们给main函数传递两个参数：argc，argv：
● argc是int类型的，它表示的是命令行参数的个数。不许要用户传递，它会根据用户从命令行输入的参数个数，自动确定。
● argv是char* argv[]类型的，即是指针数组类型，它的作用是存储用户从命令行传递进来的参数。它的第一个成员是程序执行的.exe文件。
● main函数还有一个参数是envp，是一个 指针数组类型，每个元素存储指向一个环境变量的字符指针。这里不予赘述。
对于上面的例子，我们将其保存为test.c，用gcc编译生成目标文件为a.out
编译结果如下：
执行结果如下：
这里第一个输出的是argc，因为我们只输入了./a.out，所以argc为1，即只有一个命令行参数。后面输出的第一个命令行参数也是./a.out。接着程序就出错了，因为程序要说输出第二、第三参数，而后面已经没有第二个和第三个参数了，在写实际的应用时，应注意对这一部分进行容错处理。所谓容错处理就是指软件运行时，能对由非正常因素引起的运行错误给出适当的处理或信息提示，使软件运行正常结束。而这个错误也就是程序员很容易犯得段错误。
当在命令行输入./a.out、linux、nihao三个参数时，执行结果如图：
命令行参数个数为3，第一个参数./a.out、第二个参数linux、第三个参数nihao。
当输入./a.out、”linux nihao”、hehe、”hi apple”四个参数时，执行结果如图：
当输入四个参数，命令行参数个数就为4，但需要注意的是就是如果一个参数之间有空格，需要用双引号引起来，以免产生不必要的错误。
当然对于具体情况请看下图：
]]>对于main函数第二个参数argv，其数据类型可以写成三种形式：
char *argv[]、char **argv、char argv[][]，当然第三个函数参数envp同理。
人生，走着走着便懂了，对于未来，不再迷茫彷徨，而是以更坚定的步伐迈向预定的目标；人生，走着走着便懂了，对于爱情，不再痴迷悲伤，而是以更理智的心态去接受爱情细水长流的平淡；人生，走着走着便懂了，对于生活，不再困惑感伤，而是以积极乐观的心态去迎接每一个黎明的到来。
白驹过隙，转眼间，我已是大二学生，虽然已经在大学生活了一年，却依然对未来很迷茫，这种迷茫也带来了一系列的恐惧：能否找到称心如意的工作、能否有能力赡养自己的父母，买不起房怎么办、程序员真的是青春饭吗……
我是通信学院物联网工程专业的一名普通的不能再普通的学生。说实话，上大学以来，我并没有为了某些事情真正地努力过，即使是一些很简单的事情 。
曾听人说大学有四个阶段：不知道自己不知道->知道自己不知道->不知道自己知道->知道自己知道。就目前情况来看我应该处于第二阶段，我认识到自己缺乏太多的专业知识以及社交原则，我也会经常阅读搞IT的成功人士的案例来寻求安慰与激励，但这只是短暂的麻痹罢了。
曾经很“牛逼”地对好朋友说过：“我不想过一辈子穷苦生活！”现在想起当时的自己真的是既无知又可笑，我特么拿什么去过理想中的生活呢？殊不知：开水不响，响水不开。被打的人才会大吼几声来搏回一点颜面，而真正有实力的人都是深藏不露的。
小时候家里还种地的时候，我也像其他孩子一样要去田里除草。烈日炎炎下，站在田地里往前一看，我的妈，还有这么多的草要拔呀！还没干活便没了一半的力气。而如果一步一步的做好眼前的这一块，便在不知不觉中就到了地头。我现在何尝又不是当年那个拔草的少年呢，我还有海量的东西要学，我为何不能脚踏实地的学好现在的东西呢？
现于公元二零一八年，特写此篇 ，抒己所感。我并不是为自己起初愚笨忏悔，而是把压在心里的东西排出来轻松一下，并且要警示自己从现在起，静下心来，虚心学习，因为仅剩的大学时光不多了。说实话，像我这样无实力的人连现在的生活都掌控不好，有何权利去畅想未来？关键是要把自己变强大，才能在困难面前有获胜的筹码。曾听过一句自认为非常好的话，毅然当作了自己的座右铭：人生在勤，不索何获！
作此篇亦献给正处于迷茫中的你，希望能够共勉，一起进步!
]]>