C语言基础语法与编程实践指南

1. C语言基础语法概述

C语言作为一门经典的编程语言，自1972年由Dennis Ritchie在贝尔实验室开发以来，一直是系统编程和嵌入式开发领域的基石。它的设计哲学强调简洁、高效和直接访问硬件的能力，这使得C语言在操作系统、编译器、数据库等底层系统开发中占据不可替代的地位。

C语言的基本语法单元被称为"令牌"(Token)，这是编译器能够识别的最小有意义单元。一个完整的C程序就是由这些令牌按照特定规则组合而成的。理解这些基本语法元素是掌握C语言的第一步。

提示：学习C语言语法时，建议从简单的程序结构开始，逐步理解每个语法元素的作用，而不是试图一次性掌握所有细节。

2. C程序的基本结构

2.1 最简单的C程序示例

让我们从一个经典的"Hello, World!"程序开始：

c复制#include <stdio.h>

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

这个简单的程序展示了C语言程序的基本结构：

1. #include <stdio.h> - 预处理指令，包含标准输入输出头文件
2. int main() - 主函数声明，程序执行的入口点
3. {} - 函数体边界
4. printf() - 标准输出函数调用
5. return 0; - 函数返回值，表示程序正常结束

2.2 程序结构的详细解析

一个更复杂的C程序可能包含以下部分：

c复制#include <stdio.h>   // 头文件包含
#define PI 3.14159   // 宏定义

// 函数声明
int add(int a, int b);

int main() {         // 主函数
    // 变量声明
    int num1, num2, sum;
    
    // 用户输入
    printf("Enter two integers: ");
    scanf("%d %d", &num1, &num2);
    
    // 函数调用
    sum = add(num1, num2);
    
    // 输出结果
    printf("Sum: %d\n", sum);
    
    return 0;        // 返回0表示程序成功执行
}

// 函数定义
int add(int a, int b) {
    return a + b;
}

这个示例展示了C程序的典型组成部分：

1. 头文件包含：使用#include引入所需库
2. 宏定义：使用#define定义常量
3. 函数声明：提前声明函数原型
4. 主函数：程序执行的起点
5. 变量声明：定义程序中使用的变量
6. 输入输出：与用户交互
7. 函数调用：执行特定功能的代码块
8. 函数定义：实现具体功能的代码

3. C语言的基本语法元素

3.1 令牌(Token)类型

C语言中的令牌主要包括以下几种类型：

1. 关键字(Keywords)：语言预留的具有特殊含义的单词，如int、if、return等
2. 标识符(Identifiers)：程序员自定义的名称，用于变量、函数等
3. 常量(Constants)：固定不变的值，如整数、浮点数等
4. 字符串字面量(String Literals)：由双引号括起来的字符序列
5. 运算符(Operators)：用于执行运算的符号
6. 分隔符(Separators)：用于分隔语句和代码块的符号

3.2 标识符命名规则

标识符是程序中变量、函数、数组等的名称，命名时需要遵循以下规则：

1. 只能包含字母、数字和下划线(_)
2. 第一个字符必须是字母或下划线，不能是数字
3. 不能与C语言关键字相同
4. 区分大小写（count和Count是不同的标识符）
5. 长度限制取决于具体编译器实现（现代编译器通常支持较长的标识符）

有效的标识符示例：

c复制int age;
float average_score;
char _temp;

无效的标识符示例：

c复制int 2nd_value;    // 错误：以数字开头
float my-score;    // 错误：包含连字符
char return;       // 错误：与关键字重名

3.3 注释的使用

C语言支持两种注释方式：

1. 单行注释：以//开始，到行尾结束

   c复制// 这是单行注释
   int x = 5;  // 也可以放在代码后面
   

2. 多行注释：以/*开始，以*/结束

   c复制/* 这是多行注释
      可以跨越多行
      直到遇到结束符号 */
   

注释使用的注意事项：

• 不能嵌套多行注释（/* /* */ */是非法的）
• 注释不能出现在字符串或字符常量内部
• 良好的注释应该解释"为什么"而不是"做什么"
• 保持注释简洁明了，与代码同步更新

4. 变量与常量

4.1 变量声明与初始化

在C语言中，变量必须先声明后使用。声明变量时需要指定其类型：

c复制int count;          // 声明一个整型变量
float price = 9.99; // 声明并初始化浮点变量
char letter = 'A';  // 声明并初始化字符变量

变量声明的重要规则：

1. C89要求变量声明必须在代码块开头
2. 未初始化的局部变量包含不确定的值
3. 全局变量和静态变量会被自动初始化为0
4. 变量名应具有描述性，便于理解其用途

4.2 常量的定义

C语言中定义常量主要有两种方式：

1. 使用#define预处理指令：

   c复制#define PI 3.14159
   #define MAX_SIZE 100
   

2. 使用const关键字（C99推荐）：

   c复制const double PI = 3.14159;
   const int MAX = 100;
   

两种方式的区别：

• #define是文本替换，没有类型检查
• const变量有类型信息，更安全
• #define不占用内存空间，const变量会占用内存

4.3 常见数据类型

C语言的基本数据类型包括：

1. 整型：

   • char：1字节，通常用于存储字符
   • short：2字节，短整型
   • int：4字节（通常），整型
   • long：4或8字节，长整型
   • long long：8字节，超长整型(C99)

   每种整型又可分为signed（有符号）和unsigned（无符号）版本。

2. 浮点型：

   • float：单精度浮点，通常4字节
   • double：双精度浮点，通常8字节
   • long double：扩展精度浮点，大小取决于实现

3. 无值类型：

   • void：表示无类型，用于函数返回值或指针

5. 运算符与表达式

5.1 基本运算符分类

C语言提供了丰富的运算符，主要包括以下几类：

1. 算术运算符：+, -, *, /, %（取模）
2. 关系运算符：==, !=, >, <, >=, <=
3. 逻辑运算符：&&（与）, ||（或）, !（非）
4. 位运算符：&, |, ^（异或）, ~（取反）, <<（左移）, >>（右移）
5. 赋值运算符：=, +=, -=, *=, /=, %=等
6. 其他运算符：
   • sizeof：获取类型或变量的大小
   • &：取地址
   • *：解引用
   • ?:：条件运算符

5.2 运算符优先级与结合性

运算符的优先级决定了表达式中运算的执行顺序。当不确定优先级时，应该使用括号明确指定运算顺序。

常见运算符优先级（从高到低）：

1. ()（函数调用）、[]（数组下标）、.（成员访问）、->（指针成员访问）
2. !、~、++、--、+（正）、-（负）、*（解引用）、&（取地址）、sizeof
3. *、/、%
4. +、-
5. <<、>>
6. <、<=、>、>=
7. ==、!=
8. &（按位与）
9. ^（按位异或）
10. |（按位或）
11. &&（逻辑与）
12. ||（逻辑或）
13. ?:（条件运算符）
14. =、+=、-=等赋值运算符
15. ,（逗号运算符）

5.3 表达式示例

c复制int a = 5, b = 10;
int sum = a + b;           // 算术运算
int isEqual = (a == b);    // 关系运算
int result = a << 1;       // 位运算（左移相当于乘以2）
a++;                       // 自增运算
int max = (a > b) ? a : b; // 条件运算

6. 控制流语句

6.1 条件语句

1. if语句：

   c复制if (condition) {
       // 条件为真时执行
   }
   

2. if-else语句：

   c复制if (condition) {
       // 条件为真时执行
   } else {
       // 条件为假时执行
   }
   

3. if-else if-else语句：

   c复制if (condition1) {
       // 条件1为真时执行
   } else if (condition2) {
       // 条件2为真时执行
   } else {
       // 其他情况执行
   }
   

4. switch语句：

   c复制switch (expression) {
       case constant1:
           // 代码块1
           break;
       case constant2:
           // 代码块2
           break;
       default:
           // 默认代码块
   }
   

6.2 循环语句

1. while循环：

   c复制while (condition) {
       // 循环体
   }
   

2. do-while循环：

   c复制do {
       // 循环体（至少执行一次）
   } while (condition);
   

3. for循环：

   c复制for (initialization; condition; increment) {
       // 循环体
   }
   

6.3 跳转语句

1. break：跳出当前循环或switch语句
2. continue：跳过当前循环的剩余部分，进入下一次循环
3. goto：无条件跳转到指定标签（应谨慎使用）
4. return：从函数返回，可带返回值

7. 函数基础

7.1 函数定义与调用

函数定义的基本语法：

c复制return_type function_name(parameter_list) {
    // 函数体
    return value;  // 如果return_type不是void
}

示例：

c复制// 函数声明（原型）
int max(int a, int b);

// 函数定义
int max(int a, int b) {
    return (a > b) ? a : b;
}

// 函数调用
int result = max(10, 20);

7.2 函数参数传递

C语言中函数参数传递是"值传递"，即传递的是参数的副本而非原始变量：

c复制void swap(int a, int b) {  // 这不会交换原始变量的值
    int temp = a;
    a = b;
    b = temp;
}

// 正确的交换函数需要使用指针
void real_swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

7.3 递归函数

函数可以调用自身，这种技术称为递归：

c复制// 计算阶乘的递归函数
int factorial(int n) {
    if (n <= 1) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

递归函数必须有一个明确的终止条件，否则会导致无限递归和栈溢出。

8. 数组与字符串

8.1 数组基础

数组是相同类型元素的集合：

c复制// 声明并初始化数组
int numbers[5] = {1, 2, 3, 4, 5};

// 访问数组元素
int first = numbers[0];  // 数组索引从0开始
numbers[2] = 10;         // 修改第三个元素

// 多维数组
int matrix[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

数组的特点：

1. 大小在声明时固定
2. 元素在内存中连续存储
3. 数组名可以退化为指向第一个元素的指针

8.2 字符串处理

C语言中的字符串是以空字符(\0)结尾的字符数组：

c复制// 字符串初始化
char str1[] = "Hello";  // 自动添加\0
char str2[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

// 常用字符串函数（需要#include <string.h>）
strlen(str1);      // 返回字符串长度
strcpy(dest, src); // 复制字符串
strcat(dest, src); // 连接字符串
strcmp(s1, s2);    // 比较字符串

字符串操作的注意事项：

1. 确保目标缓冲区足够大
2. 字符串字面量不可修改
3. 始终以\0结尾

9. 指针基础

9.1 指针的概念与声明

指针是存储内存地址的变量：

c复制int var = 20;    // 普通变量
int *ptr = &var; // 指针变量，存储var的地址

printf("var的值: %d\n", var);      // 20
printf("var的地址: %p\n", &var);   // 地址
printf("ptr存储的地址: %p\n", ptr); // 同上
printf("ptr指向的值: %d\n", *ptr); // 20

指针操作符：

1. &：取地址运算符
2. *：解引用运算符

9.2 指针与数组

数组名可以看作指向数组第一个元素的指针：

c复制int arr[3] = {10, 20, 30};
int *ptr = arr;  // 等价于 int *ptr = &arr[0]

printf("%d\n", *ptr);     // 10
printf("%d\n", ptr[1]);   // 20
printf("%d\n", *(ptr+2)); // 30

指针算术：

• 指针加减整数：根据指向类型的大小调整地址
• 指针减指针：得到两个指针之间的元素个数

9.3 指针与函数

指针可以作为函数参数，实现"引用传递"的效果：

c复制void increment(int *p) {
    (*p)++;
}

int main() {
    int num = 5;
    increment(&num);
    printf("%d\n", num);  // 6
    return 0;
}

函数指针：

c复制int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

int main() {
    int (*operation)(int, int);  // 声明函数指针
    
    operation = add;
    printf("%d\n", operation(5, 3));  // 8
    
    operation = sub;
    printf("%d\n", operation(5, 3));  // 2
    
    return 0;
}

10. 结构体与联合体

10.1 结构体基础

结构体允许将不同类型的数据组合在一起：

c复制// 定义结构体类型
struct Point {
    int x;
    int y;
};

// 声明结构体变量
struct Point p1;
p1.x = 10;
p1.y = 20;

// 初始化结构体
struct Point p2 = {5, 15};

// 使用typedef简化
typedef struct {
    char name[50];
    int age;
    float salary;
} Employee;

Employee emp1 = {"John", 30, 5000.0};

结构体成员的访问：

1. 直接访问：.运算符
2. 通过指针访问：->运算符

10.2 联合体

联合体允许在同一内存位置存储不同的数据类型：

c复制union Data {
    int i;
    float f;
    char str[20];
};

union Data data;
data.i = 10;          // 现在data.i有效
printf("%d\n", data.i);

data.f = 220.5;       // 现在data.f有效，data.i的值被覆盖
printf("%f\n", data.f);

联合体的特点：

1. 所有成员共享同一块内存
2. 大小等于最大成员的大小
3. 同一时间只能使用一个成员

11. 文件操作基础

11.1 文件打开与关闭

文件操作的基本步骤：

1. 使用fopen打开文件
2. 进行读写操作
3. 使用fclose关闭文件

c复制#include <stdio.h>

int main() {
    FILE *fp;
    
    // 打开文件（写入模式）
    fp = fopen("test.txt", "w");
    if (fp == NULL) {
        printf("无法打开文件\n");
        return 1;
    }
    
    // 写入内容
    fprintf(fp, "这是写入文件的内容\n");
    
    // 关闭文件
    fclose(fp);
    
    return 0;
}

文件打开模式：

• "r"：只读
• "w"：只写（创建或清空文件）
• "a"：追加（创建或追加到文件末尾）
• "r+"：读写（文件必须存在）
• "w+"：读写（创建或清空文件）
• "a+"：读写（创建或追加）

11.2 文件读写操作

常见的文件读写函数：

1. fprintf：格式化写入
2. fscanf：格式化读取
3. fputc/fgetc：单个字符读写
4. fputs/fgets：字符串读写
5. fwrite/fread：二进制读写

示例：复制文件内容

c复制#include <stdio.h>

int main() {
    FILE *src, *dest;
    char ch;
    
    src = fopen("source.txt", "r");
    if (src == NULL) {
        printf("无法打开源文件\n");
        return 1;
    }
    
    dest = fopen("destination.txt", "w");
    if (dest == NULL) {
        printf("无法打开目标文件\n");
        fclose(src);
        return 1;
    }
    
    while ((ch = fgetc(src)) != EOF) {
        fputc(ch, dest);
    }
    
    fclose(src);
    fclose(dest);
    
    printf("文件复制成功\n");
    return 0;
}

12. 预处理器指令

12.1 常用预处理器指令

1. #include：包含头文件

   c复制#include <stdio.h>  // 系统头文件
   #include "myheader.h" // 用户头文件
   

2. #define：定义宏

   c复制#define PI 3.14159
   #define MAX(a, b) ((a) > (b) ? (a) : (b))
   

3. #ifdef/#ifndef：条件编译

   c复制#ifdef DEBUG
       printf("调试信息\n");
   #endif
   

4. #pragma：编译器特定指令

   c复制#pragma once  // 防止头文件重复包含
   

12.2 宏与内联函数

宏的优缺点：

• 优点：不占用运行时内存，执行速度快
• 缺点：没有类型检查，可能产生副作用

示例：

c复制#define SQUARE(x) ((x) * (x))

int a = 5;
int b = SQUARE(a++);  // 有问题：(a++) * (a++)

替代方案：使用内联函数（C99）

c复制inline int square(int x) {
    return x * x;
}

13. 动态内存管理

13.1 内存分配函数

1. malloc：分配指定大小的内存块

   c复制int *arr = (int*)malloc(10 * sizeof(int));
   

2. calloc：分配并清零内存块

   c复制int *arr = (int*)calloc(10, sizeof(int));
   

3. realloc：调整已分配内存的大小

   c复制arr = (int*)realloc(arr, 20 * sizeof(int));
   

4. free：释放分配的内存

   c复制free(arr);
   

13.2 内存管理注意事项

1. 检查分配是否成功：

   c复制if (arr == NULL) {
       printf("内存分配失败\n");
       exit(1);
   }
   

2. 避免内存泄漏：

   • 分配的内存必须释放
   • 不要丢失对分配内存的引用

3. 避免悬垂指针：

   • 释放内存后将指针设为NULL

   c复制free(arr);
   arr = NULL;
   

4. 不要重复释放同一块内存

14. 常见错误与调试技巧

14.1 常见语法错误

1. 缺少分号：

   c复制int x = 5  // 错误：缺少分号
   

2. 不匹配的花括号：

   c复制if (condition) {
       // 代码
   // 错误：缺少闭合花括号
   

3. 未声明的变量：

   c复制x = 10;  // 错误：x未声明
   

4. 类型不匹配：

   c复制int *p = 10;  // 错误：整数赋给指针
   

14.2 调试技巧

1. 使用printf调试：

   c复制printf("变量x的值：%d\n", x);
   

2. 使用预定义宏：

   c复制printf("当前文件：%s, 行号：%d\n", __FILE__, __LINE__);
   

3. 使用断言：

   c复制#include <assert.h>
   assert(x > 0);  // 如果x<=0，程序终止
   

4. 使用调试器：

   • GDB（Linux）
   • LLDB（macOS）
   • Visual Studio调试器（Windows）

15. 编码规范与最佳实践

15.1 命名规范

1. 变量和函数名：

   • 使用有意义的名称
   • 可以采用小驼峰命名法（calculateSum）
   • 或者下划线命名法（calculate_sum）

2. 常量：

   • 通常全大写，用下划线分隔单词

   c复制#define MAX_SIZE 100
   const int BUFFER_SIZE = 1024;
   

3. 类型定义：

   • 通常以_t结尾

   c复制typedef struct {
       int x, y;
   } point_t;
   

15.2 代码组织

1. 头文件（.h）：

   • 包含函数声明、宏定义、类型定义
   • 使用头文件保护

   c复制#ifndef MYHEADER_H
   #define MYHEADER_H
   // 头文件内容
   #endif
   

2. 源文件（.c）：

   • 包含函数实现
   • 包含对应的头文件

3. 模块化设计：

   • 每个模块应该有明确的职责
   • 减少全局变量的使用
   • 函数应该尽量短小，只做一件事

15.3 错误处理

1. 检查函数返回值：

   c复制FILE *fp = fopen("file.txt", "r");
   if (fp == NULL) {
       perror("打开文件失败");
       return EXIT_FAILURE;
   }
   

2. 使用错误码：

   c复制#define ERROR_FILE_OPEN 1
   #define ERROR_MEMORY 2
   

3. 资源清理：

   • 确保分配的资源（内存、文件等）被正确释放
   • 可以使用goto进行集中错误处理（谨慎使用）

16. C语言标准与编译器扩展

16.1 C语言标准版本

1. C89/C90：第一个标准化版本

   • 由ANSI于1989年发布（C89）
   • 由ISO于1990年采用（C90）
   • 大多数现代编译器仍默认兼容此标准

2. C99：重要更新

   • 引入单行注释（//）
   • 增加long long、_Bool类型
   • 变长数组（VLA）
   • 内联函数
   • restrict指针限定符

3. C11：现代特性

   • 多线程支持
   • 泛型选择（_Generic）
   • 匿名结构体和联合体
   • 静态断言（_Static_assert）

4. C17/C18：小幅度修订

   • 主要是缺陷修复，没有引入重要新特性

16.2 编译器特定扩展

不同编译器可能提供扩展功能：

1. GCC/Clang扩展：

   • __attribute__语法
   • 语句表达式
   • 零长度数组

2. MSVC扩展：

   • __declspec关键字
   • 特殊调用约定

使用编译器扩展的注意事项：

• 降低代码可移植性
• 必要时使用条件编译
• 明确文档说明

17. 实际项目中的C语言

17.1 构建系统

1. Makefile：传统的构建工具

   makefile复制CC = gcc
   CFLAGS = -Wall -O2
   
   all: program
   
   program: main.o utils.o
       $(CC) $(CFLAGS) -o program main.o utils.o
   
   main.o: main.c utils.h
       $(CC) $(CFLAGS) -c main.c
   
   utils.o: utils.c utils.h
       $(CC) $(CFLAGS) -c utils.c
   
   clean:
       rm -f program *.o
   

2. CMake：跨平台构建系统

   cmake复制cmake_minimum_required(VERSION 3.10)
   project(MyProject)
   
   set(CMAKE_C_STANDARD 11)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
   
   add_executable(program main.c utils.c utils.h)
   

17.2 常用库

1. 标准库：

   • <stdio.h>：输入输出
   • <stdlib.h>：内存管理、随机数等
   • <string.h>：字符串处理
   • <math.h>：数学函数
   • <time.h>：时间日期处理

2. 第三方库：

   • GLib：通用实用程序库
   • SQLite：嵌入式数据库
   • libcurl：网络传输
   • OpenSSL：加密和安全

17.3 性能优化

1. 编译器优化选项：

   • -O1、-O2、-O3：不同级别的优化
   • -Os：优化代码大小
   • -march=native：针对当前CPU优化

2. 代码级优化：

   • 减少函数调用开销（内联小函数）
   • 使用寄存器变量（register关键字）
   • 避免不必要的内存访问
   • 使用查表法替代复杂计算

3. 性能分析工具：

   • gprof：GNU性能分析器
   • perf：Linux性能计数器
   • Valgrind：内存和性能分析

18. 现代C语言开发环境

18.1 开发工具

1. 编辑器/IDE：

   • Visual Studio Code + C/C++扩展
   • CLion（商业）
   • Eclipse CDT
   • Vim/Emacs + 插件

2. 编译器：

   • GCC（GNU Compiler Collection）
   • Clang/LLVM
   • MSVC（Microsoft Visual C++）

3. 调试器：

   • GDB（GNU Debugger）
   • LLDB（LLVM Debugger）
   • Visual Studio Debugger

18.2 静态分析工具

1. clang-tidy：基于Clang的静态分析
2. cppcheck：轻量级静态分析
3. PVS-Studio：商业静态分析工具

18.3 代码格式化工具

1. clang-format：基于Clang的代码格式化
2. astyle：Artistic Style代码格式化

示例.clang-format配置文件：

yaml复制BasedOnStyle: LLVM
IndentWidth: 4
TabWidth: 4
UseTab: Never
BreakBeforeBraces: Allman
ColumnLimit: 80

19. C语言学习资源

19.1 经典书籍

1. 《C程序设计语言》（K&R）：C语言之父所著，经典入门
2. 《C Primer Plus》：全面系统的C语言教程
3. 《C陷阱与缺陷》：深入理解C语言的陷阱
4. 《C专家编程》：进阶C语言知识
5. 《C和指针》：深入讲解指针概念

19.2 在线资源

1. C语言官方文档：各编译器文档
2. cppreference.com：C标准库参考
3. GCC在线文档：GCC特定扩展和选项
4. 在线编译器：如godbolt.org（Compiler Explorer）

19.3 练习平台

1. LeetCode：算法题练习
2. HackerRank：编程挑战
3. Exercism：有导师指导的练习
4. Codewars：编程卡塔挑战

20. 从C到其他语言

20.1 C与C++

关系：

• C++是C的超集（大部分C代码可以直接在C++中编译）
• C++增加了面向对象、模板等特性

主要区别：

1. C++有引用类型
2. C++支持函数重载
3. C++有new/delete运算符
4. C++标准库更丰富

20.2 C与Java/C#

相似性：

• 语法类似
• 基本控制结构相同

主要区别：

1. Java/C#是面向对象语言
2. Java/C#有垃圾回收
3. Java/C#没有指针（但有引用）
4. Java/C#有更丰富的标准库

20.3 C与Python

相似性：

• 基本控制结构类似
• 运算符用法类似

主要区别：

1. Python是动态类型语言
2. Python有垃圾回收
3. Python没有指针概念
4. Python标准库更高级

21. C语言项目实战建议

21.1 小型项目创意

1. 命令行工具：

   • 计算器
   • 待办事项列表
   • 文件加密/解密工具

2. 系统工具：

   • 简单的shell
   • 进程监视器
   • 内存使用统计工具

3. 游戏：

   • 猜数字
   • 井字棋
   • 简单的文字冒险游戏

21.2 项目结构示例

典型的C项目目录结构：

code复制project/
├── include/         // 头文件
│   └── utils.h
├── src/             // 源文件
│   ├── main.c
│   └── utils.c
├── tests/           // 测试代码
│   └── test_utils.c
├── Makefile         // 构建脚本
└── README.md        // 项目说明

21.3 版本控制

使用Git管理项目：

1. 初始化仓库：

   bash复制git init
   

2. 添加.gitignore文件（C项目示例）：

   code复制*.o
   *.a
   *.so
   *.out
   *.exe
   /build/
   

3. 常规工作流程：

   bash复制git add .
   git commit -m "描述变更"
   git push
   

22. C语言常见问题解答

22.1 指针与数组的区别

常见混淆点：

c复制int arr[10];
int *ptr = arr;

// 以下表达式看似相似但含义不同
sizeof(arr);  // 整个数组的大小（10 * sizeof(int)）
sizeof(ptr);  // 指针的大小（通常4或8字节）

// 数组名不能赋值
arr = ptr;    // 错误

关键区别：

1. 数组名是常量指针，不能重新赋值
2. sizeof行为不同
3. 数组名取地址（&arr）得到的是数组指针，而非指针的指针

22.2 const关键字的用法

1. 常量指针：

   c复制const int *p;    // 指向常量的指针（指针可变，内容不可变）
   int const *p;    // 同上
   int * const p;   // 常量指针（指针不可变，内容可变）
   const int * const p;  // 指向常量的常量指针
   

2. 函数参数中的const：

   c复制void print(const char *str);  // 保证不修改str指向的内容
   

22.3 static关键字的多种含义

1. 文件作用域：

   c复制// file1.c
   static int hidden_var;  // 只在当前文件可见
   
   static void hidden_func() {}  // 只在当前文件可见
   

2. 函数内的静态变量：

   c复制void func() {
       static int count = 0;  // 只在第一次初始化，保持值不变
       count++;
   }
   

3. C++中的类静态成员（C语言中没有）

22.4 头文件包含保护

防止头文件重复包含的惯用法：

c复制#ifndef MYHEADER_H
#define MYHEADER_H

// 头文件内容

#endif

现代替代方案（部分编译器支持）：

c复制#pragma once
// 头文件内容

23. C语言进阶主题

23.1 位操作技巧