为什么不调用这个模板化的移动构造函数？

Question

我遇到了这种奇怪的情况：

template <typename pointed_t>
class MyPointer
{public:
    MyPointer() : pPointed(nullptr) {}
    /* PREVENT COMPILER-GENERATED FUNCTIONS */
    MyPointer(const MyPointer&);
    MyPointer(MyPointer&&);
    MyPointer& operator=(const MyPointer&);
    MyPointer& operator=(MyPointer&&);

    //----------
    pointed_t* pPointed;


    /* COPY CONSTRUCTOR */
    template <typename AnyPointerType>
    MyPointer(AnyPointerType& other)
    {
        
    }
    /* MOVE CONSTRUCTOR */
    template <typename AnyPointerType>
    MyPointer(AnyPointerType&& other)
    {
        

    }

};

int main()
{
    MyPointer<char> p1;

    MyPointer<char> p2 = p1; // COPY CONSTRUCTOR CALLED FINE
    MyPointer<char> p3 = std::move(p1); // RAISES BELOW LINKER ERROR
    /* Unresolved external symbol 
    public: __cdecl MyPointer<char>::MyPointer<char>(class MyPointer<char> &&)" */

}

所以 p2 = p1;调用模板复制构造函数很好，但 p3 = std::move(p1);不能调用模板化的移动构造函数？

所以结果是复制构造函数工作，但移动构造函数没有。除非它是不同的类型：

MyPointer<float> p1;

MyPointer<char> p2 = std::move(p1); // NOW THE TEMPLATED MOVE CONSTRUCTOR IS CALLED FINE

有人可以帮我理解为什么没有调用模板化移动构造函数吗？

Answer 1

问题是从构造函数模板生成的构造函数永远不是复制/移动构造函数。

为什么复制构造函数不会失败？

因为您提供的用户声明的副本 ctor MyPointer::MyPointer(const MyPointer&) 具有 const MyPointer& 类型的参数，但您提供的相应模板化构造函数具有 AnyPointerType& 类型的参数。请注意，后者没有低级const。所以当你写的时候：

MyPointer<char> p2 = p1; //this will use the template constructor that has no low-level const. 

在上面，模板版本选择非模板移动 ctor，因为模板版本有一个非常量参数，p1 也是非常量。您可以通过设置p1 const 来确认是这种情况，在这种情况下，您将收到相同的链接器错误，但这次是复制ctor。 Demo

---

所以结果是复制构造函数起作用了，但是移动构造函数不起作用。

MyPointer<char> p3 = std::move(p1); 不起作用，因为在这种情况下，您提供的用户声明的移动构造函数 MyPointer(MyPointer&&) 具有 MyPointer&& 类型的参数，并且相应的模板化 ctor 也具有参数 MyPointer&&。所以写的时候：

MyPointer<char> p3 = std::move(p1); //the compiler prefers the non-template user-delcared move ctor

用户声明的非模板移动 ctor MyPointer::MyPointer(MyPointer&&)优先于模板版本，但由于用户声明的 ctor 没有实现，我们会收到上述链接器错误。

---

解决方案

我想要调用我的模板。

在这种特殊情况下，有一个解决方案，如下所示。特别是，我们可以在用户声明的move ctor MyPointer::MyPointer(MyPointer&&)的参数中添加一个低级的const。

template <typename pointed_t>
class MyPointer
{public:
    MyPointer() : pPointed(nullptr) {}
    /* PREVENT COMPILER-GENERATED FUNCTIONS */
    MyPointer(const MyPointer&);
//------------vvvvv------------------>const added here
    MyPointer(const MyPointer&&);
    MyPointer& operator=(const MyPointer&);
    MyPointer& operator=(MyPointer&&);

    //----------
    pointed_t* pPointed;


    /* COPY CONSTRUCTOR */
    template <typename AnyPointerType>
    MyPointer(AnyPointerType& other)
    {
        std::cout<<"templated copy"<<std::endl;
    }
    /* MOVE CONSTRUCTOR */
    template <typename AnyPointerType>
    MyPointer(AnyPointerType&& other)
    {
        
       std::cout<<"template move"<<std::endl;
    }

};

int main()
{

    MyPointer<char> p1;

    MyPointer<char> p2 = p1; //calls the templated version
    MyPointer<char> p3 = std::move(p1); //calls the templated version
}

Working demo