创建新类的开销

Question

如果我有一个这样定义的类：

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

并且 someInt 是 classWithInt 中唯一的一个成员变量，那么声明该类的新实例会慢多少类而不是仅仅声明一个新整数？

如果类中有 10 个这样的整数呢？ 100？

Answer 1

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

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

数据成员的数量并不重要。将苹果与苹果进行比较；如果你有一个包含 10 个整数的类，那么它所占用的空间与 10 个整数所占用的空间相同。

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

Answer 2

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

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 类型 与普通 int 的区别仅在于一个方面，它需要不同的对齐方式，它是 8 字节对齐而不是 4 字节对齐。

另一个值得注意的事情是 POD 和 bare int 没有被初始化。它们的存储就像来自堆栈的荒野一样使用。非 Pod 类型具有重要的构造函数，会导致在实例用于其他任何操作之前存储零。