In un proyecto mío, Yo tengo unID generador para tipos que se parecen a esto:

class Family {
    static std::size_t identifier;

    template<typename...>
    static std::size_t family() {
        static const std::size_t value = identifier++;
        return value;
    }

public:
    template<typename... Type>
    inline static std::size_t type() {
        return family<std::decay_t<Type>...>();
    }
};

std::size_t Family::identifier{};

Uso

const auto id = Family::type<FooBar>();

Funciona bien para mis propósitos, pero tiene algunas limitaciones. El más molesto (propósito de la pregunta) es que falla cuando lo utiliza un ejecutable que se vincula a bibliotecas compartidas si todas ellas intentan crear identificadores. El resultado generalmente es que el identificador n-ésimo se asigna a diferentes tipos a través de los límites porque cada biblioteca compartida mantiene su propia @ separaFamily::identifier.

Algunos biblioteca compartida chicos señaló que se apreciaría una solución más confiable, pero no sugirió una que no arruinara el rendimiento (casi todos introducen contenedores, encuentran funcionalidades y asignación de memoria).

Existe algún enfoque alternativo que funcione en torno a las limitaciones mencionadas sin perder el rendimiento del diseño actual?

Busqué en SO y encontré algunas respuestas interesantes. Muchos de los cuales tenían varios años. Me gustaría explorar soluciones hasta la última revisión del estándar, siempre y cuando la interfaz de la clase existente permanezca intacta.
Ést es el más interesante. Utiliza direcciones de miembros estáticos para lograr lo mismo, pero no encaja con la idea de identificadores generados secuencialmente

Not: desafortunadamente, usar RTTI no es una opción.

Not: los ID deben generarse secuencialmente y comenzar desde 0 como en la solución presentada anteriormente.