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

template<class T>
struct f: public uf<T>
{
  void operator()(type) const; // error: ‘type’ has not been declared|
};

template<class T>
struct f<T*>: public uf<T*>
{
  void operator()(type) const; // error: ‘type’ has not been declared|
};


void test()
{
  f<int> fi;
  f<int*> fpi;
}

typedef typename uf<T*>::type type;
void operator()(type) const;

14.6.2/3
In the definition of a class template or a member of a class template, if a base class of the class template
depends on a template-parameter, the base class scope is not examined during unqualified name lookup
either at the point of definition of the class template or member or during an instantiation of the class template
or member. [Example:

typedef double A;
template<class T> class B {
typedef int A;
};
template<class T> struct X : B<T> {
A a; // a has type double
};

A a; // error C2248: 'B<T>::A' : cannot access private typedef declared in class 'B<T>'

std::cout << typeid(X<void>().a).name() << std::endl; //Output: int

А>template<typename T>
А>struct uf
А>{
А>  typedef T type;
А>};

А>template<class T>
А>struct f: public uf<T>
А>{
А>  void operator()(type) const; // error: ‘type’ has not been declared|
А>};

А>template<class T>
А>struct f<T*>: public uf<T*>
А>{
А>  void operator()(type) const; // error: ‘type’ has not been declared|
А>};


А>void test()
А>{
А>  f<int> fi;
А>  f<int*> fpi;
А>}

template<class T>
struct f
{
  void operator()(UnknownType) const; 
};

typedef char type;

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

template<class T>
struct f: public uf<T>
{
  void operator()(type) const; // здесь type - это 'char'
};

//
void operator()(typename f<T>::template uf<T>::type);

//
void operator()(typename f::template uf<T>::type);

//
void operator()(typename f::type);

//
void operator()(typename uf<T>::type);

// и т.п.

//
using typename /* любой тип из вышеперечисленных */; 
void operator()(type) const; 

// Вариант c using полностью эквивалентен такому (Draft 7.3.3/20):

typedef typename /*...*/ type;
void operator()(type) const;

struct A 
{
  typedef int Integer;
};
struct B : A
{
  using A::Integer;
};

template<typename T>
struct A 
{
  typedef int Integer;
};
template<typename T>
struct B : A<T>
{
  using typename A<T>::Integer;
};

The keyword typename shall only be used in template declarations and definitions, including in the return type of a function template or member function template, in the return type for the definition of a member function of a class template or of a class nested within a class template, and in the type-specifier for the definition of a static member of a class template or of a class nested within a class template.

template<typename T>
struct B : T
{
  using T::X; //X без typename - не тип
  
   void f() {X();} //Ok
   X g(); //"ComeauTest.c", line 7: error: nontype "T::X" is not a type name
};

14.6/3
A qualified-id that refers to a type and in which the nested-name-specifier depends on a template-parameter (14.6.2) shall be prefixed by the keyword typename to indicate that the qualified-id denotes a type, forming an elaborated-type-specifier(7.1.5.3).

14.6/3
When a qualified-id is intended to refer to a type that is not a member of the current instantiation (14.6.2.1) ... it shall be prefixed by the keyword typename, forming a typename-specifier.