c语言指针之二级指针示例
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了c语言指针中的二级指针示例,需要的朋友可以参考下
二级指针的概念
首先任何值都有地址，一级指针的值虽然是地址，但这个地址做为一个值亦需要空间来存放，是空间就具有地址，这就是存放地址这一值的空间所具有的地址，二级指针就是为了获取这个地址，一级指针所关联的是其值（一个地址）名下空间里的数据，这个数据可以是任意类型并做任意用途，但二级指针所关联的数据只有一个类型一个用途，就是地址，指针就是两个用途提供目标的读取或改写，那么二级指针就是为了提供对于内存地址的读取或改写指针的表现形式是地址，核心是指向关系指针运算符“*”的作用是按照指向关系访问所指向的对象．如果存在A指向B的指向关系，则A是B的地址，“*A”表示通过这个指向关系间接访问B．如果B的值也是一个指针，它指向C，则B是C的地址，“*B”表示间接访问C如果C是整型、实型或者结构体等类型的变量或者是存放这些类型的数据的数组元素，则B(即C的地址)是普通的指针，称为一级指针,用于存放一级指针的变量称为一级指针变量。A(即B的地址)是指向指针的指针，称为二级指针，用于存放二级指针的变量称为二级指针变量．根据B的不同情况，二级指针又分为指向指针变量的指针和指向数组的指针二级指针的分类
指向指针变量的指针在如上的A指向B、B指向C的指向关系中，如果A、B、C都是变量，即C是普通变量，B是一级指针变量，其中存放着C的地址，A是二级指针变量，其中存放着B的地址，则这3个变量分别在内存中占据各自的存储单元，它们之间的相互关系下图所示，相互之间的前后位置关系并不重要．此时，B是一级指针变量，B的值(即C的地址)是一级指针数据；A是二级指针变量，A的值(即B的地址)是二级指针数据．
指向数组的指针在C语言中，数组与其它变量在使用上有很大的不同．无论是字符型、整型、实型变量,还是结构体类型或者指针类型的变量，语句中出现变量名都代表对该变量所在内存单元的访问，变量名代表整个变量在内存中的存储单元，可以向该变量赋值,也可以从中取出数据使用．但是定义一个数组之后，数组名并不代表整个数组所占据的内存单元，而是代表数组首元素的地址．二级指针例子： 代码如下:int *q;&& //定义一个一级指针变量，它指向一个普通变量（即它存的是一个变量的地址）int **p;&& //定义一个二级指针变量，它指向一个指针变量（它存的也是一个变量地址，只不过是一个指针变量的地址）q = &s;&& //q中存的是整型变量s的地址，所以q是一级指针p = &q;&& //p中存的是一级指针q的地址，所以p是二级指针
例子： 代码如下:# include &stdio.h&void f(int ** q);int main(void){&&& int i = 9;&&& int * p = &i;// int& *p;& p = &i;&&& printf("%p\n", p);&&& f(&p);&&& printf("%p\n", p);&&& return 0;}void f(int ** q){&&& *q = (int *)0xFFFFFFFF;// 这里是更改了p的值，与i无关，p不再指向i}1、二级指针的相关问题 代码如下:#include "iostream"#include "string"#include "cmath"int main(){char ch='a';char *p1=&char **p=&p1;cout&&ch&&cout&&p1&&cout&&&ch&&cout&&*p1&&cout&&p&&cout&&**p&&char *p3=NULL;//cout&&p3&&//cout&&*p3&&char **p4=&p3;cout&&p4&&//cout&&*p4&&cout&&**p4&&}思考上面的输出是什么？
2、如下程序，输出是什么？
代码如下:#include "iostream"int main(){int a=12;int *p=&a;int **p1=&p;cout&&a&&cout&&&a&&cout&&p&&cout&&*p&&cout&&p1&&cout&&*p1&&cout&&**p1&&}
3、如下程序的输出是什么？ 代码如下:#include "iostream"int main(){int *p=NULL;int **p1=&p;cout&&p&&//cout&&*p&&cout&&p1&&cout&&*p1&&cout&&**p1&&}void GetMM(char **p,int n){if(*p!=NULL)*p=(char*)malloc(n);(*p)[1]='a';}int main(){char *str=NULL;GetMM(&str,10);}#include "iostream"union A{char ch[2];};int main(){Aa.ch[0]=0x38;a.ch[1]=0x39;printf("%x",a.b);//3938}
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具1. 数组名 　　C语言中的数组名是一个特殊的存在, 从本质上来讲, 数组名是一个地址, 我们可以打印一个指针的值,和打印一个数组的值来观察出这个本质:
int nArray[10] ={ 0 };
int *p = nA
printf("nArray:%p , p = %p\n", nArray,p);
　　打印出来的将会是两个相同的值.但是数组名并不意味着和指针完全相同, 数组名还有另一个本质,数组名是一个常量,不允许被赋值. 但指针允许被赋值,例如:
　　　　p = nA
　　　　nArray = // 语句将会被报错:表达式必须可修改的左值 　　因此,我们可以得到数组名的两个性质:
　　　　1. 是一个地址.
　　　　2. 是一个常量地址. 　　只要不对数组名进行赋值, 对指针进行的任何操作都可以应用在数组名上, 例如对数组名取值, 对数组名解引用,进行算术运算:
<span style="color: # printf("%d",nArray ); //取数组名的值,并将这个值打印.
<span style="color: # int n = *nA //对数组名解引用,取得一个地址上的值.
<span style="color: # nArray + <span style="color: #;
//对数组名进行算术运算,返回一个被增加一个单位的地址
2. 二级指针和多级指针 　　2.1 一级指针的使用
　　当我们对一个指针解引用时, C语言会为我们从指针变量中取出一个地址,随后再从这个地址中取出一个值.
<span style="color: # int a = <span style="color: #; /*a的地址等于0x1000*/
<span style="color: # int *p = &a;/*此时p保存的值是0x1000*/
<span style="color: # printf("%d",*p);
　　在第三条语句中, *p的作用就是对指针解引用, 在解引用时,发生了两个动作:
　　　　1. 对指针变量p取值, 取出0x1000
　　　　2. 将上一步得到的0x1000上进行*运算符的操作,该操作得到0x1000上的整型值
　　因此,这个表达式的结果就是10; 　　2.2 二级指针的本质
　　再说到主题二级指针, 二级指针的本质也和一级指针一样,这里的一样指的是这两种属性:
　　　　1. 占用4字节的空间
　　　　2. 保存的值是一个地址
　　但定义二级指针的语法是不一样的,定义二级指针也比较简单: int **p;
　　在定义时使用两个*运算符.
　　对于一级指针能够进行的操作,在二级指针上面同样是可行的,而且得到的是一致的效果.
<span style="color: # int **p = (int**)<span style="color: #x1000; // 允许
<span style="color: # int **p2 = p + <span style="color: # ; // 允许,p2的值是p被增加一个单位的值.即0x1004
<span style="color: # int n = *p; // 错误
　　我们可以看到, 第三条语句将会被报以"int*的值不能赋值到int型的实体"的编译错误.
　　这是因为, *p表达式的结果是一个指针.如果你想要从一个二级指针中得到一个值.那么你需要再加上一个*运算符:
　　　　int n = **p;
　　这条语句可以分解成一下步骤:
　　　　1. 取变量p的值 =& 0x1000
　　　　2. 对0x1000解引用,得到0x1000保存的值
　　　　3. 把第二步得到的值当成是一个地址,再对这个地址解引用, 得到这个地址的值
　　因此,你可以看到, 在对一级指针解引用时, 分解的步骤到第2步就结束了. 但对二级指针,还需要进行第3步.
　　2.3 二级指针引用的规则和规律
　　2.3.1 规则:
　　　　对一级指针进行解引用时, 得到的结果将是一个变量的值.
　　　　对二级指针进行解引用时, 得到的结果是一个一级指针.
　　2.3.2 规律
　　　　对三级指针进行解引用时, 得到的结果是一个二级指针.
　　　　对n级指针进行解引用时,得到的结果是一个(n-1)级指针.
3. 二维数组的解引用 　　3.1 二维数组名
　　　　一维数组的本质就是一个常量一级指针, 而二维数组的本质就是一个常量二级指针.因此, 只要不对这个常量进行赋值, 任何施加在二级指针上的可允许操作都能够施加在二维数组名上. 　　3.2 将二维数组名赋值给一个指针.
　　　　一维数组名可以直接赋值给一个一级指针. 但是二维数组却不能直接赋值给一个二级指针.
　　　　在将二维数组赋值给一个二级指针时,我们需要考虑两件事情:
　　　　　　int nArray[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
　　　　　　int** pp = (int**)nA // 通过强制类型转换可以将二维数组名赋值给二级指针
　　　　　　int n1 = nArray[1][2] ; // n1的值将等于6
　　　　　　int n2 = pp[1][2];
// 执行到此处时将会被报错.
　　　　我们可以通过对int n2 = pp[1][2];这条语句进行分解, 来揪出错误之源:
　　　　　　1. 对变量pp取值 =& 得到数组nArray的首地址
　　　　　　2. 地址[1] ==转换为=&
　　　　　　3. 将上一步的结果当成一个地址:
　　　　　　 & & & &地址[2] ==转换为=& *(地址+2)
　　　　在这三步分解中, 第二步时, 取到的结果是2(数组首地址的第二个元素的值). 但在进行第3步时, 2被当成一个地址,进行了解引用, 错误的根源就在这里了.因此, 我们也可以看出, 将一个二级指针当成数组来使用时, 二级指针的内存模型将如下图所示:
　　　　二级指针将是以下内存格子的首地址,每个格子将占用4个字节. 当我们对一个二级指针解引用时, 得到的是一个地址,这个地址就是一个一级指针. 当我们将一个二级指针增加一个单位时, 得到的结果就是第二个格子的内容,也是一个内存地址.
　　　　+--------+ [0x1000]
　　　　+--------+ [0x1004]
　　　　+--------+ [0x1008]
　　　　+--------+ [0x100C]
　　　　+--------+ [0x1010]
　　但一个二维数组中的在内存中的模型如下图所示:
　　　　+--------+
　　　　+--------+
　　　　+--------+
　　　　+--------+
　　　　+--------+
　　而nArray[1][2] 这样的语法将会被转换成: *(数组首地址 + (1 * 低维数组的最大下标 + 2)),而对二级指针进行p[1][2]时, 这样的语法将转换成: *( *( p + 1 ) + 2).
　　我们可以看到, 在对数组nArray解引用时, 编译器会将1解释一个单位, 这个单位就是: 低维度数组的最大下标.
　　而一个二级指针中, 并没有保存低维度数组最大下标这样的信息.
　　因此, 一个二维数组赋值给一个二级指针时, 即使二级指针可以使用[]运算符,但得到的结果将完全不一样. 因为二级指针在对一个地址解引用时,没有把这个地址当成是一个数组名.不是数组名, 就没有想要保存一个二维数组的地址, 只能使用数组指针. 4. 数组指针 　　草莓, 是一种水果, 蛋糕, 是一种糕点. 草莓蛋糕是一种蛋糕. 　　数组, 是相同类型的变量的集合. 指针, 是一个保存变量地址的变量. 数组指针是一种指针. 　　因此, 数组指针从本质上来说, 它是一个占用4个字节的指针. 　　数组有不同维度的数组, 如一维数组, 二维数组.
　　在保存一维数组时, 我们可以直接使用一个一级指针来保存.
　　保存二维数组时, 如果使用二级指针保存二维数组的地址,会导致二维数组的低维度最大下标的信息丢失. 而数组指针这样的类型将能够保存低维度最大下标信息. 　　4.1 定义数组指针:
　　　　int nArray[3][3];
　　　　int (*p)[3] = nA
　　语句2就是在定义一个数组指针p , 在语句2中, *p必须被圆括号括起来, 这样一来,就能使*运算符先和变量p结合, 让p变成一个一级指针变量, 而[3]让指针p变成一个指向最低维度为3的数组指针.
　　这个数组指针就只能保存最低维度为3的二维数组,而二维数组的高维度的最大小标数将被会限制.如:
　　　　int nArray1[10][3] , nArray2[3][10];
　　　　int (*p)[3];
　　　　p = nArray1; // 语法通过
　　　　p = nArray2; // 语法不通过,因为nArray2的低维度最大下标是10,而p只能指向低维度最大小标为3的的数组 　　4.2 对数组指针进行解引用
　　　　int nArray[3][3];
　　　　int (*p)[3] = nA
　　　　nArray[2][1]; 和 p[2][1] 将会得到一个一致的结果. 　　4.3 保存多维数组的数组指针:
　　　　int nArray[4][3][3];
　　　　保存这样的指针, 指针必须能够描述低维度的最大下标.
　　　　int (*p)[3][3]; 　　4.4 传递一个多维数组到函数.
　　　　在传递时, 只需要根据要传递的数组的低维度最大下标来定义形参即可.
　　　　即将形参定义成一个数组指针.
5. 指针数组. 　　指针数组, 从本质上来说是一个数组,数组中保存的每一个元素都是一个指针.指针数组也有多种形式:
　　1. 保存一级指针的数组
　　　　int *p[10];
　　　这里的标识符先和[]结合,说明p是一个具有10元素的数组. int* 说明这个数组中的每一个元素是都是int类型的一级指针.
　　2. 保存多级指针的数组
　　　　int** p[10];
　　3. 保存数组指针的数组
　　　　3.1 保存二维数组的数组指针的数组
　　　　　　int (*p[5])[10]; // 标识符p先和[]结合,说明p是一个具有5个元素的数组, 在和int(*)[10]结合, 说明数组中的每一个元素都是指向数组的指针.
　　　　3.2 保存多维数组的数组指针的数组
　　　　　　int (*p[5])[3][3];
6. 函数指针 　　现在, 我们学会了如何定义一个指针来保存数组的地址.
　　在c语言当中, 函数是有地址的, 这个地址中,保存着这个函数的代码(机器码).函数名就是这些机器码的首地址. 当我们使用一个函数时, 使用到的就是函数的地址.但不仅仅是函数的地址. 　　一个函数名包含着以下信息:
　　　　1. 函数地址
　　　　2. 参数列表,即函数的参数个数,每个参数的数据类型
　　　　3. 函数的返回值类型 　　因此, 如果要保存一个函数的地址, 也需要额外保存另外两个信息. c语言提供了类似的语法让我们能够保存函数地址和额外信息的指针, 就是函数指针.
　　　　int (*pfn)(int arg1, int arg2); 　　在这一条语句中, 定义了一个标识符pfn, 这个标识符pfn被()括起来, 所以,它先和*运算符结合, 说明pfn是一个一级指针.
　　这个指针指向的类型是 : int (*)(int arg1, int arg2); 而这这种类型就是一个函数的类型, ()左边是函数的返回值, ()右边是函数的参数列表.
　　6.1 函数指针的赋值
　　　　数类型也必须匹配才能够赋值. 　　6.2 函数指针的使用.
　　　　正如一个数组指针可以被当成真正的数组名来说用一样. 函数指针也能够被当成真正的函数名来使用. 如:
　　　　　　int n = pfn(1,2);
　　　　这条语句会先对变量pfn取值,将取出的值当成是一个函数地址去调用一个函数,并将实参1和2传入到函数中, 最后将函数表达式的结果,即函数的返回值赋值给变量n.
7. 指针函数 　　7.1 返回普通指针的函数
　　　　当一个函数的返回值是一个函数指针时, 这个函数就被称为指针函数.
　　　　例如:
　　　　　　char* strstr( const char* str,const char* sub );
　　　　fun是一个函数, 它的返回值类型是char*
　　　　这种指针函数相对来说还是比较简单, 我们想要保存这样的函数的地址时, 我们需要定义这种类型的函数的指针:
　　　　　　char* (*pfn)( const char* str,const char* sub ); 　　7.2 返回函数指针的函数
　　　　一个函数可以返回另一个函数的地址.这个时候,它的返回值就是一个函数指针了.
　　　　如:
　　　　　　char* (*)( const char* str,const char* sub ) fun(int nIndex);
　　　　标识符fun是一个函数, 标识符fun的左边是它的函数返回值,标识符右边是它函数参数列表.但实际上C语言不支持这个语法, 需要将fun(int nIndex)部分写在(*)中:
　　　　　　char* (*fun(int nIndex))( const char* str,const char* sub );
　　　　现在, 我们可以重新来解释这一条语句.
　　　　　　1. fun先和参数列表结合,说明fun是一个函数.
　　　　　　2. 这个函数的参数列表就是int nIndex.
　　　　　　3. 这个函数的返回值类型就是去除函数名,和参数列表的部分:
　　　　　　　　char* (*)( const char* str,const char* sub );
　　　　　　4. 返回值是一个指针. 这个指针是一个函数指针. 这种函数指针拥有char*类型的返回值,参数列表中有2个都是const char*类型的形参.
阅读(...) 评论()3292人阅读
在C语言中，数组名就是一个指针常量，保存数组的首地址。因为数组名是一个常量指针常量，不能修改其指向的&#20540;，因此可以定义一个指针变量指向数组。这样使用数组名加下标可访问数组中的元素，使用指针名加下标也可访问数组中的元素。这些在本章前面已经介绍过了。
现在如果再定义一个二级指针变量，让其指向一级指针，就可使用二级指针变量操作数组。例如，使用以下语句定义二级指针变量：
int&a[10]; &int&*p=a; &int&**pp=&p;&
这样，二级指针变量pp、一级指针变量p和数组a之间的关系，如图9-47所示。
（点击查看大图）图9-47& 用二级指针操作一维数组
1．用二级指针操作一维数组
可使用以下代码输出数组a中各元素的&#20540;：
【程序9-24】
#include&&&//头文件 &#include&&&int&main() &{ &&&&&int&i,a[10]={1,2,3,4,5,6,7,8,9,10};//声明并初始化 &&&&&int&*p,** &&&&&&printf(&使用数组方式输出数组各元素的&#20540;:\n&); &&&&&for(i=0;i;i&#43;&#43;)&&&//使用数组方式输出 &&&&&{ &&&&&&&&&printf(&%4d&&&,a[i]); &&&&&} &&&&&&printf(&\n使用一级指针变量输出数组各元素的&#20540;:\n&); &&&&&p=a; &&&&&for(i=0;i;i&#43;&#43;)&&&//使用一级指针变量输出 &&&&&{ &&&&&&&&&printf(&%4d&&&,*p&#43;&#43;); &&&&&} &&&&&&printf(&\n使用二级指针变量输出数组各元素的&#20540;:\n&); &&&&&p=a; &&&&&pp=&p; &&&&&for(i=0;i;i&#43;&#43;)&&&//用二级指针变量输出 &&&&&{ &&&&&&&&&printf(&%4d&&&,*(*pp&#43;i)); &&&&&} &&&&&&printf(&\n使用二级指针变量**p方式输出数组各元素的&#20540;:\n&); &&&&&p=a; &&&&&for(i=0;i;i&#43;&#43;,p&#43;&#43;)//使用二级指针变量**p方式输出 &&&&&{ &&&&&&&&printf(&%4d&&&,**pp); &&&&&} &&&&&&printf(&\n&); &&&&&&system(&pause&); &&&&&return&0; &}&
在以上程序中，分别采用了如下几种方法输出数组各元素的&#20540;。
使用数组下标方式输出各元素的&#20540;。
使用一级指针变量输出指向元素的&#20540;，然后执行p&#43;&#43;使指针指向下一个元素，循环处理将所有数组元素都输出。
使用二级指针变量的方式输出数组元素&#20540;，在第23行中，首先使用*pp得到一级指针变量p中保存的&#20540;，再将其加上一个整数i，再使用运算符*得到具体的&#20540;。
使用**pp方式输出具体元素的&#20540;，这时，因为二级指针变量pp指向一级指针变量p，所以只需要改变一级指针变量p所指向的位置，**pp就可以得到不同元素的&#20540;。
编译执行这段程序，得到如下结果，如图9-48所示。
图9-48& 执行结果
从以上程序可以看出，对于一维数组，使用一级指针变量可方便地操作数组元素，而使用二级指针变量只会让情况更复杂。
2．用二级指针操作二维数组
用二级指针操作二维数组的示意图，如图9-49所示。同样在二级指针变量pp中保存一级指针的地址，修改一级指针p的指向，使用**pp就可访问到不同的数组元素，如图9-49所示。因为一级指针变量定义为int型，所以对指针变量p进行自增时，将移动到下一个int变量（即一个数组元素），如图9-49右图所示。
（点击查看大图）图9-49& 用二级指针操作二维数组示意图
下面编写程序，用二级指针变量输出二维数组的数据。
【程序9-25】
#include&//头文件 &#include&&&int&main() &{ &&&&&int&i,j,a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};&//声明并初始化 &&&&&int&*p,** &&&&&&printf(&用二级指针方式输出二维数组:\n&); &&&&&pp=&p; &&&&&for(i=0;i;i&#43;&#43;)//用二级指针方式输出 &&&&&{ &&&&&&&&&p=a[i]; &&&&&&&&&for(j=0;j;j&#43;&#43;) &&&&&&&&&&&&&printf(&%4d&,*(*pp&#43;j)); &&&&&&&&&printf(&\n&); &&&&&} &&&&&&printf(&用二级指针**pp输出二维数组:\n&); &&&&&for(i=0;i;i&#43;&#43;)//用二级指针**pp输出 &&&&&{ &&&&&&&&&p=a[i]; &&&&&&&&&for(j=0;j;j&#43;&#43;,p&#43;&#43;) &&&&&&&&&&&&&printf(&%4d&,**pp); &&&&&&&&&printf(&\n&); &&&&&} &&&&&&printf(&\n&);&&&//输出换行 &&&&&&system(&pause&); &&&&&return&0; &}&
在该程序中，首先使二级指针变量pp指向一级指针变量p，因为p的内存地址不会再变化，所以可将该语句放在程序前面，在后面的循环中不需要修改其&#20540;。然后，使用*(*pp&#43;j)的方式输出数组中的&#20540;，这种方式在本章前面曾多次使用，首先通过*pp得到一级指针变量p保存的&#20540;（从语句p=a[i]可知道，变量p中保存着二维数组某行的首地址），再将其加上一个整数j，得到该行第j个元素的地址，最后使用运算符*得到该地址的&#20540;。
在第二种方法中，使用**pp方式输出二维数组元素的&#20540;，该表达式可看做为*(*pp)，*pp得到变量p中的&#20540;，从语句p=a[i]可知道，变量p中保存着二维数组某行的首地址，该首地址也是该行第1个元素的地址，因此使用*(*pp)将输出某行第1个元素的&#20540;。接着执行循环中的p&#43;&#43;，使一级指针变量的&#20540;增加1，因该变量保存的&#20540;是一个指针，所以对其进行自增运算将指向下一个元素，即该行的第2个元素，再使用**pp即可输出第2个元素的&#20540;。通过内循环语句，即可将二维数组一行中的每个元素输出。再通过外循环，即可输出整个二维数组中的元素&#20540;。
编译执行这段程序，得到如下结果，如图9-50所示。
图9-50& 执行结果
3．用二级指针操作指针数组
在本章的程序9-22中，使用指针数组操作多个字符串。还可以通过二级指针变量的方式进行这种操作，其示意图如图9-51所示。首先定义一个字符串指针数组s，用来指向多个字符串常量，再定义一个二级指针变量p，使其指向数组s，因数组s中的每个元素都是数组，因此指针变量p必须定义为指向指针的指针（即二级指针）。
（点击查看大图）图9-51& 二级指针与数组
修改程序9-22中的strsort()函数，使其形参使用二级指针的方式。
【程序9-26】
#include&&&//头文件 &#include&&#include&&&void&strsort(char&**p,int&n);&&&&&&&//函数声明 &&int&main() &{ &&&&&int&i; &&&&&char&*s[]={&&&&&//初始化 &&&&&&&&&&&&&&&&&C&, &&&&&&&&&&&&&&&&&Basic&, &&&&&&&&&&&&&&&&&Foxpro&, &&&&&&&&&&&&&&&&&Visual&Studio& &&&&&&&&&&&&&&&&}; &&&&&&strsort(s,sizeof(s)/4);&&&&&//排序 &&&&&printf(&\n排序后的数据:\n&); &&&&&for(i=0;i(s)/4;i&#43;&#43;)&&&&&&//输出 &&&&&{ &&&&&&&&&printf(&%s\n&,s[i]); &&&&&} &&&&&&system(&pause&); &&&&&return&0; &} &&void&strsort(char**p,int&n)&&&&&//自定义函数 &{ &&&&&&int&i,j; &&&&&&char&* &&&&&&for(i=0;i;i&#43;&#43;) &&&&&&{ &&&&&&&&for&(j=i&#43;1;j;j&#43;&#43;) &&&&&&&&{ &&&&&&&&&&&&if&(strcmp(*(p&#43;i),*(p&#43;j))0)//比较 &&&&&&&&&&&&{ &&&&&&&&&&&&&&&&pstr=*(p&#43;j); &&&&&&&&&&&&&&&&*(p&#43;j)=*(p&#43;i); &&&&&&&&&&&&&&&&*(p&#43;i)= &&&&&&&&&&&&} &&&&&&&&} &&&&&&} &}&
编译执行这段程序，得到如下结果，如图9-52所示。
图9-52& 执行结果
在该程序中，重新编写自定义函数strsort()。在函数头的形参中，使用二级指针变量p接收一个指针变量的地址作为参数（指针数组的每一个元素是一个指针，指针数组名就是一个指向指针变量的指针），变量n为需要处理的字符串数量。
在自定义函数strsort()中，定义了一个字符指针变量pstr，作为临时指针变量，用来保存需要交换的指针地址。
对照前面的示意图，*(p&#43;i)表示p[i]，即与数组s[i]相同，得到其指向的字符串常量。程序中调用库函数strcmp()比较两个字符串的大小，再根据需要交换指针。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：72407次
积分：1040
积分：1040
排名：千里之外
原创：23篇
转载：39篇
评论：11条
(1)(1)(2)(1)(3)(1)(7)(3)(13)(5)(9)(15)(1)