零基础轻松入门！掌握C语言核心语法，一文搞定
本篇文章系统介绍了C语言的基础语法，涵盖变量、数据类型、控制结构、函数、指针等核心概念。通过逐步解析每个知识点，读者可以清晰理解C语言的结构化编程方式和应用场景。文章适合初学者快速入门，也为有基础的读者提供了巩固知识的参考。阅读后，您将具备编写基础C语言程序的能力。
1. 基本结构
C语言程序的基本结构定义了程序的整体框架。理解这个结构是编写任何C程序的基础。
1.1 预处理指令
预处理指令位于代码的最上方，通常以 # 开头。它们用于在实际编译之前对代码进行处理。常见的预处理指令有：
-
#include：用于引入标准库或自定义的头文件。#include <stdio.h>表示引入标准输入输出库stdio.h，这个库提供了像printf这样的函数，用于输出数据。
-
#define：用于定义宏，可以用来替换代码中的常量或表达式。#define PI 3.14159
预处理指令在编译器编译代码之前处理，因此它们不会出现在最终生成的机器代码中。使用预处理指令可以提高代码的可读性和复用性。
1.2 函数
C语言程序是由一个或多个函数组成的，其中 main() 函数是每个C程序的起点，也是程序执行的入口。
int main() {
// 程序的主逻辑从这里开始执行
}
int main()表示main函数的返回类型是int（整数类型），函数的返回值通常表示程序的退出状态。返回0表示程序成功执行，其他非零值可以表示不同的错误状态。- C程序可以包含多个函数，但执行总是从
main函数开始。
1.3 变量声明
在C语言中，变量在使用之前必须声明，声明变量时需要指定数据类型。
int a = 10;
float b = 3.14;
变量声明通常出现在函数的开头，并为程序的逻辑操作提供存储和处理数据的空间。
1.4 语句和表达式
C语言中的语句通常以分号 ; 结尾，它们告诉编译器执行特定的操作。表达式则是由操作数（如变量或常量）和操作符组成，用于计算值。
int sum = a + b; // 表达式和语句的结合
语句可以是赋值语句、函数调用、循环、条件判断等。
1.5 注释
注释用于解释代码，帮助程序员理解程序的逻辑。注释不会被编译，因此它不会影响程序的执行。C语言中有两种类型的注释：
- 单行注释：使用
//开始，注释内容在当前行的剩余部分。// 这是一个单行注释 - 多行注释：使用
/* ... */包围的区域可以跨多行。/* 这是一个多行注释， 它可以用于长文本注释 */
1.6 扩展
C语言的基本结构看似简单，但它是理解更复杂程序设计的基础。下面是一些可以扩展和深入理解的要点：
1.6.1 #include 的作用
#include 的工作方式是直接将头文件的内容插入到当前文件中。这使得程序可以利用库函数，比如 printf 来实现特定功能。常见的头文件还有：
<stdlib.h>：包含通用工具函数，例如内存管理、随机数生成等。<string.h>：包含字符串处理函数。<math.h>：包含数学函数。
自定义头文件通常以 .h 结尾，用户可以使用 #include "filename.h" 来包含自己定义的文件。
1.6.2 main 函数的变体
除了标准的 int main(void) 或 int main()，还有一种 main 函数的定义可以接受命令行参数：
int main(int argc, char *argv[]) {
// argc 是传入参数的数量，argv 是指向参数的指针数组
}
这允许程序从命令行接收输入，从而更灵活地运行。
1.6.3 变量的作用域
变量的声明可以有不同的作用域：
- 全局变量：在所有函数外声明的变量，整个程序都可以访问。
- 局部变量：在函数内部声明，只有在该函数内可用。
- 块级变量：在代码块（如
for循环或if语句）中声明，只有在该块内可用。
int global_var = 10; // 全局变量
int main() {
int local_var = 5; // 局部变量
if (local_var > 0) {
int block_var = 20; // 块级变量
printf("block_var = %d\n", block_var);
}
// block_var 在这里不可访问
return 0;
}
1.6.4 return 语句
return 语句不仅用于返回值，还可以立即退出函数。对于 main 函数，return 的返回值用于告诉操作系统程序的执行结果：
return 0;表示程序成功完成。return 非0值;通常表示发生了错误，非零值可用于指定错误代码。
2. 变量声明和数据类型
在C语言中，变量是存储数据的容器，而数据类型定义了变量可以存储什么样的数据以及如何操作这些数据。C语言支持多种数据类型，主要分为基本数据类型、派生数据类型和用户自定义数据类型。以下是C语言中常见的基本数据类型和变量声明的详细讲解。
2.1 整型（int）
int类型用于表示整数，通常占用4字节的内存空间（32位系统或64位系统）。int可以存储正数、负数和零。- 取值范围：
-2,147,483,648到2,147,483,647（具体范围取决于编译器和系统架构）。
int a = 10; // 声明并初始化一个整型变量a
- 常见的变体：
short int或short：占用2字节，范围较小。long int或long：占用4字节或8字节，范围更大。unsigned int：用于表示非负整数，取值范围翻倍。
short int s = 32767; // 最大短整型值
long int l = 1000000L; // 长整型
unsigned int u = 4294967295U; // 无符号整型
2.2 浮点型（float 和 double）
float和double用于表示带有小数的数值（浮点数）。float：单精度浮点数，占用4字节，精度为6~7位有效数字。double：双精度浮点数，占用8字节，精度为15~16位有效数字。- 对于更加精确的计算，如科学计算或需要处理大量小数的场合，通常使用
double。
float b = 3.14f; // 单精度浮点数
double pi = 3.141592653589793; // 双精度浮点数
- 注意：在声明
float类型时，常在数值后加f后缀来明确表示这是float类型，而不是double类型。
2.3 字符型（char）
char类型用于存储单个字符，占用1字节内存。char也可以存储整数值，因为在C语言中，字符的存储实际上是存储其对应的ASCII码值（0-255）。
char c = 'A'; // 声明字符变量c并赋值为字符A
char d = 65; // 声明字符变量d并赋值为65（ASCII码值对应'A'）
char可以用于表示符号和控制字符，例如：\n（换行符），\t（制表符）等。
2.4 变量声明与初始化
- 在C语言中，变量在使用之前必须声明。声明时，必须指定变量的数据类型。
- 声明的同时可以对变量进行初始化，也可以声明后再赋值。
int x; // 声明但未初始化
x = 5; // 赋值
int y = 10; // 声明并初始化
2.5 变量的作用域和生命周期
C语言中的变量可以根据其声明位置分为局部变量和全局变量。
- 局部变量：在函数或代码块中声明，只在该函数或块内有效。
- 全局变量：在所有函数外声明，在整个程序中都有效。
int globalVar = 100; // 全局变量
int main() {
int localVar = 10; // 局部变量
}
变量的生命周期取决于它的作用域，局部变量在函数结束时销毁，而全局变量在程序结束时销毁。
2.6 常量（const 关键字）
const关键字用于声明常量，常量的值在程序运行过程中不能被修改。- 常量可以是整数、浮点数、字符等类型。
const int max_value = 100; // 声明一个常量
max_value = 200; // 错误：常量的值不能修改
2.7 扩展：类型转换
在某些情况下，不同数据类型的变量可能会参与同一表达式。C语言支持隐式类型转换和显式类型转换。
-
隐式类型转换：当不同类型的数据混合在一起时，C语言会自动将较小范围的数据类型提升为较大范围的数据类型。
int a = 5; float b = 3.5; float result = a + b; // a被隐式转换为float类型 -
显式类型转换（强制类型转换）：通过类型转换操作符
()进行转换。int a = 5; float b = 3.5; int result = (int) b + a; // b被强制转换为int类型
2.8 扩展：存储类关键字
C语言提供了几种存储类用于指定变量的存储位置、初始化时间和作用范围：
- auto：局部变量的默认存储类。
- static：用于声明局部静态变量，局部静态变量在函数调用结束后不会销毁，下次调用时保留上次的值。
- extern：声明外部变量，在其他文件中定义。
- register：建议编译器将变量存储在CPU寄存器中，以提高访问速度。
void func() {
static int count = 0; // 静态局部变量
count++;
printf("Count: %d\n", count);
}
int main() {
func(); // 输出 Count: 1
func(); // 输出 Count: 2
}
3. 常量
在C语言中，常量指的是在程序运行过程中值不会发生改变的量。常量可以提高代码的可读性和安全性，因为它们的值一旦设定就不能被修改。C语言通过 const 关键字来定义常量。
3.1 const 关键字
const关键字可以用于声明任何基本数据类型的常量，包括int、float、double、char等。- 常量声明后，其值是只读的，任何试图修改它的操作都会导致编译错误。
const int x = 100; // 定义一个整型常量x
x = 200; // 错误：常量的值不能修改
const 常量的使用不仅能够提高代码的安全性，还能避免因为意外修改变量值而导致的程序逻辑错误。
3.2 const 的应用场景
-
替代魔法数（Magic Numbers）：
- 在程序中，常常需要用到一些固定的值（例如圆周率、最大长度等），这些值被称为"魔法数"。为了避免在代码中到处使用这样的魔法数，可以用
const定义常量，并且为这些常量赋予有意义的名字。 - 例如：
const double PI = 3.14159; const int MAX_LENGTH = 100;
- 在程序中，常常需要用到一些固定的值（例如圆周率、最大长度等），这些值被称为"魔法数"。为了避免在代码中到处使用这样的魔法数，可以用
-
函数参数保护：
const还可以用于函数参数，表示参数在函数内部不可被修改。这不仅可以保证函数不意外修改传入的值，还可以帮助编译器进行优化。- 例如：
void printValue(const int value) { printf("Value: %d\n", value); // value = 5; // 错误：不能修改const参数 }
3.3 指针与 const
const 可以与指针结合使用，具体的用法会影响指针和指向的数据的可修改性：
-
指向常量的指针：
- 这种指针指向的对象是不可修改的，但是指针本身可以指向不同的对象。
- 例如：
const int *ptr; int a = 10, b = 20; ptr = &a; // 可以修改指针指向 // *ptr = 15; // 错误：不能修改指向的值 ptr = &b; // 可以修改指针指向另一个变量
-
常量指针：
- 常量指针的含义是指针本身不可修改，但是它指向的数据是可以修改的。
- 例如：
int *const ptr = &a; // ptr是常量指针 *ptr = 15; // 可以修改指向的值 // ptr = &b; // 错误：不能修改指针本身
-
指向常量的常量指针：
- 这种情况下，指针本身和它指向的值都不能修改。
- 例如：
const int *const ptr = &a; // *ptr = 15; // 错误：不能修改指向的值 // ptr = &b; // 错误：不能修改指针本身
3.4 #define 宏与 const 常量
在C语言中，定义常量除了使用 const 关键字，还可以使用 #define 宏。
-
#define用于定义宏常量，在预处理阶段直接将宏名替换为具体的值。这与const不同，const是类型安全的，而#define只是简单的文本替换。 -
#define示例：#define PI 3.14159 #define MAX_LENGTH 100 -
尽管
#define也是一种定义常量的方式，但它没有const的类型检查功能，因此在现代C语言编程中，建议优先使用const代替#define来定义常量。
3.5 enum 枚举常量
C语言还支持通过 enum 枚举来定义一组相关的常量。枚举中的每个常量默认值从0开始，依次递增，但也可以手动赋值。
-
枚举常量的定义方式：
enum Weekday { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday }; enum Weekday today = Tuesday; // today的值为2（从0开始） -
如果需要，可以为枚举常量赋值：
enum Month { January = 1, February, March }; // February的值为2，March的值为3
3.6 扩展：volatile 关键字
volatile 关键字与 const 相反，表示变量的值可能在程序控制之外被改变，如在硬件寄存器或多线程环境下，这使得编译器不会对其进行优化。例如：
volatile int signal;
在这种情况下，即使编译器检测不到对 signal 的修改，它也不会优化掉对该变量的读取。
4. 输入输出
在C语言中，输入输出操作是通过标准库提供的函数来实现的。最常用的输入输出函数是 printf() 和 scanf()，分别用于输出数据到屏幕和从键盘读取用户输入。这两个函数来自标准输入输出库 stdio.h，在编写程序时需要包含该头文件。
4.1 printf() 函数
printf() 函数用于将格式化的字符串输出到屏幕。它可以处理不同类型的数据，并根据指定的格式说明符将其格式化输出。
-
语法：
int printf(const char *format, ...); -
格式说明符：用于指定输出的变量类型，常用的格式说明符有：
%d：输出整数类型int。%f：输出单精度浮点数类型float。%lf：输出双精度浮点数类型double。%c：输出字符类型char。%s：输出字符串。
-
示例：
int num = 10; float pi = 3.14; char grade = 'A'; printf("Integer: %d, Float: %.2f, Char: %c\n", num, pi, grade);
在这个例子中，%.2f 表示将浮点数限制为显示两位小数。
4.2 scanf() 函数
scanf() 函数用于从标准输入设备（通常是键盘）读取数据，并将输入的数据存储到变量中。与 printf() 类似，scanf() 也使用格式说明符来指定读取的数据类型。
-
语法：
int scanf(const char *format, ...); -
格式说明符：与
printf()的格式说明符类似，scanf()也有对应的格式说明符来读取不同类型的数据。%d：读取整数类型int。%f：读取单精度浮点数类型float。%lf：读取双精度浮点数类型double。%c：读取字符类型char。%s：读取字符串（不带空格）。
-
示例：
int num; printf("Enter a number: "); scanf("%d", &num); // 从输入读取一个整数并存储到num中 printf("You entered: %d\n", num); // 输出读取到的整数 -
注意：在使用
scanf()时，读取变量的地址需要通过&符号传递（除字符串外）。例如：int a; scanf("%d", &a); // 使用&获取变量a的地址
4.3 输入输出扩展
4.3.1 处理多个输入
scanf() 可以同时处理多个输入，格式说明符的数量应与变量的数量相对应。
- 示例：
int a, b; printf("Enter two numbers: "); scanf("%d %d", &a, &b); printf("You entered: %d and %d\n", a, b);
在这个例子中，用户可以输入两个整数，scanf() 会分别读取并存储到 a 和 b 中。
4.3.2 读取字符串
使用 %s 可以从输入中读取一个字符串，字符串会存储在字符数组中。注意，scanf() 读取的字符串不能包含空格，一旦遇到空格，输入就会被截断。
-
示例：
char name[50]; printf("Enter your name: "); scanf("%s", name); // 不需要加&，因为name是字符数组 printf("Hello, %s\n", name); -
扩展：如果需要读取包含空格的字符串，可以使用
fgets()函数而不是scanf()：fgets(name, sizeof(name), stdin);
4.3.3 处理浮点数输入
scanf() 可以用 %f 来读取浮点数，并存储在 float 类型变量中。对于 double 类型，使用 %lf。
- 示例：
float num; printf("Enter a floating-point number: "); scanf("%f", &num); printf("You entered: %.2f\n", num);
4.3.4 格式化输出控制
printf() 允许通过格式化控制符调整输出的格式，例如指定输出宽度、精度等。
-
指定宽度：
printf("%10d\n", num); // 整数占10个字符宽度，右对齐 -
指定浮点数精度：
printf("%.3f\n", pi); // 输出3位小数
4.3.5 getchar() 和 putchar()
除了 scanf() 和 printf()，C语言还提供了 getchar() 和 putchar() 来处理单个字符的输入输出。
-
getchar()：从标准输入读取一个字符。char ch; printf("Enter a character: "); ch = getchar(); // 读取一个字符 printf("You entered: %c\n", ch); -
putchar()：输出单个字符到标准输出。char ch = 'A'; putchar(ch); // 输出字符'A'
4.4 错误处理
在输入时要处理错误输入情况，例如用户输入的值与预期的格式说明符不匹配时，可能会导致未定义行为。在输入复杂数据时，进行错误检查是良好的编程实践。
- 示例：
int result; int num; printf("Enter an integer: "); result = scanf("%d", &num); if (result == 1) { printf("You entered: %d\n", num); } else { printf("Invalid input!\n"); }
5. 运算符
C语言中提供了丰富的运算符，用于执行不同类型的操作。运算符分为以下几类：算术运算符、关系运算符、逻辑运算符、赋值运算符、位运算符、增量与减量运算符、条件运算符等。掌握这些运算符对于编写高效的C程序至关重要。
5.1 算术运算符
算术运算符用于执行基本的数学运算，如加法、减法、乘法、除法和取余。
| 运算符 | 描述 | 示例 |
|---|---|---|
+ | 加法 | a + b |
- | 减法 | a - b |
* | 乘法 | a * b |
/ | 除法 | a / b |
% | 取余数（模运算） | a % b |
-
注意：在整数除法中，除法运算符
/返回整数部分，忽略小数部分。例如：int a = 5, b = 2; int quotient = a / b; // 结果为2，而不是2.5 -
取余运算符
%：用于计算整数除法的余数。仅适用于整数类型。int remainder = a % b; // 结果为1（5除以2的余数）
5.2 关系运算符
关系运算符用于比较两个值，并返回一个布尔值（true 或 false），在C语言中通常表示为 1 或 0。
| 运算符 | 描述 | 示例 |
|---|---|---|
== | 等于 | a == b |
!= | 不等于 | a != b |
< | 小于 | a < b |
> | 大于 | a > b |
<= | 小于等于 | a <= b |
>= | 大于等于 | a >= b |
- 关系运算符通常用于条件语句中，例如
if语句：if (a > b) { printf("a is greater than b\n"); }
5.3 逻辑运算符
逻辑运算符用于逻辑运算，主要在布尔表达式中使用。常用于条件判断或控制流程。
| 运算符 | 描述 | 示例 |
|---|---|---|
&& | 逻辑与（AND） | a && b |
|| | 逻辑或（OR） | a || b |
! | 逻辑非（NOT） | !a |
-
逻辑与（&&）：只有两个表达式都为
true时，结果为true。if (a > 0 && b > 0) { printf("Both a and b are positive\n"); } -
逻辑或（||）：只要有一个表达式为
true，结果为true。if (a > 0 || b > 0) { printf("Either a or b is positive\n"); } -
逻辑非（!）：对表达式取反，
true变为false，false变为true。if (!a) { printf("a is false\n"); }
5.4 赋值运算符
赋值运算符用于给变量赋值。除了基本的 = 运算符，还有复合赋值运算符用于简化表达式。
| 运算符 | 描述 | 示例 |
|---|---|---|
= | 赋值 | a = b |
+= | 加法赋值 | a += b 相当于 a = a + b |
-= | 减法赋值 | a -= b 相当于 a = a - b |
*= | 乘法赋值 | a *= b 相当于 a = a * b |
/= | 除法赋值 | a /= b 相当于 a = a / b |
%= | 取余赋值 | a %= b 相当于 a = a % b |
- 示例：
int a = 10; a += 5; // a现在等于15 a *= 2; // a现在等于30
5.5 增量与减量运算符
增量（++）和减量（--）运算符用于对变量自增或自减。它们有前缀和后缀两种形式。
-
前缀形式（
++a或--a）：先执行自增或自减，再使用变量的值。 -
后缀形式（
a++或a--）：先使用变量的值，再执行自增或自减。 -
示例：
int a = 5; int b = ++a; // a先自增为6，然后b的值为6 int c = a--; // c的值为6，然后a自减为5
5.6 位运算符
位运算符用于对二进制位进行操作，通常用于底层编程和性能优化。
| 运算符 | 描述 | 示例 |
|---|---|---|
& | 按位与（AND） | a & b |
| | 按位或（OR） | a | b |
^ | 按位异或（XOR） | a ^ b |
~ | 按位取反（NOT） | ~a |
<< | 左移 | a << b |
>> | 右移 | a >> b |
-
按位与（&）：对两个数的每个位进行与操作，只有相应位都为1时，结果为1。
int a = 5, b = 3; // a = 0101, b = 0011 int result = a & b; // 结果为0001，即1 -
按位或（|）：对两个数的每个位进行或操作，只要有一个位为1，结果为1。
int result = a | b; // 结果为0111，即7 -
按位异或（^）：对两个数的每个位进行异或操作，相同则为0，不同则为1。
int result = a ^ b; // 结果为0110，即6 -
按位取反（~）：将每个位取反。
int result = ~a; // 结果为11111010（补码形式） -
左移（<<）：将二进制位左移n位，右边补0。
int result = a << 1; // 结果为1010，即10 -
右移（>>）：将二进制位右移n位。
int result = a >> 1; // 结果为0010，即2
5.7 条件运算符（三元运算符）
条件运算符 ?: 是一个简写形式的 if-else 语句，通常用于简单的条件判断。
-
语法：
condition ? expression1 : expression2; -
示例：
int a = 10, b = 20; int max = (a > b) ? a : b; // 如果a > b，max为a，否则max为b
5.8 扩展：运算符的优先级和结合性
C语言中，运算符有优先级和结合性，决定了在表达式中它们的执行顺序。了解运算符的优先级可以避免不必要的括号。
-
优先级：
*和/的优先级高于+和-，因此它们会先被计算。例如：int result = 5 + 3 * 2; // 结果为11，而不是16 -
结合性：大多数二元运算符是左结合的，意味着它们从左到右计算。例如：
int result = 5 - 3 - 1; // 结果为1，相当于(5 - 3) - 1
6. 条件语句
C语言中的条件语句用于根据特定条件执行不同的代码块。主要的条件语句包括 if、else if 和 else，它们可以组合使用来创建多分支的条件判断。
6.1 if 语句
if 语句用于测试一个条件。如果条件为 true（即非零值），则执行对应的代码块；如果条件为 false（即零值），则跳过该代码块。
-
语法：
if (condition) { // 如果condition为true，则执行此代码 } -
示例：
int num = 5; if (num > 0) { printf("Positive number\n"); }
6.2 else 语句
else 语句用于处理 if 语句的 “否则” 情况，即当 if 条件为 false 时执行 else 块中的代码。
-
语法：
if (condition) { // 当condition为true时执行 } else { // 当condition为false时执行 } -
示例：
int num = -3; if (num > 0) { printf("Positive number\n"); } else { printf("Negative number or zero\n"); }
6.3 else if 语句
else if 语句用于在 if 条件之外再添加一个条件。如果 if 条件为 false，则检查 else if 条件；如果 else if 条件为 true，则执行其代码块。
-
语法：
if (condition1) { // 如果condition1为true，执行此代码 } else if (condition2) { // 如果condition1为false且condition2为true，执行此代码 } else { // 如果以上条件都不成立，则执行此代码 } -
示例：
int num = 0; if (num > 0) { printf("Positive number\n"); } else if (num < 0) { printf("Negative number\n"); } else { printf("Zero\n"); }
6.4 嵌套条件语句
条件语句可以嵌套，即在 if、else if 或 else 语句块内再放置另一个 if 语句。这种嵌套可以处理更加复杂的逻辑。
- 示例：
int num = 15; if (num > 0) { if (num % 2 == 0) { printf("Positive even number\n"); } else { printf("Positive odd number\n"); } } else { printf("Non-positive number\n"); }
6.5 条件运算符（三元运算符）
条件运算符 ?: 是 if-else 的简写形式，用于简化简单的条件判断。它是一个三元运算符，因为它有三个操作数。
-
语法：
condition ? expression1 : expression2; -
示例：
int num = 5; const char *result = (num > 0) ? "Positive" : "Negative or zero"; printf("%s\n", result);
在这个例子中，(num > 0) 是条件，如果为 true，result 会被赋值为 "Positive"，否则赋值为 "Negative or zero"。
6.6 switch 语句
除了 if-else 之外，C语言还提供了 switch 语句，它用于对一个表达式的多个值进行条件判断。switch 适合用于多个可能值的情况，逻辑清晰且避免了过多的嵌套 if-else。
-
语法：
switch (expression) { case constant1: // 当expression等于constant1时执行 break; case constant2: // 当expression等于constant2时执行 break; default: // 当expression不匹配任何case时执行 } -
示例：
int day = 3; switch (day) { case 1: printf("Monday\n"); break; case 2: printf("Tuesday\n"); break; case 3: printf("Wednesday\n"); break; default: printf("Invalid day\n"); }
在这个例子中，如果 day 的值为3，则输出 “Wednesday”。break 语句用于防止程序执行到下一个 case，default 用于处理没有匹配的情况。
6.7 条件语句的最佳实践
-
保持条件表达式简单：条件语句中的表达式应保持简单和易读。复杂的逻辑可以拆分成多个
if语句或用函数封装。 -
避免过度嵌套：嵌套过多的
if-else语句会使代码难以维护，可以使用switch语句或将复杂逻辑抽象到函数中。 -
确保覆盖所有情况：在处理条件时，确保使用
else或default来处理未预见的情况，防止遗漏某些条件。
7. 循环语句
循环语句是C语言中用于重复执行某段代码的控制结构。C语言支持三种主要的循环语句：for 循环、while 循环和 do-while 循环。每种循环都有其适用的场景和特点。
7.1 for 循环
for 循环用于在已知重复次数的情况下，执行一个代码块。通常它包含三部分：初始化、条件、迭代表达式。
-
语法：
for (initialization; condition; increment/decrement) { // 循环体 } -
解释：
- 初始化：在循环开始时执行一次，用于初始化循环控制变量。
- 条件：每次循环迭代前都会检查条件。如果条件为
true，执行循环体；为false时，终止循环。 - 增量/减量：在每次循环结束后，更新循环控制变量。
-
示例：
#include <stdio.h> int main() { for (int i = 0; i < 5; i++) { printf("i = %d\n", i); } return 0; }
在上面的示例中，for 循环从 i = 0 开始，当 i < 5 时执行循环体，并在每次循环结束时执行 i++。
7.2 while 循环
while 循环用于在不确定循环次数但需要根据条件控制的情况下使用。循环在每次迭代前先检查条件。
-
语法：
while (condition) { // 循环体 } -
解释：
- 条件：在进入循环体之前首先检查条件，如果为
true，执行循环体；否则结束循环。 - 循环体：在条件为
true的情况下反复执行的代码块。
- 条件：在进入循环体之前首先检查条件，如果为
-
示例：
#include <stdio.h> int main() { int i = 0; while (i < 5) { printf("i = %d\n", i); i++; } return 0; }
在这个例子中，while 循环通过检查 i < 5 来控制是否继续执行循环。当 i 达到5时，循环结束。
7.3 do-while 循环
do-while 循环类似于 while 循环，但它会先执行一次循环体，然后再检查条件。因此，即使条件为 false，循环体也会至少执行一次。
-
语法：
do { // 循环体 } while (condition); -
解释：
- 循环体：无论条件如何，首先执行循环体一次。
- 条件：在每次循环结束后进行检查。如果条件为
true，则继续执行循环；否则结束循环。
-
示例：
#include <stdio.h> int main() { int i = 0; do { printf("i = %d\n", i); i++; } while (i < 5); return 0; }
在这个例子中，do-while 循环确保 i = 0 时循环体至少被执行一次，之后再判断条件 i < 5。
7.4 循环控制语句
7.4.1 break 语句
break 语句用于立即退出循环，跳过剩余的循环体，即使循环条件依然为 true。常用于提前结束循环。
- 示例：
#include <stdio.h> int main() { for (int i = 0; i < 5; i++) { if (i == 3) { break; // 当i为3时，退出循环 } printf("i = %d\n", i); } return 0; }
当 i 等于3时，break 语句将终止循环，输出的结果为 i = 0, 1, 2。
7.4.2 continue 语句
continue 语句用于跳过当前循环的剩余部分，并开始下一次迭代。它通常用于跳过不需要执行的循环体。
- 示例：
#include <stdio.h> int main() { for (int i = 0; i < 5; i++) { if (i == 3) { continue; // 跳过i等于3时的迭代 } printf("i = %d\n", i); } return 0; }
当 i 等于3时，continue 语句将跳过当前迭代，因此输出的结果为 i = 0, 1, 2, 4。
7.4.3 goto 语句
goto 语句是一种跳转语句，可以跳转到程序中指定的标签位置。尽管 goto 语句可以用于循环控制，但一般不建议使用，因为它会使程序逻辑难以跟踪。
-
语法：
goto label; ... label: // 跳转到这里执行 -
示例：
#include <stdio.h> int main() { int i = 0; while (i < 5) { if (i == 3) { goto skip; // 当i等于3时，跳转到标签skip } printf("i = %d\n", i); i++; } return 0; skip: printf("Skipped iteration\n"); }
7.5 嵌套循环
循环可以嵌套使用，一个循环体中可以包含另一个循环。嵌套循环通常用于处理多维数组或实现多重条件判断。
- 示例：
#include <stdio.h> int main() { for (int i = 0; i < 3; i++) { for (int j = 0; j < 2; j++) { printf("i = %d, j = %d\n", i, j); } } return 0; }
在这个例子中，外层循环执行3次，内层循环每次执行2次，最终结果是输出所有 i 和 j 的组合。
7.6 无限循环
在某些情况下，循环可能永远不会终止，称为无限循环。无限循环在程序设计中通常用于等待某个条件触发或需要持续运行的任务。最常见的无限循环是 while (1)。
- 示例：
#include <stdio.h> int main() { while (1) { printf("This is an infinite loop.\n"); break; // 为了避免实际无限循环，这里使用break退出 } return 0; }
7.7 循环语句的最佳实践
- 避免无限循环：如果确实需要使用无限循环，确保有合适的退出机制，如
break语句或合理的条件。 - 减少嵌套层次：深度嵌套循环会影响代码可读性，尽量减少嵌套层次，并考虑将复杂逻辑抽象成函数。
- 选择合适的循环类型：根据情况选择
for、while或do-while循环。例如，当循环次数已知时，使用for循环。
8. 函数
在C语言中，函数是将代码组织成可重用模块的核心工具。通过函数，代码可以变得更简洁、模块化和易于维护。每个函数封装一段独立的功能，可以在程序的不同部分多次调用。
8.1 函数的结构
一个完整的C语言函数通常包含三部分：
- 函数声明（函数原型）：用于声明函数，告诉编译器函数的名称、参数类型以及返回类型。
- 函数定义：定义了函数的具体实现，即函数执行的操作。
- 函数调用：在程序中调用已声明或定义的函数。
8.2 函数声明
函数声明用于在函数调用之前告诉编译器该函数的名称、参数类型和返回类型。它的作用是确保编译器在看到函数调用时知道该函数的签名和返回类型。
-
语法：
返回类型 函数名(参数类型 参数名, ...); -
示例：
int add(int x, int y); // 声明add函数，接受两个int参数并返回int类型结果
声明告诉编译器 add() 函数接收两个整数参数，并返回一个整数结果。在函数定义之前必须先声明函数（除非函数定义在调用之前）。
8.3 函数定义
函数定义包含了函数的具体实现，即执行的操作和返回值。
-
语法：
返回类型 函数名(参数类型 参数名, ...) { // 函数体 return 返回值; // 对于非void函数 } -
示例：
int add(int x, int y) { return x + y; // 返回两个整数的和 }
函数 add() 定义了加法操作，接受两个整数 x 和 y，并返回它们的和。
8.4 函数调用
函数调用是指在程序中使用定义好的函数。调用时根据函数的参数列表传递实际参数（实参）。
-
语法：
函数名(实参1, 实参2, ...); -
示例：
int result = add(3, 5); // 调用add函数，传递实参3和5
8.5 函数的返回类型
-
每个函数都有一个返回类型，表示函数返回的结果类型。返回类型可以是基本数据类型（如
int、float）或void，其中void表示函数没有返回值。 -
返回值函数：
- 如果函数有返回值，则需要在函数体中使用
return语句来返回值。
int multiply(int a, int b) { return a * b; // 返回两个整数的乘积 } - 如果函数有返回值，则需要在函数体中使用
-
无返回值函数：
void类型函数不需要返回任何值，return语句可以省略或仅用于退出函数。
void greet() { printf("Hello, World!\n"); }
8.6 参数传递
-
按值传递：
-
C语言默认使用按值传递方式，即将实参的值复制一份传递给形参。函数内部对形参的操作不会影响外部实参。
-
示例：
void changeValue(int a) { a = 10; // 不会影响主函数中的变量 } int main() { int x = 5; changeValue(x); printf("x = %d\n", x); // x仍然为5 return 0; }
-
-
按指针传递：
-
如果希望在函数内部修改实参的值，可以使用指针来传递变量的地址。通过指针，函数可以直接修改外部变量的值。
-
示例：
void changeValue(int *a) { *a = 10; // 修改指向的变量 } int main() { int x = 5; changeValue(&x); // 传递x的地址 printf("x = %d\n", x); // x现在为10 return 0; }
-
8.7 递归函数
递归是指函数调用自身。在某些场景下，递归是一种简洁且有效的解决问题的方法，比如计算阶乘或斐波那契数列。
- 示例：计算一个数的阶乘
int factorial(int n) { if (n == 0) { return 1; // 基本情况：0的阶乘是1 } else { return n * factorial(n - 1); // 递归调用 } } int main() { int num = 5; printf("Factorial of %d is %d\n", num, factorial(num)); return 0; }
8.8 函数的作用域和生命周期
-
局部变量：在函数内部声明的变量称为局部变量，只有在该函数中有效，函数结束后局部变量被销毁。
-
全局变量：在所有函数之外声明的变量称为全局变量，可以在整个程序的任何地方访问。
-
静态变量：使用
static关键字声明的局部变量，其值在函数调用结束后不会销毁，下一次调用时仍然保留上次的值。 -
示例：
void increment() { static int count = 0; // 静态局部变量 count++; printf("Count = %d\n", count); } int main() { increment(); // 输出 Count = 1 increment(); // 输出 Count = 2 return 0; }
8.9 函数的重用性和可维护性
函数使得代码更加模块化和可复用。通过将常用的操作封装成函数，程序员可以避免重复编写相同的代码，便于修改和维护。
- 好处：
- 提高代码的可读性和组织性。
- 提高代码的复用性，减少代码重复。
- 使得代码更易于调试和测试。
9. 数组
在C语言中，数组是用来存储相同类型数据的一种集合数据结构。数组可以存储多个元素，这些元素在内存中是连续存储的，并通过数组的下标来访问每个元素。
9.1 数组的定义
数组的基本语法如下：
数据类型 数组名[数组长度];
-
数据类型：数组中元素的类型，可以是
int、float、char等。 -
数组名：数组的标识符，用于引用数组。
-
数组长度：数组可以存储元素的数量。数组长度必须是一个常量值。
-
示例：
int arr[5]; // 定义一个长度为5的整型数组
9.2 数组的初始化
数组在定义时可以使用大括号 {} 进行初始化，赋值给数组中的每个元素。未赋值的元素将被初始化为 0（仅限于全局或静态数组）。
- 示例：
int arr[5] = {1, 2, 3, 4, 5}; // 初始化数组arr的每个元素
如果你只为部分元素赋值，未赋值的元素将自动初始化为 0。
- 示例：
int arr[5] = {1, 2}; // 前两个元素为1和2，剩余元素初始化为0
9.3 访问数组元素
数组的元素通过下标（索引）访问。数组的下标从 0 开始，因此第一个元素是 arr[0]，最后一个元素是 arr[数组长度-1]。
- 示例：
#include <stdio.h> int main() { int arr[5] = {1, 2, 3, 4, 5}; // 定义并初始化数组 for (int i = 0; i < 5; i++) { printf("arr[%d] = %d\n", i, arr[i]); // 访问并打印每个元素 } return 0; }
在上面的例子中，使用 for 循环遍历数组，通过下标访问每个元素。
9.4 多维数组
C语言支持多维数组，最常用的是二维数组，它可以看作是一个矩阵。多维数组的定义格式如下：
数据类型 数组名[行数][列数];
- 示例：
int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}}; // 定义一个2x3的二维数组
访问二维数组的元素时，需要指定行和列的下标：
- 示例：
printf("matrix[1][2] = %d\n", matrix[1][2]); // 输出第2行第3列的元素，结果为6
9.5 字符数组与字符串
在C语言中，字符串其实是以 \0 结尾的字符数组。可以通过字符数组来存储字符串。
- 示例：
char str[] = "Hello, World!"; // 定义一个字符串 printf("%s\n", str); // 输出字符串
字符串的每个字符都占用一个字节，且最后一个字符是空字符 \0，用于表示字符串的结束。
9.6 数组作为函数参数
数组可以作为函数的参数传递给函数。在传递时，实际上传递的是数组的首地址，因此在函数内部对数组的修改会影响外部的数组。
- 示例：传递数组给函数并打印数组元素
void printArray(int arr[], int size) { for (int i = 0; i < size; i++) { printf("%d ", arr[i]); } printf("\n"); } int main() { int arr[5] = {1, 2, 3, 4, 5}; printArray(arr, 5); // 传递数组和长度 return 0; }
在这个例子中，arr 被传递给 printArray() 函数，函数通过下标访问并打印数组的元素。
9.7 数组越界
访问数组时，需要确保下标不越界。数组越界是指试图访问数组范围之外的元素，这会导致未定义行为，可能会引发程序崩溃或出现错误的结果。
- 错误示例：
int arr[5] = {1, 2, 3, 4, 5}; printf("%d\n", arr[5]); // 错误：合法的下标范围是0到4
数组的有效下标范围是 0 到 数组长度 - 1，超出该范围的访问将导致越界。
9.8 数组的优势与局限
-
优势：
- 使用数组可以方便地存储和管理一组相同类型的数据。
- 数组允许通过下标快速访问和修改数据。
-
局限：
- 数组的大小在定义时必须确定，无法动态调整。
- 在访问数组时需要确保下标合法，否则会导致程序异常。
10. 指针
在C语言中，指针是一个特殊的变量，用于存储另一个变量的内存地址。指针是C语言的重要特性之一，它使得程序可以直接操作内存，提高了灵活性和效率。通过指针，可以实现动态内存分配、数组和字符串操作、函数参数的引用传递等。
10.1 指针的定义
指针的定义格式如下：
数据类型 *指针名;
-
数据类型：指针所指向的变量的类型，例如
int、float、char等。 -
指针名：指针变量的名称。
-
*：表示这是一个指针变量，指向某个类型的地址。 -
示例：
int *p; // 定义一个指向int类型变量的指针p
10.2 获取变量地址
每个变量都有一个唯一的内存地址。使用 & 操作符可以获取变量的地址。
- 示例：
int a = 10; int *p = &a; // p存储变量a的地址
在这段代码中，p 指针存储了变量 a 的地址，&a 是获取 a 的地址。
10.3 访问指针指向的值
通过指针可以访问指向地址处的值，这被称为解引用。使用 * 操作符可以获取指针指向的变量值。
- 示例：
int a = 10; int *p = &a; printf("Value at pointer p: %d\n", *p); // 解引用，输出a的值
在这个示例中，*p 返回的是指针 p 所指向的地址处的值，即 a 的值。
10.4 指针的基本操作示例
#include <stdio.h>
int main() {
int a = 10;
int *p = &a; // 定义指针并指向a的地址
printf("Value of a: %d\n", a); // 输出a的值
printf("Address of a: %p\n", &a); // 输出a的地址
printf("Address stored in pointer p: %p\n", p); // 输出指针p存储的地址
printf("Value at pointer p: %d\n", *p); // 输出指针p指向的值
return 0;
}
- 输出解释：
a的值为10，这是直接访问变量a。&a是a的地址，p存储的也是这个地址。*p是通过指针p访问a的值。
10.5 指针与数组
数组的变量名实际上是一个指向数组第一个元素的指针，因此指针可以用于遍历和操作数组。
- 示例：
int arr[3] = {1, 2, 3}; int *p = arr; // 数组名arr即为指向第一个元素的指针 for (int i = 0; i < 3; i++) { printf("arr[%d] = %d, *(p + %d) = %d\n", i, arr[i], i, *(p + i)); }
在这个例子中，p + i 是指向数组 arr 中第 i 个元素的指针，*(p + i) 则获取该元素的值。
10.6 指针与字符串
字符串在C语言中是以 \0 结尾的字符数组，指针可以用于访问和操作字符串。
- 示例：
char str[] = "Hello"; char *p = str; // 指针指向字符串的首字符 while (*p != '\0') { printf("%c", *p); // 逐个字符打印 p++; // 移动指针 } printf("\n");
在这个例子中，指针 p 遍历字符串 str，直到遇到字符串结束符 \0。
10.7 指针与函数
指针可以作为函数的参数传递，这使得函数可以修改传入变量的值（通过传递变量的地址）。这通常被称为按引用传递。
- 示例：使用指针修改变量的值
void changeValue(int *p) { *p = 20; // 修改指针指向的值 } int main() { int a = 10; printf("Before: %d\n", a); // 输出10 changeValue(&a); // 传递a的地址 printf("After: %d\n", a); // 输出20 return 0; }
在这个示例中，changeValue() 函数通过指针修改了变量 a 的值。
10.8 指针运算
指针不仅可以存储地址，还可以进行运算。常见的指针运算包括：
-
指针加减法：指针可以增加或减少整数值，这实际上是在内存中移动指针，通常用于遍历数组。
int arr[5] = {1, 2, 3, 4, 5}; int *p = arr; p++; // 指针p现在指向arr[1] -
指针比较：两个指针可以进行比较，通常用于判断它们是否指向同一个内存位置。
if (p == &arr[1]) { printf("p points to arr[1]\n"); }
10.9 空指针
空指针是一个不指向任何有效地址的指针，通常用来表示指针未被初始化或没有分配有效的内存地址。在C语言中，空指针通常被赋值为 NULL。
- 示例：
int *p = NULL; // 定义一个空指针
空指针在编写安全的程序时非常有用，可以避免访问未初始化或无效的内存。
10.10 野指针
野指针是指向未分配或已经释放的内存区域的指针，使用野指针可能会导致未定义的行为，甚至程序崩溃。在使用指针时，必须确保指针指向有效的内存地址。
10.11 指针数组与数组指针
-
指针数组：存储多个指针的数组，常用于字符串数组等场景。
- 示例：
char *arr[3] = {"Hello", "World", "C"};
- 示例：
-
数组指针：指向数组的指针，通常用于处理多维数组。
- 示例：
int arr[3] = {1, 2, 3}; int (*p)[3] = &arr; // p是指向数组的指针
- 示例：
11. 结构体
在C语言中，结构体（struct）用于将不同类型的数据组合在一起，形成一个复合数据类型。这种机制非常适合表示更复杂的数据结构，比如一名学生的姓名、学号和成绩，或一辆汽车的品牌、型号和价格等。
11.1 结构体的定义
结构体的定义格式如下：
struct 结构体名 {
数据类型 成员1;
数据类型 成员2;
// 其他成员...
};
- 结构体名：用于标识该结构体类型。
- 成员：每个成员可以是不同类型的变量，包括基本类型、数组、指针等。
示例：
struct Person {
char name[50];
int age;
};
这里定义了一个名为 Person 的结构体，它包含两个成员：name（字符数组，用于存储姓名）和 age（整数，用于存储年龄）。
11.2 结构体变量的声明
在定义结构体类型之后，可以声明结构体类型的变量，类似于声明基本数据类型的变量。
- 示例：
struct Person person1; // 声明一个Person类型的变量person1
11.3 访问结构体成员
使用结构体变量后，可以通过点运算符 . 来访问和操作结构体的成员。
- 示例：
struct Person person1; // 给结构体成员赋值 person1.age = 25; snprintf(person1.name, sizeof(person1.name), "Alice"); // 输出结构体成员的值 printf("Name: %s\n", person1.name); printf("Age: %d\n", person1.age);
在这个例子中，person1.name 和 person1.age 用来访问 person1 结构体中的 name 和 age 成员。
11.4 结构体初始化
可以在声明结构体变量时直接对其成员进行初始化，类似于数组初始化。
- 示例：
struct Person person2 = {"Bob", 30}; // 初始化person2的name和age
也可以使用指定初始化来赋值特定的结构体成员：
struct Person person3 = {.age = 22, .name = "Charlie"};
11.5 结构体数组
结构体可以与数组结合使用，形成结构体数组。结构体数组是存储多个相同类型结构体的集合，适合用于管理一组相关的对象。
- 示例：
struct Person people[2] = { {"Alice", 25}, {"Bob", 30} }; for (int i = 0; i < 2; i++) { printf("Person %d: Name = %s, Age = %d\n", i+1, people[i].name, people[i].age); }
在这个例子中，people 是一个包含两个 Person 结构体的数组，通过循环遍历数组可以输出每个人的姓名和年龄。
11.6 结构体指针
指针可以指向结构体，允许通过指针来访问和操作结构体的成员。使用箭头运算符 -> 来访问指针指向的结构体成员。
- 示例：
struct Person person1 = {"Alice", 25}; struct Person *ptr = &person1; // 定义指向person1的指针 // 使用箭头运算符访问结构体成员 printf("Name: %s\n", ptr->name); printf("Age: %d\n", ptr->age);
在这个示例中，ptr 是指向 person1 的指针，通过 ptr->name 和 ptr->age 来访问 person1 的成员。
11.7 结构体作为函数参数
结构体可以作为函数的参数传递。在传递结构体时，有两种方式：按值传递和按引用传递（使用指针）。
-
按值传递：将结构体变量的一个副本传递给函数，函数内部对结构体的修改不会影响原始变量。
- 示例：
void printPerson(struct Person p) { printf("Name: %s, Age: %d\n", p.name, p.age); } int main() { struct Person person1 = {"Alice", 25}; printPerson(person1); // 按值传递 return 0; }
- 示例：
-
按引用传递（指针传递）：将结构体变量的地址传递给函数，函数可以修改原始结构体变量的内容。
- 示例：
void modifyPerson(struct Person *p) { p->age = 30; // 修改age成员 } int main() { struct Person person1 = {"Alice", 25}; modifyPerson(&person1); // 传递person1的地址 printf("Modified Age: %d\n", person1.age); // 输出30 return 0; }
- 示例：
11.8 嵌套结构体
结构体可以嵌套，即一个结构体中可以包含另一个结构体作为成员。
- 示例：
struct Date { int day; int month; int year; }; struct Person { char name[50]; int age; struct Date birthdate; // 嵌套结构体 }; int main() { struct Person person1 = {"Alice", 25, {15, 8, 1996}}; printf("Name: %s, Age: %d, Birthdate: %02d/%02d/%d\n", person1.name, person1.age, person1.birthdate.day, person1.birthdate.month, person1.birthdate.year); return 0; }
在这个示例中，Person 结构体包含了一个 Date 结构体，用于存储出生日期。
11.9 typedef 与结构体
使用 typedef 关键字可以为结构体定义一个别名，从而简化结构体的使用。
- 示例：
typedef struct { char name[50]; int age; } Person; // 定义结构体别名Person int main() { Person person1 = {"Alice", 25}; // 使用别名定义变量 printf("Name: %s, Age: %d\n", person1.name, person1.age); return 0; }
通过 typedef，可以省去每次使用结构体时加上 struct 关键字的麻烦。
12. 动态内存分配
在C语言中，数组的大小必须在编译时确定，不能在运行时动态调整。为了解决这个问题，C语言提供了动态内存分配的机制，允许程序在运行时根据需要动态分配内存空间。常用的动态内存分配函数包括 malloc()、calloc()、realloc() 和 free()，它们都在 <stdlib.h> 头文件中定义。
12.1 malloc() 函数
malloc() 函数用于分配指定大小的内存块，返回的是指向该内存块起始地址的指针。内存中的初始值不确定（可能是随机值），需要手动初始化。
-
语法：
void* malloc(size_t size); -
参数：
size_t size：需要分配的内存大小，以字节为单位。
-
返回值：
- 成功时，
malloc()返回指向分配内存的指针。 - 如果内存分配失败，返回
NULL。
- 成功时，
-
示例：
int *ptr; ptr = (int*) malloc(5 * sizeof(int)); // 分配5个整型大小的内存
12.2 calloc() 函数
calloc() 函数与 malloc() 类似，但它会初始化分配的内存为 0，且允许一次分配多个元素。
-
语法：
void* calloc(size_t num, size_t size); -
参数：
num：要分配的元素个数。size：每个元素的大小，以字节为单位。
-
返回值：
- 成功时，
calloc()返回指向分配内存的指针。 - 如果内存分配失败，返回
NULL。
- 成功时，
-
示例：
int *ptr; ptr = (int*) calloc(5, sizeof(int)); // 分配5个整型大小的内存，并初始化为0
12.3 realloc() 函数
realloc() 函数用于调整已经分配的动态内存块的大小。它可以扩展或缩小之前分配的内存空间。如果内存不足，realloc() 可能会移动内存块到新的位置。
-
语法：
void* realloc(void* ptr, size_t new_size); -
参数：
ptr：指向已分配的内存块的指针。new_size：新的内存块大小。
-
返回值：
- 成功时，
realloc()返回指向新分配内存的指针。 - 如果失败，返回
NULL，并且原内存块保持不变。
- 成功时，
-
示例：
ptr = (int*) realloc(ptr, 10 * sizeof(int)); // 将内存扩展为10个整型大小
12.4 free() 函数
free() 函数用于释放动态分配的内存，释放后这段内存可以重新用于其他目的。调用 free() 后，不应再使用该指针访问内存。
-
语法：
void free(void* ptr); -
参数：
ptr：指向需要释放的内存块的指针。
-
示例：
free(ptr); // 释放之前分配的内存
12.5 动态内存分配的示例
以下是一个完整的示例，展示了如何使用 malloc() 动态分配内存，并在使用后释放内存：
#include <stdio.h>
#include <stdlib.h>
int main() {
int *ptr;
int n = 5;
// 动态分配内存
ptr = (int*) malloc(n * sizeof(int));
// 检查内存分配是否成功
if (ptr == NULL) {
printf("Memory allocation failed\n");
return 1; // 退出程序
}
// 使用分配的内存
for (int i = 0; i < n; i++) {
ptr[i] = i + 1; // 为动态分配的数组赋值
printf("%d ", ptr[i]);
}
printf("\n");
// 释放内存
free(ptr);
return 0;
}
- 解释：
- 使用
malloc()动态分配了n个int大小的内存空间。 - 通过检查
ptr是否为NULL来确认内存分配是否成功。 - 使用
for循环遍历动态分配的数组，并对其进行初始化和打印。 - 使用
free()释放分配的内存，防止内存泄漏。
- 使用
12.6 常见问题
-
内存泄漏：如果动态分配的内存未被释放，程序将占用越来越多的内存，这就是内存泄漏。因此，确保每次动态分配内存后，及时调用
free()释放内存。 -
访问未分配或已释放的内存：在访问动态分配的内存时，确保指针指向有效的内存。访问未分配或已经释放的内存将导致程序崩溃或出现未定义行为。
-
空指针检查：在使用
malloc()、calloc()或realloc()分配内存后，始终要检查返回的指针是否为NULL，以确保内存分配成功。 -
calloc()与malloc()的区别：calloc()初始化分配的内存为0，而malloc()则不初始化，可能包含垃圾值。如果需要清零内存，calloc()更合适。
13. 文件操作
C语言提供了一组用于文件操作的函数，允许程序读写文件中的数据。通过文件操作，程序可以将数据持久化，或从文件中读取数据进行处理。文件操作通常包括打开文件、读写文件和关闭文件等步骤。
13.1 文件操作的步骤
文件操作的基本步骤如下：
- 打开文件：使用
fopen()函数打开文件。 - 读/写文件：使用
fprintf()、fscanf()、fread()、fwrite()等函数对文件进行读写操作。 - 关闭文件：使用
fclose()函数关闭文件，释放资源。
13.2 fopen() 函数
fopen() 用于打开一个文件，返回一个指向 FILE 类型的指针。如果文件打开成功，则返回该文件的指针；如果失败，则返回 NULL。
-
语法：
FILE* fopen(const char* filename, const char* mode); -
参数：
filename：要打开的文件名。mode：文件的打开模式，如"r"（只读）、"w"（写入，若文件不存在则创建）等。
-
常见的文件打开模式：
"r"：以只读模式打开文件。文件必须存在。"w"：以写入模式打开文件。如果文件不存在，则创建；如果文件存在，则清空文件内容。"a"：以追加模式打开文件。如果文件不存在，则创建；如果文件存在，数据会被追加到文件末尾。"r+"：以读写模式打开文件。文件必须存在。"w+"：以读写模式打开文件。如果文件不存在，则创建；如果文件存在，则清空文件内容。"a+"：以读写模式打开文件。如果文件不存在，则创建；如果文件存在，数据会被追加到文件末尾。
示例：打开文件进行写操作
#include <stdio.h>
int main() {
FILE *fptr;
fptr = fopen("test.txt", "w"); // 以写入模式打开文件
if (fptr == NULL) {
printf("Error opening file\n");
return 1;
}
fprintf(fptr, "Hello, file!\n"); // 写入文件
fclose(fptr); // 关闭文件
return 0;
}
- 解释：
fopen("test.txt", "w")：以写入模式打开test.txt文件。如果文件不存在，则会创建该文件。fprintf(fptr, "Hello, file!\n")：向文件中写入字符串"Hello, file!"。fclose(fptr)：关闭文件，释放与文件相关的资源。
13.3 fprintf() 和 fscanf() 函数
-
fprintf()：用于向文件中写入格式化的数据。类似于printf()，但它的输出目标是文件，而不是控制台。-
语法：
int fprintf(FILE *stream, const char *format, ...); -
示例：
fprintf(fptr, "Name: %s, Age: %d\n", "Alice", 25);
-
-
fscanf()：用于从文件中读取格式化的数据。类似于scanf()，但它从文件中读取数据而不是从标准输入读取。-
语法：
int fscanf(FILE *stream, const char *format, ...); -
示例：
int age; fscanf(fptr, "%d", &age); // 从文件中读取整数并存储到变量age中
-
示例：文件读写
#include <stdio.h>
int main() {
FILE *fptr;
// 写入文件
fptr = fopen("test.txt", "w");
if (fptr == NULL) {
printf("Error opening file\n");
return 1;
}
fprintf(fptr, "Alice 25\nBob 30\n"); // 写入两行数据
fclose(fptr); // 关闭文件
// 读取文件
fptr = fopen("test.txt", "r");
if (fptr == NULL) {
printf("Error opening file\n");
return 1;
}
char name[50];
int age;
while (fscanf(fptr, "%s %d", name, &age) != EOF) { // 读取直到文件末尾
printf("Name: %s, Age: %d\n", name, age); // 输出读取的数据
}
fclose(fptr); // 关闭文件
return 0;
}
- 解释：
- 在写入阶段，程序使用
fprintf()将两行数据写入文件。 - 在读取阶段，程序使用
fscanf()从文件中逐行读取数据，并输出到控制台。
- 在写入阶段，程序使用
13.4 fread() 和 fwrite() 函数
-
fread()和fwrite()是用于从文件中读取或写入二进制数据的函数，通常用于处理非文本文件。 -
fread()语法：size_t fread(void *ptr, size_t size, size_t count, FILE *stream); -
fwrite()语法：size_t fwrite(const void *ptr, size_t size, size_t count, FILE *stream); -
参数：
ptr：指向要读取/写入的内存区域。size：每个元素的大小（以字节为单位）。count：要读取/写入的元素个数。stream：文件指针。
示例：二进制文件操作
#include <stdio.h>
#include <stdlib.h>
int main() {
FILE *fptr;
int data[5] = {1, 2, 3, 4, 5};
// 写入二进制文件
fptr = fopen("data.bin", "wb"); // 以二进制写入模式打开文件
if (fptr == NULL) {
printf("Error opening file\n");
return 1;
}
fwrite(data, sizeof(int), 5, fptr); // 写入5个整数
fclose(fptr);
// 读取二进制文件
fptr = fopen("data.bin", "rb"); // 以二进制读取模式打开文件
if (fptr == NULL) {
printf("Error opening file\n");
return 1;
}
int read_data[5];
14. 预处理指令
预处理指令是C语言中在编译之前执行的命令，由预处理器处理。预处理指令并不会直接生成机器代码，而是通过修改、替换或扩展代码来为正式的编译做准备。预处理指令通常以 # 开头，并且在编译前被执行。常见的预处理指令包括 #include、#define、#if、#else、#elif、#endif 等。
14.1 #include
#include 指令用于在源文件中包含其他文件（通常是头文件）。头文件可以包含函数声明、宏定义等信息。#include 有两种使用方式：
- 尖括号
< >：用于包含标准库文件，编译器会在系统默认的目录中查找头文件。 - 双引号
""：用于包含用户定义的文件，编译器会在当前目录中查找文件。
- 示例：
#include <stdio.h> // 包含标准输入输出库 #include "myheader.h" // 包含用户自定义头文件
14.2 #define
#define 指令用于定义宏。宏是一种文本替换机制，编译器在编译前会将所有宏名替换为定义的内容。宏可以用来定义常量，也可以带参数。
-
简单宏定义：
-
示例：
#define PI 3.14159 // 定义PI为3.14159 -
宏定义后，所有
PI都会被替换为3.14159。
-
-
带参数的宏：
-
示例：
#define SQUARE(x) ((x) * (x)) // 带参数的宏，用于计算平方 -
SQUARE(4)将会被替换为((4) * (4))，结果是16。
-
示例：
#include <stdio.h>
#define PI 3.14159
#define SQUARE(x) ((x) * (x))
int main() {
printf("Value of PI: %f\n", PI); // 输出PI的值
printf("Square of 5: %d\n", SQUARE(5)); // 输出5的平方
return 0;
}
在这个示例中，#define 被用于定义常量 PI 和带参数的宏 SQUARE，在编译时，所有 PI 和 SQUARE(x) 会被替换为各自定义的值或表达式。
14.3 条件编译指令
条件编译指令允许根据特定条件来决定是否编译某段代码。这对于跨平台开发、调试等场景非常有用。常见的条件编译指令包括 #if、#ifdef、#ifndef、#else、#elif 和 #endif。
-
#ifdef和#ifndef：分别用于检查宏是否被定义。如果宏被定义（#ifdef）或没有被定义（#ifndef），则编译其中的代码。-
示例：
#define DEBUG #ifdef DEBUG printf("Debug mode enabled\n"); #endif -
如果
DEBUG被定义，printf语句将被编译；否则将被忽略。
-
-
#if和#else：用于根据条件编译代码。- 示例：
#define VERSION 2 #if VERSION == 1 printf("Version 1\n"); #else printf("Version 2 or above\n"); #endif
- 示例：
14.4 #undef
#undef 用于取消已经定义的宏。被取消的宏不能再被使用。
- 示例：
#define TEMP 100 #undef TEMP
在这个例子中，TEMP 宏在 #undef 之后不再有效。
14.5 #pragma
#pragma 是一个编译器相关的指令，用于指定编译器的一些行为。不同的编译器可能支持不同的 #pragma 指令，因此它是非标准的。
- 示例：
#pragma warning(disable: 4996) // 禁用特定警告（编译器特定）
14.6 文件包含的防护（头文件保护）
为了避免头文件被多次包含，通常在头文件中使用条件编译指令 #ifndef 和 #define 来确保头文件只会被编译一次。这种机制称为文件包含防护。
- 示例：
#ifndef MYHEADER_H
#define MYHEADER_H
// 头文件内容
#endif
在这个示例中，MYHEADER_H 是一个宏，第一次包含头文件时，它还没有被定义，因此头文件中的内容会被编译。之后，如果该头文件再次被包含，MYHEADER_H 已经被定义，编译器会跳过文件内容。
14.7 #error 和 #warning
-
#error指令用于在编译过程中生成错误消息，迫使编译过程停止。 -
#warning用于生成警告消息，但不会终止编译。 -
示例：
#if __STDC_VERSION__ < 199901L #error "C99 support is required" #endif
在这个示例中，如果编译器不支持 C99 标准，编译过程将停止并生成错误消息。
结论
C语言的基础语法涵盖了变量、数据类型、控制结构、循环、数组、指针、函数、结构体等关键内容。这些概念构成了C语言编程的核心，通过学习和掌握这些基础知识，开发者能够编写高效、结构清晰且功能强大的程序。
- 变量和数据类型 提供了程序存储和处理不同类型数据的基础。
- 控制结构（如
if-else、switch）和 循环（如for、while）允许程序根据条件执行不同的代码块，或者重复执行某段代码。 - 数组和指针 是C语言中强大的数据结构，通过它们可以有效地操作数据集合和内存。
- 函数 实现了代码的模块化，提高了程序的可读性和复用性。
- 结构体 则提供了将不同类型的数据组合在一起的能力，便于处理复杂的数据结构。
此外，动态内存分配、文件操作 和 预处理指令 等功能，进一步增强了C语言的灵活性和实用性，使得C语言能够应用于从系统编程到应用软件开发的广泛领域。
通过这些基础知识的学习和应用，你可以编写出高效、健壮的C语言程序，为更高级的编程奠定坚实的基础。
扫一扫
2450
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
