C++内存布局

虚拟内存 

每个进程的用户空间是私有的，内核空间是共享的；通过进程间通信比线程间通信难也是因为进程间的用户空间是相互隔离的，无法相互访问，需要通过进程间通信方式通信，通过内核地址空间；

#include <iostream>

int  gdata1 = 1;
int  gdata2 = 0;
int  gdata3;

static int  gdata4 = 4;
static int  gdata5 = 0;
static int  gdata6;

int main() {
  int  a = 11;
  int  b = 0;
  int c;

  static int d = 12;
  static int e = 0;
  static int f;

  const char *p = "hello world";

  return 0;

 }

.text（代码段）

        .text段存放程序代码，运行前就已经确定（编译时确定），通常为只读

        在window平面，可执行程序为xxx.exe;它产生两种东西：指令和数据。.exe程序存放在磁盘中，执行时被加载到内存中，当然不是物理内存，而是虚拟内存空间。.text中存放指令

 .rodata(只读数据段)

        rodata段存储常量数据，比如程序中定义为const的全局变量，#define定义的常量，以及诸如“Hello World”的字符串常量。

      注意：有些立即数与指令编译在一起，放在text段。

              const修饰的全局变量在常量区；const修饰的局部变量只是为了防止修改，没有放入常量区。

             编译器会去掉重复的字符串常量，程序的每个字符串常量只有一份。

              有些系统中rodata段是多个进程共享的，目的是为了提高空间利用率

       如在main中的  const char *p = "hello world"; 即存放在.rodata中。在vs2017中，并不能将常量字符串定义为char *p类型，否则会编译失败；

.data       

        data存储已经初始化的全局变量，属于静态内存分配。（注意：初始化为0的全局变量还是被保存在BSS段）

       static声明的变量也存储在数据段。

        定义在全局的对象，在程序启动时构造，在程序退出时释放

.bss

        bss段存储没有初值的全局变量或默认为0的全局变量，属于静态内存分配。 bss段内容会被全部设为0。

stack

      stack段存储参数变量和局部变量，由系统进行申请和释放，属于静态内存分配。

     stack的特点是先进先出，可用于保存/恢复调用现场。

      定义在栈上的对象，在定义时候构造，在离开作用域时候析构

heap

      heap段是程序运行过程中被动态分配的内存段，由用户申请和释放（例如malloc和free）。

      申请时至少分配虚存，当真正存储数据时才分配物理内存；释放时也不是立即释放物理内存，而是可能被重复利用。

        定义在堆中的对象，在new的时候构造，在delete时候析构

#include <iostream>

//全局变量 无论是否是静态全局变量 都是数据
int  gdata1 = 1;//.data
int  gdata2 = 0;//.bss 初始化为0
int  gdata3;//.bss 未初始化

static int  gdata4 = 4;//.data
static int  gdata5 = 0;//.bss 初始化为0
static int  gdata6; //.bss 未初始化

int main() {
  // a b c 存放在stack中，不是数据 在汇编中是三个mov指令
  int  a = 11;
  int  b = 0;
  int c;

  //局部静态变量
  static int d = 12;//.data
  static int e = 0;//.bss 初始化为0
  static int f;//.bss 未初始化

  const char *p = "hello world";//.rodata

  return 0;

 }

总结

1、执行文件中包含了text、rodata、data段的内容，不包含bss段内容（一堆0放入执行文件没有意义）

2、堆和栈的内存增长方向是相反的：栈是从高地址向低地址生长，堆是从低地址向高地址生长。

3、局部变量存储在stack中，编写函数时要注意如果该函数被递归调用很多次，可能会引起stack overflow的问题。

类的实例化对象所占的内存空间

        一个类的实例化对象所占空间的大小？ 注意不要说类的大小,是类的对象的大小。 首先，类的大小是什么？确切的说，类只是一个类型的定义，它是没有大小可言的，用sizeof运算符对一个类型名操作，得到的是具有该类型实体的大小：

空类的实例化对象占1一个字节

#include <iostream>

class Test
{
};

int main()
{
  Test test;
  std::cout << sizeof(test) << std::endl; //1

  return 0;
}

可以看到一个空类对象的大小1.

一个空类对象的大小是1，为什么不是0？

　　类A明明是空类，它的大小应该为0，为什么编译器输出的结果为1呢？这就是实例化的原因（空类同样被实例化），每个实例在内存中都有一个独一无二的地址，为了达到这个目的，编译器往往会给一个空类隐含的加一个字节，这样空类在实例化后在内存中得到了独一无二的地址，所以obj的大小是1.

打断点调试，F5进入断点；选中test，然后按快捷键shift+F9 

获取到test的内存地址：0x003bf833 然后点击vs菜单栏上的调试->窗口----内存-----内存（1）

然后把test的内存地址粘贴过来： 

 类的成员函数不占用类对象的内存空间

此时给类Test添加了三个成员函数，此时的类A对象的大小是1

#include <iostream>

class Test
{
  void func1() { };
  void  func2() { };
  void  func3() { };
};

int main()
{
  Test test;
  std::cout << sizeof(test) << std::endl; //1

  return 0;
}

类的成员变量占用类对象的内存空间

我们添加了类A的成员变量ch之后，类A对象的大小是多大呢？

#include <iostream>

class Test
{
public:
  void func1() { };
  void  func2() { };
  void  func3() { };

  char ch;
};

int main()
{
  Test test;
  std::cout << sizeof(test) << std::endl; //1

  test.ch = 12;
  return 0;
}

我们看到test的大小是1.shift+F9我们获取到内存地址

 执行f10,发现0x00B5FC3F地址中的值变成0x0c 也就是ch=12;换算成16进制就是0c

字节对齐原则

在系统默认的对齐方式下：每个成员相对于这个结构体变量地址的偏移量正好是该成员类型所占字节的整数倍，且最终占用字节数为成员类型中最大占用字节数的整数倍

当类中有一个char，int时

#include <iostream>

class Test
{
public:
  void func1() { };
  void  func2() { };
  void  func3() { };

  char ch;
  int  n;
};

int main()
{
  Test test;
  std::cout << sizeof(test) << std::endl; //8

  test.ch = 8;
  test.n = 9;
  return 0;
}

由于内存对齐，占8个字节。依然从内存中看：

虚函数