1.使用C语言的7个步骤

定义程序目标
思考你的程序需要哪些信息，要进行哪些计算和控制，以及程序应该要报告什么信息

设计程序
如何用程序来完成它，列如用户界面是怎样的？如何组织程序？目标用户是谁？准备花多少时间来完成这个程序？
除此之外还要决定在程序中如何表示数据，以及用什么方法处理数据

编写代码
编译

运行程序

测试和调试程序

维护和修改代码

2.ASCII码

• 字符A~ Z的ASCII码值从65~90
• 字符a~ z的ASCII码值从97~122
• 对应的大小写字符(a和A)的ASCII码值的差值是32
• 数字字符0~9的ASCII码值从48 ~ 57
• 换⾏ \n 的ASCII值是：10
• 在这些字符中ASCII码值从0~31这32个字符是不可打印字符，⽆法打印在屏幕上观察

---

3.提高程序可读性的机巧

• 选择有意义的函数名和写注释
• 用空行分割概念上的多个部分
• 每条语句各占一行（尽管这不是C语言要求的）

---

9.2.4 赋值忽略符
有时，⽤⼾的输⼊可能不符合预定的格式。
为了避免这种情况， scanf() 提供了⼀个赋值忽略符 * 。
只要把 * 加在任何占位符的百分号后⾯，该占位符就不会返回值，解析后将被丢弃。
scanf(“%d%*c%d%*c%d”, &year, &month, &day);
%*c 就是在占位符的百分号后⾯，加⼊了赋值忽略符 * ，表⽰这个占位符没有对应的变量，解读后不必返回

#pragma pack(1)修改默认对其数

4.如何使用多种整形

对于需要32位的整数选择long而不是int

对于需要16位的整数选择int而不是short

---

整数溢出
如果整数超出了相应类型的取值范围会怎样？C标准并未定义有符号类型的溢出规则，以下是比较有代表性的行为，但是也可能出现其他情况

有符号整数直接跳到了最小值，无符号整数则是直接截断

---

5.打印多种整形

C语言提供了丰富的转换类型，要需要可以直接查表。

使用错误的转换说明会得到意想不到的结果，如无符号值3000000000和-129496296在系统内存中的内部完全相同

---

4.3 位段的跨平台问题
1.int位段被当成有符号数还是⽆符号数是不确定的。
2. 位段中最⼤位的数⽬不能确定。（16位机器最⼤16，32位机器最⼤32，写成27，在16位机器会
出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配，标准尚未定义。
4. 当⼀个结构包含两个位段，第⼆个位段成员⽐较⼤，⽆法容纳于第⼀个位段剩余的位时，是舍弃
剩余的位还是利⽤，这是不确定的。
总结：
跟结构相⽐，位段可以达到同样的效果，并且可以很好的节省空间，但是有跨平台的问题存在。

7.1 被错误使⽤的 feof
牢记：在⽂件读取过程中，不能⽤feof函数的返回值直接来判断⽂件的是否结束。
feof 的作⽤是：当⽂件读取结束的时候，判断是读取结束的原因是否是：遇到⽂件尾结束。

1. ⽂本⽂件读取是否结束，判断返回值是否为 EOF （ fgetc ），或者 NULL （ fgets ）
   例如：
   • fgetc 判断是否为 EOF .
   • fgets 判断返回值是否为 NULL .

2. ⼆进制⽂件的读取结束判断，判断返回值是否⼩于实际要读的个数。
   例如：
   • fread判断返回值是否⼩于实际要读的个数。

3. #和##
   7.1 #运算符
   #运算符将宏的⼀个参数转换为字符串字⾯量。它仅允许出现在带参数的宏的替换列表中。
   #运算符所执⾏的操作可以理解为”字符串化“。
   当我们有⼀个变量 int a = 10; 的时候，我们想打印出： the value of a is 10 .
   就可以写：
   1 #define PRINT(n) printf(“the value of “#n " is %d”, n);
   当我们按照下⾯的⽅式调⽤的时候：
   PRINT(a);//当我们把a替换到宏的体内时，就出现了#a，⽽#a就是转换为"a”，时⼀个字符串

printf("the value of ““a” " is %d”, a)

10. 命令⾏定义
    许多C的编译器提供了⼀种能⼒，允许在命令⾏中定义符号。⽤于启动编译过程。
    例如：当我们根据同⼀个源⽂件要编译出⼀个程序的不同版本的时候，这个特性有点⽤处。（假定某
    个程序中声明了⼀个某个⻓度的数组，如果机器内存有限，我们需要⼀个很⼩的数组，但是另外⼀个
    机器内存⼤些，我们需要⼀个数组能够⼤些。）

//linux 环境演⽰
gcc -D ARRAY_SIZE=10 programe.c

6.课移植类型：stdint.h和inttypes.h

C语言提供了许多有用的整数类型。但是在不同系统下某些类型名的功能不一样，这些新的类型吗定义在stdint.h头文件中

例如，int32_t表示32位的有符号整数类型，在32位系统下会将int32_t作为int的别名

当然以上都是精确宽度整数类型，C99和C11提供了张宇轩宽度类型如int_least8_t是可容纳8位有符号整数值的类型中宽度最小的类型的一个别名（sizeof（类型）>=8），此外还定义了最大整数类型，可以自己去了解一下，同时为了针对不同平台下要打印相同类型提供了一系列字符串宏，如inttypes.h定义了PRId32字符串宏

#include <stdio.h>
#include <inttypes.h> // supports portable types
int main(void)
{
    int32_t me32;     // me32 a 32-bit signed variable
    
    me32 = 45933945;
    printf("First, assume int32_t is int: ");
    printf("me32 = %d\n", me32);
    printf("Next, let's not make any assumptions.\n");
    printf("Instead, use a \"macro\" from inttypes.h: ");
    printf("me32 = %" PRId32 "\n", me32);
    
    return 0;
}

7.浮点数常量

浮点数常量默认是double类型，可以通过后面加上f或F覆盖默认设置，也可以用l或L后缀使得数字成为long double 类型

C99标准添加了一种新的浮点型常量格式——用十六进制表示浮点型常量。
如下所示
0xa.1fp10
0x是前缀，a等于十进制10，.lf是1/16+15/256（十六进制f等于十进制15），p10是2¹⁰

---

8.浮点值的上溢和下溢

上溢会赋给变量一个表示无穷大的特定值，且用printf打印会显式为inf

---

下溢会导致位数部分的为向右移空出二进制位，并丢弃最后二进制数。尽管得到了结果但是损失了精度，不过C库提供了用于检查计算是否会产生低于正常值的函数。

---

9.使用数据类型

初始化变量应使用与变量类型匹配的常数类型（避免隐式类型转换）
进行系统化的命名约定，在变量名中体现其类型。
例如，用i_前缀表示int类型，us_前缀表示unsigned short类型

11.常量和C预处理器

符号常量

#define PI 3.1415926

12.转换说明的意义

转换说明是翻译说明，%d的意思是“把给定的值翻译成十进制整数文本并显示到显示屏上”

12.1转换不匹配

13.副作用和序列点

序列点是程序执行的点，在该点上，所用的副作用都在进入下一步之前发生。在C语言，语句的分号标记了一个序列点。对运算对象做的改变必须在程序执行下一条语句之前完成

任何一个完整表达式的结果也是一个序列点
什么是完整表达式？这个表达式不是另一个更大表达式的子式
如while(guests++<10)是一个完整的表达式，因此在执行下一条语句时guests已经递增了，而y=（4 + x++） +（6 + x++），表达式4 + x++不是一个完整的表达式，因此无法保证执行完4 + x++之后x立即递增

这样的代码是非常糟糕的，在C和C++标准中，对于没有显式序列点分隔的多个副作用，它们的执行顺序是未定义的（undefined behavior）。

14.数组简介

C编译器对数据下标的检查是一种抽查，且只针对写

---

读

---

写

只抽查索引后的两位

15.ctype.h系列的字符函数

备选拼写：iso646.h头文件
程序包含该头文件，便可用and代替&&、or替代||、not代替！

16.缓冲区

为什么要有缓冲区？首先，把若干字符作为一个块进行传输比逐个发送这些字符节约时间。其次，如果用户打错字符，可以直接通过键盘修正错误。当最后按上Enter键时，传输的是正确的输入

缓冲分为两类：完全缓冲I/O和行缓冲I/O。完全缓冲输入指的是当缓冲区被填满时才刷新缓冲区。行缓冲I/O指的是出现换行符是刷新缓冲区。

17.文件结尾

操作系统可以用内嵌的Ctrl+Z字符来标记文件结尾，操作系统使用的另一种方法是存储文件大小的信息，如果文件有3000字节，程序在读到3000字节时便达到文件的结尾

无论用何种语言检测文件结尾，在C语言中，用getchar()读取文件检测到文件结尾时将返回一个特殊的值，即EOF（end of file的缩写）。scanf（）函数检测到文件结尾时也返回EOF。通常，EOF定义在stdio.h文件中；
#define EOF （-1）

使用EOF？不能直接输入-1或EOF来表明EOF，正确的方法是根据当前系统的要求，如Vs下连续输入三下Ctrl+Z表示文件结尾

18.重定向

重定向输入输出让程序指定文件输入输出（Linux学习会详细介绍）

19.创建更友好的用户界面

19.1 使用缓冲输入

设计一个猜谜程序

while((response=getchar())!='y')//获得响应
{
//业务处理
while(getchar()!='/n')
continue;//跳过剩余的输入行
}

程序会输出猜得的数字，用户可以进行否定和肯定。但是程序无法识别用户说的所有话，例如业务处理让程序仅能识别’n’和’y’,只要用户输出的首字符是’n’或’y’，程序就能正常运行同时跳过剩余输入，否则则提示无法识别重新输入

---

19.2混合数值和字符输入

设计一个打印m x n字符的程序

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
void display(char cr, int lines, int width);
int main(void)
{
    int ch;             /* character to be printed      */
    int rows, cols;     /* number of rows and columns   */
    
    printf("Enter a character and two integers:\n");
    while ((ch = getchar()) != '\n')
    {
        if (scanf("%d %d",&rows, &cols) != 2)//确保输入正确
            break;
        display(ch, rows, cols);
        while (getchar() !=  '\n')//跳过剩余输入包括换行符保证下次执行时不会退出
            continue;
        printf("Enter another character and two integers;\n");
        printf("Enter a newline to quit.\n");
    }
    printf("Bye.\n");
    
    return 0;
}

void display(char cr, int lines, int width)
{
    int row, col;
    
    for (row = 1; row <= lines; row++)
    {
        for (col = 1; col <= width; col++)
            putchar(cr);
        putchar('\n');  /* end line and start a new one */
    }
}

19.3输入验证

在实际应用中，用户不一定会按照程序的指令形式，设计程序时我们应该处理一些可能得输入错误

例子
只处理正数

while(n>=0)
{
//业务处理
//获取下一个值
}

---

通过scanf函数的返回值来处理

while(scanf()==2)
{
//业务处理
//获取
}

---

通过getchar处理剩余的输入

while (getchar() !=  '\n')
           putchar（ch）;

19.4 菜单浏览

但是遗憾的是并不是所有人都会按规矩办事，所以现在的应用程序使用图形界面，避免了错误输入

---

一个简单的设计

/* menuette.c -- menu techniques */
#include <stdio.h>
char get_choice(void);
char get_first(void);
int get_int(void);
void count(void);
int main(void)
{
    int choice;
    void count(void);
    
    while ( (choice = get_choice()) != 'q')
    {
        switch (choice)
        {
            case 'a' :  printf("Buy low, sell high.\n");
                break;
            case 'b' :  putchar('\a');  /* ANSI */
                break;
            case 'c' :  count();
                break;
            default  :  printf("Program error!\n");
                break;
        }
    }
    printf("Bye.\n");
    
    return 0;
}

void count(void)
{
    int n,i;
    
    printf("Count how far? Enter an integer:\n");
    n = get_int();
    for (i = 1; i <= n; i++)
        printf("%d\n", i);
    while ( getchar() != '\n')
        continue;
}

char get_choice(void)
{
    int ch;
    
    printf("Enter the letter of your choice:\n");
    printf("a. advice           b. bell\n");
    printf("c. count            q. quit\n");
    ch = get_first();
    while (  (ch < 'a' || ch > 'c') && ch != 'q')
    {
        printf("Please respond with a, b, c, or q.\n");
        ch = get_first();
    }
    
    return ch;
}

char get_first(void)
{
    int ch;
    
    ch = getchar();
    while (getchar() != '\n')
        continue;
    
    return ch;
}

int get_int(void)
{
    int input;
    char ch;
    
    while (scanf("%d", &input) != 1)
    {
        while ((ch = getchar()) != '\n')
            putchar(ch);  // dispose of bad input
        printf(" is not an integer.\nPlease enter an ");
        printf("integer value, such as 25, -178, or 3: ");
    }
    
    return input;
}

想创造出让人满意的菜单界面并不容易。就是从0到1实现很难，但是CV比较简单然后修改一下复用就行了

20.函数

20.1 形参的创建

在原型中使用变量名并没有实际创造变量，char仅代表了一个char类型的变量。只有当调用函数的时候才开辟形参

20.2 黑盒视角

21.编译多源代码文件的程序

22.指定初始化器（C99）

没初始化的元素都会变成零

---

当然这样赋值的话检查就比较严格，能检测下标是否越界

元素个数为最大下标个数+1

23.声明数组形参

23.指针的兼容性

指针之间的赋值比数值类型之间的赋值要严格

24.复合字面量

// flc.c -- funny-looking constants
#include <stdio.h>
#define COLS 4
int sum2d(const int ar[][COLS], int rows);
int sum(const int ar[], int n);
int main(void)
{
    int total1, total2, total3;
    int * pt1;
    int (*pt2)[COLS];
    
    pt1 = (int [2]) {10, 20};
    pt2 = (int [2][COLS]) { {1,2,3,-9}, {4,5,6,-8} };
    
    total1 = sum(pt1, 2);
    total2 = sum2d(pt2, 2);
    total3 = sum((int []){4,4,4,5,5,5}, 6);
    printf("total1 = %d\n", total1);
    printf("total2 = %d\n", total2);
    printf("total3 = %d\n", total3);
    
    return 0;
}

int sum(const int ar[], int n)
{
    int i;
    int total = 0;
    
    for( i = 0; i < n; i++)
        total += ar[i];
    
    return total;
}

int sum2d(const int ar[][COLS], int rows)
{
    int r;
    int c;
    int tot = 0;
    
    for (r = 0; r < rows; r++)
        for (c = 0; c < COLS; c++)
            tot += ar[r][c];
    
    return tot;
}

25.数组和指针

数组形式中，ar1是地址常量，不能更改ar1

26.字符串数组

28.fgets()函数(和fputs())

了解文件I/O，最简单的方法就是运用Linux下一切皆文件的哲学，包括键盘和显示器也视作文件，它们也有读写函数只不过键盘写方法为空，显示器读方法为空

char * fgets ( char * str, int num, FILE * stream );
int fputs ( const char * str, FILE * stream );

f前缀代表file，get从文件读取，put写到文件中

无前缀代标准流，get从标准输入流读取，put写到标准输出流

s前缀代表string,get从字符串读取，put写到字符串中

---

理解这个你也能理解scanf，fscanf，sscanf这类

f前缀代表file，从文件读取，

无前缀代标准流，从标准输入流读取，

s前缀代表string,从字符串读取，、

---

事实上正如鹏哥所说甚至公司会单独封装一套文件I/O，现有的文件I/O设计不是很理想

char * s_gets(char * st, int n)
{
    char * ret_val;
    int i = 0;
    
    ret_val = fgets(st, n, stdin);
    if (ret_val)
    {
        while (st[i] != '\n' && st[i] != '\0')
            i++;
        if (st[i] == '\n')
            st[i] = '\0';
        else // must have words[i] == '\0'
            while (getchar() != '\n')
                continue;
    }
    return ret_val;
}

29.命令行参数

在图形界面普及之前都是用命令行界面

尤其是Linux环境往往使用的就是命令行界面

/* repeat.c -- main() with arguments */
#include <stdio.h>
int main(int argc, char *argv[])
{
    int count;
    
    printf("The command line has %d arguments:\n", argc - 1);
    for (count = 1; count < argc; count++)
        printf("%d: %s\n", count, argv[count]);
    printf("\n");
    
    return 0;
}

Linux环境下会详细介绍

30.结构体

/* complit.c -- compound literals */
#include <stdio.h>
#define MAXTITL  41
#define MAXAUTL  31

struct book {          // structure template: tag is book
    char title[MAXTITL];
    char author[MAXAUTL];
    float value;
};

int main(void)
{
    struct book readfirst;
    int score;
    
    printf("Enter test score: ");
    scanf("%d",&score);
    
    if(score >= 84)
        readfirst = (struct book) {"Crime and Punishment",
            "Fyodor Dostoyevsky",
            11.25};
    else
        readfirst = (struct book) {"Mr. Bouncy's Nice Hat",
            "Fred Winsome",
            5.99};
    printf("Your assigned reading:\n");
    printf("%s by %s: $%.2f\n",readfirst.title,
           readfirst.author, readfirst.value);
    
    return 0;
}

1.int位段被当成有符号数还是⽆符号数是不确定的。
2. 位段中最⼤位的数⽬不能确定。（16位机器最⼤16，32位机器最⼤32，写成27，在16位机器会
出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配，标准尚未定义。
4. 当⼀个结构包含两个位段，第⼆个位段成员⽐较⼤，⽆法容纳于第⼀个位段剩余的位时，是舍弃剩余的位还是利⽤，这是不确定的。
总结：
跟结构相⽐，位段可以达到同样的效果，并且可以很好的节省空间，但是有跨平台的问题存在。

31.存储类别、链接和内存管理

前置知识
C提供了多种不同的存储类别在内存中存储数据。
C语言中也有对象概念但是并不同于C++中的对象概念，对象指的是指内存中的一段有意义的区域，这段区域根据程序的声明被分配存储的每个值占用的物理内存区域，一块内存可以存储一个或多个值，也可以未存储实际的值。

软件方面来看，程序需要一种方法访问对象。这可以通过声明变量来完成

int entity = 3；，虽然这里说是声明变量但同时也定义了变量（开了空间，声明存在了多久这块对象就保留了多久时间）

entity可以指定特定的一块内存空间的内容，这样的方式可以得到一块特定的内存空间，同时也提供了存储在这块内存空间的内容

当然也可以通过一下方式指定对象
int*pt = &entity；//声明指针的方式
int ranks[10];//声明数组的方式实则就是声明指针的方式

31.1作用域

块作用域指的是从定义到包含该定义的块的末尾，不是指{}括起来的范围。比如if语句就不需要花括号，但是它是块作用域

大家看以前的C语言代码是这样写的

int i;
for（i=0;i<length;i++）
//现在我们都是这么写的
for（int i=0;i<length;i++）

C99我们把块的概念拓展到到了循环语句和if语句，

函数作用域不需要过多了解，因为这仅仅作用在goto语句，但是goto语句尽量别用

函数原型作用域从作用域的范围到从形参定义处到原型声明结束。就是说编译器只关注类型，不关注形参名。只有在变长数组中，形参名才有用

void use_a_VLM(int n,int m,ar[n][m]);

文件作用域也叫全局作用域，从他的定义到该定义文件的结尾甚至文件外部也能使用

31.2 链接

31.3 存储期

31.3.1 自动变量

内部块会隐藏外层块的定义，但是离开内层块之后后，程序使用的是当前块（外层块）的定义

尽量别使用同名变量，上述仅仅是编译器如何看待同名变量

31.3.2 寄存器变量

32 ANSI C类型限定符

32.1 volatile限定符

32.2 restrict限定符

32.3_Atomic类型限定符(C11)

32.4 旧关键字的新位置

33.结构体

/* complit.c -- compound literals */
#include <stdio.h>
#define MAXTITL  41
#define MAXAUTL  31

struct book {          // structure template: tag is book
    char title[MAXTITL];
    char author[MAXAUTL];
    float value;
};

int main(void)
{
    struct book readfirst;
    int score;
    
    printf("Enter test score: ");
    scanf("%d",&score);
    
    if(score >= 84)
        readfirst = (struct book) {"Crime and Punishment",
            "Fyodor Dostoyevsky",
            11.25};
    else
        readfirst = (struct book) {"Mr. Bouncy's Nice Hat",
            "Fred Winsome",
            5.99};
    printf("Your assigned reading:\n");
    printf("%s by %s: $%.2f\n",readfirst.title,
           readfirst.author, readfirst.value);
    
    return 0;
}

34.位操作

//  mytype.c

#include <stdio.h>

#define MYTYPE(X) _Generic((X),\
int: "int",\
float : "float",\
double: "double",\
default: "other"\
)

int main(void)
{
    int d = 5;
    
    printf("%s\n", MYTYPE(d));     // d is type int
    printf("%s\n", MYTYPE(2.0*d)); // 2.0* d is type double
    printf("%s\n", MYTYPE(3L));    // 3L is type long
    printf("%s\n", MYTYPE(&d));    // &d is type int *
    return 0;
}

//varargs.c -- use variable number of arguments
#include <stdio.h>
#include <stdarg.h>
double sum(int, ...);

int main(void)
{
    double s,t;
    
    s = sum(3, 1.1, 2.5, 13.3);
    t = sum(6, 1.1, 2.1, 13.1, 4.1, 5.1, 6.1);
    printf("return value for "
           "sum(3, 1.1, 2.5, 13.3):                %g\n", s);
    printf("return value for "
           "sum(6, 1.1, 2.1, 13.1, 4.1, 5.1, 6.1): %g\n", t);
    
    return 0;
}

double sum(int lim,...)
{
    va_list ap;                    // declare object to hold arguments
    double tot = 0;
    int i;
    
    va_start(ap, lim);             // initialize ap to argument list
    for (i = 0; i < lim; i++)
        tot += va_arg(ap, double); // access each item in argument list
    va_end(ap);                    // clean up
    
    return tot;
}

35 其他

预处理详解

数据在内存中的存储