C++ 指针与 C 语言指针的深度比较-EW帮帮网

特性	C 指针	C++ 指针
内存管理	手动 (`malloc/free`)	手动或智能指针 (`new/delete`, RAII)
类型安全	弱类型安全	强类型系统，类型转换操作符
空指针	`NULL` (通常为 0)	`nullptr` (类型安全的空指针)
面向对象支持	无直接支持	支持多态、虚函数、成员指针
引用类型	无	有引用类型 (`&`)，作为指针替代
函数指针	支持简单函数指针	支持成员函数指针和函数对象
模板支持	无	支持模板和泛型指针

二、关键区别详解

1. 内存管理方式

C 语言方式：

// 手动分配和释放
int* arr = (int*)malloc(10 * sizeof(int));
free(arr);

C++ 方式：

// 1. 手动管理
int* arr = new int[10];
delete[] arr;

// 2. 智能指针 (推荐)
#include <memory>
std::unique_ptr<int[]> smart_arr(new int[10]);
// 自动释放内存

// 3. RAII 模式
class ResourceHolder {
    int* resource;
public:
    ResourceHolder(size_t size) : resource(new int[size]) {}
    ~ResourceHolder() { delete[] resource; }
};

2. 类型安全性增强

C 语言问题：

void* p = malloc(sizeof(int));
float* f = (float*)p; // 危险的类型转换

C++ 解决方案：

// 1. 显式类型转换操作符
int* i = new int(42);
double* d = reinterpret_cast<double*>(i); // 明确危险转换

// 2. 模板类型安全
template <typename T>
void safe_process(T* ptr) {
    // 类型安全的操作
}

// 3. 智能指针类型绑定
std::unique_ptr<int> int_ptr = std::make_unique<int>(10);

3. 空指针表示

C 语言问题：

#define NULL 0
int* p = NULL; 
// 可能被误用为整数

C++ 解决方案：

// C++11 引入 nullptr
int* p = nullptr; 

// 类型安全的空指针
static_assert(!std::is_same_v<decltype(nullptr), int>);

4. 面向对象支持

C++ 特有特性：

class Base {
public:
    virtual void show() { cout << "Base\n"; }
};

class Derived : public Base {
public:
    void show() override { cout << "Derived\n"; }
};

// 多态指针
Base* b = new Derived();
b->show(); // 输出 "Derived" (动态绑定)

// 成员指针
void (Base::*memFuncPtr)() = &Base::show;
(b->*memFuncPtr)(); // 调用成员函数

5. 引用类型

C++ 特有特性：

int x = 10;
int& ref = x; // 引用是变量的别名
ref = 20;     // x 现在为 20

// 与指针对比
int* ptr = &x;
*ptr = 30;    // x 现在为 30

引用特性：

必须初始化
不能重新绑定
不需要解引用
语法更简洁

6. 函数指针的演进

C 语言函数指针：

typedef int (*Comparator)(int, int);
int compare(int a, int b) { return a - b; }

Comparator comp = &compare;
comp(5, 3); // 调用函数

C++ 增强：

// 1. 函数指针语法改进
using Comparator = int (*)(int, int);
auto comp = &compare;

// 2. 成员函数指针
class Sorter {
public:
    static int compare(int a, int b) { return a - b; }
};
int (Sorter::*memPtr)(int, int) = &Sorter::compare;

// 3. 函数对象 (Functor)
struct Comparator {
    bool operator()(int a, int b) const {
        return a < b;
    }
};
Comparator comp;
comp(3, 5); // 调用函数对象

// 4. std::function (C++11)
#include <functional>
std::function<int(int, int)> func = &compare;

7. 模板与泛型编程

C++ 特有优势：

// 泛型指针处理
template <typename T>
void processPointer(T* ptr) {
    // 类型安全的指针操作
}

// 智能指针模板
template <typename T>
class SmartPointer {
    T* ptr;
public:
    explicit SmartPointer(T* p) : ptr(p) {}
    ~SmartPointer() { delete ptr; }
};

三、使用场景对比

1. 数组处理

C 风格数组：

int arr[5] = {1, 2, 3, 4, 5};
int* p = arr;
printf("%d", *(p + 2)); // 输出 3

C++ 替代方案：

#include <array>
#include <vector>

// 1. std::array (固定大小)
std::array<int, 5> arr = {1, 2, 3, 4, 5};
auto it = arr.begin() + 2; // 使用迭代器

// 2. std::vector (动态数组)
std::vector<int> vec = {1, 2, 3, 4, 5};
int* p = vec.data(); // 获取原始指针

2. 字符串处理

C 风格字符串：

char str[20] = "Hello";
char* p = str;
p[5] = '!'; // 直接修改

C++ 替代方案：

#include <string>

std::string s = "Hello";
char* p = s.data(); // C++17 起
// 或 &s[0]

// 更安全的操作
s.replace(5, 1, "!");

3. 回调机制

C 风格回调：

typedef void (*Callback)(int);

void register_callback(Callback cb) {
    cb(42);
}

C++ 现代替代：

#include <functional>

void register_callback(std::function<void(int)> cb) {
    cb(42);
}

// 支持多种可调用对象
register_callback([](int x) { 
    std::cout << "Lambda: " << x; 
});

四、最佳实践对比

C 指针最佳实践

始终检查 malloc 返回值
使用 const 指针保护数据
明确指针所有权
避免复杂指针运算

C++ 指针最佳实践

优先使用智能指针：

auto ptr = std::make_unique<MyClass>();

避免裸指针所有权：

void process(std::unique_ptr<Resource> res); // 明确所有权转移

使用引用替代指针：

void modify(int& value); // 更安全

利用 RAII 管理资源：

class FileHandler {
    FILE* file;
public:
    FileHandler(const char* name) : file(fopen(name, "r")) {}
    ~FileHandler() { if(file) fclose(file); }
};

五、性能与安全考虑

方面	C 指针	C++ 指针
内存安全	容易泄漏/野指针	智能指针自动管理
类型安全	弱类型，易出错	强类型，编译期检查
性能	裸指针操作高效	智能指针有微小开销
多态支持	有限（通过函数指针模拟）	原生支持（虚函数、RTTI）
异常安全	无保证	RAII 保证异常安全

六、总结：何时使用何种指针

使用 C 风格指针的情况：
- 与 C 库交互的兼容层
- 嵌入式系统等受限环境
- 需要极致性能的底层操作
使用 C++ 现代指针的情况：
- 应用程序开发（优先智能指针）
- 面向对象设计（成员指针、多态）
- 资源管理（RAII）
- 泛型编程（模板）
- 需要异常安全的场景
关键选择原则：
```
资源管理：智能指针 > RAII > 裸指针
参数传递：const 引用 > 引用 > 智能指针 > 裸指针
返回值：  值返回 > 智能指针 > 裸指针
多态：    虚函数 > 函数指针
```
C++ 在保留 C 指针功能的同时，通过引用、智能指针、RAII 和强类型系统，显著提高了类型安全性和资源管理可靠性。现代 C++ 开发应当尽量减少裸指针的使用，优先选择更安全的抽象机制。

C++ 指针与 C 语言指针的深度比较

一、核心差异概述