命名（或引用）一个专门的模板参数

Question

我决定使用以下模式自动组合各种类型的对象及其配置：

enum class Type { Car, Person };

template< Type TYPE >
struct Object;

template< Type TYPE >
struct ObjectConfig;

template<>
struct ObjectConfig< Type::Car >
{
};

// Version 1
template<>
struct Object< Type::Car >: public ObjectConfig< Type::Car > // How could I avoid this duplication???
{
};

// Version 2
template<>
struct Object< Type::Car >
{
    static constexpr Type myType{ Type::Car }; // How could I avoid this duplication???
    ObjectConfig< myType > m_params;
};

它旨在防错和自动，但我无法避免两次写入枚举值（这很容易出错并且根本不是自动的）。 我想写一些类似的东西（所以我想以某种方式引用专门的参数）：

template< Type TYPE >
struct Object;

template<>
struct Object< Type::Car >: public ObjectConfig< TYPE >
{
};

有什么技巧可以用来实现类似的目标吗？

先感谢您！

请在此处找到详细代码（代码）

Answer 1

我有两个版本的解决方案，虽然有点复杂。

#include <type_traits>

enum class Type { Car, Person, Truck };

template<Type TYPE>
struct ObjectConfig;

template<>
struct ObjectConfig<Type::Car>
{ };

template<>
struct ObjectConfig<Type::Person>
{ };

template<Type T>
struct FakeDependency: public std::false_type
{ };

template<Type TYPE, Type DELEGATED_TYPE = TYPE, typename DUMMY = typename std::enable_if<DELEGATED_TYPE == TYPE>::type >
struct Object;

template<Type TYPE, Type DELEGATED_TYPE, typename DUMMY>
struct Object
{
    static_assert( FakeDependency<DELEGATED_TYPE>::value, "Not supported!" );
};

template<Type DELEGATED_TYPE, typename DUMMY>
struct Object<Type::Car, DELEGATED_TYPE, DUMMY>
{
    ObjectConfig<DELEGATED_TYPE> m_params;
};

template<Type DELEGATED_TYPE, typename DUMMY>
struct Object<Type::Person, DELEGATED_TYPE, DUMMY> : public ObjectConfig<DELEGATED_TYPE>
{ };

int main() {
    Object<Type::Car> c;
    Object<Type::Person> p;
    //Object<Type::Truck> t;  // Static assertion
    //Object<Type::Car, Type::Person> cp; // template 3 (enable_if) invalid
}

您可以查看完整代码

我介绍了一个模板，它通过将第一个模板作为默认值来隐藏它。 您可以在 class 和 inheritance 内部使用它。

我添加了安全检查以防止使用不同的模板参数实例化您的 object： Object<Type::Car, Type::Person> 。 为此，我添加了第三个模板参数，它是一个带有enable_if作为默认值的类型模板。 如果您尝试使用不同的模板参数实例化 object，您将收到编译时错误。 第二个检查防止你有这样的对象： Object<Type::Car, Object::Car, int>因为在这种情况下，编译器将回退到要断言的主模板。

如果没有安全检查，它会变得更加简单：

enum class Type { Car, Person, Truck };

template<Type TYPE>
struct ObjectConfig;

template<>
struct ObjectConfig<Type::Car>
{ };

template<>
struct ObjectConfig<Type::Person>
{ };

template<Type TYPE, Type DELEGATED_TYPE = TYPE>
struct Object;

template<Type DELEGATED_TYPE>
struct Object<Type::Car, DELEGATED_TYPE>
{
    ObjectConfig<DELEGATED_TYPE> m_params;
};

template<Type DELEGATED_TYPE>
struct Object<Type::Person, DELEGATED_TYPE> : public ObjectConfig<DELEGATED_TYPE>
{ };

int main() {
    Object<Type::Car> c;
    Object<Type::Person> p;
}

Answer 2

我想我找到了一个通用的解决方案。

#include <type_traits>

enum class Type { Car, Person };

template< Type TYPE, typename T = void >
struct Object
{
    static_assert( sizeof( T ) == 0, "Not supported" );
};

template< Type TYPE >
struct ObjectConfig;

template<>
struct ObjectConfig< Type::Car >
{
};


// Version 1 - solved
template< Type TYPE >
struct Object< TYPE, std::enable_if_t< TYPE == Type::Car > >: public ObjectConfig< TYPE > // No emum duplication
{
};

// Version 2 - solved
template< Type TYPE >
struct Object< TYPE, std::enable_if_t< TYPE == Type::Person > >
{
    ObjectConfig< TYPE > m_params; // No emum duplication
};

您可以在此处查看完整的解决方案（代码）

Answer 3

如果可能，您可以按组合工作，而不是 inheritance。 创建一个内部模板化配置 Class 并向其中添加一个成员。

template< Type TYPE>
struct ObjectByComposition
{
    template<typename Type TYPE >
    struct Config{
        /*Whatever*/
    };

    Config<TYPE> m_Config;
};

ObjectByComposition< Type::Car > m_params;

在 OP 回答后编辑：这是一个内部 class 的事实当然不是强制性的，重要的是使成员 m_config 模板化为 T 类型。

template< Type TYPE  >
struct ObjectByComposition
{
    ObjectConfig< TYPE> m_Config;
};

ObjectByComposition< Type::Car > m_params;

Answer 4

我想我已经解决了版本 2 的问题：

enum class Type { Car, Person };

template< Type TYPE >
struct Object;

template< Type TYPE >
struct ObjectConfig;

template<>
struct ObjectConfig< Type::Car >
{
};

template< typename T >
struct ObjectTypeResolver
{
};

template< template< Type > class OBJ_T, Type TYPE >
struct ObjectTypeResolver< OBJ_T< TYPE > >
{
    static constexpr auto value{ TYPE };
};

// Version 1 - still unsolved
//template<>
//struct Object< Type::Car >: public ObjectConfig< Type::Car > // How could I avoid this duplication???
//{
//};

// Version 2 - solved
template<>
struct Object< Type::Car >
{
    static constexpr Type myType{ ObjectTypeResolver< Object >::value }; // No emum duplication
    ObjectConfig< myType > m_params;
};

您可以在此处查看完整代码（代码）

我使用了以下内容： C++17 标准 17.7.1 本地声明的名称

与普通（非模板）类一样，class 模板具有注入类名称（第 12 条）。 注入的类名可以用作模板名或类型名。 当它与模板参数列表一起使用时，作为模板模板参数的模板参数，或作为朋友 class 模板声明的详细类型说明符中的最终标识符，它指的是 class 模板本身. 否则，它等价于 <> 中包含的 class 模板的模板名称后跟模板参数。

在 class 模板特化或部分特化的 scope 内，当注入的类名用作类型名时，它等效于模板名后跟 ZA2F2ED4F8EBC2CBB4C21A29DC4 封闭的 ZA2F2ED4F8EBC2CBB4C21A29DC 的模板参数在<>。

这就是为什么它不能应用于版本 1 的问题：继承列表在 class 模板的 scope 之外。

这部分问题仍然悬而未决。