1.1 Standard_C

StandardC

Linux

  1. 终端只能使用键盘不能使用鼠标。
  2. 在终端里使用命令完成各种功能。
  3. whoami命令可以查看当前使用的账号。
  4. clear命令可以用来清除中端窗口中的所有文字信息。
  5. 操作系统中用来管理文件的部分成为文件系统。
  6. 文件系统中对文件进行分组管理，分组是多层的。
  7. 文件系统中使用文件夹（目录）表示一个文件分组，文件夹可以包含其他文件夹。
  8. Linux文件系统中顶级分组只有一个，这个分组对应的目录叫根目录，用“/”表示。
  9. 在文件系统中使用路径表示文件或文件夹所在的位置，路径是从一个起点目录开始到终点为止所经过的所有文件（文件夹）名称的总和。
  10. 有两种编写路径的方法，它们所选的起点不同：绝对路径，把根目录设定为起点“/”定为开头。相对路径，可以把任何目录设定为起点。“..”表示左走一步，“.”表示原地踏步。相对路径不需要写起点目录名称。（先回根目录再往后走）
  11. 如果目录B向左走一步能到目录A，则我们说它们之间存在父子关系，目录A是父目录，目录B是子目录。
  12. 在Linux文件系统中为每个用户保留一个私有目录，这个目录叫做用户的HOME目录，可以采用“~”表示。
  13. 终端窗口的当前目录就是所有相对路径的起点，可以反复使用。
  14. 当前目录是可以修改的，一旦修改成功以后的所有相对路径都以修改后的当前目录为起点。
  15. 每次刚打开终端口时当前目录就是当前账号的HOME目录。
  16. pwd命令可以查看当前目录的位置。
  17. cd命令可以修改当前目录位置，使用方法如下：cd 目录路径。
  18. ls：命令列出当前目录下的文件。 ls 目录路径。
  19. ls命令可以使用-a选项，这个选项可以查看目录中所有内容，格式：ls空格-a文件夹(下同)。-l选项可以查看每个目录的详细信息。-a和-l可以合并成-al或-la选项。
  20. cd：路径，cd 空格 文件名 进入文件夹cd 空格 .. 退出当前文件。复制文件：cp 源文件 目录文件。复制目录：cp 空格–r 源目录 目标目录。剪切文件：mv 源文件 目标文件夹。剪切目录：mv 源目录 目标路径/目标目录(目标目录名可以省略)。重命名 ： mv 源文件名 目标文件名。新建文件：touch 文件名。新建目录：mkdir 目录名/目录名，如果要连续创建不存在的目录加参数 1–p。格式：mkdir空格-p文件夹名 空格 –p 文件夹名……删除文件/删除目录:rm 文件名/rm -r 目录名。-rf选项删除非空目录。
  21. 压缩：tar zcvf 1.tar.gz 1.c 压缩命令 压缩的目标文件 压缩的源文件 tar zcvf 压缩文件名 .tar.gz。解压：tar zxvf 压缩文件名 .tar.gz。

​ z: 压缩格式

​ c：压缩参数

​ v：显示压缩的文件信息

​ f：创建压缩文件

​ x: 解压参数

  1. 解压缩：tar zxvf 1.tar.gz

Vi命令

  1. vimtutor<回车>进入vi。vim空格 文件名<回车>进入当前文件。Esc确保正常模式。

  2. Esc :q! <回车>放弃修改退出。Esc :wq<回车>保存修改并退出。Esc :w文件名<回车>保存不退出。Esc :x保存退出。Esc shift zz 保存退出。Esc :w 文件名 保存不退出。

  3. x删除光标所在位置字符。

    i在光标当前插入内容。

    a在光标后方插入内容。

    A在光标的行末插入内容。

    o在当前光标下方插入新的空行。

    O在当前光标上方插入新的空行。

  4. dw删除该单词（包括该单词后面的空格）。

    de删除该单词（不包括该单词后面的空格）。

    d$删除到行尾。

    3d或d3删除三个单词。

    dd剪切当行，p粘贴。等价于剪切->粘贴。

    yy 和 p 等价于复制->粘贴。

    2yy 和 p 复制两行->粘贴。

    u撤销当前操作。

    数字 G 跳到指定行。

  5. ：/内容（单词） 查找。n切换下一个自上而下查找。N自下而上查找。括号配对查找，放在当前括号上按%。:%s/错误/正确/g 全文替换。:开始行号，结束行号s/错误/正确/g。

  6. :set ic 设置忽略大小写。:set nu 设置显示行号。

  7. vi空格 . vimrc 设置每次启动按设置进行。

  8. 在Linux下：终端输入 gftp ip：xxx.xxx.x.xxx name：xxx passwd：xxx

    在XP/win7,打开我的电脑：输入ftp://xxx.xxx.x.xxx name：xxx passwd：xxx

C语言

  1. C语言中支持加减乘除运算，使用符号+-*/表示。

  2. 每条语句结尾必须加“；”作为分隔符。

  3. 大括号用来对语句进行分组，大括号可以互相嵌套。

  4. 函数代表一组数据处理过程，不同函数通过名称进行区分。

  5. 叫做main的函数称为主函数，它是程序的起点，它结束了则程序结束了。

    1. int main() {
    2.     2 * 169;
    3.     return 0;
    4. }
    1. /*
    2.    main函数的参数
    3. */
    4. #include <stdio.h>
    5. int main(int argc, char *argv[]) {
    6.     int loop = 0;
    7.     for (loop = 0; loop <= argc - 1; loop++) {
    8.         printf("%s\n", argv[loop]);
    9.     }
    10.     return 0;
    11. }

  6. 可把某个数字记录在返回值中。

  7. C语言中数字是分组的，int代表整数分组。

  8. 关键字是C语言中有特定功能的英文单词。

  9. C语言程序中使用标示符区分不同内容，标示符要符合以下规定：

    （1）必须使用字母，下划线开头。

    （2）后面的可以是字母、数字或下划线。

    （3）区分大小写。

  10. 不能使用关键作为标示符。

  11. 长度没有限制。

  12. 一行只包含一条语句（过长的语句可以分散在多行内）。

  13. 层次不同的语句使用缩进区分开。

  14. 适当使用空格。

  15. 使用空格分割不同语句。

  16. 采用驼峰方式或（XiAn）下划线方式(xi_an)书写标示符。

  17. include是一条预处理命令，用于把某个“.h”文件的内容合并当前“.c”文件中。使用方法如下：

    include “abc.h”或#include

  18. 双引号表示“.c”文件所在目录开始查找“abc.h”文件，尖括号表示从系统公共目录开始查找“abc.h”文件。

  19. 使用注释可以在程序中加入文字信息，注释分成单行注释和多行注释，单行注释由：、“//”开头到行尾，多行注释使用“/*”开头由“*/”结尾。

  20. C语言开发步骤：

    (1). 使用vi编写源程序文件。

    (2). 使用gcc工具对源程序文件进行编译处理。

    (3). 使用命令“./a.out”执行得到的文件。

  21. 编译处理的过程：

    (1). 预处理，完成所有预处理指令的处理。

    (2). 编译，把预处理后的程序编译成计算机能识别的格式。

    (3). 链接，把各个语句段落链接起来。

  22. gcc命令选项介绍：

    (1). -E 只完成与处理工作。

    (2).2-c 只完成与处理和编译工作。

    (3).-o 指定执行文件的名称。

    (4).-std=c89或-std=c99 指编译所采用的规范版本。

    (5).-D定义宏

  23. printf函数可以在屏幕上显示信息， 需要包含文件stdio.h。占字符要和显示的信息必须匹配。

    %d 整数匹配

    %c 字符数据匹配

    %f和%g 与带小数点的数字匹配，例如5.7f。

    %lf和%lg 与小数点的数字匹配，例如5.7。

    占字符还可以通过变化支持多种格式。

    1. /*
    2.    printf练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    printf("1\n");
    7.    printf("%d\n", 1);
    8.    printf("%d %d\n", 1, 2);
    9.    printf("你%d 好%d吗?\n", 1, 2);
    10.    printf("%c\n", 'a');
    11.    printf("%f %g\n", 5.7f, 5.7f);
    12.    printf("%lf %lg\n", 5.7, 5.7);
    13.    printf("%d\n", 4.8);  //数据和占位符不匹配
    14.    printf("%3d\n", 1);
    15.    printf("%03d\n", 1);
    16.    printf("%-3dabc\n", 1);
    17.    printf("%7.2fabc\n", 2.5f);
    18.    return 0;
    19. }
    1. /*
    2.    printf练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    printf("12345\n");
    7.    printf("%d\n", 12345);
    8.    printf("1%d5\n", 234);
    9.    printf("1%c3%c5\n", '2', '4');
    10.    printf("%d%c%d\n", 12, '3', 45);
    11.    printf("%d - %d = %d\n", 4000, 3600, 4000 - 3600);
    12.    return 0;
    13. }

  24. 使用变量申明语句向程序中引入变量，语句如下：

    int shu_zi;

    其中shu_zi是变量的名称，int表示变量中只能存储整数类型数据。

    1. /*
    2.    变量练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int shu_zi;
    7.    shu_zi = 3000;
    8.    //3000 = shu_zi;    错误,3000不能当成变量使用
    9.    shu_zi = shu_zi;
    10.    printf("%d\n", shu_zi);
    11.    return 0;
    12. }

  25. 声明变量的时候可以立刻使用赋值语句进行赋值，这叫变量的初始化，变量一定要初始化。

  26. 计算机内部使用地址数据管理变量。

  27. 假设一个叫做shu_zi的变量，则&shu_zi可以表示这个变量的地址。在变量地址数据前边加上符号*可以表示对应的的变量。

    1. /*
    2.    地址数据练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int shu_zi = 3;
    7.    printf("%d\n", shu_zi);
    8.    printf("%d\n", *(&shu_zi));
    9.    return 0;
    10. }

  28. printf函数使用时的四个特殊字符：\”,\,%%,\r 。

    1. /*
    2.    printf特殊字符：\”,\\,%%,\r 练习
    3. */
    4. #include<stdio.h>
    5. int main(){
    6.    printf("\"\n");
    7.    printf("\\\n");
    8.    printf("%%\n");
    9.    printf("\rxyz\n");
    10. return 0;
    11. }

  29. scanf函数可以从键盘上读取数据并记录到变量中，需要包含stdio.h文件。

    1. /*
    2.    scanf练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int shu_zi = 0, shu_zi1 = 0;
    7.    printf("请输入一个加法公式：");
    8.    scanf("%d + %d", &shu_zi, &shu_zi1);
    9.    printf("计算结果是%d\n", shu_zi + shu_zi1);
    10.    return 0;
    11. }
    1. /*
    2.    scanf练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int shu_zi = 0, shu_zi1 = 0;
    7.    printf("请输入两个整数：");
    8.    scanf("abc%d def%d", &shu_zi, &shu_zi1);
    9.    //scanf("%d", shu_zi);    段错误
    10.    printf("%d %d\n", shu_zi, shu_zi1);
    11.    return 0;
    12. }

    使用scanf函数的时候一定要使用变量的地址表示变量而不能使用变量名称。

    1. /*
    2.    闰年练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int nian = 0;
    7.    printf("请输入一个年份数字：");
    8.    scanf("%d", &nian);
    9.    if (!(nian % 400) || (!(nian % 4) && (nian % 100))) {
    10.        printf("闰年\n");
    11.    }
    12.    else {
    13.        printf("不是闰年\n");
    14.    }
    15.    return 0;
    16. }
    1. /*
    2.    素数练习
    3. */
    4. #include <stdio.h>
    5. #include <math.h>
    6. int main() {
    7.    int shu_zi = 0, gen = 0, xun_huan = 0;
    8.    printf("请输入一个数字：");
    9.    scanf("%d", &shu_zi);
    10.    gen = sqrt(shu_zi);
    11.    for (xun_huan = 2;xun_huan <= gen;xun_huan++) {
    12.        if (!(shu_zi % xun_huan)) {
    13.            break;
    14.        }
    15.    }
    16.    if (xun_huan <= gen) {
    17.        printf("不是素数\n");
    18.    }
    19.    else {
    20.        printf("是素数\n");
    21.    }
    22.    return 0;
    23. }

  30. 字符类型由256个不同的字符构成，在C语言中使用char（+-128）表示。ASCII码表规定了字符到数字之间的对应关系。’d’-‘a’等于’D’-‘A’等于’3’-‘0’。

  31. unsigned char（0-255）叫做无符号字符类型。

  32. 计算机内存以字节为单位进行管理，每个变量都由一个或多个相邻的字节组成。

  33. sizeof关键字可以计算出某个变量或某种数据类型占据多少个字节的空间。

  34. sizeof关键字可以对表达式的结果求大小，但是表达式中的所有修改都不会保留。

    1. /*
    2.    sizeof练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    char zi_fu = 0;
    7.    unsigned char u_zi_fu = 0;
    8.    printf("变量zi_fu占%d个字节\n", sizeof(zi_fu));
    9.    printf("char类型变量占%d个字节\n", sizeof(char));
    10.    printf("变量u_zi_fu占%d个字节\n", sizeof(u_zi_fu));
    11.    printf("unsigned char类型变量占%d个字节\n", sizeof(unsigned char));
    12.    zi_fu = 'a';
    13.    sizeof(zi_fu = 'b');
    14.    printf("%c\n", zi_fu);
    15.    return 0;
    16. }

  35. short（+-三万）叫做短整数类型，unsigned short（+六万）叫做无符号整数类型。这两种数据类型都在内存中占2个相邻的字节。

  36. long叫长整数类型，unsigned long叫做无符号常数类型。这两种类型都在内存中占4个相邻的字节。

  37. int叫整数类型，unsigned int叫做无符号整数类型。在我们的计算机上这两种类型都在内存在占4个相邻的字节。

  38. float叫做单精度浮点数类型，这种类型在内存中占4个相邻字节。

    double叫做双精度浮点数类型，这种类型在内存中占8个字节。

  39. 使用一组0或1表示数字的方法叫做二进制，计算机内部所有数字都是使用二进制表示的。

  40. 一个字节由8个二进制位构成。

  41. 十进制到二进制转换例子：

    123=64+32+16+8+2+1 = 2^6 + 2^5 + 2^4 + 2^3 + 2^1 + 2^0 = 01111011 。

    二进制到十进制转化例子：

    00110110 = 2^5 + 2^4 + 2^2 + 2^1 = 32 + 16 + 4 + 2 = 54 。

  42. 负数到二进制的转换方法是正数二进制按位求反再加1，例如：51 = 00110011，-51 = 11001100 + 1 = 11001101 。

  43. 负数二进制表示方法叫做补码，正数的二进制表示方式既叫原码也叫补码。

  44. 负数的二进制也可以通过按位求反加1的办法计算出相反的正数的二进制。

  45. 根据负数补码计算负数的过程如下：10101001的相反数 = 01010110 + 1 = 01010111 = 87 。 10101001对应的十进制负数是 -87 。

  46. 二进制数字最左一位叫做符号位，正数符号位是0，负数符号位是1。

  47. 00000000为十进制的0 , 10000000为八位二进制最小的数字对应十进制为-128。

  48. 把一个二进制数字从右向左每三个分为一组，把每一组用一个0到7之间的数字替换掉就得到八位制数字。

    1. /*
    2.    进制练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    printf("%d %d %d\n", 12, 012, 0x12);
    7.    printf("%d 0%o 0x%x\n", 18, 18, 18);
    8.    printf("%p\n", 14);
    9.    return 0;
    10. }
    1. /*
    2.    二进制练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int shu_zi = 300;
    7.    unsigned char u_zi_fu = 200;
    8.    char zi_fu = shu_zi;
    9.    printf("%d\n", zi_fu);
    10.    zi_fu = u_zi_fu;
    11.    printf("%d\n", zi_fu);
    12.    return 0;
    13. }

  49. 如果每四个数分为一组就得到十六进制数字。十六进制数字中用a,b,c,d,e,f分别表示每个数位上的10到15。

  50. C语言支持+，-，*，/，和%（取余操作）。

  51. 符合赋值操作符的优先级和赋值操作符的优先级一样低。

    a *= b + c等价于a = a*(b+c)

  52. ，操作符可以连接多个独立的操作。

  53. ++自增操作符和­­ - - 自减操作符可以对变量进行操作把变量内部的数字加1或者减1.这两个操作符在变量前的时候优先级非常高，写在后面的时候优先级很低（比等号都低）。

    1. /*
    2.    操作符练习
    3. */
    4. #include <stdio.h>
    5. int shu_zi2 = 3;
    6. int main() {
    7.    int shu_zi = 0, shu_zi1 = 0;
    8.    //shu_zi = 3, 7;
    9.    shu_zi = (3, 7);
    10.    printf("shu_zi是%d\n", shu_zi);
    11.    //shu_zi++;
    12.    //++shu_zi;
    13.    //shu_zi--;
    14.    --shu_zi;
    15.    printf("shu_zi是%d\n", shu_zi);
    16.    //shu_zi1 = ++shu_zi;  //两个变量内部都是7
    17.    shu_zi1 = shu_zi++;
    18.    printf("shu_zi是%d,shu_zi1是%d\n", shu_zi, shu_zi1);
    19.    shu_zi1 = shu_zi++ + ++shu_zi;
    20.    printf("shu_zi是%d,shu_zi1是%d\n", shu_zi, shu_zi1);
    21.    shu_zi1 = shu_zi2++ + ++shu_zi2;
    22.    printf("shu_zi1是%d,shu_zi2是%d\n", shu_zi1, shu_zi2);
    23.    return 0;
    24. }

  54. C语言中支持如下逻辑操作符（==，！=，<,>,<=,>=,&&,||）。

    1. /*
    2.    操作符练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int shu_zi = 0, shu_zi1 = 0;
    7.    printf("15 / 7 = %d\n", 15 / 7);
    8.    printf("15 %% 7 = %d\n", 15 % 7);
    9.    shu_zi = shu_zi1 = 7;
    10.    printf("shu_zi是%d,shu_zi1是%d\n", shu_zi, shu_zi1);
    11.    shu_zi += 2;   //相当于shu_zi = shu_zi + 2
    12.    printf("shu_zi是%d\n", shu_zi);
    13.    shu_zi *= 2 + 3;
    14.    printf("shu_zi是%d\n", shu_zi);
    15.    return 0;
    16. }

  55. &&和||具有短路特性。

  56. ！也是一个逻辑操作符，可以对一个逻辑表达式的结果求反。例如：！6则6为真1再经过！结果变为0。（规定>0的数字为真即为1）

  57. 数学操作符优先级高于逻辑操作符。

    1. /*
    2.    逻辑操作符练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int shu_zi = 0;
    7.    printf("3 == 5是%d\n", 3 == 5);
    8.    printf("3 != 5是%d\n", 3 != 5);
    9.    printf("3 > 5是%d\n", 3 > 5);
    10.    printf("3 < 5是%d\n", 3 < 5);
    11.    printf("3 >= 5是%d\n", 3 >= 5);
    12.    printf("3 <= 5是%d\n", 3 <= 5);
    13.    printf("3 < 7 < 5是%d\n", 3 < 7 < 5);
    14.    printf("3 < 7 && 7 < 5是%d\n", 3 < 7 && 7 < 5);
    15.    printf("3 < 7 || 7 < 5是%d\n", 3 < 7 || 7 < 5);
    16.    3 > 5 && ++shu_zi;
    17.    printf("shu_zi是%d\n", shu_zi);
    18.    3 < 5 || ++shu_zi;
    19.    printf("shu_zi是%d\n", shu_zi);
    20.    printf("!6是%d\n", !6);
    21.    printf("5 + 3 > 4是%d\n", 5 + 3 > 4);
    22.    return 0;
    23. }

  58. &表示按位与，可以对两个二进制补码进行计算得到一个新的二进制补码。它可以把某个补码中特定的位置清0（对应同时为1是则为1）。

  59. |表示按位或，可以对两个二进制补码进行计算得到一个新的二进制补码。它可以把某个补码中特定的位置设置为1（对应有一个为1则为1）。

  60. ^表示按位亦或，它可以把某个已知的补码中特定位置变成相反数字（对应相同的为0不同的为1）。

    1. /*
    2.    位操作符
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    printf("3 & 5是%d\n", 3 & 5);
    7.    printf("3 | 5是%d\n", 3 | 5);
    8.    printf("3 ^ 5是%d\n", 3 ^ 5);
    9.    printf("~0xffffff96是0x%x\n", ~0xffffff96);
    10.    return 0;
    11. }

  61. ~表示按位求反，可以对一个二进制补码进行计算得到一个新的二进制补码。

    1. /*
    2.    ~按位求反 练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int a = 1,b = 2;
    7.    printf("%d\n",(char)~5);
    8.    return 0;
    9. }

  62. %p读取地址数据。

    1. /*
    2.    地址操作符
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int shu_zi = 0;
    7.    printf("%p\n", &shu_zi);
    8.    *(&shu_zi) = 3;
    9.    printf("shu_zi是%d\n", shu_zi);
    10.    return 0;
    11. }

  63. <<表示左移操作，可以把一个补码向左移动指定位数。如果移动后没有丢失有效信息则新数据是原有数据的2的n次方倍。

  64. >>表示右移操作，可以把一个补码向右移动指定的位数。如果被移动的数字是无符号数据则左边补充0，否则左边补充符号位。如果移动后没有丢失有效信息则原数据是新数据的2的n次方倍。

    1. /*
    2.    移位操作
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    printf("0xabcdef89 << 2是0x%x\n", 0xabcdef89 << 2);
    7.    printf("0xabcdef89 >> 2是0x%x\n", 0xabcdef89 >> 2);
    8.    printf("(int)0xabcdef89 >> 2是0x%x\n", (int)0xabcdef89 >> 2);
    9.    return 0;
    10. }

  65. 三目操作符可以根据一个逻辑表达式的结果从两个不同的计算过程中选择一个来使用。

    1. /*
    2.    三目操作符练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int shu_zi = 0;
    7.    printf("请输入一个数字：");
    8.    scanf("%d", &shu_zi);
    9.    shu_zi = shu_zi >= 100 ? shu_zi - 100 : 100 - shu_zi;
    10.    printf("距离是%d\n", shu_zi);
    11.    return 0;
    12. }

  66. C语言中可以使用强制类型转换把任何一个数据当成任何一种类型来使用。

    1. /*
    2.    强制类型转换练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int shu_zi = 300;
    7.    printf("%d\n", (unsigned char)shu_zi);
    8.    printf("%d\n", shu_zi);
    9.    return 0;
    10. }

  67. 隐式类型转换会把占地小的的数据转换成占地大的数据，如果数据大小一样会把有符号的转换成无符号的数据。

    1. /*
    2.    隐式类型转换练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int shu_zi = -10;
    7.    unsigned int shu_zi1 = 3;
    8.    shu_zi = (shu_zi + shu_zi1) > 0 ? 1 : -1;
    9.    printf("计算结果是%d\n", shu_zi);
    10.    printf("大小是%d\n", sizeof(3 < 5 ? 1 : 0.9));
    11.    return 0;
    12. }

  68. 分支语句可以用来处理分叉情况，if语句是一种分支处理语句，使用方法如下：

    if（逻辑表达式1）{//有并且只能有一个处理语句1}

    else if （逻辑语句2）{//可能没有也可能有很多 处理语句2}

    else {//可能没有，最多一个 处理语句3}。

    1. /*
    2.    if练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int shu_zi = 0;
    7.    printf("请输入一个数字：");
    8.    scanf("%d", &shu_zi);
    9.    if (shu_zi % 2) {
    10.        printf("奇数\n");
    11.        if (!(shu_zi % 5)) {
    12.            printf("能被5整除\n");
    13.        }
    14.    }
    15.    else {
    16.        printf("偶数\n");
    17.    }
    18.    /*if (!(shu_zi % 5) && (shu_zi % 2)) {
    19.        printf("能被5整除\n");
    20.    }*/
    21.    return 0;
    22. }

  69. switch…case也可以用来实现分支处理，使用方法如下：

    switch(表达式)

    {

    case 数字1：

    ​ 处理代码1；

    ​ break;

    case 数字2：

    ​ 处理代码2；

    ​ break;

    ​ …….

    default:

    ​ 非正常处理代码；

    ​ break;

    }

    其中表达式必须能得到一个整数结果，处理代码用1来处理结果为数字1的情况。

    1. /*
    2.    switch...case练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    char zi_fu = 0;
    7.    printf("请输入一个字符：");
    8.    scanf("%c", &zi_fu);
    9.    switch (zi_fu) {
    10.    case 'a':
    11.        printf("10\n");
    12.        break;
    13.    case 'b':
    14.        printf("11\n");
    15.        break;
    16.    case 'c':
    17.        printf("12\n");
    18.        break;
    19.    case 'd':
    20.        printf("13\n");
    21.        break;
    22.    case 'e':
    23.        printf("14\n");
    24.        break;
    25.    case 'f':
    26.        printf("15\n");
    27.        break;
    28.    default:
    29.        printf("错误字符\n");
    30.        break;
    31.    }
    32.    return 0;
    33. }

  70. for语句可以用来实现循环，使用方法如下：

    int xun_huan = 0;

    for(xun_huan = 0; xun_huan < 次数；xun_huan++){

    ​ 反复执行语句

    ​ }

    for语句是分组执行的，假如有如下的for语句for（1；2；3）{4}

    [1,2] [4,3,2] [4,3,2]….

    编号为2的语句决定下一组是否要开始，正常情况下当循环结束的时候编号为2的语句计算结果应该是假。

    1. /*
    2.    for练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int xun_huan = 0;
    7.    for (xun_huan = 0;xun_huan < 3;xun_huan++) {
    8.        printf("1\n");
    9.    }
    10.    return 0;
    11. }

  71. for语句还可以用来表示一组数字的变化过程，循环变量随时代表变化中的某个数值。

  72. 循环中可以使用continue；语句直接跳到大括号的末尾，把中间的语句忽略。

  73. 循环语句使用break;语句直接结束循环的执行。

  74. 循环嵌套可以解决复杂问题，外层循环通常把大问题分解成几个小问题，内层循环负责解决每个小问题。

  75. 当编写不确定次数的循环时可以采用while语句。while有两种用法，区别在于执行顺序不同（while放后面语句后必须加分号）。

  76. 空语句循环和死循环。

    1. /*
    2.    循环练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int xun_huan = 0, he = 0;
    7.    for (xun_huan = 5;xun_huan <= 20;xun_huan++) {
    8.        if (7 == xun_huan) {
    9.            continue;
    10.        }
    11.        he += xun_huan;
    12.        if (he > 40) {
    13.            break;
    14.        }
    15.    }
    16.    printf("xun_huan是%d,he是%d\n", xun_huan, he);
    17.    return 0;
    18. }

  77. 数组是由多个同类型的变量构成的，数组的声明方式如下：

    int arr[10]；其中10表示数组中一共有10个变量，int表示数组中所有变量的类型都是int。

    arr[3]；其中arr是数组名称，3叫做数组的下标，下标从0开始到个数减一为止(0~9)，超过范围的下标不可以使用。

  78. 数组的多种初始化方法。

    1. /*
    2.    数组初始化练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    //int arr[3] = {1, 2, 3};
    7.    //int arr[3] = {1, 2, 3, 4, 5};
    8.    //int arr[] = {1, 2, 3, 4, 5};
    9.    int arr[3] = {1};
    10.    int loop = 0;
    11.    for (loop = 0; loop <= 2; loop++) {
    12.        printf("%d ", arr[loop]);
    13.    }
    14.    printf("\n");
    15.    return 0;
    16. }

  79. 编译时数组名称被直接替换成数组中第一个变量的地址，数组名称取地址的结果也是直接替换成数组中第一个变量的地址。

  80. 通过数组得到的地址数据可以进行简单的加减计算。如果进行加1计算则这个1的单位和地址的获得方式有关（变量名加1相当于加一个变量的大小，变量取地址加1相当于加一个数组的大小）。

  81. 如果有数组arr，则arr + 3可以获得数组中下标为3变量的地址。

    1. /*
    2.    数组名称的使用
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int arr[5] = {1, 2, 3, 4, 5};
    7.    int loop = 0;
    8.    printf("arr是%p，&arr[0]是%p\n", arr, &arr[0]);
    9.    //arr = 1;     错误
    10.    printf("&arr是%p\n", &arr);
    11.    printf("arr + 1是%p,&arr + 1是%p\n", arr + 1, &arr + 1);
    12.    *(arr + 3) = 13;
    13.    printf("arr[3]是%d\n", arr[3]);
    14.    for (loop = 0; loop <= 4; loop++) {
    15.        printf("%d ", *(arr + loop));
    16.    }
    17.    printf("\n");
    18.    return 0;
    19. }

  82. 对数组名称使用sizeof关键字计算得到整个数组大小。如：sizeof(arr)/sizeof(arr[20])。

    1. /*
    2.    sizeof练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.    int arr[] = {1, 2, 3, 4, 5};
    7.    printf("sizeof(arr)是%d\n", sizeof(arr));
    8.    printf("个数是%d\n", sizeof(arr) / sizeof(arr[0]));
    9.    return 0;
    10. }

  83. 多个一位数组可以合并为一个二维数组，二维数组声明如下：

    int arr[3][4];

    img img

    3表示由3个一维数组构成，4表示每个一维数组中包含4个。

  84. C语言中使用函数对大量语句进行分组，函数的编写方法如下：

    返回值类型 函数名称（形参列表） {语句} 不同的函数通过函数名区分，返回值是一个变量，可以用来记录函数执行过程中产生的一个新数据。这个变量在函数结束后可以被其它函数使用。形参就是一组变量，函数开始执行时被临时创建出来并使用指定数据进行初始化。大括号前面的部分可以独立存在，叫做函数声明。大括号整体叫做函数体。

    1. /*
    2.    函数练习
    3. */
    4. #include <stdio.h>
    5. int read() {
    6.    int value = 0;
    7.    printf("请输入一个整数：");
    8.    while (!scanf("%d", &value)) {
    9.        scanf("%*[^\n]");
    10.        scanf("%*c");
    11.        printf("请再次输入一个整数：");
    12.    }
    13.    scanf("%*[^\n]");
    14.    scanf("%*c");
    15.    return value;
    16. }
    17. int main() {
    18.    int value = 0;
    19.    value = read();
    20.    printf("数字是%d\n", value);
    21.    return 0;
    22. }

  85. fflush(stdout);

    这条语句可以把输出缓冲区里的内容立刻显示在屏幕上。

    1. /*
    2.   秒表练习
    3. */
    4. #include <stdio.h>
    5. #include <time.h>
    6. #include <unistd.h>
    7. int main() {
    8.    int start = time(0);
    9.    while (1) {
    10.        printf("%ld\r", time(0) - start);
    11.        fflush(stdout);
    12.        sleep(1);
    13.    }
    14.    return 0;
    15. }

  86. 形参和实参完全不同的，实参用来对形参进行初始化。函数结束后形参自动消失。

  87. 在源程序文件的开头应该把文件中所有函数声明都列出来。否则有可能在编译的时候导致函数隐式声明，这种方式有可能出问题。

  88. exit(0)；语句可以在任何地方终止整个程序的执行，需要包含stdlib.h文件。

    1. /*
    2.   函数终止
    3. */
    4. #include <stdio.h>
    5. #include <stdlib.h>
    6. void func(){
    7.    printf("abc\n");
    8.    //return; //结束本函数
    9.    exit(0); //结束整个程序
    10.    printf("def\n");
    11. }
    12. int main() {
    13.    func();
    14.    printf("xyz\n");
    15.    return 0;
    16. }

  89. 使用数组做参数时形参和实参是同一个数组，函数中修改了数组的内容调用函数可以看着数组的变化。

  90. 使用数组做参数需要一个专门的参数表示数组中的变量个数。

  91. 递归函数在执行过程中还会再次调用自己。

    1. /*
    2.    递归练习
    3. */
    4. #include <stdio.h>
    5. int sum(int num) {
    6.    if (1 == num) {
    7.        return 1;
    8.    }
    9.    else {
    10.        return num + sum(num - 1);
    11.    }
    12. }
    13. int main() {
    14.    printf("sum(5)是%d\n", sum(5));
    15.    return 0;
    16. }

  92. 用循环方法解决问题的思路叫做递推，用递归函数解决问题的思路叫做递归。

    1. /*
    2.    递归练习(汉诺塔)
    3. */
    4. #include <stdio.h>
    5. void han(int num, char src, char mid, char dest) {
    6.    if (1 == num) {
    7.        printf("把盘子%d从%c柱移动到%c柱\n", num, src, dest);
    8.    }
    9.    else {
    10.        han(num - 1, src, dest, mid);
    11.        printf("把盘子%d从%c柱移动到%c柱\n", num, src, dest);
    12.        han(num - 1, mid, src, dest);
    13.    }
    14. }
    15. int main() {
    16.    int num = 0;
    17.    printf("请输入盘子个数：");
    18.    scanf("%d", &num);
    19.    han(num, 'A', 'B', 'C');
    20.    return 0;
    21. }

  93. 变量分为三种，全局变量（不用初始化），局部变量和块变量。变量的作用域指的是可以用来使用某个变量的变量名的所有语句总和。变量的生命周期指的是在程序运行期间变量变量可以被使用的时间范围。全局变量的作用域包括程序的所有语句，他的生命周期是整个程序的运行周期。局部变量的作用域包括声明他的那个函数中所有语句，他的生命周期是那个函数的某次运行时间段。块变量的作用域包括声明它的那个大括号内部的所有语句，它的生命周期是那个大括号的某次运行时间段。

    1. /*
    2.   变量练习
    3. */
    4. #include <stdio.h>
    5. int value1;     //全局变量
    6. void func() {
    7.    int value2 = 2;    //局部变量
    8.    printf("value2是%d\n", value2);
    9. }
    10. int main() {
    11.    int value4 = 4;    //局部变量
    12.    {
    13.        int value3 = 3;    //块变量
    14.        printf("value3是%d\n", value3);
    15.        printf("value4是%d\n", value4);
    16.    }
    17.    //func();
    18.    //printf("%d\n", value3);
    19.    return 0;
    20. }

  94. 不同类型(不同作用域)变量可以重名，使用时遵守就近原则。

    1. /*
    2.   变量练习
    3. */
    4. #include <stdio.h>
    5. int value;
    6. int main() {
    7.    printf("value是%d\n", value);
    8.    int value = 2; //变量的就近原则
    9.    printf("value是%d\n", value);
    10.    {
    11.        printf("value是%d\n", value);
    12.        int value = 3;
    13.        printf("value是%d\n", value);
    14.    }
    15.    printf("value是%d\n", value);
    16.    return 0;
    17. }

  95. 栈是一种变量使用方式，遵循的原则是后进先出。

    1. /*
    2.   栈的练习
    3. */
    4. #include <stdio.h>
    5. int stack[10];
    6. int num;
    8. void push(int value) {
    9.    stack[num] = value;
    10.    num++;
    11. }
    13. int pop() {
    14.    num--;
    15.    return stack[num];
    16. }
    18. int empty() {
    19.    return 0 == num;
    20. }
    22. int full() {
    23.    return 10 == num;
    24. }
    26. int main() {
    28.    return 0;
    29. }

  96. sleep(n);函数可以让程序停止n秒，需包含头文件unistd.h。

  97. 程序在内存中运行的时候是分段存储的。代码段用来存储所有的语句，在运行时代码段中的内容不可以被修改。

  98. 栈是程序运行中的一个段落，用来管理某些变量。

  99. 函数的局部变量，形式参数都被放置在栈中。

  100. 堆用来管理手动创建和销毁的变量。

  101. auto关键字可以用来声明变量，所有局部变量自动是auto的，所以不需要特别声明。

  102. static关键字可以用来声明静态变量。静态全局变量的作用域被缩小成声明它的那个文件里面的所有语句。静态局部变量的生命周期被拉长到整个程序运行期间。

    1. /*
    2.  静态变量练习
    3. */
    4. #include <stdio.h>
    5. void f() {
    6.   static int value = 0;
    7.   printf("value是%d\n", value);
    8.   value++;
    9. }
    10. int main() {
    11.   f();
    12.   f();
    13.   return 0;
    14. }

  103. register关键字可以用来声明寄存器变量。

  104. volatile关键字可以声明异变变量。

  105. const关键字可以用来声明不可变变量。

    1. /*
    2.  const关键字练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   const int value = 0;
    7.   printf("value是%d\n", value);
    8.   //value = 3;
    9.   value++;
    10.   printf("value是%d\n", value);
    11.   return 0;
    12. }

  106. 指针变量是用来记录地址数据的变量。

    img

  107. int *p_value;其中*表示指针变量，int表示可以使用这个指针变量表示另外一个int类型的变量。

    1. /*
    2.  指针练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   int values[] = {1, 2, 3, 4, 5};
    7.   int *p_value;
    8.   for (p_value = values; p_value <= (values + 4); p_value++) {
    9.       printf("%d ", *p_value);
    10.   }
    11.   printf("\n");
    12.   return 0;
    13. }
    1. /*
    2.  指针练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   /*int value1 = 0, value2 = 0;
    7.   int *p_value = &value1;
    8.   *p_value = 5;
    9.   p_value = &value2;
    10.   *p_value = 7;
    11.   value1 += *p_value;*/
    12.   int values[2];
    13.   int *p_value = values;
    14.   *p_value = 5;    //values[0] = 5
    15.   p_value++;
    16.   *p_value = 7;    //values[1] = 7
    17.   *(p_value - 1) += *p_value;  //values[0] += values[1]
    18.   return 0;
    19. }

  108. 指针变量可以使用赋值操作符进行赋值，只有对指针变量赋值后才可以使用指针变量表示另外一个变量。

  109. 一个指针变量可以表示一个数组中的所有普通变量。

  110. 指针变量的大小是4个字节。

    1. /*
    2.  指针练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   int value = 0;
    7.   int *p_value = NULL;
    8.   p_value = &value;
    9.   printf("大小是%d %d\n", sizeof(p_value), sizeof(int *));
    10.   return 0;
    11. }

  111. NULL表示空地址，其实是数字0。记录空地址的指针变量叫做空指针。所有无效指针必须被设置成空指针。记录无效地址的指针叫做野指针，程序中不应该出现野指针。

  112. 指针变量可以进行强制类型转换，转换后的到的指针记录的地址就是原指针中的地址数据，但是它们的类型不同，所以使用方法也不同。

    1. /*
    2.  指针练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   int value = 134643;
    7.   int *p_value = &value;
    8.   printf("*p_value是%d\n", *p_value);
    9.   printf("*(unsigned char *)p_value是%d\n", *(unsigned char *)p_value);
    10.   return 0;
    11. }

  113. 指针变量可以作为函数的形参使用，调用这种函数必须使用地址数据作为实参。

    1. /*
    2.  指针练习
    3. */
    4. #include <stdio.h>
    5. int add(int value, int value1) {
    6.   value = 10;
    7.   return value + value1;
    8. }
    9. int add1(int *p_value, int *p_value1) {
    10.   *p_value = 10;
    11.   return *p_value + *p_value1;
    12. }
    13. int main() {
    14.   int value = 3, value1 = 5;
    15.   int ret = add(value, value1);
    16.   printf("value是%d\n", value);
    17.   printf("结果是%d\n", ret);
    18.   ret = add1(&value, &value1);
    19.   printf("value是%d\n", value);
    20.   printf("结果是%d\n", ret);
    21.   return 0;
    22. }

  114. 负责把被调用函数的数据传递给调用函数的参数叫做输出参数。

  115. 有些参数既是输入参数又是输出参数。

  116. 只有指针变量可以当输出参数使用。

  117. void*类型的指针可以记录任何类型变量的地址，在使用的时候必须首先强制类型转换成固定类型指针然后再加*。

    1. /*
    2.  指针练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   int value = 3;
    7.   char ch = 'a';
    8.   float fvalue = 4.7;
    9.   void *p_value = NULL;
    10.   p_value = &value;
    11.   printf("value是%d\n", *(int *)p_value);
    12.   p_value = &ch;
    13.   printf("ch是%c\n", *(char *)p_value);
    14.   p_value = &fvalue;
    15.   printf("fvalue是%g\n", *(float *)p_value);
    16.   return 0;
    17. }

  118. break跳出循环体，return跳出函数，exit终止整个程序。

  119. 指针变量可以作为函数返回值使用，只能把全局变量的地址，静态局部变量的地址或者通过参数得到的地址当作返回值使用，普通局部变量的地址绝对不可以当返回值使用。

    1. /*
    2.  指针练习
    3. */
    4. #include <stdio.h>
    5. int *func() {
    6.   static int value;
    7.   printf("value是%d\n", value);
    8.   return &value;
    9. }
    10. int main() {
    11.   int *p_value = NULL;
    12.   p_value = func();
    13.   *p_value = 7;
    14.   func();
    15.   return 0;
    16. }

  120. 字符串是由内存中一组连续的字符变量构成的。C语言程序中使用第一个字符的地址表示整个字符串。’\0’是字符串的结尾字符，它的位置决定了一个字符串中有效字符变量的个数。这个字符在ASCII表中对应数字为0。

  121. 字面值是程序中表示字符串的一种写法，用双引号表示。字面值表示的字符串不可以被修改。多个相同内容的字面值在程序运行时都是同一个。多个连续的字符串字面值在编译时会被合并成一个。%s做占位符。

    1. /*
    2.  字符串练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   char *p_str = "abcdef";
    7.   char str[] = "abc"; //后面还有一个\0
    8.   char str1[3] = "abc";  //错误，后面没有\0
    9.   char str2[] = {'a', 'b', 'c'}; //错误，后面没有\0
    10.   char str3[] = {'a', 'b', 'c', 0};
    11.   //*p_str = 'x';    字符串字面值不可以修改
    12.   printf("%p\n", "abcdef");
    13.   printf("p_str是%p\n", p_str);
    14.   printf("%s\n", "abc""xyz");
    15.   printf("%s\n", str);
    16.   printf("字符变量个数是%d\n", sizeof(str) / sizeof(str[0]));
    17.   //str[0] = 'y';
    18.   //str[1] = 0;  //相当于\0
    19.   printf("%s\n", str);
    20.   printf("%s\n", str2);
    21.   return 0;
    22. }

  122. 字符数组也可以表示字符串，它存储在栈中。它可以被修改，可以使用多种方式进行初始化。

  123. fgets函数可以从键盘读取字符串，不会出现字符数组溢出问题。例如：fgets(buf,10,stdin)（输入字符不够自动后面加\n和回车）。

    1. /*
    2.  字符串练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   char buf[10] = {0};
    7.   printf("请输入一个字符串：");
    8.   //scanf("%s", buf);
    9.   fgets(buf, 10, stdin);
    10.   printf("%s\n", buf);
    11.   return 0;
    12. }

  124. strlen函数可以计算字符串中有效字符的个数。

  125. strcat函数可以把两个字符串合并，可能造成数组溢出。使用strncat函数可以避免溢出。[strcat(新字符串 旧字符串)]strcpy函数可以把一个字符串赋值成另一个字符串。使用strncpy函数可以避免溢出。strcmp函数可以比较两个字符串的大小关系（相等的话为0前面大的为1后者大为-1）。strncmp的函数比较两个字符串中前几个字符的大小。strlen(arr)计算字符串大小，需要包含string.h。

    1. /*
    2.  字符串函数练习
    3. */
    4. #include <stdio.h>
    5. #include <string.h>
    6. int main() {
    7.   char str[20] = "abc";
    8.   printf("长度是%d\n", strlen("abcdef"));
    9.   printf("合并后是%s\n", strcat(str, "xyz"));
    10.   printf("赋值后字符串是%s\n", strcpy(str, "uvw"));
    11.   printf("比较结果是%d\n", strcmp("abc", "abd"));
    12.   return 0;
    13. }
    1. /*
    2.  模拟登陆练习
    3. */
    4. #include <stdio.h>
    5. #include <string.h>
    6. int main() {
    7.   int loop = 0;
    8.   char buf[10];
    9.   for (loop = 0; loop < 3; loop++) {
    10.       printf("请输入用户名：");
    11.       fgets(buf, 10, stdin);
    12.       if (strcmp(buf, "admin\n")) {
    13.           continue;
    14.       }
    15.       printf("请输入密码：");
    16.       fgets(buf, 10, stdin);
    17.       if (!strcmp(buf, "123456\n")) {
    18.           break;
    19.       }
    20.   }
    21.   if (loop < 3) {
    22.       printf("登陆成功\n");
    23.   }
    24.   else {
    25.       printf("登陆失败\n");
    26.   }
    27.   return 0;
    28. }

  126. 预处理指令#define可以用于实现宏定义，宏可以用来当作数字的名称。

    1. /*
    2.  宏练习
    3. */
    4. #include <stdio.h>
    5. #define   PI            3.14f
    6. #define   CIRCLE(r)     2 * PI * r
    7. #define   AREA(r)       PI * r * r
    8. int main() {
    9.   int radius = 0;
    10.   printf("请输入半径：");
    11.   scanf("%d", &radius);
    12.   printf("圆的周长是%g\n", CIRCLE(radius));
    13.   printf("圆的面积是%g\n", AREA(radius));
    14.   return 0;
    15. }

  127. 可以在gcc命令行中使用-D选项定义宏。

  128. 宏可以带参数，宏的参数都既是输入参数又是输出参数。

    1. /*
    2.  宏练习
    3. */
    4. #include <stdio.h>
    5. #define     NEG(n)     n = 0 - n
    6. void neg(int value) {
    7.   value = 0 - value;
    8. }
    9. int main() {
    10.   int value = 4;
    11.   //neg(value);
    12.   NEG(value);
    13.   printf("value是%d\n", value);
    14.   return 0;
    15. }
    1. /*
    2.  宏练习
    3. */
    4. #include <stdio.h>
    5. #define    MAX(n,m)       n > m ? n : m
    6. int main() {
    7.   printf("MAX(4, 8)是%d\n", MAX(4, 8));
    8.   return 0;
    9. }

  129. 宏的所有参数在使用的时候要用小括号包起来，宏的计算结果要用小括号包起来，不要使用自增自减的计算结果作为宏的参数使用。

    1. /*
    2.  宏练习
    3. */
    4. #include <stdio.h>
    5. #define    SECPH          (60 * 60)
    6. #define    NEG(n)         0 - (n)
    7. #define    SQUARE(n)      ((n) * (n))
    8. int main() {
    9.   int value = 4;
    10.   printf("小时数是%d\n", 7200 / SECPH);
    11.   printf("NEG(3)是%d\n", NEG(3));
    12.   printf("NEG(3 + 8)是%d\n", NEG(3 + 8));
    13.   printf("SQUARE(4)是%d\n", SQUARE(4));
    14.   printf("SQUARE(++value)是%d\n", SQUARE(++value));
    15.   return 0;
    16. }

  130. 操作符可以把宏的某个参数变成字符串面值,例如：”abc”。

  131. 操作符可以把宏的某个参数代表的标示符和其它内容合并成有一个新的标示符。

    1. /*
    2.  宏练习
    3. */
    4. #include <stdio.h>
    5. #define    STR(n)        #n
    6. #define    PTR(n)        p_##n
    7. int main() {
    8.   int *PTR(value) = NULL;
    9.   printf("STR(3 + 6)是%s\n", STR(3 + 6));
    10.   return 0;
    11. }

  132. 编译器内部提供了一些预定义的宏，在编译的时候编译器把他们替换成正确的内容。

    1. /*
    2.  预定义宏练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   printf("行号是%d\n", __LINE__);
    7.   printf("文件名是%s\n", __FILE__);
    8.   printf("日期是%s\n", __DATE__);
    9.   printf("时间是%s\n", __TIME__);
    10.   printf("%sC标准\n", __STDC__ ? "符合" : "不符合");
    11.   return 0;
    12. }

  133. 使用如下预处理指令可以实现条件编译：#ifdef 宏名称 （#ifdef 宏名称）….

    else ………

    endif

    其中#ifdef和ifndef意思相反

    1. /*
    2.  条件编译练习
    3. */
    4. #include <stdio.h>
    5. //#define     ONE
    6. //#define      TWO
    7. int main() {
    8. //#ifdef ONE
    9. #ifndef TWO
    10.   printf("1\n");
    11. #else
    12.   printf("2\n");
    13. #endif
    14.   return 0;
    15. }

  134. 使用#if和#elif可以根据任何逻辑表达式实现条件编译，并且可以从更多语句组中进行选择。

    1. /*
    2.  条件编译练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6. #if    defined(ELITE)
    7.   printf("120%%\n");
    8. #elif  !defined(FACTORY)
    9.   printf("100%%\n");
    10. #else
    11.   printf("80%%\n");
    12. #endif
    13.   return 0;
    14. }

  135. 程序中不同的函数可以写在不同的.c源文件中。不同的源文件之间使用扩展名.h的头文件链接起来。

  136. 编写所有头文件的时候要使用条件编译进行控制，避免被多次编译。

    1. #ifndef   __ADD_H__
    2. #define   __ADD_H__
    3. void add(int, int);
    4. #endif   //__ADD_H__
    1. /*
    2.  多文件练习
    3. */
    4. #include <stdio.h>
    5. #include "01add1.h"
    6. #include "01sub.h"
    7. extern int result;
    8. int main() {
    9.   add(3, 7);
    10.   printf("计算结果是%d\n", result);
    11.   printf("计算结果是%d\n", sub(7, 3));
    12.   return 0;
    13. }
    1. #include "01add1.h"
    2. /*static*/ int result;
    3. void add(int value, int value1) {
    4.   result = value + value1;
    5. }

  137. 多文件程序编译有两种方法：

    (1).使用gcc命令对所有.c源文件统一编译。

    (2).使用gcc命令对每个单独的.c源文件进行编译，得到.o作为扩展名的目标文件。最后使用gcc命令把所有目标文件合并成可执行文件。

  138. .c源文件中如果要使用其他源文件声明的全局变量则需要如下方法声明一下：extern int 全局变量。

    sub.h

    1. #ifndef __SUB_H__
    2. #define __SUB_H__
    3. int sub(int, int);
    4. #endif  //__SUB_H__

    sub.c

    1. #include "01sub.h"
    2. int sub(int value, int value1) {
    3.   return value - value1;
    4. }

  139. make工具可以用来进行项目管理，他可以根据记录在Makefile中的要求完成整个编译过程。

    1. a.out : 01add.o 01add1.o 01sub.o
    2.   gcc 01add.o 01add1.o 01sub.o
    4. 01add.o : 01add.c
    5.   gcc -c 01add.c
    7. 01add1.o : 01add1.c
    8.   gcc -c 01add1.c
    10. 01sub.o : 01sub.c
    11.   gcc -c 01sub.c
    13. clean : 
    14.   rm *.o a.out

  140. 结构体可以用来把多个不同类型的变量合并成一个整体。结构体声明方法如下：

    struct 结构体名称{变量声明语句}；

    其中struct时表示结构体的关键字。在结构体声明中所有的变量声明语句并不产生新的变量。

  141. 结构体可以当成数据类型使用，并可以声明结构体变量，使用方法如下：

    struct结构体名称 结构体变量名称；

  142. typedef关键字可以用来给数据起别名，它和#define完全不同。

    1. /*
    2.  结构体练习
    3. */
    4. #include <stdio.h>
    5. /*struct student {
    6.   int age;
    7.   char gender;
    8.   float height;
    9. };
    10. typedef struct student stu;*/
    11. typedef struct student {
    12.   int age;
    13.   char gender;
    14.   float height;
    15. } stu;
    16. int main() {
    17.   /*struct student {
    18.       int age;
    19.       char gender;
    20.       float height;
    21.   };*/
    22.   struct student student;
    23.   stu student1 = {24, 'F', 1.60f};
    24.   printf("年龄是%d\n", student1.age);
    25.   printf("性别是%c\n", student1.gender);
    26.   printf("身高是%g\n", student1.height);
    27.   /*struct {
    28.       int age;
    29.       char gender;
    30.       float height;
    31.   } student;*/
    32.   return 0;
    33. }

  143. 结构体变量做参数的时候应该使用一个指针变量来替换，这样可以节约空间和时间。若果这个参数只是输入参数则指针声明前加上关键字const。

    1. /*
    2.  结构体练习
    3. */
    4. #include <stdio.h>
    5. typedef struct {
    6.   char band[20];
    7.   int price;
    8.   int quantity;
    9. } phone;
    10. void read(phone *p_phone) {
    11.   printf("请输入品牌信息：");
    12.   fgets(p_phone->band, 20, stdin);
    13.   printf("请输入价格和数量信息：");
    14.   scanf("%d %d", &(p_phone->price), &(p_phone->quantity));
    15.   scanf("%*[^\n]");
    16.   scanf("%*c");
    17. }
    18. void print(const phone *p_phone) {
    19.   printf("电话信息是%s, %d和%d\n", p_phone->band, p_phone->price, p_phone->quantity);
    20. }
    21. int main() {
    22.   phone phones[3];
    23.   int loop = 0;
    24.   for (loop = 0; loop <= 2; loop++) {
    25.       read(phones + loop);
    26.   }
    27.   for (loop = 0; loop <= 2; loop++) {
    28.       print(phones + loop);
    29.   }
    30.   return 0;
    31. }

  144. 变量的地址必须是变量大小的整数倍，这叫数据对齐。double变量的地址只需要是4的整数倍就可以了。数据对齐会导致结构体中不同变量之间有空隙，结构体变量大小并不是其中所有子变量大小之和。

  145. 整个结构体变量的大小必须是其中最大变量大小的整数倍，double变量大小按4个计算。为了保证这一点，有时需要在结构体变量后面加入一些浪费的字节，这叫做补齐。

    1. /*  
    2.   结构体练习
    3. */
    4. #include <stdio.h>
    5. /*typedef struct {
    6.   char ch;
    7.   char ch1;
    8.   int value;
    9. } stru1;*/
    10. typedef struct {
    11.   char ch;
    12.   short value;
    13.   char ch1;
    14. } stru1;
    15. int main() {
    16.   printf("结构体大小是%d\n", sizeof(stru1));
    17.   return 0;
    18. }

  146. 声明结构体的时候可以使用位域限制某个子变量所占的二进制位数，所有整数类型变量都可以使用位域。使用位域声明的子变量没有地址。

    1. /*
    2.  结构体位域练习
    3. */
    4. #include <stdio.h>
    5. typedef struct {
    6.   int gender:1;
    7.   int age:6;
    8. } stru1;
    9. int main() {
    10.   stru1 s;
    11.   //&(s.age);
    12.   printf("大小是%d\n", sizeof(stru1));
    13.   return 0;
    14. }

  147. 通过使用联合可以用不同方式操作内存中同一段区域。计算机中存储数据的方式有两种，把低位数据存储在低地址字节的方式叫做小端存储方式，相反就叫大端存储方式，我们计算机采用的是小端存储方式。

    1. /*
    2.  联合练习
    3. */
    4. #include <stdio.h>
    5. typedef union {
    6.   char ch[4];
    7.   int value; // char和int所占字节位置重叠
    8. } un;
    9. int main() {
    10.   un u;
    11.   u.value = 0x12345678;
    12.   if (0x78 == u.ch[0]) {
    13.       printf("小端\n"); // * * * *  78 56 34 12
    14.   }
    15.   else {
    16.       printf("大端\n");
    17.   }
    18.   printf("联合的大小是%d\n", sizeof(un));
    19.   return 0;
    20. }

  148. 使用枚举类型可以把一组名称转换成整数，从数字0开始。例如：enum{SPR,SUN,AUT,WIN}season;

    1. /*
    2.  枚举练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   typedef enum {SPR, SUM = 6, AUT, WIN} season;
    7.   typedef enum {MALE, FEMALE} gender;
    8.   printf("SPR是%d\n", SPR);
    9.   season s = AUT;
    10.   printf("season是%d\n", s);
    11.   return 0;
    12. }

  149. 联合体union声明与struct格式相同，所声明的类型变量所占字节位置重叠。

    1. /*
    2.  malloc练习
    3. */
    4. #include <stdio.h>
    5. #include <stdlib.h>
    6. int main() {
    7.   //int value = 0;
    8.   int *p_value = (int *)malloc(1 * sizeof(int));
    9.   if (p_value) {
    10.       printf("value是%d\n", *p_value);
    11.       free(p_value);
    12.       p_value = NULL;
    13.   }
    14.   return 0;
    15. }

  150. 可以使用C语言提供的函数对堆中的变量进行管理，为了使用这些函数需要包含头文件stdlib.h。malloc函数可以从堆中分配指定个数的连续字节并把首字节地址返回。如果失败则返回NULL。free函数可以把堆中的变量释放掉，需要首字节地址作为参数。例如：free(p_value); p_value = NULL;

    1. /*
    2.  malloc练习
    3. */
    4. #include <stdio.h>
    5. #include <stdlib.h>
    6. int main() {
    7.   int loop = 0;
    8.   int *p_value = (int *)malloc(4 * sizeof(int));
    9.   if (p_value) {
    10.       for (loop = 0; loop <= 3; loop++) {
    11.           printf("请输入一个整数：");
    12.           scanf("%d", p_value + loop);
    13.       }
    14.       for (loop = 3; loop >= 0; loop--) {
    15.           printf("%d ", *(p_value + loop));
    16.       }
    17.       printf("\n");
    18.       free(p_value);
    19.       p_value = NULL;
    20.   }
    21.   return 0;
    22. }

  151. calloc函数也可以从堆中分配变量，并保证把变量都清零。realloc函数可以调整一段已经分配好的内存空间大小。如果失败返回NULL。特殊情况下操作效果类型似于malloc或free。

    1. /*
    2.  堆练习
    3. */
    4. #include <stdio.h>
    5. #include <stdlib.h>
    6. int main() {
    7.   int *p_value = (int*)calloc(4, sizeof(int));
    8.   int *p_value1 = NULL;
    9.   if (p_value) {
    10.       p_value1 = realloc(p_value, 6 * sizeof(int));
    11.       if (p_value1) {
    12.           p_value = p_value1;
    13.       }
    14.       free(p_value);
    15.       p_value = NULL;
    16.   }
    17.   return 0;
    18. }

  152. const指针有两种声明方法：

    const int *p_value;表示指针的整数变量不可以被修改。

    int *const p_value;表示指针变量本身不可以被修改。

    1. /*
    2.  const指针练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   int value = 3;
    7.   const int *p_value = &value;
    8.   int * const p_value1 = &value;
    9.   //*p_value = 3;    错误
    10.   value = 7;
    11.   *p_value1 = 5;
    12.   //p_value1 = NULL;   错误
    13.   p_value = NULL;
    14.   return 0;
    15. }

  153. 二级指针变量用来记录一级指针变量的地址，声明方法如下：

    int **pp_value;

    二级指针变量可以用来表示它自己和对应的一级指针变量以及整数变量，使用方法如下：

    pp_value 表示二级指针本身。

    *pp_value 表示对应的一级指针

    **pp_value 表示对应的整数变量

    1. /*
    2.  函数指针练习
    3. */
    4. #include <stdio.h>
    5. int add(int value, int value1) {
    6.   return value + value1;
    7. }
    8. int sub(int value, int value1) {
    9.   return value - value1;
    10. }
    11. int main() {
    12.   int (*p_func)(int, int) = NULL;
    13.   typedef int (*t_func)(int, int);
    14.   t_func p_func1 = NULL;
    15.   printf("add是%p\n", add);
    16.   p_func = add;
    17.   printf("计算结果是%d\n", p_func(3, 6));
    18.   p_func = sub;
    19.   printf("计算结果是%d\n", p_func(6, 3));
    20.   p_func1 = add;
    21.   printf("计算结果是%d\n", p_func1(2, 5));
    22.   p_func1 = sub;
    23.   printf("计算结果是%d\n", p_func1(10, 8));
    24.   return 0;
    25. }

  154. 二级指针做函数的输出参数可以让函数把内部的地址数据报告给调用函数。

    img

    1. /*
    2.  二级指针练习
    3. */
    4. #include <stdio.h>
    5. void func1(int **pp_value) {
    6.   *pp_value = (int *)0x12345678;
    7. }
    8. void func(int *p_value) {
    9.   *p_value = 3;
    10. }
    11. int main() {
    12.   int value = 0;
    13.   int *p_value = NULL;
    14.   func(&value);
    15.   printf("value是%d\n", value);
    16.   func1(&p_value);
    17.   printf("p_value是%p\n", p_value);
    18.   return 0;
    19. }
    1. /*
    2.   二级指针练习
    3. */
    4. #include <stdio.h>
    5. #include <stdlib.h>
    6. void split(char *p_str, char **pp_str) {
    7.   int pos = 0;
    8.   char *p_result = NULL;
    9.   while ((',' != *(p_str + pos)) && (0 != *(p_str + pos))) {
    10.       pos++;
    11.   }
    12.   pos++;
    13.   p_result = (char*)malloc(pos * sizeof(char));
    14.   if (p_result) {
    15.       pos = 0;
    16.       while ((',' != *(p_str + pos)) && (0 != *(p_str + pos))) {
    17.           *(p_result + pos) = *(p_str + pos);
    18.           pos++;
    19.       }
    20.       *(p_result + pos) = 0;
    21.   }
    22.   *pp_str = p_result;
    23. }
    24. int main() {
    25.   char *p_str = NULL;
    26.   split("abc,def,xyz", &p_str);
    27.   printf("%s\n", p_str);
    28.   free(p_str);
    29.   p_str = NULL;
    30.   return 0;
    31. }

  155. 函数名称可以当成地址数据使用，函数指针变量可以用来记录函数的地址并可以用来调用函数。函数指针的声明是从函数声明变化得到的。

    1. /*
    2.  函数指针练习
    3. */
    4. #include <stdio.h>
    5. int add(int value, int value1) {
    6.   return value + value1;
    7. }
    9. int sub(int value, int value1) {
    10.   return value - value1;
    11. }
    13. int main() {
    14.   int (*p_func)(int, int) = NULL;
    15.   int opr = 0;
    16.   printf("请输入一个整数：");
    17.   scanf("%d", &opr);
    18.   if (opr) {
    19.       p_func = sub;
    20.   }
    21.   else {
    22.       p_func = add;
    23.   }
    24.   printf("计算结果是%d\n", p_func(2, 3));
    25.   return 0;
    26. }

  156. qsort函数可以完成一个数组中所有数组的按顺序排列问题。需要包含stdlib.h头文件。使用一个用户编写的函数来决定某两个数组的前后顺序。

    1. /*
    2.  排序练习
    3. */
    4. #include <stdio.h>
    5. #include <stdlib.h>
    6. int compare(const void *p_value, const void *p_value1) {
    7.   const int *p_int = (const int*)p_value;
    8.   const int *p_int1 = (const int*)p_value1;
    9.   if (*p_int < *p_int1) {
    10.       return -1;
    11.   }
    12.   else if (*p_int > *p_int1) {
    13.       return 1;
    14.   }
    15.   else {
    16.       return 0;
    17.   }
    18. }
    19. int compare1(const void *p_value, const void *p_value1) {
    20.   return 0 - compare(p_value, p_value1);
    21. }
    22. int main() {
    23.   int values[] = {8, 4, 2, 6};
    24.   int loop = 0;
    25.   qsort(values, 4, sizeof(int), compare1);
    26.   for (loop = 0; loop <= 3; loop++) {
    27.       printf("%d ", values[loop]);
    28.   }
    29.   printf("\n");
    30.   return 0;
    31. }

  157. 由多个指针构成的数组叫做指针数组，声明如下：char *strs[5]；指针数组和二级指针可以互相通用。

    1. /*
    2.  指针数组练习
    3. */
    4. #include <stdio.h>
    5. #include <stdlib.h>
    6. #include <string.h>
    7. int compare(const void *p_value, const void *p_value1) {
    8.   char ** pp_str = (char **)p_value;
    9.   char ** pp_str1 = (char **)p_value1;
    10.   return strcmp(*pp_str, *pp_str1);
    11. }
    12. int main() {
    13.   char * strs[5] = {"China",    //指针数组
    14.                     "Russia",
    15.                     "England",
    16.                     "France",
    17.                     "America"
    18.                     };
    19.   int loop = 0;
    20.   qsort(strs, 5, sizeof(char *), compare);
    21.   for (loop = 0; loop <= 4; loop++) {
    22.       printf("%s\n", strs[loop]);
    23.   }
    24.   return 0;
    25. }

  158. 数组名称也可以取地址，得到的地址数据和二维数组名称所代表的地址数据类似。对他们做加1操作时增加的是整个一维数组的大小。这样的地址数据可以赋值给数组指针变量，这种指针声明方法如下：

    int (*p_value)[5];

    1. /*
    2.  数组指针练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   int value[5] = {0};
    7.   int values[3][4] = {0};
    8.   int *p_value = value;
    9.   int (*p_value1)[5] = &value;
    10.   printf("value是%p\n", value);
    11.   printf("&value是%p\n", &value);
    12.   printf("value + 1是%p\n", value + 1);
    13.   printf("&value + 1是%p\n", &value + 1);
    14.   printf("values是%p,values + 1是%p\n", values, values + 1);
    15.   printf("p_value1是%p,p_value1 + 1是%p\n", p_value1, p_value1 + 1);
    16.   return 0;
    17. }

  159. FILE结构体用来记录文件相关的信息。

    FILE结构体类型的指针变量叫做文件指针。

    fopen函数可以打开一个文件并制作对应的FILE结构体变量，把结构体变量的地址作为返回值使用。如果执行失败则返回NULL。

    使用fopen函数时需要指定文件的操作方式。操作方式由三部分构成，分别如下：

    第一部分有三个可选的字符‘r’，‘w’，‘a’。这部分必须指定并且只能指定一个字符。

    ‘r’ 对文件进行读操作；

    ‘w’ 对文件进行写操作。如果文件不存在则创建新文件否则把原文件内容清除。

    ‘a’ 对文件进行写操作。如果文件已存在则会把新内容追加在文件末尾。

    第二部分有一个可选字符‘+’，这部分可有可无。如果使用了这部分则表示对文件进行读写操作。

    第三部分有一个可选字符‘b’，这部分可有可无。如果使用这部分则表示要对文件进行二进制操作。fclose函数用于关闭一个文件，当程序不再使用某个文件的时候一定要使用这个函数关闭它。

    1. /*
    2.  文件练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   FILE *p_file = NULL;
    7.   p_file = fopen("a.txt", "w");
    8.   if (p_file) {
    9.       //文件操作语句
    10.       fclose(p_file);
    11.       p_file = NULL;
    12.   }
    13.   return 0;
    14. }

  160. fputc函数可以把一个字符写入文件中，如果失败返回EOF。

    1. /*
    2.  文件练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   FILE *p_file = NULL;
    7.   char str[] = "abcdef";
    8.   int loop = 0;
    9.   p_file = fopen("a.txt", "w");
    10.   if (p_file) {
    11.       //文件操作语句
    12.       while (str[loop]) {
    13.           if (EOF == fputc(str[loop], p_file)) {
    14.               break;
    15.           }
    16.           loop++;
    17.       }
    18.       fclose(p_file);
    19.       p_file = NULL;
    20.   }
    21.   return 0;
    22. }
    1. /*
    2.  文件练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   FILE *p_file = NULL;
    7.   p_file = fopen("a.txt", "r");
    8.   if (p_file) {
    9.       //文件操作语句
    10.       char ch = 0;
    11.       do {
    12.           ch = fgetc(p_file);
    13.           if (EOF != ch) {
    14.               printf("%c", ch);
    15.           }
    16.       } while (EOF != ch);
    17.       printf("\n");
    18.       fclose(p_file);
    19.       p_file = NULL;
    20.   }
    21.   return 0;
    22. }

  161. fgetc函数可以从文件中读取一个字符串并返回，如果超过文件尾部则返回EOF。

    1. /*
    2.  文件练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   FILE *p_file = NULL, *p_file1 = NULL;
    7.   p_file = fopen("a.txt", "r");
    8.   if (p_file) {
    9.       p_file1 = fopen("b.txt", "w");
    10.       if (p_file1) {
    11.           char ch = 0;
    12.           do {
    13.               ch = fgetc(p_file);
    14.               if (EOF != ch) {
    15.                   if (EOF == fputc(ch, p_file1)) {
    16.                       break;
    17.                   }
    18.               }
    19.           } while (EOF != ch);
    20.           fclose(p_file1);
    21.           p_file1 = NULL;
    22.       }
    23.       fclose(p_file);
    24.       p_file = NULL;
    25.   }
    26.   return 0;
    27. }

  162. fwrite函数可以一次性把数组中的多个变量以二进制方式写入到文件中，返回值表示写入的变量个数。

    1. /*
    2.  文件练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   FILE *p_file = NULL;
    7.   int values[] = {1, 2, 3, 4, 5};
    8.   p_file = fopen("a.bin", "wb");
    9.   if (p_file) {
    10.       //文件操作语句
    11.       int num = fwrite(values, sizeof(int), 5, p_file); //以二进制方式一次将多个数据写入，返回的为整数变量的个数
    12.       printf("共写入%d个整数变量\n", num);
    13.       fclose(p_file);
    14.       p_file = NULL;
    15.   }
    16.   return 0;
    17. }

  163. fread函数可以一次性以二进制方式从文件中读取多个变量的数值并记录到数组中，返回值表示读入的变量个数。

    1. /*
    2.  文件练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   FILE *p_file = NULL;
    7.   int values[5] = {0}, loop = 0;
    8.   p_file = fopen("a.bin", "rb");
    9.   if (p_file) {
    10.       //文件操作语句
    11.       int num = fread(values, sizeof(int), 5, p_file);
    12.       printf("共读出%d个整数变量\n", num);
    13.       for (loop = 0; loop <= 4; loop++) {
    14.           printf("%d ", values[loop]);
    15.       }
    16.       printf("\n");
    17.       fclose(p_file);
    18.       p_file = NULL;
    19.   }
    20.   return 0;
    21. }

  164. FILE结构体中使用位置指针记录下次对文件进行读写操作的位置，每次对文件进行过读写操作后位置指针都会移动。

  165. rewind函数可以把位置指针移动到文件开头。

  166. fseek函数可以把位置指针移动到任何地方。

    SEEK_SET 0 代表文件开头

    SEEK_CUR 1 位置指针当前位置

    SEEK_END 2 代表文件结尾

    1. /*
    2.  文件练习
    3. */
    4. #include <stdio.h>
    5. int main() {
    6.   FILE *p_file = NULL;
    7.   p_file = fopen("a.txt", "r");
    8.   if (p_file) {
    9.       //文件操作语句
    10.       fseek(p_file, 2, SEEK_SET);//将位置指针移动到距离开头第二个位置
    11.       printf("%c ", fgetc(p_file));
    12.       //rewind(p_file); //将位置指针移动到开头
    13.       fseek(p_file, 1, SEEK_CUR);//将位置指针移动到当前位置指针后方一个位置
    14.       printf("%c ", fgetc(p_file));
    15.       //rewind(p_file);//将位置指针移动到末尾前方3个位置
    16.       fseek(p_file, -3, SEEK_END);
    17.       printf("%c ", fgetc(p_file));
    18.       printf("\n");
    19.       fclose(p_file);
    20.       p_file = NULL;
    21.   }
    22.   return 0;
    23. }

  167. fputs函数可以把一个字符串写入到文件中。fgets函数可以从文件中读取一个字符串。

  168. fprintf函数可以把数据以指定的格式写入到任何文件中。fscanf函数可以从任何文件中以指定的格式读入数据到变量中。

  169. 不确定字符输入进行比较大小。

    1. /*
    2.  变长参数练习
    3. */
    4. #include <stdio.h>
    5. #include <stdarg.h>
    6. int max(int cnt, ...) {
    7.   int ret = 0, loop = 0;
    8.   va_list v;
    9.   va_start(v, cnt);
    10.   for (loop = 0; loop < cnt; loop++) {
    11.       int value = va_arg(v, int);
    12.       if (value > ret) {
    13.           ret = value;
    14.       }
    15.   }
    16.   va_end(v);
    17.   return ret;
    18. }
    19. int main() {
    20.   printf("max(2, 9, 6)是%d\n", max(2, 9, 6));
    21.   printf("max(3, 19, 25, 2)是%d\n", max(3, 19, 25, 2));
    22.   return 0;
    23. }

  170. atoi/atof 字符串中提取数据。

    1. /*
    2.  函数练习
    3. */
    4. #include <stdio.h>
    5. #include <stdlib.h>
    6. int main() {
    7.   char str[20] = {0};
    8.   char ch = 0;
    9.   float f_value = 0.0f;
    10.   int value = atoi("234");
    11.   double d_value = atof("23.4");
    12.   printf("value是%d\n", value);
    13.   printf("d_value是%lg\n", d_value);
    14.   sscanf("25.8 a", "%g %c", &f_value, &ch);
    15.   printf("%c %g\n", ch, f_value);
    16.   sprintf(str, "%c %g", ch, f_value);
    17.   printf("%s\n", str);
    18.   return 0;
    19. }

数据结构

  1. 链式存储结构

    1. /*
    2.    链式存储结构演示
    3. */
    4. #include <stdio.h>
    5. typedef struct node {
    6.     int num;
    7.     struct node *p_next;
    8. } node;
    9. int main() {
    10.     node node1 = {1}, node3 = {3}, node5 = {5};
    11.     node head = {}, tail = {}; //虚构的头节点和尾节点
    12.     node node7 = {7}, node4 = {4};
    13.     node *p_node = NULL;
    14.     head.p_next = &node1;
    15.     node1.p_next = &node3;
    16.     node3.p_next = &node5;
    17.     node5.p_next = &tail;
    18.     //按顺序插入
    19.     for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    20.         node *p_lnext = p_node->p_next;
    21.         if (node4.num < p_lnext->num || 
    22.                 p_lnext == &tail) {
    23.             p_node->p_next = &node4;
    24.             node4.p_next = p_lnext;
    25.             break;
    26.         }
    27.     }
    28.     //在最前面插入新节点
    29.     /*for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    30.         node *p_lnext = p_node->p_next;
    31.         if (p_node == &head) {
    32.             p_node->p_next = &node7;
    33.             node7.p_next = p_lnext;
    34.             break;
    35.         }
    36.     }*/
    37.     /*node7.p_next = head.p_next;
    38.     head.p_next = &node7;*/
    39.     //在最后插入新的有效节点
    40.     /*for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    41.         node *p_lnext = p_node->p_next;
    42.         if (p_lnext == &tail) {
    43.             p_node->p_next = &node7;
    44.             node7.p_next = p_lnext;
    45.             break;
    46.         }
    47.     }*/
    48.     //删除节点3
    49.     for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    50.         node *p_lnext = p_node->p_next;
    51.         if (p_lnext != &tail && p_lnext->num == 3) {
    52.             node *p_lnext2 = p_lnext->p_next;
    53.             p_node->p_next = p_lnext2;
    54.             break;
    55.         }
    56.     }
    57.     //删除最后一个有效节点
    58.     for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    59.         node *p_lnext = p_node->p_next;
    60.         if (p_lnext->p_next == &tail) {
    61.             node *p_lnext2 = p_lnext->p_next;
    62.             p_node->p_next = p_lnext2;
    63.             break;
    64.         }
    65.     }
    66.     //删除第一个有效节点
    67.     /*for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    68.         node *p_lnext = p_node->p_next;
    69.         if (p_node == &head && p_lnext != &tail) {
    70.             node *p_lnext2 = p_lnext->p_next;
    71.             p_node->p_next = p_lnext2;
    72.             break;
    73.         }
    74.     }*/
    75.     if (head.p_next != &tail) {
    76.         head.p_next = head.p_next->p_next;
    77.     }
    78.     //依次打印有效节点内容
    79.     for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    80.         node *p_lnext = p_node->p_next;
    81.         if (p_lnext != &tail) {
    82.             printf("%d ", p_lnext->num);
    83.         }
    84.     }
    85.     printf("\n");
    86.     return 0;
    87. }

  2. 动态分配节点链式存储结构

    1. /*
    2.    动态分配节点链式存储结构演示
    3. */
    4. #include <stdio.h>
    5. #include <stdlib.h>
    6. typedef struct node {
    7.     int num;
    8.     struct node *p_next;
    9. } node;
    10. int main() {
    11.     int arr[] = {6, 3, 5}, num = 0;
    12.     node head = {}, tail = {}, *p_node = NULL;
    13.     head.p_next = &tail;
    14.     for (num = 0;num <= 2;num++) {
    15.         //按顺序插入数字
    16.         for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    17.             node *p_lnext = p_node->p_next;
    18.             if (p_lnext == &tail || p_lnext->num > arr[num]) {
    19.                 node *p_tmp = (node *)malloc(sizeof(node));
    20.                 if (!p_tmp) {
    21.                     break;
    22.                 }
    23.                 p_tmp->num = arr[num];
    24.                 p_node->p_next = p_tmp;
    25.                 p_tmp->p_next = p_lnext;
    26.                 break;
    27.             }
    28.         }
    29.     }
    30.     //打印所有有效数字
    31.     for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    32.         node *p_lnext = p_node->p_next;
    33.         if (p_lnext != &tail) {
    34.             printf("%d ", p_lnext->num);
    35.         }
    36.     }
    37.     printf("\n");
    38.     //释放所有有效节点
    39.     while (head.p_next != &tail) {
    40.         node *p_tmp = head.p_next;
    41.         head.p_next = head.p_next->p_next;
    42.         free(p_tmp);
    43.         p_tmp = NULL;
    44.     }
    45.     return 0;
    46. }

  3. 链式存储结构（堆内存）实现桟（先入后出）

    linkstack.h

    1. #ifndef   __LINKSTACK_H__
    2. #define   __LINKSTACK_H__
    3. void init();
    4. void deinit();
    5. int full();
    6. int empty();
    7. void push(int);
    8. int pop();
    9. int top();
    10. int size();
    11. #endif   //__LINKSTACK_H__

    linkstack.h.c

    1. /*
    2.    链式存储结构实现桟的演示
    3.    */
    4. #include <stdlib.h>
    5. #include "linkstack.h"
    6. typedef struct node {
    7.     int num;
    8.     struct node *p_next;
    9. } node;
    11. static node head, tail;
    13. //初始化
    14. void init() {
    15.     head.p_next = &tail;
    16. }
    18. //清理桟
    19. void deinit() {
    20.     while (head.p_next != &tail) {
    21.         node *p_tmp = head.p_next;
    22.         head.p_next = head.p_next->p_next;
    23.         free(p_tmp);
    24.         p_tmp = NULL;
    25.     }
    26. }
    28. //判断桟是否满
    29. int full() {
    30.     return 0;
    31. }
    33. //判断桟是否空
    34. int empty() {
    35.     return head.p_next == &tail;
    36. }
    38. //入栈
    39. void push(int num) {
    40.     node *p_node = (node*)malloc(sizeof(node));
    41.     if (!p_node) {
    42.         return ;
    43.     }
    44.     p_node->num = num;
    45.     p_node->p_next = head.p_next;
    46.     head.p_next = p_node;
    47. }
    49. //出栈
    50. int pop() {
    51.     int ret = 0;
    52.     if (head.p_next != &tail) {
    53.         node *p_tmp = head.p_next;
    54.         ret = head.p_next->num;
    55.         head.p_next = head.p_next->p_next;
    56.         free(p_tmp);
    57.         p_tmp = NULL;
    58.     }
    59.     return ret;
    60. }
    62. //取栈顶数据
    63. int top() {
    64.     return head.p_next == &tail ? 0 : head.p_next->num;
    65. }
    67. //获得有效数据个数
    68. int size() {
    69.     node *p_node = NULL;
    70.     int cnt = 0;
    71.     for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    72.         node *p_lnext = p_node->p_next;
    73.         if (p_lnext != &tail) {
    74.             cnt++;
    75.         }
    76.     }
    77.     return cnt;
    78. }

  4. 动态分配节点链式存储结构

    link.h

    1. #ifndef   __LINK_H__
    2. #define   __LINK_H__
    3. void init();
    4. void deinit();
    5. int full();
    6. int empty();
    7. void push(int);
    8. int pop();
    9. int top();
    10. int size();
    11. #endif   //__LINK_H__

    link.c

    1. /*
    2.    动态分配节点链式存储结构演示
    3.    */
    4. #include <stdio.h>
    5. #include <stdlib.h>
    6. typedef struct node {
    7.     int num;
    8.     struct node *p_next;
    9. } node;
    10. int main() {
    11.     int arr[] = {6, 3, 5}, num = 0;
    12.     node head = {}, tail = {}, *p_node = NULL;
    13.     head.p_next = &tail;
    14.     for (num = 0;num <= 2;num++) {
    15.         //按顺序插入数字
    16.         for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    17.             node *p_lnext = p_node->p_next;
    18.             if (p_lnext == &tail || p_lnext->num > arr[num]) {
    19.                 node *p_tmp = (node *)malloc(sizeof(node));
    20.                 if (!p_tmp) {
    21.                     break;
    22.                 }
    23.                 p_tmp->num = arr[num];
    24.                 p_node->p_next = p_tmp;
    25.                 p_tmp->p_next = p_lnext;
    26.                 break;
    27.             }
    28.         }
    29.     }
    30.     //打印所有有效数字
    31.     for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    32.         node *p_lnext = p_node->p_next;
    33.         if (p_lnext != &tail) {
    34.             printf("%d ", p_lnext->num);
    35.         }
    36.     }
    37.     printf("\n");
    38.     //释放所有有效节点
    39.     while (head.p_next != &tail) {
    40.         node *p_tmp = head.p_next;
    41.         head.p_next = head.p_next->p_next;
    42.         free(p_tmp);
    43.         p_tmp = NULL;
    44.     }
    45.     return 0;
    46. }

  5. 链式存储结构（堆内存）实现队列（先入先出）

    linkqueue.h

    1. #ifndef   __LINKQUEUE_H__
    2. #define   __LINKQUEUE_H__
    3. void init();
    4. void deinit();
    5. int full();
    6. int empty();
    7. void push(int);
    8. int pop();
    9. int top();
    10. int size();
    11. #endif   //__LINKQUEUE_H__

    linkqueue.c

    1. /*
    2.    链式存储结构实现队列的练习
    3.    */
    4. #include <stdlib.h>
    5. #include "02queue.h"
    6. typedef struct node {
    7.     int num;
    8.     struct node *p_next;
    9. } node;
    11. static node head, tail;
    13. //初始化
    14. void init() {
    15.     head.p_next = &tail;
    16. }
    18. //清理
    19. void deinit() {
    20.     while (head.p_next != &tail) {
    21.         node *p_node = head.p_next;
    22.         head.p_next = head.p_next->p_next;
    23.         free(p_node);
    24.         p_node = NULL;
    25.     }
    26. }
    28. //判断队列是不是满的
    29. int full() {
    30.     return 0;
    31. }
    33. //判断队列是不是空的
    34. int empty() {
    35.     return head.p_next == &tail;
    36. }
    38. //放置数据
    39. void push(int num) {
    40.     node *p_node = (node*)malloc(sizeof(node));
    41.     if (!p_node) {
    42.         return ;
    43.     }
    44.     p_node->num = num;
    45.     p_node->p_next = head.p_next;
    46.     head.p_next = p_node;
    47. }
    49. //取数据
    50. int pop() {
    51.     int ret = 0;
    52.     node *p_node = NULL;
    53.     for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    54.         node *p_lnext = p_node->p_next;
    55.         if (p_lnext->p_next == &tail) {
    56.             ret = p_lnext->num;
    57.             p_node->p_next = &tail;
    58.             free(p_lnext);
    59.             p_lnext = NULL;
    60.             break;
    61.         }
    62.     }
    63.     return ret;
    64. }
    66. //取第一个数据
    67. int front() {
    68.     int ret = 0;
    69.     node *p_node = NULL;
    70.     for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    71.         node *p_lnext = p_node->p_next;
    72.         if (p_lnext->p_next == &tail) {
    73.             ret = p_lnext->num;
    74.             break;
    75.         }
    76.     }
    77.     return ret;
    78. }
    80. //获得有效数据个数
    81. int size() {
    82.     int cnt = 0;
    83.     node *p_node = NULL;
    84.     for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    85.         node *p_lnext = p_node->p_next;
    86.         if (p_lnext != &tail) {
    87.             cnt++;
    88.         }
    89.     }
    90.     return cnt;
    91. }

  6. 顺序存储结构（数组）实现队列（先入先出）

    queue.h

    1. #ifndef   __QUEUE_H__
    2. #define   __QUEUE_H__
    3. void init();
    4. void deinit();
    5. int full();
    6. int empty();
    7. void push(int);
    8. int pop();
    9. int top();
    10. int size();
    11. #endif   //__QUEUE_H__

    queue.c

    1. /*
    2.    顺序存储结构实现队列演示
    3.    */
    4. #include "queue.h"
    5. #define     SIZE         10
    6. static int arr[SIZE];
    7. static int head;
    8. static int tail;
    10. void init() {
    11.     head = 0;
    12.     tail = 0;
    13. }
    15. void deinit() {
    16.     head = 0;
    17.     tail = 0;
    18. }
    20. int empty() {
    21.     return head == tail;
    22. }
    24. int full() {
    25.     return tail == SIZE;
    26. }
    28. void push(int num) {
    29.      arr[tail] = num;
    30.      tail++;
    31. }
    33. int pop() {
    34.     head++;
    35.     return arr[head - 1];
    36. }
    38. int front() {
    39.     return arr[head];
    40. }
    42. int size() {
    43.     return tail - head;
    44. }

  7. 双向链表

    list.h

    1. #ifndef   __LIST_H__
    2. #define   __LIST_H__
    3. void init();
    4. void deinit();
    5. void remove_head();
    6. void remove_tail();
    7. void list_remove(int);
    8. int first();
    9. int last();
    10. void add_head(int);
    11. void append(int);
    12. int size();
    13. int next();
    14. int pre();
    15. #endif    //__LIST_H__

    list.c

    1. /*
    2.    链表演示
    3.    */
    4. #include <stdlib.h>
    5. #include "list.h"
    6. typedef struct node {
    7.     int num;
    8.     struct node *p_pre;   //向前的指针
    9.     struct node *p_next;  //向后的指针
    10. } node;
    12. static node head, tail;
    13. static node *p_curr;   //当前指针
    15. //初始化
    16. void init() {
    17.     head.p_next = &tail;
    18.     tail.p_pre = &head;
    19. }
    21. //清理
    22. void deinit() {
    23.     while (head.p_next != &tail) {
    24.         node *p_node = head.p_next;
    25.         head.p_next = head.p_next->p_next;
    26.         p_node->p_next->p_pre = &head;
    27.         free(p_node);
    28.         p_node = NULL;
    29.     }
    30.     p_curr = NULL;
    31. }
    33. //删除头节点
    34. void remove_head() {
    35.     //调整当前指针位置，避免出现野指针
    36.     if (p_curr == head.p_next) {
    37.         p_curr = p_curr->p_next;
    38.         if (p_curr == &tail) {
    39.             p_curr = NULL;
    40.         }
    41.     }
    42.     if (head.p_next != &tail) {
    43.         node *p_node = head.p_next;
    44.         head.p_next = head.p_next->p_next;
    45.         p_node->p_next->p_pre = &head;
    46.         free(p_node);
    47.         p_node = NULL;
    48.     }
    49. }
    51. //删除最后一个有效节点
    52. void remove_tail() {
    53.     if (p_curr == tail.p_pre) {
    54.         p_curr = p_curr->p_pre;
    55.         if (p_curr == &head) {
    56.             p_curr = NULL;
    57.         }
    58.     }
    59.     /*node *p_node = NULL;
    60.     for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    61.         node *p_lnext = p_node->p_next;
    62.         if (p_lnext->p_next == &tail) {
    63.             p_node->p_next = &tail;
    64.             tail.p_pre = p_node;
    65.             free(p_lnext);
    66.             p_lnext = NULL;
    67.             break;
    68.         }
    69.     }*/
    70.     if (tail.p_pre != &head) {
    71.         node *p_node = tail.p_pre;
    72.         /*p_node->p_pre->p_next = &tail;
    73.         tail.p_pre = p_node->p_pre;*/
    74.         node *p_pre2 = p_node->p_pre;
    75.         p_pre2->p_next = &tail;
    76.         tail.p_pre = p_pre2;
    77.         free(p_node);
    78.         p_node = NULL;
    79.     }
    80. }
    82. //删除指定数字所在的节点
    83. void list_remove(int num) {
    84.     node *p_node = NULL;
    85.     /*for (p_node = &head;p_node != &tail;p_node = p_node->p_next) {
    86.         node *p_lnext = p_node->p_next;
    87.         if (p_lnext != &tail && p_lnext->num == num) {
    88.             node *p_lnext2 = p_lnext->p_next;
    89.             p_node->p_next = p_lnext2;
    90.             p_lnext2->p_pre = p_node;
    91.             free(p_lnext);
    92.             p_lnext = NULL;
    93.             break;
    94.         }
    95.     }*/
    96.     for (p_node = &tail;p_node != &head;p_node = p_node->p_pre) {
    97.         node *p_lpre = p_node->p_pre;
    98.         if (p_lpre != &head && p_lpre->num == num) {
    99.             //调整当前指针位置
    100.             if (p_lpre == p_curr) {
    101.                 p_curr = p_curr->p_next;
    102.                 if (p_curr == &tail) {
    103.                     p_curr = NULL;
    104.                 }
    105.             }
    106.             node *p_lpre2 = p_lpre->p_pre;
    107.             p_lpre2->p_next = p_node;
    108.             p_node->p_pre = p_lpre2;
    109.             free(p_lpre);
    110.             p_lpre = NULL;
    111.             break;
    112.         }
    113.     }
    114. }
    116. //获得第一个有效数据
    117. int first() {
    118.     //把当前指针定位在第一个有效节点
    119.     if (head.p_next != &tail) {
    120.         p_curr = head.p_next;
    121.     }
    122.     return head.p_next == &tail ? 0 : head.p_next->num;
    123. }
    125. //获得最后一个有效数据
    126. int last() {
    127.     //把当前指针定位在最后一个有效节点
    128.     if (tail.p_pre != &head) {
    129.         p_curr = tail.p_pre;
    130.     }
    131.     return tail.p_pre == &head ? 0 : tail.p_pre->num;
    132. }
    134. //插入新节点成为第一个有效节点
    135. void add_head(int num) {
    136.     node *p_node = (node*)malloc(sizeof(node));
    137.     if (!p_node) {
    138.         return ;
    139.     }
    140.     p_node->num = num;
    141.     p_node->p_next = head.p_next;
    142.     head.p_next->p_pre = p_node;
    143.     head.p_next = p_node;
    144.     p_node->p_pre = &head;
    145. }
    147. //加入新节点成为最后一个有效几点
    148. void append(int num) {
    149.     node *p_node = (node*)malloc(sizeof(node));
    150.     if (!p_node) {
    151.         return ;
    152.     }
    153.     p_node->num = num;
    154.     p_node->p_pre = tail.p_pre;
    155.     tail.p_pre->p_next = p_node;
    156.     p_node->p_next = &tail;
    157.     tail.p_pre = p_node;
    158. }
    160. //获得有效节点个数
    161. int size() {
    162.     int cnt = 0;
    163.     node *p_node = NULL;
    164.     for (p_node = &tail;p_node != &head;p_node = p_node->p_pre) {
    165.         node *p_lpre = p_node->p_pre;
    166.         if (p_lpre != &head) {
    167.             cnt++;
    168.         }
    169.     }
    170.     return cnt;
    171. }
    173. //向后移动位置指针并获得新节点数据
    174. int next() {
    175.     int num = 0;
    176.     if (p_curr) {
    177.         p_curr = p_curr->p_next;
    178.         if (p_curr == &tail) {
    179.             p_curr = NULL;
    180.         }
    181.         else {
    182.             num = p_curr->num;
    183.         }
    184.     }
    185.     return num;
    186. }
    188. //向前移动位置指针并获得新节点数据
    189. int pre() {
    190.     int num = 0;
    191.     if (p_curr) {
    192.         p_curr = p_curr->p_pre;
    193.         if (p_curr == &head) {
    194.             p_curr = NULL;
    195.         }
    196.         else {
    197.             num = p_curr->num;
    198.         }
    199.     }
    200.     return num;
    201. }

  8. 有序二叉树数据结构

    tree.h

    1. #ifndef     __TREE_H__
    2. #define     __TREE_H__
    3. void init();
    4. void deinit();
    5. void insert(int);
    6. void traverse(void (*)(int*, void*), void*);
    7. void rtraverse(void (*)(int*, void*), void*);
    8. void hflip();
    9. #endif     //__TREE_H__

    tree.c

    1. /*
    2.    有序二叉树数据结构
    3.    */
    4. #include <stdlib.h>
    5. #include "tree.h"
    6. struct node;
    7. typedef struct tree {
    8.     struct node *p_node;
    9. } tree;
    10. typedef struct node {
    11.     int num;
    12.     tree left;
    13.     tree right;
    14. } node;
    16. static tree tr;
    18. //初始化
    19. void init() {
    20.     tr.p_node = NULL;
    21. }
    23. //真正的清理函数
    24. static void tree_deinit(tree *p_tree) {
    25.     if (!(p_tree->p_node)) {
    26.         return ;
    27.     }
    28.     tree_deinit(&(p_tree->p_node->left));
    29.     tree_deinit(&(p_tree->p_node->right));
    30.     free(p_tree->p_node);
    31.     p_tree->p_node = NULL;
    32. }
    34. //清理
    35. void deinit() {
    36.     tree_deinit(&tr);
    37. }
    39. //查找指定数字
    40. static tree *tree_search(tree *p_tree, int num) {
    41.     if (!(p_tree->p_node)) {
    42.         return p_tree;
    43.     }
    44.     if (p_tree->p_node->num == num) {
    45.         return p_tree;
    46.     }
    47.     else if (p_tree->p_node->num < num) {
    48.         return tree_search(&(p_tree->p_node->right), num);
    49.     }
    50.     else {
    51.         return tree_search(&(p_tree->p_node->left), num);
    52.     }
    53. }
    55. //插入新数字
    56. void insert(int num) {
    57.     tree *p_tree = tree_search(&tr, num);
    58.     if (!(p_tree->p_node)) {
    59.         node *p_node = (node*)malloc(sizeof(node));
    60.         if (p_node) {
    61.             p_node->num = num;
    62.             p_node->left.p_node = NULL;
    63.             p_node->right.p_node = NULL;
    64.             p_tree->p_node = p_node;
    65.         }
    66.     }
    67. }
    69. //遍历函数
    70. static void for_each(tree *p_tree, void (*p_cb)(int*, void*), void *p_data) {
    71.     if (!(p_tree->p_node)) {
    72.         return ;
    73.     }
    74.     for_each(&(p_tree->p_node->left), p_cb, p_data);
    75.     p_cb(&(p_tree->p_node->num), p_data);
    76.     for_each(&(p_tree->p_node->right), p_cb, p_data);
    77. }
    79. //中序遍历函数
    80. void traverse(void (*p_cb)(int*, void*), void* p_data) {
    81.     for_each(&tr, p_cb, p_data);
    82. }
    84. //反向遍历函数
    85. static void rfor_each(tree *p_tree, void (*p_cb)(int*, void*), void *p_data) {
    86.     if (!(p_tree->p_node)) {
    87.         return ;
    88.     }
    89.     rfor_each(&(p_tree->p_node->right), p_cb, p_data);
    90.     p_cb(&(p_tree->p_node->num), p_data);
    91.     rfor_each(&(p_tree->p_node->left), p_cb, p_data);
    92. }
    94. //反向中序遍历函数
    95. void rtraverse(void (*p_cb)(int*, void*), void* p_data) {
    96.     rfor_each(&tr, p_cb, p_data);
    97. }
    99. //水平翻转函数
    100. static void flip(tree *p_tree) {
    101.     node *p_node = NULL;
    102.     if (!(p_tree->p_node)) {
    103.         return ;
    104.     }
    105.     p_node = p_tree->p_node->left.p_node;
    106.     p_tree->p_node->left.p_node = p_tree->p_node->right.p_node;
    107.     p_tree->p_node->right.p_node = p_node;
    108.     flip(&(p_tree->p_node->left));
    109.     flip(&(p_tree->p_node->right));
    110. }
    112. //给外部调用的水平翻转函数
    113. void hflip() {
    114.     flip(&tr);
    115. }

算法

  1. 查找find

    1. #include <stdio.h>
    2. // 线性查找
    3. int line_find (int data[], int size, int key) {
    4.          int i;
    5.          for (i = 0; i < size; ++i)
    6.                  if (data[i] == key)
    7.                          return i;
    8.          return -1;
    9.  }
    10.  // 二分查找（利用递归）
    11.  static int recu_find (int data[], int left,int right, int key) {
    12.          if (left <= right) {
    13.                  int mid = (left + right) / 2;
    14.                  if (key < data[mid])
    15.                          return recu_find (data, left, mid - 1,key);
    16.                  else if (data[mid] < key)
    17.                          return recu_find (data, mid + 1, right,key);
    18.                  else
    19.                          return mid;
    20.          }
    21.          return -1;
    22.  }
    23.  // 二分查找(利用循环)
    24.  int half_find (int data[], int size, int key) {
    25.          /*******************************************
    26.          return recu_find (data, 0, size - 1, key);
    27.          ********************************************/
    28.          int left = 0;
    29.          int right = size - 1;
    30.          while (left <= right) {
    31.                  int mid = (left + right) / 2;
    32.                  if (key < data[mid])
    33.                          right = mid - 1;
    34.                  else if (data[mid] < key)
    35.                          left = mid + 1;
    36.                  else
    37.                          return mid;
    38.          }
    39.          return -1;
    40.  }
    41.  int main (void) {
    42.          int data1[] = {9,0,7,2,5,4,3,6,1,8};
    43.          int size = sizeof (data1) / sizeof (data1[0]);
    44.          int i = line_find (data1, size, /*7*/77);
    45.          if (i == -1)
    46.                  printf ("没找到！\n");
    47.          else
    48.                  printf ("找到了：%d\n", i);
    49.          int data2[] = {0,1,2,3,4,5,6,7,8,9};
    50.          size = sizeof (data2) / sizeof (data2[0]);
    51.          i = half_find (data2, size, /*7*/77);
    52.          if (i == -1)
    53.                  printf ("没找到！\n");
    54.          else
    55.                  printf ("找到了：%d\n", i);
    56.          return 0;
    57.  }

  2. 排序sort

    1. #include <stdio.h>
    2. /* 冒泡排序 */
    3. void bubble_sort (int data[], size_t size) {
    4.         size_t i;
    5.         for (i = 0; i < size - 1; ++i) {
    6.                 int ordered = 1;
    7.                 size_t j;
    8.                 for (j = 0; j < size - 1 - i; ++j)
    9.                         if (data[j+1] < data[j]) {
    10.                                 int swap = data[j];
    11.                                 data[j] = data[j+1];
    12.                                 data[j+1] = swap;
    13.                                 ordered = 0;
    14.                         }
    15.                 if (ordered)
    16.                         break;
    17.         }
    18. }
    19.  /* 插入排序 */
    20. void insert_sort (int data[], size_t size) {
    21.         size_t i;
    22.         for (i = 1; i < size; ++i) {
    23.                 int inserted = data[i];
    24.                 size_t j;
    25.                 for (j = i; j > 0 && inserted < data[j-1]; --j)
    26.                         data[j] = data[j-1];
    27.                 if (i != j) // 减少给自己赋值
    28.                         data[j] = inserted;
    29.         }
    30. }
    31. /* 选择排序 */
    32. void select_sort (int data[], size_t size) {
    33.         size_t i;
    34.         for (i = 0; i < size - 1; ++i) {
    35.                 size_t min = i;
    36.                size_t j;
    37.                 for (j = i + 1; j < size; ++j)
    38.                         if (data[j] < data[min])
    39.                                 min = j;
    40.                 if (min != i) {
    41.                         int swap = data[i];
    42.                         data[i] = data[min];
    43.                         data[min] = swap;
    44.                 }
    45.         }
    46. }
    47. /* 快速排序 */
    48.  void quick_sort (int data[], size_t left,size_t right) {
    49.         size_t p = (left + right) / 2;
    50.         int pivot = data[p]; // 基准值备份
    51.         size_t i = left, j = right;
    52.         while (i < j) {
    53.                 for (; ! (i >= p || pivot < data[i]); ++i);
    54.                 if (i < p) {
    55.                         data[p] = data[i];
    56.                         p = i;
    57.                 }
    58.                 for (; ! (j <= p || data[j] < pivot); --j);
    59.                 if (j > p) {
    60.                         data[p] = data[j];
    61.                         p = j;
    62.                 }
    63.         }
    64.         data[p] = pivot;
    65.         if (p - left > 1)
    66.                 quick_sort (data, left, p - 1);
    67.         if (right - p > 1)
    68.                 quick_sort (data, p + 1, right);
    69. }
    70. int main (void) {
    71.         int data[] = {23,45,23,18,44,56,45,18,79};
    72.         size_t size = sizeof (data) / sizeof (data[0]);
    73.         /*************************************************
    74.         bubble_sort (data, size);
    75.         insert_sort (data, size);
    76.         select_sort (data, size);
    77.         *************************************************/
    78.         quick_sort (data, 0, size - 1);
    79.         size_t i;
    80.         for (i = 0; i < size; ++i)
    81.                 printf ("%d ", data[i]);
    82.         printf ("\n");
    83.         return 0;
    84. }

打赏

微信支付 支付宝支付

License

本作品由Simon（http://www.uusystem.com）创作，采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。 欢迎转载，但任何转载必须保留完整文章，在显要地方显示此声明以及原文链接。如您有任何疑问或者授权方面的协商，请邮件：postmaster@uusystem.com。