C 思维导图模板_ProcessOn思维导图、流程图

C 程序结构

预处理器指令

函数

变量

语句 & 表达式

注释

C 基本语法

分号

注释

标识符

关键字

空格

C 数据类型

基本类型

它们是算术类型，包括两种类型：整数类型和浮点类型。

枚举类型

它们也是算术类型，被用来定义在程序中只能赋予其一定的离散整数值的变量。

void 类型

类型说明符 void 表明没有可用的值。

派生类型

它们包括：指针类型、数组类型、结构类型、共用体类型和函数类型。

C 变量

基本的变量类型

char

通常是一个字节（八位）。这是一个整数类型。

int

对机器而言，整数的最自然的大小。

float

单精度浮点值。

double

双精度浮点值。

void

表示类型的缺失。

C 中的变量声明（有两种情况）

1、一种是需要建立存储空间的。例如：int a 在声明的时候就已经建立了存储空间。

2、另一种是不需要建立存储空间的，通过使用extern关键字声明变量名而不定义它。例如：extern int a 其中变量 a 可以在别的文件中定义的。

C 中的左值（Lvalues）和右值（Rvalues）

左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。

右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。

例子：有效的语句：int g = 20;

C 常量

整数常量

85         /* 十进制 */ 0213       /* 八进制 */ 0x4b       /* 十六进制 */ 30         /* 整数 */ 30u        /* 无符号整数 */ 30l        /* 长整数 */ 30ul       /* 无符号长整数 */

浮点常量

3.14159       /* 合法的 */ 314159E-5L    /* 合法的 */ 510E          /* 非法的：不完整的指数 */ 210f          /* 非法的：没有小数或指数 */ .e55          /* 非法的：缺少整数或分数 */

字符常量

\\  \ 字符 \'   ' 字符 \"  " 字符 \?  ? 字符 \a  警报铃声 \b  退格键 \f   换页符 \n  换行符 \r   回车 \t   水平制表符 \v  垂直制表符 \ooo   一到三位的八进制数 \xhh . . .   一个或多个数字的十六进制数

字符串常量

定义常量

使用 #define 预处理器。

#define T1 a+a #define T2 T1-T1 实际上 T2 是 a+a-a+a。

使用 const 关键字。

const int T1=a+a; const int T2=T1-T1; T2 是 (a+a) - (a+a)。

C 存储类

auto 是局部变量的默认存储类, 限定变量只能在函数内部使用

register 代表了寄存器变量，不在内存中使用

static 是全局变量的默认存储类,表示变量在程序生命周期内可见

extern 表示全局变量，即对程序内所有文件可见，类似于Java中的public关键字

C 运算符

算术运算符

关系运算符

逻辑运算符

位运算符

假设变量 A 的值为 60，变量 B 的值为 13

<table><tbody><tr><th>运算符</th><th>描述</th><th>实例</th></tr><tr><td>&</td><td>如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。</td><td> (A & B) 将得到 12，即为 0000 1100</td></tr><tr><td>|</td><td>如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。</td><td> (A | B) 将得到 61，即为 0011 1101</td></tr><tr><td>^</td><td>如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。</td><td> (A ^ B) 将得到 49，即为 0011 0001</td></tr><tr><td>~</td><td>二进制补码运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0。</td><td> (~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。</td></tr><tr><td><<</td><td>二进制左移运算符。左操作数的值向左移动右操作数指定的位数。</td><td> A << 2 将得到 240，即为 1111 0000</td></tr><tr><td>>></td><td>二进制右移运算符。左操作数的值向右移动右操作数指定的位数。</td><td> A >> 2 将得到 15，即为 0000 1111</td></tr></tbody></table>

&：全为真才是真1，其它的都是假0 |  ：全为假才是假0，其它的都是真1 ^ ：一样是0不一样是1

赋值运算符

<table><tbody><tr><th>运算符</th><th>描述</th><th>实例</th></tr><tr><td>=</td><td>简单的赋值运算符，把右边操作数的值赋给左边操作数</td><td> C = A + B 将把 A + B 的值赋给 C</td></tr><tr><td>+=</td><td>加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数</td><td> C += A 相当于 C = C + A</td></tr><tr><td>-=</td><td>减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数</td><td> C -= A 相当于 C = C - A</td></tr><tr><td>*=</td><td>乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数</td><td> C *= A 相当于 C = C * A</td></tr><tr><td>/=</td><td>除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数</td><td> C /= A 相当于 C = C / A</td></tr><tr><td>%=</td><td>求模且赋值运算符，求两个操作数的模赋值给左边操作数</td><td> C %= A 相当于 C = C % A</td></tr><tr><td><<=</td><td>左移且赋值运算符</td><td> C <<= 2 等同于 C = C << 2</td></tr><tr><td>>>=</td><td>右移且赋值运算符</td><td> C >>= 2 等同于 C = C >> 2</td></tr><tr><td>&=</td><td>按位与且赋值运算符</td><td> C &= 2 等同于 C = C & 2</td></tr><tr><td>^=</td><td>按位异或且赋值运算符</td><td> C ^= 2 等同于 C = C ^ 2</td></tr><tr><td>|=</td><td>按位或且赋值运算符</td><td> C |= 2 等同于 C = C | 2</td></tr></tbody></table>

杂项运算符

<table><tbody><tr><th>运算符</th><th>描述</th><th>实例</th></tr><tr><td>sizeof()</td><td>返回变量的大小。</td><td>sizeof(a) 将返回 4，其中 a 是整数。</td></tr><tr><td>&</td><td>返回变量的地址。</td><td>&a; 将给出变量的实际地址。</td></tr><tr><td>*</td><td>指向一个变量。</td><td>*a; 将指向一个变量。</td></tr><tr><td>? :</td><td>条件表达式</td><td>如果条件为真 ? 则值为 X : 否则值为 Y</td></tr></tbody></table>

C 中的运算符优先级

<table><tbody><tr><th>类别 </th><th>运算符 </th><th>结合性 </th></tr><tr><td>后缀 </td><td>() [] -> . ++ - -  </td><td>从左到右 </td></tr><tr><td>一元 </td><td>+ - ! ~ ++ - - (type)* & sizeof </td><td>从右到左 </td></tr><tr><td>乘除 </td><td>* / % </td><td>从左到右 </td></tr><tr><td>加减 </td><td>+ - </td><td>从左到右 </td></tr><tr><td>移位 </td><td><< >> </td><td>从左到右 </td></tr><tr><td>关系 </td><td>< <= > >= </td><td>从左到右 </td></tr><tr><td>相等 </td><td>== != </td><td>从左到右 </td></tr><tr><td>位与 AND </td><td>& </td><td>从左到右 </td></tr><tr><td>位异或 XOR </td><td>^ </td><td>从左到右 </td></tr><tr><td>位或 OR </td><td>| </td><td>从左到右 </td></tr><tr><td>逻辑与 AND </td><td>&& </td><td>从左到右 </td></tr><tr><td>逻辑或 OR </td><td>|| </td><td>从左到右 </td></tr><tr><td>条件 </td><td>?: </td><td>从右到左 </td></tr><tr><td>赋值 </td><td>= += -= *= /= %=>>= <<= &= ^= |= </td><td>从右到左 </td></tr><tr><td>逗号 </td><td>, </td><td>从左到右 </td></tr></tbody></table>

C 判断

<table><tbody><tr><th>语句</th><th>描述</th></tr><tr><td><a title="C 中的 if 语句" target="_blank">if 语句</a></td><td>一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。</td></tr><tr><td><a title="C 中的 if...else 语句" target="_blank">if...else 语句</a></td><td>一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。</td></tr><tr><td><a title="C 中的嵌套 if 语句" target="_blank">嵌套 if 语句</a></td><td>您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。</td></tr><tr><td><a title="C 中的 switch 语句" target="_blank">switch 语句</a></td><td>一个 switch 语句允许测试一个变量等于多个值时的情况。</td></tr><tr><td><a title="C 中的嵌套 switch 语句" target="_blank">嵌套 switch 语句</a></td><td>您可以在一个 switch 语句内使用另一个 switch 语句。</td></tr></tbody></table>

? : 运算符(三元运算符)

C 循环

循环类型

<table><tbody><tr><th>循环类型</th><th>描述</th></tr><tr><td><a title="C 中的 while 循环">while 循环</a></td><td>当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。</td></tr><tr><td><a original-title="C 中的 for 循环">for 循环</a></td><td>多次执行一个语句序列，简化管理循环变量的代码。</td></tr><tr><td><a title="C 中的 do...while 循环">do...while 循环</a></td><td>除了它是在循环主体结尾测试条件外，其他与 while 语句类似。</td></tr><tr><td><a title="C 中的嵌套循环">嵌套循环</a></td><td>您可以在 while、for 或 do..while 循环内使用一个或多个循环。</td></tr></tbody></table>

循环控制语句

<table><tbody><tr><th>控制语句</th><th>描述</th></tr><tr><td><a title="C 中的 break 语句">break 语句</a></td><td>终止循环或 switch 语句，程序流将继续执行紧接着循环或 switch 的下一条语句。</td></tr><tr><td><a title="C 中的 continue 语句">continue 语句</a></td><td>告诉一个循环体立刻停止本次循环迭代，重新开始下次循环迭代。</td></tr><tr><td><a title="C 中的 goto 语句">goto 语句</a></td><td>将控制转移到被标记的语句。但是不建议在程序中使用 goto 语句。</td></tr></tbody></table>

无限循环

当条件表达式不存在时，它被假设为真。您也可以设置一个初始值和增量表达式，但是一般情况下，C 程序员偏向于使用 for(;;) 结构来表示一个无限循环。 注意：您可以按 Ctrl + C 键终止一个无限循环。

C 函数

定义函数

在 C 语言中，函数由一个函数头和一个函数主体组成。下面列出一个函数的所有组成部分： 返回类型：一个函数可以返回一个值。return_type 是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字 void。 函数名称：这是函数的实际名称。函数名和参数列表一起构成了函数签名。 参数：参数就像是占位符。当函数被调用时，您向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。 函数主体：函数主体包含一组定义函数执行任务的语句。

函数参数

<table><tbody><tr><th>调用类型</th><th>描述</th></tr><tr><td><a title="C 中传值方式调用函数">传值调用</a></td><td>该方法把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数不会影响实际参数。</td></tr><tr><td><a title="C 中引用方式调用函数">引用调用</a></td><td>通过指针传递方式，形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作。</td></tr></tbody></table>

C 作用域规则

C 语言中有三个地方可以声明变量

在函数或块内部的局部变量 在所有函数外部的全局变量 在形式参数的函数参数定义中

局部变量

在某个函数或块的内部声明的变量称为局部变量。它们只能被该函数或该代码块内部的语句使用。局部变量在函数外部是不可知的。下面是使用局部变量的实例。在这里，所有的变量 a、b 和 c 是 main() 函数的局部变量。

全局变量

全局变量是定义在函数外部，通常是在程序的顶部。全局变量在整个程序生命周期内都是有效的，在任意的函数内部能访问全局变量。

形式参数

函数的参数，形式参数，被当作该函数内的局部变量，它们会优先覆盖全局变量。

初始化局部变量和全局变量

当局部变量被定义时，系统不会对其初始化，您必须自行对其初始化。定义全局变量时，系统会自动对其初始化，如下所示：

<table><tbody><tr><th>数据类型</th><th>初始化默认值</th></tr><tr><td> int </td><td> 0 </td></tr><tr><td> char </td><td> '\0' </td></tr><tr><td> float </td><td> 0 </td></tr><tr><td> double </td><td> 0 </td></tr><tr><td> pointer </td><td> NULL </td></tr></tbody></table>

正确地初始化变量是一个良好的编程习惯，否则有时候程序可能会产生意想不到的结果，因为未初始化的变量会导致一些在内存位置中已经可用的垃圾值。

C 数组

C 语言支持数组数据结构，它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。

声明数组

type arrayName [ arraySize ];

例如：double balance[10];

初始化数组

访问数组元素

C 中数组详解

<table><tbody><tr><th>概念</th><th>描述</th></tr><tr><td><a title="C 中的多维数组">多维数组</a></td><td>C 支持多维数组。多维数组最简单的形式是二维数组。</td></tr><tr><td><a title="C 中传递数组给函数作为参数">传递数组给函数</a></td><td>您可以通过指定不带索引的数组名称来给函数传递一个指向数组的指针。</td></tr><tr><td><a title="C 中从函数返回数组">从函数返回数组</a></td><td>C 允许从函数返回数组。</td></tr><tr><td><a title="C 中指向数组的指针">指向数组的指针</a></td><td>您可以通过指定不带索引的数组名称来生成一个指向数组中第一个元素的指针。</td></tr></tbody></table>

C 指针

#include <stdio.h> int main () {     int var = 20; /* 实际变量的声明此时的 VAR 这个变量是存在某个地址的，地址对应某个内存单元，该单元中存储了数据20 */     int *ip; /* 指针变量的声明定义了一个指针即一个内存单元的地址变量 */     ip = &var; /* 在指针变量中存储 var 的地址就是将地址值赋值给指针这个变量*/     /* 在指针变量中存储的地址利用&符号直接输出了var所存储的数据的内存单元的地址*/     printf("Address of var variable: %p\n", &var );          /* 在指针变量中存储的地址 ip代表的是这个赋值到的地址的值所以输出的是地址值 */     printf("Address stored in ip variable: %p\n", ip );          /* 使用指针访问值 *ip代表的是定义到这个内存单元之后，内存单元中所存储的数据的值也就是将20赋值给var中20这个值 */     printf("Value of *ip variable: %d\n", *ip );     return 0; }

C 指针详解

<table><tbody><tr><th>概念</th><th>描述</th></tr><tr><td><a original-title="指针的算术运算">指针的算术运算</a></td><td>可以对指针进行四种算术运算：++、--、+、-</td></tr><tr><td><a original-title="指针数组">指针数组</a></td><td>可以定义用来存储指针的数组。</td></tr><tr><td><a title="指向指针的指针">指向指针的指针</a></td><td>C 允许指向指针的指针。</td></tr><tr><td><a title="传递指针给函数">传递指针给函数</a></td><td>通过引用或地址传递参数，使传递的参数在调用函数中被改变。</td></tr><tr><td><a title="从函数返回指针">从函数返回指针</a></td><td>C 允许函数返回指针到局部变量、静态变量和动态内存分配。</td></tr></tbody></table>

C 函数指针与回调函数

函数指针

#include <stdio.h>   int max(int x, int y) {     return x > y ? x : y; }   int main(void) {     /* p 是函数指针 */     int (* p)(int, int) = & max; // &可以省略     int a, b, c, d;       printf("请输入三个数字:");     scanf("%d %d %d", & a, & b, & c);       /* 与直接调用函数等价，d = max(max(a, b), c) */     d = p(p(a, b), c);       printf("最大的数字是: %d\n", d);       return 0; }

回调函数

函数指针变量可以作为某个函数的参数来使用的，回调函数就是一个通过函数指针调用的函数。

你到一个商店买东西，刚好你要的东西没有货，于是你在店员那里留下了你的电话，过了几天店里有货了，店员就打了你的电话，然后你接到电话后就到店里去取了货。在这个例子里，你的电话号码就叫回调函数，你把电话留给店员就叫登记回调函数，店里后来有货了叫做触发了回调关联的事件，店员给你打电话叫做调用回调函数，你到店里去取货叫做响应回调事件。

实例中 populate_array 函数定义了三个参数，其中第三个参数是函数的指针，通过该函数来设置数组的值。 实例中我们定义了回调函数 getNextRandomValue，它返回一个随机值，它作为一个函数指针传递给 populate_array 函数。 populate_array 将调用 10 次回调函数，并将回调函数的返回值赋值给数组。 #include <stdlib.h>  #include <stdio.h>   // 回调函数 void populate_array(int *array, size_t arraySize, int (*getNextValue)(void)) {     for (size_t i=0; i<arraySize; i++)         array[i] = getNextValue(); }   // 获取随机值 int getNextRandomValue(void) {     return rand(); }   int main(void) {     int myarray[10];     populate_array(myarray, 10, getNextRandomValue);     for(int i = 0; i < 10; i++) {         printf("%d ", myarray[i]);     }     printf("\n");     return 0; }

C 字符串

<table><tbody><tr><th>序号</th><th>函数 & 目的</th></tr><tr><td>1</td><td>strcpy(s1, s2); 复制字符串 s2 到字符串 s1。</td></tr><tr><td>2</td><td>strcat(s1, s2); 连接字符串 s2 到字符串 s1 的末尾。</td></tr><tr><td>3</td><td>strlen(s1); 返回字符串 s1 的长度。</td></tr><tr><td>4</td><td>strcmp(s1, s2); 如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回小于 0；如果 s1>s2 则返回大于 0。</td></tr><tr><td>5</td><td>strchr(s1, ch); 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。</td></tr><tr><td>6</td><td>strstr(s1, s2); 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。</td></tr></tbody></table>

C 结构体

C 数组允许定义可存储相同类型数据项的变量，结构是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。

#include <stdio.h> #include <string.h>   struct Books {    char  title[50];    char  author[50];    char  subject[100];    int   book_id; };   /* 函数声明 */ void printBook( struct Books *book ); int main( ) {    struct Books Book1;        /* 声明 Book1，类型为 Books */    struct Books Book2;        /* 声明 Book2，类型为 Books */      /* Book1 详述 */    strcpy( Book1.title, "C Programming");    strcpy( Book1.author, "Nuha Ali");    strcpy( Book1.subject, "C Programming Tutorial");    Book1.book_id = 6495407;      /* Book2 详述 */    strcpy( Book2.title, "Telecom Billing");    strcpy( Book2.author, "Zara Ali");    strcpy( Book2.subject, "Telecom Billing Tutorial");    Book2.book_id = 6495700;      /* 输出 Book1 信息 */    printBook0( Book1 );      /* 通过传 Book2 的地址来输出 Book2 信息指针 */    printBook( &Book2 );      return 0; } void printBook0( struct Books book ) {    printf( "Book title : %s\n", book.title);    printf( "Book author : %s\n", book.author);    printf( "Book subject : %s\n", book.subject);    printf( "Book book_id : %d\n", book.book_id); } void printBook( struct Books *book ) {    printf( "Book title : %s\n", book->title);    printf( "Book author : %s\n", book->author);    printf( "Book subject : %s\n", book->subject);    printf( "Book book_id : %d\n", book->book_id); }

位域

有些信息在存储时，并不需要占用一个完整的字节，而只需占几个或一个二进制位。例如在存放一个开关量时，只有 0 和 1 两种状态，用 1 位二进位即可。为了节省存储空间，并使处理简便，C 语言又提供了一种数据结构，称为"位域"或"位段"。

main(){     struct bs{         unsigned a:1;         unsigned b:3;         unsigned c:4;     } bit,*pbit;     bit.a=1;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */     bit.b=7;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */     bit.c=15;    /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */     printf("%d,%d,%d\n",bit.a,bit.b,bit.c);    /* 以整型量格式输出三个域的内容 */     pbit=&bit;    /* 把位域变量 bit 的地址送给指针变量 pbit */     pbit->a=0;    /* 用指针方式给位域 a 重新赋值，赋为 0 */     pbit->b&=3;    /* 使用了复合的位运算符 "&="，相当于：pbit->b=pbit->b&3，位域 b 中原有值为 7，与 3 作按位与运算的结果为 3（111&011=011，十进制值为 3） */     pbit->c|=1;    /* 使用了复合位运算符"|="，相当于：pbit->c=pbit->c|1，其结果为 15 */     printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c);    /* 用指针方式输出了这三个域的值 */ }

C 共用体

共用体是一种特殊的数据类型，允许您在相同的内存位置存储不同的数据类型。您可以定义一个带有多成员的共用体，但是任何时候只能有一个成员带有值。共用体提供了一种使用相同的内存位置的有效方式。

共用体应用场景

通信中的数据包会用到共用体:因为不知道对方会发一个什么包过来，用共用体的话就很简单了，定义几种格式的包，收到包之后就可以直接根据包的格式取出数据。

结构体与共用体

结构体变量所占内存长度是各成员占的内存长度之和。每个成员分别占有其自己的内存单元。 共用体变量所占的内存长度等于最长的成员变量的长度

C 位域

位域声明

在结构内声明位域的形式如下：<pre>struct { type [member_name] : width ; };</pre>

<table><tbody><tr><th>元素</th><th>描述</th></tr><tr><td>type</td><td>整数类型，决定了如何解释位域的值。类型可以是整型、有符号整型、无符号整型。</td></tr><tr><td>member_name</td><td>位域的名称。</td></tr><tr><td>width</td><td>位域中位的数量。宽度必须小于或等于指定类型的位宽度。</td></tr></tbody></table>

如果程序的结构中包含多个开关量，只有 TRUE/FALSE 变量，如下：<pre>struct { unsigned int widthValidated; unsigned int heightValidated; } status;</pre>这种结构需要 8 字节的内存空间，但在实际上，在每个变量中，我们只存储 0 或 1。在这种情况下，C 语言提供了一种更好的利用内存空间的方式。如果您在结构内使用这样的变量，您可以定义变量的宽度来告诉编译器，您将只使用这些字节。例如，上面的结构可以重写成：<pre>struct { unsigned int widthValidated : 1; unsigned int heightValidated : 1; } status;</pre>

C typedef

typedef为类型取一个新的名字。如：typedef unsigned char BYTE;

typedef vs #define

#define 是 C 指令，用于为各种数据类型定义别名，与 typedef 类似，但是它们有以下几点不同： typedef 仅限于为类型定义符号名称，#define 不仅可以为类型定义别名，也能为数值定义别名，比如您可以定义 1 为 ONE。 typedef 是由编译器执行解释的，#define 语句是由预编译器进行处理的。

C 输入 & 输出

C 语言中的 I/O (输入/输出) 通常使用 printf() 和 scanf() 两个函数。

printf("Number = %d", testInteger); 在 printf() 函数的引号中使用 "%d" (整型) 来匹配整型变量 testInteger 并输出到屏幕。

getchar() & putchar() 函数

int getchar(void) 函数从屏幕读取下一个可用的字符，并把它返回为一个整数。这个函数在同一个时间内只会读取一个单一的字符。您可以在循环内使用这个方法，以便从屏幕上读取多个字符。 int putchar(int c) 函数把字符输出到屏幕上，并返回相同的字符。这个函数在同一个时间内只会输出一个单一的字符。您可以在循环内使用这个方法，以便在屏幕上输出多个字符。

gets() & puts() 函数

char *gets(char *s) 函数从 stdin 读取一行到 s 所指向的缓冲区，直到一个终止符或 EOF。 int puts(const char *s) 函数把字符串 s 和一个尾随的换行符写入到 stdout。

scanf() 和 printf() 函数

int scanf(const char *format, ...) 函数从标准输入流 stdin 读取输入，并根据提供的 format 来浏览输入。 int printf(const char *format, ...) 函数把输出写入到标准输出流 stdout ，并根据提供的格式产生输出。 format 可以是一个简单的常量字符串，但是您可以分别指定 %s、%d、%c、%f 等来输出或读取字符串、整数、字符或浮点数。