问：

目标

我想实现一个结构，满足某些要求。我有一个有效的解决方案代码，但它有某些缺点。我寻求更好的方法。Derived<size_t ...Tpar>

要求

Derived<size_t ...Tpar>必须以独占方式继承自 。 对我来说，相关案例是 和 .Base<size_t ...Tpar>Derived<size_t>Derived<>

成员和属性：

• 空 Tpar 和非空 Tpar 的相同成员函数void a(void);
• 仅用于非空 Tpar 的长度数组dataTpar[0]Derived<Tpar...>
• 以及一个仅用于非空 Tpar 的函数，该函数在 上执行计算。void b(void);data

最小工作示例

正如以下示例代码中的注释所示，这些问题使解决方案没有吸引力：

1. 既然和两者都实现了，我就想到了继承。但这不起作用，因为会继承自 ，这违反了要求。Derived<>Derived<size_t>a()Derived<size_t>Derived<>Derived<size_t>Base<>
2. 因此，我选择了一个专门的子模块。但这不起作用，因为 Derived 已经是一个模板，因此我无法根据语言规则在其命名空间中专门化子模块模板。
3. 因此，我将子模块制作为两个非模板显式变体，并用于在任一专业化中获得正确类型的子模块。 3.1. 数组有没有更好的替代方案（我必须用零来增加，只是为了条件不抱怨是空指针？ 3.2. 有没有办法在不将子模块暴露给编译单元的情况下对子模块进行模板化或使整个代码更短？conditional_tDerivedaTpar[0]

#include<iostream>
#include<array>
#include<type_traits>

template<size_t ...Tpar> class Base{};

// I cannot inherit Derived<Tpar> from Derived<> since this would make Derived<Tpar> a derived of Base<>.
template<size_t ...Tpar>
class Derived: Base<Tpar...>{
    // c++ won't allow template structure specializations within a template struct
    template<size_t n>
    struct SubModule_paged{
        double data[n];
        void foo(){
            // foo is a routine that computes on data.
            std::cout << "Sub<"<<n<<">foo.\n";
        }
    };
    struct SubModule_empty{
        // no data, hence no foo.
        void foo() = delete; // COMPILER HINT: Intentionally, Derived<> has no member b.
    };
    static constexpr size_t nTpar = sizeof...(Tpar);
    static constexpr std::array<const size_t, nTpar+1> aTpar = {Tpar...,0}; // <-- This is ugly!
    using SubModuleType = std::conditional_t< (nTpar>0) , SubModule_paged<aTpar[0]> , SubModule_empty >;
    //
    SubModuleType sub;
    //
public:
    void a(){
        std::cout << "a.\n";
    }
    void b(){
        std::cout << "b.\n";
        sub.foo();
    }
};

int main(){
    Derived< > x;
    Derived<3> y;
    
    x.a();
    //x.b();
    
    y.a();
    y.b();
}