Question

我的问题是：

C++ dynamic_cast vs storing object type in a static enum?

这个问题没有得到答复。 dynamic_cast需要RTTI，而虚函数需要查表，减慢了他们的调用（我知道Stroustrup推荐这个）。枚举+访问器是识别类型之间最快的方法吗？

编辑：

我的帖子的重点是课程Screen：

class ScreenImpl;

class Screen
{
public:
  enum Type
  {
    GLES1,
    GLES2,
    GLES3
  };

  enum Type type() const noexcept { return type_; }

private:
  enum Type type_;

  ScreenImpl* impl_;
};

该类可以有不同的实现（使用PIMPL，可以创建3个不同的上下文之一，头文件保持不变，所以static_cast是可以的）我认为对象可能在他们正在运行什么上下文（GLES1，GLES2或GLES3）。或者，我可以使用dynamic_cast（至少需要1个虚拟成员函数）或typeid。现在，在阅读帖子之后，我想我会废除这一点，让所有对象知道它们在什么上下文中提前运行（前面所有的ifs和switch，以及虚函数的调用）。

Answer 1

通常，你需要这三个......;）

通常，虚拟的减慢速度小于if (x) do_something的开销。特别是如果你得到多个if语句，它将对性能非常不利。换句话说，当涉及到性能时，在每个类中存储枚举将至少与调用虚函数一样糟糕。

[和上一个问题中的答案一样，你不能有一个静态枚举，除非所有对象都是同一类型，在这种情况下，你不是在谈论你应该使用虚拟的东西]。

在大多数编译器中，dynamic_cast只需要一个vtable - 编译器将生成代码以将vtable的地址与已知类型进行比较。但是如果你相信比较vtable +比较结果不是NULL更好（性能明智，显然设计可能是另一回事）而不是调用虚函数，我想你会发现你错了。

如果由于使用虚函数而出现性能问题，那么对象本身可能设计错误/使用不当或其他问题。例如，也许调用虚拟函数PER PIXEL是个坏主意，你应该使用一个在像素区域上运行的函数......

当然，与往常一样，对于处理性能的任何事情，您需要使用编译器和编译器设置来测量系统（不要在调试构建上进行测量） - 编译器通常会进行非悲观的判断当你没有优化时代表“真实代码”）。

另请注意，编译器可以（有时）将虚函数化。还有更多工作正在进行中，因此编译器将“更好”地执行此操作。例如，请参阅Jan Hubicka关于此主题的帖子： http://hubicka.blogspot.co.uk/2014/01/devirtualization-in-c-part-1.html

Answer 2

Vtable'lookup'正在评估偏移量（一加运算），然后取消引用指向该函数的指针。
静态枚举将花费几个“if”检查。如果有很多ifs，它可能会花费更多:)但你应该测量这些东西。编译时模板多态性在运行时不需要任何费用。

Answer 3

如有疑问，请查看并检查汇编：）

以下是三种情况的比较（dynamic_cast，虚拟函数（type）和enum）。为简单起见，special方法在所有情况下都是相同的，只能看到实际情况的差异。然而，在现实世界中，“特殊”每次都会有所不同，否则就没有意义了。

by_enum还演示了开头的vcall会发生什么。

enum Type { D1_t, D2_t, D3_t, D4_t, D5_t };
struct Base
{
  virtual ~Base() = default;
  virtual Type type() = 0;
};

struct D1 : public Base
{ 
  Type type() override { return D1_t; }
  int special1();
};
struct D2 : public Base{ 
  Type type() override { return D2_t; } 
  int special2();
};
struct D3 : public D2{
  Type type() override { return D3_t; } 
  int special3();
};
struct D4 : public D2{ 
  Type type() override { return D4_t; }
  int special4();
};
struct D5 : public D4{
  Type type() override { return D5_t; }
  int special5();
};


int by_dynamic(Base* b)
{
  if(auto d = dynamic_cast<D1*>(b)) return d->special1();
  else if(auto d = dynamic_cast<D2*>(b)) return d->special2();
  else if(auto d = dynamic_cast<D3*>(b)) return d->special3();
  else if(auto d = dynamic_cast<D4*>(b)) return d->special4();
  else if(auto d = dynamic_cast<D5*>(b)) return d->special5();
}

int by_enum(Base* b)
{
  switch(b->type())
  {
    case D1_t:
      return static_cast<D1*>(b)->special1();
      break;
    case D2_t:
      return static_cast<D2*>(b)->special2();
      break;
    case D3_t:
      return static_cast<D3*>(b)->special3();
      break;
    case D4_t:
      return static_cast<D4*>(b)->special4();
      break;
    case D5_t:
      return static_cast<D5*>(b)->special5();
      break;
  }
}

以下是by_dynamic（GCC-5.2，-O3）的相关ASM。所以我认为，如果你的表现受到限制，请选择枚举。

by_dynamic(Base*):
    testq   %rdi, %rdi
    je  .L15
    pushq   %rbx
    xorl    %ecx, %ecx
    movl    typeinfo for D1, %edx
    movl    typeinfo for Base, %esi
    movq    %rdi, %rbx
    call    __dynamic_cast
    testq   %rax, %rax
    je  .L3
    popq    %rbx
    movq    %rax, %rdi
    jmp D1::special1()
.L3:
    xorl    %ecx, %ecx
    movl    typeinfo for D2, %edx
    movl    typeinfo for Base, %esi
    movq    %rbx, %rdi
    call    __dynamic_cast
    testq   %rax, %rax
    je  .L4
    popq    %rbx
    movq    %rax, %rdi
    jmp D2::special2()
.L4:
    xorl    %ecx, %ecx
    movl    typeinfo for D3, %edx
    movl    typeinfo for Base, %esi
    movq    %rbx, %rdi
    call    __dynamic_cast
    testq   %rax, %rax
    je  .L5
    popq    %rbx
    movq    %rax, %rdi
    jmp D3::special3()
.L5:
    xorl    %ecx, %ecx
    movl    typeinfo for D4, %edx
    movl    typeinfo for Base, %esi
    movq    %rbx, %rdi
    call    __dynamic_cast
    testq   %rax, %rax
    je  .L6
    popq    %rbx
    movq    %rax, %rdi
    jmp D4::special4()
.L6:
    xorl    %ecx, %ecx
    movl    typeinfo for D5, %edx
    movl    typeinfo for Base, %esi
    movq    %rbx, %rdi
    call    __dynamic_cast
    testq   %rax, %rax
    je  .L2
    popq    %rbx
    movq    %rax, %rdi
    jmp D5::special5()
.L2:
    popq    %rbx
.L15:
    ret

适用于by_enum

by_enum(Base*):
    pushq   %rbx
    movq    (%rdi), %rax
    movq    %rdi, %rbx
    call    *16(%rax)
    cmpl    $4, %eax
    ja  .L18
    movl    %eax, %eax
    movq    %rbx, %rdi
    jmp *.L20(,%rax,8)
.L20:
    .quad   .L19
    .quad   .L21
    .quad   .L22
    .quad   .L23
    .quad   .L24
    popq    %rbx
    jmp D4::special4()
    popq    %rbx
    jmp D5::special5()
    popq    %rbx
    jmp D1::special1()
    popq    %rbx
    jmp D2::special2()
    popq    %rbx
    jmp D3::special3()
.L18:
    popq    %rbx
    ret

dynamic_cast vs虚函数vs成员枚举？

3 个答案: