Указатели на самом деле не указывают на сами объекты?

vector хранит свои элементы в массиве. Массив представляет собой непрерывную последовательность элементов.

Если у вас есть vector, содержащий элементы a, b, c, d, и удалить элемент b, то элементы c и d перемещаются вниз на один индекс в массиве, чтобы заполнить дыру, созданную удаленным элементом, оставив массив, содержащий a, c, d.

Указатели не «следуют» за элементами в vector по мере их перемещения. Если у вас есть указатель «на c», этот указатель действительно указывает на «элемент с индексом 2 в массиве». Когда вы удаляете b из массива, «элемент с индексом 2» становится d, а не c.

Если вы хотите, чтобы объект имел фиксированный адрес, который никогда не меняется, вы должны сами динамически выделять его и отслеживать с помощью интеллектуального указателя (например, unique_ptr или shared_ptr).

Если вы хотите добиться чего-то подобного, вы не сможете использовать vector<foo> для управления самими foo объектами. Мне кажется, что ваш подвектор foo* должен фактически указывать на память, за которую отвечает vector<foo>. (Вот почему вы все еще видите дополнительный указатель в конце, который указывает на d, и у вас все еще есть длина 4.)

Мне кажется, что вы действительно хотите сделать, это использовать два vector<foo*> и вручную создавать объекты, которые хранятся в первом, вместо того, чтобы сам вектор отвечал за объекты. Затем ваш второй vector<foo*> просто скопирует указатели на объекты, которые вы создали. Таким образом, когда вы удаляете элемент из первого vector<foo*>, он удалит только его копию указателя, а ваш второй vector<foo*> не пострадает.

Подумайте об этом без задействованного вектора:

// create the initial storage for all the foo
foo* fooarray = new foo[foo_count];

// create all the foos for the array
for (int i=0; i < foo_count; ++i)
   fooarray = new foo();

// get a pointer to a subset of foo 
foo* foo_subset_pointer = &fooarray[10];

// make a list of a subset of the fooarray pointers
foo* foo_subset_list = new foo[10];
for (int i=0; i < 10; ++i)
    foo_subset_list = fooarray[i];

Итак, теперь, когда вы удаляете элемент из fooarray:

// remove fooarray[3]
delete fooarray[3]; 
for (int i=4; i < 20; ++i)
   fooarray[i-1] = fooarray[i];

foo_subset_pointer будет удален исходный элемент 3, поскольку он был просто указателем на существующий массив. (И если вы получите доступ к foo_subset_pointer[19], он все равно будет иметь указатель на то же самое, что и foo_subset_pointer[18], потому что элементы не были обнулены...)

Но что еще хуже, foo_subset_list[3] по-прежнему указывает на исходное местоположение: но оно недействительно, потому что оно было удалено! Вот почему вы не хотите, чтобы вектор отвечал за элементы вашего списка, когда вы имеете дело с подмножеством, которое вы хотите сохранить.

Вместо этого кажется, что вы хотите, чтобы ваш первый вектор удалял только элемент (цикл for выше), но не delete. В этом случае он оставляет ваш foo_subset_list[3] нетронутым и по-прежнему указывает на действительный foo. Дополнительная трудность заключается в том, что теперь вы должны обязательно выполнить delete foo_subset_list[3]; в какой-то момент в будущем. Но это позволяет вам вести себя так, как вы хотели.

Когда объект в vector удаляется, все объекты с большими индексами в vector перемещаются вниз, чтобы закрыть «дыру». Указатели на любой из этих объектов становятся недействительными. Единственный способ обнаружить ситуацию — это вообще не попадать в эту ситуацию — не храните указатели на объекты не в const vector, потому что это опасно.