返回专栏
· 15 分钟阅读

C 与 C++ 的区别


一、C 与 C++ 的基本定位

C 和 C++ 都是广泛应用于系统软件、底层开发和高性能计算的编程语言。两者拥有相似的语法基础,但设计目标、语言机制和工程能力存在明显差异。

1. C 语言

C 由 Dennis Ritchie 在 20 世纪 70 年代初设计,最初用于 Unix 系统开发。

C 的核心设计目标包括:

  • 接近硬件:提供指针、内存地址和底层数据操作能力。
  • 高效执行:语言抽象较少,便于编译器生成高效机器代码。
  • 结构化编程:以函数、语句和控制结构组织程序。
  • 可移植性:通过标准化语言规范支持不同硬件和操作系统。

C 常用于:

  • 操作系统内核
  • 嵌入式系统
  • 驱动程序
  • 编译器和解释器
  • 网络协议栈
  • 系统级工具

2. C++ 语言

C++ 由 Bjarne Stroustrup 在 20 世纪 80 年代初设计,最初以 C with Classes 为基础,后来发展为多范式编程语言。

C++ 保留了大量 C 风格语法,同时增加了更丰富的抽象机制。

核心设计能力包括:

  • 面向对象编程:类、对象、继承、多态和封装。
  • 泛型编程:模板、类型参数和编译期计算。
  • 资源管理:构造函数、析构函数和 RAII。
  • 运算符重载:允许自定义类型定义特定运算行为。
  • 标准库:提供容器、算法、迭代器、并发工具等。
  • 零成本抽象:在不需要运行时开销的情况下提供高级抽象能力。

C++ 常用于:

  • 游戏引擎
  • 桌面应用程序
  • 高性能服务器
  • 浏览器和数据库
  • 图形渲染
  • 金融计算
  • 实时系统

二、C 与 C++ 的核心区别

C 和 C++ 的区别不只是有没有类,而是两种语言在抽象方式、类型系统、资源管理和程序组织方面存在系统性差异。

对比维度 C C++
编程范式 主要是过程式编程 多范式编程
核心组织方式 函数、结构体 类、对象、函数、模板
面向对象 不原生支持 原生支持
封装机制 通过结构和模块约定实现 类、访问控制和封装
继承与多态 不原生支持 支持继承和运行时多态
泛型机制 主要依赖宏、void* 等 模板
函数重载 不支持 支持
运算符重载 不支持 支持
内存管理 malloc、free new、delete,以及 RAII
资源管理 主要依赖显式释放和约定 构造、析构和智能指针
异常处理 不提供语言级异常机制 支持异常机制
标准库 相对精简 提供丰富的标准库
类型系统 以 C 的类型规则为基础 增加类、模板、引用等机制
编译复杂度 相对较低 通常更复杂
二进制兼容性 取决于 ABI 和平台 还涉及名称修饰、对象布局等

需要注意:C++ 并不是简单地在 C 上增加面向对象功能。C++ 有独立的语言标准,C 与 C++ 的语法和语义并非完全兼容。

三、编程范式的区别

1. C:以过程式编程为核心

C 通常将程序组织为多个函数,通过函数调用完成业务逻辑。

数据结构与操作数据的函数通常分开定义。

#include <stdio.h>

struct User {
    int id;
    int age;
};

void print_user(struct User user) {
    printf("ID: %d, Age: %d\n", user.id, user.age);
}

int main(void) {
    struct User user = {1, 25};

    print_user(user);

    return 0;
}

在这个例子中:

  • struct User 描述数据结构。
  • print_user() 负责操作和展示数据。
  • 数据和操作数据的函数没有通过语言级类机制绑定在一起。

C 可以通过模块、头文件、结构体和函数指针实现较好的封装,但需要开发者自行设计接口边界。

2. C++:支持面向对象编程

C++ 可以将数据和操作数据的方法组织在同一个类中。

#include <iostream>
#include <string>

class User {
private:
    int id;
    int age;

public:
    User(int userId, int userAge)
        : id(userId), age(userAge) {}

    void print() const {
        std::cout << "ID: " << id
                  << ", Age: " << age << '\n';
    }
};

int main() {
    User user(1, 25);

    user.print();

    return 0;
}

这里:

  • private 控制成员访问权限。
  • 构造函数负责初始化对象。
  • print() 是对象的方法。
  • const 成员函数承诺不通过该函数修改对象的非 mutable 成员。

C++ 的类机制可以将数据和行为封装在一起,但并不意味着所有 C++ 程序都必须采用面向对象设计。

C++ 同样支持过程式编程和函数式风格编程。

四、数据类型与类型系统的区别

1. 结构体的差异

C 和 C++ 都支持结构体,但 C++ 中的结构体能力更丰富。

C 语言:

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point p = {10, 20};

    return 0;
}

C++:

struct Point {
    int x;
    int y;

    void move(int dx, int dy) {
        x += dx;
        y += dy;
    }
};

int main() {
    Point p{10, 20};

    p.move(5, 5);

    return 0;
}

主要区别:

特性 C struct C++ struct
成员变量 支持 支持
成员函数 不支持 支持
构造函数 不支持 支持
析构函数 不支持 支持
继承 不支持 支持
访问控制 没有类式访问控制 支持 public、private、protected
默认成员访问权限 成员可直接访问 默认 public

C++ 中的 struct 和 class 在语言能力上基本相同,主要区别是默认访问权限:

  • struct 默认成员访问权限为 public。
  • class 默认成员访问权限为 private。

2. 引用与指针

C 支持指针,但不支持 C++ 意义上的引用类型。

C:

#include <stdio.h>

void increment(int *value) {
    if (value != NULL) {
        (*value)++;
    }
}

int main(void) {
    int number = 10;

    increment(&number);

    printf("%d\n", number);

    return 0;
}

C++:

#include <iostream>

void increment(int& value) {
    value++;
}

int main() {
    int number = 10;

    increment(number);

    std::cout << number << '\n';

    return 0;
}

两者的主要区别:

对比 指针 C++ 引用
是否保存地址 是 语义上是对象的别名
是否可以为空 可以 正常情况下必须绑定有效对象
是否可以重新指向 可以 不能重新绑定到另一个对象
使用方式 通过 * 解引用 直接使用
是否支持指针运算 支持 不支持
是否支持多级间接访问 支持 不支持引用的引用作为普通引用类型

需要注意,C++ 引用在底层可能通过地址实现,但语言语义并不等同于指针。引用也不能替代所有指针场景。

五、内存管理机制的区别

内存管理是 C 与 C++ 的重要区别之一。

1. C:malloc 与 free

C 主要通过标准库中的动态内存分配函数管理内存。

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

int main(void) {
    int *arr = malloc(5 * sizeof(int));

    if (arr == NULL) {
        return 1;
    }

    for (int i = 0; i < 5; i++) {
        arr[i] = i * 10;
    }

    free(arr);
    arr = NULL;

    return 0;
}

核心函数:

函数 作用
malloc() 分配指定大小的内存,不初始化内容
calloc() 分配内存并将其全部字节初始化为零
realloc() 调整已分配内存的大小
free() 释放动态分配的内存

C 的动态内存管理主要依赖程序员显式控制分配和释放时机。

常见问题:

  • 内存泄漏:分配的内存没有释放。
  • 重复释放:同一块内存被多次释放。
  • 野指针:指针指向已经失效的对象或内存。
  • 越界访问:访问超出分配范围的内存。

2. C++:new 与 delete

C++ 提供 new 和 delete 表达式,用于创建和销毁对象。

#include <iostream>

int main() {
    int* value = new int(100);

    std::cout << *value << '\n';

    delete value;
    value = nullptr;

    return 0;
}

与 C 的 malloc() 不同,new 不只是分配内存,还会根据对象类型执行初始化。

对于类类型,new 会调用构造函数,delete 会调用析构函数。

数组分配需要对应使用数组形式:

int* arr = new int[5];

delete[] arr;

new[] 必须与 delete[] 配对,不能混用。

3. C++ 的 RAII 资源管理

C++ 更重要的内存管理能力不是 new 和 delete,而是 RAII(Resource Acquisition Is Initialization)。

RAII 将资源的获取与对象生命周期绑定:

  • 对象构造时获取资源。
  • 对象销毁时释放资源。
  • 利用作用域和析构函数自动完成清理。

例如:

#include <iostream>
#include <memory>

int main() {
    auto value = std::make_unique<int>(100);

    std::cout << *value << '\n';

    return 0;
}

std::unique_ptr 独占管理动态对象,当智能指针离开作用域时,会自动释放其管理的对象。

常见智能指针:

类型 所有权模型 主要用途
std::unique_ptr 独占所有权 一个对象只有一个主要所有者
std::shared_ptr 共享所有权 多个对象共享资源生命周期
std::weak_ptr 弱引用 观察共享对象,避免循环引用

实际开发中,C++ 通常优先使用标准容器、智能指针和 RAII,而不是直接大量使用 new 和 delete。

六、函数机制的区别

1. 函数重载

C 不支持通过相同函数名、不同参数列表定义多个函数。

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

double add_double(double a, double b) {
    return a + b;
}

C++ 支持函数重载:

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

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

int main() {
    int a = add(1, 2);
    double b = add(1.5, 2.5);

    return 0;
}

编译器根据调用时的参数类型、数量和重载决议规则选择合适的函数。

需要注意,C++ 不能仅通过返回值类型不同来重载函数。

2. 默认参数

C 不原生支持函数默认参数。

C++ 支持默认参数:

#include <iostream>

void greet(const char* name, int age = 18) {
    std::cout << name << ", " << age << '\n';
}

int main() {
    greet("Tom");
    greet("Jerry", 25);

    return 0;
}

默认参数通常在调用点由编译器根据函数声明处理,并不意味着运行时自动进行参数推断。

3. 内联函数

C 和 C++ 都支持 inline,但其语义与使用规则并不完全相同。

在 C 中,inline 的链接规则比较特殊,尤其涉及 extern inline 和不同 C 标准的具体定义。

在 C++ 中,inline 除了提示内联优化外,还具有重要的 ODR(One Definition Rule,单一定义规则)相关语义,允许符合规则的内联函数定义出现在多个翻译单元中。

需要注意:

  • inline 不保证函数一定被展开。
  • 编译器可以忽略内联建议。
  • 即使没有写 inline,编译器也可能自动进行内联优化。

七、面向对象与多态机制

C 不原生支持类继承和虚函数,但可以通过结构体、函数指针和手动约定模拟类似设计。

1. C 中通过函数指针模拟多态

#include <stdio.h>

typedef struct {
    void (*speak)(void);
} Animal;

void dog_speak(void) {
    printf("Woof\n");
}

void cat_speak(void) {
    printf("Meow\n");
}

int main(void) {
    Animal dog = {dog_speak};
    Animal cat = {cat_speak};

    dog.speak();
    cat.speak();

    return 0;
}

这里通过函数指针保存不同实现,实现了类似动态分派的效果。

但这种方式需要程序员手动维护对象布局、函数指针和类型约定,并不等同于语言原生的继承和多态系统。

2. C++ 中通过虚函数实现运行时多态

#include <iostream>

class Animal {
public:
    virtual void speak() const {
        std::cout << "Animal\n";
    }

    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    void speak() const override {
        std::cout << "Woof\n";
    }
};

class Cat : public Animal {
public:
    void speak() const override {
        std::cout << "Meow\n";
    }
};

int main() {
    Dog dog;
    Cat cat;

    Animal* animals[] = {&dog, &cat};

    for (Animal* animal : animals) {
        animal->speak();
    }

    return 0;
}

关键机制:

  • virtual 声明虚函数。
  • override 明确表示派生类重写基类虚函数。
  • 基类指针可以指向派生类对象。
  • 通过基类指针调用虚函数时,根据实际对象类型进行动态分派。

常见 C++ ABI 通常通过虚函数表(vtable)和虚指针(vptr)实现动态分派,但 C++ 标准并没有强制规定必须采用这种具体实现。

另外,若类会通过基类指针销毁派生类对象,基类通常需要具有虚析构函数,否则可能产生未定义行为。

八、泛型编程的区别

1. C:使用 void* 和宏实现通用操作

C 没有 C++ 模板机制,通常使用 void*、宏或针对不同类型编写不同函数。

例如:

#include <stdio.h>

void print_value(const void* value, char type) {
    if (type == 'i') {
        printf("%d\n", *(const int*)value);
    } else if (type == 'd') {
        printf("%f\n", *(const double*)value);
    }
}

int main(void) {
    int a = 10;
    double b = 3.14;

    print_value(&a, 'i');
    print_value(&b, 'd');

    return 0;
}

这种方式能够处理不同类型的数据,但存在一些问题:

  • 类型信息需要额外传递。
  • 类型转换需要程序员负责。
  • 错误类型可能导致未定义行为。
  • 编译器无法像模板那样针对具体类型进行完整的编译期检查。

2. C++:使用模板实现泛型

C++ 提供模板机制,可以编写与具体类型无关的代码。

#include <iostream>

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    std::cout << add(1, 2) << '\n';
    std::cout << add(1.5, 2.5) << '\n';

    return 0;
}

编译器根据模板实参生成相应的实例化代码。

模板的主要优势:

  • 编译期类型检查。
  • 减少重复代码。
  • 支持泛型容器和算法。
  • 支持模板特化和编译期计算。
  • 能够构建高性能的通用抽象。

C++ 模板不仅用于函数,也可以用于类、变量和其他模板结构。

九、异常处理机制的区别

1. C:通过返回值和错误码处理错误

C 没有原生的 try、catch 和 throw 异常处理语法。

常见方式是通过返回值表示执行结果:

#include <stdio.h>

int divide(int a, int b, int* result) {
    if (b == 0 || result == NULL) {
        return -1;
    }

    *result = a / b;
    return 0;
}

int main(void) {
    int result;

    if (divide(10, 2, &result) != 0) {
        printf("Division failed\n");
        return 1;
    }

    printf("%d\n", result);

    return 0;
}

这种方式的特点:

  • 错误处理路径明确。
  • 调用者需要检查返回值。
  • 错误传播通常需要逐层处理。
  • 资源清理需要开发者显式组织。

C 也可以使用 errno、setjmp() 和 longjmp() 等机制处理特定错误场景,但它们并不等同于 C++ 异常机制。

2. C++:支持异常机制

#include <iostream>
#include <stdexcept>

double divide(double a, double b) {
    if (b == 0) {
        throw std::runtime_error("Division by zero");
    }

    return a / b;
}

int main() {
    try {
        std::cout << divide(10, 2) << '\n';
        std::cout << divide(10, 0) << '\n';
    } catch (const std::exception& e) {
        std::cerr << e.what() << '\n';
    }

    return 0;
}

核心语法:

关键字 作用
try 定义可能抛出异常的代码区域
throw 抛出异常对象
catch 捕获并处理异常

C++ 异常机制通常涉及栈展开(Stack Unwinding)。

当异常离开当前作用域时,已经构造完成的自动存储期对象会按照析构规则销毁。这也是 RAII 能够与异常安全协同工作的原因。

需要注意,异常并不是所有 C++ 项目都必须采用的错误处理方式。嵌入式、实时系统或特定性能敏感项目可能禁用异常,采用错误码、std::expected 等方式处理错误。

十、标准库的区别

C 和 C++ 都有标准库,但提供的抽象层次和功能范围不同。

1. C 标准库

C 标准库提供基础的通用功能:

头文件 主要功能
stdio.h 输入输出
stdlib.h 内存分配、程序控制、通用工具
string.h 字符串和内存操作
math.h 数学运算
time.h 时间处理
ctype.h 字符分类和转换
stdint.h 固定宽度整数类型
stdbool.h 布尔类型支持

2. C++ 标准库

C++ 标准库在基础功能之外,提供了大量高级抽象。