不同类型的变量在内存中存储的详细情况

最新推荐文章于 2022-03-18 22:08:13 发布
最新推荐文章于 2022-03-18 22:08:13 发布
阅读量854 收藏
点赞数
分类专栏： 编程 文章标签： 内存 存储

 

一、int型变量在内存中存储详细情况

[cpp] view plain copy print ?
  1. //By Richard
  2. #include <stdio.h>
  3. #include <math.h>
  5. int main()
  6. {
  7. int i1=0;
  8. int i2=1;
  9. int i3=-1;
  10. int i4=127;
  11. int i5=-127;
  12. int i6=128;
  13. int i7=-128;
  14. int i8=255;
  15. int i9=-255;
  16. int i10=256;
  17. int i11=-256;
  18. int i12=(int)pow(2.0,16)-1;//65535
  19. int i13=-(int)pow(2.0,16)+1;//-65535
  20. int i14=(int)pow(2.0,16);//65536
  21. int i15=-(int)pow(2.0,16);//-65536
  22. int i16=(int)pow(2.0,24)-1;//16777215
  23. int i17=-(int)pow(2.0,24)+1;//-16777215
  24. int i18=(int)pow(2.0,24);//16777216
  25. int i19=-(int)pow(2.0,24);//-16777216
  26. int i20=(int)pow(2.0,31)-1;//2147483647，最大值
  27. int i21=-(int)pow(2.0,31)+1;//-2147483647
  28. int i22=(int)pow(2.0,31);//超出范围，溢出，从最小值-2147483648循环
  29. int i23=-(int)pow(2.0,31);//-2147483648，最小值
  31. /***************************************************************
  32. * 在return 0上打上断点，F5开始调试，Alt+6查看内存
  33. * 要想查看哪个变量在内存中的存储情况，在地址栏输入&+变量名，比如说：&i1
  34. * int型占4个字节，注意：内存中的存储顺序和实际的字节表示刚好相反
  35. * 比如说：10，在内存中表示为0a 00 00 00，而实际中表示为00 00 00 0a
  36. * 负数的二进制数：对应的正数的二进制数每一位取反，再加1
  37. * int型最高位表示符号：1，表示负数，0表示正数（内存中的最后一个字节的第一位表示）
  38. * 具体来分析：
  39. * 0 :00 00 00 00
  40. * 1 :01 00 00 00
  41. * -1 :ff ff ff ff(00 00 00 01->ff ff ff fe->ff ff ff ff)
  42. * 127 :7f 00 00 00
  43. * -127 :81 ff ff ff(00 00 00 7f->ff ff ff 80->ff ff ff 81)
  44. * 128 :80 00 00 00
  45. * -128 :80 ff ff ff(00 00 00 80->ff ff ff 7f->ff ff ff 80)
  46. * 255 :ff 00 00 00
  47. * -255 :01 ff ff ff(00 00 00 ff->ff ff ff 00->ff ff ff 01)
  48. * 256 :00 01 00 00
  49. * -256 :00 ff ff ff(00 00 01 00->ff ff fe ff->ff ff ff 00)
  50. * 65535 :ff ff 00 00
  51. * -65535 :01 00 ff ff(00 00 ff ff->ff ff 00 00->ff ff 00 01)
  52. * 65536 :00 00 01 00
  53. * -65536 :00 00 ff ff(00 01 00 00->ff fe ff ff->ff ff 00 00)
  54. * 16777215 :ff ff ff 00
  55. * -16777215 :01 00 00 ff(00 ff ff ff->ff 00 00 00->ff 00 00 01)
  56. * 16777216 :00 00 00 01
  57. * -16777216 :00 00 00 ff(01 00 00 00->fe ff ff ff->ff 00 00 00)
  58. * 2147483647 :ff ff ff 7f
  59. *-2147483647 :01 00 00 80(7f ff ff ff->80 00 00 00->80 00 00 01)
  60. * 2147483648 :01 00 00 00 00(超出范围)
  61. *-2147483648 :00 00 00 80(-2147483647减去1得到)
  62. ********同理可知道short型、long型情况************
  63. *****************************************************************/
  65. return 0;
  66. } 
//By Richard
#include <stdio.h>
#include <math.h>

int main()
{
	int i1=0;
	int i2=1;
	int i3=-1;
	int i4=127;
	int i5=-127;
	int i6=128;
	int i7=-128;
	int i8=255;
	int i9=-255;
	int i10=256;
	int i11=-256;
	int i12=(int)pow(2.0,16)-1;//65535
	int i13=-(int)pow(2.0,16)+1;//-65535
	int i14=(int)pow(2.0,16);//65536
	int i15=-(int)pow(2.0,16);//-65536
	int i16=(int)pow(2.0,24)-1;//16777215
	int i17=-(int)pow(2.0,24)+1;//-16777215
	int i18=(int)pow(2.0,24);//16777216
	int i19=-(int)pow(2.0,24);//-16777216
	int i20=(int)pow(2.0,31)-1;//2147483647，最大值
	int i21=-(int)pow(2.0,31)+1;//-2147483647
	int i22=(int)pow(2.0,31);//超出范围，溢出，从最小值-2147483648循环
	int i23=-(int)pow(2.0,31);//-2147483648，最小值

	/***************************************************************
	*	在return 0上打上断点，F5开始调试，Alt+6查看内存
	*	要想查看哪个变量在内存中的存储情况，在地址栏输入&+变量名，比如说：&i1
	*	int型占4个字节，注意：内存中的存储顺序和实际的字节表示刚好相反
	*	比如说：10，在内存中表示为0a 00 00 00，而实际中表示为00 00 00 0a
	*	负数的二进制数：对应的正数的二进制数每一位取反，再加1
	*	int型最高位表示符号：1，表示负数，0表示正数（内存中的最后一个字节的第一位表示）
	*	具体来分析：
	*	       0 :00 00 00 00
	*	       1 :01 00 00 00
	*	      -1 :ff ff ff ff(00 00 00 01->ff ff ff fe->ff ff ff ff)
	*	     127 :7f 00 00 00
	*	    -127 :81 ff ff ff(00 00 00 7f->ff ff ff 80->ff ff ff 81)
	*	     128 :80 00 00 00
	*	    -128 :80 ff ff ff(00 00 00 80->ff ff ff 7f->ff ff ff 80)
	*	     255 :ff 00 00 00
	*       -255 :01 ff ff ff(00 00 00 ff->ff ff ff 00->ff ff ff 01)
	*	     256 :00 01 00 00
	*       -256 :00 ff ff ff(00 00 01 00->ff ff fe ff->ff ff ff 00)
	*      65535 :ff ff 00 00
	*     -65535 :01 00 ff ff(00 00 ff ff->ff ff 00 00->ff ff 00 01)
	*      65536 :00 00 01 00
	*     -65536 :00 00 ff ff(00 01 00 00->ff fe ff ff->ff ff 00 00)
	*   16777215 :ff ff ff 00
	*  -16777215 :01 00 00 ff(00 ff ff ff->ff 00 00 00->ff 00 00 01)
	*   16777216 :00 00 00 01
	*  -16777216 :00 00 00 ff(01 00 00 00->fe ff ff ff->ff 00 00 00)
	* 2147483647 :ff ff ff 7f
	*-2147483647 :01 00 00 80(7f ff ff ff->80 00 00 00->80 00 00 01)
	* 2147483648 :01 00 00 00 00(超出范围)
	*-2147483648 :00 00 00 80(-2147483647减去1得到)	
	********同理可知道short型、long型情况************
	*****************************************************************/

	return 0;
}


二、unsigned int型存储情况
[cpp] view plain copy print ?
  1. //By Richard
  2. #include <stdio.h>
  3. #include <math.h>
  5. int main()
  6. {
  7. unsigned int i1=0;
  8. unsigned int i2=1;
  9. unsigned int i3=255;
  10. unsigned int i4=256;
  11. unsigned int i5=65535;
  12. unsigned int i6=65536;
  13. unsigned int i7=(unsigned int)pow(2.0,24)-1;
  14. unsigned int i8=(unsigned int)pow(2.0,24);//16777216
  15. unsigned int i9=(unsigned int)pow(2.0,31)-1;
  16. unsigned int i10=(unsigned int)pow(2.0,31);//2147483648
  17. unsigned int i11=(unsigned int)pow(2.0,32)-1;//4294967295
  18. unsigned int i12=(unsigned int)pow(2.0,32);//超出范围，这里为0
  21. /***********************************************************************
  22. * unsigned int占4个字节，只能表示正数
  23. * 最大为(int)pow(2.0,32)-1=4294967295
  24. * 当超出最大值后，从0开始往后循环
  25. * 0 :00 00 00 00
  26. * 1 :01 00 00 00
  27. * 255 :ff 00 00 00
  28. * 256 :00 01 00 00
  29. * 65535 :ff ff 00 00
  30. * 65536 :00 00 01 00
  31. * 16777215 :ff ff ff 00
  32. * 16777216 :00 00 00 01
  33. * 2147483647:ff ff ff 7f(01111111 11111111 11111111 11111111)
  34. * 2147483648:00 00 00 80(1000000 00000000 00000000 00000000)
  35. * 4294967295:ff ff ff ff
  36. ************************************************************************/
  37. return 0;
  38. } 
//By Richard
#include <stdio.h>
#include <math.h>

int main()
{
	unsigned int i1=0;
	unsigned int i2=1;
	unsigned int i3=255;
	unsigned int i4=256;
	unsigned int i5=65535;
	unsigned int i6=65536;
	unsigned int i7=(unsigned int)pow(2.0,24)-1;
	unsigned int i8=(unsigned int)pow(2.0,24);//16777216
	unsigned int i9=(unsigned int)pow(2.0,31)-1;
	unsigned int i10=(unsigned int)pow(2.0,31);//2147483648
	unsigned int i11=(unsigned int)pow(2.0,32)-1;//4294967295
	unsigned int i12=(unsigned int)pow(2.0,32);//超出范围，这里为0


	/***********************************************************************
	*	unsigned  int占4个字节，只能表示正数
	*	最大为(int)pow(2.0,32)-1=4294967295
	*	当超出最大值后，从0开始往后循环
	*	  0       :00 00 00 00
	*	  1       :01 00 00 00
	*	  255     :ff 00 00 00
	*	  256     :00 01 00 00
	*	  65535   :ff ff 00 00
	*	  65536   :00 00 01 00
	*	16777215  :ff ff ff 00
	*	16777216  :00 00 00 01
	*	2147483647:ff ff ff 7f(01111111 11111111 11111111 11111111)
	*	2147483648:00 00 00 80(1000000 00000000 00000000 00000000)
	*	4294967295:ff ff ff ff
	************************************************************************/
	return 0;
}

三、char和unsigned char型讨论

[cpp] view plain copy print ?
  1. //By Richard
  2. #include <stdio.h>
  4. int main()
  5. {
  6. char c0=0;//00
  7. char c1=1;//01
  8. char c2=-1;//ff(01->fe->ff)
  9. char c3='A';//41
  10. char c4=65;//41
  11. char c5=127;//7f
  12. char c6=-127;//81(7f->80->81)
  13. char c7=128;//超出范围
  14. char c8=-128;//80
  16. unsigned char uc0=0;
  17. unsigned char uc1='A';//41
  18. unsigned char uc2=65;//41
  19. unsigned char uc3=127;//7f
  20. unsigned char uc4=128;//80
  21. unsigned char uc5=255;//ff
  22. unsigned char uc6=256;//超出范围，从0开始循环
  24. /********************************************
  25. * char范围为-128到127，表示的ASCII码有限
  26. * unsigned char范围为0到255，能表示所有的ASCII码
  27. * 在牵扯到读取文件或写文件，都定义成unsigned char型
  28. *********************************************/
  29. return 0;
  30. } 
//By Richard
#include <stdio.h>

int main()
{
	char c0=0;//00
	char c1=1;//01
	char c2=-1;//ff(01->fe->ff)
	char c3='A';//41	
	char c4=65;//41
	char c5=127;//7f
	char c6=-127;//81(7f->80->81)
	char c7=128;//超出范围
	char c8=-128;//80

	unsigned char uc0=0;
	unsigned char uc1='A';//41
	unsigned char uc2=65;//41
	unsigned char uc3=127;//7f
	unsigned char uc4=128;//80
	unsigned char uc5=255;//ff
	unsigned char uc6=256;//超出范围，从0开始循环
	
	/********************************************
	* char范围为-128到127，表示的ASCII码有限
	* unsigned char范围为0到255，能表示所有的ASCII码
	* 在牵扯到读取文件或写文件，都定义成unsigned char型
	*********************************************/
	return 0;
}


四、float型讨论

[cpp] view plain copy print ?
  1. //By Richard
  2. #include <stdio.h>
  4. int main()
  5. {
  6. //float占4个字节
  7. float d0=0;
  8. float d1=1;
  9. float d2=-1;
  10. float d3=1.5;
  11. float d4=-1.5;
  12. float d5=11.9;
  13. float d6=0.2356;
  15. /*********************************************************************
  16. * 0:00 00 00 00
  17. * 1:00 00 80 3f
  18. * -1:00 00 80 bf
  19. * 1.5:00 00 c0 3f
  20. *-1.5:00 00 c0 bf
  21. *详细过程：
  22. *============================================================
  23. *4字节： 31 30 29-23（7位） 22-0（23位）
  24. * 表示：实数符号位 指数符号位 指数位 有效数位
  25. *=============================================================
  26. * 将一个float型转化为内存存储格式的步骤为：
  27. * 1，先将这个实数的绝对值化为二进制格式
  28. * 2，将这个二进制格式实数的小数点左移或右移n位，直至小数点移动到第一个
  29. * 有效数字的右边
  30. * 3，从小数点右边第一位开始数出23位，放入第22位到第0位
  31. * 4，如果实数是正的，则在第31位放入“0”，否则放入“1”
  32. * 5，如果n是左移得到的，说明指数是正的，第30位放入“1”。如果是右移得到的或
  33. * n=0，则第30位为“0”
  34. * 6，如果n是左移得到的，则将n减去1后化为二进制，并在左边加0补足7位，放入
  35. * 第29到第23位。如果n是右移得到的或n=0，则将n化为二进制后在左边加0补足7位
  36. * 再各位取反，之后放入第29到第23位
  37. *=============================================================
  38. * 举例说明： 11.9的内存存储格式
  39. * (1) 将11.9化为二进制后大约是" 1011. 1110011001100110011001100..."。
  40. * (2) 将小数点左移三位到第一个有效位右侧： "1. 011 11100110011001100110 "。
  41. * 保证有效位数24位，右侧多余的截取（误差在这里产生了 ）。
  42. * (3) 这已经有了二十四位有效数字，将最左边一位“1”去掉，得到
  43. * “ 011 11100110011001100110 ”共23bit。将它放入float存储结构的第22到第0位。
  44. * (4) 因为11.9是正数，因此在第31位实数符号位放入“0”。
  45. * (5) 由于我们把小数点左移，因此在第30位指数符号位放入“1”。
  46. * (6) 因为我们是把小数点左移3位，因此将3减去1得2，化为二进制，并补足7位得到0000010，
  47. * 放入第29到第23位。
  48. * 最后表示11.9为：|0 1 [00|0001|0] [011 |1110|0110|0110|0110|0110]
  49. * 对应的16进制为： 4 1 3 e 6 6 6 6
  50. * 内存存储为：66 66 3e 41
  51. *================================================================
  52. * 再举一个例子：0.2356的内存存储格式
  53. *（1）将0.2356化为二进制后大约是0.00111100010100000100100000。
  54. *（2）将小数点右移三位得到1.11100010100000100100000。
  55. *（3）从小数点右边数出二十三位有效数字，即11100010100000100100000放
  56. * 入第22到第0位。
  57. *（4）由于0.2356是正的，所以在第31位放入“0”。
  58. *（5）由于我们把小数点右移了，所以在第30位放入“0”。
  59. *（6）因为小数点被右移了3位，所以将3化为二进制，在左边补“0”补足七
  60. * 位，得到0000011，各位取反，得到1111100，放入第29到第23位。
  61. * 最后表示0.2356：0 0 [11|1110|0] [111|0001|0100|0001|0010|0000]
  62. * 对应的16进制为： 3 e 7 1 4 1 2 0
  63. * 内存存储为：20 41 71 3e
  64. ************************************************************************/
  65. return 0;
  66. } 
//By Richard
#include <stdio.h>

int main()
{
	//float占4个字节
	float d0=0;
	float d1=1;
	float d2=-1;
	float d3=1.5;
	float d4=-1.5;
	float d5=11.9;
	float d6=0.2356;

	/*********************************************************************
	*   0:00 00 00 00
	*   1:00 00 80 3f
	*  -1:00 00 80 bf
	* 1.5:00 00 c0 3f
	*-1.5:00 00 c0 bf
	*详细过程：
	*============================================================
	*4字节：    31          30      29-23（7位） 22-0（23位）
	* 表示：实数符号位  指数符号位   指数位        有效数位
	*=============================================================
	* 将一个float型转化为内存存储格式的步骤为：
	* 1，先将这个实数的绝对值化为二进制格式
	* 2，将这个二进制格式实数的小数点左移或右移n位，直至小数点移动到第一个
	*    有效数字的右边
	* 3，从小数点右边第一位开始数出23位，放入第22位到第0位
	* 4，如果实数是正的，则在第31位放入“0”，否则放入“1”
	* 5，如果n是左移得到的，说明指数是正的，第30位放入“1”。如果是右移得到的或
	*    n=0，则第30位为“0”
	* 6，如果n是左移得到的，则将n减去1后化为二进制，并在左边加0补足7位，放入
	*    第29到第23位。如果n是右移得到的或n=0，则将n化为二进制后在左边加0补足7位
	*    再各位取反，之后放入第29到第23位
	*=============================================================
	* 举例说明： 11.9的内存存储格式 
	* (1) 将11.9化为二进制后大约是" 1011. 1110011001100110011001100..."。 
	* (2) 将小数点左移三位到第一个有效位右侧： "1. 011 11100110011001100110 "。 
	*     保证有效位数24位，右侧多余的截取（误差在这里产生了  ）。 
	* (3) 这已经有了二十四位有效数字，将最左边一位“1”去掉，得到
	*     “ 011 11100110011001100110 ”共23bit。将它放入float存储结构的第22到第0位。 
	* (4) 因为11.9是正数，因此在第31位实数符号位放入“0”。 
	* (5) 由于我们把小数点左移，因此在第30位指数符号位放入“1”。 
	* (6) 因为我们是把小数点左移3位，因此将3减去1得2，化为二进制，并补足7位得到0000010，
	*     放入第29到第23位。 
	* 最后表示11.9为：|0  1  [00|0001|0] [011 |1110|0110|0110|0110|0110]
	* 对应的16进制为：   4       1     3      e    6    6   6    6
	* 内存存储为：66 66 3e 41
	*================================================================
	* 再举一个例子：0.2356的内存存储格式
	*（1）将0.2356化为二进制后大约是0.00111100010100000100100000。 
	*（2）将小数点右移三位得到1.11100010100000100100000。 
	*（3）从小数点右边数出二十三位有效数字，即11100010100000100100000放
	*     入第22到第0位。 
	*（4）由于0.2356是正的，所以在第31位放入“0”。 
	*（5）由于我们把小数点右移了，所以在第30位放入“0”。 
	*（6）因为小数点被右移了3位，所以将3化为二进制，在左边补“0”补足七
	*     位，得到0000011，各位取反，得到1111100，放入第29到第23位。 
	*  最后表示0.2356：0 0 [11|1110|0] [111|0001|0100|0001|0010|0000]
	*  对应的16进制为：   3      e     7      1    4    1    2    0
	*  内存存储为：20 41 71 3e
	************************************************************************/
	return 0;
}


五、double型讨论

My_Dream_Life
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
全局变量与局部变量在内存中的区别详细解析
09-04
全局变量与局部变量是编程语言中两种常见的变量类型，它们在内存中有着不同的分配和管理方式，这在理解和优化程序性能时非常重要。 首先，我们来理解一下程序内存的分配： 1. 栈区（stack）：这是由编译器自动分配...
C语言程序内存的各种变量存储区域
xing__Q的博客
12-03 3113
预备知识1.内存空间2.分配方式动or静态分配堆栈全局/静态存储区常量储存区测试三级目录 预备知识 1.内存空间 C语言在内存中一共分为如下几个区域，分别是： 内存栈区： 存放局部变量名； 内存堆区： 存放new或者malloc出来的对象； 常数区： 存放局部变量或者全局变量的值； 静态区： 用于存放全局变量或者静态变量； 代码区：存放函数体的二进制代码。 2.分配方式 静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。 在栈上创.
C语言之从内存角度理解不同类型的变量
weixin_33748818的博客
11-06 119
我们都知道在C语言中不同类型的变量在内存中的存放位置不同的，从内存角度上讲，不同内存块中存放的代码或者变量其属性（主要是作用域、生命周期、链接属性）是不同的。首先我们介绍一下作用域、生命周期已经链接属性的概念1：作用域作用域也就是指变量其作用的范围（1）局部变量为代码块作用域（也就是说局部变量的作用范围是{ }）（2）函数和全局变量是文件作用域，进一步讲其作...
C语言变量内存分布
其疾如风 其徐如林 侵略如火 不动如山
05-21 3044
1.   首先，看一下内存中的分区情况： ①堆区 ： 一般由程序员手动分配释放 ， 若程序员不释放，程序结束时将由OS回收。 ②栈区：由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。  ③全局区：全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域(BSS)。  程序结束
c语言 变量的存储类别以及对应的内存分配？
weixin_34149796的博客
11-21 218
<h4><strong>1.变量的存储类别</strong></h4>从变量值存在的角度来分，可以分为静态存储方式和动态存储方式。所谓静态存储方式指在程序运行期间由系统分配固定的存储空间的方式（<strong>程序开始执行时分配，在程序完毕时释放，在程序过程中它们占据国定的存储单元，而不是动态分配和释放</strong>）。而...
c语言中 变量的内存分布,C/C++变量在内存中的分布
weixin_39722759的博客
05-18 249
C/C++变量在内存中的分布变量在内存地址的分布为：堆-栈-代码区-全局静态-常量数据。下面是小编为大家整理的C/C++变量在内存中的分布，欢迎参考~C/C++变量在内存中的分布在笔试时经常考到，虽然简单，但也容易忘记，因此在这作个总结，以加深印象。先写一个测试程序：代码如下:#include#includeint g_i = 100;int g_j = 200;int g_k, g_h;int ...
c/c++变量在内存中的分配
08-20
自动存储类别的变量存储在栈中，静态存储类别的变量存储在静态存储区中，寄存器存储类别的变量存储在寄存器中，外部存储类别的变量存储在数据段中。 在C/C++中，还有一个重要的概念是作用域和生命周期。作用域是指...
c代码-13.变量在内存中存储
07-14
在C语言中，变量是程序的基本构建块，用于存储数据。理解变量在内存中的存储方式对于深入学习C语言和计算机系统...在实际编程中，理解变量的内存存储不仅有助于避免内存泄漏，还能帮助我们设计更高效的数据结构和算法。
嵌入式开发第八日(linux内存起源，内存的分布)
Reasonss的博客
07-19 611
内存的起源： 其实我们谈到的内存以及内存地址，指的都是“虚拟内存”和“虚拟内存地址”，他是linux操作系统为了更好的使用内存，而将实际物理内存进行映射，对应用程序屏蔽了物理细节，有利于简化程序的编写和系统的管理。 假设正在使用的物理内存只有1GB，而当前系统运行了三个程序，那么系统会将PM中的某些物理内存，映射为三个大小均为4GB的虚拟内存，让每个进程都以为自己有了完整的空间，这样极大地方便
整形数据在内存中的存储
weixin_45423515的博客
03-18 449
前言： 在计算机底层，只能识别1和0，但是如果只用0和1来写代码，会发现非常不方便，所以就诞生出的像int ,char ,long ,short等一系列的整形数据，来减少工作量，提高写代码效率，但是其在内存中的存储依然是0和1。 一、进制 2进制： 0~1 (逢二进一，这里要知道二进制只有0~1，如果出现了2说明不是用的二进制计数,以下同理) 8进制： 0~7 10进制：0~9 16进制：0~9 a b ......
C语言不同变量内存区域（堆，栈，代码区，全局区，BSS段）
10-06
C语言不同变量内存区域（堆，栈，代码区，全局区，BSS段）
C/C++程序内存的各种变量存储区域和各个区域详解
热门推荐
jirryzhang的博客
03-11 7万+
C语言在内存中一共分为如下几个区域，分别是：1. 内存栈区： 存放局部变量名；2. 内存堆区： 存放new或者malloc出来的对象；3. 常数区： 存放局部变量或者全局变量的值；4. 静态区： 用于存放全局变量或者静态变量；5. 代码区：二进制代码。知道如上一些内存分配机制，有助于我们理解指针的概念。C/C++不提供垃圾回收机制，因此需要对堆中的数据进行及时销毁，防止内存泄漏，使用free和de...
程序设计中各变量在内存中的分布
MySmartLife的博客
01-09 717
程序设计中，目标文件通常有三种形式： （1）可重定位的目标文件：包含二进制代码和数据，与其他可重定位目标文件合并后创建一个可执行目标文件。 （）（2）可执行的目标文件：包含二进制代码、数据，其形式可被直接拷贝到存储器中后执行。 （）（3）共享目标文件：一种特殊的可重定位目标文件，即通常所说的动（静）态链接库。
C 语言变量在内存中的分布情况
andy 的专栏
03-16 1222
关于内存的基础知识： 一个由C/C++编译的程序占用的内存分为以下几个部分：     1. 栈区：由编译器自动分配释放，存放函数的参数值、返回值和局部变量，在程序运行过程中实时分配和释放，栈区由操作系统自动管理，无须程序员手动管理。      2.堆区：堆是由malloc()函数分配的内存块，使用free()函数来释放内存，堆的申请释放工作由程序员控制，容易产生内存泄漏。     
面试经常问的C语言变量在内存中的分布（VC6.0）
思緒凌亂
10-06 2431
C/C++变量在内存中的分布在笔试时经常考到，虽然简单，但也容易忘记，因此在这作个总结，以加深印象。 一： #include #include int g_i = 100; int g_j = 200; int g_k, g_h; int main() { const int MAXN = 100; int *p = (int*)malloc(MAXN * sizeof(int));
c语言程序中用来存储变量的三种内存
weixin_39330853的博客
08-19 1854
c语言程序中变量存储在三种类型的内存中：栈内存、堆内存、数据段内存 一.栈内存，用来存储程序中各个函数的局部变量（动态局部变量），特点： 1.不用程序员手动申请和释放内存，由编译系统自动分配与释放； 2.内存是脏的，内存中内容是随机的，如果在定义局部变量时未显式初始化该变量，则变量的值是不确定的； 3.栈内存的生长模式是向下生长的（高地址向低地址），且变量存储与取出时遵循先进后出的原则； ...
c语言中不同类型的变量在内存地址中相差多少
最新发布
07-09
这是由于不同类型的变量在内存中所需的存储空间是根据其数据类型决定的。 下面是一些常见的C语言数据类型及其在内存中所占用的字节数： - char类型：通常占用1个字节。 - int类型：通常占用4个字节。 - float类型...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值