C>template<int*>
C>class A1{};
C>template<double*>
C>class A2{}; // и т.д.
C>

C>typedef DesiredClass<A1>::Type A1_pT; // == int*
C>typedef DesiredClass<A2>::Type A2_pT; // == double*
C>

template<int*>
struct A1
{
  typedef int type;  
};

template<double*>
struct A2
{
  typedef double type;  
};

template<class T>
struct MetaProgrammingForeverClass
{
  typedef typename T::type type;
};

template<template<typename P> class T>
class A
{
};

template<template<typename P> template<P*> class T> // это не компилится
class A
{
};

template<int* P>
class T
{
};
typedef A<T> _AT;

C>template<template <typename P> template<P*> class T> // Это чего такое :)
C>class A
C>{
C>};
C>

template <template <class W> typename T>
class A
{
};

template<int*>
class A1{};
template<double*>
class A2{}; // и т.д.

typedef DesiredClass<A1>::Type A1_pT; // == int*
typedef DesiredClass<A2>::Type A2_pT; // == double*

K>template<int*>
K>struct A1
K>{
K>  typedef int type;  
K>};

K>template<double*>
K>struct A2
K>{
K>  typedef double type;  
K>};

K>template<class T>
K>struct MetaProgrammingForeverClass
K>{
K>  typedef typename T::type type;
K>};
K>

template <typename T>
struct TypeStripper
{
    typedef typename T type;
};

template <typename T>
struct TypeStripper<T*>
{
    typedef typename T type;
};

//
// И в итоге получаем:
template <typename T>
struct MetaProgrammingForeverClass
{
    typedef T::type type;
    typedef TypeStripper<T::type>::type stripped_type;
};