C++11 “如何覆盖”；“没有对临时对象的非常量引用”；正确地

我有一门课

Foo

Foo

有一些非常量方法。我可以在临时

Foo

对象上调用非常量方法；我只对方法实际返回的内容感兴趣，而不是它们对

Foo

对象本身的作用

第一个问题：这本身是否意味着类

Foo

设计得不好

第二个问题：如果我想按原样继续使用

Foo

，但我仍然希望能够通过引用调用非常量方法的函数来传递

Foo

对象，那么最好的方法是什么

这就是我得出的结论：

// The function that performs work on a Foo object.
int TakeFoo (Foo& FooBar) { ... }

// An overload just to accept temporary Foo objects.
int TakeFoo (Foo&& FooBar)
{
    // Delegate
    return TakeFoo(FooBar);
}

另一种方法就是这样做：

int TakeFoo (const Foo& FooBar)
{
    Foo& MyFooBar = const_cast<Foo&>(FooBar);
    // Do work on MyFooBar
}

inttakefoo（constfoo&FooBar）
{
Foo&MyFooBar=const_cast（FooBar）；
//在MyFooBar上工作吗
}

但是这种方法有一个问题，就是你可能在一个实际声明为const的对象上抛出const，这会让我陷入未定义的行为领域

编辑：

使用TakeFoo的代码示例：

Foo GimmeFoo() { ... }

cout << TakeFoo(GimmeFoo()) << endl;

Foo ConstructedFoo(...);

cout << TakeFoo(ConstructedFoo) << endl;

// Continue to use ConstructedFoo

Foo GimmeFoo（）{…}
无法回答您的第二个问题：

如果函数TakeFoo要调用Foo的非常量成员，那么使用

int TakeFoo (Foo& FooBar);

如果您确定TakeFoo只接受一个右值作为参数，那么使用

int TakeFoo (Foo&& FooBar);

如果要对Foo进行一些更改以计算
int
返回值，请使用

int TakeFoo (const Foo& FooBar)
{
    Foo FooBar MyFooBar = FooBar;
    // do something with MyFooBar and return int
}

或

回答你的第一个问题：

int TakeFoo（FooBar）
不应更改FooBar以计算
int
结果。
更好的设计是

Foo transform_foo(Foo const& foo);
int compute_result(Foo const& foo);
int TakeFoo(Foo const& FooBar)
{
    return compute_result( transform_foo(FooBar) );
}

您还可以添加一些代码来显示客户端代码将如何调用和使用
TakeFoo
？
Foo transform_foo(Foo const& foo);
int compute_result(Foo const& foo);
int TakeFoo(Foo const& FooBar)
{
    return compute_result( transform_foo(FooBar) );
}