01-C 语言基础概念

1. 什么是 C 语言

C 是一种通用的编程语言，已有近 50 年的历史。 C 可以编写从操作系统（包括 Windows 和其他许多系统）到复杂的程序，如 Python 解释器、Git、Oracle 数据库等。

C 的功能性是设计出来的。它是一种低级别的语言，与机器的工作方式密切相关，同时也易于学习。

学习 C 语言，可以帮助大家更深入理解计算机底层的工作原理，如内存管理。

2. Hello World!

如同学习任何新语言一样，让我们从经典的 "Hello World！"程序开始：

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

//#include "stdio.h"  // 导入头文件、预编译文件、别人做好的
#include <stdio.h>
int main() {
//    body code
    printf("Hello, GaoTianqi.");  // 输出
    return 0;  // 程序正常结束，返回 0
}

现在，分析下上面的代码：

• #include <stdio.h> 引入头文件 stdio.h。为了使用 printf 函数，需要首先包括所需的文件，也称为头文件。
• int main() main() 函数是一个程序的执行入口。大括号{ }表示一个函数（也叫代码块）的开始和结束。大括号内的语句决定了该函数在执行时的作用。

2.1 探究 c include 的功能性

1. 首先，打开 Terminal。
2. 使用 cd 命令来切换到你的源代码所在的目录。
3. 使用 clang 命令来编译你的源代码。比如，如果你的源代码文件名是 main.c，你可以使用以下命令来编译：

clang -E main.c > test.i

• -E 参数会让 clang 只预处理源代码，并把结果输出到 test.i 文件中。

如果你是想要编译 C++ 程序，你可以把 clang 改成 clang++，其他步骤是一样的。

注意这只是预处理你的代码，并没有完成编译过程。如果你想要编译并执行你的代码，你需要更多的步骤。

2.2 printf 函数用来输出内容

#include <stdio.h>

int main() {
    // 输出内容
    printf("Hello, World!\n");
    // 返回 0，表示成功
    return 0;
}

#include <stdio.h>

int main() {
    // 输出内容
    printf("Hello, World!");
    printf("Hello, World!");
    // 返回 0，表示成功
    return 0;
}

// ---output---
Hello, World!Hello, World!

#include <stdio.h>

int main() {
    // 输出内容
    printf("Hello, World!\n");
    printf("Hello, World!\n");
    // 返回 0，表示成功
    return 0;
}

// ---output---
Hello, World!
Hello, World!

这里，我们把文本 "Hello World!"传给它。 转义字符\n（escape sequence）输出一个换行符。转义字符总是以反斜线 \ 开始。

分号;表示语句的结束。每个语句必须以分号;结束。

return 0; 语句则终止了 main() 函数，并返回数值0。数字0通常意味着我们的程序已经成功执行。任何其他数字都表示程序失败了。

2.3 练习

打印文本"Hi, everyone!"

3. 数据类型 Data Type

C 语言支持以下基本数据类型：

1. int: 整数，一个整数。
2. float: 浮点数，一个带有小数部分的数字。
3. double: 双精度浮点数。
4. char: 单字符。

每种类型所需的存储大小因平台而异。

C 语言有一个内置的 sizeof 操作符，可以返回特定数据类型的内存占用大小。 例如:

#include <stdio.h>

int main() {
    printf("int: %ld \n", sizeof(int));
    printf("float: %ld \n", sizeof(float));
    printf("double: %ld \n", sizeof(double));
    printf("char: %ld \n", sizeof(char));

    return 0;
}

#include <stdio.h>

int main() {
    // 输出 int 类型的字节大小
    printf("int: %ld \n", sizeof(int));
    // 输出 float 类型的字节大小
    printf("float: %ld \n", sizeof(float));
    // 输出 double 类型的字节大小
    printf("double: %ld \n", sizeof(double));
    // 输出 char 类型的字节大小
    printf("char: %ld \n", sizeof(char));

    return 0;
}
// 1 byte = 8 bit

程序输出显示每种数据类型的相应大小（字节）。

本程序中的 printf 语句有两个参数：

• 第1个参数是带有格式指定符（%ld）的字符串
• 第2个参数返回 sizeof 值。

在最后的输出中，%ld（用于长十进制）被第 2 个参数中的值取代。

练习： 下面哪一项是 C 语言中的正确的变量类型？「C」

A. int, double, char, boolean

B. int, bool, string

C. int, float, double, char

D. int, float, string, char

4. 变量 Variable

变量是内存中某块值的名称。

变量名（也称为标识符）必须以字母或下划线_开头，可以由字母、数字和下划线_字符组成。

不同语言中，变量的命名规则各不相同，但是使用小写字母和下划线来分隔单词是很常见的（snake_case）。

变量在使用前也必须声明为一种数据类型。

用赋值语句可以改变已声明的变量的值。 例如，下面的语句声明了一个整数变量 my_var，然后将其赋值为 42。

int my_var;
my_var = 42;

你也可以在一条语句中同时声明和初始化变量的量。

int my_var = 42;

snake_case 是一种命名约定，通常用于编程语言中的变量、函数或其他标识符的命名。这种命名方式的特点是所有的单词都是小写，并且单词之间用下划线（_）来分隔。

snake_case 得名于它的外观——单词之间的下划线看起来就像是蛇的弯曲身体。这种命名方式的优点是清晰易读，特别是对于由多个单词组成的名称。

以下是一些 snake_case 命名的例子：

• employee_name
• total_amount
• print_employee_details
• calculate_average_score

在一些编程语言和框架中，snake_case 是推荐或者必须的命名方式。例如，Python 和 Ruby 的社区通常推荐使用 snake_case 来命名变量和函数。在 SQL 语言中，snake_case 也是常见的命名方式。

然而，不同的编程语言、框架或项目可能会有不同的命名约定。在 JavaScript 或 Java 中，常见的命名方式是 camelCase，而在 C# 中，常见的命名方式是 PascalCase。选择哪种命名方式取决于你所使用的编程语言和项目的编码规范。

type variable_name;

int a;       // 声明一个整型变量a
float b;     // 声明一个浮点型变量b
char c;      // 声明一个字符型变量c

int a = 10;        // 声明并初始化整型变量a为10
float b = 3.14;    // 声明并初始化浮点型变量b为3.14
char c = 'z';      // 声明并初始化字符型变量c为'z'

int a, b, c;      // 声明多个整型变量a, b, c
float x, y, z;    // 声明多个浮点型变量x, y, z

int array[10];    // 声明一个有10个元素的整型数组

int *p;    // 声明一个整型指针p

int a = 10, b = 20, c = 30;

int array[3] = {10, 20, 30};

int a = 10, float b = 20.0;  // 错误！不可以在一行中声明不同类型的变量

让我们定义不同类型的变量，做一个简单的数学运算，并输出结果：

#include <stdio.h>

int main() {
    int a, b;               // 声明整型变量 a 和 b
    float salary = 56.23;   // 声明浮点型变量 salary 并赋值为 56.23
    char letter = 'Z';      // 声明字符型变量 letter 并赋值为 'Z'
    a = 8;                  // 将变量 a 赋值为 8
    b = 34;                 // 将变量 b 赋值为 34
    int c = a + b;            // 声明整型变量 c 并将 a 和 b 的和赋值给 c

    printf("%d \n", c);     // 打印变量 c 的值
    printf("%f \n", salary);    // 打印变量 salary 的值
    printf("%c \n", letter);    // 打印变量 letter 的值

    return 0;
}

// type variable_name;
// 方法一
int a;       // 声明一个整型变量 a
float b;     // 声明一个浮点型变量 b
char c;      // 声明一个字符型变量 c

// 方法二
int a = 10;        // 声明并初始化整型变量 a 为 10
float b = 3.14;    // 声明并初始化浮点型变量 b 为 3.14
char c = 'z';      // 声明并初始化字符型变量 c 为 'z'

// 方法三
int a, b, c;      // 声明多个整型变量 a, b, c
float x, y, z;    // 声明多个浮点型变量 x, y, z

// 方法四
int a = 10, b = 20, c = 30;

正如你所见，可以在一行中声明多个变量，用逗号,分隔它们。

另外，注意对浮点数（%f）和字符（%c）输出使用不同的格式指定符。

练习：

填空，声明一个 int 类型变量 num，并赋值为 42。

5. 常量 Constant

一个常量存储了一个不能改变值的变量(但必须初始化变量)。

通过使用有意义的常量名，代码会更易阅读和理解。 为了区分常量和变量，一个常见的做法是使用大写的标识符来声明常量。

定义常量的一种方法是在变量声明前使用 const 关键字。

#include <stdio.h>

int main() {
    // const 声明为常量并初始化值
    const double PI = 3.14;
    printf("%f", PI);
    
    return 0;
}

在程序执行期间，常量 PI 的值不能被改变。

例如，PI=3.141将产生一个错误。

另一种定义常量的方法是使用 #define 预处理器指令。

#define 指令使用宏来定义常量值。 例如：

#include <stdio.h>

#define PI 3.14

int main() {
    printf("%f", PI);
    return 0;
}

#define PI 3.14159

int main() {
    float radius = 5.0;
    float area = PI * radius * radius;
    printf("Area: %f\n", area);
    return 0;
}

int main() {
    const float pi = 3.14159;
    float radius = 5.0;
    float area = pi * radius * radius;
    printf("Area: %f\n", area);
    return 0;
}

在编译之前，预处理程序将代码中的每个宏标识符替换为指令中的相应值。在这种情况下，每个出现的 PI 都被替换为 3.14。 发送给编译器的最终代码将已经有了常量值。

const和#define的区别在于，前者使用内存进行存储，而后者不使用。

Question 1

在具体使用的时候我们应该如何选择？选择依据是什么？

选择 const 或者 define 的决定依赖于具体的应用场景和你的需求。以下是一些考虑的因素：

1. 类型检查：如果你需要编译器进行类型检查，你应该选择 const，因为 define 不提供类型检查。如果你试图使用一个与定义的类型不同的值，使用 const 的代码会在编译时报错。

2. 作用域：如果你希望常量只在特定的作用域内有效，你应该使用 const，因为它会考虑作用域。define 定义的宏在定义后的所有地方都是有效的。

3. 性能：由于 define 在预处理阶段就进行了文本替换，所以它不会占用内存，这可能会有一些性能优势。然而，这个优势通常很小，并且在现代计算机上可能无法察觉。

4. 编程风格：在一些编程风格中，例如 C++，推荐使用 const 而不是 define，因为 const 提供了更多的类型安全性和更好的集成到语言中。

总的来说，两者都可以用来定义常量，但它们的适用场合并不完全相同。如果你需要更多的类型安全性或更细的作用域控制，使用 const 会更好。而如果你正在定义一个需要在多个文件或整个项目中使用的常量，define 可能是一个更好的选择。

6. 输入及输出

6.1 输入 Input

C 支持多种方式获取用户输入。 如 getchar() 获取一个单字符的输入。

比如:

#include <stdio.h>

int main() {
    // 获取单个输入字符
    char a = getchar();

    printf("You entered: %c", a);

    return 0;
}

输入字符存储在变量 a 中。

gets() 函数用于读取输入的字符序列，也称为字符串。 一个字符串被存储在一个 char 数组中。 例如：

#include <stdio.h>

int main() {
    char a[100];

    // 获取字符串
    gets(a); 

    printf("You entered: %s", a);

    return 0;
}

在这里，我们将输入的内容存储在一个大小100字符的数组中。

scanf() 扫描符合格式指定符的输入。

例如：

#include <stdio.h>

int main() {
    int a;
    scanf("%d", &a);

    printf("You entered: %d", a);

    return 0;
}

变量名前的 & 符号是地址运算符。它给出了一个变量的地址，或在内存中的位置。这样做是因为 scanf 将一个输入值放在一个变量地址上。

1. scanf：获取用户输入
2. %d：指定用户输入的数据类型；
3. 上面得到用户输入的值，存储在 a 变量中。但是，想要存储在 a 变量中，我们需要知道 a 的家庭住址「在这里，也就是 a 变量的物理地址」

想要获取用户输入的字符串，代码如下：

#include <stdio.h>

int main() {
    char inputString[100];
    printf("请输入一串字符：");
    scanf("%s", inputString);

    printf("You entered: %s", inputString);

    return 0;
}

Question 2

scanf("%s", inputString);为什么不需要 &？

在 C 语言中，当你需要使用 scanf() 函数读取一个整型、浮点型等基本数据类型的值时，你需要在变量名前添加 & 操作符，这是因为 scanf() 函数需要知道这个变量的内存地址，以便将用户的输入值存储在那里。这就是 & 操作符的作用——获取变量的内存地址。

然而，当你使用 scanf() 函数读取字符串时，情况就不同了。在 C 语言中，字符串其实是字符数组，而数组名本身就是一个指向数组首元素的指针，也就是说，它已经是一个地址了。因此，当你使用 scanf() 函数读取字符串时，你只需要直接传入数组名（即字符串名），而无需在前面添加 & 操作符。

所以，当你写 scanf("%s", inputString); 时，你实际上是在告诉 scanf() 函数：“请将输入的字符串存储在名为 inputString 的字符数组的起始位置（即 inputString 的地址）”。这也是为什么你不需要添加 & 操作符的原因。

练习： 输入两个整数并输出它们的和。

#include <stdio.h>

int main() {
    int a, b;
    printf("Enter two numbers:");
    scanf("%d %d", &a, &b);

    printf("\nSum: %d", a+b);

    return 0;
}

6.2 探究 scanf 获取字符串的特性

首先，我们需要明白 scanf() 是如何工作的。scanf() 是一个用于读取用户输入的函数。它通常和特定的格式说明符一起使用，例如：

• %s（对应字符串）
• %d（对应整数）
• %f（对应浮点数）等等。

这些说明符告诉 scanf() 我们期待输入的数据类型。

特别地，当我们用 %s 格式说明符与 scanf() 一起使用时，它会读取连续的字符，直到遇到一个"空白"字符（比如空格、制表符或换行符）。因此，如果我们试图使用 scanf() 读取"Hello World"这样的带空格的字符串，那么 scanf() 只会读取"Hello"，因为空格就在这之后。

这是一个代码示例，以及运行它的结果：

#include <stdio.h>

int main() {
    char str[20];
    printf("请输入一个字符串: ");
    scanf("%s", str);
    printf("你输入的字符串是: %s\n", str);
    return 0;
}

如果你在提示下输入"Hello World"，输出将会是：

请输入一个字符串: Hello World
你输入的字符串是: Hello

如果你想读取含有空格的字符串，你应该使用fgets()函数，它可以读取整行（包括空格），直到遇到换行符或者达到给定的最大字符数。例如：

#include <stdio.h>

int main() {
    char str[20];
    printf("请输入一个字符串: ");
    fgets(str, 20, stdin); // 从标准输入（stdin）读取最多20个字符
    printf("你输入的字符串是: %s\n", str);
    return 0;
}

这次，如果你在提示下输入"Hello World"，输出将会是：

请输入一个字符串: Hello World
你输入的字符串是: Hello World

注意：fgets()会读取换行符（如果在给定字符限制内），因此在输出中可能会包含换行符。如果你想移除这个换行符，你可以编写额外的代码来处理这个问题。

#include <stdio.h>

int main() {
    char str[200];
    printf("请输入一个字符串: ");
    fgets(str, 200, stdin);
    printf("你输入的字符串是: %s\n", str);
    return 0;
}

#include <stdio.h>

int main() {
    char str[10];
    printf("请输入一个字符串: ");
    fgets(str, 100, stdin); // 这里定义的缓冲区大小比数组的大小大，可能会导致缓冲区溢出
    printf("你输入的字符串是: %s\n", str);
    return 0;
}

#include <stdio.h>

int main() {
    char str1[10];
    char str2[10] = "important";

    printf("str1: %s\n", str1);
    printf("str2: %s\n", str2);

    printf("请输入一个字符串: ");
    fgets(str1, 20, stdin);  // 这里故意使得缓冲区大小大于数组大小

    printf("str1: %s\n", str1);
    printf("str2: %s\n", str2);

    return 0;
}

填空，读取单个字符，并存储在字符变量c中。

char c = ___();

6.3 scanf 是否需要 & 速查表

在 C 语言中，当使用 scanf 函数来获取用户输入时，我们经常需要使用取址符( & )来指定我们想要存放数据的变量的地址。这样，scanf 可以直接修改该内存位置的值。以下是一个基于数据类型的简单表格，显示了哪些类型需要取址符以及哪些不需要：

注意:

1. 字符串 (char[]或char*) 在使用 scanf 时不需要取址符，因为数组名或字符指针本身就代表一个地址。
2. 当读取 char 类型时，通常在格式字符串中放置一个空格（如" %c"），以跳过可能存在的换行符或空格。
3. 在实际使用中，应确保为 scanf 提供足够大小的缓冲区以避免溢出，特别是当读取字符串时。
4. 使用 scanf 读取其他复杂数据结构或自定义数据类型时，通常也需要使用取址符。

总的来说，基本的数据类型（如int，float，char等）在使用scanf时都需要取址符。但字符串和指针不需要取址符，因为它们本身就是地址。

6.4 输出 Output

在前面的小节中，我们已经使用了 printf() 函数来输出内容。在本小节中，我们将介绍其他几个同于输出的函数。关于 printf 函数，我后面会专门讲一下。

putchar() 输出单一字符。 比如:

#include <stdio.h>

int main() {
  char a = getchar();

  printf("You entered: ");
  putchar(a);

  return 0;
}

输入存储在变量 a 中，并用 putchar(a) 输出字符变量 a。

puts()函数用于将输出一个字符串。 一个字符串存储在一个 char 数组中。 例如：

#include <stdio.h>

int main() {
  char a[100];

  gets(a); 

  printf("You entered: ");
  puts(a); 

  return 0;
} 

在这里，我们将输入的内容存储在 100 个字符的数组中，并用 puts() 来输出该字符串。

scanf() 扫描符合格式指定符的输入。

例如:

#include <stdio.h>

int main() {
    int a;
    scanf("%d", &a);

    printf("You entered: %d", a);

    return 0;
}

变量名前的 & 符号是地址运算符。它给出了一个变量的地址，或在内存中的位置。需要这样做是因为 scanf 将一个输入值放在一个变量地址上

作为另一个例子，让我们输入整数并输出它们的总和：

#include <stdio.h>

int main() {
    int a, b;
    printf("Enter two numbers:");
    scanf("%d %d", &a, &b);

    printf("\nSum: %d", a+b);

    return 0;
}

填空，输出单字符变量c。

char c = 's';
___(c);

6.5 printf 函数

C 语言中，输出内容到屏幕的基本函数是 printf() 函数，该函数声明在 stdio.h 头文件中。

在第一个"Hello World"程序中引入了 printf 函数。对这个函数的调用需要一个格式字符串，其中可以包括用于输出特殊字符的转义字符和由值替换的格式指定符。

例如：

#include <stdio.h>

int main() {
    printf("The tree has %d apples.\n", 22);
    /* output: The tree has 22 apples. */

    printf("\"Hello World!\"\n");
    /* output: "Hello World!" */
}

现在，我们来学习如何使用它。

6.5.1 printf() 函数基本使用

首先，我们从最基础的 printf() 函数开始。下面是一个最简单的 C 程序，该程序使用 printf() 函数向控制台打印出一段文字。

#include <stdio.h>  // 引入stdio.h头文件，这个头文件中声明了printf()函数

int main() {  // main函数是C程序的入口
    printf("Hello, World!\n");  // 使用printf函数打印一段文字到控制台
    return 0;  // main函数结束，返回0
}

6.5.2 printf() 函数中的转义序列

有一些特殊的字符，我们不能直接在 printf() 函数中打印出来，例如换行符、制表符等。

转义字符以反斜线\开始。

这时候，我们需要用到转义序列。下面是一些常用的转义序列：

• \n：换行符，打印完这个字符后，光标会移动到下一行的开始位置。
• \t：制表符，打印完这个字符后，光标会移动到下一个制表位置。
• \\：反斜杠，用来打印一个\字符。
• \"：双引号，用来打印一个"字符。
• \b：退格
• \'：单引号
• \"：双引号

#include <stdio.h>

int main() {
    printf("Hello,\nWorld!\n");  // 使用\n来打印换行
    printf("Hello,\tWorld!\n");  // 使用\t来打印制表符
    printf("Hello,\\World!\n");  // 使用\\来打印反斜杠
    printf("Hello,\"World!\"\n");  // 使用\"来打印双引号
    return 0;
}

6.5.3 printf() 函数中的格式化输出

在 printf() 函数中，我们还可以进行格式化输出，这就涉及到了格式控制符。

格式指定符以百分号%开始，并由格式字符串后的相应参数取代。一个格式指定符可以包括几个选项，以及一个转换字符：

%[-][width].[precision]conversion character 

• 可选的 - 指定了字符串中数据的左对齐；「没有 - 的，是右对齐」
• 可选的 width (宽度)提供了数据的最小字符数；
• 其中.将宽度 width 与精度 precision 分开；

可选的 precision (精度)给出了数字的小数位数。如果使用 s 作为转换字符，那么精度决定了要打印的字符数。

如有必要，转换字符将参数conversion character转换为指定类型，下面是一些常用的格式控制符：

• %d：整型数据（十进制）
• %c：字符
• %s：字符串
• %f：浮点数
• %e：科学记数法
• %x： 十六进制

#include <stdio.h>

int main() {
    int i = 10;
    char c = 'A';
    char s[] = "Hello, World!";
    float f = 3.14;
    
    printf("%d\n", i);  // 打印整型变量i
    printf("%c\n", c);  // 打印字符变量c
    printf("%s\n", s);  // 打印字符串s
    printf("%.2f\n", f);  // 打印浮点数f，保留2位小数
    
    return 0;
}

#include <stdio.h>

int main() {
    printf("Color: %s, Number: %d, float: %5.2f \n", "red", 42, 3.14159);
    /* Color: red, Number: 42, float:  3.14  */

    printf("Pi = %3.2f \n", 3.14159); 
    /* Pi = 3.14 */
    
    printf("Pi = %8.5f \n", 3.14159); 
    /* Pi = 3.14159 */
    
    printf("Pi = %-8.5f \n", 3.14159); 
    /* Pi = 3.14159 */
    
    printf("There are %d %s in the tree. \n", 22, "apples");
    /* There are 22 apples in the tree. */
    
    return 0;
}

要打印%符号，在格式字符串中使用%%。

这就是 C 语言中使用 printf() 函数进行输出的基本方法，通过 printf() 函数和格式控制符，我们可以将各种类型的数据按照我们想要的格式打印到控制台。

练习：

填空，格式化输出数字4.42。

printf("%3.___f", 4.4289743);

6.6 格式化输入

scanf() 函数用于将输入分配给变量。对这个函数的调用是根据格式指定符扫描输入，在必要时转换输入。

如果输入不能被转换，那么就不进行赋值。 scanf() 语句会等待输入，然后进行赋值。

#include <stdio.h>

int main() {
    int x;
    float num;
    char text[20];
    scanf("%d %f %s", &x, &num, text);
}

输入 10 22.5 abcd，然后按回车键，将 10 分配给 x，22.5 分配给 num，abcd 分配给 text。

注意，必须使用 & 来访问变量地址。字符串不需要 &，因为字符串的名字就像一个指针。

格式指定符以百分号 % 开始，用于为控制字符串后的相应参数赋值。空白、制表符和换行符被忽略。

一个格式指定符可以包括几个选项和一个转换字符:

%[*][max_field]conversion character

• 可选的 * 将跳过输入字段。
• 可选的 max_width 指定了输入字段的最大字符数。

如有必要，转换字符将参数 conversion character 转换为指定的类型，如：

• d - 十进制
• c - 字符
• s - 字符串
• f - 浮点数
• x - 十六进制

例如：

#include <stdio.h>

int main() {
    int x, y;
    char text[20];

    scanf("%2d %d %*f %5s", &x, &y, text);
    /* input: 1234  5.7  elephant */
    printf("%d  %d  %s", x, y, text);
    /* output: 12  34  eleph */

    return 0;
} 

int main() {
    int i;
    printf("Please enter an integer: ");
    scanf("%d", &i); // %d用于读取整数
    printf("You entered: %d\n", i); // %d用于打印整数
    return 0;
}

int main() {
    char c;
    printf("Please enter a character: ");
    scanf(" %c", &c); // 注意前面有一个空格，这是为了清除可能存在的换行符
    printf("You entered: %c\n", c);
    return 0;
}

int main() {
    char str[10];
    printf("Please enter a string (up to 9 characters): ");
    scanf("%9s", str); // 只读取前9个字符
    printf("You entered: %s\n", str);
    return 0;
}

int main() {
    float f;
    printf("Please enter a float: ");
    scanf("%f", &f);
    printf("You entered: %f\n", f);
    return 0;
}

int main() {
    int i;
    printf("Please enter a hexadecimal integer: ");
    scanf("%x", &i);
    printf("You entered: %x\n", i); // 打印为十六进制
    printf("In decimal: %d\n", i); // 打印为十进制
    return 0;
}

int main() {
    int i;
    char str[10];
    printf("Please enter an integer and a string (up to 9 characters): ");
    scanf("%*d %9s", str); // 读取整数但忽略它，只保存字符串
    printf("You entered: %s\n", str);
    return 0;
}

每个程序都从读取用户输入开始，然后打印出用户输入的值。在这些例子中，'%' 后面的字符定义了输入或输出值的类型，而 '&' 用于获取变量的地址，以便 scanf 可以将读取的值存储在正确的位置。

详细解释上面的 demo 代码：

这个程序首先从用户输入获取数据，然后将数据赋值给指定的变量，最后打印这些变量的值。

以下是具体步骤的解释：

1. 程序首先调用 scanf 函数从用户输入读取数据。格式字符串 "%2d %d %*f %5s" 定义了需要读取的数据类型和格式。这个字符串表示：

   • 读取一个最多两位的十进制整数并存储到变量 x 中（对应 "%2d" ）
   • 然后跳过一个或多个空格（对应 " "）
   • 再读取一个十进制整数并存储到变量 y 中（对应 "%d"）
   • 然后跳过一个或多个空格（对应 " "）
   • 然后读取一个浮点数，但是忽略它不保存（对应 "%*f"）
   • 然后跳过一个或多个空格（对应 " "）
   • 最后读取一个最多五个字符的字符串并存储到 text 数组中（对应 "%5s"）。

2. 用户输入的数据是 "1234 5.7 elephant"，按照上面的规则，程序将：

   • 读取 "12" 作为第一个整数（因为只读取两位），并将其存储到 x 中，所以 x 的值为 12
   • 然后读取 "34" 作为第二个整数，并将其存储到 y 中，所以 y 的值为 34
   • 然后读取 "5.7" 作为浮点数，但是忽略它不保存
   • 最后读取 "eleph" 作为字符串（因为只读取五个字符），并将其存储到 text 中，所以 text 的值为 "eleph"。

3. 然后，程序使用 printf 函数打印变量 x、y 和 text 的值。输出结果是 "12 34 eleph"，这与我们前面解释的结果一致。

所以，scanf 其实就是一个“流”。

例如：

填空，使用scanf()输入两个整数变量:

int num1, num2;
scanf("%d %d", &__, ___num2);

7. 代码注释

7.1 多行注释

注释是程序代码的解释信息，你可以在程序中添加注释，让代码更易阅读理解。编译器会忽略注释，所以它们对程序没有影响。

注释以斜线 /* 开始，以斜线 */ 结束，可以出现在代码的任何地方。 注释可以和语句在同一行，也可以跨越多行。 例如：

#include <stdio.h>

/* 简单的c语程序
 *  Version 1.0
 */
int main() {
    /* 输出字符串 */
    printf("Hello World!");
    return 0;
}

正如你所看到的，注释向读者澄清了程序的意图。使用注释来澄清代码段背后的目的和逻辑。

7.2 单行注释

C++ 引入了双斜线注释 // 作为注释单行的一种方式。大部分 C 语言编译器也支持单行注释。 例如：

#include <stdio.h>

int main() {
    int x = 42; // 声明int变量x
    
    //%d 占位符，此处代表x
    printf("%d", x);
    
    return 0;
}

给代码添加注释是良好的编程实践。它有助于你和他人清楚地了解代码。

8. 算术运算符

C 支持的 算术运算符：+（加法）、-（减法）、*（乘法）、/（除法）和 %（模除法）。

运算符经常用来组成一个算术表达式，如10+5，在这种情况下，它包含两个操作数和加法运算符。

算术表达式经常用于赋值语句中。 例如：

#include <stdio.h>

int main() {
    int length = 10;
    int width = 5;
    int area;

    area = length * width;
    printf("%d \n", area);  /* 50 */

    return 0;
}

8.1 除法

C 语言有两个除法运算符: / 和 %。 根据操作数的数据类型，除法 / 运算符有不同的表现。

当两个操作数都是 int 数据类型时，为整数除法，也称为截断除法，去掉任何余数，结果是一个整数。

当一个或两个操作数都是实数（float 或 double ）时，结果是一个实数。

% 运算符只返回整数除法的余数。它对许多算法很有用，如欧几里得算法求最大公约数。但模数除法不能在浮点数上执行。

下面的例子演示了除法：

#include <stdio.h>

int main() {
    int i1 = 10;
    int i2 = 3;
    int quotient, remainder;
    float f1 = 4.2;
    float f2 = 2.5;
    float result;

    quotient = i1 / i2;  // 3
    remainder = i1 % i2;  // 1
    result = f1 / f2;  // 1.68

    printf("%d \n", quotient);
    printf("%d \n", remainder);
    printf("%f \n", result);

    return 0;
}

下面代码，result最终等于多少？

int a = 12;
int b = 5;
int result = a % b;

请输入一个两位数的整数：123
输入错误！请输入一个两位数。
请输入一个两位数的整数：89
十位数和个位数的和为: 17
翻转后的整数为: 98

#include <stdio.h>

int main() {
    int number, tens, ones, sum, reversed;

    while(1) {
        // 获取用户输入
        printf("请输入一个两位数的整数：");
        scanf("%d", &number);

        // 检查输入是否为两位数
        if (number < 10 || number > 99) {
            printf("输入错误！请输入一个两位数。\n");
            continue;
        } else {
            break;
        }
    }

    // 计算十位数和个位数
    tens = number / 10;
    ones = number % 10;

    // 计算它们的和
    sum = tens + ones;
    printf("十位数和个位数的和为: %d\n", sum);

    // 翻转整数
    reversed = ones * 10 + tens;
    printf("翻转后的整数为: %d\n", reversed);

    return 0;
}

8.2 运算符优先级

C 语言根据运算符的优先级来计算算术表达式。

+ 和 - 的优先级相同，*、/ 和 % 的优先级也相同。

首先按照从左到右的顺序执行 *、/ 和 %，然后是 + 和 - 。 你可以通过使用圆括号 () 来改变计算的顺序，表示哪些运算要先执行。

例如，5+3*2 的结果是 11，而 (5+3)*2 的结果是16。

例如：

#include <stdio.h>

int main() {
    int a = 6;
    int b = 4;
    int c = 2;
    int result;
    result = a - b + c;  // 4
    printf("%d \n", result);
    result = a + b / c;  // 8
    printf("%d \n", result);
    result = (a + b) / c;  // 5
    printf("%d \n", result);

    return 0;
}

练习： 填空，变量 x 减去 y，再相加 z 并将结果赋值给 result。

int x = 6;
int y = 4;
int z = 2;

int res = x _____ y _______ z;

8.3 类型转换

当一个算术表达式包含不同数据类型的操作数时，它们会在一个称为类型转换的过程中自动进行必要的转换。

例如，在一个同时涉及浮点数 float 和整数 int 的计算中，编译器将把整数值转换为浮点数。

在下面的程序中，变量 increase 被自动转换为浮点数：

#include <stdio.h>

int main() {
    float price = 6.50;
    int increase = 2;
    float new_price;

    new_price = price + increase;
    printf("New price is %4.2f", new_price);
    /* Output: New price is 8.50 */

    return 0;
}

请注意，格式指定符包括 4.2，表示浮点数将打印在一个至少 4 个字符宽的空间中，并有 2 个小数位。

当你想把表达式的结果强制转换成不同的类型时，你可以通过类型转换进行显式的转换，如下代码：

#include <stdio.h>

int main() {
    float average;
    int total = 23;
    int count = 4;
    // total 强制转换为float 类型
    average = (float) total / count;
    
    printf("%4.2f", average);

    return 0;
}

如果不进行类型转换，变量 average 将赋值为 5。 显示的进行类型转换，即使编译器可以做自动类型转换，也认为是好的编程风格。

填空，显示的将除法结果转换为float类型：

average = (___) total / count;

8.4 赋值运算符

赋值语句首先评估等号( = )右边的表达式，然后将该值赋给 = 左边的变量。 这使得在赋值语句的两边使用同一个变量是有可能的，且在编程中经常使用该特性。

例如：

int x = 3;
x = x + 1;  /* x 现在为 4 */

为了缩短此类型的赋值语句，C 语言提供了 += 赋值运算符。上面的语句可以写成:

x += 1;  /* x = x + 1 */

许多 C 语言的运算符都有一个相应的赋值运算符。下面的程序演示了算术赋值运算符:

int x = 2;

x += 1;  // 3
x -= 1;  // 2
x *= 3;  // 6
x /= 2;  // 
x %= 2;  // 1
x += 3 * 2;  // 7

仔细看一下最后一条赋值语句。右边的整个表达式被计算，然后和 x 相加，再赋值给 x。等价于 x = x + (3 * 2)。

填空，将 int 类型变量num2相加到变量num1中：

int num1 = 8;
int num2 = 42;
num1___num2;

8.5 自增及自减运算

给一个变量加1可以用自增运算符 ++ 来完成。同样地，自减运算符 -- 用于从一个变量中减去1。 例如:

z--;  /* z 减去 1 */
y++; /* y 增加 1 */

自增和自减运算符分为前缀（在变量名之前）或后缀（在变量名之后）。在赋值语句中，前缀或后缀 自增、自减结果不一样，如下面的例子：

#include <stdio.h>

int main() {
    int x, y, z;
    
    z = 3;
    x = z--;  /* z先赋值给x，x=3，之后z 自减，z=2*/
    printf("x=%d \n", x);
    
    y = 3;
    x = ++y;  /* y先自增1，y=4, 之后y赋值给x，x=4 */
    
    printf("x=%d \n", x);
    
    printf("y=%d \n", y);

    return 0;
}

• 前缀形式是先增加、减少变量，然后在赋值语句中使用它。
• 后缀形式首先使用变量的值，然后再进行增减。

下面代码，变量 x 最终等于多少？

int x = 8;
int y = 7;
x++;
x+= y--;

8.6 对比学习

1. x--;

#include <stdio.h>

int main() {
    int x = 9;
    int y;
    y = 2 * x--;
    printf("%d \n", x);
    printf("%d", y);
    return 0;
}

// ---output---
8
18

#include <stdio.h>

int main() {
    int x = 9;
    int y;
    y = 2 * x;
    x = x - 1;
    printf("%d \n", x);
    printf("%d", y);
    return 0;
}

// ---output---
8
18

2. --x;

#include <stdio.h>

int main() {
    int x = 9;
    int y;
    y = 2 * --x;
    printf("%d \n", x);
    printf("%d", y);
    return 0;
}

// ---output---
8
16

#include <stdio.h>

int main() {
    int x = 9;
    int y;
    x = x - 1;
    y = 2 * x;
    printf("%d \n", x);
    printf("%d", y);
    return 0;
}

// ---output---
8
16

3. x++;

#include <stdio.h>

int main() {
    int x = 9;
    int y;
    y = 2 * x++;
    printf("%d \n", x);
    printf("%d", y);
    return 0;
}

// ---output---
10 
18

#include <stdio.h>

int main() {
    int x = 9;
    int y;
    y = 2 * x;
    x = x + 1;
    printf("%d \n", x);
    printf("%d", y);
    return 0;
}

// ---output---
10 
18

4. ++x;

#include <stdio.h>

int main() {
    int x = 9;
    int y;
    y = 2 * ++x;
    printf("%d \n", x);
    printf("%d", y);
    return 0;
}

// ---output---
10 
20

#include <stdio.h>

int main() {
    int x = 9;
    int y;
    x = x + 1;
    y = 2 * x;
    printf("%d \n", x);
    printf("%d", y);
    return 0;
}


// ---output---
10 
20

9. 练习

1. C 语言执行的主入口是？

   A. 代码第一行

   B. main() 函数

   C. <stdio.h> 头文件

2. 填空，使用 printf 输出文本"I love C":

   ___("I love C")___
   

3. 下面哪一项是 c 语言单行注释？

   A. ## 单行注释

   B. ** 单行注释

   C. // 单行注释

4. 填空，声明一个变量 sum，并将变量 a、b 相加赋值给 sum:

   int___ = a ___ b;
   

5. 填空，输出变量 v。

   ___include <stdio.h>
   int main() {
       int v = 42135;
       printf("%d", ___);
       return 0;
   }
   

公众号：AI悦创【二维码】