C++ 中的 dynamic_cast 开销

Question

我知道 dynamic_cast 有运行时检查，因此认为更安全（可以在失败时返回空指针）但比 static_cast 慢。但是两者之间的开销有多糟糕？

我真的应该考虑在循环中使用 static_cast 来解决常规大型项目中的性能问题吗？或者差异很小，只与特殊的实时程序有关。

Answer 1

你有介绍过吗？

规则是：

• 当您知道目标类型有效时使用static_cast。
• 当您不确定时使用dynamic_cast，并且您需要程序为您查找对象的运行时类型。

就这么简单。所有其他考虑都是次要的。

Answer 2

取决于动态转换如何进行其类安全/正确性检查。在我分析过的系统中，它可以很快变成大量的字符串比较。这是一个足够大的交易，我们几乎使用了一个 assert_cast 风格的系统，其中静态转换用于提高性能，而动态转换用于调试。

Answer 3

超大型 C++ 代码库（例如 Mozilla、OpenOffice）有禁用 RTTI 的习惯（因此无法使用dynamic_cast 和异常），因为仅包含 RTTI 数据的开销在可执行文件中 被认为是不可接受的。特别是，据报道，由于额外的动态重定位，它会导致启动时间大幅增加（我记得大约 10%）。

从未讨论过避免dynamic_cast 和异常所需的额外代码实际上是否更慢。

Answer 4

Tomalak Geret'kal 是对的，当你知道时使用static_cast，当你不知道时使用dynamic_cast。如果你想避免成本，你必须以你知道的方式来构建你的设计。在单独的容器中存储单独的类型会使您的循环逻辑更加复杂，但您可以使用模板算法来解决这个问题。

对于简单的继承树，它非常快。如果您在具有虚拟继承的复杂层次结构中进行横向转换，那么它必须进行非平凡的搜索。

例子：

struct Base {virtual ~Base () {}};
struct Foo : Base {};

struct Bar1 : virtual Base {};
struct Bar2 : virtual Base {};

struct Baz : Bar1, Bar2 {};

Base * a = new Foo ();
Bar1 * b = new Baz ();

dynamic_cast <Foo *> (a); // fast
dynamic_cast <Bar2 *> (b); // slow

性能很大程度上取决于编译器。测量，测量，测量！请记住，运行时类型信息通常会被排除在外，并且会保存在非本地内存中——您应该考虑缓存在循环中的作用。

Answer 5

我刚刚尝试了一个小的演员表基准（在我大约 3 岁的上网本上，所以数字很高，但还不错）。这是测试设置：

class A {
  public:
    virtual ~A() {}
};

class B : public A {
};

#define IT(DO) \
    for (unsigned i(1<<30); i; i--) { \
      B* volatile b(DO); \
      (void)b; \
    }

#define CastTest(CAST) IT(CAST<B*>(a))
#define NullTest() IT(NULL)

int main(int argc, char** argv) {
  if (argc < 2) {
    return 1;
  }
  A* a(new B());
  switch (argv[1][0]) {
    case 'd':
      CastTest(dynamic_cast)
      break;
    case 's':
      CastTest(static_cast)
      break;
    default:
      NullTest()
      break;
  }
  return 0;
}

我发现它高度依赖于编译器优化，所以这是我的结果：

（见下文评估）

O0：

g++ -O0 -Wall castbench.cpp; time ./a.out _; time ./a.out s; time ./a.out d

real        0m7.139s
user        0m6.112s
sys         0m0.044s

real        0m8.177s
user        0m6.980s
sys         0m0.024s

real        1m38.107s
user        1m23.929s
sys         0m0.188s

O1：

g++ -O1 -Wall castbench.cpp; time ./a.out _; time ./a.out s; time ./a.out d

real        0m4.412s
user        0m3.868s
sys         0m0.032s

real        0m4.653s
user        0m4.048s
sys         0m0.000s

real        1m33.508s
user        1m21.209s
sys         0m0.236s

氧气：

g++ -O2 -Wall castbench.cpp; time ./a.out _; time ./a.out s; time ./a.out d

real        0m4.526s
user        0m3.960s
sys         0m0.044s

real        0m4.862s
user        0m4.120s
sys         0m0.004s

real        0m2.835s
user        0m2.548s
sys         0m0.008s

O3：

g++ -O3 -Wall castbench.cpp; time ./a.out _; time ./a.out s; time ./a.out d

real        0m4.896s
user        0m4.308s
sys         0m0.004s

real        0m5.032s
user        0m4.284s
sys         0m0.008s

real        0m4.828s
user        0m4.160s
sys         0m0.008s

编辑：评估

对于一次演员表（在上面的测试中，我们总共有 2**30 演员表）我们在上面的最小示例中得到以下时间：

-O0    71.66 ns
-O1    71.86 ns
-O2    -1.46 ns
-O3    -0.11 ns

负值可能是由于程序执行时的负载不同，并且小到足以被视为不重要（即 ==0）而被丢弃。由于这里没有开销，我们必须假设编译器足够聪明以优化转换，即使我们说b 是易失的。因此，唯一可靠的值是 70 ns 结果。