Template of class pointers

I want to create a template class that holds pointers to objects instead of objects themselves.
I have this:

Code:

template <class T>
class MyADT { ... };
MyADT<datatype> adt;

But want this:

Code:

template <class T*> // incorrect syntax!!
class MyADT { ... };
MyADT<datatype*> adt;

What is the correct syntax?
Thanks.

You can store a T* as a member variable.

Code:

template <class T> // incorrect syntax!!
class MyADT { ... };
MyADT<datatype*> adt;

Would be correct.

Although Raigne's example will allow your code to compile, I would point out that it is contrary to common practice for smart pointer class templates, e.g., we use std::auto_ptr<T> instead of std::auto_ptr<T*>.

I'd like to ensure the class is never used with anything but pointers (i.e. MyADT<datatype> should be an error). I was under the impression this required a different syntax, as it was from an earlier discussion I ear-marked this from stroustrup's notes as a solution, but it's a been a while and I've forgotten how to harness it:

Code:

template<class T> inline void destroy(T*& p) { delete p; p = 0; }

I noted to myself the T*& syntax was the key to solving the problem... but maybe I'm way off... does it in any way pertain to what I'm trying to do?

I guess you can use partial specialization:

Code:

#include <boost/static_assert.hpp>

template <class T>
class X
{
    BOOST_STATIC_ASSERT(sizeof(T)==0 && "non-pointer argument to X");
};

template <class T>
class X<T*>
{
};

int main()
{
    X<int*> y;  //OK
    //X<int> x;  //triggers STATIC_ASSERT
}

Another thing, if the class is meant for pointers, it might contain code that wouldn't compile anyway if the argument was not a pointer.

Also, in the case of the destroy function, the template argument is a non-pointer type:

Code:

int* p = new int;
destroy<int>(p);

If you try to pass a non-pointer you'll get an error (no matching function to call).

Thanks. Just out of curiosity what is

Code:

template< class T* > class Foo{};

saying anyways? It compiles fine, but instantiating an object of type Foo doesn't seem to be possible.

Nothing. It is a syntax error.
Since a template declaration should specify placeholders for types, you cannot give them any explicit types such as pointer-types.
So...

Code:

template<typename T> class Foo{};

...is fine, but...

Code:

template<typename T*> class Foo{};

...is not.

Nothing. It is a syntax error.

Maybe even a misunderstanding of the concept.
Will this line _ever_ be valid, even if it were not a template parameter? No.

This, however, is correct:

Code:

template<someClass* T>

or this

Code:

template<someClass& T>