C语言内存布局简记待补充

C语言存储类型总结内存操作函数总结

用于自己学习和记录

1. void *memset(void *s, int c, size_t n);

#include <string.h>

功能:将s的内存区域的前n个字节以参数c填入

参数:

  • s:需要操作内存s的首地址
  • c:填充的字符,c虽然参数为int,但必须是unsigned char, 范围为u0~255
  • n:指定需要设置的大小

返回值:

s的首地址

示例:文章来源地址https://www.yii666.com/article/754022.html

int a[10];

memset(a, 0, sizeof(a));
memset(a, 97, sizeof(a));
int i = 0;
for(i = 0; i< 10; i++)
{
printf("%c\n", a[i]);
}
2. void *memcpy(void *dest, const void *src, size_t n);

#include<string.h>

功能:拷贝src所指的内存内容的前n个字节到dest所值的内存地址上。

参数:

  • dest:目的内存首地址
  • src:源内存首地址,注意:dest和src所指的内存空间不可重叠
  • n:需要拷贝的字节数。

返回值:dest的首地址。

示例:网址:yii666.com

int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int b[10]; memcpy(b, a, sizeof(a));
int i = 0;
for(i = 0; i< 10; i++)
{
printf("%d, ", b[i]);
}
printf("\n");
//memcpy(&a[3], a, 5 * sizeof(int)); //err, 内存重叠
3. void *memmove(void *dest, const void *src, size_t n);

** memmove()功能用法和memcpy()一样,区别在于:dest和src所指的内存空间重叠时,memmove()仍然能处理,不过执行效率比memcpy()低些。**

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

#include<string.h>

功能:比较s1和s2所指向内存区域的前n个字节网址:yii666.com<

参数:

  • s1:目的内存首地址1
  • s2:目的内存首地址2
  • n:需比较的前n个字节。

返回值:

  • 相等:=0
  • 大于:>0
  • 小于:<0

示例:

int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int b[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int flag = memcmp(a, b, sizeof(a));
printf("flag = %d\n", flag);

堆区内存分配和释放

1. *void malloc(size_t size);

#include<stdlib.h>

功能:在内存的动态存储区(堆区)中分配一块长度为size字节的连续区域,用来存放类型说明符指定的类型。分配的内存空间内容不确定,一般使用memset初始化。

参数:

  • size:需要分配内存大小(单位:字节)

返回值:

  • 成功:分配空间的起始地址
  • 失败:NULL

示例:

#include<stdlib.h>
#include<stdio.h>
#include<string.h> int main()
{
int count, *array, n;
printf("请输入要申请数组的个数:\n");
scanf("%d", &n); array = (int *)malloc(n * sizeof (int));
if(array == NULL)
{
printf("申请空间失败!\n");
return -1;
}
//将申请到空间清0
memset(array, 0, sizeof(int)*n); for(count = 0; count<n; count++) /*给数组赋值*/
array[count] = count; for(count = 0; count<n; count++) /*打印数组元素*/
printf("%2d", array[count]); free(array); return 0;
}
2. void free(void *ptr);

功能:释放ptr所指向的一块内存空间,ptr是一个任意类型的指针变量,指向被释放区域的首地址。对同一内存空间多次释放会出错。

参数:ptr:需要释放空间的首地址,被释放区应是由malloc函数所分配的区域。

返回值:无

内存分区代码分析(在Linux下测试)

1. 返回栈区地址
#include<stdio.h>
int a = 10;
int *fun()
{ return &a;//函数调用完毕,a释放
}
int main(int argc, char *argv[])
{
int *p = NULL;
p = fun();
*p = 100; //操作野指针指向的内存,err return 0;
}
2. 返回data区地址
#include<stdio.h>

int *fun()
{
static int a = 10;
return &a; //函数调用完毕,a不释放
} int main(int argc, char *argv[])
{
int *p = NULL;
p = fun();
*p = 100; //ok
printf("*p = %d\n", *p); return 0;
}
3. 值传递1
#include <stdio.h>
#include <stdlib.h> void fun(int *tmp)
{
tmp = (int *)malloc(sizeof(int));
*tmp = 100;
} int main(int argc, char *argv[])
{
int *p = NULL;
fun(p); //值传递,形参修改不会影响实参
printf("*p = %d\n", *p);//err,操作空指针指向的内存 return 0;
}
4. 值传递2
# include<stdio.h>
# include<stdlib.h> void fun(int *tmp)
{
*tmp = 100;
} int main(int argc, char *argv[])
{
int *p = NULL;
p = (int *)malloc(sizeof(int)); fun(p); //值传递
printf("*p = %d\n", *p); //ok,*p为100 return 0;
}
5. 返回堆区地址
#include<stdio.h>
#include<stdlib.h> int *fun()
{
int *tmp = NULL;
tmp = (int *)malloc(sizeof(int));
*tmp = 100;
return tmp;//返回堆区地址,函数调用完毕,不释放
} int main(int argc, char *argv[])
{
int *p = NULL;
p = fun();
printf("*p = %d\n", *p);//ok //堆区空间,使用完毕,手动释放
if (p != NULL)
{
free(p);
p = NULL;
} return 0;
}

拓展

  • C代码经过预处理、编译、汇编、链接4步后生成一个可执行程序

  • 在没有运行程序前,也就是说程序没有加载到内存前,可执行程序内部已经分好3段信息,分别为代码区(text)、数据区(data)和未初始化数据区(bss)3 个部分

  • 代码区

存放 CPU 执行的机器指令。

通常代码区是可共享的(即另外的执行程序可以调用它),使其可共享的目的是对于频繁被执行的程序,只需要在内存中有一份代码即可。

代码区通常是只读的,使其只读的原因是防止程序意外地修改了它的指令。另外,代码区还规划了局部变量的相关信息。

  • 全局初始化数据区/静态数据区(data段)

该区包含了在程序中明确被初始化的全局变量、已经初始化的静态变量(包括全局静态变量和局部静态变量)和常量数据(如字符串常量)。文章来源地址:https://www.yii666.com/article/754022.html

  • 未初始化数据区(又叫 bss 区)

存入的是全局未初始化变量和未初始化静态变量。未初始化数据区的数据在程序开始执行之前被内核初始化为 0 或者空(NULL)。

程序在加载到内存前,代码区和全局区(data和bss)的大小就是固定的,程序运行期间不能改变。然后,运行可执行程序,系统把程序加载到内存,除了根据可执行程序的信息分出代码区(text)、数据区(data)和初始化数据区(bss)之外,还额外增加了栈区、堆区。

  • 代码区(text segment)

加载的是可执行文件代码段,所有的可执行代码都加载到代码区,这块内存是不可以在运行期间修改的。文章地址https://www.yii666.com/article/754022.html

  • 未初始化数据区(BSS)

加载的是可执行文件BSS段,位置可以分开亦可以紧靠数据段,存储于数据段的数据(全局未初始化,静态未初始化数据)的生存周期为整个程序运行过程。

  • 全局初始化数据区/静态数据区(data segment)

加载的是可执行文件数据段,存储于数据段(全局初始化,静态初始化数据,文字常量(只读))的数据的生存周期为整个程序运行过程。

  • 栈区(stack)

栈是一种先进后出的内存结构,由编译器自动分配释放,存放函数的参数值、返回值、局部变量等。在程序运行过程中实时加载和释放,因此,局部变量的生存周期为申请到释放该段栈空间。

  • 堆区(heap)

堆是一个大容器,它的容量要远远大于栈,但没有栈那样先进后出的顺序。用于动态内存分配。堆在内存中位于BSS区和栈区之间。一般由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收。

存储类型总结

类型 作用域 生命周期 存储位置
auto变量 一对{}内 当前函数 栈区
static局部变量 一对{}内 整个程序运行期 初始化在data段,未初始化在BSS段
extern变量 整个程序 整个程序运行期 初始化在data段,未初始化在BSS段
static全局变量 当前文件 整个程序运行期 初始化在data段,未初始化在BSS段
extern函数 整个程序 整个程序运行期 代码区
static函数 当前文件 整个程序运行期 代码区
register变量 一对{}内 当前函数 运行时存储在CPU寄存器
字符串常量 当前文件 整个程序运行期 data段

常见内存问题记录

int main()
{
int* p = (int*)malloc(sizeof(int) * 10); printf("%p\n", p);
//赋值
for (int i = 0; i < 10; i++)
{
p[i] = i;
}
//打印
for (int i = 0; i < 10; i++)
{
//printf("%d\n", p[i]);
//printf("%d\n", *(p + i));
printf("%d\n", *p);
p++;
}
p = p - 10;
//指着叠加改变指针指向 使指针指向未知空间
//释放野指针对应的堆空间一定会报错
printf("%p\n", p);
//释放堆区空间
free(p); return EXIT_SUCCESS;
}
int main()
{
// 野指针
int* p = (int*)malloc(0);
// printf("%p\n", p);
*p = 123;
printf("%d\n", *p);
// 释放野指针对应的堆空间
free(p);
return 0;
}
int main()
{
//开辟堆空间内存为sizeof(数据类型)倍数
int* p = (int*)malloc(10); printf("%p\n", p);
p[0] = 123;
p[1] = 666;
p[2] = 2333;
printf("%d\n", p[0]);
printf("%d\n", p[1]);
printf("%d\n", p[2]); free(p);
return 0;
}
int main()
{
int* p = (int*)malloc(sizeof(int));
printf("%p\n", p);
*p = 123;
printf("%d\n", *p);
free(p);
//指针释放之后成为空指针,需要将野指针变为空指针
p = NULL; //p是一个野指针
//操作野指针对应的堆空间
*p = 666;
printf("%d\n", *p);
printf("%p\n", p); //指针空间不允许多次释放
free(p); //空指针之后
free(p);
free(p);
free(p);
free(p);
free(p);
free(p);
free(p);
free(p);
free(p);
free(p);
free(p);
free(p); return 0;
void demo(int* p)
{
// 仍然表示值传递
p = (int*)malloc(sizeof(int) * 10);
printf("%p\n", p);
}
// 二级指针作为函数参数
void demo(int** p)
{
// 二级指针-地址传递
*p = (int*)malloc(sizeof(int) * 10);
printf("%p\n", *p);
}
int main1212()
{
int* p = NULL;
demo(&p);
p[0] = 123;
printf("%d\n", p[0]);
free(p);
return 0;
}

版权声明:本文内容来源于网络,版权归原作者所有,此博客不拥有其著作权,亦不承担相应法律责任。文本页已经标记具体来源原文地址,请点击原文查看来源网址,站内文章以及资源内容站长不承诺其正确性,如侵犯了您的权益,请联系站长如有侵权请联系站长,将立刻删除

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

支付宝扫一扫打赏

微信图片_20190322181744_03.jpg

微信扫一扫打赏

请作者喝杯咖啡吧~

支付宝扫一扫领取红包,优惠每天领

二维码1

zhifubaohongbao.png

二维码2

zhifubaohongbao2.png