用C学习内存

标签: c语言 内存 编译
3922人阅读 评论(0) 收藏 举报
分类:

内存分段

32位操作系统,地址总线是32位,寻址空间就是32位,内存编号只能编到32个二进制位,故其只能使用4G内存。

空间:

232byte=210×210×210×22byte=1024×1024×1024×4byte=1024×1024×4K=1024×4M=4G

1 byte = 8 bit, 32bit对应4字节。
64位操作系统对应的内存就是 264byte

内存分段 用途
系统内存 操作系统的内核使用
记录函数执行,存储函数中的变量
可分配内存 给应用程序动态分配
malloc获取的内存
数据段 存储全局变量和常量
代码段 存储编译后的二进制数据

上表排列是有规律的,代码段在内存的低位段0x0,内核位于高位段0xffff..f
变量代表着某块内存存储着特定的数据。

栈内变量的内存地址:

#include <stdio.h>
#include <stdlib.h>
typedef unsigned long long UINT64;
int main(void) {
    int a,b;
    printf("&a: %llu, &b: %llu\n",(UINT64)&a,(UINT64)&b);
    int *p = &a;
    int *p1 = &a;
    int c;
    printf("&c: %llu\n",(UINT64)&c);
    return EXIT_SUCCESS;
}

使用gdb()调试:

$ gcc -g -o exe memory_learn.c 
$ gdb exe
(gdb) start
Temporary breakpoint 1, main () at memory_learn.c:14
14  int main(void) {
(gdb) n
16      printf("&a: %llu, &b: %llu\n",(UINT64)&a,(UINT64)&b);
(gdb) p &a
$1 = (int *) 0x7fffffffdc9c
(gdb) p &b
$2 = (int *) 0x7fffffffdca0
(gdb) n
&a: 140737488346268, &b: 140737488346272
17      int *p = &a;
(gdb) n
18      int *p1 = &a;
(gdb) p &p
$3 = (int **) 0x7fffffffdca8
(gdb) n
20      printf("&c: %llu\n",(UINT64)&c);
(gdb) p &p1
$4 = (int **) 0x7fffffffdcb0
(gdb) n
&c: 140737488346276
21      return EXIT_SUCCESS;

从上面的信息可以发现,先后声明的a,b在内存中是连续的,sizeof(int)等于4,正好是地址差,同时指针p指向a,且p本身有自己的地址,是0x7fffffffdca8. 和&b相差4的是&c,不是&p,这是编译器的优化处理。编译器会将同一类型的变量的声明放在一起。这种优化使得程序的效率更高。
在32位操作系统中,指针需要4个字节存储,在64位操作系统中就需要8个字节来存储了。本系统的信息:

$ uname -a
Linux ubuntu 4.2.0-42-generic #49-Ubuntu SMP Tue Jun 28 21:26:26 UTC 2016 x86_64 x86_64 x86_64 GNU/Linux

所以&p1和&p的差是8
同时,我们发现上面的所有的地址都和0xff..f很相近,所以main()是放在栈内存中的。

再看一个栈和全局变量的例子:

/*
 ============================================================================
 Name        : memory_learn.c
 Author      : theArcticOcean
 Version     :
 Copyright   :
 Description : C, Ansi-style
 ============================================================================
 */

#include <stdio.h>
#include <stdlib.h>
int global;
int sum(int a,int b){
    return a+b;
}
int square(int a){
    return a*a;
}
int square_sum(int a,int b){
    int aa = square(a);
    int bb = square(b);
    int ans = sum(aa,bb);
    return ans;
}
int main(void) {
    int a,b;
    a=3;
    b=6;
    printf("square_sum is %d\n",square_sum(a,b));
    printf("global is %d\n",global);
    return EXIT_SUCCESS;
}
(gdb) start
Temporary breakpoint 1 at 0x4005a1: file memory_learn.c, line 28.
Starting program: /home/edemon/workspace/memory_learn/src/exe 

Temporary breakpoint 1, main () at memory_learn.c:28
28      a=3;
(gdb) n
29      b=6;
(gdb) n
30      printf("square_sum is %d\n",square_sum(a,b));
(gdb) s
square_sum (a=3, b=6) at memory_learn.c:21
21      int aa = square(a);
(gdb) s
square (a=3) at memory_learn.c:18
18      return a*a;
(gdb) bt
#0  square (a=3) at memory_learn.c:18
#1  0x0000000000400572 in square_sum (a=3, b=6) at memory_learn.c:21
#2  0x00000000004005be in main () at memory_learn.c:30
(gdb) n
19  }
(gdb) n
square_sum (a=3, b=6) at memory_learn.c:22
22      int bb = square(b);
(gdb) n
square_sum (a=3, b=6) at memory_learn.c:23
23      int ans = sum(aa,bb);
(gdb) s
sum (a=9, b=36) at memory_learn.c:15
15      return a+b;
(gdb) bt
#0  sum (a=9, b=36) at memory_learn.c:15
#1  0x0000000000400591 in square_sum (a=3, b=6) at memory_learn.c:23
#2  0x00000000004005be in main () at memory_learn.c:30
...
(gdb) p &global
$1 = (int *) 0x601044 <global>
(gdb) p &a
$2 = (int *) 0x7fffffffdcb8
(gdb) p sum
$3 = {int (int, int)} 0x400536 <sum>
(gdb) p &sum
$4 = (int (*)(int, int)) 0x400536 <sum>
(gdb) p main
$5 = {int (void)} 0x400599 <main>

bt命令让我们从函数的地址大小关系能看到函数调用关系,先被调用者地址越大, 那些函数是在代码段中。
函数中的变量保存在栈中,全局变量global保存在数据段中,所以&a明显比&global大。

数组的内存分配

多维数组的元素的内存地址是否是简单的线性分布?让我们测试看看。

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int a[3][5];
    int i,j;
    for(i=0;i<3;i++){
        for(j=0;j<5;j++){
            printf("%p ",&a[i][j]);
        }
        puts("");
    }
    return EXIT_SUCCESS;
}
/*
0x7fff35512b40 0x7fff35512b44 0x7fff35512b48 0x7fff35512b4c 0x7fff35512b50 
0x7fff35512b54 0x7fff35512b58 0x7fff35512b5c 0x7fff35512b60 0x7fff35512b64 
0x7fff35512b68 0x7fff35512b6c 0x7fff35512b70 0x7fff35512b74 0x7fff35512b78 
*/

恩,栈中数组地址分布是线性的。指针运算(指针偏移,地址移动)同样证明了这一点

指针偏移

/*
 ============================================================================
 Name        : array_mem.c
 Author      : theArcticOcean
 Version     :
 Copyright   :
 Description : C, Ansi-style
 ============================================================================
 */

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int a[3][5];
    int *p[3] = {NULL};
    int i,j;
    for(i=0;i<3;i++){
        p[i] = a[i];
    }
    for(i=0;i<3;i++){
        for(j=0;j<5;j++){
            printf("%9d ",a[i][j]);
        }
        puts("");
    }
    for(i=0;i<3;i++){
        for(j=0;j<5;j++){
            printf("%9d ",*p[i]);
            p[i]++;
        }
        puts("");
    }
    return EXIT_SUCCESS;
}
970839232     32559         0         0         1 
        0   4196237         0   4195584         0 
        0         0   4196160         0   4195584 
970839232     32559         0         0         1 
        0   4196237         0   4195584         0 
        0         0   4196160         0   4195584 

更加简单的指针偏移:

/*
 ============================================================================
 Name        : pointer.c
 Author      : theArcticOcean
 Version     :
 Copyright   :
 Description : C, Ansi-style
 ============================================================================
 */

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int a[21];
    int *p = a;
    int i;
    for(i=0;i<21;i++){
        a[i] = i;
    }
    printf("3的倍数:\n");
    p+=3;
    for(i=3;i<21;i+=3){
        printf("%d ",*p);
        p+=3;
    }
    return EXIT_SUCCESS;
}
/*
3的倍数:
3 6 9 12 15 18 
*/

使用gdb调试的结果,因为又一次运行,所以a[][]的内容会不同。

# a的内容
(gdb) p a   
$3 = {{-134253376, 32767, 0, 0, 1}, {0, 4196237, 0, 4195584, 0}, {0, 0, 
    4196160, 0, 4195584}}
#p的地址信息
(gdb) p p
$4 = {0x7fffffffdc80, 0x7fffffffdc94, 0x7fffffffdca8}
#打印0x7fffffffdc80后的5个值
(gdb) x/5d 0x7fffffffdc80
0x7fffffffdc80: -134253376  32767   0   0
0x7fffffffdc90: 1
#打印0x7fffffffdc80后的15个值,也即是所有的数组元素。
(gdb) x/15d 0x7fffffffdc80
0x7fffffffdc80: -134253376  32767   0   0
0x7fffffffdc90: 1   0   4196237 0
0x7fffffffdca0: 4195584 0   0   0
0x7fffffffdcb0: 4196160 0   4195584

看出来,地址相差16字节的区域存储了4个int (sizeof(int) = 4)。

那么堆中又是怎样的呢?

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int a[3][5];
    int *p[3] = {NULL};
    //p = (int *)malloc(sizeof(a));
    /* 当分配一个多维数组空间时,除了第一维外 ,其余各维都必须显式地指定为正常数. 编译器只能记住一维 */
    int i,j;
    for(i=0;i<3;i++){
        p[i] = (int *)malloc(sizeof(a[i]));
    }
    for(i=0;i<3;i++){
        for(j=0;j<5;j++){
            printf("%p ",&p[i][j]);
        }
        puts("");
    }
    return EXIT_SUCCESS;
}
0x1c57010 0x1c57014 0x1c57018 0x1c5701c 0x1c57020 
0x1c57030 0x1c57034 0x1c57038 0x1c5703c 0x1c57040 
0x1c57050 0x1c57054 0x1c57058 0x1c5705c 0x1c57060 

因为存在多次的malloc,所以内存几乎不会线性连续。不过,如果让p[0]指向分配好的二维数组的内存,然后进行指针偏移,可以做到连续:

int main(void) {
    int *p[3] = {NULL};
    /* 当分配一个多维数组空间时,除了第一维外 ,其余各维都必须显式地指定为正常数. 编译器只能记住一维 */
    int i,j;
    p[0] = (int *)malloc(sizeof(int)*15);
    for(i=1;i<3;i++){
        p[i] = p[i-1] + 5;
    }
    for(i=0;i<3;i++){
        for(j=0;j<5;j++){
            printf("%p ",&p[i][j]);
        }
        puts("");
    }
    return EXIT_SUCCESS;
}
0x81d010 0x81d014 0x81d018 0x81d01c 0x81d020 
0x81d024 0x81d028 0x81d02c 0x81d030 0x81d034 
0x81d038 0x81d03c 0x81d040 0x81d044 0x81d048 

字符数组与指针

int main(void) {
    char *p = "hello";
    return EXIT_SUCCESS;
}
(gdb) p p
$1 = 0x400594 "hello"
#查看数组的内容
(gdb) x/6c 0x400594
0x400594:   104 'h' 101 'e' 108 'l' 108 'l' 111 'o' 0 '\000'
#查看多余的内容
(gdb) x/8c 0x400594
0x400594:   104 'h' 101 'e' 108 'l' 108 'l' 111 'o' 0 '\000'    0 '\000' 0 '\000'

为什么不能给字符指针scanf()?

int main(void) {
    char *p ;
    scanf("%s",p);
    printf("%s\n",p);
    p = NULL;
    return EXIT_SUCCESS;
}

使用gdb一探究竟:

Temporary breakpoint 1, main () at pointer.c:16
16      scanf("%s",p);
(gdb) p p
$1 = 0x0
(gdb) p &p
$2 = (char **) 0x7fffffffdcc8

可以发现p本身是放在栈中的,不过其指向的地址是在代码段中(0x0),而代码段的内存是不能被我们写入的。

字节对齐

一个有趣的例子:

int main(void) {
    char s1[6] = "hello";
    char s2[10] = "world";
    scanf("%s",s1);
    printf("s1: %s, s2: %s\n",s1,s2);
    return EXIT_SUCCESS;
}
17      scanf("%s",s1);
(gdb) p &s1
$5 = (char (*)[6]) 0x7fffffffdca0
(gdb) p &s2
$6 = (char (*)[10]) 0x7fffffffdcb0
#字节对齐
(gdb) x/17c 0x7fffffffdca0
0x7fffffffdca0: 104 'h' 101 'e' 108 'l' 108 'l' 111 'o' 0 '\000'    0 '\000'0 '\000'
0x7fffffffdca8: 0 '\000'    0 '\000'    0 '\000'    0 '\000'    0 '\000'    0 '\000'    0 '\000'    0 '\000'
0x7fffffffdcb0: 119 'w'
#连续存储,越界存储
(gdb) n
0123456789abcdefgh
18      printf("s1: %s, s2: %s\n",s1,s2);
(gdb) n
s1: 0123456789abcdefgh, s2: gh

经典的字节对齐问题,这篇博客不错:
http://blog.csdn.net/andy572633/article/details/7213465

查看评论

C语言再学习 -- 再论内存管理

之前有总结过内存管理,参看:C语言再学习 -- 内存管理 但现在看来,缺少示例。从新再写一篇文章,着重介绍常见内存错误、跨函数使用存储区。开始吧,再论内存管理!!...
  • qq_29350001
  • qq_29350001
  • 2017-01-22 15:46:36
  • 965

C语言再学习 -- 内存管理

的风
  • qq_29350001
  • qq_29350001
  • 2016-11-07 15:03:09
  • 879

【c和指针学习笔记】深入理解字符串常量

思考下列表达式代表什么意思??? 1:“zyh_helen”+ 1 2: *“zyh_helen” 3:“zyh_helen”[2]。 如果你觉得上述表达式不了解,甚至认为他们看上去像垃圾的话...
  • ZongYinHu
  • ZongYinHu
  • 2015-09-29 13:30:50
  • 717

C语言(对内存的理解)

很多人学习C语言总是不得要领总是不入门,明明听了很多课,明明买了很多书,却无法独自写出规范像样的代码,要领在哪里?门在哪里?   拓展: 学习编程要踏入的第一个门槛是对内存的深刻理解...
  • vincent040
  • vincent040
  • 2016-03-27 16:16:02
  • 728

【C解析之三】C语言的内存分配

和你谈谈C系列之三运行时内存分配      前言:这里展示C与计算机的思考方式,从C语言设计者的角度看C。          C语言的内存是让很多初学C编程的同学感到混乱与头疼的问题,受此困扰很难对...
  • Jiangweihll
  • Jiangweihll
  • 2014-03-12 14:20:35
  • 9297

陈正冲老师讲c语言之内存的申请malloc() 和释放free()

1.如何使用 malloc 函数   不要莫名其妙,其实上面这段小小的对话,就是malloc的使用过程。malloc是一个函数,专门用来从堆上分配内存。使用malloc函数需要几个要求: ...
  • u010154760
  • u010154760
  • 2015-04-07 15:33:12
  • 2995

c模拟内存管理

// 内存管理 #include #include const int SIZE=100; const int MAX=65; //最大进程数 const int DEBUG=0;//调试开...
  • eric491179912
  • eric491179912
  • 2011-09-25 15:55:02
  • 1124

一分钟了解“c语言开辟内存函数malloc”

int *pt; pt = (int*)malloc(sizeof(int) * 128);
  • yes1989yes
  • yes1989yes
  • 2017-07-18 22:32:50
  • 372

用C语言实现将一个文件读入内存中

转载自 phps 用C语言实现将一个文件读入内存中 /**  * 用C语言实现将文件读入内存中  * 作者:学无止境  * QQ:339534039  * ...
  • A_ZI_MAO
  • A_ZI_MAO
  • 2017-08-31 10:15:02
  • 856

C/C++学习之二进制、八进制、十进制和十六进制的总结

在实际应用当中,二进制、十进制和十六进制用得比较多,八进制基本上没怎么用了解一下就可以了。 八进制数要在前面加0 十六进制数要在前面加0x 十进制数是逢十进一的,所以十进制数的每一位只能取0~9其...
  • u014044821
  • u014044821
  • 2015-05-11 23:21:33
  • 621
    个人资料
    持之以恒
    等级:
    访问量: 37万+
    积分: 9440
    排名: 2419
    我的链接
    最新评论