有没有办法从非默认操作符调用默认的move操作符?

您可以有一个带有默认移动运算符的基类:

struct HandlerBase {
    int* ptr_to_something;
    int member1;
    int member2;
    int member3;
};

struct Handler : HandlerBase {
    void operator=(Handler&& other) {
        HandlerBase::operator=(std::move(other));
        other.ptr_to_something = nullptr;
    }
};

或者,您可以通过使默认的移动操作符执行您想要的操作 ptr_to_something 一个班级 operator= 执行您想要的操作:

template<typename T>
struct PtrThatResetsOnMove {
    T* value;

    constexpr explicit(false) PtrThatResetsOnMove(T* value) noexcept : value(value) {}
    constexpr PtrThatResetsOnMove(PtrThatResetsOnMove&& other) noexcept : value(std::exchange(other.value, nullptr)) {}
    constexpr PtrThatResetsOnMove& operator=(PtrThatResetsOnMove&& other) noexcept {
        value = std::exchange(other.value, nullptr);
        return *this;
    }
    ~PtrThatResetsOnMove() = default;
};

struct Handler {
    PtrThatResetsOnMove<int> ptr_to_something;
    int member1;
    int member2;
    int member3;
};

或者,您可以使用默认运算符将其他成员放在不同的类中:

struct HandlerMembers {
    int member1;
    int member2;
    int member3;
};

struct Handler {
    int* ptr_to_something;
    HandlerMembers members;
    void operator=(Handler&& other) {
       ptr_to_something = other.ptr_to_something;
       members = std::move(other.members);
       other.ptr_to_something = nullptr;
    }
};