转自：https://blog.csdn.net/allen_tony/article/details/76973906ios
https://blog.csdn.net/zzwdkxx/article/details/53635173函数
关于多个父类，虚继承，类自己本身的虚函数，状况比较复杂，后续时间再研究。this
类所占内存的大小是由成员变量（静态变量除外）决定的，成员函数是不计算在内的。摘抄部分：
成员函数仍是以通常的函数同样的存在。a.fun()是经过fun(a.this)来调用的。所谓成员函数只是在名义上是类里的。其实成员函数的大小不在类的对象里面，同一个类的多个对象共享函数代码。而咱们访问成员函数是经过类里面的一个指针实现，而这个指针指向的是一个table，table里面记录的各个成员函数的地址（固然不一样的编译可能略有不一样的实现）。因此咱们访问成员函数是间接得到地址的。因此这样也就增长了必定的时间开销，这也就是为何咱们提倡把一些简短的，调用频率高的函数声明为inline形式（内联函数）。spa
若是类定义了虚函数，该类及其派生类就要生成一张虚拟函数表，即vtable。而在类的对象地址空间中存储一个该虚表的入口，占4个字节，这个入口地址是在构造对象时由编译器写入的。.net
因此，因为对象的内存空间包含了虚表入口，编译器可以由这个入口找到恰当的虚函数，这个函数的地址再也不由数据类型决定了。指针
故对于一个父类的对象指针，调用虚拟函数，若是给他赋父类对象的指针，那么他就调用父类中的函数，若是给他赋子类对象的指针，他就调用子类中的函数(取决于对象的内存地址)。code
(一)
class CBase
{
};
sizeof(CBase)=1;对象
为何空的什么都没有是1呢？blog
C++要求每一个实例在内存中都有独一无二的地址。 //important继承
空类也会被实例化，因此编译器会给空类隐含的添加一个字节，这样空类实例化以后就有了独一无二的地址了。因此空类的sizeof为1.
(二)
class CBase
{
int a;
char p;
};
sizeof(CBase)=8;
记得对齐问题,64位是8字节对齐，32位是4字节对齐。int占4字节 //注意这点和struct的对齐原则很像！！！
char占一个字节，补齐3字节
(三)
class CBase
{
public:
CBase(void);
virtual ~CBase(void);
private:
int a;
char* p;
};
再运行：sizeof(CBase)=12
C++类中有虚函数的时候有一个指向虚函数的指针(vptr)，在32位系统分配指针大小为4字节。不管多少个虚函数，只有这一个指针，4字节。//注意通常的函数是没有这个指针的，并且也不占类的内存。
(四)
class CChild:public CBase
{
public:
CChild(void);
~CChild(void);
virtual void test();
private:
int b;
};
输出：sizeof(CChild)=16;
可见子类的大小是自己成员变量的大小加上父类的大小。//其中有一部分是虚函数表的缘由，必定要知道
父类子类共享一个虚函数指针。
(五)
#include <iostream>
class a{};
class b{};
class c:public a{
virtual void fun() = 0;
};
class d:[public b,public c{};
int main()
{
cout << "sizeof(a)=" << sizeof(a)<<endl;
cout << "sizeof(b)=" << sizeof(b)<<endl;
cout << "sizeof(c)=" << sizeof(c)<<endl;
cout << "sizeof(d)=" << sizeof(d)<<endl;
retrun 0;
}
程序执行的输出结果为：
sizeof(a)=1
sizeof(b)=1
sizeof(c)=4
sizeof(d)=8
前三种状况比较常见，注意第四种状况。类d的大小更让初学者疑惑，类d是由类b，c派生而来的，它所大小应该是两者之和5，为何倒是8呢？这是由于为了提升实例在内存中的存取效率。类的大小每每被调整到系统的整数倍，并采起就近的法则，离哪最近的倍数就是该类的大小，因此类d的大小为8字节。
（六）
class MyClass { public: MyClass(); ~MyClass(); void test(); private: char p; }; MyClass::MyClass() { } MyClass::~MyClass() { } void MyClass::test() { } class MyClassA { public: MyClassA(); ~MyClassA(); public: static int m_a; }; MyClassA::MyClassA() { } MyClassA::~MyClassA() { } int MyClassA::m_a = 10; class MyClassB { public: MyClassB(); ~MyClassB(); virtual void test1(); virtual void test2(); private: }; MyClassB::MyClassB() { } void MyClassB::test1() { } void MyClassB::test2() { } MyClassB::~MyClassB() { } int main() { printf("MyClass's size is %d\n", sizeof(MyClass)); printf("MyClassA's size is %d\n", sizeof(MyClassA)); printf("MyClassB's size is %d\n", sizeof(MyClassB)); return 0; }
输出
MyClass's size is 1
MyClassA's size is 1
MyClassB's size is 4
（七）继承多个父类，父类都存在虚函数：
// y1.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" class MyClassA { public: MyClassA(); ~MyClassA(); virtual void test1(); }; MyClassA::MyClassA() { } MyClassA::~MyClassA() { } void MyClassA::test1() { } class MyClassB { public: MyClassB(); ~MyClassB(); virtual void test1(); private: }; MyClassB::MyClassB() { } void MyClassB::test1() { } MyClassB::~MyClassB() { } class MyClassC:public MyClassA { public: MyClassC(); ~MyClassC(); private: }; MyClassC::MyClassC() { } MyClassC::~MyClassC() { } class MyClassD: public MyClassA, MyClassB { public: MyClassD(); ~MyClassD(); private: }; MyClassD::MyClassD() { } MyClassD::~MyClassD() { } int main() { printf("MyClass's size is %d\n", sizeof(MyClassA)); printf("MyClassA's size is %d\n", sizeof(MyClassB)); printf("MyClassB's size is %d\n", sizeof(MyClassC)); printf("MyClassB's size is %d\n", sizeof(MyClassD)); return 0; }
输出：
MyClassA's size is 4
MyClassB's size is 4
MyClassC's size is 4
MyClassD's size is 8
MyClassA，MyClassB都有虚函数。MyClassD继承了MyClassA和MyClassB，因此
MyClassD占用的空间为8
总结：
空的类是会占用内存空间的，并且大小是1，缘由是C++要求每一个实例在内存中都有独一无二的地址。
(一)类内部的成员变量：
普通的变量：是要占用内存的，可是要注意对齐原则(这点和struct类型很类似)。
static修饰的静态变量：不占用内容，缘由是编译器将其放在全局变量区。
(二)类内部的成员函数：
普通函数：不占用内存。虚函数：要占用4个字节，用来指定虚函数的虚拟函数表的入口地址。因此一个类的虚函数所占用的地址是不变的，和虚函数的个数是没有关系的。