class F{
public:
  template<class T> 
  int func(T::B& a){return 0;}
};

int main()
{
  A<C>::B a;
  F f;
  int rc = f.func(a);
    
  return 0;
}

class C{
    typedef XXX B;
};
class A{
    typedef typename C::B B;
    template<class A> int CLASS::func(A::B& a){return 0;}
};

    A::B a;
    func(a);

struct XXX
{
    int a,b,c;
};

class C{
public:
    typedef XXX B;
};

template<class T> 
class A{
public:
    typedef /*typename*/ T::B B;
};

class F{
public:
    template<class T> 
    int func(T::B& a){return 0;}
};

int main(int argc, char* argv[])
{

    A<C>::B a;
    F f;
    int rc = f.func(a);
    
    return 0;
}

U>class F{
U>public:
U>  template<class T> 
U>  int func(T::B& a){return 0;}
U>};

U>int main()
U>{
U>  A<C>::B a;
U>  F f;
U>  int rc = f.func(a);
    
U>  return 0;
U>}
U>

struct XXX
{
    int a,b,c;
};

class C{
public:
    typedef XXX B;
};

template<class T> 
class A{
public:
    typedef typename T::B B;
};

typedef A<C> AC;

class F{
public:
    template<class T> 
    int func(typename T::B& a){return 0;}
};

int main(int argc, char* argv[])
{
    AC::B a;
    F f;
    int rc = f.func<AC>(a);
    return 0;
}

int rc = f.func<AC>(a);

w40>int rc = f.func<AC>(a);
w40>

w40>выходит, что в 6-ом (класс-)функции нельзя явно указать аргумент темплэйта

VC6 is not up to C++ standards.

w40> int rc = f.func<AC>(a);
w40>

w40> выходит, что в 6-ом (класс-)функции нельзя явно указать аргумент темплэйта

    template<class T> 
    int func(typename T & a) {return 0;}

template<class T> struct MakePointer { typedef T* type; };
// решатель уравнения MakePointer<T>::type = P
// то есть, MakePointer<MakePointerIs<P>::type>::type == P
template<class P> struct MakePointerIs;
template<class T> struct MakePointerIs<T*> { typedef T type; };

template<class T> struct MakeConst { typedef T const type; };
// инъекция: область значений уже области определения
template<class C> struct MakeConstIs;
template<class T> struct MakeConstIs<T const> { typedef T type; }; // одно из решений (второе - это T const)
// либо надо возвращать множество ответов: boost::mpl::vector<T, T const>

template<class T> struct MakeUnsigned        { typedef unsigned int type; };
template<>        struct MakeUnsigned<long>  { typedef unsigned long type; };
template<>        struct MakeUnsigned<short> { typedef unsigned short type; };
// ещё одна инъекция...
template<class U> struct MakeUnsignedIs;
template<> struct MakeUnsignedIs<unsigned long>  { typedef long type; };
template<> struct MakeUnsignedIs<unsigned short> { typedef short type; };
template<> struct MakeUnsignedIs<unsigned int>   { typedef int type; }; // произвольное решение
// тут уже множество не вернёшь

template<class T> struct MakeStrange        { typedef T*** type; };
template<class T> struct MakeStrange<T*>    { typedef T type; };
template<>        struct MakeStrange<int>   { typedef char***** type; };
template<>        struct MakeStrange<short> { typedef char type; };
// значению char соответстует параметр short или char*
// значению T*** соответстует T**** или T
// значению char***** соответствует int, char** или char******
// в любом случае, значению T соответствует T* и ещё что-нибудь
template<class S> struct MakeStrangeIs { typedef S* type; };

template<class T> struct alfa  { typedef int aaa; };
template<class T> struct beta  { typedef T* bbb; };
template<class T> struct gamma { typedef T* aaa; typedef T** bbb; };

// решаем уравнение: TPL<T>::aaa = int
// ответ: TPL = gamma
// если нам нужен не просто TPL<T>, а TPL в чистом виде, то придётся исхитриться

template<template<typename> class ABG> struct rebinder // передавать шаблон мы можем...
{
  template<class T> struct rebind { typedef ABG<T> abg; }; // а вот возвращать - нет; только конкретный тип
  // поэтому напишем метафункцию, выполняющую ту же работу - подставляющую параметры в шаблон
};
// напишем решатель с помощью заготовки
template<class T> struct solve_aaa;
template<>        struct solve_aaa<int> : rebinder<alfa> {};
template<class T> struct solve_aaa<T*>  : rebinder<gamma> {};

struct CPkt4 
{
    int a,b,c;
};
struct CLess4
{
    typedef CPkt4 CXPkt;
};

template<class CLessT>
class CTcpStreamT 
{
public:
    typedef CLessT CLess;
    typedef typename CLess::CXPkt CXPkt;
};
typedef CTcpStreamT<CLess4> CTcpStream4;

template<class CTcpStreamT>
class CTcpCollectorT
{
public:
    typedef typename CTcpStreamT CTcpStream;
    typedef typename CTcpStream::CXPkt CXPkt;
};
typedef CTcpCollectorT<CTcpStream4> CTcpCollector4;

class CTcpCollectorWrapper
{
public:
    CTcpCollector4 m_TcpCollector4;
    //здесь еще .. CTcpCollector6 m_TcpCollector6;

    template<class CTcpCollectorT>
    int _process_packetT(CTcpCollectorT& collector, /*CPkt4&*/ typename CTcpCollectorT::CXPkt& a)
    {
        printf("%d %d %d \n",a.a,a.b,a.c);
        return 0;
    }
};

int main(int argc, char* argv[])
{
    CTcpCollectorWrapper w;
    CTcpCollector4::CXPkt x = {12,13,14};
    w._process_packetT(w.m_TcpCollector4, x);
    return 0;
}

template<class CTcpCollectorT> int _process_packetT(T& collector, typename CTcpCollectorT::CXPkt& a)

template<class T> int _process_packetT(T& collector, typename T::CXPkt& a)