Идиома Pimpl как базовый класс шаблона

Да, есть несколько проблем, как я это вижу.

1. Ваш класс по сути является миксином. Речь идет не о динамическом полиморфизме, поэтому никто никогда не будет вызывать удаление для указателя на Pimpl<ObjectPrivate>. Отбросьте виртуальный деструктор. Это вводит накладные расходы, которые никогда не потребуются. То, что вам нужно, это только статический полиморфизм.

2. Вы выделяете объект с помощью new и освобождаете с помощью delete. Я не буду использовать ваш шаблон, потому что эта схема распределения не всегда подходит для моих приложений. Вы должны дать возможность настроить схему распределения, чтобы сделать ваш класс действительно полезным.

3. Ваш оператор присваивания не является безопасным для исключений. Если конструктор для T сбрасывает, вы теряете ранее сохраненные данные. ИМО, в этом случае лучше использовать copy and swap идиома.

Решение (1) и (2) состоит в том, чтобы добавить больше параметров шаблона, где первый для CRTP. Это позволит вам передавать операции, которые вы не знаете, как выполнять, в класс, который наследует ваш миксин. Он может переопределить их, определив свои собственные make, unmake и clone. И все они будут связаны статически.

template <class Handle, class Impl>
class Pimpl
{
private:
    Impl* _make() const
    { return ((Handle const*)this)->make(); }

    void _unmake(Impl *p) const
    { ((Handle const*)this)->unmake(p); }

    Impl* _clone(Impl *p) const
    { return ((Handle const*)this)->clone(p); }

    void swap(Pimpl &other) {
        Impl *temp = d_ptr;
        d_ptr = other.d_ptr;
        other.d_ptr = temp;
    }

public:
    explicit Pimpl();
            ~Pimpl();

    Pimpl(const Pimpl &other);
    Pimpl &operator=(const Pimpl &other);

    // fall-backs
    static Impl* make()          { return new Impl; }
    static void  unmake(Impl* p) { delete p; }
    static Impl* clone(Impl* p)  { return new Impl(*p); }

protected:

    Impl *d_ptr;
};

template<class Handle, class Impl>
Pimpl<Handle, Impl>::Pimpl() :
  d_ptr(_make())
{

}

template<class Handle, class Impl>
Pimpl<Handle, Impl>::~Pimpl()
{
    _unmake(d_ptr);
    d_ptr = 0;
}

template<class Handle, class Impl>
Pimpl<Handle, Impl>::Pimpl(const Pimpl &other) :
  d_ptr(_clone(other.d_ptr))
{

}

template<class Handle, class Impl>
Pimpl<Handle, Impl> &Pimpl<Handle, Impl>::operator=(const Pimpl &other)
{
    Pimpl copy(other);
    swap(copy);

    return *this;
}

Живой пример

Теперь ваш заголовок может компилироваться чисто. Пока деструктор для Object не определен встроенным. Когда он встроен, компилятор должен создать экземпляр деструктора шаблона везде, где включен object.h.

Если он определен в файле cpp после определения ObjectPrivate, то при создании экземпляра ~Pimpl будет отображаться полное определение частных частей.

Дополнительные идеи по улучшению:

1. Сделайте специальные элементы защищенными. В конце концов, их должен вызывать только производный класс Handle.

2. Добавить поддержку семантики перемещения.

Но я никогда не видел, чтобы он был реализован как базовый класс шаблона.

Это сделал Владимир Батов: https://github.com/yet-another-user/pimpl

Современная версия, которую я использую:

///////////////////////////////
// Header File
template <typename impl_t>
class Pimpl {
  public:
    Pimpl() = default;
    virtual ~Pimpl() = default;
    Pimpl(std::shared_ptr<impl_t> handle) : handle(handle) {}

    std::shared_ptr<impl_t>
    get_handle() const {
      return handle;
    }
  protected:
    std::shared_ptr<impl_t> handle;
};

class object_impl;
class object : public Pimpl<object_impl> {
/* whatever constructors you want*/
public:
  object(int x);
}

///////////////////////////////
// Cpp File
class object_impl {
public:
  object_impl(int x) : x_(x) {}
private:
  int x_;
}

object::object(int x) : Pimpl(std::make_shared<object_impl>(x)) {}