C语言的内存操作函数详解

已于 2024-07-23 08:45:10 修改
阅读量1.1k 收藏 19
点赞数 28
分类专栏： c语言 c/c++ linux 文章标签： c语言 开发语言 申请空间 堆 malloc
于 2024-06-16 20:37:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gopher9511/article/details/139725878
版权
c/c++ 同时被 3 个专栏收录
87 篇文章 0 订阅
订阅专栏
c语言
45 篇文章 0 订阅
订阅专栏
linux
14 篇文章 0 订阅
订阅专栏

内存管理

进程空间

程序，是经源码编译后的可执行文件，可执行文件可以多次被执行，比如我们可以
多次打开 office。
而进程，是程序加载到内存后开始执行，至执行结束，这样一段时间概念，多次打
开的 wps,每打开一次都是一个进程，当我们每关闭一个 office，则表示该进程结束。
程序是静态概念，而进程动态/时间概念。

进程空间图示

在这里插入图片描述

栈内存(Stack)

栈存储的特点

栈中存放任意类型的变量，但必须是 auto 类型修饰的，即自动类型的局部变量，
随用随开，用完即消。
内存的分配和销毁系统自动完成，不需要人工干预。

栈大小

栈的大小并不大，他的意义并不在于存储大数据，而在于数据交换。

[root@localhost ~]# ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size
(blocks, -f) unlimited
pending signals                 (-i) 16384
max locked memory       (kbytes, -l) 32
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues
(bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 10240
//10M
cpu time               (seconds, -t) unlimited
max user processes              (-u) 16384
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

堆内存(Heap)

堆存储的特点

堆内存可以存放任意类型的数据，但需要自己申请与释放

堆大小

堆的大小受限于系统的内存大小，一般为物理内存的 1/4 到 1/2。

测试申请大空间

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
    int * p = (int*)malloc(1024*1024*1024); //1G 完全无压力
    if(p == NULL)
    {
        printf("malloc error\n");
        return -1;
    }
    int *q = (int*)malloc((unsigned int)-1);
//无力归天 42 亿个字节 避免整型溢出
    if(q == NULL)
    {
        printf("malloc error\n");
        return -1;
    }
    return 0;
}

堆内存的申请与释放

malloc()

函数声明
void * malloc(size_t _Size);
函数功能

申请指定大小的堆内存空间，并返回指向该空间的指针。

函数参数
  • _Size：要申请的堆内存空间的大小，以字节为单位。
  • 返回值：
  • 成功：返回指向新分配的堆内存空间的指针。
  • 失败：返回 NULL。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
//申请基本数据类型和数组，栈堆空间作对比。
    int a; int *p = &a;
    a = 100; printf("*p = %d\n",a);
    int *pm = (int*)malloc(sizeof(int));
    if(pm == NULL) return -1;
    *pm = 100;
    printf("*pm = %d\n",*pm);
//申请基本数据类型和数组，栈堆空间作对比。
    int array[10]; int *pa = array;
    pm = (int*)malloc(10*sizeof(int));

    for(int i=0; i<10; i++)
    {
        printf("%d\n",pm[i]);
    }
    free(pm);
    return 0;
}

calloc()

函数声明
void * calloc(size_t _Num, size_t _Size);
函数功能

申请指定大小的堆内存空间，并返回指向该空间的指针。自动清零。

函数参数
  • _Num：要申请的堆内存空间的个数。
  • _Size：要申请的堆内存空间的大小，以字节为单位。
  • 返回值：
  • 成功：返回指向新分配的堆内存空间的指针。
  • 失败：返回 NULL。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
    int * array = (int*)calloc(10,sizeof(int));
    for(int i=0; i<10; i++)
    {
        printf("%d\n",array[i]); //己被初始化。
    }
    return 0;
}

realloc()

函数声明
void * realloc(void * ptr, size_t size);
函数功能

调整指定指针所指向的堆内存空间的大小，并返回调整后的指针。

函数参数
  • ptr：指向要调整的堆内存空间的指针。
  • size：新的堆内存空间的大小，以字节为单位。
  • 返回值：
  • 成功：返回指向调整后的堆内存空间的指针。
  • 失败：返回 NULL。
    返回的指针，可能与 ptr 的值相同，也有可能不同。
    若相同，则说明在原空间后面申请，否则，则可能后续空
    间不足，重新申请的新的连续空间，原数据拷贝到新空间，
    原有空间自动释放。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
    int * array = (int*)calloc(10,sizeof(int));
    int * newArray = realloc(array,80);
//array = realloc(array,80);
    if(newArray == NULL)
    {
        printf("realloc 失败\n");
        return -1;
    }
    for(int i=0; i<20; i++)
    {
        printf("%d\n",newArray[i]);
    }
    return 0;
}

free()

函数声明
void free(void * ptr);
函数功能

释放指定的堆内存空间。

函数参数
  • ptr：指向要释放的堆内存空间的指针。
  • 返回值：无。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
    int * array = (int*)calloc(10,sizeof(int));
    free(array);
    return 0;
}

应用

动态数组

#include <stdio.h>
#include <stdlib.h>

// 主函数
int main()
{
    int len;
    printf("请输入新的长度：");  // 提示用户输入新长度
    scanf("%d", &len);  // 读取用户输入的长度

    int *p = (int*)realloc(NULL, sizeof(int) * len);  // 为指针分配内存空间

    // 打印初始分配的内存空间中的值
    for(int i = 0; i < len; i++)
    {
        printf("%d\n", p[i]);
    }

    // 增加大小
    printf("请输入新的长度：");  // 提示用户输入新长度
    scanf("%d", &len);  // 读取用户输入的长度
    p = (int*)realloc(p, sizeof(int) * len);  // 重新分配内存空间

    // 打印重新分配的内存空间中的值
    for(int i = 0; i < len; i++)
    {
        printf("%d\n", p[i]);
    }

    // 减小大小
    printf("请输入新的长度：");  // 提示用户输入新长度
    scanf("%d", &len);  // 读取用户输入的长度
    p = (int*)realloc(p, sizeof(int) * len);  // 重新分配内存空间

    // 打印重新分配的内存空间中的值
    for(int i = 0; i < len; i++)
    {
        printf("%d\n", p[i]);
    }

    free(p);  // 释放内存空间
    return 0;
}

置空与判空

堆内存使用的逻辑是这样的，申请，判空，使用/释放(配对)，置空。常见错误
之一就是释放以后置未置为 NULL 再次作判空使用 或 释放以后继续非法使用。

char*p=(char*)malloc(100);
strcpy(p,"hello");
free(p);/*p 所指的内存被释放，但是 p 所指的地址仍然不变*/
//p = NULL;忘了此句，后而又用到了
.......
if(NULL!=p)
{
/*没有防错*/
strcpy(p,"hello");
/*出错*/
}

重复申请

while (1)
{
char *p = malloc(1000);
printf("xxxxxx\n");
printf("xxxxxx\n");
printf("xxxxxx\n");
printf("xxxxxx\n");
p = malloc(1000);
// 中途可能忘了，重复申请，内存泄漏
free(p);
printf("xxxxxx\n");
Sleep(10);
}

谁申请谁释放模型（并非绝对）

如果没有协同的原则，则有可能会造成，重复释放

void func(char *p)
{
strcpy(p, "American");
printf("%s\n", p);
free(p);
//此处违反了，，谁申请谁释放的原则。
}
int main()
{
char * p = malloc(100);
func(p);
free(p);
return 0;
}

内存操作函数

memcpy

实现两段空间的拷贝，从源地址src开始，拷贝n个字节到目的地址dest。

void * memcpy(void *dest, const void *src, size_t n);
  • dest：目的地址。
  • src：源地址。
  • n：拷贝的字节数。
#include <stdio.h>
#include <string.h>

int main(void)
{
    int a[10] = {1,2,3,4,5,0,6,7,8,9}; // 定义整型数组a
    int b[10];  // 定义整型数组b
    memcpy(b, a, 10 * sizeof(a[0]));  // 使用memcpy函数对整型数组进行拷贝
    for(int i = 0; i < 10; i++)
    {
        printf("%d\n", b[i]);  // 输出拷贝后的整型数组b
    }
    printf("***************\n");

    char c[10] = {'a','b','c','d','\0','\n','e','f','g','h'};  // 定义字符数组c
    char d[10];  // 定义字符数组d
    memcpy(d, c, 10 * sizeof(a[0]));  // 使用memcpy函数对字符数组进行拷贝
    for(int i = 0; i < 10; i++)
    {
        printf("%c\n", d[i]);  // 输出拷贝后的字符数组d
    }
    printf("***************\n");

    puts(d);  // 输出字符数组d
    return 0;
}

输出:

1
2
3
4
5
0
6
7
8
9
***************
a
b
c
d



e
f
g
h
***************
abcd

memmove

实现两段空间的移动，从源地址src开始，移动n个字节到目的地址dest。

void * memmove(void *dest, const void *src, size_t n);
  • dest：目的地址。
  • src：源地址。
  • n：移动的字节数。
#include <stdio.h>
#include <string.h>

//实现删除数组中某一个元素，后序元素依次向前，返回新的元素个数。
int deleteArrayByIdx(int *array, int idx, int count)
{
    memmove(array + idx, array + idx + 1, (count - (idx + 1)) * sizeof(*array));
    return count - 1;
}

int main()
{
    int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    int count = sizeof(array) / sizeof(array[0]);
    count = deleteArrayByIdx(array, 2, count);
    for (int i = 0; i < count; i++)
    {
        printf("%d\n", array[i]);
    }
    return 0;
}

输出:

1
2
4
5
6
7
8
9
0

memcmp

实现两段内存的比较，从地址src1开始，比较n个字节，如果相同，返回0，如果不同，返回第一个不同的字节的差值。

int memcmp(const void *src1, const void *src2, size_t n);
  • src1：源地址1。
  • src2：源地址2。
  • n：比较的字节数。

memchr

查找一段空间中的一个字符，若存在则返回，所查找到字符的指针，若无，返回 NULL。

void * memchr(const void *s, int c, size_t n);
  • s：源地址。
  • c：要查找的字符。
  • n：查找的字节数。

memset

将一段空间中的字节设置为指定的值，返回指向修改后的空间的指针。最小单位是字节

void * memset(void *s, int c, size_t n);
  • s：源地址。
  • c：要设置的字符。
  • n：设置的字节数。
#include <stdio.h>
#include <string.h>
int main()
{
    
    char buf[1024];
    //memset(buf,0,1024); //将buf数组中所有元素设置为0
    memset(buf,0,1024*sizeof(char)); //这样作更安全
    //memset(buf,'a',1024); //这样作很危险 因为会将buf数组中所有元素设置为'a'
    printf("buf = %s \n",buf);
    strcpy(buf,"china is great\n");
    printf("buf = %s \n",buf);
    int array[10];
    //memset 函数将整型数组中的每个字节设置为十进制数值 1
    //整型数组 array 的每个元素通常占用4个字节（32位），因此memset函数会将每个4字节的区块都设置为十进制数值 16843009。\
    //十进制数值 16843009 对应的二进制表示是 00000001000000010000000100000001
    memset(array,1,10*sizeof(int));//hex 01010101 -> dec 1684 3009
    for(int i=0; i<10; i++)
    {
        printf("%d\n",array[i]);
    }
    return 0;
}

输出:

buf =
buf = china is great

16843009
16843009
16843009
16843009
16843009
16843009
16843009
16843009
16843009
16843009

y[10];
//memset 函数将整型数组中的每个字节设置为十进制数值 1
//整型数组 array 的每个元素通常占用4个字节（32位），因此memset函数会将每个4字节的区块都设置为十进制数值 16843009。
//十进制数值 16843009 对应的二进制表示是 00000001000000010000000100000001
memset(array,1,10*sizeof(int));//hex 01010101 -> dec 1684 3009
for(int i=0; i<10; i++)
{
printf(“%d\n”,array[i]);
}
return 0;
}

输出:

buf =
buf = china is great

16843009
16843009
16843009
16843009
16843009
16843009
16843009
16843009
16843009
16843009

可能只会写BUG
关注
  • 28
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言 - 详解内存操作函数
linkang007的博客
05-12 1447
1.memcpy( )函数2.memmove( )函数3.memset( )函数4.memcmp( )函数
c语言文件操作函数详解汇总
weixin_64423973的博客
03-26 823
c语言文件操作函数详解汇总
C语言内存操作函数详解
Anmory的博客
03-17 9130
memcpy函数的原型声明如下：这里进行一下详细的解读：1. `void * destination`：这是一个指向目标内存区域的指针，即将接收拷贝内容的地址。2. `const void * source`：这是一个指向源内存区域的常量指针，即需要被拷贝内容的起始地址。3. `size_t num`：这是一个无符号整型变量，表示要拷贝的字节数。这意味着无论源内存区域中存储的是何种类型的数据，都将以字节为单位进行拷贝。
c语言常用内存函数详解
m0_67530233的博客
07-18 667
c语言常用内存函数
C语言函数详解
热门推荐
qq_65285898的博客
04-26 8万+
函数作为C语言的基本组成元素，让我们深入认识这个熟悉又陌生的朋友
C语言——内存操作函数
Brenda_Bestow的博客
09-23 715
我们前面了解到字符串操作函数（strlen,strcopy等），字符操作函数（tolower等）。这些函数的操作对象都需要符合一种指定类型，比较局限。而内存操作函数，是通过访问地址的方式操作对象，（不用担心地址存的对象类型)，可应用于任何类型的对象。下面将简单介绍几种常见的内存操作函数。以上就是有关C语言进阶的内容，内存操作函数部分的模拟实现和函数使用说明及方法memcpy函数是用来进行内存拷贝的，但要注意C语言规定：该函数只要能拷贝内存不重叠的内存即可，但在有些编译器中也是可以拷贝内存重叠的内存的。
C语言——malloc函数详解
tyustli
10-23 4万+
malloc函数和free函数详解 引言：为什么使用动态内存分配 当你声明数组时，你必须用一个编译时常量指定数组的长度。但是，数组的长度常常在运行时才知道，这是由于它所需要的内存空间取决于输入数据。例如，一个用于计算学生等级和平均分的程序可能需要存储一个班...
C语言之详解内存操作函数
m0_74352571的博客
11-16 1303
详解内存操作函数：memcpy、memmove、memcmp、memset
C语言中的函数（详解）
m0_63562631的博客
07-01 4万+
详细讲解初学者会遇到的函数问题，干活满满。
C语言中的函数（超详细）
m0_68662723的博客
07-25 5万+
我们都知道函数是数学里的重要组成部分，数学中我们常见到函数的概念，但是你了解C语言中的函数吗？其实函数就相当于一个子程序，那什么是子程序呢？在计算机科学中，子程序是一个大型程序中的某部分代码， 由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代 码，具备相对的独立性。一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。如果库函数能干所有的事情，那还要程序员干什么？所有更加重要的是自定义函数！！！
C语言 回调函数详解
01-20
在C语言中，每个函数都有其在内存中的地址，函数指针就是存储这个地址的变量，从而能够调用相应的函数。 1、回调函数的概念 回调函数本质上是一个通过函数指针调用的函数。它作为参数传递给其他函数，在接收函数...
c语言 malloc函数详解
08-25
"C语言malloc函数详解" malloc函数是C语言中最基本的内存分配函数，用于从堆(heap)中分配内存块。它的原型为`extern void *malloc(unsigned int num_bytes);`，其中`num_bytes`是要分配的内存大小，以字节为单位。...
C语言标准函数库详解.pdf
07-29
C语言标准函数库详解 C语言标准函数库是C语言中提供的一组预定义的函数，用于实现各种常见的操作，如输入输出、数学运算、字符串处理、时间日期处理等。这些函数库是C语言的基础组件，掌握这些函数库的使用是C语言...
基于C语言string函数的详解
09-05
在C语言中，`string`函数是一组用于处理和操作字符串的函数，它们定义在`<string.h>`头文件中。这些函数对于编程任务来说至关重要，尤其是涉及到字符串处理的时候。以下是一些常用的C语言string函数的详细说明： 1....
C语言函数库详解.doc
11-18
C语言函数库是C编程的基础，它包含了丰富的函数和头文件，使得程序员能够方便地进行输入输出、字符串处理、数学计算、错误诊断等操作。以下是对C语言函数库中一些重要头文件及其相关函数的详细解释： 1. `...
CTPN+CRNN 额度信贷文字识别
爱编程的鱼的博客
08-20 857
和anchor一样，带星号的是groundtruth，Xside表示文本框的左边界或者右边界，Cxa表示anchor中心的横坐标，Wa是anchor固定的宽度16像素，所以可以把这个o理解为一个缩放的比例，来对最后的结果做一个准确的拉伸，下面这张图中红色的就是使用了side-refinement，黄色的则是没有使用的结果。，因为文本（单词）其实是一个序列，在图像中每个单词中间是有空格的（字母间），算法就很难界定这是单词内空格还是单词间空格，这也就很难分清检测文本的开始与结束的地方。
C/C++｜C++标准库 string 流之std::ostringstream 和 std::istringstream 流
糖炒栗子
08-20 374
我们在 sstream 头文件中定义了三个类型来支持内存IO(ostringstream\istringstream\stringstream)，这些类型可以向 string 写入数据，这里我们主要讲：和( C++ Primer 中文版第五版)以上的两个类型都继承自我们经常使用的 iostream 头文件中定义的类型。并且，他们还增加了一下成员来管理与流相关的 string。也就是说，他们使得我们能够像控制IO流一样控制 string。
2024河南萌新联赛第五场 C小美想收集（并查集拓展域，2-sat）
最新发布
qq_45809243的博客
08-23 112
2024河南萌新联赛第五场，C小美想收集，并查集拓展域，2-sat
哈希环算法（C语言版本）
qq_64304610的博客
08-21 335
哈希环算法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

可能只会写BUG

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值