Question

以下类不能在C ++ 11下编译;它所处的循环只能在运行时执行，因此得到一个＆＃34; char（*）[i]是一个可变修改的类型＆＃34;循环中模板类静态函数调用的错误：

#include <cstddef>
#include <vector>

template <std::size_t N>
class Foo
{
private:
    const std::vector<char(*)[]> bar = bar_init();

    static std::vector<char(*)[]> bar_init()
    {
        std::vector<char(*)[]> init;

        for (size_t i = N; i > 0; i >>= 1)
        {
            auto ptr_to_array = MyClass<char(*)[i]>::static_return_ptr_to_array();
            init.emplace_back(reinterpret_cast<char(*)[]>(ptr_to_array));
        }

        return init;
    }
};

有没有办法可以在初始化函数中使用模板来实现相同的效果？也就是说，初始化＆＃34; bar＆＃34;大小log2（N）at＆＃34; Foo＆＃34;类实例化作为指向char数组的指针的const向量，每个向量元素包含例如对于N = 32，输出：

MyClass<char(*)[32]>::static_return_ptr_to_array();
MyClass<char(*)[16]>::static_return_ptr_to_array();
MyClass<char(*)[8]>::static_return_ptr_to_array();

//etc...

Answer 1

类似（在c ++ 11中）

template<int I> 
struct tag{};

void init( std::vector<char(*)[]>& result, tag<0> ){}

template<int I>
void init( std::vector<char(*)[]>& result, tag<I> )
{
    auto ptr_to_array = MyClass<char(*)[I]>::static_return_ptr_to_array;

    result.emplace_back(reinterpret_cast<char(*)[]>(ptr_to_array));

    init(result,tag<(I>>1)>{});
}

template <std::size_t N>
class Foo
{
private:
    const std::vector<char(*)[]> bar = bar_init();

    static std::vector<char(*)[]> bar_init()
    {
        std::vector<char(*)[]> result;

        init( result, tag<N>{} );

        return result;
    }
};

在c ++ 17中，这可以通过 if constexpr 进一步简化，并且没有标签＆lt;＆gt;。此外，请注意std::vector<char(*)[]>不可移植，因为vector需要一个完整的类型。

Answer 2

我认为这里至关重要的见解是，你不能写：

int i = ?? // automatic variable
auto val = MyClass<char(*)[i]>::static_return_ptr_to_array()

...模板参数必须是常量。

你可以做的事情是这样的：

const std::unordered_map<int,???> allocator_map = {
    {1, MyClass<char(*)[1]>::static_return_ptr_to_array},
    {2, MyClass<char(*)[2]>::static_return_ptr_to_array},
    {4, MyClass<char(*)[4]>::static_return_ptr_to_array},
    {8, MyClass<char(*)[8]>::static_return_ptr_to_array},
    ...
};

然后

const auto it = allocator_map.find(i);
if (it == allocator_map.end())
    // throw error
auto val = (it->second)();

基本上，我们的想法是你有一个静态的allocator函数数组，然后将其编入索引。（可能有使用模板初始化地图的聪明方法。我可能只是手工编写它 - 可能使用预处理器宏）。

Answer 3

如果你定义索引容器类型特征（或者你使用std::index_sequence，遗憾的是只能从C ++开始14）

template <std::size_t ...>
struct indexList
 { };

并定义一个类型特征以提取两个递减幂的序列

template <std::size_t, typename>
struct iLH;

template <std::size_t N, std::size_t ... Is>
struct iLH<N, indexList<Is...>> : public iLH<(N >> 1), indexList<Is..., N>>
 { };

template <std::size_t ... Is>
struct iLH<0U, indexList<Is...>>
 { using type = indexList<Is...>; };

template <std::size_t N>
struct getIndexList : public iLH<N, indexList<>>
 { };

template <std::size_t N>
using getIndexList_t = typename getIndexList<N>::type;

应该可以将您的Foo简单地写为

template <std::size_t N>
class Foo
 {
   private:
      const std::vector<char **> bar = bar_init (getIndexList_t<N>{});

      template <std::size_t ... Is>
      static std::vector<char **> bar_init (indexList<Is...> const &)
       {
         std::vector<char **> init { MyClass<char(*)[Is]>::getPtr()... };

         return init;
       }
 };

（假设getPtr()中的静态MyClass方法）返回char **的{{1}}和bar向量。

以下是完整的编译示例

char **

使用模板在编译时初始化指向数组的指针的const向量

3 个答案: