c++：过度复制大对象

Question

虽然已经有很多关于复制构造函数/赋值运算符的问题，但我没有找到适合我的问题的答案。

我有一个像现在这样的课程

class Foo
{
   // ...
private:
   std::vector<int> vec1;
   std::vector<int> vec2;
   boost::bimap<unsigned int, unsigned int> bimap;
   // And a couple more
};

，似乎正在进行一些相当过度的复制（基于配置文件数据）..所以我的问题是如何最好地解决这个问题？

我应该实现自定义复制构造函数/赋值运算符并使用交换吗？或者我应该定义自己的交换方法并使用它（在适当的情况下）而不是赋值？

由于我不是 C++ 专家，因此非常感谢展示如何正确处理这种情况的示例。

更新：看来我不是很清楚..让我尝试解释一下。该程序基本上是一个动态广度优先搜索程序，对于所采取的每一步，我都需要存储有关该步骤的元数据（即 Foo 类）。现在的问题是（通常）有指数级的步骤，所以你可以想象需要存储大量的这些对象。据我所知，我总是传递（常量）引用。每次我从以下节点计算后继者我需要创建和存储一个图表Foo 对象（但是，在处理该后继对象时，一些数据成员将被添加到这个 foo 中）。

我的个人资料数据大致显示如下（我在这台机器上没有实际数字）：

SearchStrategy::Search    13s
FooStore::Save            10s

所以你可以看到我保存这些元数据的时间几乎和搜索图表一样多。哦，FooStore 将 Foo 保存在 google::sparse_hash_map >。

编译器是 g++4.4 或 g++4.5 （我不在我的开发机器上，所以我现在无法检查）..

更新 2 我在构建后将一些成员分配给像我想明天那样的 Foo 实例

void SetVec1(const std::vector<int>& vec1) { this->vec1 = vec1; };

，我应该将其更改为使用交换方法，这肯定会稍微改进这一点。

如果我不完全清楚我要实现的语义，我很抱歉，但是原因是我不太 当然。

问候，

莫滕

Answer 1

一切都取决于复制这个对象在你的情况下意味着什么：

1. 这意味着复制它的整个值，
2. 这意味着复制的对象将引用相同的内容

如果它是1，那么这个类看起来是正确的。您不太清楚您所说的确实会产生大量副本的操作，因此我假设您尝试复制整个对象。

如果是2，那么你需要使用像shared_ptr这样的东西来在对象之间共享容器。仅使用shared_ptr而不是真实对象作为成员将隐式允许两个对象（副本和被复制的）引用缓冲区。
这是更简单的方法（如果您有支持 C++0x 的编译器提供的话，请使用 boost::shared_ptr 或 std::shared_ptr ）。

还有更困难的方法，但它们肯定会成为以后的问题。

Answer 2

1. 当然，大家都这么说，不要过早优化。 不要为此烦恼。

2. 如果您的程序设计要求您同时保存数据的多个副本，那么您无能为力。您只需硬着头皮复制数据即可。不，实现自定义复制构造函数和自定义赋值运算符不会使其运行得更快。

3. 如果您的程序不需要此数据的多个同时副本，那么您确实有一些技巧可以减少执行的副本数量。

检测你的复制方法如果是我，即使在尝试改进任何东西之前，我要做的第一件事就是计算我的复制方法被使用的次数
调用。

class Foo {
private:
  static int numberOfConstructors;
  static int numberofCopyConstructors;
  static int numberofAssignments;
  Foo() { ++numberOfConstructors; ...; }
  Foo(const Foo& f) : vec1(f.vec1), vec2(f.vec2), bimap(f.bimap) {
    ++numberOfCopyConstructors;
    ...;
  }
  Foo& operator=(const Foo& f) {
    ++numberOfAssignments;
    ...;
  }
};

在有或没有改进的情况下运行您的程序。打印出这些静态成员的值以查看您的更改是否有任何效果。

避免在函数调用中使用引用进行赋值 如果将 Foo 类型的对象传递给函数，请考虑是否可以通过引用来完成。如果您不更改传递的副本，则通过 const 引用传递它是理所当然的。

// WAS:
extern SomeFuncton(Foo f);
// EASY change -- if this compiles, you know that it is correct
extern SomeFunction(const Foo& f);
// HARD change -- you have to examine your code to see if this is safe
extern SomeFunction(Foo& f);

使用 Foo::swap 避免复制 如果您经常使用复制方法（显式或隐式），请考虑分配来源项是否可以放弃其数据，而不是复制它。

// Was:
vectorOfFoo.push_back(myFoo);
// maybe faster:
vectorOfFoo.push_back(Foo());
vectorOfFoo.back().swap(myFoo);

// Was:
newFoo = oldFoo;
// maybe faster
newfoo.swap(oldFoo);

当然，只有当 myFoo 和 oldFoo 不再需要访问其数据时，这才有效。而且，您必须实现 Foo::swap

void Foo::swap(Foo& old) {
    std::swap(this->vec1, old.vec1);
    std::swap(this->vec2, old.vec2);
    ...
}

无论您做什么，请在更改之前和之后测量您的程序。测量复制方法被调用的次数以及程序中的总时间改进。

Answer 3

你的课程看起来并没有那么糟糕，但你没有展示你如何使用它。

如果存在大量复制，则需要通过引用（或者如果可能的话 const 引用）传递这些类的对象。
如果必须复制该类，那么您将无能为力。

Answer 4

如果这确实是个问题，您可以考虑实施 pimpl idiom。但我怀疑这是一个问题，尽管我必须看看你对该类的使用才能确定。

Answer 5

复制巨大的向量不太可能很便宜。最有希望的方法是复制稀有的。虽然在 C++ 中无意地调用复制非常容易（可能太容易了），但有一些方法可以避免不必要的复制：

• 传递 const 和非 const 引用
• 移动构造函数
• 具有所有权转移的智能指针

这些技术可能只留下以下副本：算法要求。

有时甚至可以避免其中一些复制。例如，如果您需要两个对象，其中第二个对象是第一个对象的反向副本，则可以创建一个包装对象，其行为类似于反向，但不存储整个副本，仅具有引用。

Answer 6

减少复制的明显方法是使用诸如shared_ptr之类的东西。然而，对于多线程来说，这种治疗方法可能比疾病更糟糕——增加和减少引用计数需要以原子方式完成，这可能非常昂贵。但是，如果您通常最终会修改副本并需要每个副本都具有唯一性（即，修改副本不会影响原始副本），那么您最终可能会获得更差的性能，并为引用计数的原子增量/减量付出代价，并且仍然进行大量复制。

有一些明显的方法可以避免这种情况。一种是移动唯一的对象而不是复制——如果你能让它发挥作用，那就太好了。另一种是大部分时间使用非原子引用计数，并且仅在线程之间移动数据时才进行深复制。

但没有一个答案是通用且真正干净的。