C++面向对象设计原则与实践一、引言面向对象编程（OOP）是C++的核心编程范式，利用类和对象封装数据和行为，提升程序

一、引言

面向对象编程（OOP）是C++的核心编程范式，利用类和对象封装数据和行为，提升程序的模块化和可维护性。良好的设计原则帮助开发者写出灵活、可扩展且易于维护的代码。

本文重点讲解C++面向对象设计的基本原则，如封装、继承、多态，以及经典设计原则（SOLID），并结合实战案例说明如何应用它们。

二、面向对象基础

1. 封装

通过类隐藏实现细节，暴露接口：

cpp复制编辑class Account {
private:
    double balance;
public:
    Account(double b) : balance(b) {}
    void deposit(double amount) { balance += amount; }
    double getBalance() const { return balance; }
};

封装保证内部状态安全，防止外部直接访问导致不一致。

2. 继承

子类继承父类的属性和行为，实现代码复用：

cpp复制编辑class SavingsAccount : public Account {
private:
    double interestRate;
public:
    SavingsAccount(double b, double rate) : Account(b), interestRate(rate) {}
    void applyInterest() { deposit(getBalance() * interestRate); }
};

3. 多态

基类指针或引用调用派生类重写的方法，实现行为动态绑定：

cpp复制编辑class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数
    virtual ~Shape() = default;
};

class Circle : public Shape {
public:
    void draw() override { std::cout << "画圆\n"; }
};

void render(Shape& s) {
    s.draw();
}

三、SOLID设计原则

1. 单一职责原则（SRP）

一个类只负责一个职责，避免职责混乱。

2. 开闭原则（OCP）

对扩展开放，对修改关闭。通过继承和多态实现扩展，不改动已有代码。

3. 里氏替换原则（LSP）

子类必须能够替换父类而不影响程序正确性。

4. 接口隔离原则（ISP）

接口应精简，不应强迫客户端依赖不需要的方法。

5. 依赖倒置原则（DIP）

高层模块不应依赖低层模块，二者都依赖抽象；抽象不依赖细节，细节依赖抽象。

四、设计模式简介

设计模式是解决常见设计问题的模板。

1. 工厂模式

封装对象创建过程：

cpp复制编辑class Product { public: virtual void use() = 0; };
class ConcreteProduct : public Product {
public:
    void use() override { std::cout << "使用产品\n"; }
};

class Factory {
public:
    virtual Product* create() = 0;
};

class ConcreteFactory : public Factory {
public:
    Product* create() override { return new ConcreteProduct(); }
};

2. 观察者模式

对象间一对多依赖，状态变化通知所有观察者。

五、实战示例：基于接口的动物行为设计

cpp复制编辑#include <iostream>
#include <vector>
#include <memory>

class Animal {
public:
    virtual void speak() = 0;
    virtual ~Animal() = default;
};

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

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

void letAnimalsSpeak(const std::vector<std::shared_ptr<Animal>>& animals) {
    for (auto& a : animals) {
        a->speak();
    }
}

int main() {
    std::vector<std::shared_ptr<Animal>> zoo;
    zoo.push_back(std::make_shared<Dog>());
    zoo.push_back(std::make_shared<Cat>());

    letAnimalsSpeak(zoo);
    return 0;
}