当前位置:主页C 语言入门教程

11. C 语言的内存管理

文章来源:知付 更新时间:2022-05-28 16:22 热度:389
目录
  • 简介

  • void 指针

  • malloc()

  • free()

  • calloc()

  • realloc()

  • restrict 说明符

  • memcpy()

  • memmove()

  • memcmp()

简介

C 语言的内存管理,分成两部分。一部分是系统管理的,另一部分是用户手动管理的。

系统管理的内存,主要是函数内部的变量(局部变量)。这部分变量在函数运行时进入内存,函数运行结束后自动从内存卸载。这些变量存放的区域称为”栈“(stack),”栈“所在的内存是系统自动管理的。

用户手动管理的内存,主要是程序运行的整个过程中都存在的变量(全局变量),这些变量需要用户手动从内存释放。如果使用后忘记释放,它就一直占用内存,直到程序退出,这种情况称为”内存泄漏“(memory leak)。这些变量所在的内存称为”堆“(heap),”堆“所在的内存是用户手动管理的。

void 指针

前面章节已经说过了,每一块内存都有地址,通过指针变量可以获取指定地址的内存块。指针变量必须有类型,否则编译器无法知道,如何解读内存块保存的二进制数据。但是,向系统请求内存的时候,有时不确定会有什么样的数据写入内存,需要先获得内存块,稍后再确定写入的数据类型。

为了满足这种需求,C 语言提供了一种不定类型的指针,叫做 void 指针。它只有内存块的地址信息,没有类型信息,等到使用该块内存的时候,再向编译器补充说明,里面的数据类型是什么。

另一方面,void 指针等同于无类型指针,可以指向任意类型的数据,但是不能解读数据。void 指针与其他所有类型指针之间是互相转换关系,任一类型的指针都可以转为 void 指针,而 void 指针也可以转为任一类型的指针。

int x = 10;

void* p = &x; // 整数指针转为 void 指针
int* q = p; // void 指针转为整数指针

上面示例演示了,整数指针和 void 指针如何互相转换。 &x 是一个整数指针, p 是 void 指针,赋值时 &x 的地址会自动解释为 void 类型。同样的, p 再赋值给整数指针 q 时, p 的地址会自动解释为整数指针。

注意,由于不知道 void 指针指向什么类型的值,所以不能用 * 运算符取出它指向的值。

char a = 'X';
void* p = &a;

printf("%cn", *p); // 报错

上面示例中, p 是一个 void 指针,所以这时无法用 *p 取出指针指向的值。

void 指针的重要之处在于,很多内存相关函数的返回值就是 void 指针,只给出内存块的地址信息,所以放在最前面进行介绍。

malloc()

malloc() 函数用于分配内存,该函数向系统要求一段内存,系统就在“堆”里面分配一段连续的内存块给它。它的原型定义在头文件 stdlib.h

void* malloc(size_t size)

它接受一个非负整数作为参数,表示所要分配的内存字节数,返回一个 void 指针,指向分配好的内存块。这是非常合理的,因为 malloc() 函数不知道,将要存储在该块内存的数据是什么类型,所以只能返回一个无类型的 void 指针。

可以使用 malloc() 为任意类型的数据分配内存,常见的做法是先使用 sizeof() 函数,算出某种数据类型所需的字节长度,然后再将这个长度传给 malloc()

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

*p = 12;
printf("%dn", *p); // 12

上面示例中,先为整数类型分配一段内存,然后将整数 12 放入这段内存里面。这个例子其实不需要使用 malloc() ,因为 C 语言会自动为整数(本例是 12 )提供内存。

有时候为了增加代码的可读性,可以对 malloc() 返回的指针进行一次强制类型转换。

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

上面代码将 malloc() 返回的 void 指针,强制转换成了整数指针。

由于 sizeof() 的参数可以是变量,所以上面的例子也可以写成下面这样。

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

malloc() 分配内存有可能分配失败,这时返回常量 NULL。Null 的值为0,是一个无法读写的内存地址,可以理解成一个不指向任何地方的指针。它在包括 stdlib.h 等多个头文件里面都有定义,所以只要可以使用 malloc() ,就可以使用 NULL 。由于存在分配失败的可能,所以最好在使用 malloc() 之后检查一下,是否分配成功。

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

if (p == NULL) {
  // 内存分配失败
}

// or
if (!p) {
  //...
}

上面示例中,通过判断返回的指针 p 是否为 NULL ,确定 malloc() 是否分配成功。

malloc() 最常用的场合,就是为数组和自定义数据结构分配内存。

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

for (int i = 0; i < 10; i++)
  p[i] = i * 5;

上面示例中, p 是一个整数指针,指向一段可以放置10个整数的内存,所以可以用作数组。

malloc() 用来创建数组,有一个好处,就是它可以创建动态数组,即根据成员数量的不同,而创建长度不同的数组。

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

上面示例中, malloc() 可以根据变量 n 的不同,动态为数组分配不同的大小。

注意, malloc() 不会对所分配的内存进行初始化,里面还保存着原来的值。如果没有初始化,就使用这段内存,可能从里面读到以前的值。程序员要自己负责初始化,比如,字符串初始化可以使用 strcpy() 函数。

char* p = malloc(4);
strcpy(p, "abc");

// or
p = "abc";

上面示例中,字符指针 p 指向一段4个字节的内存, strcpy() 将字符串“abc”拷贝放入这段内存,完成了这段内存的初始化。

free()

free() 用于释放 malloc() 函数分配的内存,将这块内存还给系统以便重新使用,否则这个内存块会一直占用到程序运行结束。该函数的原型定义在头文件 stdlib.h 里面。

void free(void* block)

上面代码中, free() 的参数是 malloc() 返回的内存地址。下面就是用法实例。

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

*p = 12;
free(p);

注意,分配的内存块一旦释放,就不应该再次操作已经释放的地址,也不应该再次使用 free() 对该地址释放第二次。

一个很常见的错误是,在函数内部分配了内存,但是函数调用结束时,没有使用 free() 释放内存。

void gobble(double arr[], int n) {
  double* temp = (double*) malloc(n * sizeof(double));
  // ...
}

上面示例中,函数 gobble() 内部分配了内存,但是没有写 free(temp) 。这会造成函数运行结束后,占用的内存块依然保留,如果多次调用 gobble() ,就会留下多个内存块。并且,由于指针 temp 已经消失了,也无法访问这些内存块,再次使用。

calloc()

calloc() 函数的作用与 malloc() 相似,也是分配内存块。该函数的原型定义在头文件 stdlib.h

两者的区别主要有两点:

(1) calloc() 接受两个参数,第一个参数是某种数据类型的值的数量,第二个是该数据类型的单位字节长度。

void* calloc(size_t n, size_t size);

calloc() 的返回值也是一个 void 指针。分配失败时,返回 NULL。

(2) calloc() 会将所分配的内存全部初始化为 0malloc() 不会对内存进行初始化,如果想要初始化为 0 ,还要额外调用 memset() 函数。

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

// 等同于
int* p = malloc(sizeof(int) * 10);
memset(p, 0, sizeof(int) * 10);

上面示例中, calloc() 相当于 malloc() + memset()

calloc() 分配的内存块,也要使用 free() 释放。

realloc()

realloc() 函数用于修改已经分配的内存块的大小,可以放大也可以缩小,返回一个指向新的内存块的指针。如果分配不成功,返回 NULL。该函数的原型定义在头文件 stdlib.h

void* realloc(void* block, size_t size)

它接受两个参数。

  • block :已经分配好的内存块指针(由 malloc()calloc()realloc() 产生)。

  • size :该内存块的新大小,单位为字节。

    realloc() 可能返回一个全新的地址(数据也会自动复制过去),也可能返回跟原来一样的地址。 realloc() 优先在原有内存块上进行缩减,尽量不移动数据,所以通常是返回原先的地址。如果新内存块小于原来的大小,则丢弃超出的部分;如果大于原来的大小,则不对新增的部分进行初始化(程序员可以自动调用 memset() )。

下面是一个例子, b 是数组指针, realloc() 动态调整它的大小。

int* b;

b = malloc(sizeof(int) * 10);
b = realloc(b, sizeof(int) * 2000);

上面示例中,指针 b 原来指向10个成员的整数数组,使用 realloc() 调整为2000个成员的数组。这就是手动分配数组内存的好处,可以在运行时随时调整数组的长度。

realloc() 的第一个参数可以是 NULL,这时就相当于新建一个指针。

char* p = realloc(NULL, 3490);
// 等同于
char* p = malloc(3490);

如果 realloc() 的第二个参数是 0 ,就会释放掉内存块。

由于有分配失败的可能,所以调用 realloc() 以后,最好检查一下它的返回值是否为 NULL。分配失败时,原有内存块中的数据不会发生改变。

float* new_p = realloc(p, sizeof(*p * 40));

if (new_p == NULL) {
  printf("Error reallocingn");
  return 1;
}

注意, realloc() 不会对内存块进行初始化。

restrict 说明符

声明指针变量时,可以使用 restrict 说明符,告诉编译器,该块内存区域只有当前指针一种访问方式,其他指针不能读写该块内存。这种指针称为“受限指针”(restrict pointer)。

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

上面示例中,声明指针变量 p 时,加入了 restrict 说明符,使得 p 变成了受限指针。后面,当 p 指向 malloc() 函数返回的一块内存区域,就味着,该区域只有通过 p 来访问,不存在其他访问方式。

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

int* q = p;
*q = 0; // 未定义行为

上面示例中,另一个指针 q 与受限指针 p 指向同一块内存,现在该内存有 pq 两种访问方式。这就违反了对编译器的承诺,后面通过 *q 对该内存区域赋值,会导致未定义行为。

memcpy()

memcpy() 用于将一块内存拷贝到另一块内存。该函数的原型定义在头文件 string.h

void* memcpy(
  void* restrict dest, 
  void* restrict source, 
  size_t n
);

上面代码中, dest 是目标地址, source 是源地址,第三个参数 n 是要拷贝的字节数 n 。如果要拷贝10个 double 类型的数组成员, n 就等于 10 * sizeof(double) ,而不是 10 。该函数会将从 source 开始的 n 个字节,拷贝到 dest

destsource 都是 void 指针,表示这里不限制指针类型,各种类型的内存数据都可以拷贝。两者都有 restrict 关键字,表示这两个内存块不应该有互相重叠的区域。

memcpy() 的返回值是第一个参数,即目标地址的指针。

因为 memcpy() 只是将一段内存的值,复制到另一段内存,所以不需要知道内存里面的数据是什么类型。下面是复制字符串的例子。

#include <stdio.h>
#include <string.h>

int main(void) {
  char s[] = "Goats!";
  char t[100];

  memcpy(t, s, sizeof(s));  // 拷贝7个字节,包括终止符

  printf("%sn", t);  // "Goats!"

  return 0;
}

上面示例中,字符串 s 所在的内存,被拷贝到字符数组 t 所在的内存。

memcpy() 可以取代 strcpy() 进行字符串拷贝,而且是更好的方法,不仅更安全,速度也更快,它不检查字符串尾部的 0 字符。

char* s = "hello world";

size_t len = strlen(s) + 1;
char *c = malloc(len);

if (c) {
  // strcpy() 的写法
  strcpy(c, s);

  // memcpy() 的写法
  memcpy(c, s, len);
}

上面示例中,两种写法的效果完全一样,但是 memcpy() 的写法要好于 strcpy()

使用 void 指针,也可以自定义一个复制内存的函数。

void* my_memcpy(void* dest, void* src, int byte_count) {
  char* s = src;
  char* d = dest;

  while (byte_count--) {
    *d++ = *s++;
  }

  return dest;

}

上面示例中,不管传入的 destsrc 是什么类型的指针,将它们重新定义成一字节的 Char 指针,这样就可以逐字节进行复制。 *d++ = *s++ 语句相当于先执行 *d = *s (源字节的值复制给目标字节),然后各自移动到下一个字节。最后,返回复制后的 dest 指针,便于后续使用。

memmove()

memmove() 函数用于将一段内存数据复制到另一段内存。它跟 memcpy() 的主要区别是,它允许目标区域与源区域有重叠。如果发生重叠,源区域的内容会被更改;如果没有重叠,它与 memcpy() 行为相同。

该函数的原型定义在头文件 string.h

void* memmove(
  void* dest, 
  void* source, 
  size_t n
);

上面代码中, dest 是目标地址, source 是源地址, n 是要移动的字节数。 destsource 都是 void 指针,表示可以移动任何类型的内存数据,两个内存区域可以有重叠。

memmove() 返回值是第一个参数,即目标地址的指针。

int a[100];
// ...

memmove(&amp;a[0], &amp;a[1], 99 * sizeof(int));

上面示例中,从数组成员 a[1] 开始的99个成员,都向前移动一个位置。

下面是另一个例子。

char x[] = "Home Sweet Home";

// 输出 Sweet Home Home
printf("%sn", (char *) memmove(x, &amp;x[5], 10));

上面示例中,从字符串 x 的5号位置开始的10个字节,就是“Sweet Home”, memmove() 将其前移到0号位置,所以 x 就变成了“Sweet Home Home”。

memcmp()

memcmp() 函数用来比较两个内存区域。它的原型定义在 string.h

int memcmp(
  const void* s1,
  const void* s2,
  size_t n
);

它接受三个参数,前两个参数是用来比较的指针,第三个参数指定比较的字节数。

它的返回值是一个整数。两块内存区域的每个字节以字符形式解读,按照字典顺序进行比较,如果两者相同,返回 0 ;如果 s1 大于 s2 ,返回大于0的整数;如果 s1 小于 s2 ,返回小于0的整数。

char* s1 = "abc";
char* s2 = "acd";
int r = memcmp(s1, s2, 3); // 小于 0

上面示例比较 s1s2 的前三个字节,由于 s1 小于 s2 ,所以 r 是一个小于0的整数,一般为-1。

下面是另一个例子。

char s1[] = {'b', 'i', 'g', '0', 'c', 'a', 'r'};
char s2[] = {'b', 'i', 'g', '0', 'c', 'a', 't'};

if (memcmp(s1, s2, 3) == 0) // true
if (memcmp(s1, s2, 4) == 0) // true
if (memcmp(s1, s2, 7) == 0) // false

上面示例展示了, memcmp() 可以比较内部带有字符串终止符 0 的内存区域。

分享到:

#免责声明#

版权声明:《 11. C 语言的内存管理 》为作者 知付 原创文章,转载请注明原文地址!
本站所有文章,如无特殊说明或标注,均为本站原创或整合发布。任何个人或组织,在未征得本站同意时,禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益,可联系我们进行处理。
本文地址:https://www.yoppunion.com/C%20%E8%AF%AD%E8%A8%80%E5%85%A5%E9%97%A8%E6%95%99%E7%A8%8B/97.html
同类推荐
评论列表
签到

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

支付宝扫一扫打赏

微信扫一扫打赏

微信扫一扫打赏