如何使用模板化别名或 const 变量来缩写 static const 变量？

Question

I am writing an entity component system as an exercise with C++17. I'd like to have each component type, represented as a struct, to be associated with a unique identifier that may be used as a index into into a vector of bitsets in the component registry as an example. This works using the templated struct ComponentType . However, it feels verbose to write ComponentType<Tag>::type every time I'd like to get the value. I'd prefer to use something like component_type_t<Tag> . However, compilation fails using a templated alias and the implementation as below, though it compiles, using produces the following output. Is there a better way to go about this?

0
1
2
0
0
0

Code:

#include <iostream>
    
namespace ECS {
    struct ComponentTraits {
        using component_type = unsigned int;
    protected:
        static component_type types;
    };

    using component_type = ComponentTraits::component_type;
    component_type ComponentTraits::types = 0;

    template<typename Component> 
    struct ComponentType : public ComponentTraits {
        static const component_type type;
    };

    template<typename Component>
    const component_type ComponentType<Component>::type = types++;

    template<typename Component>
    const component_type component_type_t = ComponentType<Component>::type;

    //Components
    struct Tag {};
    struct Transform {};
    struct Mesh {};
    // and so on...
  
    ////Won't compile
    //template<typename Component>
    //using component_type_t = ComponentType<Component>::type;
};

int main() {
    using namespace ECS;

    std::cout << ComponentType<Tag>::type << std::endl;
    std::cout << ComponentType<Transform>::type << std::endl;
    std::cout << ComponentType<Mesh>::type << std::endl;

    std::cout << component_type_t<Tag> << std::endl;
    std::cout << component_type_t<Transform> << std::endl;
    std::cout << component_type_t<Mesh> << std::endl;

    return 0;
}

Answer 1

The reason your templated using is not compiling because your ComponentType doesn't hold an alias, it holds variable storage.

using component_type = unsigned int;
static const component_type type; // this is not an alias

template<typename Component>
using component_type_t = ComponentType<Component>::type;

To fix that error you need to get its type by using decltype :

template<typename Component>
using component_type_t = decltype(ComponentType<Component>::type);

But this raises another problem, component_type_t never actually holds the value you expect, it actually holds the component_type which is unsigned int without any value assigned to it ( since it's an alias ), so when you call:

std::cout << component_type_t<Tag> << std::endl;
std::cout << component_type_t<Transform> << std::endl;
std::cout << component_type_t<Mesh> << std::endl;

It prints 0 because your compiler assigning 0 to uninitialized variables, you should not rely on this, because different compilers may deal with this differently.

So to fix this, you need to pass the value into a variable rather than pass its type:

template<typename T>
component_type component_type_t<T> = ComponentType<T>::type;

And your output will be:

0 // Tag 
1 // Transform
2 // Mesh
0 // Tag 
1 // Transform
2 // Mesh