创建新类的开销

Question

如果我有这样定义的类：

class classWithInt
{
public:
    classWithInt();
...
private:
    int someInt;
...
}

而someInt 是classWithInt 中唯一且唯一的一个成员变量，那么声明这个类的新实例比只声明一个新整数要慢多少？

如果你在课堂上有 10 个这样的整数呢？ 100？

Answer 1

好吧，让我们测试一下。我可以通过完全优化编译一个更完整的示例，如下所示：

void use(int &);

class classWithInt
{
public:
    classWithInt() : someInt(){}
    int someInt;
};
class podWithInt
{
public:
    int someInt;
};

int main() {
  int foo;
  classWithInt bar;
  podWithInt baz;

  use(foo);
  use(bar.someInt);
  use(baz.someInt);

  return 5;

}

这是我从gcc-llvm得到的输出

; ModuleID = '/tmp/webcompile/_21792_0.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-linux-gnu"

%struct.classWithInt = type { i32 }

define i32 @main() {
entry:
  %foo = alloca i32, align 4                      ; <i32*> [#uses=1]
  %bar = alloca %struct.classWithInt, align 8     ; <%struct.classWithInt*> [#uses=1]
  %baz = alloca %struct.classWithInt, align 8     ; <%struct.classWithInt*> [#uses=1]
  %0 = getelementptr inbounds %struct.classWithInt* %bar, i64 0, i32 0 ; <i32*> [#uses=2]
  store i32 0, i32* %0, align 8
  call void @_Z3useRi(i32* %foo)
  call void @_Z3useRi(i32* %0)
  %1 = getelementptr inbounds %struct.classWithInt* %baz, i64 0, i32 0 ; <i32*> [#uses=1]
  call void @_Z3useRi(i32* %1)
  ret i32 5
}

declare void @_Z3useRi(i32*)

每种情况都有一些差异。在最简单的情况下，POD type 与普通 int 仅在一个方面不同，它需要不同的对齐方式，它是 8 字节对齐而不是 4 字节。

另一个值得注意的事情是 POD 和裸 int 没有被初始化。它们的存储空间就像从堆栈的荒野中一样使用。非 pod 类型具有非平凡的构造函数，会导致在实例可用于其他任何内容之前存储一个零。

Answer 2

使用不是由凌晨喝醉的大学生编写的编译器，开销为零。至少在你开始使用virtual 函数之前；那么你必须为虚拟调度机制付出代价。或者，如果您在类中没有数据，在这种情况下，类仍然需要占用一些空间（这反过来又是因为每个对象在内存中必须具有唯一的地址）。

函数不是对象数据布局的一部分。它们只是对象的心理概念的一部分。函数被翻译成以对象实例作为附加参数的代码，对成员函数的调用也被相应地翻译成传递对象。

数据成员的数量无关紧要。比较苹果和苹果；如果你有一个包含 10 个整数的类，那么它会占用与 10 个整数相同的空间。

在堆栈上分配东西实际上是免费的，无论它们是什么。编译器将所有局部变量的大小相加并立即调整堆栈指针以为它们腾出空间。在内存中分配空间成本，但成本可能更多地取决于分配的数量而不是分配的空间量。