深入理解C++的重载、继承、多态三大特性
承接Qt/C++软件开发项目，高质量交付，灵活沟通，长期维护支持。需求所寻，技术正适，共创完美，欢迎联系(微信：wid_ljh)！
引言
C++ 是一种支持面向对象编程（OOP）的语言，提供了丰富的特性来实现代码的复用和扩展。其中，重载（Overloading）、多态（Polymorphism）和继承（Inheritance）是 OOP 的三大核心特性。
1. 重载（Overloading）
1.1 概念简介
重载是指在同一个作用域内定义多个同名函数或运算符，但它们的参数列表不同。编译器根据调用时提供的参数类型和数量来选择合适的版本。因此，重载的核心在于参数签名的不同。
-
示例：函数重载
#include
void print(int x) {
std::cout << "Integer: " << x << "\n";
}
void print(double x) {
std::cout << "Double: " << x << "\n";
}
void print(int x, int y) {
std::cout << "Two integers: " << x << ", " << y << "\n";
}
int main() {
print(42); // 调用第一个print
print(3.14); // 调用第二个print
print(1, 2); // 调用第三个print
return 0;
} -
示例：运算符重载
class Complex {
public:
double real, imag;
Complex(double r = 0, double i = 0) : real(r), imag(i) {}
Complex operator+(const Complex& rhs) const {
return Complex(real + rhs.real, imag + rhs.imag);
}
};
int main() {
Complex c1(1, 2), c2(3, 4);
Complex c3 = c1 + c2;
std::cout << "Result: (" << c3.real << ", " << c3.imag << ")\n";
return 0;
}1.2 最佳实践
- 避免过多重载：过多的重载会增加代码复杂度，降低可读性。
- 明确命名优于重载：有时候，使用不同的函数名称比重载更清晰。
- 考虑默认参数：通过默认参数可以减少重载的数量。
1.3 设计模式中的应用
- 工厂模式：利用函数重载根据不同的参数创建不同的对象实例。
- 策略模式：通过重载操作符或方法为不同策略提供统一接口。
2. 继承（Inheritance）
2.1 概念简介
继承允许一个类（派生类）从另一个类（基类）继承属性和行为，从而实现代码复用。C++ 支持单继承和多继承。
-
示例：单继承
class Vehicle {
public:
void start() { std::cout << "Vehicle started.\n"; }
};
class Car : public Vehicle {
public:
void drive() { std::cout << "Car is driving.\n"; }
};
int main() {
Car myCar;
myCar.start(); // 继承自Vehicle的方法
myCar.drive(); // Car自己的方法
return 0;
}-
示例：多继承
class Engine {
public:
void startEngine() { std::cout << "Engine started.\n"; }
};
class Wheel {
public:
void rotateWheel() { std::cout << "Wheel rotated.\n"; }
};
class Car : public Engine, public Wheel {
public:
void drive() { std::cout << "Car is driving.\n"; }
};
int main() {
Car myCar;
myCar.startEngine(); // 继承自Engine的方法
myCar.rotateWheel(); // 继承自Wheel的方法
myCar.drive(); // Car自己的方法
return 0;
}2.2 访问控制
C++ 提供了三种访问控制修饰符：public、protected 和 private，用于控制类成员的可见性。
- public：成员可以在任何地方访问。
- protected：成员只能在类内部和派生类中访问。
- private：成员只能在类内部访问。
示例：访问控制
class Base {
protected:
int protectedData;
private:
int privateData;
public:
void setProtectedData(int data) { protectedData = data; }
void setPrivateData(int data) { privateData = data; }
int getProtectedData() const { return protectedData; }
int getPrivateData() const { return privateData; }
};
class Derived : public Base {
public:
void displayProtectedData() const { std::cout << "Protected Data: " << protectedData << "\n"; }
// 无法直接访问privateData
};2.3 构造函数与析构函数
派生类的构造函数可以调用基类的构造函数进行初始化，并且需要确保所有基类的构造函数都得到调用。
class Base {
public:
Base(int x) : m_x(x) { std::cout << "Base constructor called.\n"; }
protected:
int m_x;
};
class Derived : public Base {
public:
Derived(int x, int y) : Base(x), m_y(y) { std::cout << "Derived constructor called.\n"; }
~Derived() { std::cout << "Derived destructor called.\n"; }
private:
int m_y;
};
int main() {
Derived d(1, 2);
return 0;
}2.4 继承 vs 组合
并非所有情况下都应该使用继承。有时候，组合模式（Composition）更合适，即通过包含其他类的对象来实现功能，而不是通过继承。组合提高了模块化和灵活性，减少了代码耦合。
-
示例：组合
class Engine {
public:
void start() { std::cout << "Engine started\n"; }
};
class Car {
private:
Engine engine;
public:
void startCar() {
engine.start(); // 使用组合的方式调用Engine的方法
std::cout << "Car started\n";
}
};
int main() {
Car car;
car.startCar();
return 0;
}2.5 设计模式中的应用
- 装饰模式：通过组合来添加新功能，而不改变原有类的行为。
- 代理模式：通过组合来控制对其他对象的访问。
3. 多态（Polymorphism）
3.1 概念简介
多态性指的是同一接口可以有多种实现方式。C++ 主要通过虚函数（virtual function）实现动态多态性，即运行时多态。
-
示例：动态多态性
#include
#include
class Shape {
public:
virtual double area() const = 0; // 纯虚函数
virtual ~Shape() {} // 虚析构函数
};
class Circle : public Shape {
private:
double radius;
public:
Circle(double r) : radius(r) {}
double area() const override { return 3.14159 * radius * radius; }
};
class Rectangle : public Shape {
private:
double width, height;
public:
Rectangle(double w, double h) : width(w), height(h) {}
double area() const override { return width * height; }
};
void processShapes(const std::vector>& shapes) {
for (const auto& shape : shapes) {
std::cout << "Area: " << shape->area() << "\n";
}
}
int main() {
std::vector> shapes;
shapes.push_back(std::make_unique(5.0));
shapes.push_back(std::make_unique(4.0, 6.0));
processShapes(shapes);
return 0;
} 3.2 动态绑定与虚函数表
当一个类中声明了虚函数后，编译器会为该类创建一个虚函数表（vtable），每个对象都有一个指向这个表的指针（vptr）。当通过基类指针或引用来调用虚函数时，程序会在运行时查找 vtable，找到正确的派生类实现。
3.3 抽象类与接口
抽象类包含纯虚函数，不能实例化，通常用于定义接口。接口是一种特殊的抽象类，所有成员均为纯虚函数，适用于定义一组相关的行为规范。
class Drawable {
public:
virtual void draw() const = 0; // 定义绘图接口
virtual ~Drawable() {}
};
class Square : public Drawable {
public:
void draw() const override { std::cout << "Drawing square\n"; }
};3.4 性能与内存开销
- 虚函数的性能开销：每次调用虚函数时都需要通过 vtable 查找实际实现，这比直接调用静态函数稍微慢一些。但在现代 CPU 上，这种开销通常是可以接受的。
- 虚析构函数的重要性：如果基类中有虚函数，建议将析构函数也声明为虚函数，以确保派生类的对象被正确销毁，防止资源泄漏。
3.5 设计模式中的应用
- 桥接模式：分离接口和实现，允许它们独立变化。
- 策略模式：通过多态行为选择不同的算法实现。
- 观察者模式：基类定义通用接口，派生类实现具体通知逻辑。
总结
- 重载：用于定义多个同名函数或运算符，根据参数的不同选择合适的版本。
- 继承：用于实现代码复用，注意访问控制和构造函数的调用顺序。
- 多态：通过虚函数实现动态绑定，增强代码的灵活性和扩展性。