是否可以实现 std::move-and-clear 功能？

Question

是否可以编写一个函数 move_and_clear 这样， 对于任何 STL 容器：

do_something_with(move_and_clear(container));

相当于：

do_something_with(std::move(container));
container.clear();

?

这是我的第一次尝试，但不起作用。 我想我的类型是正确的 （虽然这个的生产版本可能会洒在一些 std::remove_reference's)，它编译成功， 但它失败或崩溃，因为在它超出范围后访问了临时。

template<class T>
T &&move_and_clear(T &t)
{
    T scratch;
    std::swap(scratch, t);
    return std::move(scratch);
}

这是我的第二次尝试。这确实有效，但它是一个预处理器宏，因此是邪恶的：

template<class T>
T &&move_and_clear_helper(T &t, T &&scratch)
{
    std::swap(scratch, t);
    return std::move(scratch);
}
#define move_and_clear(t) move_and_clear_helper(t, decltype(t)())

我的第三次尝试是另一个同样有效的宏，这次 使用 lambda 而不是命名的辅助函数。 所以它比之前的宏更独立一些， 但也许可读性较差，当然它仍然是邪恶的，因为它是一个宏：

#define move_and_clear(t) \
    [](decltype(t) &tparam, decltype(t) &&scratch){ \
        std::swap(scratch, tparam); \
        return std::move(scratch); \
    }(t, decltype(t)())

这是一个包含我的三个尝试的可编译程序：

/*
    g++ --std=c++11 -W -Wall -g move_and_clear.cc -o move_and_clear1 -DWHICH=1
    g++ --std=c++11 -W -Wall -g move_and_clear.cc -o move_and_clear2 -DWHICH=2
    g++ --std=c++11 -W -Wall -g move_and_clear.cc -o move_and_clear3 -DWHICH=3
    ./move_and_clear1   # assert-fails
    ./move_and_clear2   # succeeds
    ./move_and_clear3   # succeeds
*/

#include <assert.h>
#include <iostream>
#include <memory>
#include <vector>

#if WHICH == 1
    template<class T>
    T &&move_and_clear(T &t)
    {
        T scratch;
        std::swap(scratch, t);
        return std::move(scratch);
    }
#elif WHICH == 2
    template<class T>
    T &&move_and_clear_helper(T &t, T &&scratch)
    {
        std::swap(scratch, t);
        return std::move(scratch);
    }
    #define move_and_clear(t) move_and_clear_helper(t, decltype(t)())
#elif WHICH == 3
    #define move_and_clear(t) \
        [](decltype(t) &tparam, decltype(t) &&scratch){ \
            std::swap(scratch, tparam); \
            return std::move(scratch); \
        }(t, decltype(t)())
#endif

// Example "do_something_with":
// takes an rvalue reference to a vector that must have size 3,
// steals its contents, and leaves it in a valid but unspecified state.
// (Implementation detail: leaves it with 7 elements.)
template<typename T>
void plunder3_and_leave_in_unspecified_state(std::vector<T> &&v)
{
  assert(v.size() == 3);
  std::vector<T> pirate(7);
  assert(pirate.size() == 7);
  std::swap(pirate, v);
  assert(pirate.size() == 3);
  assert(v.size() == 7);
}

int main(int, char**)
{
    {
        std::cout << "Using std::move and clear ..." << std::endl << std::flush;
        std::vector<std::unique_ptr<int>> v(3);
        assert(v.size() == 3);
        plunder3_and_leave_in_unspecified_state(std::move(v));
        assert(v.size() == 7); // (uses knowledge of plunder's impl detail)
        v.clear();
        assert(v.empty());
        std::cout << "done." << std::endl << std::flush;
    }
    {
        std::cout << "Using move_and_clear ..." << std::endl << std::flush;
        std::vector<std::unique_ptr<int>> v(3);
        assert(v.size() == 3);
        plunder3_and_leave_in_unspecified_state(move_and_clear(v));
        assert(v.empty());
        std::cout << "done." << std::endl << std::flush;
    }
}

有没有办法在不使用宏的情况下将 move_and_clear 实现为模板函数？

Answer 1

是否可以编写一个函数 move_and_clear 使得对于任何 STL 容器：

do_something_with(move_and_clear(container));

相当于：

do_something_with(std::move(container));
container.clear();

?

template<typename T>
T move_and_clear(T& data){
     T rtn(std::move(data));
     data.clear();
     return rtn;
}

返回值将在调用站点被视为rvalue。

同样，这将享受 返回值优化（在任何理智的编译器中）的好处。最肯定的是，内联。请参阅Howard Hinnant's answer to this 问题。

---

同样，STL 容器具有移动构造函数，但对于任何其他自定义容器，最好将其限制为 move-constructible 类型。否则，您可以使用不会移动的容器调用它，并且那里有必要的副本。

template<typename T>
auto move_and_clear(T& data)
-> std::enable_if_t<std::is_move_constructible<T>::value, T>
{
     T rtn(std::move(data));
     data.clear();
     return rtn;
}

见：This answer

编辑：

如果您担心 RVO，我不知道任何主要的编译器不会在优化构建中执行 RVO（除非通过开关显式关闭）。还有一个proposal to make it mandatory，希望我们应该在 C++17 中看到它。

EDIT2：

论文进入C++17的工作草案，见this

Answer 2

这是一个不需要额外移动容器的实现，但引入了一个代理对象：

template <class T>
class ClearAfterMove
{
  T &&object;

public:
  ClearAfterMove(T &&object) : object(std::move(object)) {}

  ClearAfterMove(ClearAfterMove&&) = delete;

  ~ClearAfterMove() { object.clear(); }

  operator T&& () const { return std::move(object); }
};


template <class T>
ClearAfterMove<T> move_and_clear(T &t)
{
  return { std::move(t) };
}

它的工作原理是它创建了一个不可移动对象ClearAfterMove，它将包装源容器t，并在它（包装器）超出范围时在t 上调用clear。

在这样的电话中：

do_something_with(move_and_clear(container));

一个临时的ClearAfterMove 对象（我们称之为cam）包装container 将通过调用move_and_clear 创建。然后这个临时值将被其转换运算符转换为右值引用并传递给do_something_with。

临时变量在创建它们的完整表达式结束时超出范围。对于cam，这意味着一旦解决了对do_something_with 的调用，它将被销毁，这正是您想要的。

请注意，这样做的优点是不会产生任何额外的移动，而所有代理对象解决方案都有一个缺点：它不能很好地使用类型推导，例如：

auto x = move_and_clear(y);

Answer 3

template<class T>
T &&move_and_clear(T &t)
{
  T scratch;
  std::swap(scratch, t);
  return std::move(scratch);
}

这很接近。但是你输入了很多：

template<class T>
T move_and_clear(T &t)
{
  T scratch;
  std::swap(scratch, t);
  return scratch;
}

scratch 将与返回值一起被省略（除非有人设置恶意编译器标志）。

略有改进：

template<class T>
T move_and_clear(T &t)
{
  T scratch;
  using std::swap;
  swap(scratch, t);
  return scratch;
}

启用 Koenig 查找 swap，这意味着如果有人在他们的容器上编写了一个比 std::swap 更有效的免费 swap 操作，它将被调用。

---

现在，在实践中，std 容器的成功移动将清除它。当 SSO（小字符串优化）处于活动状态时，唯一不清除源容器甚至有点意义的情况是 std::basic_string，并且清除所需的工作量非常小，我看不到库编写者不这样做为了理智起见。

但是，带有交换的这段代码保证源对象将具有T 类型的空对象的状态。

请注意，这不适用于所有可能的 C++ 实现：

template<class T>
T move_and_clear(T &t)
{
  T scratch = std::move(t);
  return scratch;
}

对于大多数std容器，对move-construction的要求比较严格，迭代器必须要迁移。迭代器转移意味着在实践中必须清源。

然而，在std::basic_string 上，由于小字符串优化，迭代器不必传输。我知道不能保证源 basic_string 将被清除（但我很容易出错：标准中可能有一个条款明确要求：它只是不被操作的其他语义所暗示）。

Answer 4

std::move 被定义为移动内容，因此源容器将被有效地清除。

^{（或者我可能误解了你的问题）}