1

テンプレートパラメーターに基づいて constexpr として初期化したい配列があります (constexpr として初期化リストを必要とする答えを想定しているため、これには c++14 が必要になると思います)。

テンプレートがあるとしましょう

template<T t>

どこ

 T = int[1][2][3]

これで、type_traits std::extent を使用して配列サイズを再帰的に抽出できます

最終的にやりたいことは、T の次元を myarray の要素として持つ constexpr メンバーを生成することです

std::array<int,3> myarray = {1,2,3};

可変個引数テンプレート ref: How to construct std::array object with initializer listを使用して配列を初期化する良い方法のように見えるものを見てきました。

問題は、T?1 を指定して、T の次元を持つイニシャライザ リストまたは可変個引数テンプレートのいずれかを生成する方法です。

4

2 に答える 2

2

以下は少し複雑ですが、動作するはずです (C++11 で):

#include <array>
#include <type_traits>

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

template<typename,typename> struct cat;
template<std::size_t... Is, std::size_t... Js>
struct cat<seq<Is...>,seq<Js...>>
{
    using type = seq<Is...,Js...>;
};

template<typename> struct extract_seq { using type = seq<>; };
template<typename T,std::size_t N>
struct extract_seq<T[N]>
{
    using type = typename cat< seq<N>, typename extract_seq<T>::type >::type;
};

template<typename T> struct extract_type { using type = T; };
template<typename T,std::size_t N>
struct extract_type<T[N]>
  : extract_type<T>
{};

template<typename,typename> struct to_array_helper;
template<typename T, std::size_t... Is>
struct to_array_helper<T,seq<Is...>>
{
    constexpr static const std::array<T,sizeof...(Is)> value {{ Is... }};
};

template<typename T, std::size_t... Is>
constexpr const std::array<T,sizeof...(Is)>
to_array_helper<T,seq<Is...>>::value;

template<typename T>
struct to_array
  : to_array_helper<typename extract_type<T>::type,
                    typename extract_seq<T>::type>
{};

int main()
{
    auto arr = to_array< int[1][2][3] >::value;
}

実際の例

于 2013-10-31T00:10:29.770 に答える
1

特別な将来の C++ は必要ないと思います。これは C++11 で正常に動作します。

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

#include <prettyprint.hpp>

template <typename T>
struct Foo
{
    std::array<std::size_t, std::rank<T>::value> a;

    Foo() : Foo(X<std::rank<T>::value>(), Y<>(), Z<T>()) { }

private:
    template <unsigned int K>  struct X { };
    template <unsigned int ...I> struct Y { };
    template <typename> struct Z { };

    template <typename U, unsigned int K, unsigned int ...I>
    Foo(X<K>, Y<I...>, Z<U>)
    : Foo(X<K - 1>(),
          Y<I..., std::extent<U>::value>(),
          Z<typename std::remove_extent<U>::type>())
    { }

    template <typename U, unsigned int ...I>
    Foo(X<0>, Y<I...>, Z<U>) 
    : a { I... }
    { }
};

int main()
{
    Foo<char[4][9][1]> x;
    std::cout << x.a << std::endl;
}

出力:

[4, 9, 1]
于 2013-10-30T23:51:39.650 に答える