1
2
3
4
5
6
7

#include <stdio.h>

int main(void) {
    int x = 10;
    printf("x = %d\n", x); // x = 10
    return 0;
}

1

gcc -Wall test.c -o test

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#include <stdio.h>

int main(void) {
    int a = 5;
    int b = 3;

    if (a = b) {  // 警告！这是赋值不是比较！
        printf("相等\n"); // 相等
    }

    return 0;
}

1

gcc -Wall -Wextra test.c -o test

1

gcc -Wall -Wextra -Werror test.c -o test

1
2
3
4
5
6

#include <stdio.h>

int main() {  // 警告！K&R 风格函数定义不符合 ISO C
    printf("Hello\n"); // Hello
    return 0;
}

1

gcc -Wall -pedantic test.c -o test

1
2
3
4
5
6
7
8

#include <stdio.h>

int main(void) {
    int big = 300;
    char small = big;  // 300 超出 char 范围（通常 -128~127）
    printf("small = %d\n", small); // small = 44
    return 0;
}

1

gcc -Wall -Wconversion test.c -o test

1
2
3
4
5
6
7
8
9

#include <stdio.h>

int x = 100;  // 全局变量

int main(void) {
    int x = 200;  // 遮蔽了全局变量！
    printf("x = %d\n", x); // x = 200 （你以为是 100，其实是 200）
    return 0;
}

1

gcc -Wall -Wshadow test.c -o test

1
2
3
4
5

int foo();  // 警告！应该写成 foo(void)

int foo(void) {
    return 42;
}

1

gcc -Wall -Wstrict-prototypes test.c -o test

1
2
3
4
5
6
7

// test1.c
int helper() {  // 没有在头文件中声明，也没有在 main 之前声明
    return 99;
}

// test2.c 假设这里调用了 test1.c 的 helper 函数...
// 如果没有正确声明原型，链接器可能找不到这个函数！

1

gcc -Wall -Wmissing-prototypes test1.c -o test1

1
2
3
4
5
6
7
8
9

#include <stdio.h>

int main(void) {
    int a;  // 未初始化！
    int b = 10;
    int c = a + b;  // a 是垃圾值，结果不可预测！
    printf("c = %d\n", c);
    return 0;
}

1

gcc -Wall -O2 -Wuninitialized test.c -o test

1
2
3
4
5

gcc -Wall -Wextra -Wpedantic -Wconversion -Wshadow \
    -Wstrict-prototypes -Wmissing-prototypes \
    -Wuninitialized -Werror \
    -O2 -g \
    your_code.c -o your_program

1

sudo apt-get install cppcheck

1

brew install cppcheck

1

cppcheck your_code.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include <stdlib.h>
#include <stdio.h>

void leaky_function(void) {
    int* ptr = (int*)malloc(sizeof(int) * 10);
    printf("分配了内存\n");

    // 糟糕！忘记 free 就返回了！
    // return 之前没有 free(ptr);
}

int main(void) {
    leaky_function();
    leaky_function();
    leaky_function();
    // 运行三次，泄漏了 3 次内存！
    printf("程序结束\n"); // 程序结束
    return 0;
}

1

cppcheck --enable=all leaky.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 检查所有文件（包括标准库的头文件）
cppcheck --check-config your_code.c

# 生成 HTML 报告
cppcheck --html-output=report.html your_code.c

# 只检查特定类别的错误
cppcheck --enable=warning your_code.c
cppcheck --enable=performance your_code.c
cppcheck --enable=portability your_code.c

1
2

# 检查整个 src 目录
cppcheck --enable=all --std=c11 --verbose src/

1
2
3
4

# 安装（如果没装）
# Ubuntu: sudo apt-get install clang-tools

scan-build gcc your_code.c -o your_program

1

clang --analyze your_code.c -o your_program

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#include <stdlib.h>
#include <stdio.h>

int main(void) {
    int* ptr = NULL;

    // 模拟某种条件
    int x = 5;
    if (x > 0) {
        ptr = (int*)malloc(sizeof(int));
    }

    // 如果 x <= 0，ptr 就是 NULL，这里直接解引用就会崩溃！
    *ptr = 42;  // 空指针解引用！
    printf("值为: %d\n", *ptr); // 崩溃！
    free(ptr);
    return 0;
}

1

scan-build gcc null_deref.c -o null_deref 2>&1

1
2

scan-build -o ./report make -j4
# 然后用浏览器打开 ./report/index.html

1
2
3
4
5

# Ubuntu/Debian
sudo apt-get install check

# macOS
brew install check

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

/* calculator.h */
#ifndef CALCULATOR_H
#define CALCULATOR_H

int add(int a, int b);
int subtract(int a, int b);
int multiply(int a, int b);
double divide(int a, int b);  // 如果 b=0 返回 0.0

#endif

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

/* calculator.c */
#include "calculator.h"

int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int multiply(int a, int b) {
    return a * b;
}

double divide(int a, int b) {
    if (b == 0) {
        return 0.0;  // 糟糕的错误处理！
    }
    return (double)a / b;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

/* test_calculator.c */
#include <check.h>
#include <stdlib.h>
#include "calculator.h"

/* 测试 add 函数 */
START_TEST(test_add) {
    ck_assert_int_eq(add(1, 2), 3);
    ck_assert_int_eq(add(-1, 1), 0);
    ck_assert_int_eq(add(0, 0), 0);
    ck_assert_int_eq(add(-5, -3), -8);
}
END_TEST

/* 测试 subtract 函数 */
START_TEST(test_subtract) {
    ck_assert_int_eq(subtract(5, 3), 2);
    ck_assert_int_eq(subtract(3, 5), -2);
    ck_assert_int_eq(subtract(0, 0), 0);
}
END_TEST

/* 测试 multiply 函数 */
START_TEST(test_multiply) {
    ck_assert_int_eq(multiply(3, 4), 12);
    ck_assert_int_eq(multiply(-2, 5), -10);
    ck_assert_int_eq(multiply(0, 100), 0);
}
END_TEST

/* 测试 divide 函数 */
START_TEST(test_divide) {
    ck_assert_double_eq(divide(10, 2), 5.0);
    ck_assert_double_eq(divide(7, 2), 3.5);
    ck_assert_double_eq(divide(0, 5), 0.0);
}
END_TEST

/* 主函数，组装测试用例 */
int main(void) {
    Suite* s = suite_create("Calculator");  // 创建一个测试套件
    TCase* tc_core = tcase_create("Core");   // 创建一个测试用例组

    /* 把测试用例添加到组里 */
    tcase_add_test(tc_core, test_add);
    tcase_add_test(tc_core, test_subtract);
    tcase_add_test(tc_core, test_multiply);
    tcase_add_test(tc_core, test_divide);

    /* 把测试用例组添加到套件里 */
    suite_add_tcase(s, tc_core);

    /* 运行测试 */
    SRunner* sr = srunner_create(s);
    srunner_run_all(sr, CK_NORMAL);
    int number_failed = srunner_ntests_failed(sr);
    srunner_free(sr);

    /* 返回 0 表示全部通过，非 0 表示有失败 */
    return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Makefile
CC = gcc
CFLAGS = -Wall -Wextra -std=c11
LDFLAGS = -lcheck -lsubunit -lm -lrt -lpthread

TARGET = test_calculator
SRC = calculator.c test_calculator.c

$(TARGET): $(SRC)
	$(CC) $(CFLAGS) -o $(TARGET) $(SRC) $(LDFLAGS)

clean:
	rm -f $(TARGET)

.PHONY: clean

1

make && ./test_calculator

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

/* test_gpio.c */
#include "unity.h"
#include "gpio.h"  /* 假设这是你的 GPIO 驱动头文件 */

/* 全局变量，用于存放测试结果 */
extern int gpio_read_counter;
extern int gpio_write_counter;

/* 测试前设置（类似 pytest 的 setup） */
void setUp(void) {
    gpio_read_counter = 0;
    gpio_write_counter = 0;
}

/* 测试后清理（类似 pytest 的 teardown） */
void tearDown(void) {
    /* 清理工作 */
}

/* 测试 GPIO 初始化 */
void test_gpio_init(void) {
    gpio_init(GPIO_PIN_5, GPIO_MODE_OUTPUT);
    TEST_ASSERT_TRUE(gpio_is_initialized(GPIO_PIN_5));
    TEST_ASSERT_EQUAL_INT(GPIO_MODE_OUTPUT, gpio_get_mode(GPIO_PIN_5));
}

/* 测试 GPIO 写入 */
void test_gpio_write(void) {
    gpio_init(GPIO_PIN_5, GPIO_MODE_OUTPUT);
    gpio_write(GPIO_PIN_5, GPIO_HIGH);
    TEST_ASSERT_EQUAL_INT(GPIO_HIGH, gpio_read(GPIO_PIN_5));
}

/* 测试 GPIO 读取 */
void test_gpio_read(void) {
    gpio_init(GPIO_PIN_3, GPIO_MODE_INPUT);
    TEST_ASSERT_TRUE(gpio_read(GPIO_PIN_3) == GPIO_HIGH ||
                     gpio_read(GPIO_PIN_3) == GPIO_LOW);
}

/* 主函数 */
int main(void) {
    UNITY_BEGIN();
    RUN_TEST(test_gpio_init);
    RUN_TEST(test_gpio_write);
    RUN_TEST(test_gpio_read);
    return UNITY_END();
}

1
2
3
4
5
6

TEST_ASSERT_TRUE(condition);        // 断言为真
TEST_ASSERT_FALSE(condition);      // 断言为假
TEST_ASSERT_EQUAL_INT(a, b);       // 整数相等
TEST_ASSERT_EQUAL_HEX32(a, b);    // 32位十六进制相等
TEST_ASSERT_EQUAL_STRING(a, b);   // 字符串相等
TEST_ASSERT_TRUE_MESSAGE(c, msg);  // 带错误信息的断言

1
2
3
4
5
6

# Ubuntu/Debian
sudo apt-get install libcmocka-dev

# 源码安装
git clone https://git.cryptomilk.org/projects/cmocka.git
cd cmocka && cmake . && make && sudo make install

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

/* test_string.c */
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <string.h>
#include <stdio.h>

/* 假设的字符串处理函数 */
int string_length(const char* str) {
    if (str == NULL) return -1;
    return strlen(str);
}

/* 测试正常字符串 */
static void test_string_length_normal(void** state) {
    (void) state;  /* 未使用的参数 */
    assert_int_equal(string_length("hello"), 5);
    assert_int_equal(string_length(""), 0);
    assert_int_equal(string_length("C is fun!"), 10);
}

/* 测试空指针 */
static void test_string_length_null(void** state) {
    (void) state;
    assert_int_equal(string_length(NULL), -1);
}

/* 测试边界 */
static void test_string_length_boundary(void** state) {
    (void) state;
    assert_int_equal(string_length("a"), 1);
    assert_int_equal(string_length("ab"), 2);
}

/* 主函数 */
int main(void) {
    const struct CMUnitTest tests[] = {
        cmocka_unit_test(test_string_length_normal),
        cmocka_unit_test(test_string_length_null),
        cmocka_unit_test(test_string_length_boundary),
    };

    return cmocka_run_group_tests(tests, NULL, NULL);
}

1

gcc -Wall -Wextra -std=c11 -o test_string test_string.c -lcmocka && ./test_string

1
2

# Ubuntu
sudo apt-get install afl++

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

/* fuzz_target.c - 一个存在漏洞的简单程序 */
#include <stdio.h>
#include <string.h>

/* 假设这是一个解析配置文件的程序 */
void parse_config(const char* input) {
    char buffer[32];

    /* 简单的解析逻辑：找冒号 */
    const char* colon = strchr(input, ':');
    if (colon != NULL) {
        size_t key_len = colon - input;
        /* 危险！没有检查 key_len 是否 < 32 */
        strncpy(buffer, input, key_len);
        buffer[key_len] = '\0';
        printf("key = %s\n", buffer);
    }
}

int main(int argc, char* argv[]) {
    if (argc < 2) {
        printf("Usage: %s <input_file>\n", argv[0]);
        return 1;
    }

    FILE* f = fopen(argv[1], "r");
    if (!f) {
        printf("无法打开文件\n");
        return 1;
    }

    char line[256];
    while (fgets(line, sizeof(line), f)) {
        parse_config(line);
    }

    fclose(f);
    return 0;
}

1
2

# 用 AFL++ 的编译器替换 gcc
AFL_USE_ASAN=1 afl-gcc-fast fuzz_target.c -o fuzz_target

1
2
3

mkdir input output
echo "name:Alice" > input/seed1.txt
echo "port:8080" > input/seed2.txt

1

afl-fuzz -i input -o output ./fuzz_target @@

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/* libfuzzer_demo.c

   ⚠️ 关键点：入口函数的名字必须严格是 LLVMFuzzerTestOneInput
   （大小写敏感，一个字母都不能差）。libFuzzer 链接时会去找这个名字，
   写错成 LLVM_FUZZER_SIZED_INPUT 之类，它就直接"找不到入口"。
   下面是一个故意留有缓冲区溢出的例子。 */
#include <stdint.h>
#include <stddef.h>
#include <string.h>

/* Fuzzer 入口函数：libFuzzer 会自动调用它无数次，喂各种随机数据 */
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
    if (size < 2) return 0;

    char buffer[10];

    /* 故意制造缓冲区溢出：size 完全可能远大于 10 */
    memcpy(buffer, data, size);   // 💥 这就是 fuzzer 要帮你抓出来的 bug
    buffer[9] = '\0';

    /* 使用 buffer... */
    return 0;
}

1
2

clang -fsanitize=fuzzer,address -g -O2 libfuzzer_demo.c -o libfuzzer_demo
./libfuzzer_demo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/* coverage_demo.c */
#include <stdio.h>
#include <stdlib.h>

int classify_number(int n) {
    if (n > 0) {
        return 1;  // 正数
    } else if (n < 0) {
        return -1;  // 负数
    } else {
        return 0;  // 零
    }
}

int main(void) {
    /* 测试用例：只测了正数和零，故意没测负数！ */
    printf("测试结果: %d\n", classify_number(5));   // 1
    printf("测试结果: %d\n", classify_number(0));   // 0
    printf("测试结果: %d\n", classify_number(10));  // 1
    printf("测试结果: %d\n", classify_number(0));   // 0

    return 0;
}

1
2
3
4
5
6
7
8

# 用覆盖率信息编译（注意是两个选项：-fprofile-arcs 和 -ftest-coverage）
gcc -fprofile-arcs -ftest-coverage -O0 -g coverage_demo.c -o coverage_demo

# 运行测试
./coverage_demo

# 生成覆盖率报告
gcov coverage_demo.c

1

cat coverage_demo.c.gcov

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 安装 lcov
sudo apt-get install lcov     # Ubuntu/Debian
brew install lcov             # macOS（Homebrew）

# 第一步：把 gcov 数据收集成 lcov 的 .info 文件
lcov --capture --directory . --output-file coverage.info

# 第二步：把 .info 渲染成 HTML 报告
genhtml coverage.info --output-directory coverage_report

# 用浏览器打开 coverage_report/index.html

1
2
3
4
5
6
7
8

# 编译时加 -pg 选项（"profiling"的意思）
gcc -pg -O2 -g my_program.c -o my_program

# 运行程序（这会生成 gmon.out 文件）
./my_program

# 生成性能分析报告
gprof my_program gmon.out > profile.txt

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

/* profiling_demo.c */
#include <stdio.h>
#include <stdlib.h>

/* 一个计算斐波那契数列的（低效）递归函数 */
long fibonacci(int n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

/* 一个计算阶乘的函数 */
long factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

/* 主函数 */
int main(void) {
    printf("斐波那契(30) = %ld\n", fibonacci(30)); // 斐波那契(30) = 832040
    printf("阶乘(12) = %ld\n", factorial(12));     // 阶乘(12) = 479001600
    return 0;
}

1
2
3

gcc -pg -O0 -g profiling_demo.c -o profiling_demo
./profiling_demo
gprof profiling_demo gmon.out | head -50

1
2

# Ubuntu
sudo apt-get install linux-tools-common linux-tools-generic

1

perf stat -e cycles,instructions,cache-references,cache-misses ./profiling_demo

1
2
3
4
5

# 记录性能数据（会生成 perf.data 文件）
perf record -g ./profiling_demo

# 查看报告（交互式界面）
perf report

1
2

# 实时显示系统中最热的函数（按 Ctrl+C 退出）
sudo perf top

1
2

# 用命令行启动 Instruments
instruments -t TimeProfiler ./my_program

1
2
3
4
5
6
7
8

# 安装（需要 Intel oneAPI 工具包）
# 下载地址：https://www.intel.com/content/www/us/en/developer/tools/oneapi/vtune-profiler.html

# 基本用法
vtune -collect hotspots -- ./my_program

# 生成 HTML 报告
vtune -report summary -format html -o vtune_report.html

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

double safe_divide(int a, int b) {
    /* 断言：除数不能为零 */
    assert(b != 0 && "除数不能为零！");

    return (double)a / b;
}

int main(void) {
    printf("10 / 2 = %f\n", safe_divide(10, 2));  // 10 / 2 = 5.000000

    printf("尝试除以零...\n");
    safe_divide(10, 0);  // 触发断言！程序崩溃！

    return 0;
}

1
2
3
4
5
6

/* 在所有 include assert.h 之前定义 NDEBUG */
#define NDEBUG
#include <assert.h>

/* 现在所有 assert 都变成了空操作！ */
assert(1 == 0);  // 不会崩溃，不做任何检查

1
2

# 或者在编译时定义
gcc -DNDEBUG -O2 my_program.c -o my_program

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <stdio.h>

int main(void) {
    /* 编译期断言：验证 int 至少是 32 位 */
    static_assert(sizeof(int) >= 4, "int 类型太小了！");

    /* 编译期断言：验证 double 恰好是 64 位 */
    static_assert(sizeof(double) == 8, "double 不是 64 位！");

    printf("int 大小: %zu 字节\n", sizeof(int));  // int 大小: 4 字节
    printf("double 大小: %zu 字节\n", sizeof(double));  // double 大小: 8 字节

    /* 这个断言会失败并导致编译错误！ */
    /* static_assert(sizeof(char) == 4, "char 不应该是 4 字节！"); */

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include <assert.h>
#include <stdint.h>

/* 确保基本类型大小符合预期（跨平台兼容性） */
static_assert(sizeof(int) == 4, "int 不是 4 字节");
static_assert(sizeof(void *) == 8, "假定运行在 64 位平台上");

/* 确保结构体大小符合预期（防止不小心改动字段后忘记更新协议） */
struct PacketHeader {
    uint32_t magic;
    uint16_t version;
    uint16_t length;
    uint64_t timestamp;
};
static_assert(sizeof(struct PacketHeader) == 16,
              "PacketHeader 大小必须是 16 字节");

/* C23 起消息参数可省略 */
static_assert(sizeof(char) == 1);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <stdio.h>
#include <string.h>

/* 危险版本：没有边界检查！ */
void unsafe_copy(char* dest, const char* src, size_t dest_size) {
    /* 危险！strcpy 不知道 dest 有多大！ */
    strcpy(dest, src);  // 如果 src > dest_size，溢出！
}

/* 安全版本：使用 strncpy 并检查长度 */
void safe_copy(char* dest, const char* src, size_t dest_size) {
    size_t src_len = strlen(src);
    if (src_len >= dest_size) {
        /* 截断并记录错误（这里只是示例） */
        printf("警告：字符串被截断！\n");
        src_len = dest_size - 1;
    }
    strncpy(dest, src, src_len);
    dest[src_len] = '\0';  // 确保字符串以 '\0' 结尾！
}

int main(void) {
    char buffer[5] = {0};

    printf("安全版本测试:\n");
    safe_copy(buffer, "Hello", sizeof(buffer));  // 警告：字符串被截断！
    printf("buffer = \"%s\"\n", buffer);  // buffer = "Hell"

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include <stdio.h>
#include <string.h>

/* ❌ 危险版本：这里其实叠了两个错误 ——
 *   1) 把局部数组的地址返回出去（函数一返回，buffer 这块内存就失效了）
 *   2) buffer 里根本没有 '\0'，即使内存还有效，它也不是一个合法字符串
 */
char* get_message(void) {
    char buffer[5];
    const char* msg = "Hello";
    for (int i = 0; i < 5; i++) {
        buffer[i] = msg[i];  // 没有拷贝结尾的 '\0'！
    }
    return buffer;  // ⚠️ 悬空指针 + 未终止字符串，双重错误
}

/* ✅ 正确做法 A：由调用者提供缓冲区，并告诉函数它有多大 */
void get_message_ok(char* out, size_t out_size) {
    /* snprintf 一定会补上 '\0'（空间够的话），也不会写越界 */
    snprintf(out, out_size, "%s", "Hello");
}

/* ✅ 正确做法 B：确实想"返回字符串"，就用 static 数组或 malloc */
char* get_message_static(void) {
    static char buffer[8] = "Hello";  // static：生命周期贯穿整个程序
    return buffer;
}

int main(void) {
    /* 危险版本会导致未定义行为，这里故意注释掉：
     * printf("%s\n", get_message());  // 可能输出乱码，也可能直接崩溃
     */

    char buf[16];
    get_message_ok(buf, sizeof(buf));
    printf("%s\n", buf);            // Hello

    printf("%s\n", get_message_static());  // Hello

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#include <stdio.h>

/* 危险版本：整数除法的陷阱 */
double compute_average(int sum, int count) {
    /* 整数除法！5/10 = 0，不是 0.5 */
    return sum / count;  // 返回整数，精度丢失！
}

/* 安全版本：先转成 double */
double safe_average(int sum, int count) {
    if (count == 0) {
        return 0.0;  // 防御性检查
    }
    return (double)sum / (double)count;  // 浮点除法
}

int main(void) {
    printf("危险版本: %f\n", compute_average(5, 10));   // 0.000000
    printf("安全版本: %f\n", safe_average(5, 10));      // 0.500000
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

/* 违反：使用非标准扩展 */
void bad_practice(void) {
    int x = 10;
    __asm__("nop");  // 内联汇编，非标准！
}

/* 符合：在标准 C 中使用带符号右移 */
void good_practice(void) {
    int x = -10;
    int y = x >> 1;  // 算术右移（实现定义，但可接受）
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

/* 违反：递归求斐波那契 */
long fib_bad(int n) {
    if (n <= 1) return n;
    return fib_bad(n - 1) + fib_bad(n - 2);  // 递归！
}

/* 符合：迭代求斐波那契 */
long fib_good(int n) {
    if (n <= 1) return n;
    long a = 0, b = 1;
    for (int i = 2; i <= n; i++) {
        long temp = a + b;
        a = b;
        b = temp;
    }
    return b;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

/* 违反：动态内存分配 */
void bad_alloc(void) {
    int* p = (int*)malloc(sizeof(int));  // 危险！
    if (p) {
        *p = 42;
        free(p);
    }
}

/* 符合：使用静态/栈内存 */
void good_no_alloc(void) {
    int x = 42;  // 栈上分配，确定性！
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

/* 违反：返回栈上变量的地址 */
int* bad_return(void) {
    int local = 42;
    return &local;  // 函数返回后，local 被销毁！
}

/* 符合：使用参数传递输出结果 */
void good_return(int* out) {
    *out = 42;  // 调用者提供存储空间
}

1
2
3
4
5

# 使用 clang-tidy 检查 MISRA 规则
clang-tidy -checks='-*,misra-*' my_code.c

# 使用 PC-lint Plus
pc-lint -MISRA(2012) my_code.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

/* 这段代码有什么问题？ */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>   // strcpy

void process_data(char* input) {
    char buffer[100];
    strcpy(buffer, input);
    printf("%s\n", buffer);
}

int main(int argc, char* argv[]) {
    if (argc > 1) {
        process_data(argv[1]);
    }
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <stdio.h>
#include <string.h>

void process_data(const char* input) {
    if (input == NULL) {
        fprintf(stderr, "错误：输入为空！\n");
        return;
    }

    char buffer[100];
    strncpy(buffer, input, sizeof(buffer) - 1);
    buffer[sizeof(buffer) - 1] = '\0';
    printf("%s\n", buffer);
}

int main(int argc, char* argv[]) {
    if (argc > 1) {
        process_data(argv[1]);
    } else {
        fprintf(stderr, "用法：%s <输入字符串>\n", argv[0]);
    }
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#define MAX_NAME_LEN 64
#define MAX_AGE 150

typedef struct {
    char name[MAX_NAME_LEN];
    int age;
} Person;

/* 防御性函数：安全地解析人员信息 */
int parse_person(const char* input, Person* out) {
    /* 检查空指针 */
    if (input == NULL || out == NULL) {
        fprintf(stderr, "错误：空指针！\n");
        return -1;
    }

    /* 检查输入长度 */
    if (strlen(input) == 0) {
        fprintf(stderr, "错误：输入为空！\n");
        return -1;
    }

    if (strlen(input) >= MAX_NAME_LEN) {
        fprintf(stderr, "错误：输入太长！（最大 %d 字符）\n", MAX_NAME_LEN);
        return -1;
    }

    /* 解析 "name,age" 格式 */
    char name_part[MAX_NAME_LEN];
    int age_part;

    if (sscanf(input, "%63[^,],%d", name_part, &age_part) != 2) {
        fprintf(stderr, "错误：格式应该是 \"名字,年龄\"！\n");
        return -1;
    }

    /* 验证年龄范围 */
    if (age_part < 0 || age_part > MAX_AGE) {
        fprintf(stderr, "错误：年龄必须在 0-%d 之间！\n", MAX_AGE);
        return -1;
    }

    /* 验证名字只包含可见字符 */
    for (size_t i = 0; i < strlen(name_part); i++) {
        if (!isprint((unsigned char)name_part[i])) {
            fprintf(stderr, "错误：名字包含非法字符！\n");
            return -1;
        }
    }

    /* 一切验证通过，赋值 */
    strncpy(out->name, name_part, MAX_NAME_LEN - 1);
    out->name[MAX_NAME_LEN - 1] = '\0';
    out->age = age_part;

    return 0;  /* 成功 */
}

int main(void) {
    Person p;

    /* 测试各种输入 */
    const char* tests[] = {
        "Alice,25",      /* 正常 */
        "",              /* 空字符串 */
        NULL,            /* NULL 指针 */
        "Bob,200",       /* 年龄超出范围 */
        "Charlie,30",    /* 正常 */
        "Dave\x01\x02",  /* 包含控制字符 */
    };

    for (int i = 0; i < 6; i++) {
        printf("测试 %d: ", i + 1);
        if (parse_person(tests[i], &p) == 0) {
            printf("成功 -> %s, %d岁\n", p.name, p.age);
        } else {
            printf("失败！\n");
        }
    }

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <stdio.h>
#include <stdlib.h>

#define ARRAY_SIZE 10

/* 危险版本：没有边界检查 */
int get_element_unsafe(int* arr, int size, int index) {
    return arr[index];  /* 没有检查 index 是否越界！ */
}

/* 安全版本：带边界检查 */
int get_element_safe(int* arr, int size, int index) {
    if (arr == NULL) {
        fprintf(stderr, "错误：数组指针为空！\n");
        return 0;  /* 或者返回错误码 */
    }

    if (index < 0 || index >= size) {
        fprintf(stderr, "错误：下标 %d 超出范围 [0, %d)！\n", index, size);
        return 0;  /* 或者使用 assert(index >= 0 && index < size) */
    }

    return arr[index];
}

/* 更安全：使用宏封装 */
#define GET_ELEMENT(arr, size, index) \
    ((index >= 0 && index < (size)) ? (arr)[index] : (fprintf(stderr, "数组越界！\n"), 0))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

typedef enum {
    SUCCESS = 0,
    ERR_NULL_POINTER = 1,
    ERR_INVALID_PARAM = 2,
    ERR_OUT_OF_MEMORY = 3,
    ERR_IO = 4,
} ErrorCode;

/* 错误码转字符串 */
const char* error_to_string(ErrorCode err) {
    switch (err) {
        case SUCCESS: return "成功";
        case ERR_NULL_POINTER: return "空指针错误";
        case ERR_INVALID_PARAM: return "无效参数";
        case ERR_OUT_OF_MEMORY: return "内存不足";
        case ERR_IO: return "IO错误";
        default: return "未知错误";
    }
}

/* 示例：安全地分配并初始化数组 */
ErrorCode init_array(int** arr, int size) {
    if (arr == NULL) {
        return ERR_NULL_POINTER;
    }

    if (size <= 0) {
        return ERR_INVALID_PARAM;
    }

    *arr = (int*)malloc(sizeof(int) * size);
    if (*arr == NULL) {
        return ERR_OUT_OF_MEMORY;
    }

    /* 初始化为 0 */
    for (int i = 0; i < size; i++) {
        (*arr)[i] = 0;
    }

    return SUCCESS;
}

int main(void) {
    int* numbers = NULL;
    ErrorCode err;

    err = init_array(&numbers, 5);
    if (err != SUCCESS) {
        fprintf(stderr, "初始化失败：%s\n", error_to_string(err));
        return 1;
    }

    printf("数组初始化成功！\n");
    free(numbers);
    return 0;
}