C语言作为面向过程的经典语言，以流程和函数为核心构建程序。而C++在兼容C语言特性的基础上，融入了面向对象思想，凭借封装、继承、多态三大特性显著拓展了编程边界。两者的差异远不止于此，从数据类型、函数特性到内存管理与错误处理，乃至最基础的类型转换方式，都存在显著区别。对于开发者，尤其是面临C++面试的求职者而言，深入理解这些差异至关重要。
一、编程范式：面向过程 vs 面向对象
C语言是一门典型的面向过程编程语言，它强调的是程序执行的过程和步骤，通过函数将解决问题的步骤一步一步实现，使用时依次调用这些函数。例如，实现一个简单的两数相加功能，在 C 语言中可能会这样写：
#include <stdio.h>
// 定义一个函数用于两数相加
int add(int a, int b) {
return a + b;
}
int main() {
int num1 = 3;
int num2 = 5;
int result = add(num1, num2);
printf("两数之和为：%d\n", result);
return 0;
}
在这个例子中，我们定义了一个 add 函数来实现特定功能，然后在 main 函数中按步骤调用。这就是典型的面向过程编程，注重功能实现的步骤和流程。
而 C++ 在保留面向过程编程特性的基础上，引入了面向对象编程范式。它将现实世界中的实体抽象为类，类中封装了数据（属性）和操作这些数据的方法（行为）。通过创建类的对象来操作数据，使得代码的组织结构更加贴近现实世界的模型。例如，同样实现一个简单的数学运算类：
#include <iostream>
// 定义一个数学运算类
class MathOperation {
private:
// 类的私有成员变量
int data;
public:
// 类的公有成员函数，实现两数相加
int add(int a, int b){
return a + b;
}
};
int main(){
MathOperation operation;
int num1 = 3;
int num2 = 5;
int result = operation.add(num1, num2);
std::cout << "两数之和为：" << result << std::endl;
return 0;
}
在 C++ 代码中，我们定义了一个 MathOperation 类，数据和操作被封装在一起。在 main 函数中，通过创建类的对象 operation 来调用方法。这体现了通过对象调用方法完成操作的特点，增强了代码的封装性和模块化。
C++ 还完整支持面向对象的三大特性：封装、继承和多态。封装提高了数据的安全性；继承实现了代码的复用；多态则提高了代码的灵活性和扩展性。例如，通过继承和多态实现不同动物的叫声：
#include <iostream>
// 基类
class Animal {
public:
virtual void speak(){
std::cout << "动物发出声音" << std::endl;
}
};
// 派生类 Dog 继承自 Animal
class Dog : public Animal {
public:
void speak() override{
std::cout << "汪汪汪" << std::endl;
}
};
// 派生类 Cat 继承自 Animal
class Cat : public Animal {
public:
void speak() override{
std::cout << "喵喵喵" << std::endl;
}
};
// 测试多态性的函数
void testSpeak(Animal& animal){
animal.speak();
}
int main(){
Dog dog;
Cat cat;
testSpeak(dog); // 输出“汪汪汪”
testSpeak(cat); // 输出“喵喵喵”
return 0;
}
在这段代码中，Animal 是基类，Dog 和 Cat 是派生类。testSpeak 函数接收一个 Animal 类型的引用，在调用 speak 函数时，根据传入对象的实际类型决定执行哪个函数，这就是多态的体现。
二、数据类型：C++的扩展与增强
在数据类型方面，C++ 在 C 语言的基础上进行了显著的拓展。C++ 引入了 bool 类型，专门用于表示逻辑值 true 和 false，使逻辑判断更加清晰。例如：
#include <iostream>
int main(){
bool isFinished = true;
if (isFinished) {
std::cout << "任务已完成" << std::endl;
} else {
std::cout << "任务未完成" << std::endl;
}
return 0;
}
C++ 还引入了引用类型（&）。引用可以看作是变量的别名，在函数参数传递等方面提供了一种更安全方便的方式。对比 C 语言用指针交换两个整数：
#include <stdio.h>
// 交换两个整数的值
void swap(int* a, int* b){
int temp = *a;
*a = *b;
*b = temp;
}
int main(){
int num1 = 3;
int num2 = 5;
printf("交换前: num1 = %d, num2 = %d\n", num1, num2);
swap(&num1, &num2);
printf("交换后: num1 = %d, num2 = %d\n", num1, num2);
return 0;
}
而用 C++ 的引用可以这样写，更加直观：
#include <iostream>
// 交换两个整数的值
void swap(int& a, int& b){
int temp = a;
a = b;
b = temp;
}
int main(){
int num1 = 3;
int num2 = 5;
std::cout << "交换前: num1 = " << num1 << ", num2 = " << num2 << std::endl;
swap(num1, num2);
std::cout << "交换后: num1 = " << num1 << ", num2 = " << num2 << std::endl;
return 0;
}
此外，C++ 引入了 wchar_t 等宽字符类型以更好地支持 Unicode，并支持模板，实现了泛型编程。例如，定义一个泛型函数获取较大值：
#include <iostream>
// 泛型函数，获取两个数中的较大值
template <typename T>
T max(T a, T b){
return a > b? a : b;
}
int main(){
int num1 = 3, num2 = 5;
double d1 = 3.14, d2 = 2.71;
std::cout << "较大的整数是: " << max(num1, num2) << std::endl;
std::cout << "较大的浮点数是: " << max(d1, d2) << std::endl;
return 0;
}
三、函数特性：C++的灵活与高效
在函数特性方面，C++ 相比 C 语言有了很大的改进和扩展。
1. 函数重载：C++ 支持在同一作用域内定义多个同名函数，但参数列表必须不同。编译器根据实际参数调用合适的函数。
#include <iostream>
// 整数加法
int add(int a, int b){
return a + b;
}
// 浮点数加法
double add(double a, double b){
return a + b;
}
int main(){
int result1 = add(3, 5); // 调用 int add(int, int)
double result2 = add(3.14, 2.71); // 调用 double add(double, double)
std::cout << "整数相加结果: " << result1 << std::endl;
std::cout << "浮点数相加结果: " << result2 << std::endl;
return 0;
}
2. 默认参数：在函数声明时可为参数指定默认值，调用时若未传入则使用默认值。
#include <iostream>
// 带有默认参数的函数
void greet(std::string name = "World"){
std::cout << "Hello, " << name << "!" << std::endl;
}
int main(){
greet(); // 输出 Hello, World!
greet("Alice"); // 输出 Hello, Alice!
return 0;
}
3. 内联函数：通过 inline 关键字建议编译器将函数体插入调用处，减少调用开销，适用于短小频繁调用的函数。
#include <iostream>
// 内联函数定义
inline int square(int x){
return x * x;
}
int main(){
int num = 5;
int result = square(num);
std::cout << "平方结果: " << result << std::endl;
return 0;
}
而在 C 语言中，要实现类似功能通常需要定义不同名称的函数，或用宏定义模拟，但宏定义缺乏类型检查，容易出错。
四、内存管理：从手动到智能
内存管理直接关系到程序的性能和稳定性。C 语言主要使用 malloc 和 free 进行手动内存管理。
#include <stdio.h>
#include <stdlib.h>
int main(){
int* ptr = (int*)malloc(sizeof(int));
if (ptr == NULL) {
printf("内存分配失败！\n");
return 1;
}
*ptr = 42;
printf("分配的内存中的值：%d\n", *ptr);
free(ptr);
return 0;
}
malloc/free 的问题在于需要手动初始化和释放，容易导致内存泄漏或错误释放。
C++ 引入了 new 和 delete 操作符。new 不仅分配内存，还会调用构造函数初始化；delete 会调用析构函数后释放内存。
#include <iostream>
class MyClass {
public:
MyClass() {
std::cout << "MyClass 构造函数被调用" << std::endl;
}
~MyClass() {
std::cout << "MyClass 析构函数被调用" << std::endl;
}
};
int main(){
MyClass* obj = new MyClass; // 分配内存并调用构造函数
delete obj; // 调用析构函数并释放内存
return 0;
}
更重要的是，C++ 引入了智能指针，基于 RAII（资源获取即初始化）原则自动管理内存，极大提升了安全性。
std::unique_ptr：独占所有权，同一时间只能有一个指针指向对象。std::shared_ptr：共享所有权，通过引用计数管理，计数为零时自动释放。std::weak_ptr：弱引用，不增加引用计数，用于解决 shared_ptr 的循环引用问题。
#include <iostream>
#include <memory>
int main(){
// 使用 std::make_unique 创建 unique_ptr
auto ptr = std::make_unique<int>(42);
std::cout << *ptr << std::endl;
// 通过 std::move 转移所有权
auto ptr2 = std::move(ptr);
if (!ptr) {
std::cout << "ptr 已为空，所有权已转移" << std::endl;
}
return 0;
}
五、错误处理：返回值 vs 异常机制
C 语言主要依靠函数返回值来表示错误状态，调用者必须显式检查。
#include <stdio.h>
#include <stdlib.h>
int main() {
FILE* file = fopen("nonexistent.txt", "r");
if (file == NULL) {
perror("Error opening file");
return EXIT_FAILURE;
}
// 文件操作...
fclose(file);
return EXIT_SUCCESS;
}
这种方式在复杂调用链中会使错误处理代码与业务逻辑混杂。
C++ 引入了 try、catch 和 throw 异常处理机制，将错误处理与正常逻辑分离。
#include <iostream>
#include <stdexcept>
double divide(double numerator, double denominator){
if (denominator == 0) {
throw std::runtime_error("Division by zero is not allowed");
}
return numerator / denominator;
}
int main(){
try {
double result = divide(10.0, 0.0);
std::cout << "结果: " << result << std::endl;
} catch (const std::runtime_error& e) {
std::cerr << "捕获到异常: " << e.what() << std::endl;
}
return 0;
}
C++ 还支持自定义异常类，实现更精细的错误处理。
六、类型转换：安全性的飞跃
类型转换是编程中的常见操作，C 和 C++ 的处理方式截然不同。
C 语言使用 C 风格强制类型转换，写法简单但安全隐患大。
#include <stdio.h>
int main(){
double d = 3.14;
int i = (int)d; // C风格强制转换
printf("转换后的整数: %d\n", i);
return 0;
}
C++ 引入了四种专用的类型转换操作符，安全性高、意图明确。
- static_cast：用于编译时的非多态转换，如基本类型转换、上行转换。
int i = static_cast<int>(d); // 基本类型转换
Base* bPtr = static_cast<Base*>(&dObj); // 上行转换（安全）
- dynamic_cast：用于运行时的安全向下转型，依赖 RTTI，失败返回
nullptr（指针）或抛出异常（引用）。
Derived* dPtr = dynamic_cast<Derived*>(bPtr); // 安全向下转型
if (dPtr == nullptr) {
// 转换失败处理
}
- const_cast：用于添加或移除
const 或 volatile 限定符。
const char* cstr = "hello";
char* str = const_cast<char*>(cstr); // 移除const限定
- reinterpret_cast：低层级重新解释，最危险，应尽量避免。
char* charPtr = reinterpret_cast<char*>(ptr); // 重新解释指针类型
七、高频面试题解析
1. C 和 C++ 的区别有哪些？
回答时应系统阐述：编程范式（面向过程 vs 面向对象）、数据类型扩展（bool、引用、模板等）、函数特性（重载、默认参数、内联）、内存管理（malloc/free vs new/delete 及智能指针）、错误处理（返回值 vs 异常）、类型转换（C风格 vs 四种操作符）等。
2. new/delete 和 malloc/free 的区别？
new/delete 是操作符，malloc/free 是函数。new 分配内存并调用构造函数，delete 调用析构函数并释放内存；malloc/free 仅进行内存分配释放。new 返回类型指针，malloc 返回 void* 需强制转换。new 失败抛出 bad_alloc 异常，malloc 失败返回 NULL。
3. 智能指针如何实现自动内存管理？
基于 RAII 原则。unique_ptr 独占所有权，对象销毁时自动释放；shared_ptr 通过引用计数共享所有权，计数归零自动释放；weak_ptr 弱引用，不增加计数，用于打破循环引用。
4. 什么是多态，如何实现？
多态指同一接口在不同对象上表现出不同行为。C++中通过虚函数和继承实现：基类声明虚函数 (virtual)，派生类重写 (override)，通过基类指针或引用调用虚函数时，根据对象实际类型动态绑定到对应函数。
5. vector 和 list 的区别及使用场景？
- vector：动态数组，连续内存，支持随机访问（效率高），中间插入删除效率低（需移动元素）。
- list：双向链表，非连续内存，不支持随机访问（需遍历），任意位置插入删除效率高（仅修改指针）。
- 场景：需频繁随机访问用
vector；需频繁在任意位置插入删除用 list。
理解 C 与 C++ 的核心差异，不仅是应对技术面试的关键，更是编写高效、健壮 C++ 代码的基础。希望本文的梳理能帮助你建立起清晰的知识框架。如果你想深入探讨某个主题，或分享自己的学习心得，欢迎到云栈社区与更多开发者交流。
发表于 前天 06:05
|
查看: 19|
回复: 0
