class A 
{
  class B{};
  class C{};
};

namespace std
{
    template <class T>
    class vector
    {
        class iterator
        {
            ...
        };
        ...
    };
    ...
};

std::vector<int>::iterator it;

struct fake
{
    struct nested;
    void uu(nested obj);
};

struct fake::nested
{
    void uu(fake obj);
};

void fake::uu(nested obj){}
void fake::nested::uu(fake obj){}

Ytz>namespace std
Ytz>{
Ytz>    template <class T>
Ytz>    class vector
Ytz>    {
Ytz>        class iterator
Ytz>        {
Ytz>            ...
Ytz>        };
Ytz>        ...
Ytz>    };
Ytz>    ...
Ytz>};

Ytz>std::vector<int>::iterator it;
Ytz>

namespace std
{
    template <class T>
    class vector_iterator
    {
    };

    template <class T>
    class vector
    {
        friend class vector_iterator<T>;
        typedef vector_iterator<T> iterator;
        ...
    };
    ...
};

std::vector<int>::iterator it;

S>class A 
S>{
S>  class B{};
S>  class C{};
S>};
S>

//Foo.hpp
//-------

class Foo
{
public:
  explicit Foo(const std::string& some_text);

  void bar();

  virtual ~Foo();

private:
  class Impl;
  shared_ptr<Impl> m;
};

//Foo.cpp
//-------

class Foo::Impl
{
public: 

  const std::string& text;

  Impl(const std::string& text) : text(text) { }
};

void Foo::bar()
{
  std::cout << m->text << std::endl;
}

//IFoo.hpp
//--------

class IFoo
{
public:
  virtual void foo() = 0;   
};

//Bar.hpp
//-------

class Bar
{
public:

  shared_ptr<IFoo> create_foo();

private:
  class Foo;
};

//Bar.cpp
//-------

class Bar::Foo : public IFoo
{
public:
  Foo(Bar* owner) {/*...*/}  

  virtual void foo() {/*...*/}
};

shared_ptr<IFoo> Bar::create_foo()
{
  return shared_ptr<Foo>(new Foo(this));
}

template<typename T>
class random_access_iterator { /*...*/ };

template<typename T>
class vector
{
public:
#if _DEBUG
  typedef random_access_iterator iterator;
#else
  typedef T* iterator;
#endif

/*...*/
};

S>>class A 
S>>{
S>>  class B{};
S>>  class C{};
S>>};
S>>

template<typename T>
class Outer
{
public:

  template<typename Q>
  class Inner
  {
  public:
     T foo(const Q&);  
  };
};

template<typename T, typename Q>
class InnerBase
{
public:
   T foo(const Q&);  
};

template<typename T>
class Outer
{
public:
 
  template<typename Q>
  using Inner = InnerBase<T, Q>;
};

template<typename T, typename Q>
class InnerBase
{
public:
   T foo(const Q&);  
};

template<typename T>
class Outer
{
public:
 
  template<typename Q>
  struct Inner 
  {
      typedef InnerBase<T, Q> Type;
  };
};

E>Ну можно другом объявлять вложенные классы всегда. Тогда будет совместимо...

11.4 Friends [class.friend]
1 A friend of a class is a function or class that is not a member of the class but is permitted to use the private
and protected member names from the class. The name of a friend is not in the scope of the class, and the
friend is not called with the member access operators (5.2.5) unless it is a member of another class.
...

11.3 Friends [class.friend]
1 A friend of a class is a function or class that is given permission to use the private and protected member
names from the class. A class specifies its friends, if any, by way of friend declarations. Such declarations give
special access rights to the friends, but they do not make the nominated friends members of the befriending
class.
...

11.7 Nested classes [class.access.nest]
1 A nested class is a member and as such has the same access rights as any other member. The members of
an enclosing class have no special access to members of a nested class; the usual access rules (Clause 11)
shall be obeyed. [ Example:

class E {
    int x;
    class B { };
    
    class I {
        B b; // OK: E::I can access E::B
        int y;
        void f(E* p, int i) {
            p->x = i; // OK: E::I can access E::x
        }
    };
    
    int g(I* p) {
        return p->y; // error: I::y is private
    }
};

—end example ]

E>>Если тебе нужно приватное или защищённое наследование, то с таким приведением будут проблемы. Можно, конечно, объявить базу своим другом. Но можно и не базу, а какую-то вложенную в базу структурку методы которой умеют осуществлять все нужные конверсии...

struct SimpleListTag {};
template<typename TNode, typename TList = SimpleListTag> class CListBase {
protected:    
    // Все непубличные наследники CListBase и CNodeBase вплоть до TList и  TNode должны иметь в друзьях этот класс.
    // Он используется для преобразований TList и  TNode в CListBase и CNodeBase и обратно.
    class TypeConvertor {
        friend CListBase;
        static const CListBase* toBase( const TList* list ) { return list; }
        static CListBase* toBase( TList* list ) { return list; }
        
        static const CNodeBase* toBase( const TNode* node ) { return node; }
        static CNodeBase* toBase( TNode* node ) { return node; }
        
        static TNode* toNode( CNodeBase* node ) { return static_cast<TNode*>( node ); }
        static TList* toList( CListBase* list ) { return static_cast<TList*>( list ); }
    }; 
private:    
    static const CNodeBase* toBase( const TNode* node ) { return TypeConvertor::toBase( presumePtr( node ) ); }
    static CNodeBase* toBase( TNode* node ) { return TypeConvertor::toBase( presumePtr( node ) ); }
    static CListBase* toBase( TList* list ) { return TypeConvertor::toBase( presumePtr( list ) ); }
};     
template<typename TNode> 
class CListBase<TNode, SimpleListTag> : public CListBase< TNode, CListBase<TNode> > {};

//SomeOther.hpp

template<typename, typename> class InnerBase; //forward declaration

class SomeOther
{
public:

  typedef InnerBase<int, long> Foo;

  void bar(const Foo&);

private:
  shared_ptr<Foo> _foo;
};