陣列與指標

九. 陣列與指標

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 ] ;

<2> 宣告陣列的位置為程式之最上端 .
<3> 一維陣列的排列結構如下圖所述 . 我們舉例一陣列名叫 A 的陣列 , 其陣列大小有 n 個 , 即為 A[n] .

           ┌────┬────┬────┬────┬────┐
           │  A[0]  │  A[1]  │  A[2]  │ ...... │ A[n-1] │
           └────┴────┴────┴────┴────┘

<4> 陣列大小的宣告 , 除了依自己的需要來定訂外 , 還需依編譯器在編譯時之記憶體型態及實際可用之記憶體大小而定 , 並不是想要多少就有多少 . 例如陣列名叫 A 的陣列 , 其陣列大小為 5 , 即為 A[5] , 其陣列的成員分別為 A[0] , A[1] ,A[2] , A[3] , A[4] 五個 .
<5> 如何存取陣列中之資料 ? 我們可以在宣告陣列時 , 指定數值給陣列 . 例如 :

                    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;
                            .
                            .
                    }

<6> 我們就一維陣列來舉一例子說明 . 請參考 example : 9-1-1 .


           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 ] ;

<2> 宣告陣列的位置為程式之最上端 .
<3> 二維陣列的排列結構如下圖所述 . 我們舉例一陣列名叫 A 的陣列 , 其列陣列大小有 m 個 , 行陣列大小有 n 個 , 即為 A[m][n] .

            行 (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] │
         └─────┴─────┴─────┴────┴──────┘

<4> 陣列大小的宣告 , 除了依自己的需要來定訂外 , 還需依編譯器在編譯時之記憶體型態及實際可用之記憶體大小而定 , 並不是想要多少就有多少 . 例如陣列名叫 A 的陣列 , 其列陣列大小為 2 , 行陣列大小有 5個 , 即為 A[2][5] , 其陣列的成員分別為 A[0][0] , A[0][1] , A[0][2] , A[0][3] , A[0][4] , A[1][0] , A[1][1] , A[1][2] , A[1][3] , A[1][4]十個 .
<5> 如何存取陣列中之資料 ? 我們可以在宣告陣列時 , 指定數值給陣列 . 例如 :

                  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;
                            .
                            .
                    }

<6> 我們就用九九乘法表的例子來說明二維陣列的使用 . 請參考 example : 9-1-2 .


           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 ] ;

<2> 宣告陣列的位置為程式之最上端 .
<3> 陣列大小的宣告 , 除了依自己的需要來定訂外 , 還需依編譯器在編譯時之記憶體型態及實際可用之記憶體大小而定 , 並不是想要多少就有多少 .
<4> 如何存取陣列中之資料 ? 我們可以在宣告陣列時 , 指定字元給陣列 . 例如 :

              例一 :
                      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 陣列中 */
                            .
                            .
                    }

<6> 由於以上敘述 , 我們知道如果字元陣列以字元的方式來存取陣列 , 則須加結束字元 \0 於陣列的最末端 , 表示此字元陣列的結束 . 例如 <3> 項例一所述 . 如果字元陣列以字串的方式來存取陣列 , 則 C 編譯器會自動在字串最末端加上結束字元 \0 表示此字元陣列的結束 , 所以我們不需自行加入 . 例如 <3> 項例二所述 . ( \0 表式零的八進位數 )
<7> 我們就來舉一例子說明 . 請參考 example : 9-1-3 .


           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);

所以 USER 可以自行參考相關的章節使用之 . 在此補充一點 , 上述所敘述 scanf 函數是乎少一個 & (位址運算元 ) ? ? ? 沒錯 ! 那是因為陣列本身的名稱即代表其位址之所在 , 所以不需在陣列名稱前加上 & 符號來代表位址 .

9-2 指標 ( pointer )

關於指標 , 對於一些 C 語言初學者而言是不易瞭解的一種很抽象 , 但又很實用的工具 . 相信只要大家對 C 語言有興趣 , 我們很快就能進入指標的世界裡 . 說了這麼多 , 那何謂指標呢 ? 簡單的說 " 它是一個用來指示資料存在於記憶體中的位址標示器 " , 簡稱指標 . 由指標的運用裡 , 使我們瞭解到資料與位址間的關係 , 進而對記憶體配置有很大的幫助 . 請參考下列章節 .

9-2-1 指標的基本觀念

<1> 在 C 語言中 , 指標變數的宣告方式如下 :

               變數資料型態   *變數名稱 ;

           例如:

                int  *p ;

由以上的宣告 , 表示了三件事 [1] p 為指標變數 . [2] p 代表一個位址 , 而 *p 代表此位址的資料 . [3] p 所指向此位址之變數型態為整數 ( int ) .
<2> 指標變數宣告的關鍵字為 " * " , 而指標變數的資料型態也分為整數 ( int ) , 浮點數 ( float ) , 字元 ( char ) 三種 .
<3> 我們曾在基本輸出入函數的章節提到位址運算元 " & " 與函數 scanf( ) 搭配使用 , 我們知道在變數前加上 " & " 符號表示該變數所在的位址 , 相對於指標的用法 , 其實是非常相似的 . 請參考 Example 9-2-1 .


           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 .


           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

回 SEE 思 C 教室

九. 陣 列 與 指 標

九. 陣列與指標