c语言:题目：利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来?下面是答案！_百度知道
c语言:题目：利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来?下面是答案！
函数每被调用一次，都会分配一段专门给被调函数使用的栈空间，被调函数的局部变量就在这段栈空间里分配空间，所以即便像递归调用这种主调函数和被调函数是同一函数的情况，栈里面是分别有独立的栈空间的，相应的局部变量也有独立的内存空间，所以，以这个例子来说，主调函数的局部变量n和被调函数的局部变量n是有不同的内存空间的，不会相互冲突，主调函数的n被赋值，不影响被调函数对n赋值。
其他类似问题
为您推荐：
递归函数的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁页面导航：
→ 正文内容 C语言 递归算法
对C语言中递归算法的深入解析
C通过运行时堆栈支持递归函数的实现。递归函数就是直接或间接调用自身的函数
许多教科书都把计算机阶乘和菲波那契数列用来说明递归，非常不幸我们可爱的著名的老潭老师的《C语言程序设计》一书中就是从阶乘的计算开始的函数递归。导致读过这本经书的同学们，看到阶乘计算第一个想法就是递归。但是在阶乘的计算里，递归并没有提供任何优越之处。在菲波那契数列中，它的效率更是低的非常恐怖。
这里有一个简单的程序，可用于说明递归。程序的目的是把一个整数从二进制形式转换为可打印的字符形式。例如：给出一个值4267，我们需要依次产生字符‘4'，‘2'，‘6'，和‘7'。就如在printf函数中使用了%d格式码，它就会执行类似处理。
我们采用的策略是把这个值反复除以10，并打印各个余数。例如，4267除10的余数是7，但是我们不能直接打印这个余数。我们需要打印的是机器字符集中表示数字‘7'的值。在ASCII码中，字符‘7'的值是55，所以我们需要在余数上加上48来获得正确的字符，但是，使用字符常量而不是整型常量可以提高程序的可移植性。‘0'的ASCII码是48，所以我们用余数加上‘0'，所以有下面的关系：
&&&&&&&&& ‘0'+ 0 =‘0'&&&&&&&&& ‘0'+ 1 =‘1'&&&&&&&&& ‘0'+ 2 =‘2'&&&&& &&& ...从这些关系中，我们很容易看出在余数上加上‘0'就可以产生对应字符的代码。接着就打印出余数。下一步再取商的值，4267/10等于426。然后用这个值重复上述步骤。
这种处理方法存在的唯一问题是它产生的数字次序正好相反，它们是逆向打印的。所以在我们的程序中使用递归来修正这个问题。
我们这个程序中的函数是递归性质的,因为它包含了一个对自身的调用。乍一看，函数似乎永远不会终止。当函数调用时，它将调用自身，第2次调用还将调用自身，以此类推，似乎永远调用下去。这也是我们在刚接触递归时最想不明白的事情。但是，事实上并不会出现这种情况。
这个程序的递归实现了某种类型的螺旋状while循环。while循环在循环体每次执行时必须取得某种进展，逐步迫近循环终止条件。递归函数也是如此，它在每次递归调用后必须越来越接近某种限制条件。当递归函数符合这个限制条件时，它便不在调用自身。
在程序中，递归函数的限制条件就是变量quotient为零。在每次递归调用之前，我们都把quotient除以10，所以每递归调用一次，它的值就越来越接近零。当它最终变成零时，递归便告终止。
/*接受一个整型值（无符号0，把它转换为字符并打印它，前导零被删除*/
代码如下:#include &stdio.h&
int binary_to_ascii( unsigned int value){&&&&&&&&& u&& quotient = value / 10;&& if( quotient != 0)&&&&&& binary_to_ascii( quotient);&& putchar ( value % 10 + '0' );}递归是如何帮助我们以正确的顺序打印这些字符呢？下面是这个函数的工作流程。1. 将参数值除以102. 如果quotient的值为非零，调用binary-to-ascii打印quotient当前值的各位数字3. 接着，打印步骤1中除法运算的余数
注意在第2个步骤中，我们需要打印的是quotient当前值的各位数字。我们所面临的问题和最初的问题完全相同，只是变量quotient的值变小了。我们用刚刚编写的函数（把整数转换为各个数字字符并打印出来）来解决这个问题。由于quotient的值越来越小，所以递归最终会终止。
一旦你理解了递归，阅读递归函数最容易的方法不是纠缠于它的执行过程，而是相信递归函数会顺利完成它的任务。如果你的每个步骤正确无误，你的限制条件设置正确，并且每次调用之后更接近限制条件，递归函数总是能正确的完成任务。
但是，为了理解递归的工作原理，你需要追踪递归调用的执行过程，所以让我们来进行这项工作。追踪一个递归函数的执行过程的关键是理解函数中所声明的变量是如何存储的。当函数被调用时，它的变量的空间是创建于运行时堆栈上的。以前调用的函数的变量扔保留在堆栈上，但他们被新函数的变量所掩盖，因此是不能被访问的。
当递归函数调用自身时，情况于是如此。每进行一次新的调用，都将创建一批变量，他们将掩盖递归函数前一次调用所创建的变量。当我追踪一个递归函数的执行过程时，必须把分数不同次调用的变量区分开来，以避免混淆。
程序中的函数有两个变量：参数value和局部变量quotient。下面的一些图显示了堆栈的状态，当前可以访问的变量位于栈顶。所有其他调用的变量饰以灰色的阴影，表示他们不能被当前正在执行的函数访问。
假定我们以4267这个值调用递归函数。当函数刚开始执行时，堆栈的内容如下图所示：
执行除法之后，堆栈的内容如下：
接着，if语句判断出quotient的值非零，所以对该函数执行递归调用。当这个函数第二次被调用之初，堆栈的内容如下：
堆栈上创建了一批新的变量，隐藏了前面的那批变量，除非当前这次递归调用返回，否则他们是不能被访问的。再次执行除法运算之后，堆栈的内容如下：
quotient的值现在为42，仍然非零，所以需要继续执行递归调用，并再创建一批变量。在执行完这次调用的出发运算之后，堆栈的内容如下：
此时，quotient的值还是非零，仍然需要执行递归调用。在执行除法运算之后，堆栈的内容如下：
不算递归调用语句本身，到目前为止所执行的语句只是除法运算以及对quotient的值进行测试。由于递归调用这些语句重复执行，所以它的效果类似循环：当quotient的值非零时，把它的值作为初始值重新开始循环。但是，递归调用将会保存一些信息（这点与循环不同），也就好是保存在堆栈中的变量值。这些信息很快就会变得非常重要。
现在quotient的值变成了零，递归函数便不再调用自身，而是开始打印输出。然后函数返回，并开始销毁堆栈上的变量值。
每次调用putchar得到变量value的最后一个数字，方法是对value进行模10取余运算，其结果是一个0到9之间的整数。把它与字符常量‘0'相加，其结果便是对应于这个数字的ASCII字符，然后把这个字符打印出来。
接着函数返回，它的变量从堆栈中销毁。接着，递归函数的前一次调用重新继续执行，她所使用的是自己的变量，他们现在位于堆栈的顶部。因为它的value值是42，所以调用putchar后打印出来的数字是2。
接着递归函数的这次调用也返回，它的变量也被销毁，此时位于堆栈顶部的是递归函数再前一次调用的变量。递归调用从这个位置继续执行，这次打印的数字是6。在这次调用返回之前，堆栈的内容如下：
现在我们已经展开了整个递归过程，并回到该函数最初的调用。这次调用打印出数字7，也就是它的value参数除10的余数。
输出4267：
然后，这个递归函数就彻底返回到其他函数调用它的地点。如果你把打印出来的字符一个接一个排在一起，出现在打印机或屏幕上，你将看到正确的值：4267使用递归一定要有跳出的条件:这是一个最简单的递归, 不过它会一直执行, 可用 Ctrl+C 终止. 代码如下:#include &stdio.h&void prn(int num) {&&& printf("%d/n", num);&&& if (num & 0) prn(--num);& }int main(void){&&& prn(9);&&& getchar();&&& return 0;} 代码如下:实例: 翻转字符串#include &stdio.h&void revers(char *cs);int main(void){&&& revers("");&&& getchar();&&& &&& return 0;}void revers(char *cs){&&& if (*cs)&&& { &&&&&&& revers(cs + 1);&&&&&&& putchar(*cs);&&& }} 代码如下:实例: 阶乘#include &stdio.h&int factorial(int num);int main(void){&&&&&& for (i = 1; i &= 9; i++)&&& printf("%d: %d/n", i, factorial(i));&&& getchar();&&& &&& return 0;}int factorial(int num){&&& if (num == 1)&&&&&&& return(1);&&& else&&&&&&& return(num * factorial(num-1));} 代码如下:实例: 整数到二进制#include &stdio.h&void IntToBinary(unsigned num);int main(void){&&& IntToBinary(255); /*
*/&&& getchar();&&& return 0;}void IntToBinary(unsigned num) {&&& int i = num % 2;&&& if (num & 1) IntToBinary(num / 2);&&& putchar(i ? '1' : '0'); //&&& putchar('0' + i);& /* 可代替上面一句 */} 代码如下:剖析递归:#include &stdio.h&void prn(unsigned n);int main(void){&&& prn(1);&&& getchar();&&& return 0;}void prn(unsigned n) {&&& printf("%d: %p/n", n, &n);& /* A */&&& if (n & 4) &&&&&&& prn(n+1);&&&&&&&&&&&&&& /* B */&&& printf("%d: %p/n", n, &n);& /* C */}例输出效果图:
分析:程序运行到 A, 输出了第一行.此时 n=1, 满足 & 4 的条件, 继续执行 B 开始了自调用(接着会输出第二行); 注意 n=1 时语句 C 还有待执行....如此循环, 一直到 n=4, A 可以执行, 但因不满足条件 B 执行不了了; 终于在 n=4 时得以执行 C.但此时内存中有四个函数都等待返回(分别是 n=1、2、3、4 时), 咱们分别叫它 f1、f2、f3、f4.f4 执行 C 输出了第五行, 函数返回, 返回给 f3(此时 n=3), f3 得以继续执行 C, 输出了第六行.f3 -& f2 -& 继续 C, 输出了第七行.f2 -& f1 -& 继续 C, 输出了第八行, 执行完毕!
如此看来, 递归函数还是很费内存的(有时不如直接使用循环), 但的确很巧妙.
您可能感兴趣的文章:
上一篇：下一篇：
最 近 更 新
热 点 排 行
12345678910c语言堆栈问题 -
yomica - 红豆博客
用户ID：& 130193
用户名：& wa86mwi08
c语言堆栈问题
c语言堆栈问题 5 C语言程序编译的内存分配： 1.栈区（stack） --编译器自动分配释放，主要存放函数的参数值，局部变量值等； 2.堆区（heap） --由程序员分配释放； 3.全局区或静态区 --存放全局变量和静态变量；程序结束时由系统释放，分为全局初始化区和全局未初始化区； 4.字符常量区 --常量字符串放与此，程序结束时由系统释放； 5.程序代码区--存放函数体的二进制代码 例： //main.c int a=0; //全局初始化区 char *p1; //全局未初始化区 void main() { //栈 char s[]="bb"; //栈 char *p2; //栈 char *p3="123"; //其中，“123\0”常量区，p3在栈区 static int c=0; //全局区 p1=(char*)malloc(10); //10个字节区域在堆区 strcpy(p1,"123"); //"123\0"在常量区，编译器 可能 会优化为和p3的指向同一块区域 ｝ 一个C程序占用的内存可分为以下几类： (一) 栈 这是由编译器自动分配和释放的区域。主要存储函数的参数，函数的局部变量等。当一个函数开始执行时，该函数所需的实参，局部变量就推入栈中，该函数执行完毕后，之前进入栈中的参数和变量等也都出栈被释放掉。它的运行方式类似于数据结构中的栈。 (二) 堆 这是由程序员控制分配和释放的区域，在C里，用malloc()函数分配的空间就存在于堆上。在堆上分配的空间不像栈一样在某个函数执行完毕就自动释放，而是一直存在于整个程序的运行期间。当然，如果你不手动释放(free()函数)这些空间，在程序运行结束后系统也会将之自动释放。对于小程序来说可能感觉不到影响的存在，但对于大程序，例如一个大型游戏，就会遇到内存不够用的问题了 (三) 全局区 C里的全局变量和静态变量存储在全局区。它们有点像堆上的空间，也是持续存在于程序的整个运行期间，但不同的是，他们是由编译器自己控制分配和释放的。 (四) 文字常量区 例如char *c = “123456”；则”123456”为文字常量，存放于文字常量区。也由编译器控制分配和释放。 (五) 程序代码区 存放函数体的二进制代码。 2． 例子(一) int a = 0; //全局区 void main() { //栈 char s[] = "abc"; //s在栈,"abc"在文字常量区 char *p1,*p2; //栈 char *p3 = "123456"; //"123456"在常量区，p3在栈上 static int c =0; //全局区 p1 = (char *)malloc(10); //p1在栈，分配的10字节在堆 p2 = (char *)malloc(20); //p2在栈，分配的20字节在堆 strcpy(p1, "123456"); //"123456"放在常量区 //编译器可能将它与p3所指向的"123456"优化成一个地方。 } 3． 例子(二) //返回char型指针 char *f() { //s数组存放于栈上 char s[4] = {'1','2','3','0'}; //返回s数组的地址，但程序运行完s数组就被释放了 } void main() { char *s; s = f(); printf ("%s", s); //打印出来乱码。因为s所指向地址已经没有数据 } 还有就是函数调用时会在栈上有一系列的保留现场及传递参数的操作。 栈的空间大小有限定，vc的缺省是2M。栈不够用的情况一般是程序中分配了大量数组和递归函数层次太深。有一点必须知道，当一个函数调用完返回后它会释放该函数中所有的栈空间。栈是由编译器自动管理的，不用你操心。 堆是动态分配内存的，并且你可以分配使用很大的内存。但是用不好会产生内存泄漏。并且频繁地malloc和free会产生内存碎片（有点类似磁盘碎片），因为C分配动态内存时是寻找匹配的内存的。而用栈则不会产生碎片，在栈上存取数据比通过指针在堆上存取数据快些。一般大家说的堆栈和栈是一样的，就是栈(stack)，而说堆时才是堆heap.栈是先入后出的，一般是由高地址向低地址生长。 堆(heap)和栈(stack)是C/C++编程不可避免会碰到的两个基本概念。首先，这两个概念都可以在讲数据结构的书中找到，他们都是基本的数据结构，虽然栈更为简单一些。在具体的C/C++编程框架中，这两个概念并不是并行的。对底层机器代码的研究可以揭示，栈是机器系统提供的数据结构，而堆则是C/C++函数库提供的。具体地说，现代计算机(串行执行机制)，都直接在代码底层支持栈的数据结构。这体现在，有专门的寄存器指向栈所在的地址，有专门的机器指令完成数据入栈出栈的操作。种机制的特点是效率高，支持的数据有限，一般是整数，指针，浮点数等系统直接支持的数据类型，并不直接支持其他的数据结构。因为栈的这种特点，对栈的使用在程序中是非常频繁的。对子程序的调用就是直接利用栈完成的。机器的call指令里隐含了把返回地址推入栈，然后跳转至子程序地址的操作，而子程序中的ret指令则隐含从堆栈中弹出返回地址并跳转之的操作。C/C++中的自动变量是直接利栈的例子，这也就是为什么当函数返回时，该函数的自动变量自动失效的原因。 和栈不同，堆的数据结构并不是由系统(无论是机器系统还是操作系统)支持的，而是由函数库提供的。基本的malloc/realloc/free函数维护了一套内部的堆数据结构。当程序使用这些函数去获得新的内存空间时，这套函数首先试图从内部堆中寻找可用的内存空间，如果没有可以使用的内存空间，则试图利用系统调用来动态增加程序数据段的内存大小，新分配得到的空间首先被组织进内部堆中去，然后再以适当的形式返回给调用者。当程序释放分配的内存空间时，这片内存空间被返回内部堆结构中，可能会被适当的处理(比如和其他空闲空间合并成更大的空闲空间)，以更适合下一次内存分配申请。这套复杂的分配机制实际上相当于一个内存分配的缓冲池(Cache)，使用这套机制有如下若干原因： 1. 系统调用可能不支持任意大小的内存分配。有些系统的系统调用只支持固定大小及其倍数的内存请求(按页分配)；这样的话对于大量的小内存分类来说会造成浪费。 2. 系统调用申请内存可能是代价昂贵的。系统调用可能涉及用户态和核心态的转换。 3. 没有管理的内存分配在大量复杂内存的分配释放操作下很容易造成内存碎片 堆和栈的对比 从以上知识可知，栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；而堆是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率有一定降低。栈是系统数据结构，对于进程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。不同堆分配的内存无法互相操作。栈空间分静态分配和动态分配两种。静态分配是编译器完成的，比如自动变量(auto)的分配。动态分配由alloca函数完成。栈的动态分配无需释放(是自动的)，也就没有释放函数。为可移植的程序起见，栈的动态分配操作是不被鼓励的！堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/释放内存匹配是良好程序的基本要素。 引言：对于指针，正确的分配动态内存是十分重要的，本文将着重阐述动态内存分配函数malloc,calloc,realloc以及memset的用法。 一、对于malloc,在终端输入 #:man
malloc可以知道函数原型是： Void *calloc(size_t
size) ,包含在库函数 stdlib.h中，作用是在内存的堆区分配一个大小为size的连续空间，如果分配内存成功，函数返回新分配内存的首地址，否则，返回NULL，注意：鉴于上述这点，一般在写程序需要判断分配内存是否成功，如下程序语句： int
*p; p=(int *)malloc(sizeof(int)); if(p!=NULL) .................................//需要执行的语句 else .........................//打印分配内存不成功出错信息 通常造成内存分配失败的原因如下： 1、 内存访问越界 2、 所需连续的内存空间不足 二、对于函数calloc用法大致与malloc相同，函数原型为： void *callo(size_t
num,size_t
size),作用是在内存中分配连续大小为num*size的空间，这一点在动态数组内存分配有所体现，返回值以及判断返回是否成功与上面相同，下面重点来讨论malloc与calloc区别： （2）calloc函数 函数原型：void *calloc(unsigned n,unsigned size) 功能：在内存的动态存储区中分配n个长度为size字节的连续空间。返回值为所分配存储区的起始地址，分配不成功则返回NULL。 例如：char *p; p=(char *)calloc(2,20); 【说明】表示分配2块大小为20个字节的连续存储空间并进行强制类型转换，p代表首地址。 【注意】与malloc函数相比，calloc函数可以一次分配n块区域。？？？？？？ 1、后者在返回指向内存的指针之前把它初始化为0。 2、请求内存数量的方式不同。malloc的参数仅仅是需要分配的内存字节数；calloc的参数包括元素的数量和每个元素的字节数。 为了说明第一点,请看如下程序： 程序在第6行动态为指针p动态分配了内存, 经过gcc编译，运行结果如下： 注意：6593第一行数据 由图可以看出红色标记部分，并没有初始化为零，也就是说在这个单元存在随机数，这样程序在运行时可能会出错。将上面的程序用calloc来调用，程序如下： 见上述程序第6行，用calloc来代替malloc分配内存单元，运行结果如下： 注意：全为0 可以看出在用calloc申请内存时将内存都初始化为0了。那么有没有用办法用malloc同时又将内存初始化为0呢？答案是有的，用memset可以实现这一功能将第一个程序做相应改动，程序如下： 在第七行添加了语句注意：正确的应该是 memset（p,0,100*sizeof(int)）,这条语句的意思是在内存单元p所指向的100个内存单元都赋值为0，相当与初始化内存。此时在运行此程序将不会再出现形如上述红色标记部分的结果。注意：当是0或-1是，输出结果是0和-1，其他得数输出时和自己给的值不一样，如1时输出？？？？？？？？ 三、对于realloc（），函数原型是*void realloc(void
*ptr,size_t
size),改变ptr所指内存区域的大小为size长度,如果重新分配成功则返回指向被分配内存的指针，否则返回空指针NULL。当内存不再使用时，应使用free()函数将内存块释放。有一点需要注意：当分配内存成功之后，应将原本的指针ptr=NULL,否则会形成野指针，可能造成系统崩溃。 提示：不论是以上那种方式申请内存，在申请内存之后，最终都要用free释放空间，不然会造成内存泄漏。 memest原型 (please type "man memset" in your shell) void *memset(void *s,
int c, size_t n); memset:作用是在一段内存块中填充某个给定的值，它对较大的结构体或数组进行清零操作的一种最快方法。 常见的三种错误 第一: 搞反了c 和 n的位置. 一定要记住 如果要把一个char a[20]清零, 一定是 memset(a, 0, 20) 而不是 memset(a, 20,
0) 第二: 过度使用memset, 我想这些程序员可能有某种心理阴影, 他们惧怕未经初始化的内存, 所以他们会写出这样的代码: char buffer[20]; memset(buffer, 0, sizeof((char)*20)); strcpy(buffer, "123"); 这里的memset是多余的. 因为这块内存马上就被覆盖了, 清零没有意义. 第三: 其实这个错误严格来讲不能算用错memset, 但是它经常在使用memset的场合出现 int some_func(struct something *a){ … … memset(a, 0, sizeof(a)); … } 问:为何要用memset置零?memset( &Address, 0, sizeof(Address))；经常看到这样的用法，其实不用的话，分配数据的时候，剩余的空间也会置零的。 答:1.如果不清空，可能会在测试当中出现野值。 你做下面的试验看看结果() char buf[5]； CString str,str1； //memset(buf,0,sizeof(buf))； for(int i = 0；i<5；i++) { str.Format(“%d “,buf)； str1 +=str ； } TRACE(“%s\r\n“,str1) 2.其实不然！特别是对于字符指针类型的，剩余的部分通常是不会为0的，不妨作一个试验，定义一个字符数组，并输入一串字符，如果不用memset实现清零，使用MessageBox显示出来就会有乱码（0表示NULL，如果有，就默认字符结束，不会输出后面的乱码） 问: 如下demo是可以的，能把数组中的元素值都设置成字符1， #include #include int main() { char a[5]; memset(a,'1',5); for(int i = 0;i < 5;i++) cout<<a<<"
"; system("pause"); return 0; } 而，如下程序想吧数组中的元素值设置成1，却是不可行的 #include #include int main() { int a[5]; memset(a,1,5);//这里改成memset(a,1,5 *sizeof(int))也是不可以的 for(int i = 0;i < 5;i++) cout<<a<<"
"; system("pause"); return 0; } 问题是： 1，第一个程序为什么可以，而第二个不行， 2，不想要用for，或是while循环来初始化int a[5];能做到吗？（有没有一个像memset（）这样的函数初始化） 答: 1.因为第一个程序的数组a是字符型的，字符型占据内存大小是1Byte，而memset函数也是以字节为单位进行赋值的，所以你输出没有问题。而第二个程序a是整型的，使用memset还是按字节赋值，这样赋值完以后，每个数组元素的值实际上是0x即十进制的。你看看你输出结果是否这样？ 2.如果用memset(a,1,20); 就是对a指向的内存的20个字节进行赋值，每个都用ASCII为1的字符去填充，转为二进制后，1就是,占一个字节。一个INT元素是4字节，合一起就是1，就等于，就完成了对一个INT元素的 realloc
原型：extern void *realloc(void *mem_address, unsigned int newsize); 功能：改变mem_address所指内存区域的大小为newsize长度。 说明：如果重新分配成功则返回指向被分配内存的指针，否则返回空指针NULL。 当内存不再使用时，应使用free()函数将内存块释放。 注意：这里原始内存中的数据还是保持不变的。 举例： // realloc.c #include #include main() { char *p; clrscr(); // clear screen p=(char *)malloc(100); if(p) printf("Memory Allocated at: %x",p); else printf("Not Enough Memory!\n"); getchar(); p=(char *)realloc(p,256); if(p) printf("Memory Reallocated at: %x",p); else printf("Not Enough Memory!\n"); free(p); getchar(); return 0; } 详细说明及注意要点： 1、如果有足够空间用于扩大mem_address指向的内存块，则分配额外内存，并返回mem_address 这里说的是“扩大”，我们知道，realloc是从堆上分配内存的，当扩大一块内存空间时， realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节，如果能够满足，自然天下太平。也就是说，如果原先的内存大小后面还有足够的空闲空间用来分配，加上原来的空间大小＝ newsize。那么就ok。得到的是一块连续的内存。 2、如果原先的内存大小后面没有足够的空闲空间用来分配，那么从堆中另外找一块newsize大小的内存。 并把原来大小内存空间中的内容复制到newsize中。返回新的mem_address指针。（数据被移动了）。 老块被放回堆上。 例如： #include char *p，*q; p = (char * ) malloc (10); q=p; p = (char * ) realloc (p,20); ………………………… 这段程序也许在编译器中没有办法通过，因为编译器可能会为我们消除一些隐患！在这里我们只是增加了一个记录原来内存地址的指针q，然后记录了原来的内存地址p，如果不幸的话，数据发生了移动，那么所记录的原来的内存地址q所指向的内存空间实际上已经放回到堆上了!这样一来，我们应该终于意识到问题的所在和可怕了吧！ 3、返回情况 返回的是一个void类型的指针，调用成功。（这就再你需要的时候进行强制类型转换） 返回NULL，当需要扩展的大小（第二个参数）为0并且第一个参数不为NULL，此时原内存变成了“freed（游离）”的了。 返回NULL，当没有足够的空间可供扩展的时候，此时，原内存空间的大小维持不变。 4、特殊情况 如果mem_address为null，则realloc()和malloc()类似。分配一个newsize的内存块，返回一个指向该内存块的指针。 如果newsize大小为0，那么释放mem_address指向的内存，并返回null。 如果没有足够可用的内存用来完成重新分配（扩大原来的内存块或者分配新的内存块），则返回null.而原来的内存块保持不变。 为了您的安全，请只打开来源可靠的网址 打开网站
取消 为了您的安全，请只打开来源可靠的网址 打开网站
| &(0) | &(1898) | &
