如何使用具有显式特化的另一个模板参数推断模板返回类型？

Question

我有一个具有以下签名的（成员）函数：

template<Type TypeToAllocate, typename Str>
    Str* allocate();

Type 是一个枚举，根据提供的枚举，我想返回 Str 类型的不同指针。

现在我不确定我该怎么做。示例代码在这里：

#include <functional>
#include <vector>
enum class Type {
    A,
    B
};

struct Bar{};
struct Baz{};

struct Foo {
    Type t;
    union {
        Bar b;
        Baz bz;
    };
};

struct Util {
std::vector<Foo> foos;

    template<Type TypeToAllocate, typename Str>
    Str* allocate();

};


template<>
    Bar* Util::allocate<Type::A>() {
        Foo& f = foos.emplace_back(Foo{});
        f.t = Type::A;
        f.b = Bar{};
        return &f.b;
    }

int main() {
    Util u{};
    Bar* b = u.allocate<Type::A>(); // this does not work
}

https://godbolt.org/z/T357KTnGd

Answer 1

我不确定Str 在您的代码中的作用。如果这只是您尝试将枚举值映射到 Bar 或 Baz 的一部分，那么我认为您不需要它。

我会使用一个特征，它可以很容易地专门用于 Type 的不同值：

enum class Type {
    A,
    B
};

struct Bar{};
struct Baz{};

template <Type t> struct TypeMapper;
template <> struct TypeMapper<Type::A> { using type = Bar; };
template <> struct TypeMapper<Type::B> { using type = Baz; };

template <Type t> using TypeMapper_t = TypeMapper<t>::type;

struct Util {
    template<Type t>
    TypeMapper_t<t>* allocate() { 
        return new TypeMapper_t<t>();
    }
};

int main() {
    Util u{};
    Bar* b = u.allocate<Type::A>();
}

Live Demo

我还建议你使用std::variant<Bar,Baz> 而不是联合。