时间：2021-01-17 14:09:08 | 栏目：C代码 | 点击：次
内存四区
1、代码区
代码区code，程序被操作系统加载到内存的时候，所有的可执行代码都加载到代码区，也叫代码段，这块内存是不可以在运行期间修改的。
2、静态区
所有的全局变量以及程序中的静态变量都存储到静态区。
3、栈区
栈stack是一种先进后出的内存结构，所有的自动变量，函数的形参都是由编译器自动放出栈中，当一个自动变量超出其作用域时，自动从栈中弹出。对于自动变量，什么时候入栈，什么时候出栈，是不需要程序控制的，由C语言编译器。实现栈不会很大，一般都是以K为单位的。
当栈空间以满，但还往栈内存压变量，这个就叫栈。溢出对于一个32位操作系统，最大管理管理4G内存，其中1G是给操作系统自己用的，剩下的3G都是给用户程序，一个用户程序理论上可以使用3G的内存空间。
注意：C语言中函数参数入栈的顺序是从右往左。
4、堆区
堆heap和栈一样，也是一种在程序运行过程中可以随时修改的内存区域，但没有栈那样先进后出的顺序。堆是一个大容器，它的容量要远远大于栈，但是在C语言中，堆内存空间的申请和释放需要手动通过代码来完成。
代码示例：
#include <stdio.h>
int c = 0; // 静态区
void test(int a, int b) // 形参a，b都在栈区
{
printf("%d, %d\n", &a, &b);
}
int *geta() // 函数的返回值是一个指针
{
int a = 100; // 栈区
return &a;
} // int a的作用域就是这个{}
int main()
{
int *p = geta(); // 这里得到一个临时栈变量的地址，这个地址在函数geta调用完成之后已经无效了
*p = 100;
printf("%d\n", *p);
static int d = 0; // 静态区
int a = 0; // 栈区
int b = 0;
printf("%d, %d, %d, %d, %d\n", &a, &b, &c, &d, main);
test(a, b);
return 0;
}
/*
输出结果
100
2619740, 2619728, 9404720, 9404724, 9376059
2619512, 2619516
*/
堆使用注意事项：
#include <stdio.h>
#include <stdlib.h>
int *geta() // 错误，不能将一个栈变量的地址通过函数的返回值返回
{
int a = 0;
return &a;
}
int *geta1() // 可以通过函数的返回值返回一个堆地址，但记得，一定要free
{
int *p = (int *)malloc(sizeof(int)); // 申请了一个堆空间
return p;
}
int *geta2() // 合法的，但是记住这里不能用free
{
static int a = 0; // 变量在静态区，程序运行过程中一直存在
return &a;
}
void getHeap(int *p)
{
printf("p = %p\n", &p);
p = (int *)malloc(sizeof(int) * 10);
} // getHeap执行完之后，p就消失了，导致他指向的具体堆空间的地址编号也随之消失了
// 这里发生了内存泄漏
void getHeap1(int **p)
{
*p = (int *)malloc(sizeof(int) * 10);
} // 这里的操作就是正确的
int main()
{
int *p = NULL;
printf("p = %p\n", &p);
getHeap(p); // 实参没有任何改变
getHeap1(&p); // 得到了堆内存的地址
printf("p = %d\n", p);
p[0] = 1;
p[1] = 2;
printf("p[0] = %d, p[1] = %d\n", p[0], p[1]);
free(p);
return 0;
}
结构体内存对齐模式
结构体内存对齐模式各种情况详解
#include <stdio.h>
struct A
{
int a; // 此时结构体占用4个字节
char b; // 此时结构体占用8个字节
char c; // 还是8个字节
char d; // 还是8个字节
char e; // 还是8个字节
char f; // 现在是12个字节
};
struct B
{
char a; // 1个字节
char b; // 2个字节
char c; // 3个字节
};
struct c
{
char name[10]; // 10个字节
char a; // 11个字节
// 对于char型数组来说，会把数组每个元素当作一个char类型
};
struct d
{
int name[10]; // 40个字节
char a; // 44个字节
char b; // 44个字节
};
struct e
{
char a; // 1个字节
int b; // 8个字节
char c; // 12个字节
// 这种写法内存的消耗相比A就会变大
};
struct f
{
char a; // 1
short b; // 4注意这里short占用的是剩下三个字节中的后两个
// 内存对齐总是以2的倍数对齐
char c; // 所以此时是6
int d; // 12
short e; // 16
char f; // 16
};
结构体变相实现数组赋值
struct name
{
char array[10];
};
int main()
{
char name1[10] = "name1";
char name2[20] = "name2";
name1 = name2; // 这里是出错的，不能在数组之间进行赋值
struct name a1 = { "hello" };
struct name a2 = { 0 };
a2 = a1; // 这里通过结构体可以赋值的特性变相实现了数组的赋值
return 0;
}
结构体内存泄漏
#include <stdio.h>
#include <stdlib.h>
union A
{
char a;
char *b; // 联合体的指针成员要特别注意
};
int main()
{
A a;
a.b = (char *)malloc(10); // b指向了一个堆的地址
// 如果联合体中有指针成员，那么一定要使用完这个指针，并且free指针之后才能使用其他成员
a.a = 10; // b的值也成了10了
free(b); // 此时释放b是错误的，因为在上面一行对a进行赋值时，已经将b的值更改了，这里造成了内存泄漏
return 0;
}