template<typename T>
struct Base
{
    typename T::X m_x;
    void foo()
    {
        ((T *)this)->bar();
    }
};

struct A : public Base<A>
{
    typedef int X;
    void bar()
    {
    }
};

А>template<typename T>
А>struct Base
А>{
А>    typename T::X m_x;
А>    void foo()
А>    {
А>        ((T *)this)->bar();
А>    }
А>};

А>struct A : public Base<A>
А>{
А>    typedef int X;
А>    void bar()
А>    {
А>    }
А>};
А>

class A;

class B
{
...
void f(A *p_a)
 {
 p_a->foo(); // Ошибка, класс еще не описан, только объявлен
 }
};

class A
{
public:
 void foo()
 {
 ...
 }
};

Instead of polymorphism based on type compatibility, we have polymorphism based on signature compatibility. As long as the type has appropriate function signatures available, the compiler is perfectly happy. This kind of polymorphism has some interesting properties, of which ATL makes heavy use.

template<typename T, typename X>
struct Base
{
    X m_x;
    X foo()
    {
        return ((T *)this)->bar();
    }
};

struct A : public Base<A, int>
{
    typedef int X;
    X bar()
    {
      return X();
    }
};

  ((T *)this)->bar();

  static_cast<T*>(this)->bar();

template<typename T>
struct Base
{
    struct inner
    {
        typename T::X m_x;
    };
    void foo()
    {
        ((T *)this)->bar();
    }
};

struct A : public Base<A>
{
    typedef int X;
    void bar()
    {
    }
};

template<typename derived_t>
class base
{
  typedef derived_t::type type;
};

class derived : base<derived>
{
  typedef base<derived>::type type;
};

template<typename derived_t>
struct base
{
  derived_t m;
};

struct derived : base<derived>
{
};

template<typename T>
struct Base
{
    T::X m_x;        // Ошибка!!!
    void foo()
    {
        T::X m_x;    // Допустимо!!!
    }
};

template<typename T>
struct Base
{
    typename T::X m_x;
    void foo()
    {
        ((T *)this)->bar();
    }
};

struct A : public Base<A>
{
    typedef int X;
    void bar()
    {
    }
};

Unless a class template specialization has been explicitly instantiated (14.7.2) or explicitly specialized (14.7.3), the class template specialization is implicitly instantiated when the specialization is referenced in a context that requires a completely-defined object type or when the completeness of the class type affects the semantics of the program. The implicit instantiation of a class template specialization causes the implicit instantiation of the declarations, but not of the definitions or default arguments, of the class member functions, member classes, static data members and member templates; and it causes the implicit instantiation of the definitions of member anonymous unions.

The class-name in a base-specifier shall not be an incompletely defined class (clause 9)

For a class template specialization, a class member template specialization, or a specialization for a class member of a class template, if the specialization is implicitly instantiated because it is referenced from within another template specialization, if the context from which the specialization is referenced depends on a template parameter, and if the specialization is not instantiated previous to the instantiation of the enclosing template, the point of instantiation is immediately before the point of instantiation of the enclosing template. Otherwise, the point of instantiation for such a specialization immediately precedes the namespace scope declaration or definition that refers to the specialization.

template <class T>
    struct B
{
    B(int x = sizeof(typename T::type)) : // OK
        m(sizeof(typename T::type))       // OK
    {
        typename T::type t;               // OK
    }
    struct Nested
    {
        typename T::type m;               // ill-formed when T becomes D
    };
    int m;
    typename T::type t;                   // ill-formed when T becomes D
    static int s;
};

template <class T>
    int B<T>::s = sizeof(typename T::type);

//  the point of instantiation for:
//      struct B<D>,         (see 14.6.4.1/3)
//      struct B<D>::Nested  (see 14.6.4.1/3)

struct D : B<D>
{
    typedef int type;
    void f()
    {
        D().s += sizeof D::Nested().m;
    }
};

//  the point of instantiation for:
//      expression          sizeof(typename T::type)  (see 14.6.4.1/2)
//      ctor                B<D>::B(int)              (see 14.6.4.1/1)
//      static data member  B<D>::s                   (see 14.6.4.1/1)

int main() {}

template<typename T, typename XT>
struct Base
{
    typedef XT X;

    X m_x;
};

struct A : public Base<A, int>
{
    using Base::X; // Это объявление не является обязательным,
                   // если только класс A не шаблонный.
                   // Но я предпочитаю такие объявления делать 
                   // в любом случае - так нагляднее - сразу понятно, 
                   // где находится определение типа
    X m_x;
};