std :: unique_ptr dengan tipe tidak lengkap tidak akan dikompilasi

Saya menggunakan idiom-jerawat dengan std::unique_ptr:

class window {
  window(const rectangle& rect);

private:
  class window_impl; // defined elsewhere
  std::unique_ptr<window_impl> impl_; // won't compile
};

Namun, saya mendapatkan kesalahan kompilasi tentang penggunaan tipe yang tidak lengkap, pada baris 304 di <memory>:

Aplikasi ' sizeof' ke jenis yang tidak lengkap ' uixx::window::window_impl' tidak valid

Sejauh yang saya tahu, std::unique_ptrharus bisa digunakan dengan tipe yang tidak lengkap. Apakah ini bug di libc ++ atau saya melakukan sesuatu yang salah di sini?

Berikut adalah beberapa contoh std::unique_ptrdengan tipe tidak lengkap. Masalahnya terletak pada kehancuran.

Jika Anda menggunakan pimpl unique_ptr, Anda harus mendeklarasikan sebuah destruktor:

class foo
{ 
    class impl;
    std::unique_ptr<impl> impl_;

public:
    foo(); // You may need a def. constructor to be defined elsewhere

    ~foo(); // Implement (with {}, or with = default;) where impl is complete
};

karena jika tidak kompiler menghasilkan yang default, dan perlu deklarasi lengkap foo::impluntuk ini.

Jika Anda memiliki konstruktor template, maka Anda kacau, bahkan jika Anda tidak membangun impl_anggota:

template <typename T>
foo::foo(T bar) 
{
    // Here the compiler needs to know how to
    // destroy impl_ in case an exception is
    // thrown !
}

Pada lingkup namespace, menggunakan unique_ptrtidak akan berfungsi:

class impl;
std::unique_ptr<impl> impl_;

karena kompiler harus tahu di sini cara menghancurkan objek durasi statis ini. Solusi adalah:

class impl;
struct ptr_impl : std::unique_ptr<impl>
{
    ~ptr_impl(); // Implement (empty body) elsewhere
} impl_;

Seperti yang disebutkan oleh Alexandre C. , masalahnya windowadalah destruktor didefinisikan secara implisit di tempat-tempat di mana tipe window_implmasih belum lengkap. Selain solusinya, solusi lain yang saya gunakan adalah mendeklarasikan fungsi Deleter di header:

// Foo.h

class FooImpl;
struct FooImplDeleter
{
  void operator()(FooImpl *p);
};

class Foo
{
...
private:
  std::unique_ptr<FooImpl, FooImplDeleter> impl_;
};

// Foo.cpp

...
void FooImplDeleter::operator()(FooImpl *p)
{
  delete p;
}

Perhatikan bahwa menggunakan fungsi Deleter kustom menghalangi penggunaan std::make_unique(tersedia dari C ++ 14), seperti yang sudah dibahas di sini .

gunakan deleter khusus

Masalahnya adalah bahwa unique_ptr<T>harus memanggil destructor T::~T()di destructor sendiri, operator penugasan langkahnya, dan unique_ptr::reset()fungsi anggota (hanya). Namun, ini harus dipanggil (secara implisit atau eksplisit) dalam beberapa situasi PIMPL (sudah ada di destruktor kelas luar dan operator penugasan pemindahan).

Seperti sudah ditunjukkan dalam jawaban lain, salah satu cara untuk menghindari itu adalah untuk memindahkan semua operasi yang membutuhkan unique_ptr::~unique_ptr(), unique_ptr::operator=(unique_ptr&&)dan unique_ptr::reset()ke dalam file sumber di mana kelas pimpl helper sebenarnya didefinisikan.

Namun, ini agak merepotkan dan menentang titik pimpl idoim sampai batas tertentu. Solusi yang jauh lebih bersih yang menghindari semua itu adalah dengan menggunakan custom deleter dan hanya memindahkan definisinya ke file sumber tempat tinggal kelas pembantu jerawat. Ini adalah contoh sederhana:

// file.h
class foo
{
  struct pimpl;
  struct pimpl_deleter { void operator()(pimpl*) const; };
  std::unique_ptr<pimpl,pimpl_deleter> m_pimpl;
public:
  foo(some data);
  foo(foo&&) = default;             // no need to define this in file.cc
  foo&operator=(foo&&) = default;   // no need to define this in file.cc
//foo::~foo()          auto-generated: no need to define this in file.cc
};

// file.cc
struct foo::pimpl
{
  // lots of complicated code
};
void foo::pimpl_deleter::operator()(foo::pimpl*ptr) const { delete ptr; }

Alih-alih kelas deleter yang terpisah, Anda juga dapat menggunakan fungsi gratis atau staticanggota foodalam hubungannya dengan lambda:

class foo {
  struct pimpl;
  static void delete_pimpl(pimpl*);
  std::unique_ptr<pimpl,[](pimpl*ptr){delete_pimpl(ptr);}> m_pimpl;
};

Mungkin Anda memiliki beberapa fungsi tubuh dalam file .h dalam kelas yang menggunakan tipe tidak lengkap.

Pastikan bahwa dalam .h Anda untuk jendela kelas Anda hanya memiliki deklarasi fungsi. Semua badan fungsi untuk jendela harus dalam file .cpp. Dan untuk window_impl juga ...

Btw, Anda harus secara eksplisit menambahkan deklarasi destructor untuk kelas windows di file .h Anda.

Tapi Anda TIDAK BISA memasukkan tubuh dokumen kosong ke file header Anda:

class window {
    virtual ~window() {};
  }

Harus hanya deklarasi:

  class window {
    virtual ~window();
  }

Untuk menambah balasan orang lain tentang deleter khusus, di "perpustakaan utilitas" internal kami, saya menambahkan header pembantu untuk menerapkan pola umum ini ( std::unique_ptrdari tipe yang tidak lengkap, hanya diketahui oleh beberapa TU untuk mis. Menghindari waktu kompilasi yang lama atau untuk menyediakan hanya pegangan buram untuk klien).

Ini menyediakan perancah umum untuk pola ini: kelas deleter kustom yang memanggil fungsi deleter yang ditentukan secara eksternal, tipe alias untuk dengan unique_ptrdengan kelas deleter ini, dan makro untuk mendeklarasikan fungsi deleter dalam TU yang memiliki definisi lengkap dari Tipe. Saya pikir ini memiliki kegunaan umum, jadi ini dia:

#ifndef CZU_UNIQUE_OPAQUE_HPP
#define CZU_UNIQUE_OPAQUE_HPP
#include <memory>

/**
    Helper to define a `std::unique_ptr` that works just with a forward
    declaration

    The "regular" `std::unique_ptr<T>` requires the full definition of `T` to be
    available, as it has to emit calls to `delete` in every TU that may use it.

    A workaround to this problem is to have a `std::unique_ptr` with a custom
    deleter, which is defined in a TU that knows the full definition of `T`.

    This header standardizes and generalizes this trick. The usage is quite
    simple:

    - everywhere you would have used `std::unique_ptr<T>`, use
      `czu::unique_opaque<T>`; it will work just fine with `T` being a forward
      declaration;
    - in a TU that knows the full definition of `T`, at top level invoke the
      macro `CZU_DEFINE_OPAQUE_DELETER`; it will define the custom deleter used
      by `czu::unique_opaque<T>`
*/

namespace czu {
template<typename T>
struct opaque_deleter {
    void operator()(T *it) {
        void opaque_deleter_hook(T *);
        opaque_deleter_hook(it);
    }
};

template<typename T>
using unique_opaque = std::unique_ptr<T, opaque_deleter<T>>;
}

/// Call at top level in a C++ file to enable type %T to be used in an %unique_opaque<T>
#define CZU_DEFINE_OPAQUE_DELETER(T) namespace czu { void opaque_deleter_hook(T *it) { delete it; } }

#endif

Mungkin bukan solusi terbaik, tetapi terkadang Anda dapat menggunakan shared_ptr sebagai gantinya. Jika tentu saja ini agak berlebihan, tapi ... seperti untuk unique_ptr, saya mungkin akan menunggu 10 tahun lagi sampai pembuat standar C ++ akan memutuskan untuk menggunakan lambda sebagai deleter.

Sisi lain. Per kode Anda itu mungkin terjadi, bahwa pada tahap kehancuran window_impl tidak akan lengkap. Ini bisa menjadi alasan perilaku yang tidak terdefinisi. Lihat ini: Mengapa, sungguh, menghapus tipe yang tidak lengkap adalah perilaku yang tidak terdefinisi?

Jadi, jika mungkin saya akan mendefinisikan objek yang sangat dasar untuk semua objek Anda, dengan destruktor virtual. Dan kamu hampir baik. Anda hanya perlu mengingat bahwa sistem akan memanggil penghancur virtual untuk pointer Anda, jadi Anda harus mendefinisikannya untuk setiap leluhur. Anda juga harus mendefinisikan kelas dasar di bagian warisan sebagai virtual (lihat ini untuk detailnya).