이동 전용 유형의 벡터를 나열 초기화 할 수 있습니까?


95

GCC 4.7 스냅 샷을 통해 다음 코드를 전달하면 unique_ptrs를 벡터 에 복사하려고합니다 .

#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가 올바른가요?


Visual Studio 및 그 소리는 같은 동작을 가지고
장 - 사이먼 브로 슈

답변:


46

<initializer_list>18.9 의 개요 는 이니셜 라이저 목록의 요소가 항상 상수 참조를 통해 전달된다는 것을 합리적으로 명확하게합니다. 불행히도 현재 언어 개정판의 이니셜 라이저 목록 요소에서 이동 의미를 사용하는 방법이없는 것 같습니다.

구체적으로 다음과 같습니다.

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

4
cpptruths ( cpptruths.blogspot.com/2013/09/… ) 에 설명 된 in <T> 관용구를 고려하십시오 . 아이디어는 런타임에 lvalue / rvalue를 결정한 다음 move 또는 copy-construction을 호출하는 것입니다. in <T>는 initializer_list에서 제공하는 표준 인터페이스가 const 참조 인 경우에도 rvalue / lvalue를 감지합니다.
Sumant 2013-09-24

3
@Sumant 그렇게 "나에게 관용적"인 것 같지 않습니까? 대신 순수한 UB 아닌가요? 이터레이터뿐만 아니라 기본 요소 자체가 const이므로 잘 구성된 프로그램에서 캐스트 할 수 없습니다.
underscore_d

62

편집 : @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는 역 참조 될 때 pointed-to 요소를 이동합니다.


원래 답변 : 우리는 여기에 작은 도우미 유형을 활용할 것입니다.

#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>>중괄호-INIT-목록 (만든이 {...})가 변환되지 않습니다 initializer_list<move_only>(가) 있다고 vector<move_only>합니다. 따라서 여기에 2 단계 초기화가 필요합니다.

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());

1
아 ... 이것은 std::ref, non 의 rvalue 아날로그입니다 . 라고 불러야 할 수도 있습니다 std::rref.
Kerrek SB 2011

17
자, 나는 이것이 코멘트에 언급되지 않고 남겨 져서는 안된다고 생각합니다 :) move_only m[] = { move_only(), move_only(), move_only() }; std::vector<move_only> v(std::make_move_iterator(m), std::make_move_iterator(m + 3));.
Johannes Schaub-litb

1
@Johannes : 가끔은 저를 피하는 간단한 해결책이 있습니다. 인정해야하는데 move_iterator아직은 신경 쓰지 않았습니다.
Xeo

2
@Johannes : 또한, 왜 대답이 아닌가? :)
Xeo

1
@JohanLundberg : QoI 문제라고 생각하지만 왜 그렇게 할 수 없었는지 모르겠습니다. 예를 들어 VC ++의 stdlib는 반복자 범주를 기반으로 태그를 배포하고 std::distance순방향 또는 더 나은 반복자를 사용하고 std::move_iterator기본 반복기의 범주를 조정합니다. 어쨌든 좋고 간결한 솔루션입니다. 답변으로 게시 하시겠습니까?
Xeo

10

다른 답변에서 언급했듯이의 행동은 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)


4
재귀 적 팩 확장은 더미 배열 쉼표 연산자 해킹으로 대체되어 몇 줄의 코드를 절약 할 수 있습니다
MM

0

Johannes Schaub의 std::make_move_iterator()with with 트릭을 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이 GodBolt.


-1

지적했듯이 이니셜 라이저 목록으로 이동 전용 유형의 벡터를 초기화하는 것은 불가능합니다. @Johannes가 원래 제안한 솔루션은 잘 작동하지만 또 다른 아이디어가 있습니다. 임시 배열을 만든 다음 요소를 벡터로 이동하지 않고 배치 new를 사용 하여 이미이 배열을 초기화하는 경우 벡터의 메모리 블록?

unique_ptr인수 팩을 사용하여의 벡터를 초기화하는 함수는 다음과 같습니다 .

#include <iostream>
#include <vector>
#include <make_unique.h>  /// @see http://stackoverflow.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;
    }
}

끔찍한 생각입니다. 새로운 배치는 망치가 아니라 정밀한 도구입니다. result.data()임의의 메모리에 대한 포인터가 아닙니다. 개체에 대한 포인터 입니다. 그 위에 새로운 물체를 놓을 때 그 불량한 물체는 어떻게되는지 생각해보십시오.
R. Martinho Fernandes

또한 새로운 배치 형태는 실제로 사용할 수 없습니다. stackoverflow.com/questions/8720425/…
R. Martinho Fernandes

@아르 자형. Martinho Fernandes : 새로운 배열 배치가 작동하지 않는다는 점을 지적 해 주셔서 감사합니다. 이제 그게 왜 나쁜 생각인지 알았습니다.
Gart 2013 년
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.