Re: delete operator again

From:

Frederick Gotham <fgothamNO@SPAM.com>

Newsgroups:

comp.lang.c++.moderated

Date:

24 Sep 2006 15:14:08 -0400

Message-ID:

<VvzRg.14062$j7.330767@news.indigo.ie>

RenjithMohan posted:

Like if for example I have

class A;

A* pArr = new A[10];

and I say

delete pArr ; //automatically invoke operator delete [] ;

It should automatically invoke the array delete operator since the
nature of the type(whether it is an array or a simple pointer ) can be
determined from the declaration.

No, it can't. The following two objects have exactly the same type:

int *p1 = new int;

int *p2 = new int[5];

This way we can have just one form of the delete syntax eventhough
there are multiple forms of the operator.
This could be like overloading processor finding the correct function,
but only simpler.

     int main()
     {
         int *p = new int;

         delete p;

         p = new int[5];

         delete [] p;
     }

You could of course cook up more complicated scenarios like array of
polymorphic types etc. But the point remains the same . It is just a
race between the normal form and array form of delete of the type.
Since the nature of the type is always given why cant the compiler
guess to call the correct form ?

Because the nature of the type is _not_ always given. You'd need something
like:

template<class T>
struct DynamPtr {
     T *p;
     enum AllocType { sole, array } type;
};

template<class T>
void Delete(DynamPtr<T> const &dp)
{
     DynamPtr<T>::sole == dp.type ? delete dp.p : delete [] dp.p;
}

int main()
{
     DynamPtr<int> p;

     p.p = new int; p.type = DynamPtr<int>::sole;
     Delete(p);

     p.p = new int[5]; p.type = DynamPtr<int>::array;
     Delete(p);
}

--

Frederick Gotham

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]