Re: Dynamically allocated typedef'd array -- how to delete?
On Mar 31, 2:28 am, Seungbeom Kim <musip...@bawi.org> wrote:
Lance Diduck wrote:
On Mar 28, 12:29 pm, "Risto Lankinen" <rlank...@gmail.com> wrote:
struct Res { /* Uses RAII, hence must be destructed appropriately!
*/ };
typedef Res Res_Array[256];
And another method is making a selector
template <class T, bool _Dummy>
struct _deleter{
void operator()(T*d){delete d;}
};
template <class T>
struct _deleter<true>{
void operator()(T*d){delete[] d;}
};
template <class T> void DeleteMe(T*d){
_deleter<tr1::is_array<T>::value>()(d);
};
Res* pRes = new Res;
Res* pArray = new Res_Array;
Since invoking DeleteMe<T> on pRes and on pArray will both instantiate
it with T=Res, I don't see how tr1:is_array<T> can be used to
disambiguate between the two forms of the delete operator.
If the disambiguation could have be done automatically, there would have
been no need to have two forms (delete and delete[]) at all -- the
compiler could just have chosen the right form all the time.
--
Seungbeom Kim
You are right. This example would not work. There is no way to know
from the pointer itself whether you are pointing to an array or just
one type.
I got a little ahead of myself. what I intended is that you could use
such a check when you create the array, and then store the result:
template <class T>struct Deleter{
void operator()(T*p)const{
if( m_array)delete[] p;
else delete p;
}
Deleter(bool r=false):m_array(r)(
bool m_array;
};
tr1::shared_ptr<Res> res(new Res_Array
,Deleter<Res>(is_array<Res_Array>));
Not that this is good style -- one could have just written
tr1::shared_ptr<Res> res(new Res[256]
,Deleter<Res>(true));
The point is that, like in D&E 10.6, and the point of construction we
know everything there is to know about an object, and at delete time,
almost nothing. So the point is that we dont have to keep up with
this.
The standard always requires that array types are always deleted with
delete[]. The confusing parts about typedefing an array (which seems
to work on some compilers and not others) is that it will call new[]
regardless of the syntax.
You get something like this
Res* r=new Res_Array.//really is array, and will use Res::operator
new[] , or global version
The way to check this is to overload all operators new for Res, and
see what your compilers do. That will give you way more insight than
tring to parse the standard. Also pick up Lippmann's "Inside the C++
Object Model"
Lance
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]