C++类双构造函数绑定不同对象的实现方案咨询

我明白你的痛点了——同一个类要根据构造方式切换不同的工作对象，而且这俩对象还没法用继承统一接口，确实头疼。给你几个实用的方案，你可以根据自己的C++版本和需求选：

方案1：用std::variant存储不同对象（C++17及以上推荐） #

C++17引入的std::variant天生就是用来处理这种"二选一"的类型存储场景，类型安全还能在编译期做分支判断，完全不用担心运行时的额外开销。

先定义你的Bar和Baz类（假设它们的结构是这样）：

#include <iostream>
#include <string>
#include <variant>
#include <type_traits>

class Bar {
public:
    void doBarThing() {
        std::cout << "执行Bar专属操作\n";
    }
    int barOnlyVar = 42;
};

class Baz {
public:
    void doBazThing() {
        std::cout << "执行Baz专属操作\n";
    }
    std::string bazOnlyStr = "默认文本";
};

然后实现你的Foo类：

class Foo {
private:
    // 用variant存储Bar或Baz对象
    std::variant<Bar, Baz> worker;

public:
    // 无参构造：初始化Bar对象
    Foo() : worker(Bar{}) {}

    // 带参构造：初始化Baz对象，还能用传入的val做定制化
    Foo(int val) : worker(Baz{}) {
        std::get<Baz>(worker).bazOnlyStr = std::to_string(val);
    }

    // 你的printWrapper函数，用std::visit处理不同类型
    void printWrapper() {
        std::visit([](auto& obj) {
            // 用constexpr if在编译期判断当前对象类型
            using ObjType = std::decay_t<decltype(obj)>;
            if constexpr (std::is_same_v<ObjType, Bar>) {
                obj.doBarThing();
                std::cout << "Bar专属变量值：" << obj.barOnlyVar << "\n";
            } else if constexpr (std::is_same_v<ObjType, Baz>) {
                obj.doBazThing();
                std::cout << "Baz专属字符串：" << obj.bazOnlyStr << "\n";
            }
        }, worker);
    }
};

测试一下：

int main() {
    Foo foo1;          // 无参构造，用Bar
    foo1.printWrapper();

    Foo foo2(123);     // 带参构造，用Baz
    foo2.printWrapper();

    return 0;
}

方案2：用std::any+std::function封装行为（C++11/14可用） #

如果你的项目还在用C++17之前的版本，可以用std::any存储对象，配合std::function把不同的行为封装成回调，构造时直接绑定好逻辑。

#include <iostream>
#include <string>
#include <any>
#include <functional>

// 先定义Bar和Baz，同方案1

class Foo {
private:
    std::any worker;
    std::function<void()> printLogic;

public:
    Foo() : worker(Bar{}) {
        // 绑定Bar对应的打印逻辑
        printLogic = [this]() {
            Bar& bar = std::any_cast<Bar&>(worker);
            bar.doBarThing();
            std::cout << "Bar专属变量值：" << bar.barOnlyVar << "\n";
        };
    }

    Foo(int val) : worker(Baz{}) {
        // 先初始化Baz的专属变量
        Baz& baz = std::any_cast<Baz&>(worker);
        baz.bazOnlyStr = std::to_string(val);
        // 绑定Baz对应的打印逻辑
        printLogic = [this]() {
            Baz& baz = std::any_cast<Baz&>(worker);
            baz.doBazThing();
            std::cout << "Baz专属字符串：" << baz.bazOnlyStr << "\n";
        };
    }

    void printWrapper() {
        // 直接执行预先绑定好的逻辑就行
        printLogic();
    }
};

这个方案的好处是逻辑更集中，printWrapper不用管具体类型，但要注意std::any_cast如果类型不匹配会抛异常，你也可以用指针版本（std::any_cast<Bar*>(&worker)）来做安全判断。

方案3：适配器类+多态（面向对象风格） #

虽然你说继承方案不合理，但如果Bar和Baz本身不能修改，我们可以给它们套一层适配器，统一到同一个基类下，用多态来处理：

#include <iostream>
#include <string>
#include <memory>

// 先定义Bar和Baz，同方案1

// 定义统一的工作基类
class WorkerBase {
public:
    virtual ~WorkerBase() = default;
    virtual void print() = 0;
};

// Bar的适配器，封装Bar的逻辑
class BarAdapter : public WorkerBase {
private:
    Bar bar;
public:
    void print() override {
        bar.doBarThing();
        std::cout << "Bar专属变量值：" << bar.barOnlyVar << "\n";
    }
};

// Baz的适配器，封装Baz的逻辑
class BazAdapter : public WorkerBase {
private:
    Baz baz;
public:
    explicit BazAdapter(int val) {
        baz.bazOnlyStr = std::to_string(val);
    }
    void print() override {
        baz.doBazThing();
        std::cout << "Baz专属字符串：" << baz.bazOnlyStr << "\n";
    }
};

class Foo {
private:
    std::unique_ptr<WorkerBase> worker;

public:
    Foo() : worker(std::make_unique<BarAdapter>()) {}
    Foo(int val) : worker(std::make_unique<BazAdapter>(val)) {}

    void printWrapper() {
        worker->print();
    }
};

这个方案代码结构更清晰，符合经典的策略模式，但需要额外写适配器类，如果Bar和Baz的接口有变动，适配器也要跟着调整。

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