类（继承）的内存分配详解

1.基类与派生类的内存分配

派生类继承基类
      内存分配时，是在于基类对象不同的内存地址处，按基类的成员变量类型，开辟一个同样的类型空间，但注意开辟后派生对象的空间，不是复制基类的成员的值，而是仅仅开辟那种成员类型的空间，未初始化时，里面存在的数是不确定的
      
然后派生类自己定义的成员变量是排在继承的A类成员下面，如果派生类定义的变量名与基类相同，则此变量覆盖掉继承的基类同名变量，注意，覆盖不是删除，也 就是派生类中继承自基类的成员变量依然存在，而且值也不发生变化。如果想用此继承自基类的成员变量，则要加:: ， 在成员函数中访问时，直接用base::i,即可，用派生类的对象a访问时，如果此继承自基类的成员变量是对象可访问的（Public类型），则用 a.base::i访问之





Base base;
Sub_class  sub;

base.i;
base.j

但是用对象访问派生类的继承自基类的成员变量时（假定public类型）
得用： 
sub.Base::i
sub.Base::j
直接用sub.i, 访问的是子类自定义的i

如 以下程序

class base{

public:

      int i;

      int j;

};

class sub:public base{

 public:

         int i;

         int j;

    void p(){

              cout<<base::i<<endl;

              cout<<base::j<<endl;

             }        

};  

base b;

sub s;

b.i=1;

b.j=2;

s.i=3;

s.j=4;

s.p();             //   输出两个不确定的数 4425598   4421322

cout<<b.i<<endl;  //   1

cout<<b.j<<endl;   //   2

cout<<s.i<<endl;   //   3

cout<<s.j<<endl;   //   4

cout<<s.base::i<<endl;

cout<<s.base::j<<endl;

输出结果如下
4425598
4421322
1
2
3
4
4425598
4421322
Press any key to continue . . .

从派生类对象继承的两个基类变量的值和及基类对象两个成员变量的值得比较看，足以验证上述结论： 
子类继承的基类的成员，只是在另一个内存空间内开辟一个这种类型的成员变量，它的值并不是基类的值，编译器只是负责把这一部分空间类型设置为与基类的类型相同

2 普通类的内存分配

类所占内存的大小是由成员变量（静态变量除外）决定的，成员函数（这是笼统的说，后面会细说）是不计算在内的。

摘抄部分：

          成员函数还是以一般的函数一样的存在。a.fun()是通过fun(a.this)来调用的。所谓成员函数只是在名义上是类里的。其实成员函数的大小不在类的对象里面，同一个类的多个对象共享函数代码。而我们访问类的成员函数是通过类里面的一个指针实现，而这个指针指向的是一个table，table里面记录的各个成员函
cecc
数的地址（当然不同的编译可能略有不同的实现）。所以我们访问成员函数是间接获得地址的。所以这样也就增加了一定的时间开销，这也就是为什么我们提倡把一些简短的，调用频率高的函数声明为inline形式（内联函数）。

(一)

class CBase 

{ 

}; 

sizeof(CBase)=1；

为什么空的什么都没有是1呢？
c++要求每个实例在内存中都有独一无二的地址。//注意这句话！！！！！！！！！！

空类也会被实例化，所以编译器会给空类隐含的添加一个字节，这样空类实例化之后就有了独一无二的地址了。所以空类的sizeof为1。
 (二)

class CBase 

{ 

int a; 

char p; 

}; 

sizeof(CBase)=8;
记得对齐的问题。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.h>
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;
return 0;}
程序执行的输出结果为：
sizeof(a) =1
sizeof(b)=1
sizeof(c)=4
sizeof(d)=8

前三种情况比较常见，注意第四种情况。类d的大小更让初学者疑惑吧，类d是由类b，c派生迩来的，它的大小应该为二者之和5，为什么却是8 呢？这是因为为了提高实例在内存中的存取效率．类的大小往往被调整到系统的整数倍．并采取就近的法则，里哪个最近的倍数，就是该类的大小，所以类d的大小为8个字节．

 

总结：

空的类是会占用内存空间的，而且大小是1，原因是C++要求每个实例在内存中都有独一无二的地址。

（一）类内部的成员变量：

 
普通的变量：是要占用内存的，但是要注意对齐原则（这点和struct类型很相似）。
static修饰的静态变量：不占用内容，原因是编译器将其放在全局变量区。

 

 

 
（二）类内部的成员函数：

普通函数：不占用内存。
虚函数：要占用4个字节，用来指定虚函数的虚拟函数表的入口地址。所以一个类的虚函数所占用的地址是不变的，和虚函数的个数是没有关系的。