type that pointer points to

[Levent]

Hi,

Is there a generic way to dereference a pointer (of any order) enough
to get the underlying type that the whole thing points to?

Consider,

template <class P>
class Foo {
typename THIS_IS_THE_WAY_TO_DO_IT(P) member;
};

such that, say, for the following instantiation of the template class Foo,

Foo<int******> f;

f.member will be an int.

FWIW, I currently achieve this with specialization:

template <class P>
class Foo<P*> {
P member;
};

template <class P>
class Foo<P**> {
P member;
};

template <class P>
class Foo<P***> {
P member;
};

an so forth, which is not cool :)

[Ivan Vecerina]

"Levent" <sl**@pitt.edu> wrote in message
news:d5**********@usenet01.srv.cis.pitt.edu...

Is there a generic way to dereference a pointer (of any order) enough to
get the underlying type that the whole thing points to?

Consider,

template <class P>
class Foo {
typename THIS_IS_THE_WAY_TO_DO_IT(P) member;
};

such that, say, for the following instantiation of the template class Foo,

Foo<int******> f;

f.member will be an int.

The following shall do it:
template<class T>
struct FullDeref
{ typedef T Type; };

template<class T>
struct FullDeref<T*>
{ typedef typename FullDeref<T>::Type Type; };
template <class P>
class Foo {
typename FullDeref<P>::Type member;
};

// other usage example:
void foo()
{
FullDeref<int*****>::Type i = 5;
}

Ivan
--
http://ivan.vecerina.com/contact/?subject=NG_POST <- email contact form
Brainbench MVP for C++ <> http://www.brainbench.com

[Jonathan Mcdougall]

> Is there a generic way to dereference a pointer (of any order)
enough

to get the underlying type that the whole thing points to?

template <class P>
struct Foo
{
typedef P type;
};

template <class P>
struct Foo<P*>
{
typedef typename Foo<P>::type type;
};
Jonathan

[Levent]

this is what I call cool!
thx Ivan& Jonathan...

Jonathan Mcdougall wrote:

Is there a generic way to dereference a pointer (of any order)

enough

to get the underlying type that the whole thing points to?

template <class P>
struct Foo
{
typedef P type;
};

template <class P>
struct Foo<P*>
{
typedef typename Foo<P>::type type;
};
Jonathan