初始化列表和移动语义

Question

我可以将元素移出 std::initializer_list 吗？

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

由于 std::intializer_list 需要特殊的编译器注意，并且不像 C++ 标准库的普通容器那样具有值语义，因此我宁愿安全，也不愿抱歉并询问。

Answer 1

不，这不会按预期工作；您仍然会得到副本。我对此感到非常惊讶，因为我认为 initializer_list 的存在是为了保留临时数组，直到它们被移动为止。

initializer_list 的 begin 和 end 返回 const T *，因此 move 的结果在您的代码中是 T const && — 一个不可变的右值引用。这样的表达方式无法被有意义地移走。它将绑定到类型 T const & 的函数参数，因为右值确实绑定到 const 左值引用，并且您仍然会看到复制语义。

原因可能是编译器可以选择将 initializer_list 设为静态初始化常量，但将其类型设为 initializer_list 或 constinitializer_list 由编译器自行决定，因此用户不知道是否期望 begin 得到 const 还是可变结果结束。但这只是我的直觉，也许我错了有充分的理由。

更新：我写了 ISO 提案，用于支持仅移动类型的 initializer_list。这只是初稿，尚未在任何地方实现，但您可以查看它以对问题进行更多分析。

Answer 2

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

不是按照你想要的方式。您无法移动 const 对象。并且 std::initializer_list 仅提供对其元素的 const 访问。所以it的类型是const T *。

您尝试调用 std::move(*it) 只会产生左值。即：副本。

std::initializer_list 引用静态内存。这就是课程的目的。你不能从静态内存中移动，因为移动意味着改变它。您只能从中复制。

Answer 3

这不会像所说的那样工作，因为 list.begin() 的类型是 const T *，并且您无法从常量对象移动。语言设计者这样做可能是为了允许初始值设定项列表包含例如字符串常量，从该列表中移动是不合适的。

但是，如果您知道初始值设定项列表包含右值表达式（或者您想强制用户编写这些表达式），那么有一个技巧可以使其工作（我受到 Sumant 的回答的启发）这个，但解决方案比那个简单得多）。您需要存储在初始化列表中的元素不是 T 值，而是封装 T&& 的值。然后，即使这些值本身是 const 限定的，它们仍然可以检索可修改的右值。

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

现在，您不再声明 initializer_list 参数，而是声明 initializer_list 参数。 > 参数。这是一个具体的例子，涉及一个 std::unique_ptr 智能指针向量，仅定义了移动语义（因此这些对象本身永远不能存储在初始值设定项列表中）；但下面的初始化列表编译没有问题。

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

有一个问题确实需要答案：如果初始值设定项列表的元素应该是真正的纯右值（在示例中它们是x值），那么该语言是否确保相应临时变量的生命周期延伸到它们被使用的时间点？坦率地说，我认为该标准的相关第 8.5 节根本没有解决这个问题。然而，阅读 1.9:10，似乎所有情况下相关的完整表达式都包含了初始化列表的使用，所以我认为不存在悬空右值引用的危险。

Answer 4

我认为为解决方法提供合理的起点可能会有所启发。

内嵌评论。

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

Answer 5

您可以将参数声明为数组右值引用，而不是使用 std::initializer_list：

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

请参阅使用 std::unique_ptr 的示例：https://gcc.godbolt.org/z/2uNxv6

Answer 6

当前标准似乎不允许这样做，因为已经回答了。这是实现类似功能的另一种解决方法，通过将函数定义为可变参数而不是采用初始值设定项列表。

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

与initializer_list不同，可变参数模板可以适当地处理右值引用。

在此示例代码中，我使用了一组小辅助函数将可变参数转换为向量，以使其与原始代码相似。但是当然，您可以直接使用可变参数模板编写递归函数。

Answer 7

我有一个更简单的实现，它使用一个包装类，该类充当标记来标记移动元素的意图。这是编译时成本。

包装类被设计为以 std::move 的方式使用，只需将 std::move 替换为 move_wrapper 即可，但是这个需要 C++17。对于较旧的规格，您可以使用额外的构建器方法。

您需要编写接受 initializer_list 内的包装类的构建器方法/构造函数，并相应地移动元素。

如果您需要复制而不是移动某些元素，请在将其传递给 initializer_list 之前构造一个副本。

代码应该是自我记录的。

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

Answer 8

考虑 cpptruths。这个想法是在运行时确定左值/右值，然后调用移动或复制构造。即使initializer_list 提供的标准接口是常量引用，in 也会检测右值/左值。