一、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++ 标准库在基础功能之外,提供了大量高级抽象。