一、 引言

C 语言是一种功能强大、灵活多变的编译型语言，广泛应用于系统编程、嵌入式开发等领域。运算与选择结构是 C 语言编程的基础，它们构成了程序逻辑的核心。

C 语言是一种编译型语言，从创建 C 程序到运行出最终结果，包括：编辑、编译、链接和运行四个过程。

1. 程序设计语言与自然语言的对比

• 自然语言：
  • 种类：世界上有5651种语言，汉语、英语是主流。
  • 特点：
    • 汉语：象形文字，二维空间表达（上下左右），笔画组成一个字，二义性较强，需要标点符号分割句子。
    • 英语：拼音文字，一维空间表达（从左到右），句与句之间用标点符号分割，单词含义人为定义。
• 程序设计语言：
  • 目的：表达机械化可执行的算法。
  • 范围：程序设计语言可以描述的范围，远远小于自然语言的描述范畴。
  • 特点：上下文无关，机器仅关注当前语句的语义并按此执行。需要严格的词法、语法要求。

2. 程序设计语言的基本要素

• 基本语句：
  • 赋值语句：将表达式的计算结果放到某个变量里。
  • 判断（选择）语句：根据表达式的真假决定执行后续的哪个语句。
  • 循环语句：根据表达式的真假决定是否循环执行某些语句。

3. 程序设计过程

• 转换：把自然语言描述的算法转变为程序语言的语义、语法和词法，让机器能够无歧义地解释和执行。
• 程序员需知：
  • 理解自然语言与程序语言的差别。
  • 熟悉所用编程语言的词法、语法和语义。
  • 使用程序语言的词法、语法和语义表达自然语言的思想。
• 辅助工具：流程图，用于图形化表达算法，更好的完成自然语言到程序语言的转换。

4. 保留字与标识符

• 保留字：
  • 定义：编程时不能用于其他用途的字，如C语言中的int、float等。
  • 作用：防止误用，导致程序出错。
  • C语言中的保留字（也称为关键字）是语言本身定义的一些具有特殊意义的标识符，不能用作变量名、函数名或任何其他标识符。以下是C语言标准（C99和C11）中的保留字列表：

注意：

• _Bool、_Complex、_Imaginary、_Generic、_Noreturn、_Static_assert和_Thread_local这些保留字在C90标准中并不存在，是C99或C11标准中引入的。
• 在实际编程中，通常避免使用带有下划线前缀的标识符，因为C标准库和编译器可能会使用这些名称。

这个列表应该涵盖了C语言标准中的所有保留字。然而，不同的编译器可能会引入额外的保留字或关键字，所以在使用特定编译器时，最好查阅其文档以获取完整的信息。

• 标识符：
  • 定义：程序员在编程时自定义的符号，如变量名、常数名、函数名等。
  • 命名规则：
    • 一般用英文字母开头，后面可以跟字母、数字和下划线。
    • 长度一般在30个字符以下。
    • 要有含义，便于记忆和阅读，如int sum;比int a;更易于理解。
    • C语言中，大写字母和小写字母是有差别的，如int SumofStudent;不同于int sumofstudent;。
    • 可以用下划线“_”开始，但通常用作系统库函数的名称，因此变量和函数名尽可能避免使用。
    • 不能与保留字冲突，如不能使用int作为变量名。
    • 不要与常用的库函数中的函数名称冲突，如不要使用printf作为变量名。
• 示例：
  • 合法的标识符：month
  • 非法的标识符：5xy（以数字开头），int（保留字），your name（包含空格）

5. 数据类型、常量和变量

• 数据类型：定义变量时，要指定其数据类型，如int、double等。机器会根据数据类型为变量分配相应的地址和空间。
• 常量：程序中其值不能改变的量，编译系统不会为常量分配存储空间。常量通常用于给变量赋值，如#define PI 3.14定义了一个符号常量PI。
• 示例代码：

#include "stdio.h"
#define PI 3.14
void main() {
    double r, circum, area; // 定义3个双精度变量
    r = 1.0;
    circum = 2 * PI * r; // 计算圆的周长
    area = PI * r * r; // 计算圆的面积
    printf("circum=%f, area=%f\n", circum, area);
}

• 说明：

  • #define PI 3.14是符号常量的定义，属于编译预处理命令。
  • void main()是主函数的定义，程序从这里开始执行。
  • double r, circum, area;定义了三个双精度变量。
  • 接下来的几行计算了圆的周长和面积，并输出结果。

二、 赋值与运算

1. 语句与表达式

C 程序由若干个函数构成，现阶段涉及的程序只包含 main()函数；
函数由语句序列构成，语句完成具体的操作。
语句按其作用和形式分为：

• 声明语句 — 非执行语句
• 表达式语句 — 表达式；
• 控制语句 — 控制程序执行流程
• 复合语句 — { }
• 空语句 — ；

示例代码：

#include <stdio.h>

int main() {
    double a, b, x;

    // 输入a和b的值
    printf("请输入一元一次方程的系数a和常数项b（用空格分隔）: ");
    scanf("%lf %lf", &a, &b);

    // 检查a是否为零，避免除以零的错误
    if (a == 0) {
        printf("输入错误，a不能为0，否则为非法一元一次方程。\n");
        }
    } else {
        // 计算x的值
        x = -b / a;

        // 输出结果
        printf("方程的解是: x = %.2lf\n", x);
    }

    return 0;
}

#include <stdio.h>
#include <math.h>

int main() {
    double a, b, c, x1, x2, Delta;

    // 输入部分
    printf("请输入一元二次方程ax^2+bx+c=0的三个系数：\n");
    printf("请输入系数 a = \t");
    scanf("%lf", &a);
    printf("请输入系数 b = \t");
    scanf("%lf", &b);
    printf("请输入系数 c = \t");
    scanf("%lf", &c);

    Delta = b * b - 4 * a * c;

    printf("a=%.2f,\nb=%.2f,\nc=%.2f\n", a, b, c);

    if (fabs(a) > 1e-9) // 即a!=0,使用一个小数来避免浮点数比较的问题
    { 
        if (Delta < 0) 
        {
            printf("方程有没有实根！\n");
        } 
        else if (Delta == 0) 
        {
            x1 = x2 = -b / (2 * a);
            printf("方程有两个相等的根:\nx1 = x2 = %.2f\n", x1);
        } 
        else 
        {
            x1 = (-b + sqrt(Delta)) / (2 * a);
            x2 = (-b - sqrt(Delta)) / (2 * a);
            printf("方程的两个实根分别为\nx1 = %.2f,\nx2 = %.2f\n", x1, x2);
        }
    } 
    else if (fabs(b) > 1e-9) // 即b!= 0 ，使用小数来避免浮点数比较的问题
    { 
        x1 = -c / b;
        printf("方程是一元一次方程，x1 = -c/b = %.2f\n", x1);
    } 
    else if (fabs(c) > 1e-9) // 即c!= 0 ，使用小数来避免浮点数比较的问题
    {
        printf("方程无解，因为0 * x^2 + 0 * x+%.2f=0不成立。\n", c);
    } 
    else 
    {
        printf("x可以是任意值，因为方程是0=0。\n");
    }

    return 0;
}

2. 运算符与表达式

算术运算符：

• 如：+、-、*、/、%，用于执行基本的数学运算。注意，整数除法结果向下取整，如 5/2 结果为 2。

关系运算符：

• 如：=、<=、==、!=，用于比较两个操作数的值，返回布尔值（真或假）。

• =、<=、==、!=中间是没有空格的
• =、<=、!=不能写作数学形式 ≥、≤、≠
• ==是相等关系比较运算符，=是赋值运算符。n == 0; 与 n = 0;意义不同，也不相等。

逻辑运算符：

• &&（逻辑与）、||（逻辑或）、!（逻辑非），用于执行逻辑运算。逻辑运算符具有短路特性，即当逻辑表达式的值已经确定时，不会继续计算未涉及的操作数。

| a | b | a&&b | a | | b | !a |
| :---: | :---: | :---: | :---: | :---: |
| 0（假） | 0（假） | 0（假） | 0（假） | 1（真） |
| 0（假） | 1（真） | 0（假） | 1（真） | 1（真） |
| 1（真） | 0（假） | 0（假） | 1（真） | 0（假） |
| 1（真） | 1（真） | 1（真） | 1（真） | 0（假） |

• 注：整数为 0，表示逻辑量为假，否则为真，即，非零就为真。这是 C 的优点，也是缺点！

与运算（AND） ：

• 符号：& 或 ∧
• 定义：当且仅当两个输入都为 True 时，输出为 True。
• 
• 示例：
  • True AND True = True
  • True AND False = False
  • False AND True = False
  • False AND False = False

或运算（OR） ：

• 符号：| 或 ∨
• 定义：只要有一个输入为 True，输出就为 True。
• 
• 示例：
  • True OR True = True
  • True OR False = True
  • False OR True = True
  • False OR False = False

非运算（NOT） ：

• 符号：¬ 或 !
• 定义：将输入取反，即如果输入为 True，输出为 False；如果输入为 False，输出为 True。
• 
• 示例：
  • NOT True = False
  • NOT False = True

异或运算（XOR） ：

• 符号：^ 或 ⊕
• 定义：当且仅当两个输入不同（一个为 True，另一个为 False）时，输出为 True。
• 
• 示例：
  • True XOR True = False
  • True XOR False = True
  • False XOR True = True
  • False XOR False = False

同或运算（XNOR） ：

• 符号：⊙ 或 ≡（在一些文献中，XNOR 也可以表示为 !XOR 或 XOR NOT）
• 定义：当且仅当两个输入相同时（都为 True 或都为 False），输出为 True。
• 
• 示例：
  • True XNOR True = True
  • True XNOR False = False
  • False XNOR True = False
  • False XNOR False = True

这些逻辑运算在计算机科学、电子工程和数学等领域有着广泛的应用。例如，在计算机编程中，它们用于控制结构（如条件语句和循环）、数据验证和位操作等。在数字电路中，它们通过逻辑门（如 AND 门、OR 门、NOT 门等）实现，以构建复杂的电路系统。

逻辑运算体系

逻辑运算也遵循一定的运算规律。
例如：
结合律(Associativity)：
x | ( y | z ) = ( x | y ) | z ，以及 x & ( y & z ) = ( x & y ) & z
交换律(Commutativity)：
x | y = y | x ，以及 x & y = y & x
分配律(Distributivity)：
x & ( y | z ) = ( x & y ) | ( x & z )
恒等律(Identity):
x | 0 = x ，x & 1 = x
归零律(Annihilator)：
x & 0= 0

逻辑运算最小体系

第四个（异或）定义是多余的，可以用前三个定义，推导出来，例如：

1. A⊕B= (A|B)\&amp;(\sim A | \sim B)
2. A⊕B= \sim(\sim A\&amp;\sim B)\&amp;\sim (A \&amp; B)
3. A⊕B= (A\&amp;\sim B)|(\sim A \&amp; B)

进一步，与、或、非是否可以归纳为两个运算呢？
例如，或运算可以归纳为非和与两种运算，

• 事实上， A|B= \sim (\sim A \&amp; \sim B) 。
• 同样， A\&amp;B = \sim (\sim A|\sim B) 。

逻辑计算中只需要两个符号，（非、与），或（非、或），这是逻辑运算的最小体系

证明：逻辑计算中只需要两个运算符

为了证明在逻辑计算中只需要两个运算符（例如“非”和“与”，或者“非”和“或”）就能完成所有逻辑运算，我们需要展示如何使用这两个运算符来模拟其他逻辑运算符（如“或”、“异或”等）。

• 使用“非”和“与”

1. 模拟“或”运算： 给定两个变量A和B，要计算A或B（A OR B），我们可以使用德摩根定律（De Morgan's Laws）的逆用。德摩根定律告诉我们：
   \neg(A \land B) = \neg A \lor \neg B 但我们需要A OR B，所以我们可以稍作变换：
   A \lor B = \neg(\neg A \land \neg B) 这表示，我们可以通过对A和B取非，然后做与运算，再对结果取非来得到A或B。
2. 模拟“异或”运算： 异或（XOR）运算可以通过与、或、非的组合来定义： A \oplus B = (A \land \neg B) \lor (\neg A \land B) 但既然我们只能用“非”和“与”，我们可以进一步转换：
   A \oplus B = \neg((\neg A \land \neg B) \lor (A \land B)) 这里，我们先计算A和B同时为假或同时为真的情况，然后对这个结果取非。

• 使用“非”和“或”

1. 模拟“与”运算： 类似地，我们可以使用德摩根定律来模拟与运算：
   A \land B = \neg(\neg A \lor \neg B)
2. 模拟“异或”运算： 直接使用之前的异或表达式，但注意到它本质上已经包含了“与”和“或”，不过我们可以将其中的“与”用“非”和“或”来替换（如上所述，但直接转换稍显复杂）。更直接的方法是，利用异或的另一种等价表达式： A \oplus B = (A \lor B) \land \neg(A \land B) 这里，我们先计算A或B，然后计算A与B，对后者取非，最后将两者做与运算。

• 能否只用一个运算符来表达？

不能只用一个运算符来完成所有逻辑运算。原因是逻辑运算包括基本的真值表操作，如与、或、非，它们各自具有不同的真值表输出。没有足够的信息（即只有一个运算符）来区分这些不同的操作。例如，“非”运算只能反转一个值的真假，而“与”和“或”则涉及两个值的组合。因此，至少需要两个运算符来模拟所有基本的逻辑运算。

赋值符：

• 如：=，以及复合赋值运算符如 +=、-=、*=、/=、%= 等。赋值表达式: 变量 = 表达式赋值运算符左边（称为左值）必须是指向内存单元的变量(或指针），不能是常量或值表达式；

赋值运算符右边（称为右值）是合法的 C 语言表达式。图示

• 除了直接书写十进制数，也可以在表达式中直接写二、八、十六进制数。例如：

// C 语言中进制的书面表达
#include <stdio.h>
int main()
{
    int x = 0101;//八进制(octal literal--用0开头)
    int y=5; //十进制(直接写)
    int w = 0x10; //十六进制(Hexdciaml---用0x开头)
    int z = 0b010;//而进制(Binary---用0b开头)

    printf("八进制的0101 = 十进制的： %d\n", x);
    printf("八进制的0101+十进制5 = 十进制的：%d\n", y+x);
    printf("十六进制0x10 = 十进制的：%d\n", w);
    printf("二进制0b010 = 十进制的：%d\n", z);

    printf("按16进制格式打印(八进制0101): %X\n", x);

    return 0;
}

复合赋值运算符：

• 如：＋＝，－＝，*＝，／＝，％＝，<<＝，>>＝，＆＝，∧＝，|＝

  • 变量 op= 表达式 等价于：变量 = 变量 op (表达式)
    例如：a += b+3 等价于：a = a+(b+3)

位运算符：

• 程序中的任何数据在计算机内存中都是以二进制的形式储存的。 位运算就是直接对整型数（char、short、int、long)在内存的二进制位逐位进行测试、置位或移位操作。如：<<（左移）、>>（右移）、&（按位与）、|（按位或）、^（按位异或）、~（按位取反），直接对整型数的二进制位进行操作。运算效率更高：例如，加密/解密

• 位运算
  • 左移运算： a << b 将 a 的各二进位全部左移 b 位，高位丢弃，低位补 0，其值相当于乘 2^b。b 非负整数，且不超过 a 升格后的二进制位数
  • 状态字译码： 标志位左移到最高位，再与最高位为 1 的 mask 做“与”运算，结果非 0 则标志位为 1。
  • 整数快速乘法运算： 左移一位等效于乘 2。
    
  • 右移运算：a >> b 将 a 的各二进位全部右移 b 位数，低位丢弃，高位填充符号位的值。其值相当于除 2^b（取整）移位不同于循环，从一端移出的位并不送回到另一端去，移去的位永远丢失了，同时在另一端补符号位的值。例如：a=-100, b=-25

int a=-100,b;
b=a>>2;
printf(“a=%d,b=%d\n”,a,b);

• 位运算的用途

  1. 设备状态
  • 位：用来保存设备的状态、操作权限等。计算机中常用特定的状态字管理和控制各种设备。
  • 状态测试：读取状态字 status 的某标志位 mask 的值，进行判定。 status & mask 结果为 0 则该位为 0，非 0 则该位为 1。
  • 状态设置：将某位清 0，status & ~mask；将某位置 1，status | mask
  2. 简单加密解密
  • 原文与密钥异或后得到密文，密文与密钥异或后得到原文。
  3. 高效乘、除运算
  • 左移 1 位乘 2，右移 1 位除 2

运算优先级与结合性

• 括号 () 具有最高优先级，用于改变运算顺序。
• 逗号运算符 , 优先级最低，用于连接两个表达式，并返回最后一个表达式的值。
• 运算符的结合性决定了当运算符具有相同优先级时，操作的顺序。例如，算术运算符和赋值运算符都是左结合的。
• 以下是运算优先级表格，包含了 C 语言运算符的名称、含义、说明、优先级、结合性，以及每个运算符的示例：

• 这些示例展示了每个运算符在 C 语言中的典型用法。请注意，实际代码中的变量名（如 a, b, c 等）和表达式可能会根据上下文而有所不同。

4. 数据类型及转换

• 在 C 语言中，数据类型分为基本数据类型、构造数据类型、枚举类型和指针类型等几大类。以下是 C 语言中一些常见的基本数据类型及其描述，以及数据类型转换的说明。

基本数据类型表格

• 以下是一个关于C语言中常见转义序列及其意义的表格：

注意：

1. \ddd 和 \xhh 中的 d 和 h 分别代表八进制和十六进制数字，它们可以是0-7和0-9, a-f, A-F之间的字符。在实际使用时，需要替换为具体的数字。
2. 在现代C编译器中，问号字符（?）通常不需要转义，但在某些旧版本的编译器或特定上下文中，可能需要使用 \? 来避免歧义。
3. 空字符（\0）在C语言中用于表示字符串的结束，它不输出任何字符，但在内存中占用一个字节的空间，其ASCII码值为0。

数据类型转换

• 在 C 语言中，数据类型转换分为显式转换（强制类型转换）和隐式转换（自动类型转换）。

显式转换（强制类型转换）

• 显式转换使用类型转换运算符，将一种数据类型强制转换为另一种数据类型。语法如下：

(目标类型) 变量或表达式;

示例：

int a = 5;
float b = (float)a; // 将int类型变量a强制转换为float类型，赋值给float类型变量b

隐式转换（自动类型转换）

• 隐式转换发生在赋值、算术运算或比较运算中，当涉及不同数据类型的值时，编译器会自动将它们转换为一种共同类型。通常，转换规则遵循“数据类型的提升”（Promotion）规则即“低位向高位转换”，例如：

示例：

int a = 5;
double b = a; // 自动将int类型变量a转换为double类型，赋值给double类型变量b

• 需要注意的是，隐式转换有时会导致数据丢失或精度下降，因此在使用时应谨慎，特别是当涉及不同大小的整数类型或浮点类型时。

总结

C 语言提供了丰富的数据类型，以支持各种编程需求。了解每种数据类型的特性和大小，以及掌握数据类型之间的转换规则，对于编写高效、健壮的 C 程序至关重要。

• 整数类型会提升到足够大的类型（例如，char 和 short 通常会被提升为 int），字符型数据在运算时会被视为整型数据。
• 整数与浮点数进行运算时，整数会转换为浮点数。
• float 类型在运算中会被提升为 double 类型。
• 在算术运算中，如果有 long double 参与，则所有其他浮点类型会被提升为 long double。

三、输入输出

输入输出点原理

1. 标准函数库

• C 语言通过标准输入输出函数库中的函数 printf() 和 scanf() 实现数据的输入输出。
• 对于求平方根，指数，对数、三角函数等数学运算，C 语言中有标准库函数实现计算功能。编程时只要在表达式中正确调用库函数即可。
• 调用系统标准库函数之前，通常要用预编译命令将函数所在头文件包含到源程序中。

#include <stdio.h> // 标准输入输出函数头文件

#include <math.h> // 数学函数头文件常用数学计算库函数：

• 求 n 的平方根： sqrt(n)
• 求指数 ab: pow(a, b)
• 求绝对值 |x|： fabs(x)
• 求 x 正弦值： sin(x)
• 随机整数： rand()

• 调用库函数时，函数名必须正确，参数的类型和个数必须与系统规定一致。其中函数名由系统提供，不同 C 编译系统提供的函数名可能有差异，使用时需查阅相关手册。

2. 常用格式字符**

• 在 C 语言中，格式化输入输出时，printf 和 scanf 函数使用格式字符来指定数据的显示和输入格式。以下是一个关于常用格式字符的表格，包括它们的宽度和精度修饰符。

常用格式字符表格

宽度和精度修饰符

希望这个表格能帮助你更好地理解和使用 C 语言中的格式化输入输出。

• 宽度修饰符：用于指定输出字符的最小宽度。通过在格式字符前加一个数字或使用 * 来指定。
  • 示例：printf("%5d", 42); // 输出 " 42"（前面填充空格）
  • 使用 * 时，可以通过一个额外的 int 参数指定宽度：printf("%*d", 5, 42); // 同样输出 " 42"
• 精度修饰符：用于指定浮点数的小数位数或字符串的最大字符数。通过在格式字符前加 . 和一个数字来指定。
  • 示例：printf("%.2f", 3.14159); // 输出 "3.14"
  • 对于字符串：printf("%.*s", 3, "Hello"); // 输出 "Hel"（最多 3 个字符）

3. 输出：printf()

• printf() 函数用于向输出设备（如显示器）输出数据，可以使用格式控制符指定输出格式。
  • 格式化输出 printf()函数：
  • printf 输出原理
  • 格式：printf(“格式控制字符串”,输出列表)
    • 格式控制字符串：由格式字符串和非格式字符串两部分组成
      格式字符串：% 开头的字符串，指定输出项的格式。
      非格式字符串：即普通字符，原样输出。
    • 输出列表：要输出的数据，可以是常量，变量或表达式，多个输出项直接用逗号隔开。

• %d格式符：以十进制的形式输出带符号整数 int

#include<stdio.h>
int main()
{
    int a=-10;
    double b=3.5;
    char c='A';
    printf("%d,%d,%d,%d,%d\n",10,a,c,3.5,b);
}

运行结果：
%d 格式输出字符型即输出其 ASCII 值
%d 格式输出实数型会出现错误。

* `%d`**格式符：以十进制的形式输出带符号整数 int**

#include<stdio.h>
int main()
{
    long long a1=9999999999;
    printf("%d,%ld,%lld",a1,a1,a1);
}

运行结果：
超出数据类型范围则出现“溢出”
%ld：用来输出 long 类型
%lld：用来输出 long long 类型

* `%f`**格式符：以小数形式输出单精度实数 float**

#include<stdio.h>
int main()
{
    float a1=1;
    double a2=1;
    printf("%f,%f,%f\n",a1/3,-3.78,2.345e2);
    printf("%lf,%lf,%lf\n",a2/3,-3.78,2.345e2);
}

运行结果:
%lf：用来输出 double 类型
%f 和 %lf 默认输出 6 位小数。

* `%f`**格式符：以小数形式输出单精度实数 float**

#include<stdio.h>
int main()
{
    float b1=3333333333.3333333;
    double b2=3333333333.3333333;
    printf("%f\n%lf\n",b1,b2);
}

运行结果：
float 有效位 7 位
double 有效位 15 位

• %c格式符：输出单个字符

#include<stdio.h>
int main()
{
    char c='0';
    printf("%d,%c",c,c);
}

运行结果：
字符型按 %d 输出即输出其 ASCII 码值

4. 输入：scanf()

• scanf() 函数用于从输入设备（如键盘）读取数据，并将其存储在指定的变量中。注意，scanf() 函数在读取字符或字符串时，需要特别注意缓冲区溢出和输入格式的问题。
• scanf 输入原理
• 格式化输入 scanf()函数
  • 格式：scanf(“格式控制字符串”,输入项地址列表)
    • 格式控制字符串：由格式字符串和非格式字符串两部分组成
      • 格式字符串：% 开头的字符串，指定输出项的格式。
      • 非格式字符串：即普通字符，原样输入。
    • 输入项地址列表：一个或多个变量的地址，以 & 开头的变量

#include<stdio.h>
int main()
{
    int a,b,c;
    scanf("%d%d%d",a,b,c); 
//	scanf("%d%d%d",&a,&b,&c);
    printf("%d,%d,%d",a,b,c);
}
// 程序编译没有问题，但执行会出现闪退，为什么？
// scanf函数中忘记&

• 注意事项一scanf 函数中忘记&为什么要用&? scanf 语句中是&a，而不是 a

&a 表达，是把输入的数存放到变量 a 地址代表的存储空间中

• 注意事项二使用空格或者回车符作为读入数据的分隔

#include<stdio.h>
int main()
{
    int a,b,c;
    scanf("%d%d%d",&a,&b,&c);
    printf("%d,%d,%d",a,b,c);
}

1.使用空格作为分隔

2.使用回车符作为分隔

• 注意事项三格式字符串中的非格式字符需要原样输入。对于 scanf 系列函数格式字符串：非格式字符要求用户输入时必须匹配这部分内容。

例如：

int num;
scanf("%d", &num);  // 正确用法

这里 %d 表示程序期待一个整数输入。用户只需输入数字即可，无需考虑其他字符。
如果格式字符串中包含非格式字符，则用户输入时也必须包括这些字符。
例如：

int num;
scanf("Number: %d", &num);  // 错误示例

在这种情况下，程序实际上等待用户键入 Number: 后跟一个整数。如果用户仅仅输入了数字，那么这次 scanf 调用可能不会成功读取数据。
注意事项使用 scanf 时尽量避免在格式字符串中加入额外的文字，因为这可能会导致输入处理上的困难。

• 注意事项四在按字符格式输入时候，会把空格或回车当做字符

#include<stdio.h>
int main()
{
    int a;
    char b;
    double c;
    scanf("%d%c%lf",&a,&b,&c);
    printf("a=%d,b=%c,c=%lf\n",a,b,c);
}

输入：123 A 4.5
输出：a=123,b= ,c=0.000000

输入：123A4.5
输出：a=123,b=A,c=4.500000

在 C 语言中使用 scanf 函数进行输入时，空格、制表符和回车（换行）通常被视为分隔符。这意味着当你使用 %c 格式说明符来读取单个字符时，这些空白字符会被当作有效输入处理。不过，scanf 的行为依赖于具体的格式字符串和输入方式。例子

char ch;
scanf("%c", &ch);

假设用户直接按下回车键，程序将把回车符（\n）存储到变量 ch 中。

char ch;
scanf(" %c", &ch);  // 注意前面有一个空格

这里开头的空格告诉 scanf 忽略任何数量的空白字符，然后读取下一个非空白字符。这样即使用户先按下了几个空格或者回车，接着输入了一个字符，该字符也会被正确读入。
注意事项

• 如果你使用 %c 来读取一个字符，那么它会读取下一个未被跳过的字符，包括空格、制表符或换行符。
  • 如果你想忽略掉前导的空白字符（如空格、制表符、换行符等），可以使用空格作为格式字符串的一部分，例如：
  • 当使用 %c 且不希望读入空白字符时，可以通过在 %c 之前添加额外的空白字符来实现。
  • 对于更复杂的输入处理，可能需要考虑使用 getchar() 函数逐字符读取，并手动过滤不需要的空白字符，或者使用 fgets() 读取整行输入后再进行处理。
  • 在处理包含空白字符的输入时要特别小心，因为这可能导致意外的结果，尤其是在连续调用 scanf 时。

4. 其他输入输出函数

要引入string.h头文件。
putchar( )	输出1个字符
puts( )		输出1个字符串
getchar()	输入1个字符，并回显
getch()		输入1个字符，不回显（头文件conio.h）
gets()		输入1个字符串，按回车结束

备注：

因个人习惯和能力所限，该文档内容若存在表述不合理或错误之处，请大家留言多多指正

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明