template <typename X> //Допустим мы обещаем, что в Х будет определён тип Type
class A
{
private:
    typedef X::Type myType;
/*
..........................
*/
}
template <typename X>
class B : public A<X>
{

   myType myMember;//Будет ли здесь определён тип myType по стандарту
}

class A
{
private:
     typedef unsigned int uint;
}

class B: public A
{
    uint bbb;//?????????????????
}

С>template <typename X> //Допустим мы обещаем, что в Х будет определён тип Type
С>class A
С>{
С>private:
С>    typedef X::Type myType; // перед X::Type нужен typename
С>/*
С>..........................
С>*/
С>}
С>

С>class A
С>{
С>private:
С>     typedef unsigned int uint;
С>}

С>class B: public A
С>{
С>    uint bbb;//?????????????????
С>}
С>

template <class T>
class Foo
{
public:
  Foo()
  {
      typedef ~~~ +++;
      +++ *x = new ~~~();
  }
};

С>>template <typename X> //Допустим мы обещаем, что в Х будет определён тип Type
С>>class A
С>>{
С>>private:
С>>    typedef X::Type myType; // перед X::Type нужен typename
С>>/*
С>>..........................
С>>*/
С>>}
С>>

class A
{
protected:
     typedef unsigned int uint;
};

class B: public A
{
    uint bbb;//?????????????????
};

С>class A
С>{
С>protected:
С>     typedef unsigned int uint;
С>};

С>class B: public A
С>{
С>    uint bbb;//?????????????????
С>};
С>

templace <class T>
struct A
{
typedef int MyInt;
};

template <class T>
struct B : public A<T> // Тип базового класса зависит от типа T, пока ещё не известного, т.е. мы не знаем что содержит A<T>
{
  MyInt y; // как, по-твоему, компилятор догадается, что MyInt это тип, определённый в A?
};

struct C : public A<void> // Тип базового класса полностью известен и мы уже знаем, есть там MyInt или нет.
{
  MyInt y;
};

class A
{
protected:
  typedef unsigned int uint;
};
class B : public A
{
  uint bbb;
};

template <typename X>
class A
{
protected:
  typedef typename X::Type myType;
};

template <typename X>
class B : public A<X>
{
  using typename A<X>::myType;
  myType myMember;
};