Consider the following situation:
Class** array = new Class*[8];
array[1] = new Class(1,2);
Is just doing "delete[ ] array" sufficient or should I precede the former with "delete array[1]". I am not completely comfortable with memory management.
Every time you call new[], you have to call delete[] on the pointer to deallocate. Every time you call new, you have to call delete.
In your case, you call new twice. array[1] contains a pointer to a class allocated with new, so it must be deallocated with delete. And array is a pointer to an array allocated with new[], so it must be freed with delete[].
Of course, you could have saved yourself this headache by simple declaring the array like this:
Class array[8];
array[1] = Class(1,2);
no dynamic memory allocation means no need to call delete.
Or using std::vector:
std::vector<Class> array(8);
array[1] = Class(1,2);
new creates an array containing 8 pointers. If the system was to automatically delete the individual pointers, how would it know which ones of them to delete? You've only set the second entry (array[1]) to point to another allocation. The remaining 7 entries in the array are uninitialized. How would the runtime know that 7 of them should not have delete called on them, but one should?
delete or delete[] on them? :)If you create vector of objects of class Class and suppose sizeof(Class) is more than 4 bytes, then vector is going to make copies and it will waste memory. Instead consider using vector of pointers to Class objects, which will always create 4 * 8 = 32 bytes of memory irrelevant of the sizeof(Class).
Classis not a keyword;classis. Names are case sensitive in C++.classisn't a name, it's a keyword... sigh)