What happens when I delete a pointer of pointer? - c++

Question

I have a vector like std::vector<AnyObject*> myVector; and I would like to delete an element in my vector without changing position of my other elements. How can I do this ? I have two solutions, tell me if they are good:
AnyObject* initial;
std::vector<AnyObject*> myVector(10, initial);
AnyObject* object = myVector.at(4);
delete object;
or
AnyObject* initial;
std::vector<AnyObject*> myVector(10, initial);
delete myVector.at(4);
What happens in the first solution when I delete object ? Am I also deleting the pointer in the vector or just the object ?
EDIT :
When I wrote AnyObject* initial;, I know initial isn't initialized, I wanted just say what happens if I a have a vector of initialized pointers and if I wanted delete one pointer without changing position of the other pointers.
EDIT2:
For the context of the problem, I have a class PointCloud and another class SubsampledPointCloud. I want subsampled my all clouds with the same size of the smallest cloud, so among my subsampled point cloud, I have at least one cloud that have the same size of its point cloud. So to build my vector of SubsampledPointCloud, I have a vector of PointCloud initialized, a variable minPointCloudSize equals to the minimum size among my point clouds and I do this :
std::vector<SubsampledPointCloud*> subcloud(clouds.size());
for (std::size_t i = 0; i < clouds.size(); i++) {
if (clouds.at(i).size() > minPointCloudSize)
subcloud.at(i) = subPointCloud(clouds.at(i)); //subPointCloud is a function
//that return a SubsampledPointCloud*
else
subcloud.at(i) = clouds.at(i);
}
and later, I don't need of this subsampled point cloud, so I'm deleting all of this except if the sub cloud with the same size of the original cloud.
Of course, SubsampledPointCloud inherited of PointCloud.

Answer 1

I have two solutions, tell me if they are good
Both of your solutions have UB - you read from uninitialized variable initial. If you manage to put correctly initialized pointers to your vector, then both variants would have the same effect - if fifth pointer in the vector not equal to nullptr, object it points to would be destroyed and memory released. You should understand that delete does not modify argument passed to it, so calling delete would not alter pointer itself and unless it is not equal to nullptr you would have dangling pointer left in the vector. It would be your job to reassign new value to it or to avoid using it after that. Or remove it from the vector calling vector methods.
Am I also deleting the pointer in the vector or just the object ?
You are only deleting object, pointer would have exactly the same value ie point into memory where object used to be.

Answer 2

A segmenation fault in both cases, as you haven't actually created any AnyObjects, only the vector of null pointers.
In general, if you have a vector of pointers to objects, you can delete the object by deleteing the object as you have done, and then setting the pointer to null, to denote that it doesn't point to an object.
To use your example, glossing over the fact you haven't created any objects:
AnyObject* initial;
std::vector<AnyObject*> myVector(10, initial);
delete myVector[4];
myVector[4] = 0;

Answer 3

std::vector<AnyObject*> myVector(10, initial);
This statement will initialize vector with 10 initial object. initial is memory reference and when you delete it that deallocates memory that was allocated for initial object and will make all vector element pointing to invalid memory location in both case. If you will try to access it after delete in both case, the behavior will be undefined.

Answer 4

Your premise is flawed. You shouldn't use raw pointers to handle object lifetimes, use std::unique_ptr (or std::shared_ptr if the lifetime really is shared)
Then your example would look like
std::vector<std::unique_ptr<AnyObject> > myVector(10, nullptr);
// other code
myVector[index] = make_unique<AnyObject>(args...);
// other code
myvector[other_index].reset(nullptr);