转换构造函数调用移动但不复制

Question

使用此代码：

template <class T> class Test {
    T _temp;

public:
    Test() {
        std::cout << "Test()" << std::endl;
    };

    template <class T2> Test(Test<T2> const &test) {
        std::cout << "template <class T2> Test(Test<T2> const &test)" << std::endl;
    };

    template <class T2> Test(Test<T2> &&test) {
        std::cout << "template <class T2> Test(Test<T2> &&test)" << std::endl;
    };

};

有了这个测试代码：

Test<int> testInt;
Test<float> testFloat(testInt);
Test<float> testFloat2(std::move(testInt));

std::cout << "----------" << std::endl;

Test<int> testInt2;
Test<int> testInt3(testInt2);
Test<int> testInt4(std::move(testInt2));

产生这个输出：

Test()
template <class T2> Test(Test<T2> const &test)
template <class T2> Test(Test<T2> &&test)
----------
Test()

使用相同类型时，使用默认的复制和移动构造函数代替转换构造函数。

但是如果我在类中添加默认的复制构造函数：

Test(Test const &test) = default;

它产生这个输出：

Test()
template <class T2> Test(Test<T2> const &test)
template <class T2> Test(Test<T2> &&test)
----------
Test()
template <class T2> Test(Test<T2> &&test)

移动转换构造函数即使是相同的类型也会被调用，为什么？

有没有办法统一复制和转换构造函数，避免重复代码？

Answer 1

添加隐式生成（= 编译器生成）移动构造函数的规则非常保守：仅在安全的情况下添加一个。如果一个拷贝构造函数已经被用户定义，编译器不能假设添加一些简单的编译器生成的移动构造函数仍然是安全的，所以不会添加移动构造函数。 _{其实，声明就足以阻止移动构造函数的生成，IIRC允许只复制类型。}

构造函数模板从不被视为复制构造函数或移动构造函数，因此它们不会阻止隐式生成这些构造函数。

当然，如果从未声明移动构造函数，则可以通过重载决议选择另一个构造函数。考虑这个例子：

#include <iostream>
#include <utility>

struct loud
{
    loud() { std::cout << "default ctor\n"; }
    loud(loud const&) { std::cout << "copy ctor\n"; }
    loud(loud&&) { std::cout << "move ctor\n"; }
};

struct foo
{
    loud l;
};

struct bar
{
    loud l;
    bar() = default;
    bar(bar const&) = default;
};

int main()
{
    foo f0;
    foo f1(f0);
    foo f2(std::move(f0));

    std::cout << "--------------\n";

    bar b0;
    bar b1(b0);
    bar b2(std::move(b0));
}

输出：

默认 ctor
复制者
移动 ctor
--------------
默认 ctor
复制者
复制ctor

这里，foo 将获得隐式声明的默认、复制和移动构造函数，而 bar 不会获得隐式声明的移动构造函数，因为它具有用户声明的复制构造函数。

---

在您的第二种情况下，没有隐式声明的移动构造函数，因此Test<int> testInt4(std::move(testInt2)) 的重载解析更喜欢构造函数模板而不是复制构造函数，因为前者采用的引用较少 cv 限定。

---

为了减少代码重复，您可以委托构造：

template <class T>
class Test {
    T _temp;

    struct tag {};

public:
    Test() {
        std::cout << "Test()" << std::endl;
    };

    Test(Test const& test)
        : Test(test, tag{})
    {}

    Test(Test&& test)
        : Test(std::move(test), tag{})
    {}

    template <class T2> Test(Test<T2> const &test, tag = {}) {
        std::cout << "template <class T2> Test(Test<T2> const &test)" << std::endl;
    };

    template <class T2> Test(Test<T2> &&test, tag = {}) {
        std::cout << "template <class T2> Test(Test<T2> &&test)" << std::endl;
    };

};

顺便说一句，您还可以通过使用完美转发构造函数模板而不是两个构造函数模板来减少一些样板：

使用这个特性：

template<class T>
struct is_Test : std::false_type {};
template<class T>
struct is_Test<Test<T>> : std::true_type {};

你可以定义：

    template <class T2,
              class = typename std::enable_if<is_Test<T2>::value>::type>
    Test(T2&& test, tag = {}) {
        std::cout << "template <class T2> Test(T2&& test)" << std::endl;
    };