SWAP交换分区

楼上答案已经解释了各个概念，我就给你大概解释下这些概念间的联系吧。  cpu主要就是处理各种指令，运算、跳转、存取内存之内的。这些指令所需的数据以及指令本身一般都是存储在ram中的。cpu必须将ram中的指令和数据取到cpu中的各种寄存器中，指令才能执行。指令的地址存储在一个叫做PC的寄存器中，注意这边的PC不是个人电脑的意思，而是pointer of code的意思，即指令指针，而数据可以放在各种通用寄存器中。cpu中还有很多其他寄存器，控制着cpu各种功能。如果你学过汇编，便会知道汇编语言即是操作这些寄存器，完成各种运算任务。  现代高性能cpu内部一般都会有缓存，一般分为指令缓存和数据缓存。缓存的访问速度比外部ram要快很多，所以如果把一部分数据和指令存储在缓存中，cpu再从缓存中获取指令和数据能够提高cpu的速度。  可以被称作rom的东西很多，如pc主板上的rom芯片，pc关机后，rom的数据不会丢失，开机时先运行其中的bios程序，完成硬件配置和检测，之后会将磁盘第一个扇区中操作系统的引导程序装入内存，然后徐跳到引导程序。引导程序会进一步将操作系统存储在磁盘上的内核装入内存，最后执行内核程序。内核加载文件系统，并执行gui程序，便可以看到pc的桌面了。我只是简要的说明了你问题中的这些概念，省略了很多细节。如果想对计算机从硬件到操作系统再到应用层有些认识的话，强烈建议你看《深入理解计算机系统》，即入门又足够深入。
========================================================================================================================================================================================================================================================================================
学生不才，这个虚拟地址与虚拟内存的问题困惑的我很长的时间，现在写一下最近看过一些资料后的理解吧，肯定存在不完整或者不正确的地方，希望大家可以纠正，如果能给你带来一些新知识，或者帮您复习了一下旧知识，我感到非常荣幸，下面开始，以32位的i386CPU看。

   首先先来看看我一直以来认识的错误的地方。

   在最开始看书的时候，我知道程序在运行时，不是全部加入内存当中的，当然，这个现在依旧正确，在有了虚拟地址空间这个概念以后，我一直认为是在硬盘中划分出一块虚拟内存出来，然后给每个程序4G的硬盘空间，作为这个程序的虚拟内存，然后就需要运行哪一块然后哪一块装入内存当中。后来发现这个是错误的。大家可以在我错误的地方来看看自己的理解，纠正自己的问题。

   首先，虚拟地址空间是不等于虚拟内存的（我的一本Linux教材上写的是这两个概念一致的，我认为是错误的）。我们来看一下这几个概念：

   虚拟内存：虚拟内存是一种逻辑上扩充物理内存的技术。基本思想是用软、硬件技术把内存与外存这两级存储器当做一级存储器来用。虚拟内存技术的实现利用了自动覆盖和交换技术。简单的说就是将硬盘的一部分作为内存来使用。

   虚拟地址空间：在32位的i386CPU的地址总线的是32位的，也就是说可以寻找到4G的地址空间。我们的程序被CPU执行，就是在0x00000000到0xFFFFFFFF这一段地址中。高2G的空间为内核空间，由操作系统调用，低2G的空间为用户空间，由用户使用。

   CPU在寻址的时候，是按照虚拟地址来寻址，然后通过MMU(内存管理单元)将虚拟地址转换为物理地址。因为只有程序的一部分加入到内存中，所以会出现所寻找的地址不在内存中的情况（CPU产生缺页异常），如果在内存不足的情况下，就会通过页面调度算法来将内存中的页面置换出来，然后将在外存中的页面加入到内存中，使程序继续正常运行。

SWAP交换分区

   可以看出，虚拟地址空间和虚拟内存的一个关键的因素是MMU（内存管理单元）。

   现在一个程序的执行现在可以分为3部分：

   1：CPU需要执行的语句的虚拟地址。

   2：程序装入内存的部分

   3：程序再外存中的部分

   因为CPU是通过时间片轮转的方法使不同的程序并发执行的。所以在某一时刻只有一个程序占据CPU资源，CPU的最大的寻址空间为4G，所以说可以将每个程序可以看做独立占据4G的内存（只是可以看成，但是它并没有占据实际的4G内存）。而CPU是将虚拟地址空间里面的代码执行，如果在内存中寻找不到所需要的页面，就需要到外存中寻找，外存的这一部分，我们可以当成内存来使用，这也就是虚拟内存。虚拟地址空间不等于虚拟内存。虚拟地址空间是一个空间，不是真正存在的，只是通过CPU的寻址虚拟出来的一个范围。而虚拟内存是实实在在的硬盘的空间。

   我看到了一个比较形象的比喻，假设4G个门牌号（4G的虚拟地址空间，并将这4G的虚拟空间进行分页），但是房子的数量（内存）少于门牌号的数量（4G的虚拟空间），那样就先把每个房子（内存）上挂一个门牌号（页），如果你要找一个门牌号(页)，就需要查找每个房子（内存），如果这个门牌号没有挂（页还没有被加入到内存中），那么就将一个房子的门牌号（页面置换到外存）摘下来，把你找的那个门牌号挂上（将外存的页加入内存），这样就找到了需要的门牌号（页）。

   这是我将这个比喻综合了一下。CPU只需要说找哪一个页面，MMU就将这个页面翻译成物理地址，再通过页面调度机制来讲不在内存中的页加入到内存中。

   我认为计算机使用的是一种各司其职的方法。

   CPU老大只需要要虚拟地址中的一页，范围在0x00000000到0xFFFFFFFF，因为他的地址总线是32位，4G是他最大的能力，然后他就把任务分配给他的手下，CPU不需要知道他的手下是如何找到这一页，他只负责去要这一页和执行这些代码，然后他就和他的手下说“有招想去，没招死去”，他的手下必须要能找到这一页，然后内存非常有限，而CPU不管这个，只需要你能找到这一页让我执行就好，所以CPU的手下就将硬盘中的一部分当做内存，然后拿来骗CPU说，“这是我从内存中找到的”，然后CPU就去运行。如果访问的地方实在是不能找到，或者是没有权限，那么这个程序就真死了。程序员在开发的时候，因为程序员所编写的代码最终是要让CPU去执行，所以程序员也理所应当认为我有4G的内存空间，程序员把程序交给CPU，CPU就交给他手下。

   所以说，他们每一层都不需要管对方是如何办到的，他们在乎的只有结果。他们各司其职，CPU认为我有4G内存空间的原因是因为CPU的地址总线为32位，最大的寻址能力是4G，而内存没有这个大，所以它想出来的办法是将硬盘的一部分拿来骗CPU，并给这块骗人的地方起了一个好名字，虚拟内存。这就是我的理解中的虚拟内存空间和虚拟内存的概念。

   自身水平有限，希望大家矫正，谢谢！


==================================================================================================================================================================================================================
学生不才，这个虚拟地址与虚拟内存的问题困惑的我很长的时间，现在写一下最近看过一些资料后的理解吧，肯定存在不完整或者不正确的地方，希望大家可以纠正，如果能给你带来一些新知识，或者帮您复习了一下旧知识，我感到非常荣幸，下面开始，以32位的i386CPU看。

   首先先来看看我一直以来认识的错误的地方。

   在最开始看书的时候，我知道程序在运行时，不是全部加入内存当中的，当然，这个现在依旧正确，在有了虚拟地址空间这个概念以后，我一直认为是在硬盘中划分出一块虚拟内存出来，然后给每个程序4G的硬盘空间，作为这个程序的虚拟内存，然后就需要运行哪一块然后哪一块装入内存当中。后来发现这个是错误的。大家可以在我错误的地方来看看自己的理解，纠正自己的问题。

   首先，虚拟地址空间是不等于虚拟内存的（我的一本Linux教材上写的是这两个概念一致的，我认为是错误的）。我们来看一下这几个概念：

   虚拟内存：虚拟内存是一种逻辑上扩充物理内存的技术。基本思想是用软、硬件技术把内存与外存这两级存储器当做一级存储器来用。虚拟内存技术的实现利用了自动覆盖和交换技术。简单的说就是将硬盘的一部分作为内存来使用。

   虚拟地址空间：在32位的i386CPU的地址总线的是32位的，也就是说可以寻找到4G的地址空间。我们的程序被CPU执行，就是在0x00000000到0xFFFFFFFF这一段地址中。高2G的空间为内核空间，由操作系统调用，低2G的空间为用户空间，由用户使用。

   CPU在寻址的时候，是按照虚拟地址来寻址，然后通过MMU(内存管理单元)将虚拟地址转换为物理地址。因为只有程序的一部分加入到内存中，所以会出现所寻找的地址不在内存中的情况（CPU产生缺页异常），如果在内存不足的情况下，就会通过页面调度算法来将内存中的页面置换出来，然后将在外存中的页面加入到内存中，使程序继续正常运行。

SWAP交换分区

   可以看出，虚拟地址空间和虚拟内存的一个关键的因素是MMU（内存管理单元）。

   现在一个程序的执行现在可以分为3部分：

   1：CPU需要执行的语句的虚拟地址。

   2：程序装入内存的部分

   3：程序再外存中的部分

   因为CPU是通过时间片轮转的方法使不同的程序并发执行的。所以在某一时刻只有一个程序占据CPU资源，CPU的最大的寻址空间为4G，所以说可以将每个程序可以看做独立占据4G的内存（只是可以看成，但是它并没有占据实际的4G内存）。而CPU是将虚拟地址空间里面的代码执行，如果在内存中寻找不到所需要的页面，就需要到外存中寻找，外存的这一部分，我们可以当成内存来使用，这也就是虚拟内存。虚拟地址空间不等于虚拟内存。虚拟地址空间是一个空间，不是真正存在的，只是通过CPU的寻址虚拟出来的一个范围。而虚拟内存是实实在在的硬盘的空间。

   我看到了一个比较形象的比喻，假设4G个门牌号（4G的虚拟地址空间，并将这4G的虚拟空间进行分页），但是房子的数量（内存）少于门牌号的数量（4G的虚拟空间），那样就先把每个房子（内存）上挂一个门牌号（页），如果你要找一个门牌号(页)，就需要查找每个房子（内存），如果这个门牌号没有挂（页还没有被加入到内存中），那么就将一个房子的门牌号（页面置换到外存）摘下来，把你找的那个门牌号挂上（将外存的页加入内存），这样就找到了需要的门牌号（页）。

   这是我将这个比喻综合了一下。CPU只需要说找哪一个页面，MMU就将这个页面翻译成物理地址，再通过页面调度机制来讲不在内存中的页加入到内存中。

   我认为计算机使用的是一种各司其职的方法。

   CPU老大只需要要虚拟地址中的一页，范围在0x00000000到0xFFFFFFFF，因为他的地址总线是32位，4G是他最大的能力，然后他就把任务分配给他的手下，CPU不需要知道他的手下是如何找到这一页，他只负责去要这一页和执行这些代码，然后他就和他的手下说“有招想去，没招死去”，他的手下必须要能找到这一页，然后内存非常有限，而CPU不管这个，只需要你能找到这一页让我执行就好，所以CPU的手下就将硬盘中的一部分当做内存，然后拿来骗CPU说，“这是我从内存中找到的”，然后CPU就去运行。如果访问的地方实在是不能找到，或者是没有权限，那么这个程序就真死了。程序员在开发的时候，因为程序员所编写的代码最终是要让CPU去执行，所以程序员也理所应当认为我有4G的内存空间，程序员把程序交给CPU，CPU就交给他手下。

   所以说，他们每一层都不需要管对方是如何办到的，他们在乎的只有结果。他们各司其职，CPU认为我有4G内存空间的原因是因为CPU的地址总线为32位，最大的寻址能力是4G，而内存没有这个大，所以它想出来的办法是将硬盘的一部分拿来骗CPU，并给这块骗人的地方起了一个好名字，虚拟内存。这就是我的理解中的虚拟内存空间和虚拟内存的概念。

   自身水平有限，希望大家矫正，谢谢！


==================================================================================================================================================================================================================
程序访问存储器所使用的逻辑地址称为虚拟地址，虚拟地址 (virtual address): 4G虚拟地址空间中的地址，程序中使用的都是虚拟地址。每一个进程都分配有一个4G的虚拟地址。通过虚拟地址访问内存的形式称为保护模式，因为它不允许直接访问内核空间，而对应的直接访问物理内存的方式称为实模式，现在已经很少使用。　　比如 mov eax,004227b8h ，这是把地址004227b8h处的值赋给寄存器的汇编代码，004227b8这个地址就是虚拟址。CPU在执行这行代码时，发现寄存器中的分页标志位已经被设定，就自动完成虚拟地址到物理地址的转换，使用物理地址取出值，完成指令。

　　使用了分页机制之后，4G的地址空间被分成了固定大小的页，每一页或者被映射到物理内存，或者被映射到硬盘上的交换文件中，或者没有映射任何东西。CPU用来把虚拟地址转换成物理地址的信息存放在叫做页目录和页表的结构里，使用cpu中的MMU（内存管理单元）转换。

由于每个进程有自己的页目录和页表，所以每个进程的地址空间映射的物理内存是不一样的。两个进程的同一个虚拟地址处（如果都有物理内存映射）的值一般是不同的，因为他们往往对应不同的物理页。

而虚拟内存和虚拟地址几乎没有关系，前者就是拿硬盘空间当做内存空间欺骗进程。


===============================================================================================================================================================================================================================================================================================================
32位机器，每个程序有4G的虚拟地址空间。大致分为4块，从低地址到高地址依次是：NULL区，用户区，隔离区，核心区。用户私有的数据都在用户区（当然这个区里又可以细分，其中也包括一部分可以共享的内容），系统内核等东西都在核心区。
====================================================================================================================================================================================================================================================================================================================================================================================================================

SWAP就是LINUX下的虚拟内存分区,它的作用是在物理内存使用完之后,将磁盘空间(也就是SWAP分区)虚拟成内存来使用.它和Windows系统的交换文件作用类似，但是它是一段连续的磁盘空间，并且对用户不可见。
SWAP就是LINUX下的虚拟内存分区,它的作用是在物理内存使用完之后,将磁盘空间(也就是SWAP分区)虚拟成内存来使用.
它和Windows系统的交换文件作用类似，但是它是一段连续的磁盘空间，并且对用户不可见。
需要注意的是,虽然这个SWAP分区能够作为"虚拟"的内存,但它的速度比物理内存可是慢多了,因此如果需要更快的速度的话,并不能寄厚望于SWAP,最好的办法仍然是加大物理内存.SWAP分区只是临时的解决办法.
qlinux下得分区推荐一个交换分区，一个根分区,其中交换分区如上所说作为redhat或者其它虚机所划分的内存不够时候来使用！
交换分区（swap）的合理值一般在内存的2 倍左右，可以适当加大。实际上具体还是以实际应用为准，swap为内存的2倍也不过是一种以讹传讹的说法。如果交换分区的使用都超过4GB以上了，可想而知服务器的性能应该差很多了。
Linux下可以创建两种类型的交换空间，一种是swap分区，一种是swap文件。前者适合有空闲的分区可以使用，后者适合于没有空的硬盘分区，硬盘的空间都已经分配完毕。

===============================================================================================================================================================================================================================================================================================================


虚拟内存是计算机系统内存管理的一种技术。它使得应用程序认为它拥有连续的可用的内存（一个连续完整的地址空间），而实际上，它通常是被分隔成多个物理内存碎片，还有部分暂时存储在外部磁盘存储器上，在需要时进行数据交换。目前，大多数操作系统都使用了虚拟内存，如Windows家族的“虚拟内存”；Linux的“交换空间”等。


====================================================================================================================================================================================================================================================================================================================================================================================================================




如果函数接口有指针参数，既可以把指针所指向的数据传给函数使用（称为传入参数），也可以由函数填充指针所指的内存空间，传回给调用者使用（称为传出参数），例如strcpy的函数原型为

 

[cpp] view plain copy
  1. char *strcpy(char *dest, const char *src);  

其中src参数是传入参数，dest参数是传出参数。有些函数的指针参数同时担当了这两种角色，如select函数。其函数原型为：
[cpp] view plain copy
  1. int select(int nfds, fd_set *readfds,fd_set *writefds,  
  2.         fd_set *exceptfds, struct timeval*timeout);  

其中的fd_set *参数，既是传入参数又是传出参数，这称为Value-result参数。

 

传入参数示例：

假如我们实现一个函数，其参数通过地址来传入一个值，其原型如下：

[cpp] view plain copy
  1. void func(const unit_t *p);  

其调用者与实现者之间的协议如下：

调用者

实现者

1、分配p所指的内存空间；

2、在p所指的内存空间中保存数据；

3、调用函数；

4、由于有const限定符，调用者可以确信p所指的内存空间不会被改变。

1、规定指针参数的类型unit_t *；

2、读取p所指的内存空间。

 

 

传出参数示例：

假如我们实现一个函数，其参数通过地址传出一个值，其原型如下：

 

[cpp] view plain copy
  1. void func(unit_t *p);  

 

其调用者与实现者之间的协议如下：

调用者

实现者

1、分配p所指的内存空间

2、调用函数

3、读取p所指的内存空间

1、规定指针参数的类型unit_t *

2、在p所指的内存空间中保存数据

 

 

 

Value-result参数示例：

 

[cpp] view plain copy
  1. void func(unit_t *p);  

其调用者与实现者之间的协议如下：

调用者

实现者

1、分配p所指的内存空间

2、在p所指的内存空间保存数据

3、调用函数

4、读取p所指的内存空间

1、规定指针参数的类型unit_t *

2、读取p所指的内存空间

3、改写p所指的内存空间

 

注意：由于传出参数和Value-result参数的函数接口完全相同，应该在文档中说明是哪种参数。

很多系统函数对于指针参数是NULL的情况有特殊规定：如果传入参数是NULL表示取缺省值，例如pthread_create(3)的pthread_attr_t *参数，也可能表示不做特别处理，例如free的参数；如果传出参数是NULL表示调用者不需要传出值，例如time(2)的参数。这些特殊规定应该在文档中写清楚。

下面是一个传出参数的完整例子：

 

[cpp] view plain copy
  1. /* populator.h */  
  2. #ifndef POPULATOR_H  
  3. #define POPULATOR_H  
  4. typedef struct {  
  5.     int number;  
  6.     char msg[20];  
  7. } unit_t;  
  8. extern void set_unit(unit_t *);  
  9. #endif  

[cpp] view plain copy
  1. /* populator.c */  
  2. #include <string.h>  
  3. #include "populator.h"  
  4. void set_unit(unit_t *p)  
  5. {  
  6.     if (p == NULL)  
  7.          return; /* ignore NULL parameter */  
  8.     p->number = 3;  
  9.     strcpy(p->msg, "Hello World!");  
  10. }  


[cpp] view plain copy
  1. /* main.c */  
  2. #include <stdio.h>  
  3. #include "populator.h"  
  4. int main(void)  
  5. {  
  6.     unit_t u;  
  7.     set_unit(&u);  
  8.     printf("number: %d\nmsg: %s\n", u.number, u.msg);  
  9.     return 0;  
  10. }  


二级指针的参数：

二级指针也是指针，同样可以表示传入参数、传出参数或者Value-result参数，只不过该参数所指的内存空间应该解释成一个指针变量。用两层指针做传出参数的系统函数也很常见，比如pthread_join(3)的void **参数。下面看一个简单的例子。

 

二级指针做传出参数

 

[cpp] view plain copy
  1. /* redirect_ptr.h */  
  2. #ifndef REDIRECT_PTR_H  
  3. #define REDIRECT_PTR_H  
  4. extern void get_a_day(const char **);  
  5. #endif  

 

这里的参数指针是const char **，有const限定符，却不是传入参数而是传出参数。

 

[cpp] view plain copy
  1. /* redirect_ptr.c */  
  2. #include "redirect_ptr.h"  
  3.    
  4. static const char *msg[] ={"Sunday", "Monday", "Tuesday","Wednesday",  
  5.                             "Thursday","Friday", "Saturday"};  
  6. void get_a_day(const char **pp)  
  7. {  
  8.     static int i = 0;  
  9.     *pp = msg[i%7];  
  10.     i++;  
  11. }  

[cpp] view plain copy
  1. /* main.c */  
  2. #include <stdio.h>  
  3. #include "redirect_ptr.h"  
  4.    
  5. int main(void)  
  6. {  
  7.     const char *firstday = NULL;  
  8.     const char *secondday = NULL;  
  9.     get_a_day(&firstday);  
  10.     get_a_day(&secondday);  
  11.     printf("%s\t%s\n", firstday, secondday);  
  12.     return 0;  
  13. }  

二级指针作为传出参数还有一种特别的用法，可以在函数中分配内存，调用者通过传出参数取得指向该内存的指针，一般来说，实现一个分配内存的函数就要实现一个释放内存的函数。

 

通过参数分配内存示例：

 

[cpp] view plain copy
  1. void alloc_unit(unit_t **pp);  
  2. void free_unit(unit_t *p);  

其调用者与实现者之间的协议如下：

调用者

实现者

1、分配pp所指的指针变量的空间；

2、调用alloc_unit分配内存；

3、读取pp所指的指针变量，通过后者使用alloc_unit分配的内存；

4、调用free_unit释放内存。

1、规定指针参数的类型unit_t **；

2、alloc_unit分配unit_t的内存并初始化，为pp所指的指针变量赋值；

3、free_unit释放在alloc_unit中分配的内存

 

下面是一个通过二级指针参数分配内存的例子


[cpp] view plain copy
  1. /* para_allocator.h */  
  2. #ifndef PARA_ALLOCATOR_H  
  3. #define PARA_ALLOCATOR_H  
  4. typedef struct {  
  5.     int number;  
  6.     char *msg;  
  7. } unit_t;  
  8.    
  9. extern void alloc_unit(unit_t **);  
  10. extern void free_unit(unit_t *);  
  11.    
  12. #endif  
[cpp] view plain copy
  1. /* para_allocator.c */  
  2. #include <stdio.h>  
  3. #include <string.h>  
  4. #include <stdlib.h>  
  5. #include "para_allocator.h"  
  6.    
  7. void alloc_unit(unit_t **pp)  
  8. {  
  9.     unit_t *p = malloc(sizeof(unit_t));  
  10.     if(p == NULL) {  
  11.            printf("out of memory\n");  
  12.            exit(1);  
  13.     }  
  14.     p->number = 3;  
  15.     p->msg = malloc(20);  
  16.     strcpy(p->msg, "Hello World!");  
  17.     *pp = p;  
  18. }  
  19.    
  20. void free_unit(unit_t *p)  
  21. {  
  22.     free(p->msg);  
  23.     free(p);  
  24. }  

[cpp] view plain copy
  1. /* main.c */  
  2. #include <stdio.h>  
  3. #include "para_allocator.h"  
  4.    
  5. int main(void)  
  6. {  
  7.     unit_t *p = NULL;  
  8.    
  9.     alloc_unit(&p);  
  10.     printf("number: %d\nmsg: %s\n", p->number, p->msg);  
  11.      free_unit(p);  
  12.     p = NULL;  
  13.     return 0;  
  14. }  

二级指针参数如果是传出的，可以有两种情况：

第一种情况，传出的指针指向静态内存（比如上面的例子），或者指向已分配的动态内存（比如指向某个链表的节点）；

第二种情况是在函数中动态分配内存，然后传出的指针指向这块内存空间，这种情况下调用者应该在使用内存之后调用释放内存的函数，调用者的责任是请求分配和请求释放内存，实现者的责任是完成分配内存和释放内存的操作。由于这两种情况的函数接口相同，我们在撰写文档或添加注释时应该说明是哪一种情况。

  

返回值是指针的情况

返回值显然是传出的而不是传入的，如果返回值传出的是指针，和通过参数传出指针的情况类似，也分为两种情况：

第一种是传出指向静态内存或已分配的动态内存的指针；

第二种是在函数中动态分配内存并传出指向这块内存的指针，这种情况通常还要实现一个释放内存的函数，所以有和malloc对应的free。由于这两种情况的函数接口相同，应该在文档中说明是哪一种情况。

 

返回指向已分配内存的指针示例：

 

[cpp] view plain copy
  1. unit_t *func(void);  

其调用者与实现者之间的协议如下：

调用者

实现者

1、调用函数

2、将返回值保存下来以备后用

1、规定返回值指针的类型unit_t *

2、返回一个指针

 

 

下面的例子演示返回指向已分配内存的指针

 

[cpp] view plain copy
  1. /* ret_ptr.h */  
  2. #ifndef RET_PTR_H  
  3. #define RET_PTR_H  
  4.    
  5. extern char *get_a_day(int idx);  
  6.    
  7. #endif  
[cpp] view plain copy
  1. /* ret_ptr.c */  
  2. #include <string.h>  
  3. #include "ret_ptr.h"  
  4.    
  5. static const char *msg[] = {"Sunday","Monday", "Tuesday", "Wednesday",  
  6.                             "Thursday","Friday", "Saturday"};  
  7.    
  8. char *get_a_day(int idx)  
  9. {  
  10.     return msg[idx];  
  11. }  
[cpp] view plain copy
  1. /* main.c */  
  2. #include <stdio.h>  
  3. #include "ret_ptr.h"  
  4.    
  5. int main(void)  
  6. {  
  7.     printf("%s %s\n", get_a_day(0));  
  8.     return 0;  
  9. }  

动态分配内存并返回指针示例：

 

[cpp] view plain copy
  1. unit_t *alloc_unit(void); voidfree_unit(unit_t *p);  

其调用者与实现者之间的协议如下：

调用者

实现者

1、调用alloc_unit分配内存；

2、将返回值保存下来以备后用；

3、调用free_unit释放内存。

 

1、规定返回值指针的类型unit_t *；

2、alloc_unit分配内存并返回指向该内存的指针；

3、free_unit释放由alloc_unit分配的内存。

 

 

 

以下是一个完整动态分配内存并返回指针的例子

 

[cpp] view plain copy
  1. /* ret_allocator.h */  
  2. #ifndef RET_ALLOCATOR_H  
  3. #define RET_ALLOCATOR_H  
  4.    
  5. typedef struct {  
  6.     int number;  
  7.     char *msg;  
  8. } unit_t;  
  9. extern unit_t *alloc_unit(void);  
  10. extern void free_unit(unit_t *);  
  11.    
  12. #endif  
[cpp] view plain copy
  1. /* ret_allocator.c */  
  2. #include <stdio.h>  
  3. #include <string.h>  
  4. #include <stdlib.h>  
  5. #include "ret_allocator.h"  
  6.    
  7. unit_t *alloc_unit(void)  
  8. {  
  9.     unit_t *p = malloc(sizeof(unit_t));  
  10.     if(p == NULL) {  
  11.            printf("out of memory\n");  
  12.            exit(1);  
  13.     }  
  14.     p->number = 3;  
  15.     p->msg = malloc(20);  
  16.     strcpy(p->msg, "Hello world!");  
  17.     return p;  
  18. }  
  19.    
  20. void free_unit(unit_t *p)  
  21. {  
  22.     free(p->msg);  
  23.     free(p);  
  24. }  
[cpp] view plain copy
  1. /* main.c */  
  2. #include <stdio.h>  
  3. #include "ret_allocator.h"  
  4.    
  5. int main(void)  
  6. {  
  7.     unit_t *p = alloc_unit();  
  8.    
  9.     printf("number: %d\nmsg: %s\n", p->number, p->msg);  
  10.     free_unit(p);  
  11.     p = NULL;  
  12.     return 0;  
  13. } 
====================================================================================================================================================================================================================================================================================================================================================================================================================

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode