Можно ли инициализировать список типа только для перемещения?
Если я передаю следующий код через мой снимок GCC 4.7, он пытается скопировать unique_ptrс в вектор.
#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 при попытке скопировать указатели из списка инициализаторов?
8 ответов
Синопсис <initializer_list> в 18.9 достаточно ясно сказано, что элементы списка инициализатора всегда передаются через const-ссылку. К сожалению, в текущей версии языка не существует никакого способа использования семантики перемещения в элементах списка инициализатора.
В частности, у нас есть:
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
Изменить: Поскольку @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>> созданный списком фигурных скобок ({...}) не будет преобразован в 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());
Как уже упоминалось в других ответах, поведение 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)
Используя трюк Йоханнеса Шауба 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 !!
}
Посмотри вживую на Колиру.
Возможно, кто-то может использовать std::make_array() Хитрость чтобы позволить make_vector() сделать свое дело напрямую, но я не видел как (точнее, я попробовал то, что, по моему мнению, должно работать, потерпел неудачу и пошел дальше). В любом случае, компилятор должен иметь возможность встроить преобразование массива в вектор, как это делает Clang с O2 на GodBolt.
Это решение мне нравится больше всего.
С++17 версия
#include <vector>
#include <memory>
template <typename T, typename ...Args>
std::vector<T> BuildVectorFromMoveOnlyObjects(Args&&... args) {
std::vector<T> container;
container.reserve(sizeof...(Args));
((container.emplace_back(std::forward<Args>(args))), ...);
return container;
}
int main() {
auto vec = BuildVectorFromMoveOnlyObjects<std::unique_ptr<int>>(
std::make_unique<int>(10),
std::make_unique<int>(50));
}
Немного уродливая версия C++11
template <typename T, typename ...Args>
std::vector<T> BuildVectorFromMoveOnlyObjects(Args&&... args) {
std::vector<T> container;
using expander = int[];
(void)expander{0, (void(container.emplace_back(std::forward<Args>(args))), 0)... };
return container;
}
Я сделал небольшую библиотеку для этой цели.
#include <better_braces.hpp>
#include <iostream>
#include <memory>
#include <vector>
int main()
{
std::vector<std::unique_ptr<int>> foo = init{nullptr, std::make_unique<int>(42)};
std::cout << foo.at(0) << '\n'; // 0
std::cout << foo.at(1) << " -> " << *foo.at(1) << '\n'; // 0x602000000010 -> 42
}
в отличие отmove_iteratorподход, это не обязательно перемещает каждый элемент.nullptrвстраивается непосредственно в вектор, без построения промежуточногоstd::unique_ptr.
Это позволяет ему работать даже с неподвижными типами :
std::vector<std::atomic_int> bar = init{1, 2, 3};
Попытка простого ответа по существу для остальных из нас.
Вы не можете. Оно сломано.
К счастью, инициализаторы массива не сломаны.
static std::unique_ptr<SerializerBase> X::x_serializers[] = {
std::unique_ptr<SerializerBase>{
new Serializer<X,int>("m_int",&X::m_int)
},
std::unique_ptr<SerializerBase>{
new Serializer<X,double>("m_double",&X::m_double)
},
nullptr, // lol. template solutions from hell possible here too.
};
Если затем вы захотите использовать этот массив для инициализации , существует бесконечное количество способов сделать это, многие из которых включают в себя причудливо неприятное метапрограммирование шаблонов, и все это можно избежать с помощью цикла for.
К счастью, использование массива вместо std::vector работает во многих случаях, когда вы действительно предпочли бы использовать std::vector.
В качестве альтернативы рассмотрите возможность написания
custom::static_vector<T>класс, который берет
T*находится в списке инициализаторов и удаляет их в своем деструкторе. Тоже не в восторге, но нужно смириться с тем, что
std::vector<std::unique_ptr<T>>не собирается работать в разумные сроки или с разумными усилиями. Вы можете просто удалить любые методы, которые потенциально перемещаются (перемещают и копируют конструкторы,
T&operator[]()и с). Или проявите фантазию и реализуйте рудиментарную семантику ходов, если вам нужно (но вы, вероятно, этого не сделаете).
См. [1] для защиты этого, предоставленного членам пуристского духовенства.
[1] Предполагается, что языки программирования повышают производительность. Метапрограммирование шаблонов в данном случае не делает этого. Все, что мне нужно, — это способ гарантировать, что память, выделенная при статической инициализации, не попадет в кучу, что сделает невозможным использование valgrind для проверки отсутствия утечки памяти.
Это повседневный вариант использования. И это не должно быть сложно. Делая это удаленно сложным, вы только срезаете путь.
Как было указано, невозможно инициализировать вектор типа "только для перемещения" списком инициализаторов. Решение, изначально предложенное @Johannes, прекрасно работает, но у меня есть другая идея... Что если мы не создадим временный массив, а затем переместим элементы оттуда в вектор, но используем размещение new инициализировать этот массив уже вместо блока памяти вектора?
Вот моя функция для инициализации вектора unique_ptrиспользует пакет аргументов:
#include <iostream>
#include <vector>
#include <make_unique.h> /// @see http://stackru.com/questions/7038357/make-unique-and-perfect-forwarding
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;
}
}