当前位置：首页 > news >正文

C++三大特性：封装、继承与多态深度解析

news 2026/6/2 23:45:10

引言

C++作为一门强大的面向对象编程语言，其核心的三大特性——封装、继承和多态，构成了面向对象编程的基石。

这三大特性不仅使代码更模块化、可重用，还大大提升了软件的可维护性和扩展性。本文将深入探讨这三大特性的技术细节、实现机制和最佳实践。

性质	描述	访问修饰符	示例应用
封装	将数据（属性）和代码（方法）封装在一起，隐藏内部实现，提高安全性和数据保护	public, private, protected	创建类时，用私有成员变量来保护数据，通过公有方法提供访问接口
继承	允许新的类（派生类）继承现有类（基类）的属性和方法可以重写或扩展基类功能	使用public, protected 继承	定义通用类（如车辆），然后定义特定的子类（如汽车、自行车）
多态	允许同一接口呈现不同的行为支持接口重用和行为修改，使得代码更加灵活	主要通过虚函数和覆盖实现	定义一个基类接口（如绘图函数），让不同的派生类实现具体的绘图行为

一、封装（Encapsulation）

1.1 基本概念

封装是将数据（属性）和操作数据的方法（函数）捆绑在一起的机制，同时限制外部对内部数据的直接访问。封装的核心目标是实现信息隐藏和数据保护。

1.2 实现方式

class BankAccount { private: // 完全隐藏 double balance; string accountNumber; // 私有辅助方法 bool validateTransaction(double amount) { return amount > 0 && amount <= 10000; } protected: // 对派生类可见 string accountType; public: // 对外接口 BankAccount(string accNum, double initialBalance) : accountNumber(accNum), balance(initialBalance) {} // 公共接口方法 void deposit(double amount) { if (validateTransaction(amount)) { balance += amount; logTransaction("DEPOSIT", amount); } } double getBalance() const { return balance; } // 只读访问 const string& getAccountNumber() const { return accountNumber; } private: void logTransaction(const string& type, double amount) { // 实现日志记录 } };

1.3 封装的优势

数据安全：防止数据被意外修改
接口稳定性：内部实现可以改变而不影响外部调用
代码维护性：相关数据和行为集中管理
访问控制：通过public、private、protected精细控制访问权限

1.4 高级封装技巧

// 使用Pimpl惯用法实现完全封装 class WidgetImpl; // 前向声明 class Widget { public: Widget(); ~Widget(); void doSomething(); private: std::unique_ptr<WidgetImpl> pImpl; // 隐藏所有实现细节 }; // 实现文件 class WidgetImpl { // 所有私有数据和实现 int data; vector<string> items; public: void complexImplementation() { // 具体实现 } }; Widget::Widget() : pImpl(std::make_unique<WidgetImpl>()) {} Widget::~Widget() = default; void Widget::doSomething() { pImpl->complexImplementation(); }

二、继承（Inheritance）

2.1 继承类型与特点

C++支持多种继承方式，每种都有其特定用途：

// 1. 单继承 class Animal { protected: string name; int age; public: virtual void makeSound() = 0; // 纯虚函数 virtual ~Animal() = default; }; class Dog : public Animal { // 公有继承 private: string breed; public: Dog(string n, int a, string b) { name = n; age = a; breed = b; } void makeSound() override { cout << name << " says: Woof!" << endl; } // 派生类特有方法 void fetch() { cout << name << " is fetching the ball" << endl; } }; // 2. 多继承 class Printable { public: virtual void print() const = 0; virtual ~Printable() = default; }; class Loggable { public: virtual void log() const = 0; virtual ~Loggable() = default; }; class Document : public Printable, public Loggable { private: string content; public: void print() const override { cout << "Printing: " << content << endl; } void log() const override { cout << "Logging document" << endl; } }; // 3. 虚继承（解决菱形继承问题） class Base { protected: int value; }; class Derived1 : virtual public Base { // 虚继承 }; class Derived2 : virtual public Base { // 虚继承 }; class FinalDerived : public Derived1, public Derived2 { public: void setValue(int v) { value = v; // 只有一个value实例 } };

2.2 构造函数与析构函数调用顺序

class A { public: A() { cout << "A constructor" << endl; } ~A() { cout << "A destructor" << endl; } }; class B : public A { public: B() { cout << "B constructor" << endl; } ~B() { cout << "B destructor" << endl; } }; class C : public B { public: C() { cout << "C constructor" << endl; } ~C() { cout << "C destructor" << endl; } }; // 创建C对象时输出： // A constructor // B constructor // C constructor // 销毁时反向： // C destructor // B destructor // A destructor

2.3 继承中的访问控制

class Base { public: int publicVar; protected: int protectedVar; private: int privateVar; }; // 公有继承：基类的访问权限在派生类中保持不变 class PublicDerived : public Base { void test() { publicVar = 1; // OK protectedVar = 2; // OK // privateVar = 3; // 错误：不可访问 } }; // 保护继承：基类的public和protected在派生类中都变为protected class ProtectedDerived : protected Base { void test() { publicVar = 1; // OK (现在是protected) protectedVar = 2; // OK } }; // 私有继承：基类的所有成员在派生类中都变为private class PrivateDerived : private Base { void test() { publicVar = 1; // OK (现在是private) protectedVar = 2; // OK (现在是private) } };

三、多态（Polymorphism）

3.1 静态多态（编译期多态）

// 1. 函数重载 class Calculator { public: int add(int a, int b) { return a + b; } double add(double a, double b) { return a + b; } int add(int a, int b, int c) { return a + b + c; } }; // 2. 运算符重载 class Complex { private: double real, imag; public: Complex(double r = 0, double i = 0) : real(r), imag(i) {} // 成员函数运算符重载 Complex operator+(const Complex& other) const { return Complex(real + other.real, imag + other.imag); } // 友元函数运算符重载 friend ostream& operator<<(ostream& os, const Complex& c); }; ostream& operator<<(ostream& os, const Complex& c) { os << c.real << " + " << c.imag << "i"; return os; } // 3. 模板实现静态多态 template<typename T> T max(T a, T b) { return (a > b) ? a : b; } // 概念约束（C++20） template<typename T> concept Addable = requires(T a, T b) { { a + b } -> std::same_as<T>; }; template<Addable T> T sum(T a, T b) { return a + b; }

3.2 动态多态（运行期多态）

// 基类 class Shape { protected: string color; public: Shape(const string& c) : color(c) {} virtual ~Shape() = default; // 纯虚函数 - 抽象类 virtual double area() const = 0; virtual double perimeter() const = 0; // 虚函数 - 可以有默认实现 virtual void draw() const { cout << "Drawing a " << color << " shape" << endl; } // 非虚函数 - 不希望被重写 void setColor(const string& c) { color = c; } }; // 派生类 class Circle : public Shape { private: double radius; static constexpr double PI = 3.141592653589793; public: Circle(double r, const string& c = "black") : Shape(c), radius(r) {} double area() const override { return PI * radius * radius; } double perimeter() const override { return 2 * PI * radius; } void draw() const override { cout << "Drawing a " << color << " circle with radius " << radius << endl; } }; class Rectangle : public Shape { private: double width, height; public: Rectangle(double w, double h, const string& c = "black") : Shape(c), width(w), height(h) {} double area() const override { return width * height; } double perimeter() const override { return 2 * (width + height); } // 使用基类的draw()实现，不重写 }; // 多态使用示例 void processShape(Shape* shape) { cout << "Area: " << shape->area() << endl; cout << "Perimeter: " << shape->perimeter() << endl; shape->draw(); cout << "----------" << endl; } int main() { vector<unique_ptr<Shape>> shapes; shapes.push_back(make_unique<Circle>(5.0, "red")); shapes.push_back(make_unique<Rectangle>(4.0, 6.0, "blue")); for (const auto& shape : shapes) { processShape(shape.get()); } return 0; }

3.3 虚函数表（vtable）机制

// 虚函数表工作原理示意 class Base { public: virtual void func1() { cout << "Base::func1" << endl; } virtual void func2() { cout << "Base::func2" << endl; } virtual ~Base() {} }; class Derived : public Base { public: void func1() override { cout << "Derived::func1" << endl; } void func2() override { cout << "Derived::func2" << endl; } virtual void func3() { cout << "Derived::func3" << endl; } }; // 内存布局示意： // Base对象: [vptr] -> Base vtable [&Base::func1, &Base::func2, &Base::~Base] // Derived对象: [vptr] -> Derived vtable [&Derived::func1, &Derived::func2, &Base::~Base, &Derived::func3]

3.4 多态的高级应用

// 1. 类型安全的向下转型 class Animal { public: enum class Type { DOG, CAT, BIRD }; virtual Type getType() const = 0; virtual ~Animal() = default; }; class Dog : public Animal { public: Type getType() const override { return Type::DOG; } void bark() { cout << "Woof!" << endl; } }; void processAnimal(Animal* animal) { // 使用dynamic_cast进行安全的向下转型 if (animal->getType() == Animal::Type::DOG) { Dog* dog = dynamic_cast<Dog*>(animal); if (dog) { dog->bark(); } } } // 2. 协变返回类型 class Base { public: virtual Base* clone() const = 0; }; class Derived : public Base { public: // 协变返回类型：返回派生类指针 Derived* clone() const override { return new Derived(*this); } }; // 3. 使用final禁止重写 class BaseClass final { // 类不能被继承 // ... }; class Base { public: virtual void cannotOverride() final { // 方法不能被重写 // 实现 } };

四、三大特性的综合应用

4.1 设计模式示例：策略模式

// 封装支付策略接口 class PaymentStrategy { public: virtual void pay(double amount) = 0; virtual ~PaymentStrategy() = default; }; // 具体策略实现 class CreditCardPayment : public PaymentStrategy { private: string cardNumber; string cvv; public: CreditCardPayment(const string& num, const string& c) : cardNumber(num), cvv(c) {} void pay(double amount) override { cout << "Paying $" << amount << " with credit card " << cardNumber.substr(cardNumber.length()-4) << endl; } }; class PayPalPayment : public PaymentStrategy { private: string email; public: PayPalPayment(const string& e) : email(e) {} void pay(double amount) override { cout << "Paying $" << amount << " via PayPal account " << email << endl; } }; // 使用策略的上下文 class ShoppingCart { private: vector<double> items; unique_ptr<PaymentStrategy> paymentStrategy; public: void addItem(double price) { items.push_back(price); } void setPaymentStrategy(unique_ptr<PaymentStrategy> strategy) { paymentStrategy = move(strategy); } void checkout() { double total = 0; for (double price : items) { total += price; } if (paymentStrategy) { paymentStrategy->pay(total); } else { throw runtime_error("Payment strategy not set"); } } };

4.2 现代化C++特性结合

// 使用智能指针、移动语义等现代C++特性 class ResourceManager { private: // 封装资源所有权 unique_ptr<Resource> resource; protected: // 受保护的接口供派生类使用 virtual void initializeResource() = 0; public: virtual ~ResourceManager() = default; // 使用移动语义 ResourceManager(unique_ptr<Resource> res) : resource(move(res)) {} // 禁用拷贝，允许移动 ResourceManager(const ResourceManager&) = delete; ResourceManager& operator=(const ResourceManager&) = delete; ResourceManager(ResourceManager&&) = default; ResourceManager& operator=(ResourceManager&&) = default; // 多态接口 virtual void process() = 0; }; // 具体实现 class AdvancedResourceManager : public ResourceManager { public: using ResourceManager::ResourceManager; void initializeResource() override { // 具体初始化逻辑 } void process() override { // 具体处理逻辑 } };