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

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?