day01

1 malloc怎么分配空间

malloc与new的关系

　　

2 linux对内存的结构描述

a）/proc/${pid}/ 存放进程运行时候所有的信息。程序一结束，该目录就删掉了。

b） 任何一个程序的内存空间其实分成4个基本部分。

i.代码区

ii.全局栈区

iii.堆

iv. 局部栈

小实验： 运行一个只包含while（1）；的程序，然后另起一个终端，cd /proc下面的对应进程的pid目录，cat maps，查看到运行进程的内存空间分配情况。

进程查看： ps aue

c） 理解程序的变量与内存空间的关系

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int add(int a, int b)
{
return a+b;
}
int a1 = 1;
static int a2 = 2;
const int a3 = 3;
main()
{
int b1 = 4;
static b2 = 5;
const b3 = 6;

int *p1 = malloc(4);

printf("a1:%p\n", &a1);
printf("a2:%p\n", &a2);
printf("a3:%p\n", &a3);
printf("b1:%p\n", &b1);
printf("b2:%p\n", &b2);
printf("b3:%p\n", &b3);
printf("p1:%p\n", p1);
printf("main:%p\n", main);
printf("add:%p\n", add);

printf("%d\n", getpid());
while(1);
}

把打印结果与/proc下对应目录中的maps文件比较。

（代码区一般是ox8048000开头的区域。 ）

a3全局常量在代码区。

b3局部常量放在局部栈区。

a1， a2， b2 则是放在全局栈区。

main， add 在代码区。

b1， b3在局部栈区。

p1 在堆区

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

main()
{
int a1 = 10;
int a2 = 20;
int a3 = 30;

int *p1 = malloc(4);
int *p2 = malloc(4);
int *p3 = malloc(4);

printf("%p\n", &a1);
printf("%p\n", &a2);
printf("%p\n", &a3);
printf("%p\n", p1);
printf("%p\n", p2);
printf("%p\n", p3);
printf("%p\n", &a1);
printf("%p\n", &a1);
printf("%p\n", &a1);

printf("%d\n", getpid());
while(1);
}

运行结果如下：



可以看到，a1， a2， a3的地址降序排列，相差4个字节。（栈 分配内存是直接压到栈顶）

p1， p2， p3的地址升序排列，相差16个字节。（堆）

小结：

1）内存分四个区。

2）各种变量对应存放区。

3）堆栈是一种管理内存的数据结构。

查看程序的内存地址。

回到问题1.

#include <stdio.h>

#include <stdlib.h>

int main()
{
int *p1 = malloc(4);
int *p2 = malloc(4);
int *p3 = malloc(4);

*p1 = 1;
*(p1+1) = 2;
*(p1+2) = 3;
*(p1+3) = 4;
*(p1+4) = 5;
*(p1+5) = 6;
*(p1+6) = 7;
*(p1+7) = 8;
*(p1+8) = 9;

printf("%d\n", *p2);
return 0;
}

运行结果是5.

如果在程序中加一句话后：

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

int main()
{
int *p1 = malloc(4);
int *p2 = malloc(4);
int *p3 = <
4000
span class="hljs-built_in">malloc(4);

*p1 = 1;
*(p1+1) = 2;
*(p1+2) = 3;
*(p1+3) = 4;
*(p1+4) = 5;
*(p1+5) = 6;
*(p1+6) = 7;
*(p1+7) = 8;
*(p1+8) = 9;

free(p1);    //比上面的程序多了这句话
printf("%d\n", *p2);
return 0;
}

则会发生错误。

解释：

p1指向int型，应该只占用4个字节。可是实际上却占了16个字节，因为P1其实是链表里的一个节点，多的12个字节其实是保存的一些指向下一个节点，或者别的一些信息。

我们在用(p1+1) = 2; (p1+2) = 3; *(p1+3) = 4;破坏这些信息的时候，不会报错，但是在使用这个节点（free（p））时，则会报错了。

3 理解malloc的工作原理

malloc使用一个数据结构（链表）来维护分配的空间。链表的构成：分配的空间、上一个空间的地址、下一个空间的地址、以及本空间的信息等。对malloc分配的空间不要越界访问，因为容易破坏后台的链表维护结构，导致malloc/free/calloc/realloc不正常工作。

4 C++的new与malloc的关系

小实验：

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

int main()
{
int *p1 = (int*)malloc(4);
int *p2 = new int;
int *p3 = (int *)malloc(4);
int *p4 = new int;
int *p5 = new int;
int *p6 = new int;

printf("%p\n", p1);
printf("%p\n", p2);
printf("%p\n", p3);
printf("%p\n", p4);
printf("%p\n", p5);
printf("%p\n", p6);
return 0;
}

运行结果：



结论：

new的实现使用的是malloc来实现的。

区别：

new使用malloc后，还要初始化空间。基本类型，直接初始化成默认值。 UDT类型调用指定的构造器

推论：

delete也是调用free实现。

区别：

delete会调用指定的析构器，然后再调用free（）。

new与new[]的区别：

new只调用一个构造器初始化。new[]循环对每个区域调用构造器。

delete与delete[]的区别：

delete只调用一次析构函数，而delete则把数组中的每个对象的析构函数都调用一遍。

malloc new

realloc new() //定位分配

calloc new[]

free delete

5 函数调用栈空间分配与释放

5.1 总结：

函数执行的时候有自己的临时栈。（C++中的成员函数有对象栈空间和函数栈空间两个空间）

函数的参数就在临时栈中。如果函数传递实参，则用来初始化临时参数变量。

通过寄存器返回值（使用返回值返回数据）

通过参数返回值（参数必须是指针。指针指向的区域必须事先分配）

如果参数返回指针，参数就是双指针。

5.2 __stdcall, __cdecl __fastcall的问题（了解，应付面试即可）

#include <stdio.h>
int _attribute_((stdcall)) add(int *a, int *b)
{
return *a+*b;
}

int main()
{
int a1 = 20;
int b2 = 30;
int r = add(&a, &b);

printf("%d\n", r);
}

这三个属性决定函数参数压栈顺序。都是从右到左。

决定函数栈清空的方式。是调用者清空还是被调用者清空

决定了函数的名字转换方式。（编译的时候，会把函数重新命名。）

6 far near huge指针的问题

（linux中不考虑这个问题。window中属于遗留问题。windows编程统一采用far指针）

　　　　near 16

　　　　far 32

　　　　huge 综合

Note: C与C++明显的不同表现在 引用, 模板, 异常以及面向对象

函数参数传值和传指针其实是一样的,只是一个是把值拷贝过去,一个是把地址拷贝过去。

7.虚拟内存

小实验：写一个程序，定义一个整型指针，赋值为999，打印出它的地址，同时while（1）让它一直运行着。再写一个程序，定义一个整形指针，直接指向刚才打印出来的地址，然后打印这个指针指向的整数，为打印出999吗？ （不会，段错误）

问题：

为什么一个程序不能访问另外一个程序的地址指向的空间？

理解：

每个程序的开始地址一般都是0x80084000。

由1可以看出程序中使用的地址不是物理地址，而是逻辑地址（虚拟内存）。

逻辑地址仅仅是个编号，使用int 4字节整数表示。（4字节所能表示的最大整数是2的32次方=4294967296=4G）。

所以每个程序提供了4G的访问能力

问题：

逻辑地址和物理地址怎么关联？（内存映射）

背景：

虚拟内存的提出：禁止用户直接访问物理存储地址。有助于系统的稳定。

结论：

虚拟地址与物理地址在映射的时候有一个基本单位4k（16进制的1000，称为内存页）。

段错误：无效访问。虚拟地址与物理地址没有映射。

没有段错误不一定是合法访问。

合法访问：比如malloc分配的空间之外的空间（malloc后就映射了）可以访问但是访问非法。

int p1 = malloc(4); int (p1+12) = 233; 第二句不会报段错误，但是是非法访问。

8.虚拟内存的分配

栈：编译器自动生成代码维护

堆：地址是否映射？映射的空间是否被管理？

brk/sbrk内存映射函数

补充：帮助文档：man 节 关键字

节：1-8 1： Linux系统（shell）指令 （ls等）

　　 2： 系统函数 （brk等）

　　 3： 标准C函数的帮助文档 （fopen等）

　　 4： 系统的编程帮助 （tcp， icmp等）

分配释放内存

int brk(void *addr); //分配空间，释放空间

void *sbrk(int size); //返回指定大小的空间的地址

应用：

使用sbrk分配内存空间 int *p = sbrk(4); //分配4字节整数

使用sbrk得到没有映射的虚拟地址 int *p1 = sbrk(0); //返回没有映射的虚拟地址的首地址，不能给*p1赋值，会出现段错误。因为还没有映射。

使用brk分配空间

使用brk释放空间

理解：

sbrk(int size)

sbrk与brk后台系统维护一个指针。指针默认是null。

调用sbrk，判定指针是否是0（第一次调用），如果是：得到大块空闲地址的首地址来初始化该指针。返回该指针给指针变量赋值，同时把指针指向+size的地方。如果是否：返回指针，并且将指针位置+size

#include <stdio.h>
#include <unistd.h>

int main()
{
int *p = sbrk(0);  //返回空闲地址，并修改指针为+size（这里是0,），注意这个指针不是*p，而是sbrk指向内存里的指针。
//这里是0，并且是首次调用，所以内存并没有映射。如果括号里是4或者4的倍数，则会返回指针的同时做映射，并把sbrk的指针指向+4的位
//置以便供下一次调用的时候返回地址。并不是括号里是4就只映射4个字节的地址，而是映射一页的内存。这是为了效率的考虑。好比吃馒头，
//不是吃一个做一个，而是要吃了，做一屉，慢慢吃。所以 *（p+10）= 20; 是可以访问的（p最多只能加到1023，不然仍然会段错误）。
//但是是非法访问。

printf("%d\n", *p);
}

#include <stdio.h>
#include <unistd.h>

int main()
{
int *p1 = sbrk(4);  //返回空闲地址，并修改指针为+size
int *p2 = sbrk(0);

printf("%p\n", p1);
printf("%p\n", p2);  //通过上面的程序分析，这里打印的
//是p1加上4个字节后的地址。int *p2 = sbrk(200);这句话括号里即使
//是200，p2也是p1加4个字节，因为sbrk是先返回当前的地址，再加括
//号里的size。如果括号里是负数，则表示释放空间。

while(1);
}

下面再看brk(void *p)函数:

#include <stdio.h>
#include <unistd.h>

int main()
{
int *p = sbrk(0);
brk(p+1);  //将sbrk里面的指针向后移动4个字节，发现没
//有映射，就会自动映射区域。所以后面的*p就可以访问了。
*p = 800;
brk(p);   //将指针再移回去，相当于释放内存空间，即取
//消之前的映射。后面再访问就会出错了。
*p = 29;  //段错误。

while(1);
}

应用案例: 写一个程序查找1-10000之间的所有的素数，并且存放到缓冲，然后打印。

分析：

1-10000如果用数组的话，不太现实，有大部分空间都用不上。 C++的话可以用链表实现，但是链表的开销比较大。用malloc和new都不太好。所以，缓冲的实现使用sbrk/brk。

流程：

判断是否是素数（isPrime）

是，分配空间存放

否，继续下步

#include <stdio.h>

#include <unistd.h>

int isPrime(int a)
{
int i = 0;
for(i = 2; i < a; i++)
{
if(a%i == 0)
{
return 1;
}
}
return 0;
}

int main()
{
int i = 2; //循环变量
int *r;
int *p;  //p一直指向页首
r = sbrk(0);
p = r;
for(; i<10000; i++)
{
if(isPrime(i))
{
brk(r+1);
*r = i;
r = sbrk(0);
}
}

i = 0;
r = p;
while(r != sbrk(0))
{
printf("%d\n", *r);
r++;
}
brk(p);  //释放空间
}

new /
a3cf
/C++里面用得比较多

malloc //C里面用得比较多，一定要制定空间大小

brk/sbrk //数据比较简单，量比较大的时候用效率比较高

异常处理

int brk(void *) //返回int值

void *sbrk(int) //返回指针

如果成功，brk返回0， sbrk返回指针

如果失败， brk返回-1， sbrk返回（void *）-1

#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>

int main()
{
void *p = sbrk(1000000000*3);
if(p == (void *)-1)
{
printf("error!");
perror("Hello"); //打印出错误信息
printf("%m");  //打印出memory error
printf("%s", strerror(errno));
}
}

以下是一些比较常用的函数：

字符串函数string.h cstring

内存管理函数malloc memset mamcmp memcpy…bzero

错误处理函数

时间函数

类型转换函数

作业：

找出打印1-10000之间的所有孪生素数。