从非常量对象调用 const 函数

Question

我需要从非常量对象调用 const 函数。 请参阅示例

struct IProcess {
   virtual bool doSomeWork() const = 0L;
};
class Foo : public IProcess {    
  virtual bool doSomeWork() const {
    ...
  }
};

class Bar
{
public:
   const IProcess& getProcess() const {return ...;}
   IProcess& getProcess() {return ...;}

   void doOtherWork {
    getProcess().doSomeWork();        
  }
};

调用

getProcess().doSomeWork();

将始终导致调用

IProcess& getProcess()

进行调用

const IProcess& getProcess() const 

是否有另一种方法从非常量成员函数 ？ 到目前为止，我已经使用了

const_cast<const Bar*>(this)->getProcess().doSomeWork();

它，但似乎过于复杂。

---

编辑：我应该提到代码正在被重构，最终只剩下一个功能。

const IProcess& getProcess() const 

但是，目前存在副作用，const 调用有时可能会返回 IProcess 的不同实例。

请继续主题。

Answer 1

const_cast 用于强制抛弃常量！

您正在从非 const 转换为安全的 const，因此请使用 static_cast：

   static_cast<const Bar*>(this)->getProcess().doSomeWork();

我的意思是从技术上讲，您可以使用 const_cast 进行常量转换，但事实并非如此运算符的实用使用。 新样式强制转换（与旧的 c 样式强制转换相比）的目的是传达强制转换的意图。 const_cast 是一种代码味道，至少应该审查它的使用。 另一方面，static_cast 是安全的。 但这是 C++ 风格的问题。

或者您可以创建一个新的（私有）const 方法，并从 doOtherWork 调用该方法：

  void doSomeWorkOnProcess() const { getProcess().doSomeWork(); }

使用 const 临时也是一种选择（由“MSN 回答”） ”）：

   const Bar* _this = this;
   _this->getProcess().doSomeWork();

Answer 2

避免强制转换：将其分配给 const Bar * 或其他内容，并使用它来调用 getProcess()。

这样做有一些迂腐的原因，但它也使您正在做的事情更加明显，而无需强迫编译器做一些可能不安全的事情。 当然，您可能永远不会遇到这些情况，但您不妨编写一些在这种情况下不使用强制转换的内容。

Answer 3

如果转换对您来说太难看，您可以向 Bar 添加一个方法，该方法仅返回对 *this 的 const 引用：

Bar const& as_const() const {
    return *this;    // Compiler adds "const" without needing static_cast<>
}

然后您可以调用 any< /em> Bar 中的 const 方法只需在前面添加 as_const().，例如：

as_const().getProcess().doSomeWork();

Answer 4

如果 getProcess() 和 getProcess() const 没有返回对同一对象的引用（但限定不同），则表明 Bar 类的设计很差。 重载函数的常量并不是区分具有不同行为的函数的好方法。

如果它们返回对同一对象的引用，则：

const_cast<const Bar*>(this)->getProcess().doSomeWork();

并

getProcess().doSomeWork();

调用完全相同的 doSomeWork() 函数，因此无需使用 const_cast。

Answer 5

定义模板

template< class T >
const T & addConst ( T & t ) 
{
    return t;
}

并调用

addConst( getProcess() ).doSomeWork();

Answer 6

如果函数没有重载，则不必执行任何转换技巧。 调用非常量对象的 const 方法是可以的。 它从禁止的 const 对象调用非常量方法。 如果这些方法被 const 和非常量函数覆盖，那么将对象转换为 const 就可以解决问题：

const_cast<const IProcess&> (getProcess()).doSomeWork();

编辑：我没有阅读整个问题。 是的，您需要对 this 指针进行 const_cast 或将 doOtherWork 函数设为 const 来调用 const IProcess& getProcess() 常量。

重点仍然是，您不需要 const 对象来调用 doSomeWork。 既然这是目标，那么是否需要调用const方法呢？

另一种选择是重命名被覆盖的函数。 如果这两个函数实际上具有不同的行为/副作用，这将是一个非常好的主意。 否则函数调用的效果不会很明显。

Answer 7

嗯，你能声明一下

void doOtherWork const ()

吗？

这样就可以了。

Answer 8

我认为 const_cast 方法是你最好的选择。 这只是 C++ 中 const 框架的限制。 我认为避免强制转换的唯一方法是定义一个无论如何都返回 const IProcess 实例的方法。 例如。

const IProcess* getProcessConst() const { return ... }
...
getProcessConst().doSomeWork();

Answer 9

我假设您希望 DoOtherWork 调用两个 getprocess 调用之一，具体取决于它是否是从 const 对象调用的。

我能给出的最好建议是：

class Bar
{
public:
   const IProcess& getProcess() const {return ...;}
   IProcess& getProcess() {return ...;}

   void doOtherWork {            // should use getProcess()      
    getProcess().doSomeWork();        
  }
   void doOtherWork const {
    getProcess().doSomeWork();   // should use getProcess() const     
  }
};

即使这有效，对我来说这看起来也很难闻。 我会非常警惕类行为根据对象的常量而发生根本变化。

Answer 10

发表者：monjardin
另一种选择是重命名被覆盖的函数。 如果这两个函数实际上具有不同的行为/副作用，这将是一个非常好的主意。 否则函数调用的效果不会很明显。

IProcess& 主要通过属性在其他代码中访问，

__declspec(property(get=getProcess)) IProcess& Process;

因此不能选择重命名。 大多数情况下，调用函数的常量与 getProcess() 匹配，因此没有问题。

Answer 11

对于 C++17 及更高版本，请考虑使用 std::as_const：

std::as_const(getProcess()).doSomeWork()

Answer 12

您基本上只能重命名其他方法或 const_cast。

顺便说一句，这是写时复制智能指针实际上在 C++ 中不能很好地工作的原因之一。 写时复制智能指针是一种可以无限共享的智能指针。 当用户在非常量上下文中访问数据时，将创建数据的副本（如果用户不持有唯一引用）。 当共享只有某些客户端需要修改的大型数据结构时，这种指针使用起来非常方便。 最“逻辑”的实现是有一个const和一个非常量运算符->。 const 版本仅返回底层引用。 非常量版本进行唯一的引用检查和复制。 它没有用，因为非常量智能指针将使用非常量运算符 -> 。 默认情况下，即使您想使用 const 版本。 const_cast 要求使其对用户非常不友好。

我欢迎任何证明我错了并在 C++ 中展示用户友好的写时复制指针的人...