在基类子句中使用类中定义的typedefs/type别名

Using in-class defined typedefs/type aliases in base-clause

本文关键字：typedefs 定义 type 别名 基类 子句      更新时间：2023-10-16

我经常在类定义中面临不可避免的代码重复问题，即我在base子句中键入基说明符，然后我应该为每个非默认构造的基至少再键入/复制一次相同的代码：在构造函数中（在成员初始值设定项列表或其主体中）。有些打字打两次是件烦人的事。我看到了这个问题的解决方案：允许用户使用在当前类作用域中定义的typedefs、类型别名和别名模板的基本子句。即在定义之前，因为它允许在当前类范围内定义其他符号（数据成员、成员函数）。

是否存在C++-C++性质所施加的任何固有限制，以允许在类范围中定义的typedefs/类型别名/别名模板的前向使用？

例如：

template< bool >
struct enable_default_constructor;
template<>
struct enable_default_constructor< true >
{
    enable_default_constructor() = default; 
    enable_default_constructor(void * ) { ; }
};
template<>
struct enable_default_constructor< false >
{
    enable_default_constructor() = delete; 
    enable_default_constructor(void * ) { ; }
};
template< typename ...Ts >
struct X
    : enable_default_constructor< (std::is_default_constructible< Ts >::value && ...) >
{
    // next line containing duplication of code
    using enabler = enable_default_constructor< (std::is_default_constructible< Ts >::value && ...) >;
    X() = default;
    template< typename ...Us >
    X(Us &&... v)
        : enabler({})
        , m(std::forward< Us >(v)...) // using symbol `m` before definition
    { ; }
private :
    std::tuple< Ts... > m;
};
struct S {};
struct N { N() = delete; };
static_assert(std::is_default_constructible< X< int, double, S > >::value);
static_assert(!std::is_default_constructible< X< int, double, N > >::value);

我想直接在基子句中使用enabler符号。

如果我的想法是正确的，你想避免写基类的名称（例如，因为它是一个长而复杂的模板），那么有一种稍微复杂的方法。

将此应用于您的上述要求：

template< bool >
struct enable_default_constructor;
template<>
struct enable_default_constructor< true >
{
    enable_default_constructor() = default;
    enable_default_constructor(void * ) { ; }
};
template<>
struct enable_default_constructor< false >
{
    enable_default_constructor() = delete;
    enable_default_constructor(void * ) { ; }
};
namespace declare_X
{
    template<typename ...Ts> using
    base = ::enable_default_constructor< (std::is_default_constructible< Ts >::value && ...) >;
    template< typename ...Ts >
    struct X
    : base<Ts...>
    {
        X() = default;
        X(Ts &&... v)
        : base<Ts...>({})
        , m(std::forward< Ts >(v)...)
        { ; }
        private :
        std::tuple< Ts... > m;
    };
}
template<typename...Ts> using X = declare_X::X<Ts...>;

struct S {};
struct N { N() = delete; };
static_assert(std::is_default_constructible< X< int, double, S > >::value);
static_assert(!std::is_default_constructible< X< int, double, N > >::value);

但我不想重复模板的论点。。。

那么恐怕我们不得不求助于宏：

#if defined(BASE_CLASS)
#undef BASE_CLASS
#endif
#define BASE_CLASS enable_default_constructor< (std::is_default_constructible< Ts >::value && ...) >

template< typename ...Ts >
struct X
: BASE_CLASS
{
    X() = default;
    X(Ts &&... v)
    : BASE_CLASS({})
    , m(std::forward< Ts >(v)...)
    { ; }
    private :
    std::tuple< Ts... > m;
};
#undef BASE_CLASS

只需对类模板定义进行一点修改，就可以将繁重的类型粘贴到模板参数列表中：

namespace internal
{
    template <typename, typename> struct XImpl;
    template <typename ...Args, typename Enabler>
    struct XImpl<std::tuple<Args...>, Enabler> : Enabler
    {
        using XImpl() = default;
        // ...
    };
}
template <typename ...Args>
using X = internal::XImpl<std::tuple<Args...>,
                          HorrendousEnablerTemplate<Args...>>;
相关文章：