如何在没有 std:whatever 的情况下强制使用 C++ 移动运算符 [关闭]

Question

我有一个非常大的代码库，已经存在了一段时间。我一直在通过选择性地使用新的语言功能来更新它。我打算使用移动构造函数，但我什至无法想出一个复杂的场景来实现它。我不会将我什至无法进行单元测试的代码放入我的代码库中。

而且，我不能使用 std:move，因为我根本不使用标准库。我有自己的标准库，以及我自己的所有其他内容（大约一百万行代码）。所有内容都隐藏在一个不会向外界公开任何语言或平台头文件的虚拟内核中。

所以我不能使用 std::move。希望它不会做任何我做不到的神奇事情？而且我猜想在面对基类时也需要类似的东西来处理移动构造函数（几乎总是如此。）如果它确实做了一些神奇的事情，那就是库泄漏到语言中并且不会很好。

显然 Visual C++（在我的例子中是 2017 年）上没有编译设置来禁用它从省略构造函数中，这大概是为什么我无法做任何事情甚至导致它。

当然，这也引发了一个问题，即如果需要这么多努力（即使在非优化模式下）来实现它，它是否无用。

Answer 1

我不能使用 std:move，因为我根本不使用标准库...希望它不会做任何我做不到的神奇事情？

来自How does std::move() transfer values into RValues?：

template <typename T>
typename remove_reference<T>::type&& move(T&& arg)
{
    return static_cast<typename remove_reference<T>::type&&>(arg);
}

This answer 详细解释了它的工作原理。

我打算玩弄移动构造函数，但我什至想不出一个复杂的场景来实现它。

调用移动构造函数并不难。例如：

template< class T > struct my_remove_reference      {typedef T type;};
template< class T > struct my_remove_reference<T&>  {typedef T type;};
template< class T > struct my_remove_reference<T&&> {typedef T type;};

template <typename T>
typename my_remove_reference<T>::type&& my_move(T&& arg)
{
    return static_cast<typename my_remove_reference<T>::type&&>(arg);
}

struct S
{
    int *ptr = nullptr;

    S() = default;
    S(int *p) : ptr(p) {}
};

class MoveTester
{
private:
    int *m_ptr = nullptr;

public:
    MoveTester() = default;
    MoveTester(const MoveTester &) = delete;
    MoveTester(MoveTester&& src) : m_ptr(src.m_ptr) { src.m_ptr = nullptr; }

    MoveTester(int *ptr) : m_ptr(ptr) {}
    MoveTester(S&& src) : m_ptr(src.ptr) { src.ptr = nullptr; }

    MoveTester& operator=(const MoveTester &) = delete;
    MoveTester& operator=(MoveTester&& rhs) { m_ptr = rhs.m_ptr; rhs.m_ptr = nullptr; return *this; }
    MoveTester& operator=(int *rhs) { m_ptr = rhs; return *this; }
    MoveTester& operator=(S&& src) { m_ptr = src.ptr; src.ptr = nullptr; return *this; }

    void display(const char *name) const { cout << name << ".m_ptr = " << m_ptr << endl; }
};

int* int_to_ptr(intptr_t value) { return reinterpret_cast<int*>(value); }

int main()
{
    MoveTester mt1;
    mt1.display("mt1");

    MoveTester mt2 = int_to_ptr(12345);
    mt2.display("mt2");

    //MoveTester mt3 = mt2; // compiler error! Copy constructor is deleted
    MoveTester mt3 = my_move(mt2);
    mt2.display("mt2");
    mt3.display("mt3");

    MoveTester mt4 = S();
    mt4.display("mt4");

    MoveTester mt5 = S(int_to_ptr(67890));
    mt5.display("mt5");

    //mt1 = mt5; // compiler error! Copy assignment is deleted
    mt1 = my_move(mt5);
    mt1.display("mt1");
    mt5.display("mt5");

    mt1 = int_to_ptr(13579);
    mt1.display("mt1");

    mt1 = S();
    mt1.display("mt1");

    mt1 = S(int_to_ptr(24680));
    mt1.display("mt1");

    return 0;
}

Live Demo