Template Class Specialization Question

[Erik Friis]

Hi, I'm trying to create a class template like the following:

template <class Type>
class MyVector
{
MyVector();
~MyVector();

unsigned int MyCount;
Type* MyData;
}

where the destructor is defined like:

template <class Type>
MyVector<Type>: :~MyVector()
{
delete [] MyData;
}

The problem is that when Type is something like a pointer to an object
then the destructor needs to delete each of those pointers before
deleting MyData, right? But if Type is an integral type such as
"unsigned int" then I don't need (or want) to do this....

So I thought that I might be able to use a specialization, but it
seems that there are too many cases to cover, no? Am I missing
something? Thanks for any direction!

[John Harrison]

"Erik Friis" <ef****@sprintm ail.com> wrote in message
news:ce******** *************** ***@posting.goo gle.com...

Hi, I'm trying to create a class template like the following:

template <class Type>
class MyVector
{
MyVector();
~MyVector();

unsigned int MyCount;
Type* MyData;
}

where the destructor is defined like:

template <class Type>
MyVector<Type>: :~MyVector()
{
delete [] MyData;
}

The problem is that when Type is something like a pointer to an object
then the destructor needs to delete each of those pointers before
deleting MyData, right?
Well that is up to you. But I would say, wrong.

You are saying that MyVector should take ownership of any pointers added to
it. I would say that is poor design, just adding a pointer to a MyVector
doesn't mean that it is responsible for it's destruction. Consider

T* ptr = something();
if (ptr != 0)
{
MyVector<T*> vec_of_pointers ;
vec_of_pointers .add(ptr);
...
} // ptr will be deleted here
ptr->something_else (); // *** CRASH ***, ptr has already been deleted

Do you consider that behaviour surprising? I do, but as I say it's up to
you.

What about this?

{
MyVector<char*> vec_of_pointers ;
vec_of_pointers .add("watch me crash!!!");
} // crash here, attempting to delete a string literal

That behaviour would make me cross.
But if Type is an integral type such as
"unsigned int" then I don't need (or want) to do this....

So I thought that I might be able to use a specialization, but it
seems that there are too many cases to cover, no? Am I missing
something? Thanks for any direction!

You can use partial specialisation.

template <class Type>
class MyVector<Type*>
{
MyVector();
~MyVector();

unsigned int MyCount;
Type* MyData;
};

This is a specialised version of MyVector solely for pointers. Put this
class after your main MyVector class if you still think its a good idea.

john

[John Harrison]

"John Harrison" <jo************ *@hotmail.com> wrote in message
news:2s******** *****@uni-berlin.de...

"Erik Friis" <ef****@sprintm ail.com> wrote in message
news:ce******** *************** ***@posting.goo gle.com...

Hi, I'm trying to create a class template like the following:

template <class Type>
class MyVector
{
MyVector();
~MyVector();

unsigned int MyCount;
Type* MyData;
}

where the destructor is defined like:

template <class Type>
MyVector<Type>: :~MyVector()
{
delete [] MyData;
}

The problem is that when Type is something like a pointer to an object
then the destructor needs to delete each of those pointers before
deleting MyData, right?
Well that is up to you. But I would say, wrong.

You are saying that MyVector should take ownership of any pointers added

to it. I would say that is poor design, just adding a pointer to a MyVector
doesn't mean that it is responsible for it's destruction.

The whole issue of pointers and ownership is important enough that it needs
it's own solution, quite separate from anything that you might do in
MyVector. Look up 'smart pointers' in your favourite C++ book.

john