Question

我有一个班级Foo。 Foo有一些非const方法。我可以在临时Foo对象上调用非const方法;我只对实际返回的方法感兴趣，而不是他们对Foo对象本身所做的事情。

第一个问题：这本身是否必要表明课程Foo没有精心设计？

第二个问题：如果我想按原样继续Foo，但我仍然希望能够通过引用传递Foo个对象来调用非const方法，最好的方法是什么？

这就是我到达的地方：

// 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
}

但是这种方法存在一个问题，就是你可能会在一个实际上被声明为const的对象上逐渐抛出const，这会把我放在undefined-behavior-land中。

编辑：

使用TakeFoo的代码示例：

Foo GimmeFoo() { ... }

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

Foo ConstructedFoo(...);

cout << TakeFoo(ConstructedFoo) << endl;

// Continue to use ConstructedFoo

Answer 1

回答你的第二个问题：

如果你的函数TakeFoo是为了调用Foo的非常量成员，那么使用

int TakeFoo (Foo& FooBar);

如果您确定TakeFoo仅将rvalue作为参数，则使用

int TakeFoo (Foo&& FooBar);

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

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

或

int TakeFoo (Foo FooBar);

回答你的第一个问题：

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) );
}

如何正确覆盖“没有对常量对象的非const引用”

1 个答案: