如何使用 C++ 模板参数来确定类中的成员类型

Question

我想创建一个 Vertex 类，并希望通过能够创建 32 位浮点和 64 位双精度版本以及可能的整数版本来对其进行通用化。我想这样做：

template <typename P>
struct Vertex
{
    if (typeid(P) == typeid(float))
    {
         vec3 position;
         vec3 normal;
         vec2 texcoords;
    }
    else if (typeid(P) == typeid(double))
    {
         dvec3 position; // This is a double vector
         dvec3 normal;
         dvec2 texcoords;
    }
    else if (typeid(P) == typeid(int))
    {
         ivec3 position; // This is an integer vector
         ivec3 normal;
         ivec2 texcoords;
    }

};

我不认为 if 语句不会在编译时评估，所以这只是我想做的一个说明。有没有办法做到这一点？还是我必须专门针对每种类型，还是只重写所有不同的版本？

Answer 1

您可能想要某种vec3 和vec2 选择器类型。如果已经有 vec3 和 vec2 的模板版本，只需使用它们。否则，您可以使用模板特化：

template <typename T>
struct vec_selector {};

template <>
struct vec_selector<float> {
    using vec3_type = vec3;
    using vec2_type = vec2;
};

template <>
struct vec_selector<double> {
    using vec3_type = dvec3;
    using vec2_type = dvec2;
};

template <>
struct vec_selector<int> {
    using vec3_type = ivec3;
    using vec2_type = ivec2;
};

template <typename P>
using vec3_select_t = typename vec_selector<P>::vec3_type;

template <typename P>
using vec2_select_t = typename vec_selector<P>::vec2_type;

那么你可以简单地写：

template <typename P>
struct Vertex
{
    vec3_select_t<P> position;
    vec3_select_t<P> normal;
    vec2_select_t<P> texcoords;
};

您也可以只专门化 Vertex 模板，但在别处使用 vec3_select_t 似乎很有用，并且您必须在 Vertex 上重复任何成员函数（或者编写代码更复杂）

Answer 2

这是另一种选择

template<typename T>
struct Type { typedef T type; };

template<typename T>
inline constexpr Type<T> type{};

template <typename P>
struct Vertex
{
    static constexpr auto D3 = []{ 
        if constexpr(std::is_same_v<P,float>)
            return type<vec3>;
        else if constexpr(std::is_same_v<P,double>)
            return type<dvec3>;
        else if constexpr(std::is_same_v<P,int>)
            return type<ivec3>;
    }();

    static constexpr auto D2 = []{ 
        if constexpr(std::is_same_v<P,float>)
            return type<vec2>;
        else if constexpr(std::is_same_v<P,double>)
            return type<dvec2>;
        else if constexpr(std::is_same_v<P,int>)
            return type<ivec2>;
    }();

    typename decltype(D3)::type position;
    typename decltype(D3)::type normal;
    typename decltype(D2)::type texcoords;
};

在Type 模板上稍加努力，您就可以对 lambdas 的代码进行相当多的改进（也许您已经看过 boost hana，它也遵循了这个想法）

template<typename T>
struct Type {
   typedef T type;   
   friend constexpr bool operator==(Type, Type) {
       return true;
   }
};

template<typename T1, typename T2>
constexpr bool operator==(Type<T1>, Type<T2>) {
    return false;
}

template<typename T>
inline constexpr Type<T> type{};

现在它不再需要std::is_same_v

template <typename P>
struct Vertex
{
    static constexpr auto D3 = [](auto t) { 
        if constexpr(t == type<float>)
            return type<vec3>;
        else if constexpr(t == type<double>)
            return type<dvec3>;
        else if constexpr(t == type<int>)
            return type<ivec3>;
    }(type<P>);

    static constexpr auto D2 = [](auto t) { 
        if constexpr(t == type<float>)
            return type<vec2>;
        else if constexpr(t == type<double>)
            return type<dvec2>;
        else if constexpr(t == type<int>)
            return type<ivec2>;
    }(type<P>);

    typename decltype(D3)::type position;
    typename decltype(D3)::type normal;
    typename decltype(D2)::type texcoords;
};

丑陋的decltype 写作也可以通过使用auto 来修复

template<auto &t>
using type_of = typename std::remove_reference_t<decltype(t)>::type;

所以你可以写

type_of<D3> position;
type_of<D3> normal;
type_of<D2> texcoords;

Answer 3

OP 在 cmets 中提到他们正在使用 GML。

GLM 向量实际上是模板，因此不需要复杂的解决方案：

template <typename P>
struct Vertex
{
     tvec3<P> position;
     tvec3<P> normal;
     tvec2<P> texcoords;
};

Answer 4

这只是贾斯汀解决方案的补充。无论如何，这实际上是他的。使用 std::conditional 的想法是 François Andrieux 在 cmets 中给出的想法。大致如下：

template <typename P>
struct vertex
{
    using vec3_t = std::conditional_t <std::is_same_v<float, P>,
        /*IF FLOAT*/     vec3,
        /*OTHERWISE*/    std::conditional_t <is_same_v<double, P>,
        /*IF DOUBLE*/    dvec3,
        /*IF INT*/       ivec3>>;

    vec3_t position;
    vec3_t normal;
    //vec2_t texcoords; WILL HAVE TO TYPEDEF THIS AS WELL.
};

Johannes Schaub 在 cmets 中也给出了基于 constexpr 和 decltype 的两种不同解决方案。