[C 语言篇】数据在内存中的存储

在 C 语言的世界里，数据的存储是一个至关重要的基础话题。深入理解数据在内存中的存储方式，不仅有助于我们编写出更高效、更健壮的代码，还能让我们在面对各种复杂的编程问题时，拥有更清晰的思路和更敏锐的洞察力。无论是初学者还是有一定经验的开发者，都能从对数据存储的深入探究中获得新的启发和提升。接下来，就让我们一同揭开数据在内存中存储的神秘面纱。

一、内存的基本概念

1.1 什么是内存

内存，全称为内存储器（Internal Memory），是计算机中用于暂时存储正在运行的程序和数据的部件。它就像是计算机的 "临时仓库"，当我们运行一个 C 语言程序时，程序的代码以及程序中所使用的数据都会被加载到内存中，CPU 会从内存中读取指令和数据进行处理，然后再将处理结果写回内存。内存的读写速度比外部存储设备（如硬盘、U 盘等）要快得多，这使得计算机能够快速地处理各种任务。

1.2 内存的物理结构

从物理层面来看，内存是由一个个存储单元组成的，每个存储单元都有一个唯一的地址，就像我们现实生活中的每一栋房子都有一个唯一的门牌号一样。这些存储单元可以存储 8 位二进制数据，也就是 1 个字节（Byte）。在 32 位的计算机系统中，内存地址通常用 32 位二进制数来表示，这意味着可以表示个不同的地址，对应的内存容量为 4GB（ Byte = 4GB）。而在 64 位的计算机系统中，内存地址用 64 位二进制数表示，理论上可以支持的内存容量远远超过 4GB。

1.3 内存的逻辑结构

从程序员的角度来看，内存可以被划分为不同的逻辑区域，每个区域都有其特定的用途。在 C 语言程序中，常见的内存区域有以下几种：

代码区（Code Segment）：存放程序的可执行代码，这部分内存是只读的，程序在运行过程中不能修改代码区的内容。例如，我们编写的 C 语言函数中的指令就存储在代码区。

数据区（Data Segment）：用于存储已经初始化的全局变量和静态变量。数据区又可以细分为初始化数据段（Initialized Data Segment）和未初始化数据段（Uninitialized Data Segment，也称为 BSS 段）。初始化数据段存放已经初始化且初值不为 0 的全局变量和静态变量，而 BSS 段存放未初始化或初始值为 0 的全局变量和静态变量。

栈区（Stack Segment）：主要用于存放函数的局部变量、函数参数、返回地址等。栈是一种后进先出（LIFO，Last In First Out）的数据结构，当函数被调用时，会在栈顶为该函数的局部变量和参数分配内存空间，函数结束时，这些内存空间会被自动释放。栈的大小通常是有限的，在不同的操作系统和编译器环境下有所不同。

堆区（Heap Segment）：用于动态内存分配，由程序员手动申请和释放。当我们使用malloc、calloc等函数在 C 语言中分配内存时，内存就来自于堆区。堆区的大小理论上只受限于计算机的物理内存大小，但在实际使用中，由于内存碎片等问题，可分配的连续内存空间可能会小于物理内存大小。

二、C 语言的数据类型

2.1 基本数据类型

C 语言提供了丰富的数据类型，其中基本数据类型包括整型（int）、字符型（char）、浮点型（float、double）等。

整型：

- int：通常占用 4 个字节（32 位），用于表示整数，其取值范围在不同的编译器环境下可能略有不同，但一般为 - 2147483648 到 2147483647。

- short：占用 2 个字节（16 位），取值范围比int小，一般为 - 32768 到 32767。

- long：在 32 位系统中通常占用 4 个字节，在 64 位系统中通常占用 8 个字节，用于表示更大范围的整数。

- long long：占用 8 个字节，能表示的整数范围更大。

字符型：char占用 1 个字节，用于存储字符。在 C 语言中，字符在内存中是以其对应的 ASCII 码值的形式存储的，例如字符'A'的 ASCII 码值是 65，在内存中就存储为 65 的二进制形式。

浮点型：

- float：占用 4 个字节，用于表示单精度浮点数，能表示的有效数字大约为 6 - 7 位。

- double：占用 8 个字节，用于表示双精度浮点数，能表示的有效数字大约为 15 - 16 位。

2.2 构造数据类型

除了基本数据类型，C 语言还提供了构造数据类型，通过将基本数据类型组合在一起，形成更复杂的数据结构。

数组：是一组相同类型元素的集合。例如，int arr[10];定义了一个包含 10 个int类型元素的数组，数组中的元素在内存中是连续存储的，通过数组名和下标可以访问数组中的每个元素。

结构体（ struct ）：可以将不同类型的数据组合在一起，形成一个新的复合数据类型。例如：

struct Student {
char name[20];
int age;
float score;
};

这里定义了一个Student结构体，包含一个字符数组name、一个整型变量age和一个浮点型变量score。结构体变量在内存中的存储方式是按照成员的定义顺序依次存放，每个成员之间可能会有内存对齐的情况（后面会详细介绍内存对齐）。

联合体（ union ）：也叫共用体，它的所有成员共享同一块内存空间。例如：
```
union Data {
    int i;
    float f;
    char c;
};
```
定义了一个Data联合体，它可以存储一个int型数据、一个float型数据或者一个char型数据，但在同一时刻只能存储其中一种类型的数据，因为它们共享同一块内存。联合体的大小取决于其最大成员的大小。
枚举（ enum ）：用于定义一组命名的整型常量。例如：

  enum Weekday {
      Monday,
      Tuesday,
      Wednesday,
      Thursday,
      Friday,
      Saturday,
      Sunday
  };

这里定义了一个Weekday枚举类型，其中Monday默认为 0，后面的常量依次递增 1，即Tuesday为 1，Wednesday为 2，以此类推。枚举常量在内存中以整型数据的形式存储。

2.3 指针类型

指针是 C 语言中非常强大且灵活的一种数据类型，它存储的是变量的内存地址。例如：
*

  int num = 10;
  int *p = &num;

这里定义了一个整型变量num，并将其初始化为 10，然后定义了一个指针变量p，p指向num的地址，即p存储的是num在内存中的地址值。通过指针，我们可以间接访问和修改变量的值，这在很多复杂的数据结构（如链表、树等）和算法中都有广泛的应用。指针的大小在 32 位系统中通常为 4 个字节，在 64 位系统中通常为 8 个字节，因为它需要存储内存地址。

2.4 空类型（void）

void类型表示空类型，它没有确定的数据类型。在 C 语言中有以下几种常见的用法：

函数返回值类型：当函数不需要返回值时，可以将其返回值类型定义为void。例如：

  void printMessage() {

  printf("Hello, World!\n");

  }

这里printMessage函数的返回值类型是void，表示该函数不返回任何值。

函数参数列表：当函数不需要参数时，可以在参数列表中使用void。例如：

  int getNumber(void) {

  return 10;

  }

这里getNumber函数的参数列表是void，表示该函数不需要传入参数。

指针类型：void *类型的指针可以指向任何类型的数据，但在使用时需要进行强制类型转换。例如：

复制代码

  int num = 10;

  void *p = &num;

  int *q = (int *)p;

这里先定义了一个void *类型的指针p，并让它指向num的地址，然后通过强制类型转换将p转换为int *类型的指针q，这样就可以通过q来访问num的值了。

三、数据在内存中的存储方式

3.1 整型数据的存储

整型数据在内存中是以二进制补码的形式存储的。为什么要使用补码呢？这是因为补码可以将减法运算转化为加法运算，从而简化计算机的运算逻辑。对于正数，其补码与原码相同；对于负数，其补码是将原码的符号位不变，其余各位取反，然后再加 1。

例如，对于一个 8 位的有符号整型数据，假设要存储 - 5：

首先写出 5 的原码：00000101（最高位是符号位，0 表示正数）。
然后对除符号位外的其他位取反，得到 11111010。
最后加 1，得到 11111011，这就是 - 5 在内存中的补码形式。
当我们在 C 语言中定义一个整型变量并赋值时，编译器会将这个值转换为补码形式存储在内存中。例如：
```
int num = -5;
```
这里num的值 - 5 就会以补码 11111011 的形式存储在内存中，假设int类型占用 4 个字节，那么在内存中的存储情况如下（以小端序为例，小端序是指数据的低位字节存储在内存的低地址处，高位字节存储在内存的高地址处）：

低地址 -> 高地址

11111011 00000000 00000000 00000000

3.2 浮点型数据的存储

浮点型数据在内存中的存储遵循 IEEE 754 标准。以单精度浮点数float为例，它占用 4 个字节（32 位），这 32 位被分为三个部分：
符号位（Sign Bit）：占 1 位，用于表示浮点数的正负，0 表示正数，1 表示负数。
指数位（Exponent Bit）：占 8 位，用于表示浮点数的指数部分，以偏移二进制码的形式存储。偏移量为 127，即实际的指数值等于存储的指数值减去 127。
尾数位（Mantissa Bit）：占 23 位，用于表示浮点数的小数部分。
例如，对于浮点数 12.5，它的二进制表示为 1100.1，即。
符号位：因为是正数，所以符号位为 0。
指数位：指数为 3，加上偏移量 127，得到 130，其 8 位二进制表示为 10000010。
尾数位：去掉小数点前面的 1（因为在 IEEE 754 标准中，规定小数点前总是 1，所以可以省略不存储），剩下的小数部分 1001，在后面补零凑够 23 位，得到 10010000000000000000000。
那么 12.5 在内存中的存储形式（以小端序为例）为：

低地址 -> 高地址

01000001 01001000 00000000 00000000

双精度浮点数double的存储方式与float类似，只是它占用 8 个字节（64 位），其中符号位占 1 位，指数位占 11 位，尾数位占 52 位，偏移量为 1023。

3.3 字符型数据的存储

字符型数据在内存中是以其对应的 ASCII 码值的形式存储的，而 ASCII 码值是一个整数，所以本质上字符型数据的存储和整型数据的存储有一定的相似性。例如，字符'A'的 ASCII 码值是 65，在内存中就存储为 65 的二进制形式。如果定义一个字符型变量：
复制代码
char ch = 'A';

假设char类型占用 1 个字节，那么在内存中的存储情况为：

01000001

3.4 数组的存储

数组在内存中是连续存储的，数组元素的地址是按照其下标顺序依次递增的。例如，对于一个整型数组int arr[5] = {1, 2, 3, 4, 5};，假设int类型占用 4 个字节，数组名arr表示数组的首地址，那么在内存中的存储情况如下（以小端序为例）：

低地址 -> 高地址

00000001 00000000 00000000 00000000 //arr [0]

00000010 00000000 00000000 00000000 //arr [1]

00000011 00000000 00000000 00000000 //arr [2]

00000100 00000000 00000000 00000000 //arr [3]

00000101 00000000 00000000 00000000 //arr [4]

可以通过数组名和下标来访问数组中的元素，例如arr[2]就表示访问数组中的第三个元素，其地址为arr + 2 * sizeof(int)，因为每个int类型元素占用 4 个字节。

3.5 结构体的存储

结构体变量在内存中的存储方式是按照成员的定义顺序依次存放，但由于内存对齐的原因，成员之间可能会存在一些填充字节。内存对齐的目的主要是为了提高内存访问效率，因为现代计算机的 CPU 在访问内存时，通常是以特定的字节数（如 4 字节、8 字节等）为单位进行读取的。如果数据的存储地址能够满足对齐要求，CPU 就可以一次性读取多个数据，从而提高访问速度。

例如，对于下面的结构体：
```
struct Test {

char c;

int i;

short s;

};
```
假设char类型占用 1 个字节，int类型占用 4 个字节，short类型占用 2 个字节。在没有内存对齐的情况下，这个结构体的大小应该是 1 + 4 + 2 = 7 个字节。但在实际存储时，由于内存对齐的要求，编译器会在c和i之间填充 3 个字节，使得i的存储地址是 4 的倍数（因为int类型需要 4 字节对齐），在i和short之间填充 2 个字节，使得short的存储地址是 2 的倍数（因为short类型需要 2 字节对齐）。所以这个结构体的实际大小为 1 + 3 + 4 + 2 + 2 = 12 个字节。在内存中的存储情况如下（以小端序为例）：

低地址 -> 高地址

[char c] [填充 3 字节] [int i] [填充 2 字节] [short s]

可以通过结构体变量名和成员运算符（.）来访问结构体的成员，例如test.i就表示访问test结构体变量中的i成员。

3.6 联合体的存储

联合体的所有成员共享同一块内存空间，其大小取决于最大成员的大小。例如，对于前面定义的union Data联合体：
```
union Data {

int i;

float f;

char c;

};
```
因为int类型和float类型通常都占用 4 个字节，char类型占用 1 个字节，所以这个联合体的大小为 4 个字节。在内存中，i、f和c这三个成员共享这 4 个字节的空间，当我们给其中一个成员赋值时，会覆盖其他成员的值。例如：
```
union Data data;

data.i = 10;

printf("%d\n", data.i); // 输出10

data.f =
```
3.7 指针的存储

指针在内存中存储的是变量的地址。例如，有如下代码：
```
int num = 10;

int *p = &num;
```
这里p是一个指针变量，它存储的是num的地址。在 32 位系统中，指针p占用 4 个字节，这 4 个字节中存储的是num在内存中的地址值。假设num的地址是0x1000（这里只是示例，实际地址由操作系统分配），那么p在内存中的存储内容就是0x1000的二进制形式。在 64 位系统中，指针p则占用 8 个字节，以存储更大范围的内存地址。

四、内存对齐

4.1 内存对齐的规则

前面在介绍结构体存储时，简单提到了内存对齐。内存对齐有一些基本规则：
每个数据成员存储的起始地址必须是该成员大小的整数倍。例如，int类型（通常 4 字节）的成员，其起始地址必须是 4 的倍数；short类型（通常 2 字节）的成员，其起始地址必须是 2 的倍数。
结构体的总大小必须是其最宽基本数据成员大小的整数倍。比如前面的struct Test结构体，最宽的基本数据成员是int（4 字节），所以结构体的总大小是 12 字节，是 4 的整数倍。

4.2 内存对齐的影响

内存对齐对程序的性能和内存使用都有影响。从性能角度看，符合内存对齐的数据访问速度更快，因为 CPU 可以更高效地从内存中读取数据。例如，在未对齐的情况下，CPU 可能需要多次读取内存才能获取一个完整的数据，而对齐后可以一次读取完成。从内存使用角度看，内存对齐可能会导致内存空间的浪费，如前面struct Test结构体中出现的填充字节。但总体来说，在大多数情况下，内存对齐带来的性能提升是大于内存浪费的。

4.3 如何控制内存对齐

在 C 语言中，可以通过#pragma pack(n)指令来指定结构体的对齐方式，其中n表示按照n字节对齐。例如：

  #pragma pack(1)

  struct Test2 {

  char c;

  int i;

  short s;

  };

  #pragma pack()

这里使用#pragma pack(1)指定按照 1 字节对齐，此时struct Test2的大小就是 1 + 4 + 2 = 7 字节，没有填充字节。使用完自定义对齐后，通过#pragma pack()恢复默认的对齐方式。不过，使用自定义对齐可能会牺牲一定的性能，所以要谨慎使用。

五、大小端模式

5.1 什么是大小端模式

大小端模式是指数据在内存中存储时字节顺序的不同方式。

小端模式（Little - Endian）：数据的低位字节存储在内存的低地址处，高位字节存储在内存的高地址处。例如，对于一个 16 位整数0x1234，在小端模式下内存中的存储顺序是：低地址 -> 高地址：34 12。
大端模式（Big - Endian）：数据的高位字节存储在内存的低地址处，低位字节存储在内存的高地址处。对于0x1234，在大端模式下内存中的存储顺序是：低地址 -> 高地址：12 34。

5.2 大小端模式的检测

可以通过编写代码来检测当前系统是大端模式还是小端模式，示例代码如下：

  #include <stdio.h>

  int checkEndian() {

  int num = 1;

  char *p = (char *)&num;

  return *p;

  }

  int main() {

  if (checkEndian()) {

  printf("小端模式\n");

  } else {

  printf("大端模式\n");

  }

  return 0;

  }

在这个代码中，定义了一个int型变量num并初始化为 1，然后通过一个char型指针p指向num。由于char类型只占 1 个字节，所以*p指向的是num的最低位字节。如果*p的值为 1，说明最低位字节存储在低地址，即小端模式；如果*p的值为 0，说明高位字节存储在低地址，即大端模式。在大多数 x86 架构的计算机中，采用的是小端模式。

5.3 大小端模式在网络通信中的应用

在网络通信中，不同的系统可能采用不同的大小端模式。为了保证数据在不同系统之间正确传输，通常会将数据转换为网络字节序（大端模式）进行传输。在 C 语言中，可以使用htonl（将 32 位整数从主机字节序转换为网络字节序）、htons（将 16 位整数从主机字节序转换为网络字节序）等函数进行转换。例如：

  #include <arpa/inet.h>

  #include <stdio.h>

  int main() {

  int num = 0x12345678;

  int net_num = htonl(num);

  printf("主机字节序: 0x%x\n", num);

  printf("网络字节序: 0x%x\n", net_num);

  return 0;

  }

这段代码将一个 32 位整数从主机字节序转换为网络字节序，并输出转换前后的值。

六、动态内存分配与释放

6.1 动态内存分配函数

在 C 语言中，常用的动态内存分配函数有malloc、calloc和realloc。

malloc：void *malloc(size_t size)，用于分配指定字节数的内存空间，返回一个指向分配内存起始地址的指针。如果分配失败，返回NULL。例如：

  int *p = (int *)malloc(10 * sizeof(int));

  if (p == NULL) {

  // 处理分配失败的情况

  return;

  }

这里分配了 10 个int类型大小的内存空间，由于malloc返回的是void *类型指针，所以需要强制转换为int *类型。

calloc：void *calloc(size_t nmemb, size_t size)，用于分配nmemb个大小为size字节的内存空间，并将所有字节初始化为 0。返回值与malloc类似。例如：

复制代码

  int *q = (int *)calloc(10, sizeof(int));

  if (q == NULL) {

  // 处理分配失败的情况

  return;

  }

这里分配了 10 个int类型大小的内存空间，并且每个字节都被初始化为 0。

realloc：void *realloc(void *ptr, size_t size)，用于重新分配已经分配的内存空间大小。ptr是指向原来分配内存的指针，size是新的内存大小。如果重新分配成功，返回指向新内存的指针，原来的指针失效；如果分配失败，返回NULL，原来的指针仍然有效。例如：

复制代码

  p = (int *)realloc(p, 20 * sizeof(int));

  if (p == NULL) {

  // 处理分配失败的情况

  return;

  }

这里将原来分配的 10 个int类型大小的内存空间重新分配为 20 个int类型大小的内存空间。

6.2 动态内存释放

动态分配的内存使用完毕后，需要使用free函数进行释放，以避免内存泄漏。free函数的原型为void free(void *ptr)，其中ptr是指向要释放内存的指针。例如：

  free(p);

  free(q);

需要注意的是，只能释放通过malloc、calloc、realloc分配的内存，并且不能重复释放同一个指针，否则会导致未定义行为。

七、数据存储相关的常见错误与调试

7.1 内存泄漏

内存泄漏是指程序在动态分配内存后，没有及时释放，导致这部分内存无法再被使用，从而造成内存资源的浪费。例如：

  void memoryLeak() {

  int *p = (int *)malloc(10 * sizeof(int));

  // 这里没有调用free(p)释放内存

  }

在memoryLeak函数中，分配了内存但没有释放，每次调用这个函数都会造成一定的内存泄漏。可以使用一些工具（如 Valgrind）来检测内存泄漏问题。

7.2 野指针

野指针是指指向一块已经被释放或者未初始化内存的指针。例如：

  int *wildPointer() {

  int *p = (int *)malloc(10 * sizeof(int));

  free(p);

  // 这里p成为野指针，因为它指向的内存已经被释放

  return p;

  }

在这个例子中，p在释放内存后没有被置为NULL，此时p就是一个野指针。使用野指针会导致程序出现未定义行为，可能导致程序崩溃或者数据错误。

7.3 数组越界

数组越界是指访问数组元素时，下标超出了数组的有效范围。例如：

  int main() {

  int arr[5] = {1, 2, 3, 4, 5};

  int value = arr[10]; // 这里访问了arr[10]，超出了数组的有效范围0 - 4

  return 0;

  }

数组越界同样会导致未定义行为，在调试时可以通过开启编译器的数组越界检查选项（如在 GCC 中使用-fsanitize=address选项）来帮助发现这类问题。

深入理解数据在内存中的存储方式，是掌握 C 语言编程的关键一步。通过对内存基本概念、数据类型、存储方式、内存对齐、大小端模式以及动态内存分配与释放等方面的学习，我们能够编写出更高效、更稳定的 C 语言程序，同时也能更好地理解和解决程序中出现的各种与内存相关的问题。希望这篇博客能帮助大家在 C 语言的学习和实践中有所收获。

[C 语言篇】数据在内存中的存储

一、内存的基本概念

1.1 什么是内存

1.2 内存的物理结构

1.3 内存的逻辑结构

二、C 语言的数据类型

2.1 基本数据类型

2.2 构造数据类型

2.3 指针类型

2.4 空类型（void）

三、数据在内存中的存储方式

3.1 整型数据的存储

3.2 浮点型数据的存储

3.3 字符型数据的存储

3.4 数组的存储

3.5 结构体的存储

3.6 联合体的存储

3.7 指针的存储

四、内存对齐

4.1 内存对齐的规则

4.2 内存对齐的影响

4.3 如何控制内存对齐

五、大小端模式

5.1 什么是大小端模式

5.2 大小端模式的检测

5.3 大小端模式在网络通信中的应用

六、动态内存分配与释放

6.1 动态内存分配函数

6.2 动态内存释放

七、数据存储相关的常见错误与调试

7.1 内存泄漏

7.2 野指针

7.3 数组越界