这是一个人为的例子，说明了我遇到的问题 . 基本上，我创建了一个对象向量，然后是一个指向对象的指针向量，然后打印指针和解除引用的对象 .
#include <vector>
#include <iostream>
using namespace std;
namespace {
struct MyClass {
int* MyInt;
MyClass(int* i) : MyInt(i) {}
};
struct MyBigClass {
vector<MyClass> AllMyClassRecords; // Where I keep the MyClass instances
vector<int> TheInts;
void loadMyClasses();
void readMyClasses();
MyBigClass() {}
};
}
void MyBigClass::loadMyClasses() {
for (int i = 0; i < 10; ++i) {
TheInts.push_back(i); // Create an int
int *j = &TheInts[TheInts.size() - 1]; // Create a pointer to the new int
AllMyClassRecords.push_back(MyClass(j)); // Create a MyClass using pointer
}
}
void MyBigClass::readMyClasses() {
for (vector<MyClass>::iterator it = AllMyClassRecords.begin();
it != AllMyClassRecords.end(); ++it)
cout << it->MyInt << " => " << *(it->MyInt) << endl;
}
int main() {
MyBigClass MBC;
MBC.loadMyClasses();
MBC.readMyClasses();
}
基本上，我想创建一个指向另一个int向量的指针向量 . 问题是此代码打印出以下内容：
0x97ea008 => 159293472
0x97ea02c => 1
0x97ea040 => 2
0x97ea044 => 3
0x97ea078 => 4
0x97ea07c => 5
0x97ea080 => 6
0x97ea084 => 7
0x97ea0d8 => 8
0x97ea0dc => 9
它似乎按预期工作，除了第一个值，这可能是内存中的一些垃圾 . 为什么只有第一个值受到影响？如果我的代码被破坏了，为什么它只被插入第一个指针？
更新：我在Ubuntu上使用 g++ 编译它 . 具体而言，我创建编译器分析传递 . MyClass 对象包含有关指令的信息，当我找到某些寄存器时，我想要更新这些指令 . 寄存器编号索引矢量矢量，因此特定的寄存器编号将具有 MyClass*s 的矢量 . 因此，如果找到寄存器，则向量中的任何 MyClass 指针将用于更新单独的 MyClass 向量中保存的 MyClass 对象 . 因为我正在累积存储在 MyClass 对象中的指令信息和必须遵循 MyClass 指针的寄存器信息，所以我不能创建整个 MyClass 向量而不创建单独的传递，我想避免 .
Update2：现在有了图片......
Pass Progress inserts... InstRecs (TheInt) and updates... UpdatePtrs (MyClass)
---------------------- ------------------ -----------------------
| => I1: Uses r0, r1 | | InstRec for I1 | | r0: InstRec for I1* |
| I2: Uses r0, r2 | ------------------ | r1: InstRec for I1* |
---------------------- -----------------------
首先，pass传入一个InstRec，其中包含有关I1的信息 . 它还会创建指向由寄存器编号索引的新InstRec的指针 . 这里的r0实际上是指向IRe的InstRec的一个元素的向量，因此如果在后续指令中再次遇到r0，则将更新用于I1的InstRec .
Pass Progress inserts... InstRecs (TheInt) and updates... UpdatePtrs (MyClass)
---------------------- ------------------ -----------------------
| I1: Uses r0, r1 | | InstRec for I1 | | r0: InstRec for I1* |
| => I2: Uses r0, r2 | | InstRec for I2 | | InstRec for I2* |
---------------------- ------------------ | r1: InstRec for I1* |
| r2: InstRec for I2* |
-----------------------
同样，第二个条目将插入到InstRecs中，指针将添加到UpdatePtrs结构中 . 由于I2使用r0，因此另一个InstRec指针被推送到r0向量 . 未示出：当检测到I2使用r0时，传递在指针的r0向量的UpdatePtrs结构中查找，跟随每个指向其InstRec条目的指针，并用新信息更新InstRec .
希望这使我想要做的更清楚一些 . 我已经实现了@MerickOWA首先提出的使用InstRec向量索引而不是InstRec指针的建议（因为一旦将InstRecs添加到数组中，它们就永远不会移动），它现在似乎正在工作 .
4 回答
它不仅在第一个上被破坏，恰好是唯一一个被破坏的东西 . 如果你注意到，指针0到7指向不同的内存块，它们应该完全相邻 .
std :: vector可以在向向量添加内容的任何时候重新分配动态对象所需的空间，并且它没有足够的容量 . 在添加或插入可能增加其大小的内容之后，您不能依赖指针（或迭代器）仍然有效 .
有许多解决方案
a）您可以提前预留空间（使用vector :: reserve），这样就不会发生这种动态重新分配，但您必须知道要添加的最大对象数 .
b）等到所有对象都被添加，然后才能获得指向对象的指针
c）使用索引将对象和指向矢量的指针作为一对来引用您的对象直接与对象指针相对 . 它的工作量更大但不会改变（假设你没有在开头或中间插入/移除物体）
d）尝试检测向量何时重新分配其数据（vector :: capacity返回不同的值）并刷新指针向量并重建它
e）对于没有像std :: list这样的更改重新分配的对象使用不同的容器，并放弃对基础对象容器的随机访问，你仍然可以使用指针向量，但现在指针不会失效 . （你真的需要随机访问和指向对象吗？）
f）重新考虑你的设计，不要求这样的指针
你在做什么非常类似于创建这样的东西：
然后每次向
MyInts添加一个新的int时，都会获得迭代器并将该迭代器推送到MyIntIters.您无法使用
vector执行此操作，因为只要向MyInts添加新int，迭代器就会变为无效 .所以你的整个结构都被打破了 . 你需要提出一个全新的设计 . 首先，我当然是一个更好的方式去做你想做的事情试图做 . 您要做的事情将有助于确定如何做到这一点 .
编辑：
在多次阅读和重新阅读您的更新后，在我看来，您正在尝试创建一个glom矢量 . 也就是说，一个可变长度的缓冲区，它在开头有结构化数据，后面有其他东西 .
这是相当棘手的业务，它需要动态分配 . 但是，您没有使用动态分配 - 您可以按值将对象推送到向量中 . 指向这些对象的指针将随着向量的调整大小和洗牌而改变 .
因此，如果这是你要做的事情，你需要改变一些东西，以便使用
new创建你的glom，并将指针推到向量上的glom . 这打开了整个潘多拉，你可能会考虑采取另一种方式 .您正在尝试存储指向矢量内容的指针 . 这不起作用，因为向量被设计为在内存中移动其内容以实现调整大小 .
根据您的需要，您可能：
将索引存储到向量中
发明了一些其他类型的“句柄”
更改向量以存储指向实例的智能指针（将使用'new'分配并单独存在），然后将另一个智能指针存储到同一实例 . 智能指针将保持引用计数，并在向量或外部代码不再引用实例时释放内存 . （当然有预先制定的解决方案：例如，见
boost::shared_ptr. ）push_back使迭代器和指针无效 . 怎么了：
你推到TheInts
然后你拿一个指针推送元素并将其存储在另一个向量中
上面的推入点1可以重新分配向量并使之前对前面元素采用的所有指针无效 . 他们指出的 Value 超出了你的控制范围 .
为什么它只发生一次 - 只是运气（矢量可能分配比当前需要的更大的块） .
使用dequeue或list或预先保留所需的空间（如果你可以确定你需要多少）或者在完成添加之后获取指向第一个向量的指针（是的，它需要两个循环） .