Will we get SEGV if we try to ?delete []? un-initialized integer pointer va

Question

I have a class with an integer pointer, which I have not initialized to NULL in the constructor. For example:
class myclass
private:
char * name;
int *site;
myclass:: myclass(?.)
: name(NULL)
other member function "delete [] " the variable before initializing it.
Ex:
void myclass:: copy_site ( int **Values, int *from)
int *old;
old = *values.
Delete [] old; <<<<<? here I am getting SEGV
But I am getting SEGV at "delete []".
Surprisingly it is not happening every time.For some inputs it is certainly working fine.
What could be the reason?
If it is because of initialization, why is working for some inputs and certainly not for other inputs?
I have observed with workshop that, for some inputs it is automatically getting initialized to NULL, and for other inputs it is certainly not NULL (dangling pointer).
Thanks in advance,
Suresh

Answer 1

The rule for "delete"is that you must write
delete [] p;
if p points to an array, but you must write
delete p; // without []
if p points to a single object.
Therefore, you must know how how the heap item that p points to was created: as a single object or as an array.
If you guess wrong, your code is likely to fail. The exact circumstances when you get a failure depend on the details of your code and on the details of the compiler implementation. The C++ standard says that the results are "undefined", meaning that you are not allowed to expect any particular result.
If p could reasonably be assigned the address of either a single object or an array, you need to change your allocation strategy.
1. Never allocate a single object, but always allocate an array, even if an array of 1 item.
2. Use "delete []", since you will always have an array.
You could create a factory function that returns a pointer to an array of T (even if an array of 1 object) and call that function instead of allocating directly on the heap.
But it's more likely that you can organize your code so that you always know whether you are dealing with an arary or a heap. The problem of p versus p[0] to get to the object is still there.