uc 内存管理

一、错误处理
------------
1. 通过函数的返回值表示错误
~~~~~~~~~~~~~~~~~~~~~~~~~~~
1) 返回合法值表示成功，返回非法值表示失败。
范例：


#include <stdio.h>
#include <limits.h>

// 获取文件大小
// 成功返回文件大小，失败返回-1
long fsize (const char* path) {
	FILE* fp = fopen (path, "r");
	if (! fp)
		return -1;

	fseek (fp, 0, SEEK_END);
	long size = ftell (fp);

	fclose (fp);

	return size;
}

int main (void) {
	printf ("文件路径：");
	char path[PATH_MAX+1];
	scanf ("%s", path);

	long size = fsize (path);
	if (size < 0) {
		printf ("获取文件大小失败！\n");
		return -1;
	}

	printf ("文件大小：%ld字节\n", size);

	return 0;
}

2) 返回有效指针表示成功，
返回空指针(NULL/0xFFFFFFFF)表示失败。

#include <stdio.h>
#include <string.h>

// 求字符串最大值
// 成功返回参数字符串中的最大值，失败返回NULL
例如：
const char* strmax (const char* a, const char* b) {
	return a && b ? (strcmp (a, b) > 0 ? a : b) : NULL;
}

int main (void) {
	const char* max = strmax ("hello", "world");
//	const char* max = strmax ("hello", NULL);
	if (! max) {
		printf ("求字符串最大值失败！\n");
		return -1;
	}

	printf ("字符串最大值：%s\n", max);

	return 0;
}

3) 返回0表示成功，返回-1表示失败，
不输出数据或通过指针/引用型参数输出数据。
范例：


#include <stdio.h>

// 整数取模
// 成功返回0，失败返回-1
int intmod (int a, int b, int* mod) {
	if (b == 0)
		return -1;

	*mod = a % b;

	return 0;
}

int main (void) {
	printf ("两个整数：");
	int a, b;
	scanf ("%d%d", &a, &b);

	int mod;
	if (intmod (a, b, &mod) == -1) {
		printf ("整数取模失败！\n");
		return -1;
	}

	printf ("整数取模：%d\n", mod);

	return 0;
}


4) 永远成功，如：printf()。

练习：实现四个函数
slen() - 求字符串的长度，若为空指针，则报错。
scpy() - 字符串拷贝，考虑缓冲区溢出，
成功返回目标缓冲区地址，
目标缓冲区无效时报错。
intmin() - 求两个整数的最小值，若二者相等，则报错。
intave() - 求两个整数的平均值，考虑求和溢出，
该函数不会失败。

#include <stdio.h>

// 求字符串长度
// 成功返回字符串长度，失败返回(size_t)-1
size_t slen (const char* s) {
	if (! s)
		return -1;

	size_t len;
	for (len = 0; s[len]; ++len);

	return len;
}

// 字符串拷贝
// 成功返回目标字符串，失败返回NULL
char* scpy (char* dst, size_t size, const char* src) {
	if (! dst || ! size)
		return NULL;

	size_t len = slen (src);
	if (len == -1)
		return NULL;

	size_t i, chs = size - 1 < len ? size - 1 : len;
	for (i = 0; i < chs; ++i)
		dst[i] = src[i];
	dst[i] = '\0';

	return dst;
}

// 求整数最小值
// 成功返回0，失败返回-1
int intmin (int a, int b, int* min) {
	if (a == b)
		return -1;

	*min = a < b ? a : b;

	return 0;
}

// 求整数平均值
// 成功返回参数整数的平均值，不会失败
int intave (int a, int b) {
	return (a & b) + ((a ^ b) >> 1);
}
/*
  109 = 01101101 = 00100101 + 01001000
   55 = 00110111 = 00100101 + 00010010
+)------------------------------------
             a+b = (a&b)*2  + (a^b)
         (a+b)/2 = (a&b) + (a^b)>>1
                 = 37    + 01011010>>1
                 = 37    + 00101101
                 = 37    + 45
                 = 82
*/
int main (void) {
	size_t len = slen ("Hello World !");
//	size_t len = slen (NULL);
	if (len == -1)
		printf ("求字符串长度失败！\n");
	else
		printf ("字符串长度：%u\n", len);

	char dst[5];
	if (! scpy (dst, sizeof (dst) / sizeof (dst[0]), "0123456789"))
//	if (! scpy (NULL, 0, "0123456789"))
		printf ("字符串拷贝失败！\n");
	else
		printf ("字符串副本：%s\n", dst);

	int min;
	if (intmin (-1, 0, &min) == -1)
//	if (intmin (-1, -1, &min) == -1)
		printf ("求整数最小值失败！\n");
	else
		printf ("整数最小值：%d\n", min);

	printf ("整数平均值：%d\n", intave (1234, 5678));

	return 0;
}


2. 通过errno表示错误
~~~~~~~~~~~~~~~~~~~~
#include <errno.h>
1) 根据errno得到错误编号。
2) 将errno转换为有意义的字符串：
#include <string.h>
char* strerror (int errnum);
#include <stdio.h>
void perror (const char* s);
printf ("%m");
范例：

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

int main (void) {
	FILE* fp = fopen ("none", "r");
	if (! fp) {
		printf ("fopen: %d\n", errno);
		printf ("fopen: %s\n", strerror (errno));
		printf ("fopen: %m\n");
		perror ("fopen");
		return -1;
	}

	fclose (fp);

	return 0;
}


3) errno在函数执行成功的情况下不会被修改，
因此不能以errno非零，作为发生错误判断依据

4) errno是一个全局变量，其值随时可能发生变化。

二、环境变量
------------
1. 环境表
~~~~~~~~~
1) 每个程序都会接收到一张环境表，
是一个以NULL指针结尾的字符指针数组。
2) 全局变量environ保存环境表的起始地址。
+---+
environ -> | * --> HOME=/root
+---+
| * --> SHELL=/bin/bash
+---+
| * --> PATH=/bin:/usr/bin:...:.
+---+
| . |
| . |
| . |
+---+
| 0 |
+---+

图示：env_list.bmp


[img]http://dl2.iteye.com/upload/attachment/0100/6397/f1dc076c-41a8-3b44-8e18-522866865e06.bmp[/img]

2. 环境变量函数
~~~~~~~~~~~~~~~
#include <stdlib.h>
环境变量：name=value
getenv - 根据name获得value。
putenv - 以name=value的形式设置环境变量，
name不存在就添加，存在就覆盖其value。
setenv - 根据name设置value，注意最后一个参数表示，
若name已存在是否覆盖其value。
unsetenv - 删除环境变量。
clearenv - 清空环境变量，environ==NULL。
范例：

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

void printenv (void) {
	printf ("---- 环境变量 ----\n");

	extern char** environ;
	char** env;
	for (env = environ; env && *env; ++env)
		printf ("%s\n", *env);

	printf ("------------------\n");
}

int main (void) {
	char env[256];
	const char* name = "MYNAME";
	// 添加环境变量
	sprintf (env, "%s=whj", name);
	putenv (env);
	printf ("%s=%s\n", name, getenv (name));
	// 修改环境变量
	sprintf (env, "%s=bjarne", name);
	putenv (env);
	printf ("%s=%s\n", name, getenv (name));
	// 不存在就添加，存在不覆盖
	setenv (name, "whj", 0);
	printf ("%s=%s\n", name, getenv (name));
	// 不存在就添加，存在就覆盖
	setenv (name, "whj", 1);
	printf ("%s=%s\n", name, getenv (name));

	printenv ();
	// 删除环境变量
	unsetenv (name);
	printenv ();
	// 清空环境变量
	clearenv ();
	printenv ();

	return 0;
}

三、内存管理

------------
+----+--------+----------------------------+----------+
| 用 | STL | 自动分配/释放内存资源 | 调C++ |
| | C++ | new/delete，构造/析构 | 调标C |
| 户 | 标C | malloc/calloc/realloc/free | 调POSIX |
| | POSIX | brk/sbrk | 调Linux |
| 层 | Linux | mmap/munmap | 调Kernel |
+----+--------+----------------------------+----------+
| 系 | Kernel | kmalloc/vmalloc | 调Driver |
| 统 | Driver | get_free_page | ... |
| 层 | ... | ... | ... |
+----+--------+----------------------------+----------+
四、进程映像
------------


1. 程序是保存在磁盘上的可执行文件。

2. 运行程序时，需要将可执行文件加载到内存，形成进程。

3. 一个程序(文件)可以同时存在多个进程(内存)。

4. 进程在内存空间中的布局就是进程映像。
从低地址到高地址依次为：
代码区(text)：可执行指令、字面值常量、具有常属性的全局和静态局部变量。只读。

数据区(data)：初始化的全局和静态局部变量。

BSS区：未初始化的全局和静态局部变量。
进程一经加载此区即被清0。
数据区和BSS区有时被合称为全局区或静态区。

堆区(heap)：动态内存分配。从低地址向高地址扩展。

栈区(stack)：非静态局部变量，

包括函数的参数和返回值。从高地址向低地址扩展。

堆区和栈区之间存在一块间隙，一方面为堆和栈的增长预留空间，同时共享库、共享内存等亦位于此。

命令行参数与环境区：命令行参数和环境变量。
图示：maps.bmp


[img]http://dl2.iteye.com/upload/attachment/0100/6401/767388e5-03c3-3b50-9d78-57831bd78907.bmp[/img]

范例：

#include <stdio.h>
#include <unistd.h>
#include <sys/mman.h>

#define MAX_TEXT 256

int main (void) {
	char* psz = (char*)mmap (/*sbrk (0)*/NULL, MAX_TEXT * sizeof (char),
		PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
	if (psz == MAP_FAILED) {
		perror ("mmap");
		return -1;
	}

	sprintf (psz, "Hello, World !");
	printf ("%s\n", psz);

	printf ("psz = %p\n", psz);
	printf ("查看/proc/%u/maps，按<回车>退出...", getpid ());
	getchar ();

	if (munmap (psz, MAX_TEXT * sizeof (char)) == -1) {
		perror ("munmap");
		return -1;
	}

	return 0;
}

void *mmap(void *start,size_t length,int prot,int flags,int fd,off_t offsize); 
具体参数含义
start ：  指向欲映射的内存起始地址，通常设为 NULL，代表让系统自动选定地址，映射成功后返回该地址。
length：  代表将文件中多大的部分映射到内存。
prot  ：  映射区域的保护方式。可以为以下几种方式的组合：
                    PROT_EXEC 映射区域可被执行
                    PROT_READ 映射区域可被读取
                    PROT_WRITE 映射区域可被写入
                    PROT_NONE 映射区域不能存取
flags ：  影响映射区域的各种特性。在调用mmap()时必须要指定MAP_SHARED 或MAP_PRIVATE。
                    MAP_FIXED 如果参数start所指的地址无法成功建立映射时，则放弃映射，不对地址做修正。通常不鼓励用此旗标。
                    MAP_SHARED 对映射区域的写入数据会复制回文件内，而且允许其他映射该文件的进程共享。
                    MAP_PRIVATE 对映射区域的写入操作会产生一个映射文件的复制，即私人的“写入时复制”（copy on write）对此区域作的任何修改都不会写回原来的文件内容。
                    MAP_ANONYMOUS建立匿名映射。此时会忽略参数fd，不涉及文件，而且映射区域无法和其他进程共享。
                    MAP_DENYWRITE只允许对映射区域的写入操作，其他对文件直接写入的操作将会被拒绝。
                    MAP_LOCKED 将映射区域锁定住，这表示该区域不会被置换（swap）。
fd    ：  要映射到内存中的文件描述符。如果使用匿名内存映射时，即flags中设置了MAP_ANONYMOUS，fd设为-1。有些系统不支持匿名内存映射，则可以使用fopen打开/dev/zero文件，
          然后对该文件进行映射，可以同样达到匿名内存映射的效果。
offset：文件映射的偏移量，通常设置为0，代表从文件最前方开始对应，offset必须是PAGE_SIZE的整数倍。

返回值：
      若映射成功则返回映射区的内存起始地址，否则返回MAP_FAILED(－1)，错误原因存于errno 中。

错误代码：
            EBADF  参数fd 不是有效的文件描述词
            EACCES 存取权限有误。如果是MAP_PRIVATE 情况下文件必须可读，使用MAP_SHARED则要有PROT_WRITE以及该文件要能写入。
            EINVAL 参数start、length 或offset有一个不合法。
            EAGAIN 文件被锁住，或是有太多内存被锁住。
            ENOMEM 内存不足。


1.比对/proc/<pid>/maps
2.# size a.out
text data bss dec hex filename
1405  284  4  1693 69d a.out

五、虚拟内存
------------
1. 每个进程都有各自互独立的4G字节虚拟地址空间。
2. 用户程序中使用的都是虚拟地址空间中的地址，
永远无法直接访问实际物理内存地址。
3. 虚拟内存到物理内存的映射由操作系统动态维护。
4. 虚拟内存一方面保护了操作系统的安全，
另一方面允许应用程序，
使用比实际物理内存更大的地址空间。
图示：vm.png


[img]http://dl2.iteye.com/upload/attachment/0100/6403/0ab0ed64-f5e4-3548-b4fb-4dbd609ff5d5.png[/img]

5. 4G进程地址空间分成两部分：
[0, 3G)为用户空间，
如某栈变量的地址0xbfc7fba0=3,217,554,336，约3G；
[3G, 4G)为内核空间。
6. 用户空间中的代码，
不能直接访问内核空间中的代码和数据，
但可以通过系统调用进入内核态，
间接地与系统内核交互。
图示：kernel.png


[img]http://dl2.iteye.com/upload/attachment/0100/6399/874859e8-8478-3974-af51-44899f4d8a4d.png[/img]

7. 对内存的越权访问，对内存的越权访问，
或试图访问没有映射到物理内存的虚拟内存，
将导致段错误。
8. 用户空间对应进程，进程一切换，用户空间即随之变化。
内核空间由操作系统内核管理，不会随进程切换而改变。
内核空间由内核根据独立且唯一的页表init_mm.pgd
进行内存映射，而用户空间的页表则每个进程一份。
9. 每个进程的内存空间完全独立。
不同进程之间交换虚拟内存地址是毫无意义的。
范例：vm.c


[img]http://dl2.iteye.com/upload/attachment/0100/6403/0ab0ed64-f5e4-3548-b4fb-4dbd609ff5d5.png[/img]


10. 标准库内部通过一个双向链表，
管理在堆中动态分配的内存。
malloc函数分配内存时会附加若干(通常是12个)字节，
存放控制信息。
该信息一旦被意外损坏，可能在后续操作中引发异常。


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

int main (void) {
	int* p1 = malloc (sizeof (int));
	int* p2 = malloc (sizeof (int));
	printf ("%p, %p\n", p1, p2);

	free (p2);

	p1[3] = 0;//beng
	free (p1);

	return 0;
}


11. 虚拟内存到物理内存的映射以页(4K=4096字节)为单位。
通过malloc函数首次分配内存，至少映射33页。
即使通过free函数释放掉全部内存，
最初的33页仍然保留。
图示：address_space.png
#include <unistd.h>
int getpagesize (void);
返回内存页的字节数。
范例：page.c
char* pc = malloc (sizeof (char));
|
v<--------------- 33页 --------------->|
------+-------+----------+-------------------+------
| 1字节 | 控制信息 | |
------+-------+----------+-------------------+------
^ ^ ^ ^ ^
段错误 OK 后续错误 不稳定 段错误
六、内存管理APIs
----------------

1. 增量方式分配虚拟内存
~~~~~~~~~~~~~~~~~~~~~~~
#include <unistd.h>
void* sbrk (
intptr_t increment // 内存增量(以字节为单位)
);
返回上次调用brk/sbrk后的末尾地址，失败返回-1。
increment取值：
0 - 获取末尾地址。
>0 - 增加内存空间。
<0 - 释放内存空间。
内部维护一个指针，
指向当前堆内存最后一个字节的下一个位置。
sbrk函数根据增量参数调整该指针的位置，
同时返回该指针原来的位置。
若发现页耗尽或空闲，则自动追加或取消页映射。
void* p = sbrk(4); p = sbrk(0);
      ^                ^
      |                |

返回 *-- increment ->* 返回
| |
v v
--+---+---+---+---+---+---+--
| B | B | B | B | B | B |
--+---+---+---+---+---+---+--
|<--------- 页 --------
2. 修改虚拟内存块末尾地址
~~~~~~~~~~~~~~~~~~~~~~~~~
#include <unistd.h>
int brk (
void* end_data_segment // 内存块末尾地址
);
成功返回0，失败返回-1。
内部维护一个指针，
指向当前堆内存最后一个字节的下一个位置。
brk函数根据指针参数设置该指针的位置。
若发现页耗尽或空闲，则自动追加或取消页映射。
void* p=sbrk(0); brk(p+4);
^ |
| v
返回 * * 设置
| |
v v
--+---+---+---+---+---+---+--
| B | B | B | B | B | B |
--+---+---+---+---+---+---+--
|<--------- 页 --------
sbrk/brk底层维护一个指针位置，
以页(4K)为单位分配和释放虚拟内存。
简便起见，可用sbrk分配内存，用brk释放内存。

例如：

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

void presskey (void) {
	printf ("查看/proc/%u/maps，按<回车>继续...", getpid ());
	getchar ();
}

int main (void) {
	void* p1 = sbrk (4); // RXXX ---- ---- ---- -
	printf ("p1 = %p\n", p1);
	void* p2 = sbrk (4); // XXXX RXXX ---- ---- -
	printf ("p2 = %p\n", p2);
	void* p3 = sbrk (4); // XXXX XXXX RXXX ---- -
	printf ("p3 = %p\n", p3);
	void* p4 = sbrk (4); // XXXX XXXX XXXX RXXX -
	printf ("p4 = %p\n", p4);
	void* p5 = sbrk (0); // XXXX XXXX XXXX XXXX R
	printf ("p5 = %p\n", p5);

	int* pn = (int*)p1;
	pn[0] = 0;
	pn[1] = 1;
	pn[2] = 2;
	pn[3] = 3;
	pn[1023] = 1023;
	printf ("%d, %d, %d, %d, %d\n",
		pn[0], pn[1], pn[2], pn[3], pn[1023]);
//	pn[1024] = 1024;

	void* p6 = sbrk (-8); // XXXX XXXX ---- ---- R
	printf ("p6 = %p\n", p6);
	void* p7 = sbrk (-8); // ---- ---- R--- ---- -
	printf ("p7 = %p\n", p7);

//	pn[0] = 0;

	printf ("----------------\n");

	int page = getpagesize ();

	printf ("%p\n", sbrk (page));
	presskey ();

	printf ("%p\n", sbrk (1));
	presskey ();

	printf ("%p\n", sbrk (-1));
	presskey ();

	printf ("%p\n", sbrk (-page));
	presskey ();

	printf ("----------------\n");

	p1 = sbrk (0);     // R--- ---- ---- ---- -
	printf ("p1 = %p\n", p1);
	brk (p2 = p1 + 4); // XXXX S--- ---- ---- -
	printf ("p2 = %p\n", p2);
	brk (p3 = p2 + 4); // XXXX XXXX S--- ---- -
	printf ("p3 = %p\n", p3);
	brk (p4 = p3 + 4); // XXXX XXXX XXXX S--- -
	printf ("p4 = %p\n", p4);
	brk (p5 = p4 + 4); // XXXX XXXX XXXX XXXX S
	printf ("p5 = %p\n", p5);

	pn = (int*)p1;
	pn[0] = 0;
	pn[1] = 1;
	pn[2] = 2;
	pn[3] = 3;
	pn[1023] = 1023;
	printf ("%d, %d, %d, %d, %d\n",
		pn[0], pn[1], pn[2], pn[3], pn[1023]);
//	pn[1024] = 1024;

	brk (p3); // XXXX XXXX S--- ---- -
	brk (p1); // S--- ---- ---- ---- -

//	pn[0] = 0;

	printf ("----------------\n");

	void* begin = sbrk (sizeof (int));
	if ((int)begin == -1) {
		perror ("sbrk");
		return -1;
	}

	pn = (int*)begin;
	*pn = 1234;

	double* pd = (double*)sbrk (sizeof (double));
	if ((int)pd == -1) {
		perror ("sbrk");
		return -1;
	}

	*pd = 3.14;

	char* psz = (char*)sbrk (256 * sizeof (char));
	if ((int)psz == -1) {
		perror ("sbrk");
		return -1;
	}

	sprintf (psz, "Hello, World !");

	printf ("%d, %lf, %s\n", *pn, *pd, psz);

	if (brk (begin) == -1) {
		perror ("brk");
		return -1;
	}

	return 0;
}


自己写malloc、free


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

// 内存控制块
typedef struct mem_control_block {
	bool                      free; // 自由标志
	struct mem_control_block* prev; // 前块指针
	size_t                    size; // 本块大小
}	MCB;

MCB* g_top = NULL; // 栈顶指针

// +----------------------+              g_top
// v                      |                |
// +------+------------+--|---+------------+------+------------+
// | prev |            | prev |            | prev |            |
// | free |            | free |            | free |            |
// | size |            | size |            | size |            |
// +------+------------+------+------------+------+------------+
//   MCB  |<-- size -->|

// 分配内存
void* my_malloc (size_t size) {
	MCB* mcb;
	for (mcb = g_top; mcb; mcb = mcb->prev)
		if (mcb->free && mcb->size >= size)
			break;

	if (! mcb) {
		mcb = sbrk (sizeof (MCB) + size);
		if (mcb == (void*)-1)
			return NULL;

		mcb->prev = g_top;
		mcb->size = size;
		g_top = mcb;
	}

	mcb->free = false;

	return mcb + 1;
}

// 释放内存
void my_free (void* ptr) {
	if (! ptr)
		return;

	MCB* mcb = (MCB*)ptr - 1;
	mcb->free = true;

	for (mcb = g_top; mcb->prev; mcb = mcb->prev)
		if (! mcb->free)
			break;

	if (mcb->free) {
		g_top = mcb->prev;
		brk (mcb);
	}
	else
	if (mcb != g_top) {
		g_top = mcb;
		brk ((void*)mcb + sizeof (MCB) + mcb->size);
	}
}

int main (void) {
	int* pa[10];
	size_t size = sizeof (pa) / sizeof (pa[0]), i, j;

	for (i = 0; i < size; ++i) {
		if (! (pa[i] = (int*)my_malloc ((i + 1) * sizeof (int)))) {
			perror ("my_malloc");
			return -1;
		}

		for (j = 0; j <= i; ++j)
			pa[i][j] = j;
	}

	for (i = 0; i < size; ++i) {
		for (j = 0; j <= i; ++j)
			printf ("%d ", pa[i][j]);
		printf ("\n");
	}
	/*
	for (i = 0; i < size; ++i)
		my_free (pa[i]);
	*/
	for (;;) {
		my_free (pa[--i]);
		if (! i)
			break;
	}

	return 0;
}

3. 创建虚拟内存到物理内存或文件的映射
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#include <sys/mman.h>
void* mmap (
void* start, // 映射区内存起始地址，
// NULL系统自动选定，成功返回之
size_t length, // 字节长度，自动按页(4K)对齐
int prot, // 映射权限
int flags, // 映射标志
int fd, // 文件描述符
off_t offset // 文件偏移量，自动按页(4K)对齐
);


成功返回映射区内存起始地址，失败返回MAP_FAILED(-1)。
prot取值：
PROT_EXEC - 映射区域可执行。
PROT_READ - 映射区域可读取。
PROT_WRITE - 映射区域可写入。
PROT_NONE - 映射区域不可访问。
flags取值：
MAP_FIXED - 若在start上无法创建映射，
则失败(无此标志系统会自动调整)。
MAP_SHARED - 对映射区域的写入操作直接反映到文件中。
MAP_PRIVATE - 对映射区域的写入操作只反映到缓冲区中，
不会真正写入文件。
MAP_ANONYMOUS - 匿名映射，
将虚拟地址映射到物理内存而非文件，
忽略fd。
MAP_DENYWRITE - 拒绝其它对文件的写入操作。
MAP_LOCKED - 锁定映射区域，保证其不被置换。
4. 销毁虚拟内存到物理内存或文件的映射
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
int munmap (
void* start, // 映射区内存起始地址
size_t length, // 字节长度，自动按页(4K)对齐
);
成功返回0，失败返回-1。
例如:

#include <stdio.h>
#include <unistd.h>
#include <sys/mman.h>

#define MAX_TEXT 256

int main (void) {
	char* psz = (char*)mmap (/*sbrk (0)*/NULL, MAX_TEXT * sizeof (char),
		PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
	if (psz == MAP_FAILED) {
		perror ("mmap");
		return -1;
	}

	sprintf (psz, "Hello, World !");
	printf ("%s\n", psz);

	printf ("psz = %p\n", psz);
	printf ("查看/proc/%u/maps，按<回车>退出...", getpid ());
	getchar ();

	if (munmap (psz, MAX_TEXT * sizeof (char)) == -1) {
		perror ("munmap");
		return -1;
	}

	return 0;
}

mmap/munmap底层不维护任何东西，只是返回一个首地址，
所分配内存位于堆中。
brk/sbrk底层维护一个指针，记录所分配的内存结尾，
所分配内存位于堆中，底层调用mmap/munmap。
malloc底层维护一个双向链表和必要的控制信息，
不可越界访问，所分配内存位于堆中，底层调用brk/sbrk。
每个进程都有4G的虚拟内存空间，
虚拟内存地址只是一个数字，
并没有和实际的物理内存将关联。
所谓内存分配与释放，
其本质就是建立或取消虚拟内存和物理内存间的映射关系。

实现一个基于顺序表的堆栈类模板，
其数据缓冲区内存可根据数据元素的多少自动增减，
但不得使用标准C的内存分配与释放函数。

#include <iostream>
using namespace std;

template<class T = int> class Stack {
public:
	Stack (void) : m_begin (sbrk (0)) {}

	~Stack (void) {
		brk (m_begin);
	}

	void push (const T& data) {
		*(T*)sbrk (sizeof (T)) = data;
	}

	void pop (void) {
		if (sbrk (0) != m_begin)
			sbrk (-sizeof (T));
	}

	bool top (T& data) {
		if (sbrk (0) != m_begin) {
			data = *((T*)sbrk (0) - 1);
			return true;
		}
		return false;
	}

private:
	void* m_begin;
};

int main (void) {
	Stack<> sn;

	for (int i = 0; i < 5; i++)
		sn.push (i + 1);

	for (int i; sn.top (i); sn.pop ())
		cout << i << ' ';
	cout << endl;

	Stack<const char*> ss;

	ss.push ("heze");
	ss.push ("zibo");
	ss.push ("jinan");
	ss.push ("weifang");
	ss.push ("qingdao");

	for (const char* s; ss.top (s); ss.pop ())
		cout << s << ' ';
	cout << endl;

	return 0;
}