递归模板类型声明

Question

I am trying to create a struct that contains a N nested templated types:

The code I have to do this is:

// slab (base case essentially)
template<typename T, uint32_t nvecs = 8, align_policy ap = align_policy::none>
struct slab {
T t;
};

// wrapper for either slab or other super_slabs
template<typename T,
         uint32_t nvecs        = 8,
         uint32_t inner_nvec   = 8,
         typename inner_slab_t = slab<T, inner_nvec>>
struct super_slab {
inner_slab_t ist;
};

// hopefully correct functions to extract Nth values for argument pack
template<typename... Vals>
constexpr uint32_t
_get_0(uint32_t v, Vals... vals) {
    return v;
}

template<typename... Vals>
constexpr uint32_t
_get_N(int32_t n, uint32_t v, Vals... vals) {
    return n <= 0 ? _get_0(vals...) : _get_N(n - 1, vals...);
}

template<typename... Vals>
constexpr uint32_t
get_N(int32_t n, Vals... vals) {
    return _get_N(n, vals...);
}


// first approach I tried
#ifdef APPROACH_A
template<typename T, uint32_t nlevels, uint32_t level, uint32_t... other_nvecs>
struct type_helper {
    using type = typename std::conditional<
        level <= 1,
        slab<T, other_nvecs...>,
        super_slab<T,
                   get_N(nlevels - level, other_nvecs...),
                   get_N(nlevels - (level + 1), other_nvecs...),
                   typename type_helper<T, nlevels, level - 1, other_nvecs...>::
                       type>>::type;
};
#endif

// second approach I tried
#ifdef APPROACH_B
template<typename T, uint32_t nlevels, uint32_t level, uint32_t... other_nvecs>
struct type_helper;
template<typename T, uint32_t nlevels, uint32_t level, uint32_t... other_nvecs>
struct type_helper {
    using type = super_slab<
        T,
        get_N(nlevels - level, other_nvecs...),
        get_N(nlevels - (level + 1), other_nvecs...),
        typename type_helper<T, nlevels, level - 1, other_nvecs...>::type>;
};

template<typename T, uint32_t nlevels, uint32_t level, uint32_t other_nvecs>
struct type_helper {
    using type = slab<T, nvecs>;
};
#endif

// struct I want to use for API.
template<typename T, uint32_t levels, uint32_t... level_nvecs>
struct slab_manager {
    using slab_t =
        typename type_helper<T, levels, levels, level_nvecs...>::type;
};

APPROACH_A compiles but when I try to instantiate it with:

slab_manager<uint64_t, 1, 8> m;

I get the error:

slab_manager.h: In instantiation of ‘struct type_helper<long unsigned int, 1, 4294966399, 8>’:
slab_manager.h:39:36:   recursively required from ‘struct type_helper<long unsigned int, 1, 0, 8>’
slab_manager.h:39:36:   required from ‘struct type_helper<long unsigned int, 1, 1, 8>’
slab_manager.h:63:70:   required from ‘struct slab_manager<long unsigned int, 1, 8>’
obj_slab_test.cc:213:34:   required from here
slab_manager.h:36:25: fatal error: template instantiation depth exceeds maximum of 900 (use -ftemplate-depth= to increase the maximum)
                    get_N(nlevels - level, other_nvecs...),
                    ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
compilation terminated.

I don't really see how 'struct type_helper<long unsigned int, 1, 4294966399, 8>': ever comes to pass as passing 1 is initial level should cause it to just hit the base case in std::conditional . My guess was the issue was std::conditional fully unrolls both options but when I try approach BI get the following errors:

slab_manager.h:43:68: error: template parameter ‘unsigned int ...other_nvecs’
 template<typename T, uint32_t nlevels, uint32_t level, uint32_t... other_nvecs>
                                                                    ^~~~~~~~~~~
slab_manager.h:55:8: error: redeclared here as ‘unsigned int other_nvecs’
 struct type_helper {
        ^~~~~~~~~~~
slab_manager.h: In instantiation of ‘struct type_helper<long unsigned int, 1, 4294966399, 8>’:
slab_manager.h:51:75:   recursively required from ‘struct type_helper<long unsigned int, 1, 0, 8>’
slab_manager.h:51:75:   required from ‘struct type_helper<long unsigned int, 1, 1, 8>’
slab_manager.h:63:70:   required from ‘struct slab_manager<long unsigned int, 1, 8>’
obj_slab_test.cc:213:34:   required from here
slab_manager.h:49:14: fatal error: template instantiation depth exceeds maximum of 900 (use -ftemplate-depth= to increase the maximum)
         get_N(nlevels - level, other_nvecs...),
         ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Which indicates the reason A was failing is NOT due to std::conditional but confuses me more because the method of re-declaring types with a base case was what I saw in every guide I've seen so far.

My guess is that calling slab_manager<uint64_t, 1, 8> m; would set slab_t = slab<uint64_t, 8> and for example slab_manager<uint64_t, 3, 2, 4, 8> m; would set slab_t = super_slab<uint64_t, 2, 4, super_slab<uint64_t, 4, 8, slab<uint64_t, 8> . Any help would be appreciated. Thank you!

Edit for posterity:

There was ALOT wrong with this question. as @cdhowie pointed out I wasnt following the guides right. Here is a solution that worked:

template<typename... Vals>
constexpr int32_t
_get_0(int32_t v, Vals... vals) {
    return v;
}


template<typename... Vals>
constexpr int32_t
_get_0(int32_t v) {
    return v;
}

template<typename... Vals>
constexpr int32_t
_get_N(int32_t n, Vals... vals) {
    return n <= 0 ? _get_0(vals...) : _get_N(n - 1, vals...);
}


template<typename... Vals>
constexpr int32_t
get_N(int32_t n, Vals... vals) {
    return _get_N(n, vals...);
}


template<typename T, int32_t nlevels, int32_t level, int32_t... other_nvecs>
struct type_helper;


template<typename T, int32_t nlevel, int32_t... other_nvecs>
struct type_helper<T, nlevel, 0, other_nvecs...> {
    typedef slab<T, get_N(nlevel, other_nvecs...)> type;
};

template<typename T, int32_t nlevels, int32_t level, int32_t... other_nvecs>
struct type_helper {
    typedef super_slab<T,
                       get_N(nlevels - level, other_nvecs...),
                       get_N(nlevels - (level + 1), other_nvecs...),
                       typename type_helper<T, nlevels, level - 1, other_nvecs...>::type>
        type;
};


template<typename T, int32_t levels, int32_t... level_nvecs>
struct slab_manager {
    using slab_t = typename type_helper<T, levels, levels - 1, level_nvecs...>::type;
};

Answer 1

In approach A, you have compile-time integer underflow since both types in the two "branches" of std::conditional are still instantiated, even if the conditional selects the other. As a result, your type_helper causes infinite recursion trying to instantiate.

The compilation error with approach B is that your syntax for specialization is wrong. This:

template<typename T, uint32_t nlevels, uint32_t level, uint32_t other_nvecs>
struct type_helper {
    using type = slab<T, nvecs>;
};

Should be this:

template<typename T, uint32_t nlevels, uint32_t level, uint32_t other_nvecs>
struct type_helper<T, nlevels, level, other_nvecs> {
    using type = slab<T, nvecs>;
};

Approach B falls prey to exactly the same infinite recursion problem as approach A: type_helper<T, nlevels, level, other_nvecs...> will always instantiate type_helper<T, nlevels, level - 1, other_nvecs...> . level underflows, and recursion continues until the compiler gives up.

The way you'd terminate recursion in this case would be to define a special case when level is zero:

template<typename T, uint32_t nlevels, uint32_t... other_nvecs>
struct type_helper<T, nlevels, 0, other_nvecs...> {
    using type = // whatever makes sense in your case
};

I don't know what type should be here (but I presume you do).

You can also have a final terminating case where level is zero and other_nvecs is empty:

template<typename T, uint32_t nlevels>
struct type_helper<T, nlevels, 0> {
    using type = // something
};