编程思想大观：从面向对象到函数式的思维跃迁

一、编程思想是什么？为什么要了解？

编程思想（Programming Paradigm）不是具体的框架或语言，而是看待问题和组织代码的"世界观"。就像建筑师设计房屋时可以选择"现代风格"、"古典风格"、"中式风格"——风格本身没有好坏，但不同风格适合不同场景。

二、面向对象编程（OOP）：万物皆对象

2.1 C++ 实现示例：一个简单的图形系统

#include <iostream>
#include <memory>
#include <vector>

// ① 封装：基类 Shape 封装公共属性 area()
class Shape {
public:
    virtual ~Shape() = default;
    virtual double area() const = 0;  // 纯虚函数
};

// ② 继承：Circle 继承 Shape
class Circle : public Shape {
    double radius;
public:
    explicit Circle(double r) : radius(r) {}
    double area() const override {
        return 3.14159 * radius * radius;
    }
};

// ② 继承：Rectangle 继承 Shape
class Rectangle : public Shape {
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double area() const override {
        return width * height;
    }
};

// ③ 多态：统一调用 area()，自动分发到具体子类
int main() {
    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(std::make_unique<Circle>>(5.0));
    shapes.push_back(std::make_unique<Rectangle>>(3.0, 4.0));

    for (auto& s : shapes) {
        std::cout << "面积: " << s->area() << std::endl;
        // Circle::area() 或 Rectangle::area() 自动被调用
    }
    return 0;
}

三、面向过程编程：按步骤来

3.1 C++ 实现示例：计算学生成绩（过程式 vs 对象式对比）

// ❌ 过程式写法：数据和函数分离
struct Student {
    char name[32];
    double scores[5];
    int count;
};

double calcAverage(const Student& s) {
    double sum = 0;
    for (int i = 0; i < s.count; ++i) sum += s.scores[i];
    return sum / s.count;
}

void printStudent(const Student& s) {
    std::cout << s.name << " 平均分: " << calcAverage(s);
}

// ✅ 对象式写法：数据和行为绑定
class StudentObj {
    std::string name;
    std::vector<double> scores;
public:
    StudentObj(const std::string& n) : name(n) {}
    void addScore(double s) { scores.push_back(s); }
    double average() const {
        if (scores.empty()) return 0;
        double sum = 0;
        for (auto s : scores) sum += s;
        return sum / scores.size();
    }
};

四、函数式编程（FP）：把函数当公民

4.1 核心概念

• 不可变性（Immutability）：数据一旦创建就不能修改，而是创建新数据
• 纯函数（Pure Function）：相同输入总是相同输出，无副作用
• 高阶函数（HOF）：接受函数作为参数或返回函数的函数
• 闭包（Closure）：函数能"记住"并访问其词法作用域
• 递归：用递归替代循环，优雅地处理层级结构

4.2 C++ 实现示例：用函数式思想处理数据

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <functional>

using namespace std;

int main() {
    vector<int> nums = {1, 2, 3, 4, 5, 6};

    // ① 高阶函数：map（转换每个元素）
    auto doubled = vector<int>();
    transform(nums.begin(), nums.end(), back_inserter(doubled),
        [](int x) { return x * 2; });
    // nums 不变！doubled = {2,4,6,8,10,12}

    // ② 过滤：filter（筛选符合条件的元素）
    auto evens = vector<int>();
    copy_if(nums.begin(), nums.end(), back_inserter(evens),
        [](int x) { return x % 2 == 0; });
    // evens = {2,4,6}

    // ③ 归约：reduce（聚合为单个值）
    int sum = accumulate(nums.begin(), nums.end(), 0,
        [](int a, int b) { return a + b; });
    // sum = 21

    // ④ 函数组合：创建新函数 = 双增 + 过滤 + 求和
    auto doubleSum = [](const vector<int>& v) {
        auto d = vector<int>();
        transform(v.begin(), v.end(), back_inserter(d),
            [](int x) { return x * 2; });
        return accumulate(d.begin(), d.end(), 0);
    };
    cout << doubleSum(nums) << endl;  // 42
}

五、事件驱动编程：发布-订阅的艺术

5.1 C++ 实现示例：简易事件总线

#include <iostream>
#include <functional>
#include <unordered_map>
#include <vector>
#include <string>

class EventBus {
    using Handler = std::function<void(const std::string&)>;
    std::unordered_map<std::string, std::vector<Handler>> subscribers;
public:
    // 订阅事件
    void subscribe(const std::string& event, Handler handler) {
        subscribers[event].push_back(std::move(handler));
    }
    // 发布事件
    void publish(const std::string& event, const std::string& data) {
        auto it = subscribers.find(event);
        if (it != subscribers.end) {
            for (auto& handler : it->second) {
                handler(data);
            }
        }
    }
};

int main() {
    EventBus bus;

    // 订阅日志事件
    bus.subscribe("log", [](const std::string& msg) {
        std::cout << [LOG] " << msg << std::endl;
    });

    // 订阅告警事件
    bus.subscribe("alert", [](const std::string& msg) {
        std::cout << [ALERT] 🚨 " << msg << std::endl;
    });

    // 多个订阅者可以监听同一个事件
    bus.subscribe("log", [](const std::string& msg) {
        // 发送邮件通知...
        std::cout << [EMAIL] 记录已归档: " << msg << std::endl;
    });

    // 发布者不知道谁在监听
    bus.publish("log", "用户登录成功");
    bus.publish("alert", "磁盘空间不足");
}

六、面向切面编程（AOP）：横切关注点

6.1 C++ 实现示例：用装饰器/模板方法模拟 AOP

// 传统做法：在每个业务方法里手动加日志（代码污染）
void UserService::createUser() {
    qDebug() << "[LOG] createUser 开始";  // 日志代码
    if (!checkPermission("admin")) { // 权限代码
        qDebug() << "[LOG] 权限不足";
        return;
    }
    // === 真正的业务逻辑 ===
    userRepo->save(user);
    // === 业务逻辑结束 ===
    qDebug() << "[LOG] createUser 结束";  // 日志代码
}

// ✅ AOP 思想：用模板方法分离关注点
template<typename Func>
void withLogging(const std::string& name, Func&& func) {
    qDebug() << "[LOG] " << name << " 开始";
    try {
        func();  // 执行真正的业务逻辑
        qDebug() << "[LOG] " << name << " 结束 ✅";
    } catch (const std::exception& e) {
        qDebug() << "[LOG] " << name << " 失败 ❌: " << e.what();
        throw;
    }
}

// 使用：业务代码干净，日志自动织入
withLogging("createUser", []() {
    // 只有真正的业务逻辑，没有日志、权限等横切代码
    userRepo->save(user);
    sendWelcomeEmail(user);
});

七、响应式编程：数据流的交响

7.1 核心概念

• Observable：数据源，可以是事件、定时器、HTTP 请求、集合等
• Operator：对数据流的操作——map、filter、merge、debounce 等
• Subscriber：订阅者，定义数据到达时的行为
• Scheduler：控制线程，支持异步和并发

7.2 C++ 实现示例：用 range-v3 模拟响应式操作

#include <iostream>
#include <vector>
#include <chrono>
#include <thread>

template<typename Func>
class SimpleObservable {
    std::vector<Func> subscribers;
public:
    void subscribe(Func f) { subscribers.push_back(std::move(f)); }
    void emit(int value) {
        for (auto& s : subscribers) s(value);
    }
};

int main() {
    SimpleObservable<std::function<void(int)>> sensor;

    // 管道：filter(>50) → map(×2) → 输出
    sensor.subscribe([](int v) {
        if (v > 50) {         // filter
            int doubled = v * 2;  // map
            std::cout << [REACTIVE] 传感器值: << doubled << std::endl;
        }
    });

    // 模拟传感器每 100ms 产生一个读数
    for (int i = 0; i < 20; ++i) {
        int reading = 30 + i * 5;  // 30, 35, 40, ...
        sensor.emit(reading);
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

八、声明式编程：描述"做什么"而非"怎么做"

8.1 对比：命令式 SQL vs 声明式 SQL

// ❌ 命令式：用 C++ 写查询逻辑
vector<Employee> result;
for (auto& emp : allEmployees) {
    if (emp.department == "IT" && emp.salary > 10000) {
        bool found = false;
        for (auto& proj : emp.projects) {
            if (proj.status == "active") { found = true; break; }
        }
        if (found) result.push_back(emp);
    }
}

// ✅ 声明式：SQL 只描述"要什么"，不写"怎么找"
// SELECT * FROM employees
// WHERE department = 'IT'
//   AND salary > 10000
//   AND EXISTS (SELECT 1 FROM projects
//              WHERE projects.emp_id = employees.id
//              AND status = 'active');

8.2 C++ 中的声明式思想：Range-based for & STL 算法

// 声明式思想在 C++ 的体现：用 STL 算法描述意图
vector<int> nums = {3, 1, 4, 1, 5, 9, 2, 6};

// "找出所有偶数并排序"——用 STL 算法描述意图
vector<int> evens;
copy_if(nums.begin(), nums.end(), back_inserter(evens),
    [](int x) { return x % 2 == 0; });
sort(evens.begin(), evens.end);
// 不需要写循环，不需要写排序算法
// 只声明"我要偶数" + "我要排序"

九、领域驱动设计（DDD）：业务即代码

9.1 DDD 的核心概念

• 实体（Entity）：有唯一 ID 的业务对象，如 Order、Customer
• 值对象（Value Object）：无 ID，只关心值，如 Money、Address、DateRange
• 聚合根（Aggregate Root）：实体的容器，保证内部一致性，如 Order（包含 OrderItem）
• 领域服务（Domain Service）：跨聚合的业务逻辑，如 TransferService
• 领域事件（Domain Event）：业务中发生的重要事情，如 OrderPlaced、PaymentReceived
• 仓储（Repository）：数据持久化的抽象，如 IOrderRepository

9.2 C++ 实现示例：订单聚合根

// 值对象：Money 不可变，自带校验
class Money {
    double amount;
    std::string currency;
public:
    Money(double amt, const std::string& cur)
        : amount(amt), currency(cur) {
        if (amt < 0) throw std::invalid_argument("金额不能为负");
    }
    bool operator==(const Money& o) const {
        return amount == o.amount && currency == o.currency;
    }
};

// 实体：订单明细
class OrderItem {
    int productId;
    int quantity;
    Money unitPrice;
public:
    Money subtotal() const {
        return Money(quantity * unitPriceamount(), unitPricecurrency());
    }
};

// 聚合根：Order 保证内部一致性
class Order {
    int orderId;
    std::vector<OrderItem> items;
    enum class Status { Pending, Paid, Shipped, Cancelled };
    Status status;
public:
    void pay() {
        if (status != Status::Pending)
            throw std::runtime_error("订单只能在待支付状态下支付");
        status = Status::Paid;
        // 发布领域事件
        DomainEvents::publish(OrderPaid{orderId});
    }
    Money totalAmount() const {
        double total = 0;
        for (auto& item : items)
            total += item.subtotal()amount();
        return Money(total, "CNY");
    }
};

十、面向接口编程：抽象即稳定

10.1 核心原则

• 先有接口，再有实现：设计时先定义抽象契约，后续再填充实现
• 依赖倒置：高层模块依赖接口，不依赖具体实现
• 里氏替换：任何实现类都可以替换接口使用而不破坏系统
• 最小接口：接口应该尽可能小，只暴露必要的方法

10.2 C++ 实现示例：日志系统

// ① 先定义接口（抽象契约）
class ILogger {
public:
    virtual ~ILogger() = default;
    virtual void log(const std::string& msg) = 0;
    virtual void error(const std::string& msg) = 0;
};

// ② 不同实现：控制台、文件、远程
class ConsoleLogger : public ILogger {
    void log(const std::string& msg) override {
        std::cout << [LOG] " << msg << std::endl;
    }
    void error(const std::string& msg) override {
        std::cerr << [ERROR] " << msg << std::endl;
    }
};

class FileLogger : public ILogger {
    std::ofstream file;
public:
    explicit FileLogger(const std::string&&path) : file(path, std::ios::app) {}
    void log(const std::string& msg) override {
        file << [LOG] " << msg << std::endl;
    }
    void error(const std::string& msg) override {
        file << [ERROR] " << msg << std::endl;
    }
};

// ③ 使用者依赖接口，不依赖实现
class OrderService {
    std::shared_ptr<ILogger> logger;  // 依赖接口
public:
    explicit OrderService(std::shared_ptr<ILogger> l)
        : logger(std::move(l)) {}
    void createOrder() {
        logger->log("Creating order...");
        // 业务逻辑...
        logger->log("Order created");
    }
};

十一、面向数据编程：数据驱动逻辑

11.1 C++ 实现示例：基于数据的规则引擎

#include <iostream>
#include <vector>
#include <functional>
#include <string>

// 数据结构：规则 = 条件 + 动作
struct Rule {
    std::string name;
    std::function<bool(int)> condition;  // 条件
    std::function<void(int)> action;      // 动作
};

class RuleEngine {
    std::vector<Rule> rules;
public:
    void addRule(Rule r) { rules.push_back(std::move(r)); }

    void execute(int value) {
        for (auto& rule : rules) {
            if (rule.condition(value)) {
                rule.action(value);
            }
        }
    }
};

int main() {
    RuleEngine engine;

    // 规则是数据，不是硬编码的 if-else
    engine.addRule({"负数检测",
        [](int v) { return v < 0; },
        [](int v) { std::cout << "❌ 负数: " << v << std::endl; }
    });

    engine.addRule({"偶数检测",
        [](int v) { return v % 2 == 0; },
        [](int v) { std::cout << "✨ 偶数: " << v << std::endl; }
    });

    engine.addRule({"大数检测",
        [](int v) { return v > 100; },
        [](int v) { std::cout << "⚠️ 大数值: " << v << std::endl; }
    });

    // 执行时按数据驱动
    engine.execute(-5);    // 触发: 负数
    engine.execute(42);     // 触发: 偶数
    engine.execute(150);   // 触发: 偶数 + 大数
}

十二、元编程：代码即数据

12.1 C++ 中的元编程：模板元编程（TMP）

// 编译期计算阶乘——经典模板元编程
template<int N>
struct Factorial {
    static constexpr int value = N * Factorial<N - 1>::value;
};

template<>
struct Factorial<0> {
    static constexpr int value = 1;
};

// 编译期就确定了结果
constexpr int result = Factorial<5>::value;  // 120，编译器就算出了

// type_traits：编译期类型检查
#include <type_traits>

template<typename T>
auto process(T value) -> std::enable_if_t<std::is_arithmetic_v<T>> {
    return value * 2;  // 只有算术类型才能调用
}

// 反射元编程：C++17 的 std::variant + 访问器
#include <variant>
using Value = std::variant<int, double, std::string>;

struct Printer {
    void operator()(int v) { std::cout << "int: " << v; }
    void operator()(double v) { std::cout << "double: " << v; }
    void operator()(const std::string& v) { std::cout << "string: " << v; }
};

Value v = "hello";
std::visit(Printer{}, v);  // 运行期自动分派

十三、防御式编程：假设最坏，准备最好

13.1 C++ 实现示例：防御式编程检查清单

#include <iostream>
#include <stdexcept>
#include <cassert>

class SafeArray {
    std::vector<int> data;
public:
    // ① 防御 1：参数校验（前置条件）
    void setAt(int index, int value) {
        if (index < 0 || index >= static_cast<int>(data.size())) {
            throw std::out_of_range("Index out of bounds");
        }
        data[index] = value;
    }

    // ② 防御 2：返回值检查
    int getAt(int index) const {
        if (index < 0 || index >= static_cast<int>(data.size())) {
            return -1;  // 优雅降级
        }
        return data[index];
    }

    // ③ 防御 3：断言（开发期检查）
    void invariantCheck() const {
        assert(data.size() >= 0);  // 永远成立的不变量
    }
};

// ④ 防御 4：异常安全保证
template<typename Func>
void safeExecute(Func&& func) {
    try {
        func();
    } catch (const std::exception& e) {
        std::cerr << "Error caught: " << e.what() << std::endl;
        // 记录日志，通知监控系统，不崩溃
    } catch (...) {
        std::cerr << "Unknown error" << std::endl;
    }
}

十四、契约式编程：契约即保障

14.1 C++ 实现示例：显式契约

#include <iostream>
#include <cassert>
#include <stdexcept>

// 用宏模拟 Eiffel 语言的契约机制
#define REQUIRE(cond) \
    if (!(cond)) throw std::invalid_argument("Precondition failed: " #cond)
#define ENSURE(cond) \
    if (!(cond)) throw std::logic_error("Postcondition failed: " #cond)
#define INVARIANT(cond) assert(cond)

class BankAccount {
    double balance;
    bool frozen;
public:
    BankAccount() : balance(0), frozen(false) {
        INVARIANT(balance >= 0);  // 不变量：余额永不为负
    }

    // 前置：金额为正且账户未冻结
    void deposit(double amount) {
        REQUIRE(amount > 0);          // 前置条件
        REQUIRE(!frozen);                     // 前置条件

        double oldBalance = balance;
        balance += amount;

        ENSURE(balance == oldBalance + amount);  // 后置条件
        ENSURE(balance > oldBalance);        // 后置条件
        INVARIANT(balance >= 0);  // 不变量保持
    }

    // 前置：金额为正、余额充足、账户未冻结
    bool withdraw(double amount) {
        REQUIRE(amount > 0);
        REQUIRE(balance >= amount);
        REQUIRE(!frozen);

        double oldBalance = balance;
        balance -= amount;

        ENSURE(balance == oldBalance - amount);
        ENSURE(balance < oldBalance);
        INVARIANT(balance >= 0);

        return true;
    }
};

十五、各范式对比与选型指南

15.1 全景对比表

15.2 选型决策流程图

15.3 实战建议：混合使用多种范式

十六、总结：没有银弹，只有合适的选择

核心心法

1. 了解但不迷信：知道每种范式的优劣，不要只信自己熟悉的那一个
2. 场景驱动：根据问题选工具，而不是反过来
3. 混合使用：现代语言支持多范式，大胆组合
4. 渐进引入：在新项目或新模块中尝试新范式，不要大爆炸式重构
5. 团队共识：团队成员的熟悉程度决定了范式的实际效果