下面是一些带有不完整类型的std::unique_ptr的例子。问题在于破坏。

如果你在unique_ptr中使用pimpl，你需要声明析构函数:

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
};

因为否则编译器会生成一个默认值，并且它需要为此完整地声明foo::impl。

如果你有模板构造函数，那么你就完蛋了，即使你没有构造impl_成员:

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

在命名空间范围内，使用unique_ptr也将不起作用:

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

因为编译器必须知道如何销毁这个静态持续时间对象。解决方法是:

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

正如亚历山大·C。所提到的，问题归结为window的析构函数隐式定义在window_impl类型仍然不完整的地方。除了他的解决方案，我使用的另一个解决方案是在头文件中声明一个Deleter函子:

// 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;
}

注意，使用自定义delete函数排除了使用std::make_unique(从c++ 14可用)，正如已经讨论过的在这里。

可能在类的.h文件中有一些使用不完全类型的函数体。

确保在.h for class窗口中只有函数声明。window的所有函数体必须在.cpp文件中。对于window_impl也是如此…

顺便说一句，你必须在你的.h文件中显式地为windows类添加析构函数声明。

但是你不能在头文件中放空的dtor主体:

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

肯定只是个宣言:

  class window {
virtual ~window();
}

使用自定义删除器

问题是unique_ptr<T>必须在它自己的析构函数、它的move赋值操作符和unique_ptr::reset()成员函数中调用析构函数T::~T()(仅)。但是，在几种PIMPL情况下(已经在外部类的析构函数和move赋值操作符中)必须调用这些函数(隐式或显式)。

正如在另一个答案中已经指出的那样，避免这种情况的一种方法是将需要unique_ptr::~unique_ptr()、unique_ptr::operator=(unique_ptr&&)和unique_ptr::reset()的所有操作移动到pimpl helper类实际定义的源文件中。

然而，这是相当不方便的，在某种程度上违背了皮条客习俗的要点。一个更干净的解决方案是使用自定义删除人并只将其定义移动到piple helper类所在的源文件中。这里有一个简单的例子:

// 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; }

除了单独的删除器类，你还可以使用一个自由函数或foo的static成员:

class foo {
struct pimpl;
static void delete_pimpl(pimpl*);
using deleter = void(&)(pimpl*);
std::unique_ptr<pimpl,deleter> m_pimpl;
public:
foo(some data);
};

为了添加到对方关于自定义删除器的回复，在我们的内部“实用程序库”中，我添加了一个helper报头来实现这个通用模式(std::unique_ptr类型不完整，只有一些TU知道，例如，避免长时间编译或仅为客户端提供一个不透明的句柄)。

它为这种模式提供了通用的脚手架:一个调用外部定义的删除器函数的自定义删除器类，一个具有此删除器类的unique_ptr的类型别名，以及一个宏，用于在TU中声明删除器函数，TU具有该类型的完整定义。我认为这有一些普遍的用处，所以它是:

#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

可能不是最好的解决方案，但有时你可以使用要查看代替。 当然这有点太夸张了，但是……至于unique_ptr，我可能要再等10年，直到c++标准制定者决定使用lambda作为删除器 < p >另一侧。 根据你的代码，在销毁阶段，window_impl可能是不完整的。这可能是未定义行为的原因。 看到这个: 为什么，真的，删除一个不完整的类型是未定义的行为? < / p >

如果可能的话，我会用虚析构函数为所有对象定义一个非常基本的对象。你就快好了。你只需要记住，系统会为指针调用虚析构函数，所以你应该为每个祖先定义它。你还应该在继承部分中将基类定义为虚类(详见这)。

使用extern template

使用std::unique_ptr<T>(其中T是不完整类型)的问题是，unique_ptr需要能够删除T的实例以进行各种操作。类unique_ptr使用std::default_delete<T>删除实例。因此，在一个理想的世界，我们将只是写

extern template class std::default_delete<T>;

来防止std::default_delete<T>被实例化。然后,宣布

template class std::default_delete<T>;

在T完成的地方，将实例化模板。

这里的问题是default_delete实际上定义了不会被实例化的内联方法。所以,这个想法行不通。然而，我们可以解决这个问题。

首先，让我们定义一个不内联调用操作符的删除器。

/* --- opaque_ptr.hpp ------------------------------------------------------- */
#ifndef OPAQUE_PTR_HPP_
#define OPAQUE_PTR_HPP_


#include <memory>


template <typename T>
class opaque_delete {
public:
void operator() (T* ptr);
};


// Do not move this method into opaque_delete, or it will be inlined!
template <typename T>
void opaque_delete<T>::operator() (T* ptr) {
std::default_delete<T>()(ptr);
}

此外，为了便于使用，定义类型opaque_ptr，它结合了unique_ptr和opaque_delete，类似地，我们定义了make_opaque。

/* --- opaque_ptr.hpp cont. ------------------------------------------------- */
template <typename T>
using opaque_ptr = std::unique_ptr<T, opaque_delete<T>>;


template<typename T, typename... Args>
inline opaque_ptr<T> make_opaque(Args&&... args)
{
return opaque_ptr<T>(new T(std::forward<Args>(args)...));
}


#endif

类型opaque_delete现在可以与extern template构造一起使用。这里有一个例子。

/* --- foo.hpp -------------------------------------------------------------- */
#ifndef FOO_HPP_
#define FOO_HPP_


#include "opaque_ptr.hpp"


class Foo {
public:
Foo(int n);
void print();
private:
struct Impl;
opaque_ptr<Impl> m_ptr;
};


// Do not instantiate opaque_delete.
extern template class opaque_delete<Foo::Impl>;


#endif

因为我们阻止了opaque_delete被实例化，所以这段代码编译时不会出现错误。为了使链接器满意，我们在foo.cpp中实例化opaque_delete。

/* --- foo.cpp -------------------------------------------------------------- */


#include "foo.hpp"
#include <iostream>


struct Foo::Impl {
int n;
};


// Force instantiation of opaque_delete.
template class opaque_delete<Foo::Impl>;

其余的方法可以按如下方式实现。

/* --- foo.cpp cont. -------------------------------------------------------- */
Foo::Foo(int n)
: m_ptr(new Impl)
{
m_ptr->n = n;
}


void Foo::print() {
std::cout << "n = " << m_ptr->n << std::endl;
}

这种解决方案的优点是，一旦定义了opaque_delete，所需的样板代码相当小。