What's the use of `std::tuple<int[N]>`?

Question

Here ( https://stackoverflow.com/a/37550660/34509 ) user @Barry notes in the comment section that you can use std::tuple<int[2]> and that it is not apparently forbidden to instantiate such a type. I have not yet heard about this beast and I wonder what uses it could have, as opposed to storing a int var[2] directly or using std::array<int, 2> .

Reportedly, std::tuple<int[2]> is not copyable, neither movable nor construtable from an int var[2] . What other uses does it have?

Answer 1

I'm pretty sure this is undefined behavior. See the Requires and Returns clause:

tuple.creation-10 and 12 says:

Requires: For all i , U _i shall be the type cv _i tuple< Args i ... > , where cv _i is the (possibly empty) ⁱ th cv-qualifier-seq and Args _i is the parameter pack representing the element types in U _i . Let A _ik be the k _i ^th type in Args _i . For all A _ik the following requirements shall be satisfied: If T _i is deduced as an lvalue reference type, then is_constructible< A ik , cv i A ik &>::value == true , otherwise is_constructible< A ik , cv i A ik &&>::value == true .

Returns: A tuple object constructed by initializing the k _i ^th type element e _ik in e _i ... with get< k i >(std::forward< T i >( tp i )) for each valid k _i and each group e _i in order.

Like Barry says, there's nothing preventing std::tuple<int[2]> t; but trying to do anything with it is likely to cause a hard error in a compiler. Example:

std::tuple<int[2]> t; // fine
std::tuple<int[2]> t{}; // fine

While:

std::tuple<int[2]> a() {
  int a[2] = { 1, 2};
  return std::tuple<int[2]>(a);
}

int main() {
   auto x = a();
   // ...
}

gives errors like:

error: array initializer must be an initializer list
        : _M_head_impl(std::forward<_UHead>(__h)) { }