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的首地址

示例：

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的首地址。

示例：

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个字节

参数：

• 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段）

该区包含了在程序中明确被初始化的全局变量、已经初始化的静态变量（包括全局静态变量和局部静态变量）和常量数据（如字符串常量）。

• 未初始化数据区（又叫 bss 区）

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

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

• 代码区（text segment）

加载的是可执行文件代码段，所有的可执行代码都加载到代码区，这块内存是不可以在运行期间修改的。

• 未初始化数据区（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;
}