16

私のクラスが欲しい

template <class T, unsigned int n>
class X;

タイプの時間std::tupleを含むを作成します。これには特にきちんとした方法がありますか？任意の可変個引数テンプレート クラスに対してこれを行う良い方法はありますか?nT

これは私が最初にしたことです：

#include <tuple>

template <class, unsigned int, class>
struct simple_repeat_helper;

template <class T, unsigned int n, class... Args>
struct simple_repeat_helper<T, n, std::tuple<Args...>>
{
    typedef typename simple_repeat_helper<T, n-1, std::tuple<Args..., T>>::type type;
};

template <class T, class... Args>
struct simple_repeat_helper<T, 0, std::tuple<Args...>>
{
    typedef std::tuple<Args...> type;
};

template <class T, unsigned int n>
struct simple_repeat
{
    using type = typename simple_repeat_helper<T, n, std::tuple<>>::type;
};

しかし、実際には、これは必要ありませんが、std::tuple同様に機能する別のクラスには必要です。そこで、もう少し一般的なバージョンを作成しようと考えました。

template <class, unsigned int, template <class...> class, class>
struct repeat_helper;

template <class T, template <class...> class M, class... Args>
struct repeat_helper<T, 0, M, M<Args...>>
{
    typedef M<Args...> type;
};

template <class T, unsigned int n, template <class...> class M, class... Args>
struct repeat_helper<T, n, M, M<Args...>>
{
    typedef typename repeat_helper<T, n-1, M, M<Args..., T>>::type type;
};

template <class T, unsigned int n, template <class...> class M = std::tuple>
struct repeat
{
    using type = typename repeat_helper<T, n, M, M<>>::type;
};

私は次のように使用できると考えました：

repeat<double, 5, std::tuple>::type x = std::make_tuple( 1., 2., 3., 4., 5. );

残念ながら、次の理由でコンパイルに失敗します。

ambiguous class template instantiation for ‘struct repeat_helper<double, 0u, std::tuple, std::tuple<double, double, double, double, double> >’

このエラーに関するヘルプをいただければ幸いです。

4

2 に答える 2

10

インデックスベースのソリューション:

template<typename Dependent, int Index>
using DependOn = Dependent;

// Assuming e.g. Indices<3> is indices<0, 1, 2>
template<typename T, int N, typename I = Indices<N>>
struct repeat;

template<typename T, int N, int... Indices>
struct repeat<T, N, indices<Indices...>> {
    // Can be an actual type-list instead of (ab)using std::tuple
    using type = std::tuple<DependOn<T, Indices>...>;
};

C++14 フレーバー:

template<typename Dependent, std::size_t Index>
using DependOn = Dependent;

template<typename T, std::size_t N, typename Indices = std::make_index_sequence<N>>
struct repeat;

template<typename T, std::size_t N, std::size_t... Indices>
struct repeat<T, N, std::index_sequence<Indices...>> {
    using type = std::tuple<DependOn<T, Indices>...>;
};
于 2013-05-31T09:16:27.227 に答える
10

私はこのようにします：

template<typename, typename>
struct append_to_type_seq { };

template<typename T, typename... Ts, template<typename...> class TT>
struct append_to_type_seq<T, TT<Ts...>>
{
    using type = TT<Ts..., T>;
};

template<typename T, unsigned int N, template<typename...> class TT>
struct repeat
{
    using type = typename
        append_to_type_seq<
            T,
            typename repeat<T, N-1, TT>::type
            >::type;
};

template<typename T, template<typename...> class TT>
struct repeat<T, 0, TT>
{
    using type = TT<>;
};

小さなテストとして：

#include <type_traits>
#include <tuple>

template<typename... Ts>
struct X { };

int main()
{
    repeat<double, 5, std::tuple>::type t = std::make_tuple(1., 2., 3., 4., 5.);
    static_assert(
        std::is_same<
            decltype(t),
            std::tuple<double, double, double, double, double>
        >::value, "!");

    repeat<double, 3, X>::type y;
    static_assert(
        std::is_same<decltype(y), X<double, double, double>>::value, "!");
}

最後に、実際の例です。

于 2013-05-31T09:12:01.767 に答える