例如，假设我有一个 Temp 类：
class Temp
{
public:
int function1(int foo) { return 1; }
void function2(int bar) { foobar = bar; }
private:
int foobar;
};
当我创建 Temp 类的对象时，我将如何计算它需要多少空间，以及它在内存中的表示方式（例如| foobar 为 4 个字节| function1 为 8 个字节 | 等 | ）
对于一阶近似，对象的大小是其组成数据成员的大小之和。你可以肯定它永远不会小于这个。
更准确地说，编译器有权在数据成员之间插入填充空间，以确保每个数据成员满足平台的对齐要求。一些平台对对齐非常严格，而另一些（x86）则更宽容，但在正确对齐的情况下会表现得更好。因此，即使是编译器优化设置也会影响对象大小。
继承和虚函数增加了额外的复杂性。正如其他人所说，您的类的成员函数本身并不占用“每个对象”空间，但是该类接口中虚函数的存在通常意味着虚表的存在，本质上是用于查找函数指针的表动态解析正确的函数实现以在运行时调用。虚拟表 (vtbl) 通常通过存储在每个对象中的指针来访问。
派生类对象还包括其基类的所有数据成员。
最后，访问说明符（public、private、protected）赋予编译器一定的数据成员打包余地。
简短的回答是 sizeof(myObj) 或 sizeof(MyClass) 将始终告诉您对象的正确大小，但其结果并不总是容易预测。
sizeof(Temp)
会给你尺寸。最有可能的是，它是 4 个字节（给出了很多假设），并且仅适用于 int。这些函数在每个对象的基础上不占用任何空间，它们被编译一次，并在每次使用时由编译器链接。
不可能确切地说出对象布局是什么，但是，标准没有定义对象的二进制表示。
使用二进制表示需要注意一些事项，例如由于结构填充等原因，它们不一定是数据成员字节的总和
我一直想知道这种事情，所以我决定想出一个完整的答案。这是关于你可能期望的，它是可以预测的（耶）！因此，通过以下信息，您应该能够预测类的大小。
使用 Visual Studio Community 2017（版本 15.2），在禁用所有优化和 RTTI（运行时类型信息）关闭的发布模式下，我确定了以下内容：
简短的回答：
首先：
<size of pointer> == 4字节<size of pointer> == 8字节class ChildClass: virtual public ParentClass现在，我的发现是：
<size of variable>字节<size of variables>字节<size of pointer>字节<size of pointer>字节<size of pointer>字节<size of pointer>到总数中，将所有成员变量包装<size of pointer>成尽可能多的字节增量以覆盖<total size of member variables>- 是的，你没看错...（请参阅我对结论中发生的事情的猜测...）请注意，我什至尝试让 function() cout 一些文本，创建类的实例并调用该函数；它不会改变函数类的大小（这不是优化）！我有点惊讶，但这实际上是有道理的：成员函数不会改变，因此它们可以存储在类本身的外部。
结论：
<size of pointer>字节，将<size of pointer>字节添加到所述类。当然，这个 vtable 每个类只能存在一次（它存在或不存在）。<size of pointer>一次以字节为单位递增，即使它不需要消耗这么多内存，我猜是因为它为每个<size of pointer>字节的内存或其他东西添加了一个vtable“帮助块”......长答案：
我使用以下代码确定了所有这些：
#include <iostream>
using namespace std;
class TestA
{
};
class TestB: public TestA
{
};
class TestC: virtual public TestA
{
};
class TestD
{
public:
int i;
};
class TestE: public TestD
{
public:
int j;
};
class TestF: virtual public TestD
{
public:
int j;
};
class TestG
{
public:
void function()
{
}
};
class TestH: public TestG
{
public:
void function()
{
}
};
class TestI: virtual public TestG
{
public:
void function()
{
}
};
class TestJ
{
public:
virtual void function()
{
}
};
class TestK: public TestJ
{
public:
void function() override
{
}
};
class TestL: virtual public TestJ
{
public:
void function() override
{
}
};
void main()
{
cout << "int:\t\t" << sizeof(int) << "\n";
cout << "TestA:\t\t" << sizeof(TestA) << "\t(empty class)\n";
cout << "TestB:\t\t" << sizeof(TestB) << "\t(inheriting empty class)\n";
cout << "TestC:\t\t" << sizeof(TestC) << "\t(virtual inheriting empty class)\n";
cout << "TestD:\t\t" << sizeof(TestD) << "\t(int class)\n";
cout << "TestE:\t\t" << sizeof(TestE) << "\t(inheriting int + int class)\n";
cout << "TestF:\t\t" << sizeof(TestF) << "\t(virtual inheriting int + int class)\n";
cout << "TestG:\t\t" << sizeof(TestG) << "\t(function class)\n";
cout << "TestH:\t\t" << sizeof(TestH) << "\t(inheriting function class)\n";
cout << "TestI:\t\t" << sizeof(TestI) << "\t(virtual inheriting function class)\n";
cout << "TestJ:\t\t" << sizeof(TestJ) << "\t(virtual function class)\n";
cout << "TestK:\t\t" << sizeof(TestK) << "\t(inheriting overriding function class)\n";
cout << "TestL:\t\t" << sizeof(TestL) << "\t(virtual inheriting overriding function class)\n";
cout << "\n";
system("pause");
}
输出：
32 (x86) 位：
int: 4
TestA: 1 (empty class)
TestB: 1 (inheriting empty class)
TestC: 4 (virtual inheriting empty class)
TestD: 4 (int class)
TestE: 8 (inheriting int + int class)
TestF: 12 (virtual inheriting int + int class)
TestG: 1 (function class)
TestH: 1 (inheriting function class)
TestI: 4 (virtual inheriting function class)
TestJ: 4 (virtual function class)
TestK: 4 (inheriting overriding function class)
TestL: 8 (virtual inheriting overriding function class)
64 (x64) 位：
int: 4
TestA: 1 (empty class)
TestB: 1 (inheriting empty class)
TestC: 8 (virtual inheriting empty class)
TestD: 4 (int class)
TestE: 8 (inheriting int + int class)
TestF: 24 (virtual inheriting int + int class)
TestG: 1 (function class)
TestH: 1 (inheriting function class)
TestI: 8 (virtual inheriting function class)
TestJ: 8 (virtual function class)
TestK: 8 (inheriting overriding function class)
TestL: 16 (virtual inheriting overriding function class)
如果您想了解有关多重继承的信息，请自己弄清楚！-.-
如果您想了解有关对象在运行时如何在内存中表示的详细信息，则可以查看 ABI（应用程序二进制接口）规范。您需要确定您的编译器实现了哪个 ABI；例如，GCC 3.2 及更高版本实现了Itanium C++ ABI。
方法属于类，而不是任何特定的实例化对象。
除非有虚方法，否则对象的大小是其非静态成员大小的总和，加上成员之间用于对齐的可选填充。成员可能会在内存中按顺序排列，但规范不保证具有不同访问规范的部分之间的顺序，也不保证相对于超类布局的顺序。
使用虚拟方法时，可能会为vtable和其他 RTTI 信息占用额外的空间。
在大多数平台上，可执行代码位于可执行文件或库的只读.text（或类似名称）部分，并且永远不会被复制到任何地方。当class Temp有一个方法public: int function1(int)时，Temp元数据可能有一个指向_ZN4Temp9function1Ei实际实现的（损坏的名称可能因编译器而异）函数的指针，但它肯定永远不会包含嵌入的可执行代码。
成员函数不考虑特定类的对象的大小。对象的大小仅取决于成员变量。对于包含虚函数的类，VPTR 被添加到对象布局中。所以对象的大小基本上是成员变量的大小 + VPTR 的大小。有时这可能不是真的，因为编译器试图在 DWORD 边界处定位成员变量。
如果您使用的是 Microsoft Visual C++，则有一个编译器选项可以告诉您您的对象实际有多大：/d1reportSingleClassLayout
如果您想检查特定结构的布局，offsetof(s,member)宏也可能有用。它告诉你一个特定成员离结构的基地址有多远：
struct foo {
char *a;
int b;
};
// Print placement of foo's members
void printFoo() {
printf("foo->a is %zu bytes into a foo\n", offsetof(struct foo, a));
printf("foo->b is %zu bytes into a foo\n", offsetof(struct foo, b));
}
int main() {
printFoo();
return 0;
}
将在典型的 32 位机器上打印：
foo->a is 0 bytes into a foo
foo->b is 4 bytes into a foo
而在典型的 64 位机器上，它会打印
foo->a is 0 bytes into a foo
foo->b is 8 bytes into a foo
这可能会有所帮助。
此外，类函数的表示方式与任何其他函数一样。C++ 对函数所做的唯一魔术是修改函数名称以唯一标识具有特定类中特定参数集的特定函数。
有一个实用程序调用pahole（用于'Poke-A-HOLE'），名义上旨在研究对象布局如何被填充，但对于总体上可视化对象大小和布局非常有用。
一个类的对象的大小等于该类的所有数据成员的大小之和。例如，如果我有一堂课
class student
{
private:
char name[20];
int rollno, admno;
float marks;
public:
float tmarks, percentage;
void getdata();
void putdata();
};
现在，如果我创建这个类的一个对象，比如说s1，那么这个对象的大小将是 36 字节：
[20(name)+2(rollno)+2(admno)+4(marks)+4(tmarks)+4(percentage)]