move std 函数 示例_std::enable_if

好的，让我来解释一下。`std::enable_if` 是一个在编译时进行条件判断的模板元编程工具，可以根据模板参数是否满足某个条件来启用或禁用某个函数或类的实现。在使用 `std::move` 函数的时候，我们有时会需要进行条件编译，以确保只有符合一定条件的类型才能使用 `std::move` 函数。

下面是一个示例代码：

#include <iostream>
#include <type_traits>

template<typename T>
typename std::enable_if<std::is_move_constructible<T>::value>::type
move_impl(T&& t)
{
    std::cout << "move_impl(T&&)" << std::endl;
}

template<typename T>
typename std::enable_if<!std::is_move_constructible<T>::value>::type
move_impl(T&& t)
{
    std::cout << "move_impl(T&&) disabled" << std::endl;
}

template<typename T>
typename std::enable_if<std::is_move_assignable<T>::value>::type
move_impl(T& t1, T&& t2)
{
    std::cout << "move_impl(T&, T&&)" << std::endl;
}

template<typename T>
typename std::enable_if<!std::is_move_assignable<T>::value>::type
move_impl(T& t1, T&& t2)
{
    std::cout << "move_impl(T&, T&&) disabled" << std::endl;
}

template<typename T>
void my_move(T&& t)
{
    move_impl<T>(std::forward<T>(t));
}

template<typename T>
void my_move(T& t1, T&& t2)
{
    move_impl<T>(t1, std::forward<T>(t2));
}

class A
{
public:
    A() {}
    A(const A&) {}
    A(A&&) = delete;
    A& operator=(const A&) { return *this; }
    A& operator=(A&&) = delete;
};

class B
{
public:
    B() {}
    B(const B&) {}
    B(B&&) {}
    B& operator=(const B&) { return *this; }
    B& operator=(B&&) { return *this; }
};

int main()
{
    A a;
    B b;
    my_move(a);
    my_move(b);
    my_move(b, B());
    // my_move(a, A()); // error, A is not move-assignable
    // my_move(A(), a); // error, A is not move-constructible
    return 0;
}

在上面的代码中，我们定义了 `my_move` 函数作为 `std::move` 函数的替代品，并使用了 `std::enable_if` 来进行条件编译。具体来说，我们定义了两个重载版本的 `my_move` 函数，分别用于处理单个参数和两个参数的情况。然后，我们又定义了四个 `move_impl` 函数，其中两个用于处理可移动构造类型，另外两个用于处理可移动赋值类型，并使用 `std::enable_if` 来控制这些函数的启用与禁用。

最后，我们在 `main` 函数中测试了 `my_move` 函数的各种使用情况，包括可移动构造类型、可移动赋值类型以及不可移动类型等。通过这个示例代码，我们可以看到 `std::enable_if` 与 `std::move` 函数的结合使用，可以实现对移动语义的精确控制，提高代码的健壮性和可维护性。