class A
{
public:

A(...); // Какие-то параметры

protected:

class Private;
typedef std::shared_ptr<Private> PrivatePtr;

A(PrivatePtr that);

PrivatePtr m_private; // Реализация
};

class B : public A
{
public:

B(...); // Какие-то параметры

protected:

class Private;
typedef std::shared_ptr<Private> PrivatePtr;

PrivatePtr m_private; // Реализация
};

class A::Private
{
public:

Private(...); // Какие-то параметры
};

class B::Private : public A::Private
{
public:

Private(...); // Какие-то параметры
};

A::Private(aaa) {...aaa...}
A::A(aaa) : m_private(new A::Private(aaa)) {}

B::Private(aaabbb) : A::Private(aaa) {...bbb...} // как инициализировать реализацию предка - знает реализация потомка
B::B(aaabbb) : A(new B::Private(aaabbb)) {}

A::Private(AConfig) {...} // здесь - только логика создания реализации
A::A(aaa) : m_private(new A::Private(aconfig(aaa))) {} // а здесь - логика трансляции аргументов

B::Private(AConfig,BConfig) : A::Private(AConfig) {...} // здесь - только логика создания реализации, той и другой

B::B(aaabbb) : A(new B::Private(aconfig(aaa),bconfig(bbb))) {} // а здесь - и трансляция своих аргументов в аргументы предка, и своих в аргументы своей реализации

class A
{
  class PrivateA;
  struct PrivateDeleter
  {
    void operator()(PrivateA* p)const; // не инлайновый, определён после определения PrivateA, делает delete p;
  };
  typedef std::unique_ptr<PrivateA,PrivateDeleter> PrivatePtr;

public:
  A(aaaaa); // не инлайновый, определён после определения Private, делает m_private(new PrivateA(aaaaa))

protected:
  A(PrivatePtr&& p) : m_private(p) {}

  PrivateA& privateA() const { return *m_private; }
};

class B : public A
{
  class PrivateB; // : public A::PrivateA

public:
  B(bbbbb); // не инлайновый, определён после определения Private, делает : A(PrivatePtr(new PrivateB(bbbbb))) {}

protected:
  PrivateB& privateB() const { return static_cast<PrivateB&>(privateA()); }
};

К>class A
К>{
К>  class PrivateA;
К>  struct PrivateDeleter
К>  {
К>    void operator()(PrivateA* p)const; // не инлайновый, определён после определения PrivateA, делает delete p;
К>  };
К>  typedef std::unique_ptr<PrivateA,PrivateDeleter> PrivatePtr;

typedef void (*TotalDeleter)(void*); // по мотивам boost::checked_delete
typedef std::unique_ptr<PrivateA, TotalDeleter> PrivatePtr;

// в .cpp

template<class T> void total_deleter(void* p) { delete (T*)p; } // в 11 стандарте не нашёл ничего похожего, может, плохо искал.

A::A(aaaaa) : m_private(new A(aaaaa), total_deleter<A>) {}

B::B(bbbbb) : A(PrivatePtr(new B(bbbbb), total_deleter<B>)) {}

// накидай в тела классов всякую дребедень по вкусу
class Foo { ..... };
class Bar : public Foo { ..... };

int main()
{
  Bar* b = new Bar;
  Foo* f = b;
  assert( static_cast<Bar*>(f) == b ); // только если нет виртуального наследования
  assert( dynamic_cast<Bar*>(f) == b ); // только при наличии в Foo виртуальных методов
  assert( reinterpret_cast<Bar*>(f) == b ); // самое стрёмное место: компилятор может сделать сдвиг базы, static_cast его учитывает, reinterpret - нет
}

К>// накидай в тела классов всякую дребедень по вкусу
К>class Foo { ..... };
К>class Bar : public Foo { ..... };

К>int main()
К>{
К>  Bar* b = new Bar;
К>  Foo* f = b;
К>  assert( static_cast<Bar*>(f) == b ); // только если нет виртуального наследования
К>  assert( dynamic_cast<Bar*>(f) == b ); // только при наличии в Foo виртуальных методов
К>  assert( reinterpret_cast<Bar*>(f) == b ); // самое стрёмное место: компилятор может сделать сдвиг базы, static_cast его учитывает, reinterpret - нет
К>}
К>

B::B(new A) 
{
m_private = static_cast<B::Private*>(A::GetPrivate()); // Возвращаем m_private из A
}

К>>// накидай в тела классов всякую дребедень по вкусу
К>>class Foo { ..... };
К>>class Bar : public Foo { ..... };

К>>int main()
К>>{
К>>  Bar* b = new Bar;
К>>  Foo* f = b;
К>>  assert( static_cast<Bar*>(f) == b ); // только если нет виртуального наследования
К>>  assert( dynamic_cast<Bar*>(f) == b ); // только при наличии в Foo виртуальных методов
К>>  assert( reinterpret_cast<Bar*>(f) == b ); // самое стрёмное место: компилятор может сделать сдвиг базы, static_cast его учитывает, reinterpret - нет
К>>}
К>>

ATP> — я так понимаю, все проходит корректно так как первые две строчки main — рядом. А если:

ATP>B::B(new A) 
ATP>{
ATP>m_private = static_cast<B::Private*>(A::GetPrivate()); // Возвращаем m_private из A
ATP>}
ATP>

public.h

class A
{
public:
  class impl; // поскольку impl не виден наружу можем смело делать его public

  A(impl *ptr = nullptr); // если impl != nullptr запоминаем, иначе создаем

// методы, методы, методы...
};

class B : public A
{
public:
  class impl;

  B(impl *ptr = nullptr); // если impl != nullptr запоминаем, иначе создаем

// методы, методы, методы...
};


private.h

class impl::A
{
};

class impl::B : public impl::A
{
};

_>Но прежде чем такое делать, надо серьезно подумать о целесообразности. Кол-во файлов и геморроя умножается на 2

_>public.h

_>class A
_>{
_>public:
_>  class impl; // поскольку impl не виден наружу можем смело делать его public

_>  A(impl *ptr = nullptr); // если impl != nullptr запоминаем, иначе создаем

_>// методы, методы, методы...
_>};

_>class B : public A
_>{
_>public:
_>  class impl;

_>  B(impl *ptr = nullptr); // если impl != nullptr запоминаем, иначе создаем

_>// методы, методы, методы...
_>};


_>private.h

_>class impl::A
_>{
_>};

_>class impl::B : public impl::A
_>{
_>};
_>

B::B(...) 
: A(new B::impl(...))
, m_imple(????) // Как сюда получить копию указателя ????
{
...
}

ATP>Ну так это в точности тоже самое что и у меня . Это мне и нужно... А расскажите про самое интересное: если B::impl создавать снаружи B то, да проблем нет. Но я то, пытаюсь сделать чтобы B создавал impl в конструкторе. Тогда имеем:

ATP>B::B(...) 
ATP>: A(new B::impl(...))
ATP>, m_imple(????) // Как сюда получить копию указателя ????
ATP>{
ATP>...
ATP>}
ATP>

B::B(impl *p_impl = nullptr) : A(!p_impl ? p_impl = new impl() : p_impl), m_impl(p_impl) {}