指針數組的使用方法

① 指針數組的創建和用法

創建：
（1）聲明一個數組，聲明時用常量表達式指定數組維數，然後可以用數組名訪問數組元素。
（2）聲明一個變長數組，聲明時用變數表達式指定數組維數，然後用數組名來訪問數組元素。
（3）聲明一個指針，調用malloc()，然後使用該指針來訪問數組元素。malloc接受一個參數：所需內存位元組數。然後malloc()找到可用內存中一個大小合適的塊。內存是匿名的；也就是說，malloc()分配了內存，但沒有為它指定名字。然而，它卻可以返回那塊內存第一個位元組的地址。因此，可以把那個地址賦值給一個指針變數，並使用該指針來訪問那塊內存。因為char代表一個位元組，所以傳統上曾將malloc()定義為指向char的指針類型。然而，ANSI
C標准使用了一個新類型：指向void的指針。這一類型被用作「通用指針」。函數malloc()可用來返回數組指針、結構指針等等，因此一般需要把返回值的類型指派為適當的類型。如果malloc()找不到所需的空間，它將返回空指針。我們使用malloc()來創建一個數組，可以在程序運行時使用malloc()請求一個存儲塊，另外還需要一個指針來存放該塊在內存中的位置。例如，考慮以下代碼：

double * ptd;
ptd = (double
*)malloc(30*sizeof(double));

使用第二種或第三種方法可以做一些用普通的數組聲明做不到的事；創建一個動態數組(dynamic
array)，即一個在程序運行時才分配內存並可在程序運行時選擇大小的數組。例如，假定n是一個整數變數。在C99之前，不能這樣做：

double item[n]; /*如果n是一個變數，C99之前不允許這樣做*/

然而，即使在C99之前的編譯器中，也可以這樣做：
ptd=(double
*)malloc(n*sizeof(double));

變長數組VLA和malloc的用法有兩點區別。一個區別在於VLA是自動存儲的。自動存儲的結果之一就是VLA所用內存空間在運行完定義部分之後會自動釋放。因此不必使用free()。另一方面，使用由malloc()創建的數組不必局限在一個函數中。例如，函數可以創建一個數組並返回指針，供調用該函數的函數訪問。接著，後者可以在它結束時調用free()。free()可以使用不同於malloc()指針的指針變數；必須一致的是指針中存儲的位置。

用法：
//注意指針數組和數組指針分別是如何指向二維數組的
#include
<stdio.h>
main()
{

static int m[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};

int (*p)[4];//數組指針 p是指針，指向一維數組,每個一維數組有4個int元素*p是個數組的地址，**p就是數組元素了

int i,j;

int *q[3];//指針數組 q是數組，數組元素是指針，3個int指針

p=m; //p是指針，可以直接指向二維數組

printf("--數組指針輸出元素--\n");

for(i=0;i<3;i++)

{

for(j=0;j<4;j++)

{

printf("] ",*(*(p+i)+j));

}

printf("\n");

}

printf("\n");

for(i=0;i<3;i++,p++)//p可看成是行指針

{

printf("= ",**p);//每一行的第一個元素

printf("= ",*(*p+1));//每一行的第二個元素

printf("= ",*(*p+2));//每一行的第三個元素

printf("= ",*(*p+3));//每一行的第四個元素

printf("\n");

}

printf("\n");

printf("--指針數組輸出元素--\n");

for(i=0;i<3;i++)

q[i]=m[i];//q是數組，元素q[i]是指針

for(i=0;i<3;i++)

{

for(j=0;j<4;j++)

{

printf("= ",q[i][j]);//q[i][j]可換成*(q[i]+j)

}

printf("\n");

}

printf("\n");

q[0]=m[0];

for(i=0;i<3;i++)

{

for(j=0;j<4;j++)

{

printf("= ",*(q[0]+j+4*i));

}

printf("\n");

}

printf("\n");
}

② C語言 指針數組的使用

int**a可以表達一個二維數組。為什麼呢？

你可以這么理解*p[3]表達的是一個數組指針，這個指針p[0]表示的是數組存的第一個地址。而數組實際上是一串連續地址的塊。每一個小塊存著一個內容。每次訪問數組時，你為什麼可以用數組名+下標訪問呢？//比如a[i]；

實際上就是訪問*a+i;*這個符號可以表示你存的是變數的地址。而數組地址的第一位為int類型變數存的地址(你可以直接使用數組的地址加上單位變數的空間的大小去訪問下個元素)。在這個程序中int*p[3]表示可以存三個int類型的地址。而p正好把二維數組的三個一維數組的開頭的int類型變數的地址給存起來了。

給你舉個例子

實際上p[i]與 *（p+i）是表達的是同一個意思。只不過只有數組可以定義一個連續的空間

（數組的第一個地址是隨機的其他的是連續的。）單獨用指針的話會隨機分配的

數組的指針可以存三個地址。當然可以訪問二維數組了。

③ c＋＋指針數組怎麼用，還有指針數組和數組指針

指針的數組和整型的數組是指一個數組，其中每一個元素是指針類型；
數組的指針是指一個數組的首元素的地；
參考實例應用如下：
//注意指針數組和數組指針分別是如何指向二維數組的；
#include <stdio.h>
main()
{
static int m[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};/* 定義二維數組m並初始化*/
int (*p)[4];//數組指針 p是指針，指向一維數組,每個一維數組有4個int元素
int i,j;
int *q[3];//指針數組 q是數組，數組元素是指針，3個int指針
p=m; //p是指針，可以直接指向二維數組
printf("--數組指針輸出元素--/n");
for(i=0;i<3;i++)/*輸出二維數組中各個元素的數值*/
{
for(j=0;j<4;j++)
{
printf("%3d ",*(*(p+i)+j));
}
printf("/n");
}
printf("/n");
for(i=0;i<3;i++,p++)//p可看成是行指針
{
printf("%3d ",**p);//每一行的第一個元素
printf("%3d ",*(*p+1));//每一行的第二個元素
printf("%3d ",*(*p+2));//每一行的第三個元素
printf("%3d ",*(*p+3));//每一行的第四個元素
printf("/n");
}
printf("/n");
printf("--指針數組輸出元素--/n");
for(i=0;i<3;i++)
q[i]=m[i];//q是數組，元素q[i]是指針
for(i=0;i<3;i++)
{
for(j=0;j<4;j++)
{
printf("%3d ",q[i][j]);//q[i][j]可換成*(q[i]+j)
}
printf("/n");
}
printf("/n");
q[0]=m[0];
for(i=0;i<3;i++)
{
for(j=0;j<4;j++)
{
printf("%3d ",*(q[0]+j+4*i));
}
printf("/n");
}
printf("/n");

}

④ 數組指針怎麼使用

可以這樣來
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
char *d[4];
d[0]=malloc(1*sizeof(char));
strcpy(d[0],"web");
printf("%s",d[0]);
return 0;
}
此時*d[]為一個指向指針的指針
d[0]=malloc(1*sizeof(char));
此句話的意思是，分配1個位元組的內存空間給d[0]，也就意味著d這個數組的第一個元素[0]內保存的是一個1位元組空間的地址，因為d[0]指向一個地址！

你可以這樣理解
對於普通的數組(例如 char d[4];)，在內存中是這樣的
變數:內存地址:內容
d[0]:0x400000h:'w'
d[1]:0x400001h:'e'
d[2]:0x400002h:'b'
d[3]:0x400003h:'\0'
而在此處 char *d[4]; *d[0] = malloc(1*sizeof(char));，是這樣的'
d[0]:0x400000h:0x400100h
d[1]:0x400001h:0x400101h
d[2]:0x400002h:0x400102h
d[3]:0x400003h:0x400103h
而在內存0x400100h處
才保存著"web\0"

不好意思，我上面說錯了，應該是
d[0]:0x400000h:0x400100h
d[1]:0x400001h:NULL
d[2]:0x400002h:NULL
d[3]:0x400003h:NULL
而在內存0x400100h處
0x400100h:'w'
0x400101h:'e'
0x400102h:'b'
0x400103h:'\0'

對應的，你的代碼執行後，內存變數應該是這樣的
d[0]:0x400000h:0x400100h
d[1]:0x400001h:0x400104h
d[2]:0x400002h:0x400108h
d[3]:0x400003h:NULL
在內存0x400100處:
0x400100h:'w'
0x400101h:'e'
0x400102h:'b'
0x400103h:'\0'
0x400104h:隨機字元
......
0x400108h:隨機字元

以上內存地址是以位元組方式內存對齊的，用一些編譯器編譯後可能地址會有些問題(比如d[0]到d[1]不止差了4，可能是8)，但總體框架就是這樣！

⑤ 指針數組怎麼使用

在C語言和C++等語言中，數組元素全為同一類指針變數的數組稱為指針數組，指針數組中的元素都必須具有相同的存儲類型、指向相同數據類型的指針變數。指針數組比較適合用來指向若干個字元串，使字元串處理更加方便、靈活。一維指針數組的定義形式為：「類型名 *數組標識符[數組長度]」。

⑥ c＋＋指針數組怎麼用

指針數組，是指一個數組裡面裝著指針；

一下是指針數組的使用案例：

#include "stdafx.h"

#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])

{

int *ptr[5]; //指針數組

int p = 5, p2 = 8, *page, *page2;

page = &p;

page2 = &p2;

ptr[0] = &p;

ptr[1] = page2;

cout << *ptr[0] << endl;

cout << *page << endl;

cout << *ptr[1] << endl;

return 0;

}

運行結果：

⑦ 指針數組函數的用法

請參考：
#include <stdio.h>

const int fun1(int a,int b)
{
return a+b;
};
const int fun2(int a,int b)
{
return a-b;
};

typedef const int (* Fun)(int a,int b); //把 int 返回值 兩個int參數的函數定義成Fun函數指針類型

int main()
{
Fun f[2]={fun1,fun2}; //形式相同的函數指針數組,方便函數的統一管理
int temp[2];
/*
int i;
for(i=0;i<2;i++)
temp[i]=f[i](1,1);
*/
temp[0]=f[0](3,6);
temp[1]=f[1](7,4);
printf("%d %d\n",temp[0],temp[1]);
return 0;
}

⑧ 二維數組與指針、指針數組、數組指針的用法

二維數組和指針⑴ 用指針表示二維數組元素。
要用指針處理二維數組，首先要解決從存儲的角度對二維數組的認識問題。我們知道，一個二維數組在計算機中存儲時，是按照先行後列的順序依次存儲的，當把每一行看作一個整體，即視為一個大的數組元素時，這個存儲的二維數組也就變成了一個一維數組了。而每個大數組元素對應二維數組的一行，我們就稱之為行數組元素，顯然每個行數組元素都是一個一維數組

下面我們討論指針和二維數組元素的對應關系，清楚了二者之間的關系，就能用指針處理二維數組了。
設p是指向二維數組a[m][n]的指針變數，則有：

int* p=a[0];//此時P是指向一維數組的指針。P++後，p指向 a[0][1]。

如果定義int (*p1)[n];p1=a;p1++後，p1指向a[1][0];

則p+j將指向a[0]數組中的元素a[0][j]。
由於a[0]、a[1]┅a[M-1]等各個行數組依次連續存儲，則對於a數組中的任一元素a[i][j]，指針的一般形式如下：
p+i N+j 相應的如果用p1來表示，則為 (p1+i)+j
元素a[i][j]相應的指針表示為：
( p+i N+j) 相應的如果用p1來表示，則為 ( (p1+i)+j)
同樣，a[i][j]也可使用指針下標法表示，如下：
p[i N+j]
例如，有如下定義：
int a[3][4]={{10,20,30,40,},{50,60,70,80},{90,91,92,93}};
則數組a有3個元素，分別為a[0]、a[1]、a[2]。而每個元素都是一個一維數組，各包含4個元素，如a[1]的4個元素是a[1][0]、a[1][1]、a[1]2]、a[1][3]。
若有：
int p=a[0];
則數組a的元素a[1][2]對應的指針為：p+1 4+2
元素a[1][2]也就可以表示為：( p+1 4+2)
用下標表示法，a[1][2]表示為：p[1 4+2]
特別說明：
對上述二維數組a，雖然a[0]、a都是數組首地址，但二者指向的對象不同，a[0]是一維數組的名字，它指向的是a[0]數組的首元素，對其進行「 」運算，得到的是一個數組元素值，即a[0]數組首元素值，因此， a[0]與a[0][0]是同一個值；而a是一個二維數組的名字，它指向的是它所屬元素的首元素，它的每一個元素都是一個行數組，因此，它的指針移動單位是「行」，所以a+i指向的是第i個行數組，即指向a[i]。對a進行「 」運算，得到的是一維數組a[0]的首地址，即 a與a[0]是同一個值。當用int p;定義指針p時，p的指向是一個int型數據，而不是一個地址，因此，用a[0]對p賦值是正確的，而用a對p賦值是錯誤的。這一點請讀者務必注意。
⑵ 用二維數組名作地址表示數組元素。
另外，由上述說明，我們還可以得到二維數組元素的一種表示方法：
對於二維數組a，其a[0]數組由a指向，a[1]數組則由a+1指向，a[2]數組由a+2指向，以此類推。因此， a與a[0]等價、 (a+1)與a[1]等價、 (a+2)與a[2]等價，┅，即對於a[i]數組，由*(a+i)指向。由此，對於數組元素a[i][j]，用數組名a的表示形式為：
( (a+i)+j)
指向該元素的指針為：
*(a+i)+j
數組名雖然是數組的地址，但它和指向數組的指針變數不完全相同。

第一，指針變數的值可以改變，即它可以隨時指向不同的數組或同類型變數，而數組名自它定義時起就確定下來，不能通過賦值的方式使該數組名指向另外一個數組。

第二，數組名是指針，類型是指向元素類型的指針，但值是指針常量，聲明數組時編譯器會為聲明所指定的元素數量保留內存空間。數組指針是指向數組的指針，聲明指針變數時編譯器只為指針本身保留內存空間。

例4 求二維數組元素的最大值。

該問題只需對數組元素遍歷，即可求解。因此，可以通過順序移動數組指針的方法實現。
main()
{
int a[3][4]={{3,17,8,11},{66,7,8,19},{12,88,7,16}};
int p,max;
for(p=a[0],max= p;p<a[0]+12;p++)
if( p>max)
max= p;
printf("MAX=%d/n",max);
}
執行結果：
MAX=88
這個程序的主要演算法都是在for語句中實現的：p是一個int型指針變數；p=a[0]是置數組的首元素地址為指針初值；max= p將數組的首元素值a[0][0]作為最大值初值；p<a[0]+12是將指針的變化范圍限制在12個元素的位置內；p++使得每比較一個元素後，指針後移一個元素位置。
例5 求二維數組元素的最大值，並確定最大值元素所在的行和列。
本例較之上例有更進一步的要求，需要在比較的過程中，把較大值元素的位置記錄下來，顯然僅用上述指針移動方法是不行的，需要使用能提供行列數據的指針表示方法。
main()
{
int a[3][4]={{3,17,8,11},{66,7,8,19},{12,88,7,16}};
int p=a[0],max,i,j,row,col;
max=a[0][0];
row=col=0;
for(i=0;i<3;i++)
for(j=0;j<4;j++)
if( (p+i4+j)>max)
{
max= (p+i 4+j);
row=i;
col=j;
}
printf("a[%d][%d]=%d/n",row,col,max);
}
程序運行結果：
a[2][1]=88
⑶ 行數組指針
在上面的說明中我們已經知道，二維數組名是指向行的，它不能對如下說明的指針變數p直接賦值：
int a[3][4]={{10,11,12,13},{20,21,22,23},{30,31,32,33}}, p;
其原因就是p與a的對象性質不同，或者說二者不是同一級指針。C語言可以通過定義行數組指針的方法，使得一個指針變數與二維數組名具有相同的性質。行數組指針的定義方法如下：
數據類型 ( 指針變數名)[二維數組列數]；
例如，對上述a數組，行數組指針定義如下：
int ( p)[4];
它表示，數組 p有4個int型元素，分別為( p)[0]、( p)[1]、( p)[2]、( p)[3] ，亦即p指向的是有4個int型元素的一維數組，即p為行指針

此時，可用如下方式對指針p賦值：

p=a;

(4)指針數組的定義

指針數組是指每個元素中存放的是指針。定義為 int *p[4];sizeof(p)=16,返回的是數組的總空間