6.关键字if：

a.对于bool类型的比较：FLASE都是0  TRUE不一定是1   所以应该用if(bool_num);    if(!bool_num);

1. cosnt int* func()
2. {
3. static int  count  =  0;
4. count++;
5. return &count;
6. }

1. struct student
2. {
3. }*str;
4. const str stu3;
5. str const stu4;

下面是一个利用union判断PC是大端小端的例子，代码如下：

15.enum关键字：

枚举enum其实就是int类型，用来保存枚举常量的。enum枚举类型，这个才是真正的常量，定义常量一般用enum 。#define是宏定义是在预编译期间单纯的替换。#define宏定义无法调试，枚举常量是可以调试的。#define宏定义是无类型信息的，枚举类型是有类型信息的常量，是int型的。

1. typedef struct student
2. {
3. }str，*str1;

1. 程序一：
2. for(i=0; i<m; i++)
3. {
4. for(j=0; j<n; j++)
5. {
6. for(k=0; k<p; k++)
7. {
8. c[i][j] = a[i][k] * b[k][j];
9. }
10. }
11. }
12. 程序二：
13. for(i=0; i<m; i++)
14. {
15. for(k=0; k<p; k++)
16. {
17. for(j=0; j<n; j++)
18. {
19. c[i][j] = a[i][k] * b[k][j];
20. }
21. }
22. }

本节接触了，C语言中的三大蛋疼：符号优先级  ++i顺序点  贪心法  (其实这里面好多都是跟编译器有关的，而且有好多问题都是可以通过良好的编程习惯避免的)

本节知识点：

1.注释问题：

注释不能把关键字弄断，如：in/*注释*/t

注释不是简单的剔除，而是使用空格替换

编译器认为双引号括起来的内容都是字符串，双斜杠也不例外。如：char *p = "heh//jfeafe"   //不起注释作用

2.接续符：

接续符\  ，常用于宏定义中

反斜杠同时有接续符和转义符两个用途，当接续符使用的时候，可以直接在程序中出现。当转义符使用的时候，必须是出现在字符串中。

接续符，也用与接续一个关键字，代码如下，  注意： 但是直接连接\两边不能有空格。

3.逻辑运算符：有一个短路规则

4.最容易忘记规则的两个运算符：

三目运算符：(a?b:c)   当a的值为真的时候   返回b的值，否则返回c的值

逗号表达式：a，b    表达式的值为b的值

5.位运算：

对于左移和右移<<  >>问题 ：无符号的，和有符号左移，都是补0 ，对于有符号的在右移动的时候，正数补零，负数补什么跟编译器有关系。并且左移和右移的大小不能大于数据的长度，也不能小于0。

交换两个数，有一种不借助中间变量的方法，就是异或，代码如下：

6.i++，i--顺序点：

只有 i++ i--才有顺序点  就是什么时候开始加，什么时候开始减。真心对于顺序点 是搞不懂啊~~~ （++i）+（++i）+（++i） ，在gcc中是5+5+6(DEV C++) ，在vc中是6+6+6(vc++6.0) ，不同编译器顺序点不一样。这个例子的顺序点 在; 前。

        a=((++i),(++i),(++i))  它的顺序点在每个逗号前面完成计算。我觉得特殊的顺序点 是可以通过合理的顺序布局来避免的。

7.贪心法：

每一个符号应该尽可能多的包含字符

8.符号运算优先级问题：

个人觉得优先级不用记，好好的写括号吧~~~

给一个易错优先级表，如图：

9.c语言中的类型转换：

c语言中有两种转换类型，分别是：隐式转换和显示转换(强制类型转换)

隐式转换的规则：

a.算术运算中，低类型转换为高类型

b.赋值运算中，表达式的类型转换为左边变量的类型

c.函数调用时，实参转换成形参的类型

d.函数返回值，return表达式转换为返回值的类型

隐式转换的例子，代码如下：

注意：在使用C语言的时候，应该特别注意数据的类型是否相同，尽量避免隐式转换带来的不必要的麻烦~~~

三、

本节知识点：

1.编译过程的简介：

预编译：

a.处理所有的注释，以空格代替。

b.将所以#define删除，并展开所有的宏定义，字符串替换。

c.处理条件编译指令#if，#ifdef，#elif，#else，#endif

d.处理#include，并展开被包含的文件，把头文件中的声明，全部拷贝到文件中。

e.保留编译器需要使用的#pragma指令、

怎么样观察这些变化呢？最好的方法就是在GCC中，输入预处理指令，可以看看不同文件经过预处理后变成什么样了，预处理指令：gcc -E file.c -o file.i   注意：-C -E一起使用是预编译的时候保留注释。

编译：

a.对预处理文件进行一系列词法分析，语法分析和语义分析

词法分析：主要分析关键字，标示符，立即数等是否合法

语法分析：主要分析表达式是否遵循语法规则

语义分析：在语法分析的基础上进一步分析表达式是否合法

b.分析结束后进行代码优化生成相应的汇编代码文件               编译指令：gcc -S  file.c  -o  file.s

汇编：

汇编器将汇编代码转变为机器可以执行的指令，每个汇编语句几乎都对应一条机器指令，其实机器指令就是机器码，就是2进制码。汇编指令：gcc  -c  file.c  -o file.o  注意：-c是编译汇编不连接。

链接：

再把产生的.o文件，进行链接就可以生成可执行文件。连接指令：gcc  file.o  file1.o  -o  file  这句指令是链接file.o和file1.o两个编译并汇编的文件，并生成可执行文件file。

链接分两种：静态链接和动态链接，静态链接是在编译器完成的，动态链接是在运行期完成的。静态链接的指令是：gcc -static file.c -o file对于一些没有动态库的嵌入式系统，这是常用的。

一般要想通过一条指令生成可执行文件的指令是：   gcc file.c  -o  file

资料：这里面说到了很多关于gcc的使用的问题，我提供一个gcc的学习资料，个人觉得还不错，也不长，就是一个txt文档，很全面。资源下载地址http://download.csdn.net/detail/qq418674358/6041183 
 Ps：嘿嘿，设了一个下载积分，因为真的是没分用了！希望大家见谅哈！

2.c语言中的预处理指令：#define、#undef(撤销已定义过的宏名)、#include、#if、#else、#elif、#endif、#ifdef、#ifndef、#line、#error、#pragma。还有一些ANSI标准C定义的宏：__LINE__、__FILE__、__DATA__、__TIME__、__STDC__。这样使用printf("%s\n",__TIME__);     printf(__DATE__);

一个#undef的例子：

这个输出的是6，说明了#undef的作用

3.宏定义字符串的时候：应该是 #define HELLO "hello world"  记住是双引号。还有就是一切宏都是不能有分号的，这个一定要切忌！！！

4.宏与函数的比较：

a.宏表达式在预编译期被处理，编译器不知道有宏表达式存在

b.宏表达式没有任何的"调用"开销

 c.宏表达式中不能出现递归定义

5.为什么不在头文件中定义全局变量：

如果一个全局变量，想要在两个文件中，同时使用，那这两个文件中都应该#include这个头文件，这样的话就会出现重复定义的问题。其实是重名的问题，因为#include是分别在两个文件中展开的，试想一下，如果在两个文件中的开始部分，都写上int  a = 10;  是不是也会报错。可能你会说那个#ifndef不是防止重复定义吗？是的 ，那是防止在同一个文件中，同时出现两次这个头文件。现在是两个文件中，所以都要展开的。全局变量就重名了！！！所以 对于全局变量，最好是定义在.c文件中，不要定义在头文件中。

6.#pargma pack 设置字符对齐，看后面一节专门写字符对齐问题的！！！

7.#运算符（转换成字符串）：

假如你希望在字符串中包含宏参数，那我们就用#号，它把语言符号转换成字符串。

#define SQR(x) printf("the "#x"lait %d\n",((x)*(x)));

    SQR(8)

    输出结果是：the 8 lait 64   这个#号必须使用在带参宏中

有个小例子：

8.##运算符（粘合剂）

一般用于粘贴两个东西，一般是用作在给变量或函数命名的时候使用。如#define XNAME(n) x##n

XNAME(8)为8n   这个##号可以使用在带参宏或无参宏中

下面是一个##运算符的小例子，代码如下：

注意：#号和##号都必须只能在宏定义中使用，不能使用在其他地方

9.其实预编译这块还有一些，不常用到的预编译指令，也是盲点，但是不难理解，用到的时候查查就好。比如说#line、#error、#warning等。

很多人都觉得内存对齐这个问题很难，很不好算，总算错，其实我想说只要你画一画就没那么难了。好了，进入正题。

本节知识点：

1.结构体为什么要内存对齐(也叫字节对齐)：

其实我们都知道，结构体只是一些数据的集合，它本身什么都没有。我们所谓的结构体地址，其实就是结构体第一个元素的地址。这样，如果结构体各个元素之间不存在内存对齐问题，他们都挨着排放的。对于32位机，32位编译器(这是目前常见的环境，其他环境也会有内存对齐问题)，就很可能操作一个问题，就是当你想要去访问结构体中的一个数据的时候，需要你操作两次数据总线，因为这个数据卡在中间，如图：

在上图中，对于第2个short数据进行访问的时候，在32位机器上就要操作两次数据总线。这样会非常影响数据读写的效率，所以就引入了内存对齐的问题。

另外一层不太重要的原因是：某些硬件平台只能从规定的地址处取某些特定类型的数据，否则会抛出硬件异常。

2.内存对齐的规则：

a.第一个成员起始于0偏移处

b.每个成员按其类型大小和指定对齐参数n中较小的一个进行对齐

c.结构体总长度必须为所有对齐参数的整数倍

d.对于数组，可以拆开看做n个数组元素

3.来几个小例子，画画图，有助于理解：

第一个例子，代码如下：

输出的结果分别是：str1为12    str2为8，分析的过程如下图：

看图很自然就知道了str1为12个字节，str2为8个字节。

第二个例子，上面的那个例子有好多问题还没有考虑到，比如说上面的那个例子在8字节对齐，和4字节对齐的情况都是一样的。结构体中嵌套结构体的内存对齐怎么算，所以就有了这个例子，代码如下：

在Dev c++中，默认的是8字节对齐。我们分析下在4字节对齐的情况下输出的是，S2是20，S1是8，分析如图：

在4字节对齐的情况中，有一个问题值得注意：就是图中画1的地方。这里面本应short是可以上去的。但是对于结构体中的结构体一定要十分警惕，S1是一体的，short已经由于long进行了内存对齐，后面还空了两个字节的内存，其实此时的short已经变成了4个字节了！！！即结构体不可拆，不管是多少字节对齐，他们都是一体的。所有的圈都变成了叉。所以说结构体只能往前篡位置，不能改变整体。

我们在分析一些8字节对齐的情况，如图：

同样，到这里又有一个字节对齐的原则要好好重申一下：就是以什么为对齐参数，首先我们要知道编译器或者自己定义的是多少字节对齐的，这个数为n。然后我们要看这个结构体中的各个数据类型，找到所占字节数最大的类型，为m。如果n大于m，就以m为对齐参数，比如说一个4字节对齐的结构体中都是short，那这个结构体以什么为对齐参数，当然是2了，如果m大于n，就以n为对齐参数，比如说在4字节对齐的情况下的double类型。

以上就是我对内存对齐的小总结，最最想要说明的就是两大段红色的部分。

1.int a=9,b=10,d=9;是可以的。

2.%*d ，在scanf中使用的时候，是1整数但不赋给任何变量，有个小代码：

a的值，你是赋值不进去的，仅仅占位用的。

3.对于冒泡排序，怎么在不完全执行完循环前就预先判断，已经排序结束了：

在一次内层循环的时候，一次都没有进行数据交换，就说名冒泡排序已经排序ok了。

4.不要总记得scanf，同样还存在getchar()和gets()函数，gets能接收含有空格的字符串，这个是scanf不能做到的。

scanf("%ls",a);  //接收有效字符串的第一个字符

scanf("%ns",a);   //这个是格式化输入，接收字符串的从头开始的n个字符

其实我想说，scanf函数真心没有什么用，很不好的一个函数。

5.堆区分配内存是从两头开始增长的，不是单向增长的。

6.typedef int [10]   其实[10]就是int了，个人觉得这个代码风格，很不好，千万不能写成这样，可读性很差！

7.要记住函数在传递参数的时候，其实是数据的拷贝，直接对形参进行改变或者赋值，是毫无意义的，实参是不会改变的。对于指针也是一样的。只有通过指针，取得了当前这个指针指向的内容的时候，改变了这个内容，这样实参才会被改变。因为是直接改变了内存地址中保存的数值。

举个例子就是：在数据结构那节中的链表，creat函数就是一个典型的例子。仔细想想为什么不能在main函数中定义一个头结点，再把这个头结点的地址传给creat函数呢？一定要通过creat返回一个头结点指针呢？再想想，为什么在想通过形参获得子函数中数据的时候，一定要传入地址或者指针呢？然后再把想要获得数据，写入这个地址或者指针中去？

给一段代码，帮助理解这个问题：

想想，为什么子函数中赋值，在main中打印出来是不一样的！！！

      对于fun(strp)的过程是这样的：在函数传递参数的时候，strp的值 赋值给了子函数的str1，这个过程就是函数参数拷贝的过程，然后str1的值在malloc的时候不幸被malloc改变了，所以在main中打印出来的不一样。

对于fun(&str1)的过程是这样的：在函数传递参数的时候，&str1的值  赋值给了子函数的str1，后面的过程跟上面一样。所以在main中打印的也是不一样的。

对于这种情况，最好的解决办法就是利用函数返回值，把str1返回 回来就ok了！！！

注意：可能你会问了，那怎样通过参数获得子函数传递的值啊，其实很简单，你在main中开辟好一段内存，然后把这个内存地址传递到子函数中去，然后对这个内存进行赋值，不要去改变这个指针的指向(即指针的值)，仅仅改变指针指向的内存(即指针指向的内容)，自然就获得了你想要的值！

8.c语言文件操作的一个问题：

c语言中打开文件有两种方式，一种是二进制方式，另一种是文本方式(ASCII码方式)。这两种方式有什么区别？(对于Linux这种只有一种文件类型的操作系统来说是没有区别的)

我们就以windows为例说说区别：

a.以文本方式打开文件，若将数据写入文件，如果遇到换行符'\n'(ASII 值为10，0A)，则会转换为回车—换行'\r\n'(ASCII值为13，10，0D0A)存入到文件中，同样读取的时候，若遇到回车—换行，即连续的ASCII值13，10，则自动转换为换行符。

而以二进制方式打开文件时，不会进行这样的处理。

b.还有如果以文本方式打开文件时，若读取到ASCII码为26(^Z)的字符即0x1a，则停止对文件的读取，会默认为文件已结束，而以二进制方式读取时不会发生这样的情况。由于正常情况下我们手动编辑完成的文件是不可能出现ASCII码为26的字符，所以可以用feof函数去检测文件是否结束。

所以，由于存在上面的两个区别，我们在明确文件类型的时候，最好使用相对应的方式对文件进行打开。对于那些不明确文件类型的时候，最好使用二进制方式打开文件。

指针这一节是本书中最难的一节，尤其是二级指针和二维数组直接的关系。

本节知识点：

d.子函数malloc，主函数free，这是可以的(有两种办法，第一种是利用return 把malloc的地址返回。第二种是利用二级指针，传递一个指针的地址，然后把malloc的地址保存出来)。记住不管函数参数是，指针还是数组， 当改变了指针的指向的时候，就会出问题，因为子函数中的指针就跟主函数的指针不一样了，他只是一个复制品，但可以改变指针指向的内容。这个知识点可以看<在某培训机构的听课笔记>这篇文章。

13.数组作为函数参数：数组作为函数的实参的时候，往往会退化成数组元素类型的指针。如：int a[5]，会退化成int*   ；指针数组会退化成二级指针；二维数组会退化成一维数组指针；三维数组会退化成二维数组指针(三维数组的这个是我猜得，如果说错了，希望大家帮我指出来，谢谢)。如图：

二维数组作为实参的例子：

数组当作实参的时候，会退化成指针。指针当做实参的时候，就是单纯的拷贝了！

14.函数指针与指针函数：

      a.对于函数名来说，它是函数的入口，其实函数的入口就是一个地址，这个函数名也就是这个地址。这一点用汇编语言的思想很容易理解。下面一段代码说明函数名其实就是一个地址，代码如下：

可见函数名就是一个地址，所以函数名abc与&abc没有区别，所以p和*p也没有区别。

b.我觉得函数指针最重要的是它的应用环境，如回调函数(其实就是利用函数指针，把函数当作参数进行传递)代码如下，还有中断处理函数(同理)详细见<

ok6410学习笔记(16.按键中断控制led)>中的 中断注册函数，request_irq。还有就是函数指针数组，第一次见到函数指针数组是在zigbee协议栈中。

回调函数原理代码：

注意：可以使用函数名f2，函数名取地址&f2都可以，但是不能有括号。

c.所谓指针函数其实真的没什么好说的，就是一个返回值为指针的函数而已。

15.赋值指针的阅读：

a.char* (*p[3])(char* d); 这是定义一个函数指针数组，一个数组，数组元素都是指针，这个指针是指向函数的，什么样的函数参数为char*  返回值为char*的函数。

分析过程：char (*p)[3] 这是一个数组指针、char* p[3] 这是一个指针数组  char* 是数组元素类型、char* p(char* d) 这个是一个函数返回值类型是char* 、char (*p)(char* d)这个是一个 函数指针。可见char* (*p[3])(char* d)是一个数组  数组中元素类型是 指向函数的指针，char* (* )(char* d) 这是函数指针类型，char* (* )(char* d) p[3] 函数指针数组 这个不好看 就放里面了。(PS：这个看看就好了~~~当娱乐吧)

b.函数指针数组的指针：char* (*(*pf)[3])(char* p) //这个就看看吧  我觉得意义也不大 因为这个逻辑要是一直下去 就递归循环了。

分析过程：char* (* )(char *p) 函数指针类型，char* (*)(char *p) (*p)[3]  函数指针 数组指针  也不好看 就放里面了。

本节知识点：

通过上面的运行结果，可以分析得出：在同一个函数中，先定义的变量在高地址处，后定义的变量在低地址处，且他们的地址是相连的中间没有空隙。定义的数组是下标大的在高地址处，下标小的在低地址处(由此可以推断出malloc开辟出的推空间，也应该是下标大的在高地址处，下标小的在低地址处)。子函数中的变量，跟父函数中的变量的地址之间有很大的一块空间，这块空间应该是两个函数的其他活动记录，且父函数中变量在高地址处，子函数中的变量在低地址处。

对于本节的函数内容其实就没什么难点了，但是对于函数这节又涉及到了顺序点的问题，我觉得可以还是忽略吧。

本节知识点：

1.函数中的顺序点：f(k,k++);  这样的问题大多跟编译器有关，不要去刻意追求。  这里给下顺序点的定义：顺序点是执行过程中修改变量值的最后时刻。在程序到达顺序点的时候，之前所做的一切操作都必须反应到后续的访问中。

2.函数参数：函数的参数是存储在这个函数的栈上面的(对于栈可以看上篇文章<内存管理的艺术>)，是实参的拷贝。

3.函数的可变参数：

a.对于可变参数要包含starg.h头文件。需要va_list变量，va_start函数，va_arg函数，va_end函数。对于其他函数没什么可说的，只有va_arg函数记得一定是按顺序的接收。这里有一个可变参数使用的小例子，代码如下：

b.可变参数的缺点：

(1).必须要从头到尾按照顺序逐个访问。

(2).参数列表中至少要存在一个确定的命名参数。

(3).可变参数宏无法判断实际存在的参数的数量。

(4).可变参数宏无法判断参数的实际类型。

(5).如果函数中想调用除了可变参数以外的参数，一定要放在可变参数前面。

注意：va_arg中如果指定了错误的类型，那么结果是不可预期的。

Ps：可变参数就说到这里，可变参数最经典的应用就是printf，等分析printf实现的时候，再好好写写。

4.函数与宏的比较：

注意：宏有一个函数不可取替的功能，宏的参数可以是类型名，这个是函数做不到的！代码如下：

5.函数调用中的活动记录问题：包含参数入栈、调用约定等问题。见上篇文章<内存管理的艺术>。

6.递归函数：递归函数有两个组成部分，一是递归点(以不同参数调用自身)，另一个是出口(不再递归的终止条件)。

对于递归函数要有一下几点注意：

a.一定要有一个清晰的出口，不然递归就无限了。

b.尽量不要进行太多层次的递归，因为递归是在不断调用函数，要不断的使用栈空间的，很容易造成栈空间溢出的，然后程序就会崩溃的。比如说：对一个已经排好序的结构进行快速排序(因为快排需要使用递归，且对排好顺序的结构排序是最坏情况，递归层数最多)，就很容易造成栈空间溢出。一般不同的编译器分配的栈空间大小是不一样的，所以允许递归的层数也是不一样的！

c.利用递归函数，实现不利用参数的strlen函数。代码如下：

7.使用函数时应该注意的好习惯：

a.如果函数参数是指针，且仅作为输入参数用的时候，应该加上const防止指针在函数体内被以外改变，如：

b.在函数的入口处，应尽可能使用assert宏对指针进行有效性检查，函数参数的有效性检查是十分必要的。不用assert也行，if(NULL == p)也可以。

c.函数不能返回指向栈内存的指针

d.函数不仅仅要对输入的参数，进行有效性的检查 。还要对通过其他途径进入函数体的数据进行有效性的检查 ，如全局变量，文件句柄等。



   e.不要在函数中使用全局变量，尽量让函数从意义上是一个独立的模块

f.尽量避免编写带有记忆性的函数。函数的规模要小，控制在80行。函数的参数不要太多，控制在4个以内，过多就使用结构体。

g.函数名与返回值类型在语言上不可以冲突，这里有一个经典的例子getchar，getchar的返回值是int型，会隐藏这么一个问题：

如果XXX的值不在char的范围之内， 那c中存储的就是XXX的低8位 ，if就永远不会成立。但是getchar当然不会惹这个祸了，因为getchar获得的值是从键盘中的输入的，是满足ASCII码的范围的，ASCII码是从0~127的，是在char的范围里面的，就算是用char去接getchar的值也不会有问题，getchar还是相对安全的。可是对于fgetc和fgetchar就没这么幸运了，他们的返回值类型同样是int，如果你还用char去接收，那文件中的一些大于127的字符，就会造成越界了，然后导致你从文件中接收的数据错误。这里面就有隐藏的危险了！！！对于字符越界问题可以看看这篇文章<c语言深度解剖读书笔记(1.关键字的秘密)>8.陈正冲老师还有一个第七章是讲文件的我觉得总结不多，就写在这里了：

a.每个头文件和源文件的头部 ，都应该包含文件的说明和修改记录 。

b.需要对外公开的常量放在头文件中 ，不需要对外公开的常量放在定义文件的头部。

9.最终的胜利，进军c++(唐老师的最后一课，讲了些c++的知识，总结如下)：

a.类与对象：

b.c++中类有三种访问权限：

(1).public  类外部可以*访问

(2).protected   类自身和子类中可以访问

(3).private     类自身中可以访问

小例子：

注意：上面这段代码要在c++的编译器中进行编译，在gcc中会报错的，因为c标准中是不允许struct中有函数的。

        c.继承的使用，如图：

小例子：

Ps：以上6篇文章终于更新完了，是我对陈正冲老师的<c语言深度解剖>一书和国嵌唐老师c语言课程的一些总结和理解，针对c语言，后面的一点c++仅仅是做个笔记而已，望大牛莫喷~~~

本节知识点：

最近对c语言的总结学习可以告一段落了！觉得这种边学边思考边总结的方式，还不错，还是有一定的进步的！但是对于日后的c语言学习还远远没有停止。所以写了这篇文章来督促自己对c语言的学习，告诉自己还有很多不错的书没有去读。过一段时间，再回头看看。

1.对于c语言描述的数据结构的学习。

2.林锐老师的<高质量程序设计指南>，听说他的<大学十年>也很不错，有时间应该读一读。

3.<c和指针>     <c陷阱与缺陷>    <c专家编程>    <c++沉思录>

4.仔细研读 <c primer plus>这本书，这本书中有很多细节，很多标准(c99标准)值得学习，应该好好看看！

5.还有就是找一本介绍c 表库函数的书(像字典一样)，看看c库函数都有什么，c库中有多少头文件等。

6.还有就是一些当作补充的书籍：<C语言的科学和艺术>    <你必须知道的495个c语言问题>    <c语言进阶：重点、难点与疑点解析>  <攻破C语言笔试与机试难点V0.3>

7.最后在回头看看，带我最初接触c语言的，谭浩强的<c语言程序设计>。

转自yhf19881015的专栏