Std:: make_tuple не делает ссылок

Я экспериментировал с std::tuple в сочетании со ссылками:

#include <iostream>
#include <tuple>

int main() {
  int a,b;
  std::tuple<int&,int&> test(a,b);
  std::get<0>(test) = 1;
  std::get<1>(test) = 2;
  std::cout << a << ":" << b << std::endl;

  // doesn't make ref, not expected
  auto test2 = std::make_tuple(a,b);
  std::get<0>(test2) = -1;
  std::get<1>(test2) = -2;
  std::cout << a << ":" << b << std::endl;

  int &ar=a;
  int &br=b;
  // why does this not make a tuple of int& references? can we force it to notice?
  auto test3 = std::make_tuple(ar,br);
  std::get<0>(test3) = -1;
  std::get<1>(test3) = -2;
  std::cout << a << ":" << b << std::endl;
}

Из трех примеров здесь первые два работают так, как ожидалось. Третий, однако, этого не делает. Я ожидал, что тип auto (test3) будет таким же, как тип test (т.е. std::tuple<int&,int&>).

Кажется, что std::make_tuple не может автоматически создавать кортежи ссылок. Почему нет? Что я могу сделать, чтобы сделать это, за исключением явного создания чего-то такого типа?

(Компилятор был g++ 4.4.5, используя 4.5 не меняет его)

Ответы

Ответ 1

Попробуйте forward_as_tuple:

auto test3 = std::forward_as_tuple(ar,br);

Ответ 2

std::tie делает ссылки не const.

auto ref_tuple = std::tie(a,b); // decltype(ref_tuple) == std::tuple<int&, int&>

Для ссылок const вам понадобится функция обертки std::cref:

auto cref_tuple = std::make_tuple(std::cref(a), std::cref(b));

Или используйте простой помощник as_const для определения переменных перед передачей их в std::tie:

template<class T>
T const& as_const(T& v){ return v; }

auto cref_tuple = std::tie(as_const(a), as_const(b));

Или, если вы хотите получить фантазию, напишите свой собственный ctie (повторное использование std::tie и as_const):

template<class... Ts>
std::tuple<Ts const&...> ctie(Ts&... vs){
  return std::tie(as_const(vs)...);
}

auto cref_tuple = ctie(a, b);

Ответ 3

Как насчет:

auto test3 = std::make_tuple(std::ref(a),std::ref(b));

Ответ 4

Для чего: make_tuple параметры передаются с помощью ссылки const (const T&), поэтому, если вы пройдете int&, T соответствует int. Если бы значение T было int&, то параметр был бы const T&&, и вы получили бы ошибку компиляции.

Ответ 5

В С++ 14 вы можете продолжить следующее:

template<typename ...T, size_t... I>
auto make_rtuple_helper(std::tuple<T...>& t ,  std::index_sequence<I...>)
-> std::tuple<T&...>
{ return std::tie(std::get<I>(t)...) ;}

template<typename ...T>
std::tuple<T&...> make_rtuple( std::tuple<T...>& t )
{
    return make_rtuple_helper( t, std::make_index_sequence<sizeof...(T)>{});
}

Посмотрите, как он работает здесь, в coliru: http://coliru.stacked-crooked.com/a/a665130e17fd8bcc

Приветствия A.A.

Ответ 6

Как насчет std::make_tuple<int&, int&>(a, b);

По общему признанию, это отчасти поражает цель, но для таких функций, как make_shared, вы по-прежнему получаете преимущества.

Предупреждение, я не пытался скомпилировать это, но я считаю, что это сработает.