I am alittle bit confused on topic of allocating objects on heap vs allocating on stack, and when and how delete() should be called.
For example I have class Vector. I would like to make an array of these.
I could either do this
Vector** v = new Vector*[100]; //create an array of 100 pointers to 100 Vector objects
This as I understand would allocate everything (well except pointer addresses) on a heap?
So to free memory I would need to:
for (int i = 0; i < 100; ++i)
{
delete(v[i]);
}
delete(v);
OR just
delete(v);
is enough?
Now another example:
Vector* v = Vector[100];
Whats happening in this case? Where does allocation happen? Heap or stack?
Do I still need to call
delete(v);
But this is not all question, sorry for long post..
example:
class Vector
{
int x, y, z;
}
Vector* v = new Vector();
wheres x, y, z allocated? Heap or stack?
or how about this:
class Vector2
{
int items[10];
}
Vector2* v2 = new Vector2();
where are items[10] allocated?
How do I delete v2? Do i need custom destructor?
Also last but not least how about this one:
class Vector3
{
int* items;
}
Vector3 v3 = Vector3();
Where is items pointer stored? heap or stack? How do I delete this?
Thanks and sorry for long question. Ive been having trouble with this stuff for long time and couldnt really find any complete explanation on line.
Best Answer
I'll start from the beginning...
Allocates an array of 100 pointers to objects of type Vector on the heap It returns one pointer- v - the you can use to keep track of this array of pointers.
Delete this array of 100 points with:
(Use the
delete
operator-delete
for a single allocated object,delete[]
for an array)Next case (I'm assuming you mean
new Vector[100]
:You allocated an array of 100 Vectors on the heap and got a pointer to its start location- v. Delete this array with:
Next...
This allocates an object of class Vector on the heap and gives you a pointer to keep track of it. Because you allocated the entire object on the heap, x, y, and z are all allocated on the heap.
Delete it with:
This one is a bit trickier but I'm going to reason it out...
Classes are blueprints. You haven't allocated any memory at all until you instantiate the class somehow, in this case on the heap. Because the class is a blueprint,
items
could not have been allocated until you created an object of classVector2
on the heap. I think we can reasonably infer thatitems
is thus allocated on the heap.Delete v2 with:
And finally:
You allocated all of class Vector3 on the stack, the pointer inside of it
items
is also allocated thus. Nothing went on the heap, so don't delete it.