由于C++中具有移动语义，现在通常这样做
void set_a(A a) { _a = std::move(a); }
如果a是rvalue，推断是复制将被省略，并且只会进行一次移动。
但是如果a是lvalue会发生什么？似乎会进行一个复制构造，然后再进行一个移动赋值（假设A拥有适当的移动赋值运算符）。如果对象具有太多成员变量，则移动赋值可能代价高昂。
另一方面，如果我们执行：
void set_a(const A& a) { _a = a; }
只会有一个拷贝赋值函数。如果我们将传递左值，那么是否可以说这种方式比按值传递的惯用法更好？
在现代C++中，需要昂贵移动的类型很少。如果你担心移动成本，那么请编写两个重载函数：
void set_a(const A& a) { _a = a; }
void set_a(A&& a) { _a = std::move(a); }
或者一个完美转发的setter:
template <typename T>
void set_a(T&& a) { _a = std::forward<T>(a); }
它将接受lvalue，rvalue和任何隐式可转换为decltype(_a)的内容，而不需要额外的拷贝或移动。
尽管从lvalue设置时需要额外移动，但这种习惯用法并不算不好，因为(a)绝大多数类型提供常数时间的移动(b)拷贝并交换提供了异常安全和近乎最优的性能，在一行代码中实现。
T 是可以由 std::initializer_list 构造的东西，这将不允许您在调用中使用列表。例如，set_a({1,2,3}) 将需要变成 set_a(A{1,2,3})，因为大括号初始化列表没有类型。 - NathanOliver但是，如果
a是左值呢？这似乎会有一个复制构造和一个移动赋值（假设A有适当的移动赋值运算符）。如果对象具有太多成员变量，则移动赋值可能代价高昂。
问题被很好地发现了。我不想说传值后再移动的构造方式是一个糟糕的模式，但它绝对有潜在的问题。
如果您的类型移动代价高并且/或者移动本质上只是一次复制操作，那么传值方式就不是最优选择。这样的类型示例包括具有固定大小数组成员的类型：移动可能相对昂贵，并且移动仅仅是一次复制操作。请参见此处的Small String Optimization and Move Operations和"Want speed? Measure." (by Howard Hinnant)。
传值方式的优点是您只需要维护一个函数，但您需要牺牲性能。是否使用此方式取决于您的应用程序，即维护优势是否大于性能损失。
如果您有多个参数，传递左值和右值引用可能会很快导致维护问题。请考虑以下内容：
#include <vector>
using namespace std;
struct A { vector<int> v; };
struct B { vector<int> v; };
struct C {
A a;
B b;
C(const A& a, const B& b) : a(a), b(b) { }
C(const A& a, B&& b) : a(a), b(move(b)) { }
C( A&& a, const B& b) : a(move(a)), b(b) { }
C( A&& a, B&& b) : a(move(a)), b(move(b)) { }
};
如果你有多个参数，就会出现排列问题。在这个非常简单的例子中，维护这4个构造函数可能还不错。但是，在这个简单的情况下，我会认真考虑使用单个函数的传值方法来替代上面的4个构造函数：
C(A a, B b) : a(move(a)), b(move(b)) { }
长话短说，两种方法都有缺点。根据实际的性能测试信息做出决策，而非过早优化。
目前的答案相当不完整。相反，我将试图根据我发现的优缺点列表进行总结。
简而言之，它可能是可以的，但有时很糟糕。
这个习语，即统一接口，与转发模板或不同的重载相比，在概念设计和实现方面具有更好的清晰度。它有时与复制并交换（实际上，在这种情况下也包括移动并交换）一起使用。
优点如下：
C 与拷贝/移动构造函数冲突)，以确保它不与拷贝/移动构造函数冲突(即使后者明确地由用户提供)?缺点是：
当参数对象类型与类相同时，统一接口无法替代复制和移动构造函数。否则，参数的复制初始化将会无限递归，因为它将调用统一构造函数，而构造函数又会调用自身。const&和&&限定类型的参数指定不同的noexcept-说明符，作为复数重载。noexcept(false)复制+ noexcept移动，如果您指定了noexcept，或者总是noexcept(false)当您没有指定任何内容（或显式noexcept(false)）。 （请注意，在前一种情况下，noexcept不能防止在复制期间抛出，因为那只会发生在参数的求值期间，而这超出了函数体。）没有进一步的机会分别调整它们。noexcept说明符现在影响函数类型。 （一些意外的兼容性问题可以通过Clang++警告进行诊断。）T的参数，如果所有操作都需要每个参数的一个副本，则使用统一接口。T的复制和移动构造成本均可以忽略，则使用统一接口。T的对象，并且T的移动构造成本可以忽略，则使用统一接口。以下是一些需要避免使用统一接口的示例：
请注意，“可忽略”成本的准确限制在某种程度上是主观的，因为它最终取决于开发人员和/或用户可以容忍多少成本，并且可能因情况而异。
实际上，我（保守地）假设任何大小不超过一个机器字的平凡可复制和可销毁类型（如指针）通常都符合可忽略成本的标准——如果在这种情况下实际上产生了太多的代码成本，那么这表明可能使用了错误的构建工具配置，或者工具链尚未准备好生产。
如果有任何关于性能的疑问，请进行分析。
还有一些其他的类型，根据惯例，更喜欢按值传递或不传递：
std::move，因为假定复制的成本可以忽略不计，而移动并不一定会使其更好。
std::function的构造函数模板（但不是赋值运算符模板）也使用传值方式的函数对象参数。std::initializer_list和std::basic_string_view的实例或多或少是两个指针或一个指针加上一个大小。这使它们足够便宜，可以直接传递而不使用引用。shared_ptr实例。 （但是，并非所有智能指针都是这样的; observer_ptr更像原始指针。）对于一般情况下将要保存的值，仅传递值是一个很好的折中方案-
对于只传递lvalue的情况（一些紧密耦合的代码），这是不合理的，不明智的。
对于怀疑提供两者可以加速的情况，请三思而后行，如果没有帮助，请进行测量。
对于不需要保存值的情况，我更喜欢通过引用传递，因为这可以避免无数不必要的复制操作。
最后，如果编程可以简化为机械应用规则，我们可以将其留给机器人。因此，在规则上花费太多精力并不是一个好主意。最好关注不同情况下的优缺点。成本不仅包括速度，还包括代码大小和清晰度等方面。规则通常无法处理此类利益冲突。
按值传递，然后移动，实际上是一个适用于可移动对象的好习惯。
正如您所提到的，如果传递了 rvalue，则它将省略复制或被移动，然后在构造函数内部它将被移动。
您可以显式重载复制构造函数和移动构造函数，但是如果有多个参数，则会变得更加复杂。
考虑以下示例：
class Obj {
public:
Obj(std::vector<int> x, std::vector<int> y)
: X(std::move(x)), Y(std::move(y)) {}
private:
/* Our internal data. */
std::vector<int> X, Y;
}; // Obj
class Obj {
public:
Obj(std::vector<int> &&x, std::vector<int> &&y)
: X(std::move(x)), Y(std::move(y)) {}
Obj(std::vector<int> &&x, const std::vector<int> &y)
: X(std::move(x)), Y(y) {}
Obj(const std::vector<int> &x, std::vector<int> &&y)
: X(x), Y(std::move(y)) {}
Obj(const std::vector<int> &x, const std::vector<int> &y)
: X(x), Y(y) {}
private:
/* Our internal data. */
std::vector<int> X, Y;
}; // Obj
正如您所看到的，随着参数数量的增加，必要构造函数的排列组合也会增加。
如果您没有具体类型但有一个模板化的构造函数，您可以使用完美转发，如下所示：
class Obj {
public:
template <typename T, typename U>
Obj(T &&x, U &&y)
: X(std::forward<T>(x)), Y(std::forward<U>(y)) {}
private:
std::vector<int> X, Y;
}; // Obj
参考文献：
声明中的可读性：
void foo1( A a ); // easy to read, but unless you see the implementation
// you don't know for sure if a std::move() is used.
void foo2( const A & a ); // longer declaration, but the interface shows
// that no copy is required on calling foo().
A a;
foo1( a ); // copy + move
foo2( a ); // pass by reference + copy
职责：
A a;
foo1( a ); // caller copies, foo1 moves
foo2( a ); // foo2 copies
对于典型的内联代码，通常在优化时没有区别。 但是foo2()可能只在某些条件下进行复制（例如，如果键不存在，则插入到映射中），而对于foo1()，复制将始终执行。
std::move 信号表示要放弃所有权，这也是重点所在。 - Lightness Races in Orbit
std::move在一个const&上会返回一个const&&，不能从中移动。 - Casey