指针指向多维数组

指向多维数组的指针变量 $ J5 J, U+ |4 o: z$ _
本小节以二维数组为例介绍多维数组的指针变量。
# ]7 O' a/ G1 c一、多维数组地址的表示方法
" S: Z' v& {: s9 ^3 r/ B0 l: x6 X设有整型二维数组a[3][4]如下：
9 I. Q" h; K5 G6 r4 o: _0 1 2 3
. }8 q% V% k/ {2 w* v2 T4 5 6 7
8 F2 {" h9 L& |( x# Q2 M8 9 10 11 + K# A: w, D) D. n$ P. x
　　 设数组a的首地址为1000，各下标变量的首地址及其值如图所示。在第四章中介绍过， Ｃ语言允许把一个二维数组分解为多个一维数组来处理。因此数组a可分解为三个一维数组，即a[0]，a[1]，a[2]。每一个一维数组又含有四个元素。例如a[0]数组，含有a[0][0]，a[0][1]，a[0][2]，a[0][3]四个元素。 数组及数组元素的地址表示如下：a是二维数组名，也是二维数组0行的首地址，等于1000。a[0]是第一个一维数组的数组名和首地址，因此也为1000。*(a+0)或*a是与a[0]等效的， 它表示一维数组a[0]0 号元素的首地址。 也为1000。&a[0][0]是二维数组a的0行0列元素首地址，同样是1000。因此，a，a[0]，*(a+0)，*a?amp;a[0][0]是相等的。同理，a+1是二维数组1行的首地址，等于1008。a[1]是第二个一维数组的数组名和首地址，因此也为1008。 &a[1][0]是二维数组a的1行0列元素地址，也是1008。因此a+1,a[1],*(a+1),&a[1][0]是等同的。 由此可得出：a+i，a ，*(a+i)，&a[0]是等同的。 此外，&a和a也是等同的。因为在二维数组中不能把&a理解为元素a的地址，不存在元素a。
8 v# M( v- k9 D5 \　　Ｃ语言规定，它是一种地址计算方法，表示数组a第i行首地址。由此，我们得出：a，&a，*(a+i)和a+i也都是等同的。另外，a[0]也
9 U* n3 Z8 c' i0 x7 {可以看成是a[0]+0是一维数组a[0]的0号元素的首地址， 而a[0]+1则是a[0]的1号元素首地址，由此可得出a+j则是一维数组a的j号元素首地址，它等于&a[j]。由a=*(a+i)得a+j=*(a+i)+j，由于*(a+i)+j是二维数组a的i行j列元素的首地址。该元素的值等于*(*(a+i)+j)。
+ X, }& X5 X- Q! H. V  |$ _  m[Explain]#define PF "%d,%d,%d,%d,%d,\n"
; R9 E9 j; m) F% Qmain(){
  K3 i: R( a+ X- ~: pstatic int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};- ?5 H, b# e' p( J9 q9 r. L" A2 [
printf(PF,a,*a,a[0],&a[0],&a[0][0]);8 j( |& M/ L6 x4 ?
printf(PF,a+1,*(a+1),a[1],&a[1],&a[1][0]);
* K. W" {$ H- ]printf(PF,a+2,*(a+2),a[2],&a[2],&a[2][0]);
2 |/ }  v3 p% ~+ n  v4 Dprintf("%d,%d\n",a[1]+1,*(a+1)+1);
4 h4 J$ w( x# U4 iprintf("%d,%d\n",*(a[1]+1),*(*(a+1)+1));
- ?" ?) |" l1 x7 F}
* \- G9 @. K2 a5 Q' `  t5 y二、多维数组的指针变量2 O; g7 Y. l8 R
　　把二维数组a 分解为一维数组a[0],a[1],a[2]之后，设p为指向二维数组的指针变量。可定义为： int (*p)[4] 它表示p是一个指针变量，它指向二维数组a 或指向第一个一维数组a[0]，其值等于a,a[0]，或&a[0][0]等。而p+i则指向一维数组a。从前面的分析可得出*(p+i)+j是二维数组i行j 列的元素的地址，而*(*(p+i)+j)则是i行j列元素的值。) R+ r6 S; R2 p+ I. U
　　二维数组指针变量说明的一般形式为： 类型说明符 (*指针变量名)[长度] 其中“类型说明符”为所指数组的数据类型。“*”表示其后的变量是指针类型。 “长度”表示二维数组分解为多个一维数组时， 一维数组的长度，也就是二维数组的列数。应注意“(*指针变量名)”两边的括号不可少，如缺少括号则表示是指针数组(本章后面介绍)，意义就完全不同了。
' e# }- p. v7 L3 X  N[Explain]main(){' l( c( _, v# ]+ J* u8 k: t7 `; o
static int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
* _" V4 J% t& Gint(*p)[4];
5 I/ l3 r1 O+ x7 F- j- g2 B' xint i,j;/ z5 Z$ X' s$ Q& T
p=a;! y+ k, @2 n8 E' K7 s- K
for(i=0;i<3;i++)
4 ]# q! I$ J( Nfor(j=0;j<4;j++) printf("%2d ",*(*(p+i)+j));( u% \  n/ E/ o+ b' n) X
}5 [3 Z: v8 D: q2 `
'Expain字符串指针变量的说明和使用字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针变量的赋值不同来区别。 对指向字符变量的指针变量应赋予该字符变量的地址。如： char c,*p=&c;表示p是一个指向字符变量c的指针变量。而： char *s="C Language";则表示s是一个指向字符串的指针变量。把字符串的首地址赋予s。
9 ^# w# |$ ?( n; {0 s请看下面一例。9 ~6 S$ D" I2 B1 s' g
main(){5 l, L3 F2 l  X
char *ps;- h. N0 E/ r+ o7 f0 ]4 B
ps="C Language";5 b0 W* |  b& Y8 R5 W
printf("%s",ps);
- g$ l1 J- d  Z4 f. t% j* d  ~7 m}
9 G6 r# S9 x; t* B运行结果为：7 V6 k' T2 Y, I5 b& s
C Language
% y% R6 x0 \# t4 \0 L  `上例中，首先定义ps是一个字符指针变量， 然后把字符串的首地址赋予ps(应写出整个字符串，以便编译系统把该串装入连续的一块内存单元)，并把首地址送入ps。程序中的： char *ps;ps="C Language";等效于： char *ps="C Language";输出字符串中n个字符后的所有字符。
- o5 u$ t7 b8 V& g3 o$ u8 h8 Lmain(){
( f) M! Z; M0 ^7 B" R5 r6 ]7 m6 M3 mchar *ps="this is a book";
: l. ^4 \2 u; wint n=10;  V! D7 J5 E* W. v
ps=ps+n;% E4 J: @- E* C
printf("%s\n",ps);% W/ C2 P7 ]7 i0 T& K
}
/ r% d4 t$ u  j# \; @" A( t( ]运行结果为：
7 A" k( M2 n8 T* e8 m4 {, Nbook 在程序中对ps初始化时，即把字符串首地址赋予ps，当ps= ps+10之后，ps指向字符“b”，因此输出为"book"。
) E# Y4 B6 Q5 }, `main(){
' o* @6 B2 V, C9 Achar st[20],*ps;
3 R' o3 j# o" h; \2 `int i;
! a" S) u! h9 v- gprintf("input a string:\n");0 a' X4 D6 n9 B. ~9 i
ps=st;0 I6 r. M- \7 C6 @( W1 q
scanf("%s",ps);
3 B- f8 ^( }2 L0 tfor(i=0;ps!='\0';i++)6 T0 P' O' [, H8 `$ ~, A
if(ps=='k'){/ z8 o* x: x- e- V+ j2 n* [1 N; N& e
printf("there is a 'k' in the string\n");4 X/ n3 `# `$ I# ]; g
break;
; E: M- Z1 H! j: A) K, C& d}7 ~% u/ A# d9 O  n  X/ ^
if(ps=='\0') printf("There is no 'k' in the string\n");- Z5 C7 e" a! W5 ]( }
}
/ B: U  t  ~; z( g　　 本例是在输入的字符串中查找有无‘k’字符。 下面这个例子是将指针变量指向一个格式字符串，用在printf函数中，用于输出二维数组的各种地址表示的值。但在printf语句中用指针变量PF代替了格式串。 这也是程序中常用的方法。! A( L' a5 S8 B& ]1 E" }
main(){
  p, g3 c1 X' {$ `; x7 W: Q2 Tstatic int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};+ t; L1 K, K6 r* t+ N
char *PF;
1 j9 T, i9 ?0 J* uPF="%d,%d,%d,%d,%d\n";
" _- {( q. Q. j5 Y2 Kprintf(PF,a,*a,a[0],&a[0],&a[0][0]);, e+ O1 q6 l7 c% r
printf(PF,a+1,*(a+1),a[1],&a[1],&a[1][0]);
0 ?2 n1 t( U1 Sprintf(PF,a+2,*(a+2),a[2],&a[2],&a[2][0]);
8 {2 b, D6 m& Kprintf("%d,%d\n",a[1]+1,*(a+1)+1);+ a7 e* H" j+ ?8 n1 f
printf("%d,%d\n",*(a[1]+1),*(*(a+1)+1));
' q5 K  H& V9 C' m7 Y}
$ z) h2 u  k" Y　　 在下例是讲解，把字符串指针作为函数参数的使用。要求把一个字符串的内容复制到另一个字符串中，并且不能使用strcpy函数。函数cprstr的形参为两个字符指针变量。pss指向源字符串，pds指向目标字符串。表达式：
, v0 a6 G" d& c& T7 b/ ?(*pds=*pss)!=`\0'
; L5 H* A/ Y; R; _/ I' k( B8 J1 ecpystr(char *pss,char *pds){0 M: I& u. w4 V$ x" ~/ f  g
while((*pds=*pss)!='\0'){
! Z, ]+ M, ^2 x. ^* C+ @7 m& k4 @, dpds++;, g# _+ Q* ^4 H
pss++; }+ U2 g% K9 K0 v( s3 O2 i' \! p
}
7 a$ X+ j$ X* P2 h2 I4 c& xmain(){
; T9 S  c  q1 J/ M) d% cchar *pa="CHINA",b[10],*pb;, q4 Q( X# x: w8 g9 u
pb=b;! n$ Z1 e2 B* ~9 d
cpystr(pa,pb);
8 O7 B5 {( b% Q% x" Kprintf("string a=%s\nstring b=%s\n",pa,pb);
2 ]$ `, A7 u  u. V4 ?) F1 S}7 m3 U3 j/ e$ \0 k# L
　　 在上例中，程序完成了两项工作：一是把pss指向的源字符复制到pds所指向的目标字符中，二是判断所复制的字符是否为`\0'，若是则表明源字符串结束，不再循环。否则，pds和pss都加1，指向下一字符。在主函数中，以指针变量pa,pb为实参，分别取得确定值后调用cprstr函数。由于采用的指针变量pa和pss,pb和pds均指向同一字符串，因此在主函数和cprstr函数中均可使用这些字符串。也可以把cprstr函数简化为以下形式：
3 d5 J4 _1 I1 x& rcprstr(char *pss,char*pds)
8 [7 t3 D$ j# Y% a{while ((*pds++=*pss++)!=`\0');}& O. V4 K$ N' h$ n+ ~
　　 即把指针的移动和赋值合并在一个语句中。 进一步分析还可发现`\0'的ASCⅡ码为0，对于while语句只看表达式的值为非0就循环，为0则结束循环，因此也可省去“!=`\0'”这一判断部分，而写为以下形式：
0 B! O6 ^) A8 p  Z8 t/ c( Kcprstr (char *pss,char *pds). G4 h* k3 R1 [$ D
{while (*pdss++=*pss++);}4 b! _. _( R/ U( |
表达式的意义可解释为，源字符向目标字符赋值， 移动指针，若所赋值为非0则循环，否则结束循环。这样使程序更加简洁。简化后的程序如下所示。
, X4 K2 f$ w0 o2 a: L+ F4 Hcpystr(char *pss,char *pds){6 K/ T" j9 i5 |+ G+ X8 F
while(*pds++=*pss++);; t' u; z) c) @5 b
}4 N, R2 S$ `( v) @; ~* w
main(){
: o# c7 M7 }3 Kchar *pa="CHINA",b[10],*pb;, X  [1 @/ ~" A* M
pb=b;
8 T+ A1 h* y& L* D4 b# k! g' l1 H' Dcpystr(pa,pb);
4 r, x" a6 Q; `. Zprintf("string a=%s\nstring b=%s\n",pa,pb);
2 `5 i( |( m8 n; W1 V}
5 R  R% y4 {2 C0 M# E, P使用字符串指针变量与字符数组的区别
) e7 y; g5 A& l2 m" u) i& ]用字符数组和字符指针变量都可实现字符串的存储和运算。 但是两者是有区别的。在使用时应注意以下几个问题：3 X/ [0 g3 T% f5 B! e
1. 字符串指针变量本身是一个变量，用于存放字符串的首地址。而字符串本身是存放在以该首地址为首的一块连续的内存空间中并以‘\0’作为串的结束。字符数组是由于若干个数组元素组成的，它可用来存放整个字符串。6 J' e5 X3 h& Z* T, G% E
2. 对字符数组作初始化赋值，必须采用外部类型或静态类型，如： static char st[]={“C Language”};而对字符串指针变量则无此限制，如： char *ps="C Language";
; I& n& X8 W* T2 L( D2 t8 q3. 对字符串指针方式 char *ps="C Language";可以写为： char *ps;　ps="C Language";而对数组方式：9 T0 D& D  p. H4 z
static char st[]={"C Language"};6 y( K2 O: M3 D: \- [+ h# t$ \' b
不能写为：
, q8 y% q* t' Z' |  G" Ichar st[20];st={"C Language"};
: Y. S0 l! a* r) d0 g: o而只能对字符数组的各元素逐个赋值。
4 a2 q. o; u$ v- y9 L  m　　从以上几点可以看出字符串指针变量与字符数组在使用时的区别，同时也可看出使用指针变量更加方便。前面说过，当一个指针变量在未取得确定地址前使用是危险的，容易引起错误。但是对指针变量直接赋值是可以的。因为C系统对指针变量赋值时要给以确定的地址。因此，
- I2 e2 T7 f/ f8 E9 Achar *ps="C Langage";
/ \* ^. U( y' h1 R) W* G4 z或者 char *ps;$ W7 h- M) r& L# h8 j% m
ps="C Language";都是合法的。

 

 

 

shape1和shape2的类型其实为int * shape1[5];

int *p=shape[0];

P+7=1;//等于shape[1][2]=1

要创建一个指针数组，指向int* [5];

typedef int (*shape_p)[5];

shape_p shapes[2];

对于一维数组，使用T *ptr指向即可，对于二维数组，使用T (*ptr)[size]指向行数为size的二维数组
 对于上面的例子，还可以如下设定

int(*shapes[])[3]={ shape1, shape2 };

shapes[1][3][0]指向shape2的第三行第一列.

shapes            // 类型为"int (*x[2])[3]" (也就是 "(**x)[3]") 

shapes[1]        // 类型为"int (*x)[3]" 

shapes[1][3]     // 类型为"int x[3]" (也就是 "int *x") 

shapes[1][3][0]  // 类型为"int x"

#include <stdio.h>
int main()
{
    int a[]={1,2,3,4,5};
    int b[]={2,2,3,4,5};
    int c[]={3,2,3,4,5};
    int *p[3]={a,b,c}; //指针数组，数组元素为指向int的指针
    int i;
    for (i=0;i<3;i++)
        printf ( "%d - %s\n" ,*p[i],&p[i]);
    //getch();
return 0;
}
/*
如果是int *p[]={a,b,c};
output:
1 - ��P���P���P�
2 - ��P���P�
3 - ��P�
如果是int *p[3]={a,b,c};
1 - ��A���A���A�
2 - ��A���A�
3 - ��A�
*/

　　

char**Data[70]={NULL};

一个包含70个指向char指针的指针数组

分配70*sizeof（char**）比特的空间，也就是70*4=280比特空间