C/C++教程

详解C语言中的内存四区模型及结构体对内存的使用

本文主要是介绍详解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; 
} 

这篇关于详解C语言中的内存四区模型及结构体对内存的使用的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!