5

タプルに似たものを作成しようとしていますが、コンストラクターを書く際に問題が発生しました。

コードは次のとおりです。

#include <tuple>

template <typename... Ts>
struct B {
    template <typename... ArgTypes>
    explicit B(ArgTypes&&... args)
    {
        static_assert(sizeof...(Ts) == sizeof...(ArgTypes),
            "Number of arguments does not match.");
    }
};

struct MyType {
    MyType() = delete;
    MyType(int x, const char* y) {}
};

int main()
{
   B         <int, char>               a{2, 'c'};                      // works
   B         <int, bool, MyType, char> b{2, false, {4, "blub"}, 'c'};  // fails
   std::tuple<int, bool, MyType, char> t{2, false, {4, "blub"}, 'c'};  // works
}

これで、単純な型を初期化子として渡すと問題なく動作しますが、非自明なオブジェクトの波括弧で囲まれた初期化子リストに引数を渡そうとするとうまくいきません。

GCC-4.7 は以下を発行します。

vararg_constr.cpp:21:67: error: no matching function for call to 'B<int, bool, MyType, char>::B(<brace-enclosed initializer list>)'
vararg_constr.cpp:21:67: note: candidates are:
vararg_constr.cpp:6:14: note: B<Ts>::B(ArgTypes&& ...) [with ArgTypes = {}; Ts = {int, bool, MyType, char}]
vararg_constr.cpp:6:14: note:   candidate expects 0 arguments, 4 provided

Clang-3.1 以下:

vararg_constr.cpp:21:40: error: no matching constructor for initialization of
      'B<int, bool, MyType, char>'
   B         <int, bool, MyType, char> b{2, false,{4, "blub"}, 'c'};  // fails
                                       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
vararg_constr.cpp:6:14: note: candidate constructor not viable: requires 2
      arguments, but 4 were provided
    explicit B(ArgTypes&&... args)

さて、私が非常に興味を持っているのは、それがタプルで機能することです! 標準 (20.4.2.1) によると、コンストラクターがあり、それは私のものとほとんど同じです。

template <class... Types>
class tuple {
public:
    // ...

    template <class... UTypes>
    explicit tuple(UTypes&&...);

    // ...
};

同じようにタプルオブジェクトを構築すると、うまくいきます！

今私は知りたいです：

A) 一体何？std::tuple が特別なのはなぜですか? また、コンパイラが正しい数の引数を推測しないのはなぜですか?

B）どうすればこれを機能させることができますか？

4

1 に答える 1

6

A) コンパイラは、それ{4, "blub"}が MyType 型であり、型ではないことを認識しなければならないのはなぜtuple<int, const char*>ですか?

B) コンストラクターで ArgTypes を Ts に変更します。

explicit B(Ts&&... args)

Tuple には次のコンストラクタもあります。

  explicit constexpr tuple(const _Elements&... __elements);

編集:要点は、 const& を持つコンストラクターが呼び出され、R-Values では呼び出されないことです。次の点を考慮してください。

template <typename... Ts>
struct B {
  explicit B(const Ts&... elements) { std::cout << "A\n"; }
  template<typename... As,
           typename = typename std::enable_if<sizeof...(As) == sizeof...(Ts)>::type>
  explicit B(As&&... elements) { std::cout << "B\n" ;}
};

int main()
{
  MyType m {1, "blub"};
  B<int, char>           a{2, 'c'};                            // prints B
  B<bool, MyType, char>  b{false, {4, "blub"}, 'c'};           // prints A
  B<bool, MyType, MyType>c{false, {4, "blub"}, std::move(m)};  // prints A
}
于 2012-03-03T21:47:54.650 に答える