initializer_list e mover semântica

Posso mover elementos de um 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?
    }
}

Uma vez que std::intializer_list<T>requer atenção especial do compilador e não tem semântica de valor como os contêineres normais da biblioteca padrão C ++, prefiro prevenir do que remediar e perguntar.

Não, isso não funcionará como planejado; você ainda receberá cópias. Estou bastante surpreso com isso, pois pensei que initializer_listexistia para manter uma série de temporários até que eles movemorressem.

begine endpara initializer_listretorno const T *, então o resultado de moveem seu código é T const &&- uma referência rvalue imutável. Essa expressão não pode ser mudada de forma significativa. Ele será vinculado a um parâmetro de função do tipo T const &porque rvalues ​​se vinculam a referências const lvalue, e você ainda verá a semântica de cópia.

Provavelmente a razão para isso é que o compilador pode optar por fazer initializer_listuma constante inicializada estaticamente, mas parece que seria mais limpo fazer seu tipo initializer_listou const initializer_lista critério do compilador, então o usuário não sabe se deve esperar um constou mutável resultado de begine end. Mas isso é apenas meu pressentimento, provavelmente há um bom motivo para estar errado.

Atualização: eu escrevi uma proposta ISO para initializer_listsuporte de tipos apenas de movimento. É apenas um primeiro rascunho e ainda não foi implementado em lugar nenhum, mas você pode ver para mais análises do problema.

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

Não da maneira que você pretende. Você não pode mover um constobjeto. E std::initializer_listapenas fornece constacesso aos seus elementos. Portanto, o tipo de ité const T *.

Sua tentativa de ligar std::move(*it)resultará apenas em um valor l. IE: uma cópia.

std::initializer_listfaz referência à memória estática . É para isso que serve a aula. Você não pode se mover da memória estática, porque o movimento implica em mudá-la. Você só pode copiar dele.

Isso não funcionará como declarado, porque list.begin()tem tipo const T *e não há como mover de um objeto constante. Os designers da linguagem provavelmente fizeram isso para permitir que as listas de inicializadores contivessem, por exemplo, constantes de string, das quais seria inadequado mover.

No entanto, se você estiver em uma situação em que sabe que a lista de inicializadores contém expressões rvalue (ou deseja forçar o usuário a escrevê-las), existe um truque que fará com que funcione (fui inspirado pela resposta de Sumant para isso, mas a solução é muito mais simples do que essa). Você precisa que os elementos armazenados na lista do inicializador não sejam Tvalores, mas sim valores que encapsulam T&&. Então, mesmo que esses próprios valores sejam constqualificados, eles ainda podem recuperar um rvalue modificável.

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
};

Agora, em vez de declarar um initializer_list<T>argumento, você declara um initializer_list<rref_capture<T> >argumento. Aqui está um exemplo concreto, envolvendo um vetor de std::unique_ptr<int>ponteiros inteligentes, para o qual apenas a semântica de movimento é definida (portanto, esses objetos nunca podem ser armazenados em uma lista de inicializadores); ainda assim, a lista de inicializadores abaixo compila sem problemas.

#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;
}

Uma pergunta precisa de uma resposta: se os elementos da lista de inicializadores devem ser prvalues ​​verdadeiros (no exemplo, são valores x), a linguagem garante que o tempo de vida dos temporários correspondentes se estenda até o ponto em que são usados? Francamente, não acho que a seção 8.5 relevante da norma trate desse assunto. No entanto, lendo 1.9: 10, parece que a expressão completa relevante em todos os casos engloba o uso da lista de inicializadores, então eu acho que não há perigo de referências rvalue penduradas.

Achei que seria instrutivo oferecer um ponto de partida razoável para uma solução alternativa.

Comentários embutidos.

#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));
}

Parece não permitido no padrão atual como já respondido . Aqui está outra solução alternativa para alcançar algo semelhante, definindo a função como variável em vez de obter uma lista de inicializadores.

#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;
}

Os modelos de variáveis ​​podem manipular referências de valor r apropriadamente, ao contrário de initializer_list.

Neste código de exemplo, usei um conjunto de pequenas funções auxiliares para converter os argumentos variados em um vetor, para torná-lo semelhante ao código original. Mas é claro que você pode escrever uma função recursiva com modelos variadic diretamente.

Eu tenho uma implementação muito mais simples que faz uso de uma classe de invólucro que atua como uma tag para marcar a intenção de mover os elementos. Este é um custo de tempo de compilação.

A classe wrapper é projetada para ser usada da maneira como std::moveé usada, apenas substitua std::movepor move_wrapper, mas isso requer C ++ 17. Para especificações mais antigas, você pode usar um método de construtor adicional.

Você precisará escrever métodos / construtores de construtor que aceitem classes de invólucro dentro initializer_liste mover os elementos de acordo.

Se você precisar que alguns elementos sejam copiados em vez de movidos, construa uma cópia antes de passá-la para initializer_list.

O código deve ser autodocumentado.

#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)
}

Em vez de usar um std::initializer_list<T>, você pode declarar seu argumento como uma referência de array rvalue:

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

Veja o exemplo usando std::unique_ptr<int>: https://gcc.godbolt.org/z/2uNxv6

Considere o in<T>idioma descrito em cpptruths . A idéia é determinar lvalue / rvalue em tempo de execução e então chamar move ou copy-construction. in<T>irá detectar rvalue / lvalue mesmo que a interface padrão fornecida por initializer_list seja uma referência const.