Wie wird ein Array mit Bewegung in einer Zeile zugewiesen?

Question

Zum Beispiel

using namespace std; 

array<vector<int>, 3> a; 
vector<int> v0, v1, v2; 

// assign with move 
a[0] = move(v0); 
a[1] = move(v1); 
a[2] = move(v2); 

Wie eine Zeile verwenden, um die Zuordnung wie a = {v0, v1, v2} zu implementieren?

Answer 1

Wenn Sie eine frische std::array, array<vector<int>, 3> a = { move(v0), move(v1), move(v2) } initialisieren würde immer funktionieren, sonst bauen eine temporäre std::array und verwenden Sie dann std::move in <algorithm>:

array<unique_ptr<int>, 3> temp_arr = { move(a), move(b), move(c) }; 
move(begin(temp_arr), end(temp_arr), begin(arr)); 

Answer 2

@ user1899020: Sie bezeichnen dies kann What is std::move(), and when should it be used?

Bitte beachten Sie, dass "move semantics transparent für den Programmierer ausgeführt wird. Verschieben Sie nur eine Umwandlung, um einen Wert von einem Punkt an einen anderen zu übergeben, wo der ursprüngliche lvalue nicht mehr verwendet wird."

So in folgenden Code:

a= {move(v0), move(v1), move(v2)}; 

for(int i=0; i <3; i++) 
{ 
    // Iterate and print values of vector 
    for(int n : a[i]) { 
     std::cout << n << '\n'; 
    } 
} 

**//Code will NOT enter below for loop** 
for (std::vector<int>::const_iterator j= v0.begin(); j != v0.end(); j++) 
    std::cout << *j << ' '; 

Also, wenn Sie die behalten die Werte in ursprünglichen Vektor verwenden möchten,

1. One Möglichkeiten ist: a = {v0, v1, v2};

2. eine andere Art und Weise verwendet werden könnten die Zeiger durch Initialisierung des Arrays wie folgt:

   array<vector<int> *, 3> a = {&v0, &v1, &v2}; 
   

Answer 3

schreiben tuple_assign Funktion:

template <class T> 
using uncvref = std::remove_cv_t<std::remove_reference_t<T>>; 

template <class T, class U, std::size_t...Is> 
void tuple_assign_(T& to, U&& from, std::index_sequence<Is...>) { 
    std::initializer_list<int>{ 
     (std::get<Is>(to) = std::get<Is>(std::forward<U>(from)), 0)... 
    }; 
} 

template <class T, class U, 
    std::size_t TSize = std::tuple_size<uncvref<T>>::value, 
    std::enable_if_t<TSize == std::tuple_size<uncvref<U>>::value, int*> = nullptr> 
T& tuple_assign(T& to, U&& from) { 
    tuple_assign_(to, std::forward<U>(from), std::make_index_sequence<TSize>{}); 
    return to; 
} 

und wickeln die Vektoren mit forward_as_tuple (DEMO):

tuple_assign(a, std::forward_as_tuple(std::move(v0), std::move(v1), std::move(v2)));