Как избежать понижения в этом конкретном дизайне иерархии классов?

Проблема с этим решением заключается в том, что каждый раз, когда мне нужно позвонить, например. в классе Button что-то вроде pimpl_->click() мне нужно преобразовать pimpl_, потому что метод clickA() находится не в FrameWorkABase, а в FrameWorkAButton, поэтому он будет выглядеть так (static_cast<FrameWorkAButton>(pimpl_))->click().

Я могу придумать три способа решить эту проблему:

1. Исключите Base::pimpl_ в пользу чистой виртуальной защищенной функции Base::pimpl_(). Пусть подклассы реализуют эту функцию, чтобы предоставить указатель реализации на Base::show (и любые другие функции базового класса, которым это необходимо).
2. Сделайте Base::pimpl_ закрытым, а не защищенным, и дайте подклассам собственную правильно типизированную копию указателя реализации. (Поскольку подклассы отвечают за вызов конструктора базового класса, они могут гарантировать, что они передают ему тот же указатель реализации, который они планируют использовать.)
3. Сделайте Base::show чистой виртуальной функцией (как и любые другие функции базового класса) и реализуйте ее в подклассах. Если это приводит к дублированию кода, создайте отдельную вспомогательную функцию, которую могут использовать подклассы.

Я думаю, что № 3 — лучший подход, потому что он позволяет избежать привязки вашей иерархии классов к иерархиям классов базовых фреймворков; но я подозреваю из ваших комментариев выше, что вы не согласитесь. Это нормально.

Например. если пользователь хочет создать подкласс кнопки из библиотеки UserButton : Button, ему нужно знать особенности шаблона идиомы pimpl, чтобы правильно инициализировать реализацию.

Независимо от вашего подхода, если вы не хотите, чтобы клиентский код устанавливал указатель реализации (поскольку это означает взаимодействие с базовой структурой), вам нужно будет предоставить конструкторы или фабричные методы, которые делают это. Поскольку вы хотите поддерживать наследование клиентским кодом, это означает предоставление конструкторов, которые обрабатывают это. Так что я думаю, что вы слишком быстро списали идиому Pimpl.

Что касается вашего редактирования — вместо того, чтобы иметь Base::impl и Button::impl extend FrameworkABase и FrameworkAButton, вы должны сделать FrameworkAButton членом данных для Button:: impl и дайте Base::impl просто указатель на него. (Или вы можете дать Button::impl std::unique_ptr для FrameworkAButton вместо того, чтобы удерживать его напрямую; это немного упрощает передачу указателя на Base::impl четко определенным способом.)

Например:

#include <memory>

//////////////////// HEADER ////////////////////

class Base {
public:
    virtual ~Base() { }
protected:
    class impl;
    Base(std::unique_ptr<impl> &&);
private:
    std::unique_ptr<impl> const pImpl;
};

class Button : public Base {
public:
    Button(int);
    virtual ~Button() { }
    class impl;
private:
    std::unique_ptr<impl> pImpl;
    Button(std::unique_ptr<impl> &&);
};

/////////////////// FRAMEWORK //////////////////

class FrameworkABase {
public:
    virtual ~FrameworkABase() { }
};

class FrameworkAButton : public FrameworkABase {
public:
    FrameworkAButton(int) {
        // just a dummy constructor, to show how Button's constructor gets wired
        // up to this one
    }
};

///////////////////// IMPL /////////////////////

class Base::impl {
public:
    // non-owning pointer, because a subclass impl (e.g. Button::impl) holds an
    // owning pointer:
    FrameworkABase * const pFrameworkImpl;

    impl(FrameworkABase * const pFrameworkImpl)
        : pFrameworkImpl(pFrameworkImpl) { }
};

Base::Base(std::unique_ptr<Base::impl> && pImpl)
    : pImpl(std::move(pImpl)) { }

class Button::impl {
public:
    std::unique_ptr<FrameworkAButton> const pFrameworkImpl;

    impl(std::unique_ptr<FrameworkAButton> && pFrameworkImpl)
        : pFrameworkImpl(std::move(pFrameworkImpl)) { }
};

static std::unique_ptr<FrameworkAButton> makeFrameworkAButton(int const arg) {
    return std::make_unique<FrameworkAButton>(arg);
}

Button::Button(std::unique_ptr<Button::impl> && pImpl)
    : Base(std::make_unique<Base::impl>(pImpl->pFrameworkImpl.get())),
      pImpl(std::move(pImpl)) { }
Button::Button(int const arg)
    : Button(std::make_unique<Button::impl>(makeFrameworkAButton(arg))) { }

///////////////////// MAIN /////////////////////

int main() {
    Button myButton(3);
    return 0;
}