C++类型擦除包装器：转换与跨包装器使用难题

问题1：Encodable与Printable的便捷转换 #

要避免拆包后重新包装的冗余代码，核心是让类型擦除包装器内部保留足够的类型信息与转换能力，而非依赖外部get()拆包。

实现思路：

• 在Encodable和Printable的底层多态基类中，添加转换接口（如to_printable()、to_encodable()），通过vtable动态分发到具体类型的转换逻辑。
• 构造包装器时，同时保存目标类型的构造能力，比如利用模板特性在编译期绑定转换逻辑。

示例代码：

// Printable基础接口
class Printable {
public:
    virtual ~Printable() = default;
    virtual void print() const = 0;
    virtual std::unique_ptr<Encodable> to_encodable() const = 0;
};

// Encodable基础接口
class Encodable {
public:
    virtual ~Encodable() = default;
    virtual std::string encode() const = 0;
    virtual void decode(const std::string& data) = 0;
    virtual std::unique_ptr<Printable> to_printable() const = 0;
};

// Encodable模板实现类，内置转换逻辑
template<typename T>
class EncodableImpl : public Encodable {
private:
    T obj;
public:
    EncodableImpl(T&& o) : obj(std::move(o)) {}
    
    std::string encode() const override { return encode_impl(obj); }
    void decode(const std::string& data) override { decode_impl(obj, data); }
    
    std::unique_ptr<Printable> to_printable() const override {
        // 编译期检查T是否支持print()，不支持则抛出异常
        if constexpr (requires(const T& t) { t.print(); }) {
            return std::make_unique<PrintableImpl<T>>(obj);
        } else {
            throw std::runtime_error("Type does not support print()");
        }
    }
};

// Printable模板实现类
template<typename T>
class PrintableImpl : public Printable {
private:
    T obj;
public:
    PrintableImpl(const T& o) : obj(o) {}
    
    void print() const override { obj.print(); }
    
    std::unique_ptr<Encodable> to_encodable() const override {
        if constexpr (requires(T& t) { encode_impl(t); decode_impl(t, std::string{}); }) {
            return std::make_unique<EncodableImpl<T>>(obj);
        } else {
            throw std::runtime_error("Type does not support encode/decode");
        }
    }
};

调用时直接通过包装器的转换方法完成操作，无需外部拆包：

std::vector<std::unique_ptr<Encodable>> encodables;
encodables.emplace_back(std::make_unique<EncodableImpl<MyStruct1>>(MyStruct1{}));

// 直接转换为Printable并调用print
auto printable = encodables[0]->to_printable();
printable->print();

问题2：将Encodable直接当作Printable使用 #

如果底层类型已支持print()，可以让Encodable直接实现Printable接口，或者在Encodable中内置print()方法，通过编译期检查决定是否启用。

实现思路：

1. 让Encodable继承Printable接口，在模板实现类中根据T是否支持print()来实现print()方法；
2. 若T不支持print()，可以抛出异常、输出默认提示，或者提供可选调用的接口。

示例代码（基于上述基础修改）：

// 修改Encodable接口，继承Printable
class Encodable : public Printable {
public:
    virtual ~Encodable() = default;
    virtual std::string encode() const = 0;
    virtual void decode(const std::string& data) = 0;
    // 继承Printable的print()接口
};

template<typename T>
class EncodableImpl : public Encodable {
private:
    T obj;
public:
    EncodableImpl(T&& o) : obj(std::move(o)) {}
    
    std::string encode() const override { return encode_impl(obj); }
    void decode(const std::string& data) override { decode_impl(obj, data); }
    
    // 编译期检查T是否有print()，有则实现，否则抛出异常
    void print() const override {
        if constexpr (requires(const T& t) { t.print(); }) {
            obj.print();
        } else {
            throw std::runtime_error("Underlying type does not support print()");
        }
    }
};

这样就可以直接把Encodable当作Printable使用：

std::vector<std::unique_ptr<Encodable>> encodables;
encodables.emplace_back(std::make_unique<EncodableImpl<MyStruct1>>(MyStruct1{}));

// 直接调用print()，无需转换
encodables[0]->print();

补充优化：非侵入式可选调用 #

如果不想让Encodable强制继承Printable，可以用try_print()的方式实现非侵入式调用：

class Encodable {
public:
    virtual ~Encodable() = default;
    virtual std::string encode() const = 0;
    virtual void decode(const std::string& data) = 0;
    virtual bool try_print() const = 0;
};

template<typename T>
class EncodableImpl : public Encodable {
private:
    T obj;
    std::function<void()> print_func;
public:
    EncodableImpl(T&& o) : obj(std::move(o)) {
        if constexpr (requires(const T& t) { t.print(); }) {
            print_func = [this]() { obj.print(); };
        }
    }
    
    std::string encode() const override { return encode_impl(obj); }
    void decode(const std::string& data) override { decode_impl(obj, data); }
    
    bool try_print() const override {
        if (print_func) {
            print_func();
            return true;
        }
        return false;
    }
};

调用时：

if (encodables[0]->try_print()) {
    // print调用成功
} else {
    // 类型不支持print()
}

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