如何实现CoroutineManager::Routine()调用Operator::Worker()？

1. 依赖注入（直接传递对象引用/指针） #

这是最直观的实现方式，让CoroutineManager持有Operator实例的引用或指针，在Routine()方法里直接调用Worker()。

#include <iostream>

class Operator {
public:
    void Worker() {
        std::cout << "Operator::Worker() called\n";
    }
};

class CoroutineManager {
private:
    Operator& op;
public:
    // 构造时注入Operator实例
    CoroutineManager(Operator& operator_inst) : op(operator_inst) {}

    void Routine() {
        op.Worker();
    }
};

// 测试代码
int main() {
    Operator op;
    CoroutineManager cm(op);
    cm.Routine();
    return 0;
}

这种方式简单直接，测试场景下快速就能搭起来，只要保证Operator实例的生命周期比CoroutineManager长就行。

2. 使用回调（std::function） #

如果不想让CoroutineManager直接依赖Operator类，可以用std::function作为回调，把Worker()绑定后传给CoroutineManager。

#include <iostream>
#include <functional>

class Operator {
public:
    void Worker() {
        std::cout << "Operator::Worker() called\n";
    }
};

class CoroutineManager {
private:
    std::function<void()> callback;
public:
    void SetCallback(std::function<void()> cb) {
        callback = std::move(cb);
    }

    void Routine() {
        if (callback) {
            callback();
        }
    }
};

// 测试代码
int main() {
    Operator op;
    CoroutineManager cm;
    // 绑定Operator的Worker()到回调
    cm.SetCallback(std::bind(&Operator::Worker, &op));
    cm.Routine();
    return 0;
}

这种方式解耦度更高，CoroutineManager完全不需要知道Operator的存在，只要匹配回调签名就行，适合需要灵活替换调用目标的场景。

3. 抽象接口（纯虚基类） #

定义一个抽象接口，让Operator实现该接口，CoroutineManager只依赖接口而非具体类，符合依赖倒置原则。

#include <iostream>

// 抽象接口
class IWorker {
public:
    virtual void DoWork() = 0;
    virtual ~IWorker() = default;
};

class Operator : public IWorker {
public:
    void DoWork() override {
        std::cout << "Operator::Worker() (via IWorker::DoWork) called\n";
    }

    // 保留原Worker()方法，不修改原有逻辑
    void Worker() {
        DoWork();
    }
};

class CoroutineManager {
private:
    IWorker& worker;
public:
    CoroutineManager(IWorker& w) : worker(w) {}

    void Routine() {
        worker.DoWork();
    }
};

// 测试代码
int main() {
    Operator op;
    CoroutineManager cm(op);
    cm.Routine();
    return 0;
}

这种方式适合长期维护的代码，通过接口隔离具体实现，测试时还能轻松替换成Mock类。

内容的提问来源于stack exchange，提问作者frameworker