存储可移动和可复制的类
假设你有这个课程：
class Data {
public:
Data() { }
Data(const Data& data) { std::cout << " copy constructor\n";}
Data(Data&& data) { std::cout << " move constructor\n";}
Data& operator=(const Data& data) { std::cout << " copy assignment\n"; return *this;}
Data& operator=(Data&& data) { std::cout << " move assignment\n"; return *this;}
};
注意，一个好的 C++11 编译器 should define all these functions 适合您 (Visual Studio doesn't) 但我在此处定义它们以用于调试输出。
现在，如果您想编写一个类来存储其中一个类，我可能会像您建议的那样使用按值传递：
class DataStore {
Data data_;
public:
void setData(Data data) { data_ = std::move(data); }
};
我正在利用C++11 move semantics 将值移动到所需位置。然后我可以像这样使用DataStore：
Data d;
DataStore ds;
std::cout << "DataStore test:\n";
ds.setData(d);
std::cout << "DataStore test with rvalue:\n";
ds.setData(Data{});
Data d2;
std::cout << "DataStore test with move:\n";
ds.setData(std::move(d2));
输出如下：
DataStore test:
copy constructor
move assignment
DataStore test with rvalue:
move assignment
DataStore test with move:
move constructor
move assignment
这很好。我在上次测试中有两个动作可能不是最佳的，但动作通常很便宜，所以我可以忍受。为了使其更优化，我们需要重载 setData 函数，我们稍后会这样做，但这可能是过早的优化。
存储一个不可移动的类
但现在假设我们有一个可复制但不可移动的类：
class UnmovableData {
public:
UnmovableData() { }
UnmovableData(const UnmovableData& data) { std::cout << " copy constructor\n";}
UnmovableData& operator=(const UnmovableData& data) { std::cout << " copy assignment\n"; return *this;}
};
在 C++11 之前，所有类都是不可移动的，因此希望今天能在野外找到很多类。如果我需要编写一个类来存储它，我不能利用移动语义，所以我可能会写这样的东西：
class UnmovableDataStore {
UnmovableData data_;
public:
void setData(const UnmovableData& data) { data_ = data; }
};
并通过引用到常量传递。当我使用它时：
std::cout << "UnmovableDataStore test:\n";
UnmovableData umd;
UnmovableDataStore umds;
umds.setData(umd);
我得到了输出：
UnmovableDataStore test:
copy assignment
如您所愿，只有一份副本。
存储不可复制的类
你也可以有一个可移动但不可复制的类：
class UncopyableData {
public:
UncopyableData() { }
UncopyableData(UncopyableData&& data) { std::cout << " move constructor\n";}
UncopyableData& operator=(UncopyableData&& data) { std::cout << " move assignment\n"; return *this;}
};
std::unique_ptr 是可移动但不可复制的类的示例。在这种情况下，我可能会编写一个类来存储它：
class UncopyableDataStore {
UncopyableData data_;
public:
void setData(UncopyableData&& data) { data_ = std::move(data); }
};
我经过rvalue reference 并像这样使用它：
std::cout << "UncopyableDataStore test:\n";
UncopyableData ucd;
UncopyableDataStore ucds;
ucds.setData(std::move(ucd));
输出如下：
UncopyableDataStore test:
move assignment
请注意，我们现在只有一个好的动作。
通用容器
然而，STL 容器需要是通用的，它们需要与所有类型的类一起工作并尽可能优化。如果你真的需要上面数据存储的通用实现，它可能看起来像这样：
template<class D>
class GenericDataStore {
D data_;
public:
void setData(const D& data) { data_ = data; }
void setData(D&& data) { data_ = std::move(data); }
};
通过这种方式，无论我们使用不可复制或不可移动的类，我们都可以获得最佳性能，但我们必须至少有两个 setData 方法的重载，这可能会引入重复代码。用法：
std::cout << "GenericDataStore<Data> test:\n";
Data d3;
GenericDataStore<Data> gds;
gds.setData(d3);
std::cout << "GenericDataStore<UnmovableData> test:\n";
UnmovableData umd2;
GenericDataStore<UnmovableData> gds3;
gds3.setData(umd2);
std::cout << "GenericDataStore<UncopyableData> test:\n";
UncopyableData ucd2;
GenericDataStore<UncopyableData> gds2;
gds2.setData(std::move(ucd2));
输出：
GenericDataStore<Data> test:
copy assignment
GenericDataStore<UnmovableData> test:
copy assignment
GenericDataStore<UncopyableData> test:
move assignment
Live demo.希望对您有所帮助。