对于不完整类型使用std::unique_ptr时，会出现编译错误，本文分析了这个问题的原因，并提供了解决方案。
本文前半部分转载自此博客
Pimpl(Pointer to implementation)很多同学都不陌生，但是从原始指针升级到C++11的独占指针std::unique_ptr时，会遇到一个incomplete type的报错，本文来分析一下报错的原因以及分享几种解决方法~
问题现象
首先举一个传统C++中的Pimpl的例子
// widget.h
// 预先声明
class Impl;
class Widget
{
Impl * pImpl;
};
很简单，没什么问题，但是使用的是原始指针，现在我们升级到std::unique_ptr
// widget.h
// 预先声明
class Impl;
class Widget
{
std::unique_ptr<Impl> pImpl;
};
很简单的一次升级，而且也能通过编译，看似也没问题，但当你创建一个Widget的实例
// pimpl.cpp
#include "widget.h"
Widget w;
这时候，问题来了
$ g++ pimpl.cpp
In file included from /usr/include/c++/9/memory:80,
from widget.h:1,
from pimpl.cpp:1:
/usr/include/c++/9/bits/unique_ptr.h:
In instantiation of ‘void std::default_delete<_Tp>::operator()(_Tp*) const [with _Tp = Impl]’:
/usr/include/c++/9/bits/unique_ptr.h:292:17:
required from ‘std::unique_ptr<_Tp, _Dp>::~unique_ptr() [with _Tp = Impl; _Dp = std::default_delete<Impl>]’
widget.h:5:7: required from here
/usr/include/c++/9/bits/unique_ptr.h:79:16: error: invalid application of ‘sizeof’ to incomplete type ‘Impl’
79 | static_assert(sizeof(_Tp)>0,
| ^~~~~~~~~~~
原因分析
从报错我们可以看出，std::unique_ptr中需要静态检测类型的大小static_assert(sizeof(Impl)>0，但是我们的Impl是一个预先声明的类型，是incomplete type，也就没法计算，所以导致报错。
想要知道怎么解决，首先需要知道std::unique_ptr为啥需要计算这个，我们来看一下STL中相关的源码，从报错中得知是unique_ptr.h的292行，调用了79行，我们把前后相关源码都粘出来（来自g++ 9.3.0中的实现）
// 292行附近
/// Destructor, invokes the deleter if the stored pointer is not null.
~unique_ptr() noexcept
{
static_assert(__is_invocable<deleter_type&, pointer>::value,
"unique_ptr's deleter must be invocable with a pointer");
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
// 292行在这里
get_deleter()(std::move(__ptr));
__ptr = pointer();
}
// 79行附近
/// Primary template of default_delete, used by unique_ptr
template<typename _Tp>
struct default_delete
{
/// Default constructor
constexpr default_delete() noexcept = default;
/** @brief Converting constructor.
*
* Allows conversion from a deleter for arrays of another type, @p _Up,
* only if @p _Up* is convertible to @p _Tp*.
*/
template<typename _Up, typename = typename
enable_if<is_convertible<_Up*, _Tp*>::value>::type>
default_delete(const default_delete<_Up>&) noexcept { }
/// Calls @c delete @p __ptr
void
operator()(_Tp* __ptr) const
{
static_assert(!is_void<_Tp>::value,
"can't delete pointer to incomplete type");
// 79行在这里
static_assert(sizeof(_Tp)>0,
"can't delete pointer to incomplete type");
delete __ptr;
}
};
std::unique_ptr中的析构函数，调用了默认的删除器default_delete，而default_delete中检查了Impl，其实就算default_delete中不检查，到下一步delete __ptr;，还是会出问题，因为不完整的类型无法被delete。
解决方法
原因已经知道了，那么解决方法就呼之欲出了，这里提供三种解决方法：
- 方法一：改用std::shared_ptr
- 方法二：自定义删除器，将delete pImpl的操作，放到widget.cpp源文件中
- 方法三：仅声明Widget的析构函数，但不要在widget.h头文件中实现它
其中我最推荐方法三，它不改变代码需求，且仅做一点最小的改动，下面依次分析
方法一：改用std::shared_ptr
// widget.h
// 预先声明
class Impl;
class Widget
{
std::shared_ptr<Impl> pImpl;
};
改完就能通过编译了，这种改法最简单。但是缺点也很明显：使用shared_ptr可能会改变项目的需求，shared_ptr也会带来额外的性能开销，而且违反了“尽可能使用unique_ptr而不是shared_ptr”的原则（当然这个原则是我编的，哈哈）
那为什么unique_ptr不能使用预先声明的imcomplete type，但是shared_ptr却可以？
因为对于unique_ptr而言，删除器是类型的一部分：
template<typename _Tp, typename _Dp>
class unique_ptr<_Tp[], _Dp>
这里的_Tp是element_type，_Dp是deleter_type
而shared_ptr却不是这样：
template<typename _Tp>
class shared_ptr : public __shared_ptr<_Tp>
那为什么unique_ptr的删除器是类型的一部分，而shared_ptr不是呢？
答案是设计如此！哈哈，说了句废话。具体来说，删除器不是类型的一部分，使得你可以对同一种类型的shared_ptr，使用不同的自定义删除器
auto my_deleter = [](Impl * p) {...};
std::shared_ptr<Impl> w1(new Impl, my_deleter);
std::shared_ptr<Impl> w2(new Impl); // default_deleter
w1 = w2; // It's OK!
看到了么，这里的两个智能指针w1和w2，虽然使用了不同的删除器，但他们是同一种类型，可以相互进行赋值等等操作。而unique_ptr却不能这么玩
auto my_deleter = [](Impl * p) {...};
std::unique_ptr<Impl, decltype(my_deleter)> w1(new Impl, my_deleter);
std::unique_ptr<Impl> w2(new Impl); // default_deleter
// w1的类型是 std::unique_ptr<Impl, lambda []void (Impl *p)->void>
// w2的类型是 std::unique_ptr<Impl, std::default_delete<Impl>>
w1 = std::move(w2); // 错误！类型不同，没有重载operator=
道理我都明白了，那为什么要让这两种智能指针有这样的区别啊？
答案还是设计如此！哈哈，具体来说unique_ptr本身就只是对原始指针的简单封装，这样做不会带来额外的性能开销。而shared_ptr的实现提高了灵活性，但却进一步增大了性能开销。针对不同的使用场景所以有这样的区别。
方法二：自定义删除器，将delete pImpl的操作，放到widget.cpp源文件中
// widget.h
// 预先声明
class Impl;
class Widget
{
struct ImplDeleter final
{
constexpr ImplDeleter() noexcept = default;
void operator()(Impl *p) const;
};
std::unique_ptr<Impl, ImplDeleter> pImpl = nullptr;
};
然后在源文件widget.cpp中
#include "widget.h"
#include "impl.h"
void Widget::ImplDeleter::operator()(Impl *p) const
{
delete p;
}
这种方法改起来也不复杂，但是弊端也很明显，std::make_unique没法使用了，只能自己手动new，直接看源码吧
template<typename _Tp, typename... _Args>
inline typename _MakeUniq<_Tp>::__single_object
make_unique(_Args&&... __args)
{ return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
看出问题在哪了么？这里返回的是默认删除器类型的unique_ptr，即std::unique_ptr<Impl, std::default_delete
pImpl = std::make_unique<Impl>(); // 错误！类型不同，没有重载operator=
pImpl = std::unique_ptr<Impl, ImplDeleter>(new Impl); // 正确！每次你都要写这么一大串
当然你也可以实现一个make_impl，并且using一下这个很长的类型，比如：
using unique_impl = std::unique_ptr<Impl, ImplDeleter>;
template<typename... Ts>
unique_impl make_impl(Ts && ...args)
{
return unique_impl(new Impl(std::forward<Ts>(args)...));
}
// 调用
pImpl = make_impl();
看似还凑合，但总的来说，这样做还是感觉很麻烦。并且有一个很头疼的问题：make_impl作为函数模板，没法声明和定义分离，而且其中的用到了new，需要完整的Impl类型。所以，你只能把这一段模板函数写在源文件中，emmm，总感觉不太对劲。
方法三：仅声明Widget的析构函数，但不要在widget.h头文件中实现它
// widget.h
// 预先声明
class Impl;
class Widget
{
Widget();
~Widget(); // 仅声明
std::unique_ptr<Impl> pImpl;
};
// widget.cpp
#include "widget.h"
#include "impl.h"
Widget::Widget()
: pImpl(nullptr)
{}
Widget::~Widget() = default; // 在这里定义
这样就解决了！是不是出乎意料的简单！并且你也可以正常的使用std::make_unique来进行赋值。唯一的缺点就是你没法在头文件中初始化pImpl了
但也有别的问题，因为不光是析构函数中需要析构std::unique_ptr，还有别的也需要，比如移动构造、移动运算符等。所以在移动构造、移动运算符中，你也会遇到同样的编译错误。解决方法也很简单，同上面一样：
// widget.h
// 预先声明
class Impl;
class Widget
{
Widget();
~Widget();
Widget(Widget && rhs); // 同析构函数，仅声明
Widget& operator=(Widget&& rhs);
std::unique_ptr<Impl> pImpl;
};
// widget.cpp
#include "widget.h"
#include "impl.h"
Widget::Widget()
: pImpl(nullptr)
{}
Widget::~Widget() = default;
Widget(Widget&& rhs) = default; //在这里定义
Widget& operator=(Widget&& rhs) = default;
搞定！
本文后半部分为原创内容
需求背景
在一个项目中，有三个头文件的依赖关系一开始是这样的：A.hpp -> B.hpp -> C.hpp，x -> y 表示 x 依赖于 y。
B中会涉及到本文探讨的编译错误的内容可以抽象为如下：
// B.hpp
#include <memory>
#include "C.hpp"
Class B
{
struct Param
{
// ...
};
B(std::unique_ptr<Param> &¶m) {
this->param = std::move(param);
}
~B() = default;
a_func(std::unique_ptr<C> &&c) {
this->c = std::move(c);
// do something
}
// ...
private:
std::unique_ptr<Param> param;
std::unique_ptr<C> c;
};
也就是在B头文件中，只用到了 Class C 的声明，没有用到 Class C 的任何函数。
如果此时要单独编译A的话，不仅需要包含B的头文件，还需要包含C的头文件，这样就会导致C中的内容暴露给A，这是不合理的。
因此想到了一个解决办法就是在B的头文件中使用 incomplete type，即只前向声明 Class C，不包含 C.hpp，这样就可以避免暴露C的内容给A。包含C的头文件的操作放在B的源文件中。
// B.hpp
#include <memory>
class C; // 前向声明
Class B
{
struct Param
{
// ...
};
B(std::unique_ptr<Param> &¶m) {
this->param = std::move(param);
}
~B() = default;
a_func(std::unique_ptr<C> &&c) {
this->c = std::move(c);
// do something
}
// ...
private:
std::unique_ptr<Param> param;
std::unique_ptr<C> c;
};
这时编译器就会报错，报的错误即本文前半部分所述的错误。
经过前文的阐述，可以在这里分析为什么会报 invalid application of ‘sizeof’ to incomplete type ‘Impl’ 的错误。
- B中构造函数，虽然没有和 c 相关的代码，（不知道为什么保留在这还是会报这个错，存疑）
- B的析构函数，因为
std::unique_ptr的析构函数需要调用std::default_delete的operator()，而std::default_delete中有static_assert(sizeof(_Tp)>0, "can't delete pointer to incomplete type");，所以会报错。 - B的
a_func函数，因为std::unique_ptr的移动赋值操作需要调用std::default_delete的operator()，而std::default_delete中有static_assert(sizeof(_Tp)>0, "can't delete pointer to incomplete type");，所以会报错。
采用前文所述的方法三来解决：
// B.hpp
#include <memory>
class C; // 前向声明
Class B
{
struct Param
{
// ...
};
B(std::unique_ptr<Param> &¶m);
~B();
a_func(std::unique_ptr<C> &&c);
// ...
private:
std::unique_ptr<Param> param;
std::unique_ptr<C> c;
};
// B.cpp
#include "B.hpp"
#include "C.hpp"
B::B(std::unique_ptr<Param> &¶m) {
this->param = std::move(param);
}
B::~B() = default;
B::a_func(std::unique_ptr<C> &&c) {
this->c = std::move(c);
// do something
}
这样就解决了问题。