C++ 按值传递/按引用函数重载

Question

有两个函数重载:

MyClass do_something(MyClass param);
const MyClass& do_something(const MyClass& param);

然后我做:

MyClass c1 {"c1"};
do_something(c1);  // I want this to be used by value overload
do_something(c1);  // this to be used by reference overload

是否有任何特殊的方式来显式指定参数是按值传递还是按引用传递？

对于移动语义有std::move()我想知道是否有类似 std::copy() 的东西std::ref对于我的情况？

附言它不会在实际程序中使用，只是自己检查传递参数，返回值和它们以不同方式的行为的区别，并且所有函数都具有相同的名称:

// pass by value (copy)
MyClass do_something(MyClass param) {
    cout << "do_something(MyClass param)" << endl;
    param.i = 100;
    return param;
}

// !!! Your normal habit when passing an argument to a function should be to pass by const reference. (thinking in c++)
// pass by reference (reference)
const MyClass& do_something(const MyClass& param) { // doesn't allow to modify the object
    cout << "do_something(MyClass& param)" << endl;
    return param;
}

// pass by move semantic (move)
MyClass&& do_something(MyClass&& param) {
    cout << "do_something(MyClass&& param)" << endl;
    param.name += "__after_do_something(MyClass&& param)";
    param.i = 100;
    return move(param);
}

// pass by pointer (reference)
MyClass* do_something(MyClass* const param) { // allows to modify object, but not pointer (address)
    cout << "do_something(MyClass* const param)" << endl;
    param->i = 100;
    // (*param).i = 100;  // the same as above
    return param;
}

Answer 1

您可以通过转换为相关的函数指针类型来解决重载歧义(这是表达式类型由外部上下文确定而不是从内部构建的罕见情况之一):

struct MyClass { char const* s; };

MyClass do_something(MyClass) { return MyClass(); }
const MyClass& do_something(const MyClass& param) { return param; }

auto main() -> int
{
    MyClass c1 {"c1"};
    static_cast<MyClass(*)(MyClass)>( do_something )( c1 );         // Value overload
    static_cast<MyClass const&(*)(MyClass const&)>( do_something )( c1 );  // Ref overload
}

但在实践中，您应该只是以不同的方式命名函数，或者使用打破平局的参数或参数类型，即，为显式函数选择设计函数。

我会给它们取不同的名字，因为它们做不同的事情，所以给它们取相同的名字表明是错误的事情™。