如何在C++中返回两种可能的模板对象类型之一？

你的get_data()函数编译错误的核心原因是：C++的auto返回类型要求所有代码分支返回完全相同的类型，但你一个分支返回Data<float>，另一个返回Data<int>，类型不匹配导致推导失败。

因为无法修改Boost提供的Data模板，以下是几种现代C++实现方案：

方案1：用std::variant替代std::any（推荐） #

std::variant是C++17引入的类型安全联合类型，专门适配已知有限类型集合的场景，比std::any更适合你的需求：

#include <variant>
#include <memory>
#include <iostream>

template<typename T>
struct Data {
    T attribute;
    void print() { std::cout << "Printing " << attribute << "\n"; }
};

using IntDataType = Data<int>;
using FloatDataType = Data<float>;

std::shared_ptr<IntDataType> make_int_data() {
    auto ptr = std::make_shared<IntDataType>();
    ptr->attribute = 42;
    return ptr;
}

std::shared_ptr<FloatDataType> make_float_data() {
    auto ptr = std::make_shared<FloatDataType>();
    ptr->attribute = 3.14f;
    return ptr;
}

// 用variant存储已知的两种类型指针
std::variant<std::shared_ptr<IntDataType>, std::shared_ptr<FloatDataType>> data;

void create_data(bool useFloat) {
    if (useFloat)
        data = make_float_data();
    else
        data = make_int_data();
}

// 通用访问函数，传入要执行的操作
void visit_data(auto&& op) {
    std::visit(op, data);
}

int main() {
    create_data(true);
    // 直接调用print方法，无需关心具体类型
    visit_data([](auto&& ptr) { ptr->print(); });
    
    create_data(false);
    visit_data([](auto&& ptr) { ptr->print(); });
    return 0;
}

优势： #

• 类型安全，编译期即可检查类型合法性
• 无需处理std::bad_any_cast异常
• 代码简洁，通过std::visit统一处理所有可能的类型

方案2：基于std::any的通用操作函数 #

如果必须保留std::any，可以把要执行的操作（比如print）作为参数传入函数，避免返回不同类型：

#include <any>
#include <memory>
#include <iostream>

template<typename T>
struct Data {
    T attribute;
    void print() { std::cout << "Printing " << attribute << "\n"; }
};

using IntDataType = Data<int>;
using FloatDataType = Data<float>;

std::shared_ptr<IntDataType> make_int_data() {
    auto ptr = std::make_shared<IntDataType>();
    ptr->attribute = 42;
    return ptr;
}

std::shared_ptr<FloatDataType> make_float_data() {
    auto ptr = std::make_shared<FloatDataType>();
    ptr->attribute = 3.14f;
    return ptr;
}

std::any data;

void create_data(bool useFloat) {
    if (useFloat)
        data = make_float_data();
    else
        data = make_int_data();
}

// 通用操作函数，尝试转换为每种类型并执行操作
template<typename Op>
void operate_on_data(Op&& op) {
    if (auto* float_ptr = std::any_cast<std::shared_ptr<FloatDataType>>(&data)) {
        op(*float_ptr);
        return;
    }
    if (auto* int_ptr = std::any_cast<std::shared_ptr<IntDataType>>(&data)) {
        op(*int_ptr);
        return;
    }
    std::cerr << "Unknown data type\n";
}

int main() {
    create_data(true);
    operate_on_data([](auto&& ptr) { ptr->print(); });
    
    create_data(false);
    operate_on_data([](auto&& ptr) { ptr->print(); });
    return 0;
}

优势： #

• 无需修改现有std::any的存储逻辑
• 通过模板lambda实现对共同方法的统一调用
• 用指针版any_cast避免异常处理（返回nullptr表示转换失败）

方案3：类型擦除包装器 #

如果需要返回一个能调用print的统一类型对象，可通过类型擦除创建包装类：

#include <any>
#include <memory>
#include <iostream>

template<typename T>
struct Data {
    T attribute;
    void print() { std::cout << "Printing " << attribute << "\n"; }
};

using IntDataType = Data<int>;
using FloatDataType = Data<float>;

std::shared_ptr<IntDataType> make_int_data() {
    auto ptr = std::make_shared<IntDataType>();
    ptr->attribute = 42;
    return ptr;
}

std::shared_ptr<FloatDataType> make_float_data() {
    auto ptr = std::make_shared<FloatDataType>();
    ptr->attribute = 3.14f;
    return ptr;
}

// 类型擦除的包装类，提供统一的print接口
class DataWrapper {
public:
    template<typename T>
    DataWrapper(std::shared_ptr<T> ptr)
        : impl_(std::make_unique<Impl<T>>(std::move(ptr))) {}

    void print() const { impl_->print(); }

private:
    struct Concept {
        virtual ~Concept() = default;
        virtual void print() const = 0;
    };

    template<typename T>
    struct Impl : Concept {
        Impl(std::shared_ptr<T> ptr) : ptr_(std::move(ptr)) {}
        void print() const override { ptr_->print(); }
        std::shared_ptr<T> ptr_;
    };

    std::unique_ptr<Concept> impl_;
};

std::any data;

void create_data(bool useFloat) {
    if (useFloat)
        data = make_float_data();
    else
        data = make_int_data();
}

// 返回统一的包装器
DataWrapper get_data() {
    if (auto* float_ptr = std::any_cast<std::shared_ptr<FloatDataType>>(&data)) {
        return DataWrapper(*float_ptr);
    }
    if (auto* int_ptr = std::any_cast<std::shared_ptr<IntDataType>>(&data)) {
        return DataWrapper(*int_ptr);
    }
    throw std::bad_any_cast();
}

int main() {
    create_data(true);
    get_data().print();
    
    create_data(false);
    get_data().print();
    return 0;
}

优势： #

• 可返回统一类型对象，方便多场景复用
• 隐藏具体类型细节，仅暴露所需接口
• 符合面向对象封装思想

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