这个c语言入门，目标人群是有代码基础的，例如你之前学过javaSE，看此文章可能是更有帮助，会让你快速掌握他们之间的差异，文章内容大部分都是泛谈，详细的部分我会在之后时间发布，我也在慢慢学习，勉励同志们。
随后时间我会发布C语言详细（进阶版），数据结构，C++等的文章，喜欢的可以一起讨论。
目录
一. 第一个c语言程序（输出hello）
（1）VC Code输出
（2）Windows 终端 输出（有乱码不碍事）
二. 数据类型
1. 七个数据类型
2. 数据类型的长度
3. 数据类型的使用（举例）
三. 变量、常量
1.1. 定义变量
1.2. 变量的分类
1.3. 变量的使用
1.4. 变量的作用域与生命周期
2. 定量 / 常量
2.1 常量定义
2.2 常量类型
四. 字符串+转义字符+注释+格式修饰符
1. 字符串
2. 转义字符
3. 注释
4. 格式说明符
五. 选择语句
六. 循环语句
1. 循环类型
2. 代码示例
3. 循环控制语句（break/continue）
4. 运算符（符合运算符）此处不太明白，日后加强联系。
七. 函数
1.函数定义
2.函数代码示例
八. 数组
1. 数组的类型
2. 数组的下标
3. 数组的使用（遍历）
3.1.常规数组的使用与遍历
（1）. 常规遍历-正序
（2）. 常规遍历-倒叙
3.2. 二维数组的使用与（嵌套遍历）
3.3. 字符串数组与字符串的使用与遍历
3.4. 指针数组的使用与遍历
3.5. 动态数组（堆内存）的使用与遍历
4. 数组的整体代码
九. 操作符
十. 常见关键字
十一. define 定义常量和宏
关键注释说明
宏 vs 常量变量
代码示例：
十二. 指针（泛谈）
1. 什么是指针？
2. 指针操作解析表
3. 代码示例
4. 总结
指针的核心概念总结
5. 最佳实践建议
十三. 结构体（泛谈）
1. 什么是结构体？
2. 结构体操作解析表
3. 代码示例
4. 总结
5. 最佳实践建议
一. 第一个c语言程序（输出hello）
#include <stdio.h>//相当于import java中的导包，包中包含着很多你需要使用的函数等
//main就是主函数，运行程序的入口，有且必须只有一个。
int main() {printf("hello,world\n"); //输出语句，\n表示换行printf("哈啊哈\n");return 0;//因为主函数的数据类型为int，所以，返回值为int，其余同理，viod则空
}输出：
（1）VC Code输出
（2）Windows 终端 输出（有乱码不碍事）
（Linux输出其实也差不多）
二. 数据类型
1. 七个数据类型
char //字符数据类型
short //短整型
int //整形
long //长整型
long long //更长的整形
float //单精度浮点数
double //双精度浮点数
C语言中没有String字符串类型吗？？？？
c语言中string用char的数组形式来表示。下方代码有举例。
2. 数据类型的长度
3. 数据类型的使用（举例）
#include <stdio.h>int main() {char a = 'a'; // 字符型变量 achar a1[] = {'h', 'e', 'l', 'l', 'o', '\0'}; // 字符型数组 a1，注意加上结束符 '\0'char str1[] = "Hello"; // 字符数组表示字符串，即java中的stringchar *str2 = "World"; // 字符指针表示字符串short b = 10; // 短整型变量 bint c = 10; // 整型变量 clong d = 10; // 长整型变量 dfloat f = 10.0f; // 单精度浮点数 fdouble g = 10.00000; // 双精度浮点数 g// 输出变量的值printf("字符 a: %c\n", a);printf("字符数组 a1: %s\n", a1);printf("%s %s\n", str1, str2); printf("Length of str1: %zu\n", strlen(str1));//输出str1的长度，即为5printf("短整型 b: %d\n", b);printf("整型 c: %d\n", c);printf("长整型 d: %ld\n", d);printf("单精度浮点数 f: %.2f\n", f);printf("双精度浮点数 g: %.5f\n", g);return 0;}输出：
三. 变量、常量
1. 变量
1.1. 定义变量
简而言之变量即使可以更改的量，其数值可以被更改。
1.2. 变量的分类
1.全局变量
（1）即作用于代码运行全过程的变量
2.局部变量
（2）即作用于部分代码块的变量
#include <stdio.h>
// 全局变量
int globalVar = 10; // 全局变量，作用域为整个文件
void function() {// 局部变量int localVar = 5; // 局部变量，作用域仅限于此函数内printf(" 函数内 局部变量 localVar 的值: %d\n", localVar);printf(" 函数内 全局变量 globalVar 的值: %d\n", globalVar);
}int main() {printf("全局变量 globalVar 的值: %d\n", globalVar); // 可以访问全局变量function();//调用上方的函数// printf("局部变量 localVar 的值: %d\n", localVar); // 这行代码会报错，因为 localVar 作用域仅限于 function 函数return 0;
}1.3. 变量的使用
使变量等于输入两个值，使这两个变量进行加减乘除，结果取小数点后两位。
#include <stdio.h>
int main() {// 定义变量float num1, num2; // 用于存储输入的两个数float sum, difference, product, quotient; // 用于存储运算结果// 提示用户输入两个数，scanf的标准用法，于printf很相似printf("请输入第一个数: ");scanf("%f", &num1); // 读取第一个数printf("请输入第二个数: ");scanf("%f", &num2); // 读取第二个数// 进行运算sum = num1 + num2; // 加法difference = num1 - num2; // 减法product = num1 * num2; // 乘法quotient = num1 / num2; // 除法（注意：需要确保 num2 不为 0）// 输出结果，%.2f即为取余，小数点后两位，%.3f即为小数点后3位，以此类推。printf("加法结果: %.3f\n", sum);printf("减法结果: %.3f\n", difference);printf("乘法结果: %.3f\n", product);// 除法结果的输出需要检查除数是否为0if (num2 != 0) {printf("除法结果: %.2f\n", quotient);} else {printf("除法结果: 无法除以零\n");}return 0;
}输出：
1.4. 变量的作用域与生命周期
作用域：
作用域（ scope ）是程序设计概念，通常来说，一段程序代码中所用到的名字并不总是 可用的而限定这个名字的可用性的代码范围就是这个名字的作用域。1. 局部变量的作用域是变量所在的局部范围。2. 全局变量的作用域是整个代码运行过程。
生命周期：
变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段1. 局部变量的生命周期是：进入作用域生命周期开始，出作用域生命周期结束。2. 全局变量的生命周期是：整个程序的生命周期，同理。
2. 定量 / 常量
2.1 常量定义
简而言之，定量即使不变的量。
2.2 常量类型
1. 字面常量2. const 修饰的常变量（java中常用）3. #define 定义的标识符常量4. 枚举常量
#include <stdio.h>// 使用 #define 定义标识符常量
#define PI 3.14159 // 圆周率常量// 定义枚举常量
enum Color {RED, // 默认第一个为0，以此类推。GREEN, // GREEN = 1BLUE // BLUE = 2
};int main() {// 字面常量int a = 10; // 整数字面常量float b = 5.5; // 浮点数字面常量// const 修饰的常量const int MAX_VALUE = 100; // 最大值常量，不能被修改// 输出各个常量的值printf("字面常量 a: %d\n", a);printf("字面常量 b: %.2f\n", b);printf("标识符常量 PI: %.5f\n", PI);printf("const 常量 MAX_VALUE: %d\n", MAX_VALUE);// 使用枚举常量enum Color myColor = GREEN; // 赋值为枚举常量printf("枚举常量 myColor: %d\n", myColor); // 输出枚举常量的整数值return 0;
}输出
四. 字符串+转义字符+注释+格式修饰符
1. 字符串
1. 即Java中的String，用来表示多个字符在一起的样子。但是C中没有String的概念，所以字符串用char【】（字符型数组）来表示。
2. 下方的代码，用了四种方式来表示String，具体看代码注释，写的很清楚。
//可以简单认为include与java中的import是同一个意思。
#include <stdio.h> // 引入标准输入输出库，提供输入输出函数，如printf和scanf
#include <stdlib.h> // 引入标准库，包含内存分配（如malloc、free）、进程控制和转换等函数
#include <string.h> // 引入字符串处理库，提供字符串操作函数，如strcpy、strlen等int main() {// 1. 使用字符数组定义字符串char str1[] = "hello world"; // 字符数组，自动添加'\0'char str11[] ={'0','1','2','3','4','\0'}; // 字符数组，自动添加'\0'<规范>// 2. 使用字符指针定义字符串const char *str2 = "hello world"; // 字符指针指向字符串常量// 3. 动态内存分配，malloc 返回的是 void* 类型的指针，表示它可以指向任何类型的内存。//指针相当于一种特殊类型的变量char *str3 = (char *)malloc(12 * sizeof(char)); // 开辟一个char类型，12长度的内存空间变量为str3这个指针变量if (str3 == NULL) { // 检查内存是否分配存在printf("内存分配失败\n");return 1; // 返回1表示异常，并输出内存分配失败}strcpy(str3, "hello world"); // // 输出所有字符串printf("%s\n", str1); // 输出字符数组printf("%s\n", str11); // 输出字符数组printf("%s\n", str2); // 输出字符指针printf("%s\n", str3); // 输出动态分配的字符串// 释放动态分配的内存free(str3);return 0; // 返回0表示程序正常结束
}输出：
2. 转义字符
转义字符 释义（转义字符顾名思义就是转变意思。）\？ 在书写连续多个问号时使用，防止他们被解析成三字母词\' 用于表示字符常量'\" 用于表示一个字符串内部的双引号\\ 用于表示一个反斜杠，防止它被解释为一个转义序列符。\a 警告字符，蜂鸣\b 退格符\f 进纸符\n 换行\r 回车\t 水平制表符\v 垂直制表符\ddd ddd表示 1~3 个八进制的数字。 如： \130 X\xdd dd表示 2 个十六进制数字。 如： \x30 0
举例：
仔细看注释。
#include<stdio.h>
#include<string.h>
// strlen - string length - 求字符串长度
int main()
{printf("%d\n", strlen("abcdef"));printf("%d\n", strlen("abcdefg")); // 输出字符串 "abcdef" 的长度// \62被解析成一个转义字符printf("%d\n", strlen("c:\test\628\test.c"));//会输出错误，因为系统编译会把\t认识为转义符printf("%d\n", strlen("c:\\test\\628\\test.c")); // 使用双反斜杠表示反斜杠，就没有问题了。return 0;
}详细使用方法：
#include <stdio.h>int main() {// 1. \? - 表示问号字符 原因: \? 不会被解析为转义字符，直接输出问号。 printf("这是一个问号: \?\n"); // 输出: 这是一个问号: ?// 2. \' - 表示单引号字符 原因: \' 被解析为单引号字符，用于在字符串中包含单引号。printf("这是一个单引号: \'\n"); // 输出: 这是一个单引号: '// 3. \" - 表示双引号字符 原因: \" 被解析为双引号字符，用于在字符串中包含双引号。printf("这是一个双引号: \"\n"); // 输出: 这是一个双引号: "// 4. \\ - 表示反斜杠字符 原因: \\ 被解析为一个反斜杠字符，用于在字符串中包含反斜杠。printf("这是一个反斜杠: \\\n"); // 输出: 这是一个反斜杠: \// 5. \a - 表示警告音（响铃）原因: \a 表示响铃字符，某些终端或系统可能会发出声音。printf("这将响铃: \a\n"); // 可能会发出警告音（依赖于终端设置）// 6. \b - 表示退格符 原因: \b 将光标移动到前一个字符位置，覆盖该字符。printf("这是一个退格符: Hello\bWorld\n"); // 输出: HelloWorld（“Hello”中的最后一个字母被删除）// // 7. \f - 表示换页符 原因: \f 在某些终端中可能会导致换页，但在其他终端中可能没有明显效果。printf("这是一个换页符: Hello\fWorld\n"); // 输出: Hello（在某些终端中可能表现为换页）// 8. \n - 表示换行符 原因: \n 将光标移动到下一行，输出内容在新行显示。printf("这是一个换行符: Hello\nWorld\n"); // 输出: Hello// // World// 9. \r - 表示回车符 原因: \r 将光标移动到行首，后续字符会覆盖当前行的内容。printf("这是一个回车符: Hello\rWorld\n"); // 输出: World（“Hello”被覆盖）// 10. \t - 表示水平制表符 原因: \t 插入一个水平制表符的空格，增加字符之间的间距。printf("这是一个制表符: Hello\tWorld\n"); // 输出: Hello World（“Hello”和“World”之间有一个制表符的空格）// 11. \v - 表示垂直制表符 原因: \v 在某些终端中可能表现为换行，但在其他终端中可能没有明显效果printf("这是一个垂直制表符: Hello\vWorld\n"); // 输出: Hello（可能会在某些终端中表现为换行）// 12. \ddd - 表示八进制数对应的字符 原因: 八进制数表示的字符在ASCII表中对应的字符。printf("这是一个八进制字符: \101\n"); // 输出: A（八进制101对应的字符是'A'）// 13. \xdd - 表示十六进制数对应的字符 原因: 十六进制数表示的字符在ASCII表中对应的字符。printf("这是一个十六进制字符: \x41\n"); // 输出: A（十六进制41对应的字符是'A'）return 0;}}}
3. 注释
1. 代码中有不需要的代码可以直接删除，也可以注释掉2. 代码中有些代码比较难懂，可以加一下注释文字
vs Code 分为单行注释与多行注释，自己搜索，默认的我也忘了。嘿嘿嘿。
4. 格式说明符
格式说明符：
%d 或 %i 解释：输出或输入有符号十进制整数。
%u 解释：输出或输入无符号十进制整数。
%f 解释：输出或输入十进制浮点数（float）。
%lf 解释：输出或输入双精度浮点数（double）。
%c 解释：输出或输入单个字符。
%s 解释：输出或输入字符串（字符数组）。
%p 解释：输出指针的地址（内存地址）。
%o 解释：输出无符号八进制整数。
%x 或 %X 解释：输出无符号十六进制整数。%x 使用小写字母，%X 使用大写字母。
%e 或 %E 解释：以科学计数法输出浮点数。%e 使用小写字母 e，%E 使用大写字母 E。
%g 或 %G 解释：根据数值的大小自动选择使用 %f 或 %e 的格式输出浮点数。%g 使用小写字母，
%G 解释：使用大写字母。
格式说明符代码解释 ：
#include <stdio.h>
int main() {// 1. %d 或 %i - 输出或输入有符号十进制整数 // 原因: %d 用于打印有符号整数，负数会正常显示。int signedInt = -42;printf("有符号十进制整数: %d\n", signedInt); // 输出: 有符号十进制整数: -42// 2. %u - 输出或输入无符号十进制整数 // 原因: %u 用于打印无符号整数，确保不会显示负号。unsigned int unsignedInt = 42;printf("无符号十进制整数: %u\n", unsignedInt); // 输出: 无符号十进制整数: 42// 3. %f - 输出或输入十进制浮点数（float） // 原因: %f 默认输出六位小数，适用于浮点数。float floatNum = 3.14f;printf("十进制浮点数: %f\n", floatNum); // 输出: 十进制浮点数: 3.140000// 4. %lf - 输出或输入双精度浮点数（double） // 原因: %lf 用于打印双精度浮点数，默认输出六位小数。double doubleNum = 3.141592653589793;printf("双精度浮点数: %lf\n", doubleNum); // 输出: 双精度浮点数: 3.141593// 5. %c - 输出或输入单个字符 // 原因: %c 用于打印单个字符。char character = 'A';printf("单个字符: %c\n", character); // 输出: 单个字符: A// 6. %s - 输出或输入字符串（字符数组） // 原因: %s 用于打印字符串，直到遇到空字符 '\0'。char str[] = "Hello, World!";printf("字符串: %s\n", str); // 输出: 字符串: Hello, World!// 7. %p - 输出指针的地址（内存地址） // 原因: %p 用于打印指针的地址，通常以十六进制格式输出。int *ptr = &signedInt;printf("指针地址: %p\n", (void *)ptr); // 输出: 指针地址: 0x7ffeedc3a5b4（地址会因运行而异）// 8. %o - 输出无符号八进制整数 // 原因: %o 用于打印无符号整数的八进制表示。printf("无符号八进制整数: %o\n", unsignedInt); // 输出: 无符号八进制整数: 50// 9. %x 或 %X - 输出无符号十六进制整数 // 原因: %x 用于打印小写十六进制，%X 用于打印大写十六进制。printf("无符号十六进制整数 (小写): %x\n", unsignedInt); // 输出: 无符号十六进制整数 (小写): 2aprintf("无符号十六进制整数 (大写): %X\n", unsignedInt); // 输出: 无符号十六进制整数 (大写): 2A// 10. %e 或 %E - 以科学计数法输出浮点数 // 原因: %e 和 %E 用于以科学计数法格式打印浮点数。printf("科学计数法 (小写): %e\n", floatNum); // 输出: 科学计数法 (小写): 3.140000e+00printf("科学计数法 (大写): %E\n", floatNum); // 输出: 科学计数法 (大写): 3.140000E+00// 11. %g 或 %G - 根据数值的大小自动选择格式输出浮点数 // 原因: %g 和 %G 根据数值的大小选择使用 %f 或 %e 格式输出。printf("自动选择格式 (小写): %g\n", doubleNum); // 输出: 自动选择格式 (小写): 3.14159printf("自动选择格式 (大写): %G\n", doubleNum); // 输出: 自动选择格式 (大写): 3.14159return 0;
}五. 选择语句
语句类型 适用场景 特点 if单条件判断 无默认分支 if-else二选一逻辑 必须选择其一 if-else if-else多条件阶梯判断 按顺序检查条件 switch-case离散值匹配（如枚举、字符） 效率高，需 break防止穿透
输出
由于我坚信大家能看得懂，所以就不在此过多赘述！！
#include <stdio.h>int main() {//设置一些基础的变量。int score = 85;char grade = 'B';int num = 10;/* 1. 基础if语句：单条件判断 */if (score >= 60) {printf("1. 及格\n"); // 条件成立时执行}/* 2. if-else语句：二选一分支 */if (num % 2 == 0) {printf("2. 偶数\n");} else {printf("2. 奇数\n"); // 条件不成立时执行}/* 3. if-else if-else：多条件阶梯判断 */if (score >= 90) {printf("3. 优秀\n");} else if (score >= 80) {printf("3. 良好\n"); // 满足 score>=80 但 score<90} else if (score >= 60) {printf("3. 及格\n");} else {printf("3. 不及格\n"); // 默认分支}/* 4. switch-case：离散值匹配 */switch (grade) {case 'A': printf("4. 90-100分\n");break; // 必须用break阻止穿透case 'B':printf("4. 80-89分\n");break;case 'C':printf("4. 60-79分\n");break;default:printf("4. 不及格\n"); // 默认分支}return 0;
}六. 循环语句
1. 循环类型
循环类型 执行顺序 适用场景 注意事项 for先检查后执行 明确循环次数（如数组遍历） 循环变量作用域需注意 while先检查后执行 条件未知但需前置检查（如读文件） 避免忘记更新条件变量导致死循环 do-while先执行后检查 至少执行一次（如用户输入验证） 结尾分号不可遗漏
2. 代码示例
#include <stdio.h>int main() {/* 示例1: for循环（明确循环次数） */for (int i = 1; i <= 3; i++) {printf(" 第%d次循环\n", i); // 循环体执行3次}/* 示例2: while循环（条件驱动循环） */int count = 3;while (count > 0) {printf(" 剩余次数: %d\n", count);count--; // 修改条件变量避免死循环}/* 示例3: do-while循环（至少执行一次） */int input;do {printf(" 输入1继续,其他退出: ");scanf("%d", &input);} while (input >=1); // 先执行后判断/* 示例4: 循环控制语句（break/continue） */for (int j = 1; j <= 6; j++) {if (j == 3) {continue; // 跳过本次循环剩余代码，当j==3的时候，跳出本次循环，执行j==4，即输出语句不含有3。}if (j == 6) {break; // 提前终止整个循环，当j==6的时候，终止循环，即输出语句不含有6，及其以下语句。}printf(" 当前值: %d\n", j);}return 0;
}输出：
3. 循环控制语句（break/continue）
语句 作用 示例场景 break立即终止当前循环 搜索到目标后提前退出循环 continue跳过本次循环剩余代码，进入下一轮循环 过滤无效数据（如跳过负数处理）
4. 运算符（符合运算符）此处不太明白，日后加强联系。
运算符 行为描述 典型应用场景 示例 结果 i++先用后加（后缀自增） 循环变量更新 ++i先加后用（前缀自增） 需要立即使用新值 i--先用后减（后缀自减） 递减计数器 --i先减后用（前缀自减） 需要立即使用新值
int i = 5;
int j = i--;
运算符 含义 示例 等价表达式 +=加法赋值 a += 5a = a + 5-=减法赋值 a -= 3a = a - 3*=乘法赋值 a *= 2a = a * 2/=除法赋值 a /= 4a = a / 4%=取模赋值 a %= 3a = a % 3&=按位与赋值 a &= 0x0Fa = a & 0x0F^=按位异或赋值 a ^= ba = a ^ b<<=左移赋值 a <<= 2a = a << 2>>=右移赋值 a >>= 1a = a >> 1
输出：
#include <stdio.h>int main() {int a = 10, b = 3, c = 5;/* 1. 基本运算符 */// 算术运算符printf("a + b = %d\n", a + b); // 加法：13printf("a %% b = %d\n", a % b); // 取模：1（余数）// 关系运算符printf("a > b? %d\n", a > b); // 1（true）// 逻辑运算符printf("!(a < 5) = %d\n", !(a < 5)); // 1（非操作）// 位运算符printf("a & b = %d\n", a & b); // 按位与：2（1010 & 0011 = 0010）printf("a << 2 = %d\n", a << 2); // 左移2位：40// 赋值运算符c = a; // 基本赋值，c变为10// 条件运算符（三目运算符）int max = (a > b) ? a : b; // max=10// 逗号运算符int d = (a++, b++, a + b); // d=15（a=11, b=4）/* 2. 复合运算符（组合赋值） */a += 5; // 等价于 a = a + 5 → 15b *= 2; // 等价于 b = b * 2 → 8c &= 0x0F; // 等价于 c = c & 0x0F → 10的二进制高4位清零 → 10// 验证结果printf("a=%d, b=%d, c=%d, d=%d, max=%d\n", a, b, c, d, max);return 0;
}七. 函数
1.函数定义
即为Java中的方法，目的是为了提高代码复用率，可用性。
2.函数代码示例
代码中包含了六个函数，各有差异。细节都在注释之中了，仔细看，不是很难，比较难理解的是指针类型定义，这个我会在c语言的进阶版详细来说。
#include <stdio.h>//1. 无返回值、无参数函数：用于执行特定任务，不返回数据,引用参数输出hello world 换行
void greet(void) {printf("Hello World!\n");
}// 2. 带参数和返回值的函数：接收两个整数，返回它们的和
int add(int a, int b) { // 参数是值传递（拷贝）return a + b;
}//3. 指针参数函数：通过地址修改外部变量 ，
void swap(int *x, int *y) { // 使用指针实现"引用传递"效果,a=10 , b=20,输出结果应改为 *x等于20，*y=10;int temp = *x;//*x的值传给temp =10；*x = *y ;//*y把值传给*x，此时*x的值为20*y = temp;//temp（10）的值传给*y，temp的值为10。
}// 4. 递归函数：计算阶乘，需设置终止条件
int factorial(int n) {if (n < 0) return -1; // 错误检查，简单选择语句，即 使参数n不得小于0return (n <= 1) ? 1 : n * factorial(n - 1);//三运运算符，若n=1则返回1，n>1,则 n * factorial(n - 1)，即为递归函数
}/* 5. 函数指针类型定义：用于实现回调机制 */
typedef int (*MathOperation)(int, int); // 定义函数指针类型，/* 6. 函数原型声明：必须在使用前声明（定义可在后面） */
double divide(double a, double b); // 函数原型
/* 函数实现：除法运算 */
double divide(double a, double b) {if (b == 0) { // 参数有效性检查printf("错误:除数不能为0\n");return 0;}return a / b;
}int main() {// 1.调用无参函数greet(); // 2.调用函数a+b的结果，传参什么的，不过大多叙述。int result = add(3, 5); // 接收返回值printf("3 + 5 = %d\n", result);// 3.int a = 10, b = 20;printf("交换前:a=%d, b=%d\n", a, b);swap(&a, &b); // 传递地址修改实参printf("交换后:a=%d, b=%d\n", a, b);// 4. 输出结果即为 5*5-1printf("5的阶乘 = %d\n", factorial(5));//即给参数即可，算的是5的递归。//函数指针使用MathOperation operation = add; // 指向add函数，我能理解，即为定义指针函数，把add的作用调到operation中使用，可以简单理解。printf("函数指针运算：%d\n", operation(7, 8));//printf("10 / 3 = %.2f\n", divide(10.0, 3.0));return 0;
}输出：
八. 数组
1. 数组的类型
1. 常规数组
2. 二维数组
3. 字符串数组与字符串
4. 指针数组
5. 动态数组（堆内存）
2. 数组的下标
此处的重点就是，记住下标第一个是0.
3. 数组的使用（遍历）
3.1.常规数组的使用与遍历
（1）. 常规遍历-正序
// 2. 常规遍历（正序）printf("arr1元素:");for (int i = 0; i < 5; i++) {printf("%d ", arr1[i]); // 通过下标访问，输出：1 2 3 0 0}（2）. 常规遍历-倒叙
// 3. 逆序遍历printf("\narr2逆序:");for (int i = sizeof(arr2)/sizeof(arr2[0]) - 1; i >= 0; i--) {printf("%d ", arr2[i]); // 输出：30 20 10}
3.2. 二维数组的使用与（嵌套遍历）
int matrix[2][3] = {{1, 2, 3},{4, 5, 6}};printf("\n二维数组遍历:\n");for (int row = 0; row < 2; row++) {for (int col = 0; col < 3; col++) {printf("matrix[%d][%d]=%d ", row, col, matrix[row][col]);}printf("\n");}3.3. 字符串数组与字符串的使用与遍历
char str1[] = {'H', 'e', 'l', 'l', 'o', '\0'}; // 手动添加结束符char str2[] = "World"; // 自动添加结束符'\0'，长度=5+1=6printf("字符串遍历：");int i = 0;while (str1[i] != '\0') { // 遍历到结束符停止printf("%c", str1[i++]); // 输出：Hello}printf(" %s\n", str2); // 直接输出：World------%s 解释：输出或输入字符串（字符数组）。
3.4. 指针数组的使用与遍历
const char *words[] = {"Apple", "Banana", "Cherry"}; // 字符串指针数组printf("指针数组元素：\n");for (int i = 0; i < 3; i++) {printf("第%d个单词: %s\n", i, words[i]); // 通过指针访问字符串}3.5. 动态数组（堆内存）的使用与遍历
int *dynamic_arr = malloc(5 * sizeof(int)); // 动态分配5个int空间if (dynamic_arr == NULL) {printf("内存分配失败！");return 1;}// 初始化动态数组for (int i = 0; i < 5; i++) {dynamic_arr[i] = i * 10; // 下标访问与普通数组一致}// 指针遍历动态数组printf("动态数组：");int *ptr = dynamic_arr;for (int i = 0; i < 5; i++) {printf("%d ", *ptr++); // 输出：0 10 20 30 40}free(dynamic_arr); // 必须释放内存！4. 数组的整体代码
#include <stdio.h>
#include <stdlib.h> // 用于动态数组int main() {/*=====================一维数组基础-----这个好理解。======================*/// 1. 定义与初始化int arr1[5] = {1, 2, 3}; // 长度为5，部分初始化，未赋值元素默认为0，即为剩下两个位置为0，0int arr2[] = {10, 20, 30}; // 自动推断长度（3个元素）// 2. 常规遍历（正序）printf("arr1元素:");for (int i = 0; i < 5; i++) {printf("%d ", arr1[i]); // 通过下标访问，输出：1 2 3 0 0}// 3. 逆序遍历printf("\narr2逆序:");for (int i = sizeof(arr2)/sizeof(arr2[0]) - 1; i >= 0; i--) {printf("%d ", arr2[i]); // 输出：30 20 10}/*=====================二维数组与嵌套遍历======================*/int matrix[2][3] = {{1, 2, 3},{4, 5, 6}};printf("\n二维数组遍历:\n");for (int row = 0; row < 2; row++) {for (int col = 0; col < 3; col++) {printf("matrix[%d][%d]=%d ", row, col, matrix[row][col]);}printf("\n");}/*=====================字符数组与字符串======================*/char str1[] = {'H', 'e', 'l', 'l', 'o', '\0'}; // 手动添加结束符char str2[] = "World"; // 自动添加结束符'\0'，长度=5+1=6printf("字符串遍历：");int i = 0;while (str1[i] != '\0') { // 遍历到结束符停止printf("%c", str1[i++]); // 输出：Hello}printf(" %s\n", str2); // 直接输出：World------%s 解释：输出或输入字符串（字符数组）。/*=====================指针数组与遍历======================*/const char *words[] = {"Apple", "Banana", "Cherry"}; // 字符串指针数组printf("指针数组元素：\n");for (int i = 0; i < 3; i++) {printf("第%d个单词: %s\n", i, words[i]); // 通过指针访问字符串}/*=====================动态数组（堆内存）======================*/int *dynamic_arr = malloc(5 * sizeof(int)); // 动态分配5个int空间，开辟长度为5，类型为int的内存空间，if (dynamic_arr == NULL) {printf("内存分配失败！");return 1;}// 初始化动态数组for (int i = 0; i < 5; i++) {dynamic_arr[i] = i * 10; // 下标访问与普通数组一致}// 指针遍历动态数组printf("动态数组：");int *ptr = dynamic_arr;for (int i = 0; i < 5; i++) {printf("%d ", *ptr++); // 输出：0 10 20 30 40}free(dynamic_arr); // 必须释放内存！/*=====================数组下标越界示例（危险！）======================*/int arr[3] = {100, 200, 300};// printf("\n越界访问：%d", arr[5]); // 未定义行为，可能导致崩溃或输出垃圾值return 0;
}输出：
九. 操作符
操作符 名称/作用 示例 +加法 a + b-减法/负号 a - b,-x*乘法/指针解引用 a * b,*ptr/除法 a / b%取模（余数） a % b++自增 i++,++i--自减 i--,--i>大于 a > b<小于 a < b==等于 a == b!=不等于 a != b&&逻辑与 x && y!逻辑非 !x&按位与/取地址 m & n,&var^按位异或 m ^ n~按位非 ~m<<左移 m << 2>>右移 n >> 1=赋值 c = 10+=复合赋值 c += 5?:条件运算符 (a>b)?a:b,逗号运算符 d=(a++,b++).结构体成员访问 p.x->结构体指针成员访问 ptr->xsizeof获取类型/对象大小 sizeof(int)
#include <stdio.h>int main() {/*================ 算术操作符 ================*/int a = 10, b = 3;printf("a + b = %d\n", a + b); // 加法：13printf("a - b = %d\n", a - b); // 减法：7printf("a * b = %d\n", a * b); // 乘法：30printf("a / b = %d\n", a / b); // 整除：3（截断小数）printf("a %% b = %d\n", a % b); // 取模：1（余数）/*================ 关系操作符 ================*/printf("a > b? %d\n", a > b); // 大于：1(true)printf("a == b? %d\n", a == b); // 等于：0(false)/*================ 逻辑操作符 ================*/int x = 1, y = 0;printf("x && y = %d\n", x && y); // 逻辑与：0printf("x || y = %d\n", x || y); // 逻辑或：1printf("!x = %d\n", !x); // 逻辑非：0/*================ 位操作符 ================*/unsigned char m = 0b1010, n = 0b1100;printf("m & n = %d\n", m & n); // 按位与：0b1000 (8)printf("m | n = %d\n", m | n); // 按位或：0b1110 (14)printf("m ^ n = %d\n", m ^ n); // 按位异或：0b0110 (6)printf("~m = %d\n", (unsigned char)~m); // 按位非：0b0101 (5)printf("m << 2 = %d\n", m << 2); // 左移：40 (0b101000)printf("n >> 1 = %d\n", n >> 1); // 右移：6 (0b0110)/*================ 赋值操作符 ================*/int c = 10;c += 5; // 等价 c = c + 5 → 15c %= 4; // 等价 c = c % 4 → 3printf("赋值操作后 c = %d\n", c);/*================ 其他操作符 ================*/// 条件运算符（三元运算符）int max = (a > b) ? a : b; // max = 10printf("较大值：%d\n", max);// 逗号运算符（返回最后一个表达式值）int d = (a++, b++, a + b); // a=11, b=4 → d=15printf("逗号运算结果：%d\n", d);// 地址操作符int *ptr = &a; // &取地址printf("a的地址：%p\n", ptr);printf("指针解引用：%d\n", *ptr); // *解引用// sizeof运算符printf("int字节数：%zu\n", sizeof(int)); // 通常为4// 结构体成员访问struct Point { int x; int y; } p = {5, 8};printf("结构体成员：%d\n", p.x); // .运算符访问成员return 0;
}十. 常见关键字
关键字 类别 核心作用 int/char基础类型 定义整数/字符类型 float/double浮点类型 定义单/双精度浮点数 _Bool布尔类型 定义true/false逻辑值 unsigned类型修饰符 声明无符号类型 const类型修饰符 定义不可修改的常量 struct复合类型 定义结构体数据类型 union复合类型 定义共享内存的联合体 enum复合类型 定义枚举常量集合 auto存储类别 自动存储期(默认) static存储类别 静态存储期/限制作用域 register存储类别 建议寄存器存储变量 extern存储类别 声明外部变量/函数 if/else流程控制 条件分支控制 for/while流程控制 循环结构控制 do流程控制 后置条件循环 switch流程控制 多条件分支结构 break流程控制 跳出循环/switch continue流程控制 跳过本次循环剩余代码 goto流程控制 无条件跳转(慎用) sizeof运算符 获取类型/对象内存大小 volatile类型修饰符 防止编译器优化访问 typedef类型定义 创建类型别名 void特殊类型 无类型/函数无返回值 return函数控制 从函数返回值
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h> // 包含_Bool的bool宏/*---------------- 数据类型关键字 ----------------*/
int main() {// 基本类型int num = 10; // int: 32位整型char ch = 'A'; // char: 8位字符/小整型float pi = 3.14f; // float: 单精度浮点double salary = 9999.99;// double: 双精度浮点_Bool flag = true; // _Bool: 布尔类型(需要包含stdbool.h)// 类型修饰符unsigned int age = 30; // unsigned: 无符号整型long big_num = 100000L; // long: 扩展范围整型short small_num = 100; // short: 缩小范围整型const int MAX = 100; // const: 定义不可修改常量// 复合类型struct Person { // struct: 定义结构体类型char name[20];int age;};union Data { // union: 联合体(共享内存)int i;float f;};enum Color {RED, GREEN, BLUE}; // enum: 定义枚举常量/*---------------- 存储类别关键字 ----------------*/auto int local = 5; // auto: 自动存储期(默认可省略)static int counter = 0; // static: 静态存储期register int fast = 0; // register: 建议寄存器存储extern int external; // extern: 声明外部变量/*---------------- 流程控制关键字 ----------------*/// 条件分支if (num > 5) { // if: 条件判断printf("num>5\n");} else { // else: 否则分支printf("num<=5\n");}// 循环结构for (int i=0; i<3; i++) {// for: 确定次数循环printf("for:%d\n",i);continue; // continue: 跳过本次循环}while (num > 0) { // while: 条件循环if (num == 5) break;// break: 跳出循环num--;}do { // do: 后置条件循环printf("do-while\n");} while(0);// 多路分支switch(ch) { // switch: 多条件分支case 'A': // case: 分支匹配printf("A级\n");break;default: // default: 默认分支printf("未知等级\n");}/*---------------- 运算符相关关键字 ----------------*/int size = sizeof(int); // sizeof: 获取类型/对象字节数volatile int sensor; // volatile: 防止编译器优化typedef int Score; // typedef: 定义类型别名/*---------------- 特殊用途关键字 ----------------*/goto cleanup; // goto: 跳转到标签(慎用)cleanup:void *ptr = NULL; // void: 无类型指针/函数无返回值return 0; // return: 函数返回// restrict int *p; // restrict(C99): 指针独占访问优化// _Atomic int atom; // _Atomic(C11): 原子类型
}/*---------------- 补充说明 ----------------*/
// signed int num; // signed: 有符号数(默认可省略)
// unsigned char byte; // 显式声明无符号字符
// inline void func() {} // inline(C99): 内联函数优化十一. define 定义常量和宏
关键注释说明
宏类型 示例 作用 注意事项 简单常量 #define PI 3.1415定义全局常量 全大写命名，无分号结尾 函数式宏 #define SQUARE(x) ((x)*(x))类似函数但无类型检查 参数必须用括号包裹，避免副作用 多语句宏 do { ... } while(0)安全封装多行代码 使用反斜杠 \换行字符串化 ( #)#define STRINGIFY(x) #x将标识符转为字符串 用于调试输出 连接符 ( ##)#define CONCAT(a,b) a##b拼接标识符生成新变量/函数名 避免过度使用降低可读性 可变参数宏 #define LOG(fmt, ...)支持不定参数 C99+标准支持 条件编译宏 #if DEBUG_MODE ...根据条件启用/禁用代码块 用于跨平台或调试代码
宏 vs 常量变量
特性 宏 ( #define)常量变量 ( const)类型检查 无 有 内存占用 不占用内存 占用内存 调试支持 展开后不可见 可追踪 作用域 文件作用域（除非 #undef）遵循变量作用域规则 适用场景 简单替换、条件编译 需要类型安全或复杂计算的常量
代码示例：
#include <stdio.h>/*================== 定义常量 ==================*/
// 1. 基础常量（全大写命名规范）
#define PI 3.1415926 // 定义浮点常量
#define MAX_SIZE 100 // 定义整型常量
#define WELCOME_MSG "Hello" // 定义字符串常量/*================== 带参数的宏（函数式宏） ==================*/
// 2. 简单运算宏（参数用括号包裹防止优先级问题）
#define SQUARE(x) ((x) * (x)) // 计算平方
#define MAX(a, b) ((a) > (b) ? (a) : (b)) // 返回较大值// 3. 多语句宏（用 do-while(0) 包裹保证语法安全）
#define PRINT_SUM(a, b) do { \printf("%d + %d = %d\n", a, b, (a)+(b)); \
} while(0)//do-while 循环执行一次后立即退出（0 是假条件)/*================== 高级宏技巧 ==================*/
// 4. 字符串化操作符 (#)
#define STRINGIFY(x) #x // 将参数转为字符串
#define PRINT_VAR(x) printf(#x " = %d\n", x)// 5. 连接操作符 (##)
#define CONCAT(a, b) a##b // 拼接标识符
#define MAKE_VAR(name, num) name##num// 6. 可变参数宏（C99+）
#define LOG(fmt, ...) printf("[LOG] " fmt, __VA_ARGS__)// 7. 条件编译相关宏
#define DEBUG_MODE 1 // 调试模式开关
#if DEBUG_MODE#define DEBUG_LOG(msg) printf("[DEBUG] %s\n", msg)
#else#define DEBUG_LOG(msg)
#endifint main() {// 使用基础常量printf("PI = %.2f\n", PI);printf("MAX_SIZE = %d\n", MAX_SIZE);printf("消息: %s\n", WELCOME_MSG);// 2.使用函数式宏int num = 5;printf("%d的平方 = %d\n", num, SQUARE(num));printf("较大值: %d\n", MAX(10, 20));PRINT_SUM(3, 4); // 输出：3 + 4 = 7// 高级宏演示int value = 100;PRINT_VAR(value); // 输出：value = 100printf("PI的字符串: %s\n", STRINGIFY(PI)); // 输出：PI的字符串: PIint CONCAT(var, 1) = 10; // 生成变量 var1int MAKE_VAR(temp_, 2) = 20; // 生成变量 temp_2printf("var1 = %d, temp_2 = %d\n", var1, temp_2);LOG("结果: %d, 消息: %s\n", 200, "成功"); // [LOG] 结果: 200, 消息: 成功DEBUG_LOG("调试信息"); // 根据DEBUG_MODE开关输出return 0;
}输出：
十二. 指针（泛谈）
1. 什么是指针？
指针是一种存储变量内存地址的特殊变量。通过指针可以直接访问或操作内存中的数据，是C语言实现高效内存管理和灵活数据操作的核心机制。
2. 指针操作解析表
操作类型 代码示例 核心作用 注意事项 声明与初始化 int *p = &var;获取变量地址 类型必须匹配 解引用 *p通过地址访问数据 确保指针已初始化 指针算术 p + i数组遍历/偏移访问 注意越界问题 动态内存管理 malloc/free堆内存分配与释放 必须成对使用，避免内存泄漏 多级指针 int **pp = &p;操作指针的指针 解引用层级需对应 函数指针 int (*fp)(int, int)动态调用函数 参数和返回值类型必须匹配 const修饰指针 const int *p限制数据或指针的修改权限 根据const位置理解限制范围 数组指针 int (*ptr)[3]操作多维数组 列数必须匹配
3. 代码示例
#include <stdio.h>
#include <stdlib.h>// 函数指针示例
int add(int a, int b) { return a + b; }int main() {/*================= 1. 基础指针操作 =================*/int num = 10;int *p1 = # // 声明指针并初始化为num的地址printf("1. num值: %d, 地址: %p\n", *p1, p1); // *解引用获取值/*================= 2. 指针算术运算 =================*/int arr[] = {10, 20, 30};int *p2 = arr; // 数组名即首元素地址printf("2. 数组遍历:");for (int i = 0; i < 3; i++) {printf(" %d", *(p2 + i)); // 指针加法等价于 arr[i]}printf("\n");/*================= 3. 动态内存管理 =================*/int *heap_ptr = malloc(5 * sizeof(int)); // 堆内存分配if (heap_ptr != NULL) {heap_ptr[0] = 100; // 通过指针操作动态数组free(heap_ptr); // 必须手动释放内存heap_ptr = NULL; // 置空防止野指针}/*================= 4. 多级指针 =================*/int **pp = &p1; // 二级指针：指向指针的指针printf("4. 多级指针值: %d\n", **pp); /*================= 5. 函数指针 =================*/int (*func_ptr)(int, int) = add; // 声明函数指针printf("5. 函数指针运算: %d\n", func_ptr(3, 5));/*================= 6. const与指针 =================*/const int *p3 = # // 指向常量的指针（值不可改）int *const p4 = # // 常量指针（地址不可改）*p4 = 20; // 允许修改值// p4 = NULL; // 错误！地址不可变/*================= 7. 指针与数组的关系 =================*/int matrix[2][3] = {{1,2,3}, {4,5,6}};int (*matrix_ptr)[3] = matrix; // 数组指针：指向二维数组的行printf("7. 二维数组第二行: %d\n", matrix_ptr[1][2]); // 输出6/*================= 8. 空指针与野指针 =================*/int *null_ptr = NULL; // 空指针（安全状态）int *wild_ptr; // 未初始化的野指针（危险！）// printf("%d", *wild_ptr); // 未定义行为（可能崩溃）return 0;
}输出：
4. 总结
指针的核心概念总结
本质：指针是内存地址的容器，通过地址直接操作数据。
类型安全：指针类型决定了解引用时的内存解释方式（如
int*与float*差异）。内存管理：
栈内存：函数局部变量，自动分配释放。
堆内存：手动
malloc/free，灵活但需谨慎管理。常见风险：
野指针：未初始化或已释放的指针。
内存泄漏：忘记释放堆内存。
越界访问：指针算术超出合法范围。
5. 最佳实践建议
初始化原则：声明指针时立即赋值（有效地址或
NULL）。空指针检查：使用动态内存前验证
malloc返回值。const修饰：根据需求选择
const int*（保护数据）或int* const（保护指针）。工具辅助：使用静态分析工具（如Clang静态分析器）检测指针问题。
十三. 结构体（泛谈）
1. 什么是结构体？
结构体（
struct）是C语言中用于组合多个不同类型变量的自定义复合数据类型，可将逻辑相关的数据封装为单一实体，增强代码可读性和可维护性。
2. 结构体操作解析表
操作类型 代码示例 核心作用 注意事项 结构体定义 struct Student { ... };创建自定义复合类型 成员可以是任意类型（包括其他结构体） 变量初始化 struct Student stu = {...}声明并初始化结构体变量 字符串需用 strcpy赋值成员访问 stu.age通过 .访问成员值确保结构体变量已初始化 指针访问 stu_ptr->name通过指针间接访问成员 指针必须指向有效内存地址 结构体数组 struct Student class[3]存储多个结构体实例 数组索引从0开始 结构体赋值 stu3 = stu1浅拷贝所有成员值 含指针成员时需深拷贝 动态内存分配 malloc(sizeof(...))堆内存中创建结构体 必须手动 free释放内存嵌套结构体 Line line构建复杂数据结构 逐级访问成员（如 line.start.x）函数参数传递 void func(struct Student)按值或按地址传递结构体 大结构体建议传指针减少拷贝开销
3. 代码示例
#include <stdio.h>
#include <string.h>
#include <stdlib.h>/*================= 1. 结构体定义与初始化 =================*/
// 定义结构体类型
struct Student {char name[50];int age;float score;
};// 使用typedef简化结构体类型名
typedef struct {int x;int y;
} Point;int main() {/*============= 2. 结构体变量声明与初始化 =============*/// 声明并直接初始化struct Student stu1 = {"张三", 20, 85.5};// 先声明后赋值struct Student stu2;strcpy(stu2.name, "李四"); // 字符串需使用strcpystu2.age = 22;stu2.score = 90.0;/*============= 3. 访问结构体成员 =============*/printf("学生1: %s, %d岁, 分数: %.1f\n", stu1.name, stu1.age, stu1.score); // 输出：张三,20岁,85.5/*============= 4. 结构体指针与箭头运算符 =============*/struct Student *stu_ptr = &stu1;printf("指针访问: %s\n", stu_ptr->name); // ->运算符访问成员/*============= 5. 结构体数组 =============*/struct Student class[3] = {{"王五", 19, 88.0},{"赵六", 21, 92.5},{0} // 剩余元素自动初始化为0};printf("数组遍历: %s的分数为%.1f\n", class[1].name, class[1].score); // 赵六:92.5/*============= 6. 结构体赋值与拷贝 =============*/struct Student stu3;stu3 = stu1; // 结构体直接赋值（浅拷贝）stu3.age = 23;printf("拷贝后年龄: %d vs %d\n", stu1.age, stu3.age); // 20 vs 23/*============= 7. 动态内存分配 =============*/struct Student *heap_stu = malloc(sizeof(struct Student));strcpy(heap_stu->name, "孙七");heap_stu->age = 24;heap_stu->score = 95.0;free(heap_stu); // 必须释放内存heap_stu = NULL;/*============= 8. 嵌套结构体 =============*/typedef struct {Point start;Point end;} Line;Line line = {{0, 0}, {10, 10}};printf("线段长度: %.2f\n", sqrt(pow(line.end.x - line.start.x, 2) + pow(line.end.y - line.start.y, 2))); // 14.14/*============= 9. 结构体作为函数参数 =============*/void print_student(struct Student s) {printf("函数参数传递: %s\n", s.name);}print_student(stu1); // 输出：张三return 0;
}输出：
4. 总结
内存对齐：结构体大小可能大于成员总和（因内存对齐优化），可用
sizeof(struct Student)查看。深浅拷贝：直接赋值复制所有成员值（浅拷贝），若含指针需手动复制指向数据（深拷贝）。
灵活应用：
构建链表、树等数据结构
封装文件头信息（如BMP文件头）
定义网络协议数据包格式
与联合体区别：结构体成员独立占用内存，联合体成员共享内存。
5. 最佳实践建议
命名规范：结构体类型名首字母大写（如
Student）。typedef简化：使用
typedef避免重复写struct关键字。传参优化：传递大结构体时使用指针（
void func(struct Student *s)）。内存管理：动态分配的结构体指针使用后立即置空，防止野指针。
】安全审计与日志管理：为电商平台筑牢安全防线)
