0

我有一堂课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
}

但是这种方法的问题是，您可能会在实际声明为 const 的对象上将 const 转换为 const，这会使我陷入未定义的行为领域。

编辑：

使用 TakeFoo 的代码示例：

Foo GimmeFoo() { ... }

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

Foo ConstructedFoo(...);

cout << TakeFoo(ConstructedFoo) << endl;

// Continue to use ConstructedFoo
4

1 回答 1

0

回答你的第二个问题：

如果您的函数 TakeFoo 旨在调用 Foo 的非 const 成员，则使用

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 (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) );
}
于 2013-06-20T00:00:08.053 回答