C++：更新深拷贝中的指针（高效）

Question

我的问题最好用代码示例来说明，所以让我们从这个开始：

class Game
{
    // All this vector does is establish ownership over the Card objects
    // It is initialized with data when Game is created and then is never
    // changed.
    vector<shared_ptr<Card> > m_cards;

    // And then we have a bunch of pointers to the Cards.
    // All these pointers point to Cards from m_cards.
    // These could have been weak_ptrs, but at the moment, they aren't
    vector<Card*> m_ptrs;

    // Note: In my application, m_ptrs isn't there, instead there are
    // pointers all over the place (in objects that are stored in member
    // variables of Game.
    // Also, in my application, each Card in m_cards will have a pointer
    // in m_ptrs (or as I said, really just somewhere), while sometimes
    // there is more than one pointer to a Card.
}

现在我想做的是对这个 Game 类做一个深拷贝。 我创建了一个带有新 shared_ptrs 的新向量，它指向作为原始 Card 对象副本的新 Card 对象。 那部分很容易。

那么麻烦就开始了，m_ptrs的指针要更新为指向m_cards中的卡片，这可不是简单的任务。

我能想到的唯一方法是创建一个地图并在复制 m_cards 期间填充它（使用map[oldPtr] = newPtr ），然后使用它来更新 m_ptrs。 然而，这只是O(m * log(n)) ( m = m_ptrs.size(); n = m_cards.size() )。 由于这将是一个非常常规的操作*，我想有效地执行此操作，并且我觉得使用自定义指针在O(m)应该是可能的。 但是，我似乎找不到一种有效的方法来做到这一点。 有人做吗？

*它用于为人工智能创建一个测试平台，让它“尝试”不同的动作

---

编辑：我想补充一点关于接受答案，因为我还没有。 我正在等待直到我回到这个项目（我在这个项目上做了太多工作，所以我偏离了轨道 - 如果你为了好玩而做，它必须保持有趣），所以我接受之前可能需要一段时间一个答案。 不过，我会在一段时间内接受答案，所以别担心：P

---

编辑 nr 2：我还没有回到这个项目。 现在，我正在考虑采用O(m * log(n))方式而不是抱怨，然后再看看是否需要更快。 然而，由于我最近花了一些时间来学习我的模式，我也在想我真的需要一些时间来重构这个项目。 哦，我可能只是花一些时间用我掌握的所有新知识来解决这个问题。 由于没有答案说“只使用哈希图，然后看看它是否真的需要更快”（如果有的话，我实际上会非常失望，因为它不是我问题的答案），我是推迟选择答案，直到我回到这个项目。

---

编辑 nr 3：我仍然没有回到这个项目。 更准确地说，它已被无限期搁置。 我很确定我现在不会对O(m * log(n))过于弯腰，如果结果证明这是一个问题，也许稍后再看看。 然而，这对我的问题来说并不是一个好的答案，因为我明确要求更好的性能。 不想再让答案不被接受，我选择了最有帮助的答案并接受了它。

Answer 1

将指针存储为索引。 正如你所说，它们都指向 m_Cards，它是一个可以被索引的向量（这是正确的英语吗？）。 要么你这样做只是为了存储并在加载时将它们转换回指针。 或者您可能会考虑使用索引而不是指针。

Answer 2

如何保持卡片元素索引而不是指针：

vector<int> m_indexes;

...

Card* ptr = &m_cards[m_indexes[0]];

带索引的向量可以不加改动地复制。

Answer 3

我最近遇到了非常相似的问题：将指针和 std::vector 实现的类内部结构克隆为对象存储。

首先（尽管与问题无关），我建议要么坚持使用智能指针，要么坚持使用普通结构。 在您的情况下，这意味着使用vector<weak_ptr<Card> > m_ptrs而不是原始指针更有意义。

关于问题本身 - 另一种可能的解决方法是在复制构造函数中使用指针差异。 我将针对对象向量演示它，但使用共享指针将利用相同的原理，唯一的区别在于 m_cards 的复制（如果您想要对象克隆，则不应简单地使用赋值，而是m_cards复制m_cards ）。

非常重要的是，该方法仅适用于保证存储元素的容器（向量、数组）。

另一个非常重要的时刻是m_ptrs元素应该只代表内部Card结构，即它们必须只指向内部m_cards元素。

// assume we store objects directly, not in shared pointers
// the only difference for shared pointers will be in
// m_cards assignment
// and using m_cards[...].get() instead of &m_cards[...]
vector<Card> m_cards;
vector<Card*> m_ptrs;

在这种情况下，您的指针数组可以通过使用线性时间的指针算术轻松计算。 在这种情况下，您的复制构造函数将如下所示：

Game::Game(const Game &rhs) {
  if (rhs.m_cards.empty())
    return;

  m_cards = rhs.m_cards;

  // if we have vector of shared pointers
  // and we need vector of pointers to objects clones
  // something like this should be done
  // for (auto p: rhs.m_cards) {
  //   // we must be certain here that dereferencing is safe,
  //   // i. e. object must exist. If not, additional check is required.
  //   // copy constructor will be called here:
  //   m_cards.push_back(std::make_shared<Card>(*p));
  // }

  Card *first = &rhs.m_cards[0];
  for (auto p: rhs.m_ptrs) {
    m_ptrs.push_back(&m_cards[p - first]);
  }
}

基本上在这种 deepcopy 方法中，您仍将使用索引，但您保留了在其他类方法中使用指针的便利性，而无需单独存储索引。

无论如何，对于使用这种结构，您应该确切地知道您对类成员做什么以及为什么，这需要更多的手动控制（例如，至少应该有意识地向/从m_cards添加/删除元素，在其他即使不复制对象，情况m_ptrs也很容易损坏）。