14

我昨晚睡不着，开始想std::swap。这是熟悉的 C++98 版本：

template <typename T>
void swap(T& a, T& b)
{
    T c(a);
    a = b;
    b = c;
}

如果用户定义的类Foo使用外部资源，这是低效的。常见的成语是提供一种方法void Foo::swap(Foo& other)和一种专业化的std::swap<Foo>. 请注意，这不适用于类模板，因为您不能部分特化函数模板，并且在std命名空间中重载名称是非法的。解决方案是在自己的命名空间中编写一个模板函数，并依靠参数依赖查找来找到它。这严重依赖于客户端遵循“using std::swap成语”而不是std::swap直接调用。很脆。

在 C++0x 中，如果Foo具有用户定义的移动构造函数和移动赋值运算符，提供自定义swap方法和std::swap<Foo>专门化几乎没有性能优势，因为 C++0x 版本std::swap使用高效移动而不是副本：

#include <utility>

template <typename T>
void swap(T& a, T& b)
{
    T c(std::move(a));
    a = std::move(b);
    b = std::move(c);
}

不必再摆弄swap已经为程序员减轻了很多负担。当前的编译器还没有自动生成移动构造函数和移动赋值运算符，但据我所知，这将改变。剩下的唯一问题是异常安全，因为一般来说，移动操作是允许抛出的，这会打开一大堆蠕虫。问题“移出对象的状态究竟是什么？” 使事情进一步复杂化。

std::swap然后我在想，如果一切顺利，C++0x中的语义到底是什么？交换前后对象的状态如何？通常，通过移动操作进行交换不会触及外部资源，只会触及“平面”对象表示本身。

那么，为什么不简单地编写一个swap模板来做到这一点：交换对象表示呢？

#include <cstring>

template <typename T>
void swap(T& a, T& b)
{
    unsigned char c[sizeof(T)];

    memcpy( c, &a, sizeof(T));
    memcpy(&a, &b, sizeof(T));
    memcpy(&b,  c, sizeof(T));
}

这是尽可能高效的：它只是通过原始内存爆炸。它不需要用户的任何干预：不需要定义特殊的交换方法或移动操作。这意味着它甚至可以在 C++98 中工作（请注意，它没有右值引用）。但更重要的是，我们现在可以忘记异常安全问题，因为memcpy从不抛出异常。

我可以看到这种方法的两个潜在问题：

首先，并非所有对象都需要交换。如果类设计器隐藏了复制构造函数或复制赋值运算符，则尝试交换类的对象应该在编译时失败。我们可以简单地引入一些死代码来检查类型上的复制和赋值是否合法：

template <typename T>
void swap(T& a, T& b)
{
    if (false)    // dead code, never executed
    {
        T c(a);   // copy-constructible?
        a = b;    // assignable?
    }

    unsigned char c[sizeof(T)];

    std::memcpy( c, &a, sizeof(T));
    std::memcpy(&a, &b, sizeof(T));
    std::memcpy(&b,  c, sizeof(T));
}

任何体面的编译器都可以轻松摆脱死代码。（可能有更好的方法来检查“交换一致性”，但这不是重点。重要的是它是可能的）。

其次，某些类型可能会在复制构造函数和复制赋值运算符中执行“不寻常”的操作。例如，他们可能会通知观察者他们的变化。我认为这是一个小问题，因为这类对象可能一开始就不应该提供复制操作。

请让我知道您对这种交换方法的看法。它会在实践中起作用吗？你会用吗？你能确定这会破坏的库类型吗？您是否看到其他问题？讨论！

4

5 回答 5

20

那么，为什么不简单地编写一个swap模板来做到这一点：交换 对象表示*？

当你复制它所在的字节时，一个对象一旦被构建，可能会以多种方式破坏。事实上，人们可能会想出无数种这样的情况，这不会做正确的事情——即使在实践中它可能适用于所有情况的 98%。

这是因为所有这一切的根本问题是，除了在 C 中，在 C++ 中，我们不能将对象视为仅仅是原始字节。毕竟，这就是我们有构造和销毁的原因：将原始存储转换为对象，将对象重新转换为原始存储。一旦构造函数运行，对象所在的内存就不仅仅是原始存储。如果你把它当作不是，你会破坏一些类型。

但是，从本质上讲，移动对象的性能不应该比您的想法差那么多，因为一旦您开始递归内联对 的调用std::move()，您通常最终会到达内置函数的移动位置。（如果对某些类型有更多的移动，你最好不要自己去摆弄那些内存！）当然，整体移动内存通常比单个移动更快（编译器不太可能发现它可以将单个动作优化到一个包罗万象的位置std::memcpy()），但这就是我们为抽象不透明对象提供给我们的代价。而且它非常小，尤其是当您将其与我们过去进行的复制进行比较时。

但是，您可以对聚合类型swap()的使用进行优化。std::memcpy()

于 2011-02-02T14:18:24.037 回答
20

这将破坏具有指向它们自己成员的指针的类实例。例如：

class SomeClassWithBuffer {
  private:
    enum {
      BUFSIZE = 4096,
    };
    char buffer[BUFSIZE];
    char *currentPos; // meant to point to the current position in the buffer
  public:
    SomeClassWithBuffer();
    SomeClassWithBuffer(const SomeClassWithBuffer &that);
};

SomeClassWithBuffer::SomeClassWithBuffer():
  currentPos(buffer)
{
}

SomeClassWithBuffer::SomeClassWithBuffer(const SomeClassWithBuffer &that)
{
  memcpy(buffer, that.buffer, BUFSIZE);
  currentPos = buffer + (that.currentPos - that.buffer);
}

现在，如果你只做 memcpy()，currentPos 指向哪里？到老位置，很明显。这将导致非常有趣的错误，其中每个实例实际上都使用另一个实例的缓冲区。

于 2011-02-02T14:20:44.383 回答
7

有些类型可以交换，但不能复制。唯一的智能指针可能是最好的例子。检查可复制性和可分配性是错误的。

如果 T 不是 POD 类型，则使用 memcpy 复制/移动是未定义的行为。

常见的习惯用法是提供方法 void Foo::swap(Foo& other) 和 std::swap<Foo> 的特化。请注意，这不适用于类模板，...</p>

更好的习惯用法是非成员交换，并要求用户调用不合格的交换，因此适用 ADL。这也适用于模板：

struct NonTemplate {};
void swap(NonTemplate&, NonTemplate&);

template<class T>
struct Template {
  friend void swap(Template &a, Template &b) {
    using std::swap;
#define S(N) swap(a.N, b.N);
    S(each)
    S(data)
    S(member)
#undef S
  }
};

关键是 std::swap 的 using 声明作为后备。Template 的交换友好性有助于简化定义；NonTemplate 的交换也可能是一个朋友，但这是一个实现细节。

于 2011-02-02T14:14:19.960 回答
6

我认为这是一个小问题，因为这类对象可能一开始就不应该提供复制操作。

也就是说，很简单，一大堆错误。通知观察者的类和不应该被复制的类是完全不相关的。shared_ptr 怎么样？它显然应该是可复制的，但它也显然会通知观察者——引用计数。现在确实，在这种情况下，交换后的引用计数是相同的，但绝对不是所有类型都如此，如果涉及多线程，尤其如此，在常规副本而不是交换等。这对于可以移动或交换但不能复制的类尤其错误。

因为一般来说，移动操作是允许抛出的

他们肯定不是。在几乎任何涉及移动可能抛出的移动的情况下，几乎不可能保证强大的异常安全性。来自内存的标准库的 C++0x 定义明确指出在任何标准容器中可用的任何类型在移动时都不得抛出。

这是最有效的

那也是错误的。您假设任何对象的移动纯粹是它的成员变量 - 但它可能不是全部。我可能有一个基于实现的缓存，并且我可能决定在我的班级中，我不应该移动这个缓存。作为一个实现细节，不移动任何我认为没有必要移动的成员变量完全在我的权利范围内。但是，您想要移动所有这些。

现在，您的示例代码确实对很多类都有效。但是，对于许多完全合法的类来说，这绝对是无效的，更重要的是，如果可以将操作简化为该操作，它无论如何都会编译为该操作。这是为了绝对没有任何好处而打破完美的课程。

于 2011-02-02T16:22:39.660 回答
1

您的swap版本将造成严重破坏。

考虑：

Base *b_ptr = new Base();    // Base and Derived contain definitions
Base *d_ptr = new Derived(); // of a virtual function called vfunc()
yourmemcpyswap( *b_ptr, *d_ptr );
b_ptr->vfunc(); //now calls Derived::vfunc, while it should call Base::vfunc
d_ptr->vfunc(); //now calls Base::vfunc while it should call Derived::vfunc
//...

这是错误的，因为现在 b 包含类型的 vtable Derived，所以Derived::vfunc在不是 type 的对象上调用Derived。

正常std::swap只交换 的数据成员Base，所以这可以std::swap

于 2011-02-02T14:50:08.240 回答