将A移动到param中，然后将param复制到data中。可以使用以下命令对此进行测试：

#include <iostream>

struct Data{
    Data() {
        std::cout << "init\n";
    }

    Data(Data const&) {
        std::cout << "copy\n";
    }

    Data(Data&&) {
        std::cout << "move\n";
    }
};

struct Buck {
    Buck(Data param): data{param} {} // copy

    Data data;
};

int main() {
    Data a;               // init
    Buck b{std::move(a)}; // move
}

init
move
copy

如果你想移动，你总是需要显式地强制转换为rvalue（例如，通过std::move）：
一个二个一个一个
如果希望对数据成员执行一次移动，可以在构造函数中获取一个引用：

struct Buck {
    Buck(Data&& param): data{std::move(param)} {} // move

    Data data;
};

int main() {
    Data a;               // init
    Buck b{std::move(a)}; // call-by-reference
}

init
move

**注意：**在成员初始化中仍然需要显式rvalue-cast！如果不使用它，则会复制一个副本：

struct Buck {
    Buck(Data&& param): data{param} {} // copy!!!

    Data data;
};

int main() {
    Data a;               // init
    Buck b{std::move(a)}; // call-by-reference
}

init
copy

std::move(a)与static_cast<Data&&>(a)相同。当您使用Data&&类型的变量时，它将被视为Data&，直到您在表达式中显式地将其转换为Data&&。将变量声明为Data&&只对如何初始化它很重要，而对如何使用它不重要！
如果希望对复制和移动提供易于实现的支持，那么按值调用是有用的：

struct Buck {
    // param can be copied or moved, then it is moved to data
    Buck(Data param): data{std::move(param)} {}

    Data data;
};

int main() {
    Data a;               // init
    std::cout << "----\n";
    Buck b{a};            // copy
    std::cout << "----\n";
    Buck c{std::move(a)}; // move
}

init
----
copy
move
----
move
move

如果你想要最大的性能，你可以通过实现复制和移动构造函数来避免第二次移动：

struct Buck {
    Buck(Data const& param): data{param} {}       // copy
    Buck(Data&& param): data{std::move(param)} {} // move

    Data data;
};

int main() {
    Data a;               // init
    std::cout << "----\n";
    Buck b{a};            // call-by-lvalue-reference
    std::cout << "----\n";
    Buck c{std::move(a)}; // call-by-rvalue-reference
}

init
----
copy
----
move