initializer_list dan pindahkan semantik

Apakah saya diperbolehkan untuk memindahkan elemen dari a std::initializer_list<T>?

#include <initializer_list>
#include <utility>

template<typename T>
void foo(std::initializer_list<T> list)
{
    for (auto it = list.begin(); it != list.end(); ++it)
    {
        bar(std::move(*it));   // kosher?
    }
}

Karena std::intializer_list<T>memerlukan perhatian compiler khusus dan tidak memiliki nilai semantik seperti container normal dari pustaka standar C ++, saya lebih suka aman daripada menyesal dan bertanya.

Tidak, itu tidak akan berfungsi sebagaimana mestinya; Anda masih akan mendapatkan salinannya. Saya cukup terkejut dengan ini, karena saya pikir yang initializer_listada untuk menyimpan sejumlah temporer sampai mereka movemati.

begindan endsebagai initializer_listgantinya const T *, jadi hasil dari movekode Anda adalah T const &&- referensi nilai r yang tidak dapat diubah. Ekspresi seperti itu tidak dapat dipindahkan secara berarti. Ini akan mengikat ke parameter fungsi bertipe T const &karena nilai r memang mengikat ke referensi nilai konstanta, dan Anda masih akan melihat semantik salin.

Mungkin alasannya adalah agar kompiler dapat memilih untuk membuat initializer_listkonstanta yang diinisialisasi secara statis, tetapi tampaknya akan lebih bersih untuk membuat tipenya initializer_listatau const initializer_listatas kebijaksanaan kompiler, sehingga pengguna tidak tahu apakah mengharapkan constatau bisa berubah hasil dari begindan end. Tapi itu hanya firasat saya, mungkin ada alasan bagus mengapa saya salah.

Pembaruan: Saya telah menulis proposal ISO untuk initializer_listdukungan tipe bergerak-saja. Ini hanya draf pertama, dan belum diterapkan di mana pun, tetapi Anda dapat melihatnya untuk analisis masalah lebih lanjut.

bar(std::move(*it));   // kosher?

Tidak seperti yang Anda inginkan. Anda tidak dapat memindahkan constobjek. Dan std::initializer_listhanya menyediakan constakses ke elemennya. Jadi jenis ityaitu const T *.

Upaya Anda untuk menelepon std::move(*it)hanya akan menghasilkan nilai l. YAITU: salinan.

std::initializer_listreferensi memori statis . Itulah tujuan kelas. Anda tidak dapat berpindah dari memori statis, karena gerakan berarti mengubahnya. Anda hanya dapat menyalin darinya.

Ini tidak akan berfungsi seperti yang dinyatakan, karena list.begin()memiliki tipe const T *, dan tidak mungkin Anda dapat berpindah dari objek konstan. Perancang bahasa mungkin membuatnya sedemikian rupa untuk memungkinkan daftar penginisialisasi berisi, misalnya konstanta string, yang darinya tidak pantas untuk dipindahkan.

Namun, jika Anda berada dalam situasi di mana Anda tahu bahwa daftar penginisialisasi berisi ekspresi rvalue (atau Anda ingin memaksa pengguna untuk menuliskannya) maka ada trik yang akan membuatnya bekerja (saya terinspirasi oleh jawaban Sumant untuk ini, tetapi solusinya jauh lebih sederhana dari yang itu). Anda memerlukan elemen yang disimpan dalam daftar penginisialisasi bukan Tnilai, tetapi nilai yang merangkum T&&. Kemudian, meskipun nilai itu sendiri constmemenuhi syarat, mereka masih dapat mengambil rvalue yang dapat dimodifikasi.

template<typename T>
  class rref_capture
{
  T* ptr;
public:
  rref_capture(T&& x) : ptr(&x) {}
  operator T&& () const { return std::move(*ptr); } // restitute rvalue ref
};

Sekarang, alih-alih mendeklarasikan initializer_list<T>argumen, Anda mendeklarasikan initializer_list<rref_capture<T> >argumen. Berikut adalah contoh konkret, yang melibatkan vektor std::unique_ptr<int>pointer pintar, yang hanya mendefinisikan semantik bergerak (jadi objek ini sendiri tidak akan pernah bisa disimpan dalam daftar penginisialisasi); namun daftar penginisialisasi di bawah ini dapat dikompilasi tanpa masalah.

#include <memory>
#include <initializer_list>
class uptr_vec
{
  typedef std::unique_ptr<int> uptr; // move only type
  std::vector<uptr> data;
public:
  uptr_vec(uptr_vec&& v) : data(std::move(v.data)) {}
  uptr_vec(std::initializer_list<rref_capture<uptr> > l)
    : data(l.begin(),l.end())
  {}
  uptr_vec& operator=(const uptr_vec&) = delete;
  int operator[] (size_t index) const { return *data[index]; }
};

int main()
{
  std::unique_ptr<int> a(new int(3)), b(new int(1)),c(new int(4));
  uptr_vec v { std::move(a), std::move(b), std::move(c) };
  std::cout << v[0] << "," << v[1] << "," << v[2] << std::endl;
}

Satu pertanyaan memang membutuhkan jawaban: jika elemen dari daftar penginisialisasi harus merupakan prvalues ​​yang benar (dalam contoh ini adalah xvalues), apakah bahasa memastikan bahwa masa pakai temporer yang sesuai meluas ke titik di mana mereka digunakan? Sejujurnya, menurut saya bagian 8.5 dari standar yang relevan tidak membahas masalah ini sama sekali. Namun, membaca 1.9: 10, tampaknya ekspresi lengkap yang relevan dalam semua kasus mencakup penggunaan daftar penginisialisasi, jadi saya rasa tidak ada bahaya menggantung referensi nilai r.

Saya pikir mungkin bermanfaat untuk menawarkan titik awal yang masuk akal untuk sebuah solusi.

Komentar sebaris.

#include <memory>
#include <vector>
#include <array>
#include <type_traits>
#include <algorithm>
#include <iterator>

template<class Array> struct maker;

// a maker which makes a std::vector
template<class T, class A>
struct maker<std::vector<T, A>>
{
  using result_type = std::vector<T, A>;

  template<class...Ts>
  auto operator()(Ts&&...ts) const -> result_type
  {
    result_type result;
    result.reserve(sizeof...(Ts));
    using expand = int[];
    void(expand {
      0,
      (result.push_back(std::forward<Ts>(ts)),0)...
    });

    return result;
  }
};

// a maker which makes std::array
template<class T, std::size_t N>
struct maker<std::array<T, N>>
{
  using result_type = std::array<T, N>;

  template<class...Ts>
  auto operator()(Ts&&...ts) const
  {
    return result_type { std::forward<Ts>(ts)... };
  }

};

//
// delegation function which selects the correct maker
//
template<class Array, class...Ts>
auto make(Ts&&...ts)
{
  auto m = maker<Array>();
  return m(std::forward<Ts>(ts)...);
}

// vectors and arrays of non-copyable types
using vt = std::vector<std::unique_ptr<int>>;
using at = std::array<std::unique_ptr<int>,2>;


int main(){
    // build an array, using make<> for consistency
    auto a = make<at>(std::make_unique<int>(10), std::make_unique<int>(20));

    // build a vector, using make<> because an initializer_list requires a copyable type  
    auto v = make<vt>(std::make_unique<int>(10), std::make_unique<int>(20));
}

Sepertinya tidak diperbolehkan dalam standar saat ini karena sudah dijawab . Berikut adalah solusi lain untuk mencapai sesuatu yang serupa, dengan mendefinisikan fungsi sebagai variadic alih-alih mengambil daftar penginisialisasi.

#include <vector>
#include <utility>

// begin helper functions

template <typename T>
void add_to_vector(std::vector<T>* vec) {}

template <typename T, typename... Args>
void add_to_vector(std::vector<T>* vec, T&& car, Args&&... cdr) {
  vec->push_back(std::forward<T>(car));
  add_to_vector(vec, std::forward<Args>(cdr)...);
}

template <typename T, typename... Args>
std::vector<T> make_vector(Args&&... args) {
  std::vector<T> result;
  add_to_vector(&result, std::forward<Args>(args)...);
  return result;
}

// end helper functions

struct S {
  S(int) {}
  S(S&&) {}
};

void bar(S&& s) {}

template <typename T, typename... Args>
void foo(Args&&... args) {
  std::vector<T> args_vec = make_vector<T>(std::forward<Args>(args)...);
  for (auto& arg : args_vec) {
    bar(std::move(arg));
  }
}

int main() {
  foo<S>(S(1), S(2), S(3));
  return 0;
}

Template variadic dapat menangani referensi nilai-r dengan tepat, tidak seperti initializer_list.

Dalam kode contoh ini, saya menggunakan satu set fungsi pembantu kecil untuk mengubah argumen variadic menjadi vektor, agar mirip dengan kode aslinya. Tapi tentu saja Anda bisa menulis fungsi rekursif dengan template variadic secara langsung.

Saya memiliki implementasi yang lebih sederhana yang menggunakan kelas pembungkus yang bertindak sebagai tag untuk menandai maksud pemindahan elemen. Ini adalah biaya waktu kompilasi.

Kelas pembungkus dirancang untuk digunakan dengan cara std::moveyang digunakan, cukup ganti std::movedengan move_wrapper, tetapi ini membutuhkan C ++ 17. Untuk spesifikasi yang lebih lama, Anda dapat menggunakan metode pembuat tambahan.

Anda harus menulis metode / konstruktor pembangun yang menerima kelas pembungkus di dalamnya initializer_listdan memindahkan elemen yang sesuai.

Jika Anda memerlukan beberapa elemen untuk disalin alih-alih dipindahkan, buat salinan sebelum meneruskannya initializer_list.

Kode tersebut harus didokumentasikan sendiri.

#include <iostream>
#include <vector>
#include <initializer_list>

using namespace std;

template <typename T>
struct move_wrapper {
    T && t;

    move_wrapper(T && t) : t(move(t)) { // since it's just a wrapper for rvalues
    }

    explicit move_wrapper(T & t) : t(move(t)) { // acts as std::move
    }
};

struct Foo {
    int x;

    Foo(int x) : x(x) {
        cout << "Foo(" << x << ")\n";
    }

    Foo(Foo const & other) : x(other.x) {
        cout << "copy Foo(" << x << ")\n";
    }

    Foo(Foo && other) : x(other.x) {
        cout << "move Foo(" << x << ")\n";
    }
};

template <typename T>
struct Vec {
    vector<T> v;

    Vec(initializer_list<T> il) : v(il) {
    }

    Vec(initializer_list<move_wrapper<T>> il) {
        v.reserve(il.size());
        for (move_wrapper<T> const & w : il) {
            v.emplace_back(move(w.t));
        }
    }
};

int main() {
    Foo x{1}; // Foo(1)
    Foo y{2}; // Foo(2)

    Vec<Foo> v{Foo{3}, move_wrapper(x), Foo{y}}; // I want y to be copied
    // Foo(3)
    // copy Foo(2)
    // move Foo(3)
    // move Foo(1)
    // move Foo(2)
}

Daripada menggunakan a std::initializer_list<T>, Anda bisa mendeklarasikan argumen Anda sebagai referensi nilai r array:

template <typename T>
void bar(T &&value);

template <typename T, size_t N>
void foo(T (&&list)[N] ) {
   std::for_each(std::make_move_iterator(std::begin(list)),
                 std::make_move_iterator(std::end(list)),
                 &bar);
}

void baz() {
   foo({std::make_unique<int>(0), std::make_unique<int>(1)});
}

Lihat contoh menggunakan std::unique_ptr<int>: https://gcc.godbolt.org/z/2uNxv6

Pertimbangkan in<T>idiom yang dijelaskan di cpptruths . Idenya adalah untuk menentukan lvalue / rvalue pada saat run-time dan kemudian memanggil move atau copy-construction. in<T>akan mendeteksi rvalue / lvalue meskipun antarmuka standar yang disediakan oleh initializer_list adalah referensi const.