9-1 陣 列 ( Array )
在 電 腦 資 料 之 處 理 與 檔 案 間 的 資 料 交 換 中 , 常 常 需 要 大 量 的
記 憶 空 間 來 暫 存 這 些 資 料 , 但 是 為 了 有 系 統 , 有 規 則 的 放 置 與 暫 存 , C 語 言 提 供 了 陣 列 (
array ) 來 儲 存 資 料 , 因 此 大 大 提 升 了 程 式 的 工 作 效 率 , 也 能 充 分 有 效 的 來 使 用 記 憶 體 . C
語 言 提 供 陣 列 的 資 料 型 態 包 含 了 整 數 ( int ) , 浮 點 數 ( float ) , 字 元 ( char ) , 在 存 取
型 態 方 面 也 提 供 了 靜 態 ( static ) , 外 部 ( extern ) 陣 列 型 態 . ( 用 法 與 特 性 請 參 考 相 關
之 章 節 ) . 而 陣 列 的 排 列 方 式 亦 分 為 一 維 , 二 維 , 三 維 ... 等 等 . 我 們 就 以 一 維 與 二 維 陣 列
加 以 討 論 .
9-1-1 一 維 陣 列
<1> 一 維 陣 列 的 宣 告 方 式 如 下 所 述 :
陣列的資料型態 陣列的名稱 [ 陣列的大小 ] ;
For example : int array1 [ 20 ] ; float array2 [ 25 ] ; char array3 [ 50 ] ;
┌────┬────┬────┬────┬────┐
│ A[0] │ A[1] │ A[2] │ ...... │ A[n-1] │
└────┴────┴────┴────┴────┘
int score[5]={ 1, 2, 3 ,4 ,5 };
main()
{
int score[5]; /* 陣列宣告 */
.
.
score[0]=1; /* 程式本體 */
score[1]=2;
score[2]=3;
score[3]=4;
score[4]=5;
.
.
}
Example 9-1-1 :
#include < stdio.h >
main()
{
int count,total=0;
int number[10]={ 1,2,3,4,5,6,7,8,9,10 };
for( count=0 ; count < 10 ; ++count )
{
printf("number[%d]=%d\n",count,number[count]);
total=total+number[count];
}
printf("1+2+3+4+5+6+7+8+9+10=%d\n",total);
}
執 行 結 果 :
number[0]=1
number[1]=2
number[2]=3
number[3]=4
number[4]=5
number[5]=6
number[6]=7
number[7]=8
number[8]=9
number[9]=10
1+2+3+4+5+6+7+8+9+10=55
9-1-2 二 維 陣 列
<1> 二 維 陣 列 的 宣 告 方 式 如 下 所 述 :
陣列的資料型態 陣列的名稱 [ 列陣列的大小 ][ 行陣列大小 ] ;
For example :
int array1 [ 10 ][ 20 ] ;
float array2 [ 5 ][ 25 ] ;
char array3 [ 100 ][ 50 ] ;
行 (column)
┌─────┬─────┬─────┬────┬──────┐
列 │ A[0][0] │ A[0][1] │ A[0][2] │ ...... │A[0][n-1] │
├─────┼─────┼─────┼────┼──────┤
(row)│ A[1][0] │ A[1][1] │ A[1][2] │ ...... │A[1][n-1] │
├─────┼─────┼─────┼────┼──────┤
│ A[2][0] │ A[2][1] │ A[2][2] │ ...... │A[2][n-1] │
├─────┼─────┼─────┼────┼──────┤
│ . │ . │ . │ . │ . │
├─────┼─────┼─────┼────┼──────┤
│ . │ . │ . │ . │ . │
├─────┼─────┼─────┼────┼──────┤
│A[m-1][0] │A[m-1][1] │A[m-1][2] │ ...... │A[m-1][n-1] │
└─────┴─────┴─────┴────┴──────┘
int score1[2][5]={{ 1, 2, 3, 4, 5 },{ 5, 4, 3, 2, 1 }};
main()
{
int score1[2][5]; /* 陣列宣告 */
.
.
score1[0][0]=1; /* 程式本體 */
score1[0][1]=2;
score1[0][2]=3;
score1[0][3]=4;
score1[0][4]=5;
score1[1][0]=5;
score1[1][1]=4;
score1[1][2]=3;
score1[1][3]=2;
score1[1][4]=1;
.
.
}
Example 9-1-2 :
#include < stdio.h >
main()
{
int count,count1;
int _nine[2][9]={{1,2,3,4,5,6,7,8,9},
{1,2,3,4,5,6,7,8,9}};
printf("9 x 9 list :\n");
for( count=0 ; count< 9 ; ++count )
for( count1=0 ; count1<9 ; ++count1 )
printf("%2dx%2d=%2d\n",_nine[0][count],_nine[1][count1]
,_nine[0][count]*_nine[1][count1]);
}
執 行 結 果 :
9 x 9 list :
1x 1= 1
1x 2= 2
1x 3= 3
1x 4= 4
1x 5= 5
1x 6= 6
1x 7= 7
1x 8= 8
1x 9= 9
2x 1= 2
2x 2= 4
.
.
.
.
9x 5=45
9x 6=54
9x 7=63
9x 8=72
9x 9=81
9-1-3 字 元 陣 列
<1> 字 元 陣 列 的 宣 告 方 式 如 下 所 述 :
char 陣列的名稱 [ 陣列的大小 ] ;
char 陣列的名稱 [ 列陣列的大小 ][ 行陣列大小 ] ;
For example :
char array1 [ 10 ] ;
char array2 [ 5 ][ 25 ] ;
例一 :
int string[6]={'A','B','C','D','E','\0'};
或 int string[5]="ABCDE";
例二 :
int string1[2][6]={{'A','B','C','D','E','\0'},
{'F','G','H','I','J','\0'}};
或 int string1[2][5]={ "ABCDE","FGHIJ" };
main()
{
int string[6]; /* 陣列宣告 */
.
.
score1[0]='M'; /* 程式本體 */
score1[1]='E';
score1[2]='R';
score1[3]='R';
score1[4]='Y';
score1[5]='\0';
strcpy(string,"MERRY"); /* 將 "MERRY" 字串拷貝至
string 陣列中 */
.
.
}
Example 9-1-3 :
#include < stdio.h >
main()
{
char string1[5]={'A','B','C','D','E'};
char string2[6]={'A','B','C','D','E','\0'};
char string3[6]="ABCDE\0";
char string4[5]="ABCDE";
printf("string1 = \"%s\"\n",string1);
printf("string2 = \"%s\"\n",string2);
printf("string3 = \"%s\"\n",string3);
printf("string4 = \"%s\"\n",string4);
}
執 行 結 果 :
string1 = "ABCDE�ABCDE" /*此字串是否有些不一樣?*/
string2 = "ABCDE"
string3 = "ABCDE"
string4 = "ABCDE"
9-1-4 陣 列 與 基 本 輸 出 / 輸 入 函 數 的 搭 配
無 論 是 整 數 , 浮 點 數 或 字 元 陣 列 (字串 )
均 可 與 基 本 輸 出 / 輸 入 函 數 的 搭 配 . 例 如 一 名 叫 array1 的 字 元 陣 列 :
printf("%s\n",array1);
puts(array1);
scanf("%s",array1);
gets(array1);
變數資料型態 *變數名稱 ;
例如:
int *p ;
由 以 上 的 宣 告 , 表 示 了 三 件 事 [1] p 為 指 標 變 數 . [2] p 代 表 一 個 位 址 , 而 *p 代 表 此
位 址 的 資 料 . [3] p 所 指 向 此 位 址 之 變數 型 態 為 整 數 ( int ) .
Example 9-2-1 :
#include < stdio.h >
main()
{
int x=10;
int *y;
y=&x;
printf(" x = %d\n", x);
printf("&x = %x\n",&x);
printf("*y = %d\n",*y);
printf(" y = %x\n", y);
}
執行結果 :
x = 10
&x = ffda
*y = 10
y = ffda
9-2-2 指 標 與 函 數 間 的 關 係
關 於 函 數 呼 叫 的 方 式 中 , Call by value 的 引 數 傳 遞 方 式
, 被 呼 叫 函 數 不 能 直 接 更 改 呼 叫 函 數 中 的 變 數 , 但 如 果 是 以 指 標 當 作 函 數 的 引 數 ( Call by
reference ) , 則 上 述 的 狀 況 均 迎 刃 而 解 , 而 且 也 不 受 函 數 返 回 值 ( return ) 只 能 有 一 個 的
影 響 . 請 參 考 Example 9-2-2 .
Example 9-2-2 :
#include < stdio.h >
main()
{
int m=3,n=4;
printf(" m = %d n= %d \n\n",m,n);
change(&m,&n);
printf(" m = %d n= %d \n",m,n);
}
change(x,y)
int *x,*y;
{
int temp;
temp=*x;
*x=*y;
*y=temp;
}
執行結果 :
m = 3 n= 4
m = 4 n= 3
9-2-3 指 標 與 陣 列 的 關 係
我 們 學 習 了 指 標 9-1-1 的 課 程 , 我 們 知 道 變 數 前 需 加 "
& " 符 號 或 使 用 指 標 變 數 才 能 指 示 變 數 所 在 位 址 , 但 我 們 也 提 到 陣 列 本 身 也 是 一 個 位 址
, 所 以 我 們 可 以 將 指 標 與 陣 列 的 關 係 來 做 一 對 比 . 例 如 : 有 一 整 數 陣 列 名 為 array , 其 陣 列
大 小 為 五 個 , 其 內 容 分 別 是 1,2,3,4,5 .
例如 :
int array[5]={ 1,2,3,4,5 };
陣列位址 指標相對位址
┌────┐
array[0] │ 1 │ *(array+0)
├────┤
array[1] │ 2 │ *(array+1)
├────┤
array[2] │ 3 │ *(array+2)
├────┤
array[3] │ 4 │ *(array+3)
├────┤
array[4] │ 5 │ *(array+4)
└────┘
Example 9-2-3 :
#include < stdio.h >
main()
{
int array[5]={ 1,2,3,4,5 };
int count;
for ( count=0 ; count<5 ; ++count )
printf("array[%d]=%d <-----> *\(array+%d\)=%d\n",
count,array[count],count,*(array+count));
}
執行結果 :
array[0]=1 <-----> *(array+0)=1
array[1]=2 <-----> *(array+1)=2
array[2]=3 <-----> *(array+2)=3
array[3]=4 <-----> *(array+3)=4
array[4]=5 <-----> *(array+4)=5
9-2-4 指 標 與 字 元 陣 列 ( 字 串 ) 間 的 關 係
有 了 9-2-3 的 觀 念 後 , 便 很 容 易 駕 馭 這
個 章 節 . 我 們 很 快 的 來 參 考 Example 9-2-4 來 透 視 指 標 與 字 串 之 間 的 關 係 .
Example 9-2-4 :
#include < stdio.h >
main()
{
char string[7]="POINTER";
int count;
for ( count=0 ; count<7 ; ++count )
printf("string[%d]=%c <-----> *\(string+%d\)=%c\n",
count,string[count],count,*(string+count));
}
執行結果 :
string[0]=P <-----> *(string+0)=P
string[1]=O <-----> *(string+1)=O
string[2]=I <-----> *(string+2)=I
string[3]=N <-----> *(string+3)=N
string[4]=T <-----> *(string+4)=T
string[5]=E <-----> *(string+5)=E
string[6]=R <-----> *(string+6)=R