c++ 元编程：为每个枚举类型成员创建 typedef 作为类型

Question

I wonder if it is possible to generate types set from enum class for the metaprogramming purposes. I'm originally a C# programmer and used to using a lot of attributes for reflection and metaprogramming. For example, it is a general pattern for me to write a snippet like that with C#:

public enum ComponentEnum { Component1, Component2, Component3 }

[Component(ComponentEnum.Component1)]
public class Component1
{
/* Some code */
}

public static class ComponentsMeta
{
    private static Dictionary<Type, ComponentEnum> map;
    static ComponentMeta() { /*process the whole codebase via reflection, search Component marked classes an fill the map */}
    public static bool IsComponent<T>() => map.ContainsKey(typeof(T));
    public static int GetComponentUID<T>() => (int)map[typeof(T)];
}

Of course, it is a very basic snippet without asserts and some other stuff but I believe you got the idea. I want to make the same behavior in the c++ snippet. What I want to do exactly is makes a type called Components that will contain some utility functions like bool Components::isComponent<T>() or size_t Components::getComponentUID<T>() or some related stuff. The best way I've seen so far is to write it down by myself, making a metaclass like

template <typename Ts..>
class ComponentsData
{
/* functions impl here */
}

typedef ComponentsData<C1, C2, C3> Components;

So, now I can ask Components<C1>::getComponentUID() and it returns me uid of that component (depends on its position as template parameter or constexpr value of that component, it doesn't matter). But it is a very inconvenient way to do that and I wonder if I can put a macro inside the component class or using attributes and code generation step or something. In other words, my goal is to mark somehow the class that it should be in that components set and use it later. What c++ can offer for that purpose?

It will be okay if I could make something like I did C# way - make an enum class, list all the components there, and write a constexpr value inside a component class (or somewhere near the enum class, both ways is good for me). I mean something like that:

    /* ComponentsEnum.h */
    enum class ComponentsEnum { Comp1, Comp2, Comp3 };
    // Here is some magic to generate Components<C1, C2, C3> metaclass.

    /* another file */
    #include "ComponentsEnum.h"
    struct C1 { const ComponentsEnum MyValue = ComponentsEnum::Comp1; };

or something like that

    /* ComponentsEnum.h */
    enum class ComponentsEnum { Comp1, Comp2, Comp3 };
    
    // Here is all the magic 
    // All enum members concats into `Components<Comp1, Comp2, Comp3, ...>`
    ConcatAll<ComponentsEnum>();

    /* another file */
    #include "ComponentsEnum.h"
    struct Comp1 { };

or maybe something with macro magic:

    /* ComponentsEnum.h */
    enum class ComponentsEnum { Comp1, Comp2, Comp3 };
    #define InitMeta(ComponentsEnumMember) /* Some Magic */

    /* another file */
    #include "ComponentsEnum.h"
    struct Comp1 { InitMeta(ComponentsEnum::Comp1) };

Thanks in advance!

Answer 1

Following on my comment.

You could do something like this in C++17:

// In register.hpp
int register_me();

// In register.cpp
int register_me(){
    static int id = 0;
    return id++;
}

// In wherever.hpp
// #include "register.hpp"
struct component{
    inline static int id = register_me();
};

Pre-C++17 requires moving the definition and initialization to a .cpp for each component::id .

But I strongly recommend not to use this. Rethink your design, converting types to IDs is a code smell for me. C++ is not really designed to do such things, it can haunt you later.

The code above relies on dynamic initialization of all static variable at the start of the program. The order is unspecified, each compilation might result in assignment of different IDs.

Definitely do not put this into any shared libraries before being 100% sure you know how the compilation, linking, and loading processes work for your toolchain because these are outside the scope of C++ Standard.

Answer 2

Thanks to the @JerryJeremiah link and @Quimby advice, I found the solution.

So, I was misled by my C# habits and the idea was quite simple but tricky. According to the difference between C# generics and C++ templates, generics are runtime instanced types, but templates are compile-time types. So, I do not need to create a map or process the whole codebase, all I need will be generated with templates in compile time.

The solution itself:

1. I want an enum to generate continuous uid numbers for my components. So, define it:

enum class ComponentEnum
{
    C1,
    C2,
    C3
};

2. I want a simple interface for my Components to ask for meta information. Define it too:

struct Components
{
    template<typename T>
    static bool isComponent() { /* Some stuff here */ }
    
    template<typename T>
    static int getComponentUID() { /* Some stuff here */ }
};

Now I can ask uid with one simple generalized call Components::getComponentUID<MyComponent>() . Nice.

3. The real magic. I've created template metaclass and macro to create a typedef and some additional methods:

template <typename T, ComponentEnum enumMember>
struct ComponentMeta
{
    static constexpr bool isComponent = true;
    static constexpr int uid = static_cast<int>(enumMember);
};

#define ComponentMetaMacro(type_name, enum_name) typedef ComponentMeta<type_name, ComponentEnum::enum_name> Meta; \
static const char* toString() { return #type_name; }

So I can fill methods from my interface with simple forwarding to that metaclass:

struct Components
{
    template<typename T>
    static bool isComponent() { return T::Meta::isComponent; }
    
    template<typename T>
    static int getComponentUID() { return T::Meta::uid; }
};

4. All things left is include header with metaclass and macro and call the macro:

struct C1
{
    ComponentMetaMacro(C1, C1)
};

struct C2
{
    ComponentMetaMacro(C2, C2)
};

---

Run a few tests:

    std::cout << C1::toString() << ": " << Components::getComponentUID<C1>() << std::endl;
    std::cout << C2::toString() << ": " << Components::getComponentUID<C2>() << std::endl;

C1: 0 C2: 1

Yay!

---

This solution has three main problems:

1. isComponent() becomes the static assert instead of the flag. I mean, the code won't compile if T-type is not a component. It is quite ok but smells.
2. It is a single linked meta. I can't get a component type from the index, only an index from the type. But for serialization purposes, it could be useful to have a backlink.
3. I should include the enum class to every component header. It means there will be a huge compile-time affect when I will add a new enum member. I suppose there is a way to avoid it but can't see one. The only enum class purpose is to have the smallest index as possible for every component that will be static between compilations. Maybe I have to think about some data generation or another approaches, but for the small project it is ok.