如果我有这样的课程

class Foo{
public:
    Foo(){...}
    Foo(Foo && rhs){...}
    operator=(Foo rhs){ swap(*this, rhs);}
    void swap(Foo &rhs);
private:
    Foo(const Foo&);
// snip: swap code
};
void swap(Foo& lhs, Foo& rhs);

如果我没有复制构造函数，按值和交换实现operator=是否有意义？它应该防止复制我的类对象Foo但允许移动。

这个类是不可复制的，所以我不应该能够复制构造或复制分配它。

Edit

我已经用它测试了我的代码，它似乎具有我想要的行为。

#include <utility>
#include <cstdlib>
using std::swap;
using std::move;
class Foo{
public: Foo():a(rand()),b(rand()) {}
        Foo(Foo && rhs):a(rhs.a), b(rhs.b){rhs.a=rhs.b=-1;}
        Foo& operator=(Foo rhs){swap(*this,rhs);return *this;}
        friend void swap(Foo& lhs, Foo& rhs){swap(lhs.a,rhs.a);swap(lhs.b,rhs.b);}
private:
    //My compiler doesn't yet implement deleted constructor
    Foo(const Foo&);
private:
    int a, b;
};

Foo make_foo()
{
    //This is potentially much more complicated
    return Foo();
}

int main(int, char*[])
{
    Foo f1;
    Foo f2 = make_foo(); //move-construct
    f1 = make_foo(); //move-assign
    f2 = move(f1);
    Foo f3(move(f2));
    f2 = f3; // fails, can't copy-assign, this is wanted
    Foo f4(f3); // fails can't copy-construct

    return 0;
}

移动和交换确实是合理的。如果禁用复制构造函数，则调用此函数的唯一方法是使用移动构造函数构造参数。这意味着如果你写

lhs = rhs; // Assume rhs is an rvalue

然后参数的构造函数operator =将使用移动构造函数进行初始化，清空rhs并将参数设置为旧值rhs。致电给swap然后交换lhs的旧值和rhs的旧值，离开lhs保持rhs的旧值。最后，参数的析构函数被触发，清理lhs的旧记忆。请注意，这实际上不是copy-并交换尽可能多move-并交换。

也就是说，您现在所拥有的不正确。默认实现std::swap将在内部尝试使用移动构造函数来移动元素，这会导致无限递归循环。你必须超载std::swap使其正常工作。

你可以在网上看到这个在ideone http://www.ideone.com/ay2KB.

有关更多信息，请参阅这个问题 https://stackoverflow.com/questions/3279543/what-is-the-copy-and-swap-idiom及其对“四个半规则”的讨论。

希望这可以帮助！