Можно ли инициализировать списком вектор типа только для перемещения? - PullRequest
Новая
       44

Можно ли инициализировать списком вектор типа только для перемещения?

86 голосов
/ 12 декабря 2011

Если я передаю следующий код через мой снимок GCC 4.7, он пытается скопировать unique_ptr s в вектор. 

#include <vector>
#include <memory>

int main() {
    using move_only = std::unique_ptr<int>;
    std::vector<move_only> v { move_only(), move_only(), move_only() };
}

Очевидно, что это не может работать, потому что std::unique_ptr не копируется:

ошибка: использование удаленной функции 'std :: unique_ptr <_Tp, _Dp> :: unique_ptr (const std :: unique_ptr <_Tp, _Dp> &) [with _Tp = int;_Dp = std :: default_delete;std :: unique_ptr <_Tp, _Dp> = std :: unique_ptr] '

Правильно ли GCC при попытке скопировать указатели из списка инициализаторов?

Ответы [ 5 ]

56 голосов
/ 12 декабря 2011

Редактировать: Поскольку @Johannes, похоже, не хочет публиковать лучшее решение в качестве ответа, я просто сделаю это. 

#include <iterator>
#include <vector>
#include <memory>

int main(){
  using move_only = std::unique_ptr<int>;
  move_only init[] = { move_only(), move_only(), move_only() };
  std::vector<move_only> v{std::make_move_iterator(std::begin(init)),
      std::make_move_iterator(std::end(init))};
}

Итераторы, возвращенные std::make_move_iterator будет перемещать указательный элемент при разыменовании.

Оригинальный ответ: Здесь мы будем использовать маленький вспомогательный тип: 

#include <utility>
#include <type_traits>

template<class T>
struct rref_wrapper
{ // CAUTION - very volatile, use with care
  explicit rref_wrapper(T&& v)
    : _val(std::move(v)) {}

  explicit operator T() const{
    return T{ std::move(_val) };
  }

private:
  T&& _val;
};

// only usable on temporaries
template<class T>
typename std::enable_if<
  !std::is_lvalue_reference<T>::value,
  rref_wrapper<T>
>::type rref(T&& v){
  return rref_wrapper<T>(std::move(v));
}

// lvalue reference can go away
template<class T>
void rref(T&) = delete;

К сожалению, простой код здесь не будет работать: 

std::vector<move_only> v{ rref(move_only()), rref(move_only()), rref(move_only()) };

Поскольку стандарт по какой-либо причине не определяет конструктор конвертирующего копирования, подобный этому: 

// in class initializer_list
template<class U>
initializer_list(initializer_list<U> const& other);

initializer_list<rref_wrapper<move_only>>, созданный brace-init-list ({...}), не преобразуется в initializer_list<move_only>, который принимает vector<move_only>.Итак, нам нужна двухэтапная инициализация здесь: 

std::initializer_list<rref_wrapper<move_only>> il{ rref(move_only()),
                                                   rref(move_only()),
                                                   rref(move_only()) };
std::vector<move_only> v(il.begin(), il.end());
42 голосов
/ 12 декабря 2011

Сводка <initializer_list> в 18.9 достаточно ясно показывает, что элементы списка инициализатора всегда передаются через const-reference.К сожалению, в текущей редакции языка, похоже, нет никакого способа использовать семантику перемещения в элементах списка инициализатора.

В частности, мы имеем: 

typedef const E& reference;
typedef const E& const_reference;

typedef const E* iterator;
typedef const E* const_iterator;

const E* begin() const noexcept; // first element
const E* end() const noexcept; // one past the last element
8 голосов
/ 10 ноября 2015

Как упоминалось в других ответах, поведение std::initializer_list заключается в том, чтобы удерживать объекты по значению и не разрешать их перемещение, поэтому это невозможно. Вот один из возможных обходных путей, использующий вызов функции, в котором инициализаторы задаются как переменные аргументы: 

#include <vector>
#include <memory>

struct Foo
{
    std::unique_ptr<int> u;
    int x;
    Foo(int x = 0): x(x) {}
};

template<typename V>        // recursion-ender
void multi_emplace(std::vector<V> &vec) {}

template<typename V, typename T1, typename... Types>
void multi_emplace(std::vector<V> &vec, T1&& t1, Types&&... args)
{
    vec.emplace_back( std::move(t1) );
    multi_emplace(vec, args...);
}

int main()
{
    std::vector<Foo> foos;
    multi_emplace(foos, 1, 2, 3, 4, 5);
    multi_emplace(foos, Foo{}, Foo{});
}

К сожалению, multi_emplace(foos, {}); терпит неудачу, так как не может определить тип для {}, поэтому для создания объектов по умолчанию необходимо повторить имя класса. (или используйте vector::resize)

0 голосов
/ 21 марта 2017

Используя трюк Йоханнеса Шауба std::make_move_iterator() с std::experimental::make_array(), вы можете использовать вспомогательную функцию: 

#include <memory>
#include <type_traits>
#include <vector>
#include <experimental/array>

struct X {};

template<class T, std::size_t N>
auto make_vector( std::array<T,N>&& a )
    -> std::vector<T>
{
    return { std::make_move_iterator(std::begin(a)), std::make_move_iterator(std::end(a)) };
}

template<class... T>
auto make_vector( T&& ... t )
    -> std::vector<typename std::common_type<T...>::type>
{
    return make_vector( std::experimental::make_array( std::forward<T>(t)... ) );
}

int main()
{
    using UX = std::unique_ptr<X>;
    const auto a  = std::experimental::make_array( UX{}, UX{}, UX{} ); // Ok
    const auto v0 = make_vector( UX{}, UX{}, UX{} );                   // Ok
    //const auto v1 = std::vector< UX >{ UX{}, UX{}, UX{} };           // !! Error !!
}

Смотрите его вживую на Coliru .

Возможно, кто-то может использовать хитрость std::make_array(), чтобы позволить make_vector() делать свое дело напрямую, но я не видел, как (точнее, я попробовал то, что, по моему мнению, должно работать, провалилось и пошел дальше).).В любом случае, компилятор должен иметь возможность встроить преобразование массива в вектор, как это делает Clang с O2 на GodBolt .

0 голосов
/ 15 мая 2013

Как уже указывалось, невозможно инициализировать вектор типа только для перемещения со списком инициализаторов.Решение, изначально предложенное @Johannes, прекрасно работает, но у меня есть другая идея ... Что если мы не создадим временный массив, а затем не переместим элементы в вектор, а используем размещение new, чтобы инициализировать этот массив ужеместо блока памяти вектора?

Вот моя функция для инициализации вектора unique_ptr с использованием пакета аргументов: 

#include <iostream>
#include <vector>
#include <make_unique.h>  /// @see /5759297/makeunique-i-idealnaya-peresylka

template <typename T, typename... Items>
inline std::vector<std::unique_ptr<T>> make_vector_of_unique(Items&&... items) {
    typedef std::unique_ptr<T> value_type;

    // Allocate memory for all items
    std::vector<value_type> result(sizeof...(Items));

    // Initialize the array in place of allocated memory
    new (result.data()) value_type[sizeof...(Items)] {
        make_unique<typename std::remove_reference<Items>::type>(std::forward<Items>(items))...
    };
    return result;
}

int main(int, char**)
{
    auto testVector = make_vector_of_unique<int>(1,2,3);
    for (auto const &item : testVector) {
        std::cout << *item << std::endl;
    }
}
...