Is it possible to use type traits as a template parameter?

[Raider]

I'm trying to create a base class who will contain generic algoritms
and derived class(es) who will perform problem-specific things. I'm
unable to use dynamic polymorphism, because base class know nothing
about problem-specific types. I wrote the following code using static
polymorphism, but compiler do not allow me to use type traits as a
template parameter, the following code not compiles:

template <class CT>
struct InfoClass
{
int id;
CT content;
};

template <class T, class TTraits>
struct SomeImpl
{
void go()
{
T *pT = static_cast<T*>(this);
pT->go_implementation();
}

void set_pointer(TTraits::ptrtype newptr)
{
ptr = newptr;
}

typedef InfoClass<TTraits::basetype> obj_type;
std::vector<obj_type> v;

TTraits::ptrtype ptr;
};

struct SomeClassTraits
{
typedef int basetype;
typedef char* ptrtype;
};

struct SomeClass : public SomeImpl<SomeClass, SomeClassTraits>
{
void go_implementation()
{
cout << "SomeClass.go()" << endl;

// use ptr as a char*
// use v as a vector<InfoClass<int> >
}
};

void TestTemplateImpl()
{
SomeClass x;
x.go();
}
Of course I can expand this
template <class T, class TTraits> struct SomeImpl
to the
template <class T, typename basetype, typename ptrtype, ...> struct
SomeImpl
but it will be a problem to maintain large code, for example:

// SomeImpl.h
template <class T, class TTraits>
struct SomeImpl
{
void go();
void set_pointer(TTraits::ptrtype newptr);
// a lot of member functions...
};
#include "SomeImpl.inl"

// SomeImpl.inl
template <class T, class TTraits>
inline void SomeImpl::go()
{
// implementation of go()
}

template <class T, class TTraits>
inline void SomeImpl::set_pointer(TTraits::ptrtype newptr);
{
// implementation of go()
}

If list of types changes, I need to rewrite "template<>" header for
each member function :-(

Are there any possibilities to pass type traits to template as a single
argument?

[mlimber]

Raider wrote:

I'm trying to create a base class who will contain generic algoritms
and derived class(es) who will perform problem-specific things. I'm
unable to use dynamic polymorphism, because base class know nothing
about problem-specific types. I wrote the following code using static
polymorphism, but compiler do not allow me to use type traits as a
template parameter, the following code not compiles:
Why doesn't it compile? What error messages did you get and where?

template <class CT>
struct InfoClass
{
int id;
CT content;
};

template <class T, class TTraits>
struct SomeImpl
{
void go()
{
T *pT = static_cast<T*>(this);
pT->go_implementation();
}

void set_pointer(TTraits::ptrtype newptr)

[snip rest of code]

You need "typename" before that type and all others within TTraits.

Cheers! --M

[Victor Bazarov]

Raider wrote:

I'm trying to create a base class who will contain generic algoritms
and derived class(es) who will perform problem-specific things. I'm
unable to use dynamic polymorphism, because base class know nothing
about problem-specific types. I wrote the following code using static
polymorphism, but compiler do not allow me to use type traits as a
template parameter, the following code not compiles:
Of course it doesn't. It's missing some vital portions:

#include <vector>
#include <iostream>

template <class CT>
struct InfoClass
{
int id;
CT content;
};

template <class T, class TTraits>
struct SomeImpl
{
void go()
{
T *pT = static_cast<T*>(this);
pT->go_implementation();
}

void set_pointer(TTraits::ptrtype newptr)
void set_pointer(typename TTraits::ptrtype newptr)
{
ptr = newptr;
}

typedef InfoClass<TTraits::basetype> obj_type;
typedef InfoClass<typename TTraits::basetype> obj_type;
std::vector<obj_type> v;

TTraits::ptrtype ptr;
typename TTraits::ptrtype ptr;
};

struct SomeClassTraits
{
typedef int basetype;
typedef char* ptrtype;
};

struct SomeClass : public SomeImpl<SomeClass, SomeClassTraits>
{
void go_implementation()
{
cout << "SomeClass.go()" << endl;
std::cout << "SomeClass.go()" << std::endl;

// use ptr as a char*
// use v as a vector<InfoClass<int> >
}
};

void TestTemplateImpl()
{
SomeClass x;
x.go();
}
[...]

Are there any possibilities to pass type traits to template as a
single argument?

I think you need to learn about "dependent names".

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Raider]

> You need "typename" before that type and all others within TTraits.

Oh, really!!! I forgot about "typename" keyword...
Thank you for quick answer.