【问题标题】:Is my method for avoiding dynamic_cast<> faster than dynamic_cast<> itself?我避免 dynamic_cast<> 的方法是否比 dynamic_cast<> 本身更快?
【发布时间】:2010-05-03 13:42:46
【问题描述】:

几分钟前我正在回复question,它向我提出了另一个问题:

在我的一个项目中,我做了一些网络消息解析。消息的格式为:

[1 byte message type][2 bytes payload length][x bytes payload]

负载的格式和内容由消息类型决定。我有一个基于公共类Message 的类层次结构。

为了实例化我的消息,我有一个静态解析方法,它根据消息类型字节返回Message*。比如:

Message* parse(const char* frame)
{
  // This is sample code, in real life I obviously check that the buffer
  // is not NULL, and the size, and so on.

  switch(frame[0])
  {
    case 0x01:
      return new FooMessage();
    case 0x02:
      return new BarMessage();
  }

  // Throw an exception here because the mesage type is unknown.
}

我有时需要访问子类的方法。由于我的网络消息处理必须很快,我决定避免使用dynamic_cast&lt;&gt;,并在Message 基类中添加了一个方法来返回消息类型。根据这个返回值,我使用static_cast&lt;&gt; 来代替右子类型。

我这样做主要是因为有人告诉我dynamic_cast&lt;&gt; 很慢。但是,我不确切地知道它到底做了什么以及它有多慢,因此,我的方法可能同样慢(或更慢)但要复杂得多。

你们觉得这个设计怎么样?这很常见吗?真的比使用 dynamic_cast&lt;&gt; 快吗?欢迎对使用dynamic_cast&lt;&gt; 时的幕后情况进行任何详细解释!

--- 编辑---

既然有人问为什么:

基本上,当我收到一个帧时,我会做两件事:

  1. 如果框架的内容有效,我会解析消息并构建Message 子类的相应实例。除了解析部分,没有逻辑。
  2. 我收到了一个Message,根据switch(message-&gt;getType()),我将static_cast&lt;&gt; 输入正确的类型,然后对消息执行任何操作。

【问题讨论】:

  • 你觉得什么更具可读性和可维护性?

标签: c++ polymorphism dynamic-cast static-cast


【解决方案1】:

dynamic_cast 的实现当然会因编译器而异。

在 Visual C++ 中,vtable 指向一个结构,该结构包含有关结构的所有 RTTI。因此,dynamic_cast 涉及取消引用此指针,并根据请求的类型检查“实际”类型,如果它们不兼容则抛出异常(或返回 NULL)。它基本上等同于您描述的系统。并不是特别慢。

你的设计听起来也有点不对劲——你有一个忘记对象真实类型的工厂方法,然后你马上想忘记那个信息。也许您应该将忘记类型时所做的逻辑转移到工厂方法或基类本身的虚拟方法中。

【讨论】:

  • +1:因为您很好地描述了在“呼叫”dynamic_cast&lt;&gt; 时究竟发生了什么。对于您回答的最后一部分,我编辑了我的问题,以提供有关我选择此设计的原因的更多信息。
  • 我不认为使用虚函数会有用;哪个类的虚方法?
  • Message 类上的虚拟函数,在各种子类中实现,包含处理该 Message 时所需的特定于该子类的任何逻辑
【解决方案2】:

“是否更快”的唯一正确答案是“试试看”。

【讨论】:

  • 除非您信任的人已经这样做了,并且愿意分享他们的发现?
  • 不,尝试它是一个更强大的解决方案,可以应用于“它更快吗?”问题的许多实例
  • 测试就是实践。在这里,我想专注于理论;)我对结果的兴趣不如这里的“如何”。
  • 该理论的答案是“我确信编译器编写者在编写一个可以正常工作并且在一般情况下接近最优的 dynamic_cast 方面做得很好”。但是,通过网络传递类可能会让您感到惊讶——您是否可以完全控制客户端和服务器?如果两者之间存在任何编译器/版本不匹配,则对消息的任何强制转换都可能失败。
  • 酷,在那种情况下,如果你有一个非常特定的情况(比如没有真正的类层次结构),你实际上可以比dynamic_cast稍微快一点。
【解决方案3】:

当人们说 dynamic_cast 很慢时,这只是一个经验法则。 dynamic_cast 或多或少地做了你正在做的事情。它很慢,因为它涉及到几个内存访问。有点像人们说虚函数很慢。您正在快速执行某些操作(函数调用)并为其添加几个内存访问。这是一个显着的减速(因为一直到 ram 和返回可能需要几百个周期),但对于大多数人来说,只要不经常这样做就无关紧要(经常值非常大) .

【讨论】:

  • 回到我们使用 MSVC 2005 将 32 位应用程序移植到 64 位的时候。64 位版本要慢得多,我们追踪到 dynamic_cast 更慢。
【解决方案4】:

这取决于您管理消息的方式。当我有一个switch 来根据类型选择消息时,最好的选择是使用static_cast,因为你知道函数解析器会给你创建正确的类型。

Message* gmsg parse(frame);

switch (gmsg->type) {
  case FooMessage_type:
    FooMessage* msg=static_cast<FooMessage*>(gmsg);
    // ...
    break;
  case BarMessage_type:
    BarMessage* msg=static_cast<BarMessage*>(gmsg);
    //...
    break;      
};

这里使用dynamic_cast 是过度保护。

为什么需要所有消息都继承自一个通用消息?有什么共同点? 我将添加另一个根本不使用继承的设计

switch (frame::get_msg_type(aframe)) {
  case FooMessage_type:
    FooMessage msg=parse<FooMessage>(aframe);
    // work with msg
    break;
  case BarMessage_type:
    BarMessage msg=parse<BarMessage>(aframe);
    //...
    break;
};

其中parse将一帧解析为MSG,或者解析失败时抛出异常。

我看到其他答案告诉您使用虚拟功能。我真的看不出这种面向消息的 OO 设计有什么优势。

【讨论】:

  • 实际上,这正是描述了我在做什么。我这样做主要是为了避免您所说的“过度保护”。
  • 所以你不需要dynamic_cast,因为你已经知道了这个类。
【解决方案5】:

A) 这听起来很像过早优化。

B) 如果您的设计需要大量调用 dynamic_cast 以至于您担心,那么您肯定需要查看您的设计并找出其中的问题。

C)就像前面的答案所说,回答是否更快的唯一方法是使用分析器(或等效)并进行比较。

【讨论】:

  • 感谢您的回答。不幸的是,我无法在 重负载压力 下对此进行测试,因为我还没有完成其余部分的编写。我主要想知道是否有人已经使用了类似的设计,以及 如何 慢了 dynamic_cast&lt;&gt;.
  • 进一步到 (B) 我建议,与 IO 的成本相比,对dynamic_cast 的调用必须是 很多 才能变得不可忽略首先。
  • @Phil Nash:我收到的每条消息都有一两个演员表,顶。我想真正的问题可能应该是:“dynamic_cast&lt;&gt; 是否比一字节到一字节的比较慢?”
  • 我认为“真正的问题”是“与 IO 相比,一两个 dynamic_casts 重要吗?
  • 我不会在不需要的时候使用dynamic_cast,因为它不会花费太多时间。这是过度保护。
【解决方案6】:

您关注的是速度,但正确性如何?

根本问题是你确定你不会犯错吗?特别是,您可能很想以这种方式包装强制转换方法:

template <class T>
T* convert(Message* message)
{
  if (message == 0) return 0;
  else return message->getType() == T::Type() ? static_cast<T*>(message) : 0;
}

为了将测试和强制转换嵌入到单个函数中,从而避免以下错误:

switch(message->getType())
{
case Foo:
{
  //...
  // fallthrough
}
case Bar:
{
  BarMessage* bar = static_cast<BarMessage*>(message); // got here through `Foo`
}
}

或显而易见的:

if (message->getType() == Foo) static_cast<BarMessage*>(message); // oups

固然不多,但也不是很努力。

另一方面,您也可以通过应用运行时调度来审查您的技术。

  • virtual 方法
  • Visitor

等等……

【讨论】:

  • 我不会弄错:如果消息具有给定的“字节类型”,则表示它已成功解析并且其字节类型匹配。
  • 我正在考虑测试一种类型并错误地转换为另一种类型。我知道这听起来很愚蠢,但我们是人类,这当然是我会冒险做的事情:)
  • 好吧,这样我肯定会犯错;)但很容易被发现并快速修复;)
  • 哪些函数在哪个类上是虚拟的?
  • 谈论可能的错误。 parse 函数还可以创建与找到的类型相关联的坏类。
【解决方案7】:

您已经有一个抽象基类“消息”。使用它作为一个接口来隐藏 FooMessage 和 BarMessage 的实现细节。

我猜,这就是你选择这种方法的原因,不是吗?

【讨论】:

  • 使用基类主要是因为大多数时候,我想以全局的方式处理Messages。但是,有时,我需要访问子类方法/成员。
  • 那么你必须得到你的秒表......正如其他人已经指出的那样。 :-)
【解决方案8】:

我知道这篇文章有点老了,但我和这个问题的作者完全一样。

我还需要根据MessageHeader 中的类型字段将抽象基类(MessageAbstract) 向下转换为一个或多个具体消息类。由于具体消息的长度和数据可能不同,因此不可能将所有内容都包含在MessageAbstract 中。

我也使用static_cast 方法,因为我更熟悉OOP 而不是元编程。

在当前项目中使用 C++11,我想在这个答案中概述我的解决方案。以下解决方案与 Vicente Botet Escriba 提供的解决方案非常相似,但使用的是 Modern C++。

#include <cstdint>
#include <memory>

namespace Example {

enum class MessageTypes : std::uint8_t {
  kFooMessage = 0x01,
  kBarMessage = 0x02
};

class MessageHeader {
 public:
  explicit MessageHeader(MessageTypes const kType) : kType_{kType} {
  }

  MessageTypes type() const noexcept {
    return this->kType_;
  }

 private:
  MessageTypes const kType_;
};

class MessageAbstract {
 public:
  explicit MessageAbstract(MessageHeader const kHeader) : kHeader_{kHeader} {
  }

  MessageHeader header() const noexcept {
    return this->kHeader_;
  }

 private:
  MessageHeader const kHeader_;
};

class FooMessage : public MessageAbstract {
 public:
  void specific_method_for_class_foo_message() const noexcept {
  }
  // ...
};

class BarMessage : public MessageAbstract {
 public:
  void specific_method_for_class_bar_message() const noexcept {
  }
  // ...
};

using MessagePointer = std::shared_ptr<MessageAbstract const>;

}  // namespace Example

using namespace Example;

int main() {
  MessagePointer message_ptr{/* Creation Method / Factory Method */};

  switch (message_ptr->header().type()) {
    case MessageTypes::kFooMessage: {
      std::shared_ptr<FooMessage const> foo_message{std::static_pointer_cast<FooMessage const>(message_ptr)};
      foo_message->specific_method_for_class_foo_message();
      // ...
      break;
    }
    case MessageTypes::kBarMessage: {
      std::shared_ptr<BarMessage const> bar_message{std::static_pointer_cast<BarMessage const>(message_ptr)};
      bar_message->specific_method_for_class_bar_message();
      // ...
      break;
    }
    default:
      // Throw exception.
      break;
  }

  return 0;
}

【讨论】:

    【解决方案9】:

    我没有看到任何与此相关的答案,但是您不能通过网络发送 C++ 对象并期望它们完好无损地到达。虚拟表是根据发送计算机的内存状态设置的,接收计算机很可能不会在同一个地方有东西。这通常也会使 RTTI 失败(这是 dynamic_cast 使用的),因为 RTTI 通常与 vtable 一起实现。

    【讨论】:

    • 我不直接将内存复制到网络。这些帧是根据协议规范以独立于主机的方式构建的。
    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 2010-10-02
    • 1970-01-01
    • 2023-03-26
    • 2017-06-30
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    相关资源
    最近更新 更多