一、C语言回顾：指针与内存管理、函数指针与回调、宏定义与预处理、头文件组织原则

说实话，很多从C转C++的朋友，都会犯一个毛病——觉得C那些东西太基础，直接跳过去学类、继承、多态。结果呢？写出来的C++代码，内存泄漏满天飞，宏和const混用，头文件互相包含到编译崩溃。

我个人习惯是，不管学员基础多好，第一节课必须把C的这几个核心点重新捋一遍。因为C++本质上是对C的增强和约束，你C的功底扎不扎实，直接决定了你C++能走多远。

1.1 指针与内存管理——C语言的灵魂与陷阱

指针这东西，说白了就是地址。但很多人把它想复杂了。我见过最离谱的代码，是一个新手用指针做函数参数，结果在函数里改了指针本身的值，还以为能影响外面的变量——嗯，这就是没搞懂“指针的值传递”。

// 错误示范：想通过函数修改指针本身
void alloc_memory_wrong(int *p) {
    p = (int *)malloc(sizeof(int) * 10);  // 只修改了局部变量p
}

// 正确做法：传指针的指针
void alloc_memory_correct(int **p) {
    *p = (int *)malloc(sizeof(int) * 10);
}

int main() {
    int *arr = NULL;
    alloc_memory_correct(&arr);  // 传地址
    // 使用arr...
    free(arr);
    return 0;
}

我在项目中遇到过最典型的内存问题，就是“野指针”和“内存泄漏”。野指针是用了已经释放的内存，内存泄漏是申请了没释放。C++虽然引入了智能指针，但底层原理还是这套东西。

关于堆和栈，我建议你记住一句话：栈是系统管的，堆是你管的。栈上的变量函数结束自动回收，堆上的你得亲手释放。C++的RAII（资源获取即初始化）思想，本质上就是让对象的析构函数帮你自动释放堆资源——这就是智能指针的底层逻辑。

1.2 函数指针与回调——解耦的艺术

函数指针，说白了就是把函数当成变量来用。你想想看，如果能把一个函数作为参数传给另一个函数，那代码的灵活性就大大提升了。这就是回调机制。

// 定义一个函数指针类型
typedef int (*CompareFunc)(int, int);

// 冒泡排序，比较逻辑由回调决定
void bubble_sort(int arr[], int n, CompareFunc cmp) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (cmp(arr[j], arr[j + 1]) > 0) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

// 升序比较
int asc(int a, int b) { return a - b; }
// 降序比较
int desc(int a, int b) { return b - a; }

int main() {
    int arr[] = {3, 1, 4, 1, 5, 9};
    bubble_sort(arr, 6, asc);   // 升序
    bubble_sort(arr, 6, desc);  // 降序
    return 0;
}

我个人习惯在写库或者框架时，大量使用函数指针。比如事件驱动系统里，每个事件绑定一个回调函数。这样主循环只需要统一调用回调，具体逻辑由注册者决定——这就是解耦。

1.3 宏定义与预处理——编译前的魔法

宏定义是C语言里最容易被滥用的特性。我见过有人用宏来定义常量、写函数、甚至做类型定义——结果出了问题，编译器报错信息完全看不懂，因为宏在预处理阶段就被展开了。

// 宏的典型用法：头文件保护
#ifndef MY_HEADER_H
#define MY_HEADER_H

// 条件编译
#ifdef DEBUG
    #define LOG(msg) printf("[DEBUG] %s\n", msg)
#else
    #define LOG(msg) // 空定义
#endif

// 注意：宏不是函数，参数要加括号
#define SQUARE(x) ((x) * (x))

#endif

为什么宏的参数要加那么多括号？因为宏只是文本替换。你写SQUARE(a + b)，如果不加括号，展开成a + b * a + b，结果完全不对。我曾经在一个算法竞赛里，就因为少写一对括号，调试了整整一下午——嗯，从那以后我对宏的括号格外敏感。

预处理阶段还做一件事：文件包含（#include）。这里有个常见的坑——重复包含。虽然头文件保护能解决，但如果你在头文件里定义了全局变量或函数实现，多个源文件包含就会导致重复定义错误。所以记住：头文件只放声明，不放定义（除了inline函数和模板）。

1.4 头文件组织原则——工程化的第一步

头文件组织得好不好，直接决定了你的项目能不能被其他人看懂、能不能顺利编译。我见过最乱的项目，头文件互相包含成环，编译一次要十分钟——因为改了任何一个头文件，所有源文件都得重新编译。

我个人习惯遵循以下几个原则：

• 单一职责：一个头文件只声明一个模块或一个类的接口。不要搞“万能头文件”。
• 最小包含：头文件里只包含它真正需要的东西。能用前置声明就别#include。
• 避免循环包含：如果A包含B，B又包含A，编译会报错。用前置声明打破循环。
• 实现隐藏：头文件只暴露接口，不暴露实现细节。比如结构体的内部成员可以用不透明指针隐藏。

// module.h —— 对外接口
#ifndef MODULE_H
#define MODULE_H

// 前置声明，避免包含其他头文件
typedef struct Module Module;

// 接口函数
Module* module_create(int size);
void module_process(Module *m, int data);
void module_destroy(Module *m);

#endif

// module.c —— 实现细节
#include "module.h"
#include <stdlib.h>

struct Module {
    int *buffer;
    int size;
    int count;
};

Module* module_create(int size) {
    Module *m = malloc(sizeof(Module));
    m->buffer = malloc(sizeof(int) * size);
    m->size = size;
    m->count = 0;
    return m;
}
// ... 其他实现

你想想看，如果我把struct Module的定义直接放在头文件里，那所有包含这个头文件的源文件都能看到内部成员。一旦我改了结构体，所有源文件都得重新编译。这就是“接口与实现分离”的好处。

知识体系总览

下面这张图，是我梳理的本章知识体系。你可以把它当作一个思维导图，快速回顾C语言这几个核心模块之间的关系。

这张图把四个核心模块串起来了。你会发现，指针和内存管理是基础，函数指针和回调是设计技巧，宏定义是编译期工具，头文件组织是工程化保障。四者缺一不可。

好了，这一章的内容就到这里。记住我说的：C的功底，决定了C++的上限。下一章我们会正式进入C++的世界，从“C with Classes”开始，看看C++到底在C的基础上做了哪些改进。

可可精品资料库