在封装指针的类中，移动语义无意中被复制构造函数取代

我制作了一个与std::unique_ptr非常相似的模板类derived_object<T>。虽然T只是实际对象的基类，但它还有一个附加功能，即可以进行深度复制。该技术取自boost::any。以下是文件derived_object.h:的(不幸的是很长)内容

#pragma once
#include <type_traits>
#include <algorithm>
template<class Base>
class derived_object
{
public:
derived_object()
: content(nullptr)
{}
template<typename Derived>
derived_object(Derived* ptr)
: content(new holder<Derived>(ptr))
{
static_assert(std::is_copy_constructible<Derived>::value, "type of pointer must have copy constructor");
static_assert(std::is_base_of<Base, Derived>::value, "type of pointer must be derived from base type");
}
derived_object(derived_object const& other); // left unimplemented for testing
//      : content(other.content ? other.content->clone() : nullptr)
//  {}
derived_object& operator=(derived_object const& rhs); // left unimplemented for testing
//  {
//      derived_object<Base>(rhs).swap(*this);
//      return *this;
//  }
derived_object(derived_object&& other) noexcept
: content(other.content)
{
other.content = nullptr;
}
derived_object& operator=(derived_object&& rhs) noexcept
{
rhs.swap(*this);
derived_object<Base>().swap(rhs);
return *this;
}
~derived_object()
{
delete content;
}
Base* operator->() const
{
return content->operator Base*();
}
Base* get() const
{
return content->operator Base*();
}
derived_object& swap(derived_object& rhs) noexcept
{
std::swap(content, rhs.content);
return *this;
}
private:
class placeholder
{
public:
virtual ~placeholder() {}
virtual operator Base*() const = 0;
virtual placeholder* clone() const = 0;
};
template<typename Derived>
class holder : public placeholder
{
Derived* held;
public:
holder(Derived* der_ptr)
: held(der_ptr)
{ }
placeholder* clone() const override
{
return new holder(new Derived(*held));
}
~holder() override
{
delete held;
}
operator Base*() const override { return held; }
};
placeholder* content;
};

总的来说，这很好用。但在一个特定的情况下，我想使用移动语义而不是复制，我的程序失败了。出于测试目的，我通过声明但不定义相应的方法来停用derived_object中的复制。

以下是classes.h的内容

#pragma once
#include "derived_object.h"
class B1
{};
class D1 : public B1
{};

class B2
{};
class D2 : public B2
{
public:
D2(derived_object<B1> member);
derived_object<B1> member;
};

classes.cpp

#include "classes.h"
D2::D2(derived_object<B1> m)
:   member(std::move(m))
{}

和main.cpp

#include "classes.h"
int main()
{
derived_object<B2> e(new D2(new D1()));
}

通过使用Clang(版本3.8.0-2ubuntu4)进行编译

clang++ -std=c++14 -o main.cpp.o -c main.cpp
clang++ -std=c++14 -o classes.cpp.o -c classes.cpp
clang++ main.cpp.o classes.cpp.o -o output

给出链接器错误CCD_ 9。

但是不应该复制derived_object，我总是移动或使用构造函数derived_object(Derived* ptr)。

奇怪的是，当我内联声明D2构造函数或进行其他微小的更改时，错误并没有发生
为什么编译器要复制我的对象，尽管移动似乎是可能的
如何更改derived_object.h(除了更改其方法签名)？