1. 程式人生 > >給字元陣列賦值的方法

給字元陣列賦值的方法

main()
{
char s[30];
strcpy(s, "Good News!"); /*給陣列賦字串*/
.
.
.
}
上面程式在編譯時, 遇到char s[30]這條語句時, 編譯程式會在記憶體的某處留
出連續30個位元組的區域, 並將第一個位元組的地址賦給s。當遇到strcpy( strcpy 為
Turbo C2.0的函式)時, 首先在目標檔案的某處建立一個"Good News!/0" 的字串。
其中/0表示字串終止, 終止符是編譯時自動加上的, 然後一個字元一個字元地復
制到s所指的記憶體區域。因此定義字串陣列時, 其元素個數至少應該比字串的
長度多1。
注意:
1. 字串陣列不能用"="直接賦值, 即s="Good News!"是不合法的。所以應分
清字串陣列和字串指標的不同賦值方法。
2. 對於長字串, Turbo C2.0允許使用下述方法:
例如:
main()
{
char s[100];
strcpy(s, "The writer would like to thank you for"
"your interest in his book. He hopes you"
"can get some helps from the book.");
.
.
.
}


指標陣列賦值
 


例如:
main()
{
char *f[2];
int *a[2];
f[0]="thank you"; /*給字元型陣列指標變數賦值*/
f[1]="Good Morning";
*a[0]=1, *a[1]=-11; /*給整型數陣列指標變數賦值*/
.
.
.
}

------------------------------------------------------------------------------------------------------------------

補充:

無論是靜態,區域性還是全域性陣列只有在定義時才能初始話,否則必須通過其它方法

,比如迴圈操作實現。

任何
int a[3];
static int b[3];
a[3] = {1, 2, 3};
b[3] = {1, 2, 3};
沒有在定義時初始化都是錯誤的!

-------------------------------------------------------------------------------------------------------------------

以下是轉載:
學了這麼多年的C語言,突然發現連字串賦值都出錯,真的很傷心。

char a[10];
怎麼給這個陣列賦值呢?
1、定義的時候直接用字串賦值
char a[10]="hello";
注意:不能先定義再給它賦值,如char a[10]; a[10]="hello";這樣是錯誤的!
2、對陣列中字元逐個賦值
char a[10]={'h','e','l','l','o'};
3、利用strcpy
char a[10]; strcpy(a, "hello");

易錯情況:
1、char a[10]; a[10]="hello";//一個字元怎麼能容納一個字串?況且a[10]也是不存在的!
2、char a[10]; a="hello";//這種情況容易出現,a雖然是指標,但是它已經指向在堆疊中分配的10個字元空間,現在這個情況a又指向資料區中的hello常量,這裡的指標a出現混亂,不允許!

還有:不能使用關係運算符“==”來比較兩個字串,只能用strcmp() 函式來處理。


C語言的運算子根本無法操作字串。在C語言中把字串當作陣列來處理,因此,對字串的限制方式和對陣列的一樣,特別是,它們都不能用C語言的運算子進行復制和比較操作。


直接嘗試對字串進行復制或比較操作會失敗。例如,假定str1和str2有如下宣告:

char str1[10], str2[10];

利用=運算子來把字串複製到字元陣列中是不可能的:

str1 = "abc";     /*** WRONG ***/

str2 = str1;       /*** WRONG ***/

C語言把這些語句解釋為一個指標與另一個指標之間的(非法的)賦值運算。但是,使用=初始化字元陣列是合法的:

char str1[10] = "abc";

這是因為在宣告中,=不是賦值運算子。

試圖使用關係運算符或判等運算子來比較字串是合法的,但不會產生預期的結果:

if (str1==str2) ...    /*** WRONG ***/

這條語句把str1和str2作為指標來進行比較,而不是比較兩個陣列的內容。因為str1和str2有不同的地址,所以表示式str1 == str2的值一定為0。

-------------------------------------------------------------------------------------------------------------------------------------

有空再查下動態陣列的定義使用:

陣列到底應該有多大才合適,有時可能不得而知。所以希望能夠在執行時具有改變陣列大小的能力。
動態陣列就可以在任何時候改變大小。

通俗的說靜態陣列就是在定義陣列的時候,由作業系統分配的空間,比如
int a[10];
這就是在定義時由系統給你分配了10個int型別的空間,這個空間是可以初始化的,比如
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
那麼在這個定義之後,系統會首先分配10個int型別的儲存空間,然後把大括號裡面的數字分別的,按順序放到這10個空間裡。你所做的只是寫這麼一句,而陣列賦值的操作就由系統完成了。當然,初始化與否看你的需求,初始化不是強制性操作,想初始化就初始化,不想也沒問題,還是上面的例子繼續:
int a[10];
這裡定義了,但是沒初始化,這沒有任何問題,以後你可以自己往裡面賦值,比如
a[1] = 8;
a[5] = 3;
或者
for(int i = 0; i < 10; i++)
    a[i] = i;
等等

對於動態陣列,不能被初始化,因為動態陣列在定義時只是個指標,比如
int *a;
這裡變數a只是個指向int型別的指標,而不是陣列。動態分配有10個int型別元素的陣列,如下:
a = (int) malloc(10*sizeof(int));
很明顯,指標a在定義的時候不能被初始化,比如這樣寫就是錯誤的:
int *a = {1,2,3,4,5,6,7,8,9,10}; /* 錯誤! */
因為a是隻有4個位元組的指標,沒有可用的儲存空間給需要初始化的變數。

----------------------------------------------------------------------------------------------------------------------------------------------------

第三節  初始化陣列

1.陣列的初始化

  陣列可以初始化,即在定義時,使它包含程式馬上能使用的值。
  例如,下面的程式碼定義了一個全域性陣列,並用一組Fibonacci數初始化:
    
int iArray[10]={1,1,2,3,5,8,13,21,34,55); //初始化
    void main()
    {
      //...
    }

  初始化陣列的值的個數不能多於陣列元素個數,初始化陣列的值也不能通過跳過逗號的方式來省略,這在C中是允許的,但在C++中不允許。
  例如,下面的程式碼對陣列進行初始化是錯誤的:
    int arrayl[5]={1,2,3,4,5,6}; //error: 初始化值個數多於陣列元素個數
   
 int array2[5]={1,,2,3,4}; //error:初始化值不能省略
    int array3[5]={1,2,3,}; //error:初始化值不能省略
    int array4[5]={}; //error:語法格式錯誤
    void main()
    {
      //...
    }

  初始化值的個數可少於陣列元素個數。當初始化值的個數少於陣列元素個數時,前面的按序初始化相應值, 後面的初始化為0(全域性或靜態陣列)或為不確定值(區域性陣列)。
  例如,下面的程式對陣列進行初始化:
   
 //*********************
    //**   ch7_2.cpp  **
    //*********************

    #include <iostream.h>

    int array1[5]={1,2,3};
    static int array2[5]={1};

    void main()
    {
     int arr1[5]={2};
     static int arr2[5]={1,2};

     int n;
     cout <<"global:/n";
     for(n=0; n<5; n++)
       cout <<" " <<array1[n];

     cout <<"/nglobal static:/n";
     for(n=0; n<5; n++)
       cout <<" " <<array2[n];

     cout <<"/nlocal:/n";
     for(n=0; n<5; n++)
       cout <<" " <<arr1[n];

     cout <<"/nlocal static:/n";
     for(n=0; n<5; n++)
        cout <<" " <<arr2[n];
     cout <<endl;

    }

  執行結果為:
    
global:
     l  2  3  0  0
    global static:

     1  0  0  0  0
    local:
     2 23567 23567 23567 23567
    local static:
     1  2  0  0  0

  例中,全域性陣列和全域性靜態陣列的初始化是在主函式執行之前完成的,而區域性陣列和區域性靜態陣列的初始化是在進入主函式後完成的。
  全域性陣列arrayl[5]對於初始化表的值按序初始化為1,2,3,還有兩個元素的值則按預設初始化為0。
  全域性靜態陣列array2[5]與全域性陣列的初始化情況一樣,初始化表值(1)表示第1個元素的值,而不是指全部陣列元素都為1。
  區域性陣列arrl[5]根據初始化表值的內容按序初始化, 由於初始化表值只有1個,所以還有4個元素的值為不確定。在這裡均為數值23567。
  區域性靜態陣列arr2[5]先根據初始化表按序初始化,其餘3個數組元素的值預設初始化為0。

2.初始化字元陣列


  初始化字元陣列有兩種方法,一種是:
    char array[10]={"hello"};
  另一種是:
    char array[10]={'h','e','l','l','/0'};
  第一種方法用途較廣,初始化時,系統自動在陣列沒有填值的位置用,'/0'補上。另外, 這種方法中的花括號可以省略,即能表示成:
    char array[10]="hello";
  第二種方法一次一個元素地初始化陣列,如同初始化整型陣列。這種方法通常用於輸入不容易在鍵盤上生成的那些不可見字元。
  例如,下面的程式碼中初始化值為若干製表符:
    char chArray[5]={'/t','/t','/t','/t','/0')
  這裡不要忘記為最後的,'/0'分配空間。如果要初始化一個字串"hello",那為它定義的陣列至少有6個數組元素。
  例如,下面的程式碼給陣列初始化,但會引起不可預料的錯誤:
    char array[5]="hello";
  該程式碼不會引起編譯錯誤,但由於改寫了陣列空間以外的記憶體單元,所以是危險的。

3.省略陣列大小


  有初始化的陣列定義可以省略方括號中的陣列大小。
  例如,下面的程式碼中陣列定義為5個元素:
    int a[]={2,4,6,8,10};
  編譯時必須知道陣列的大小。通常,宣告陣列時方括號內的數字決定了陣列的大小。有初始化的陣列定義又省略方括號中的陣列大小時,編譯器統計花括號之間的元素個數,以求出陣列的大小。
  例如,下面的程式碼產生相同的結果:
 static int a1[5]={1,2,3,4,5};
    static int a2[]={1,2,3,4,5};

  讓編譯器得出初始化陣列的大小有幾個好處。它常常用於初始化一個元素個數在初始化中確定的陣列,提供程式設計師修改元素個數的機會。
  在沒有規定陣列大小的情況下,怎麼知道陣列的大小呢? sizeof操作解決了該問題。 例如,下面的程式碼用sizeof確定陣列的大小:

//*********************
    //** ch7_3.cpp **
    //*********************

    #include <iostream.h>

    void main()
    {
     static int a[]={1,2,4,8,16};
     for(int i=0; i<(sizeof(a)/sizeof(int)); i++)
     cout <<a[i] <<" ";
     cout <<endl;
    }

  執行結果為:
    1 2 4 8 16
  sizeof操作使for迴圈自動調整次數。如果要從初始化a陣列的集合中增刪元素,只需重新編譯即可,其他內容無須更動。
  每個陣列所佔的儲存量都可以用sizeof操作來確定! sizeof返回指定項的位元組數。sizeof常用於陣列,使程式碼可在16位機器和32位機器之間移植:
  對於字串的初始化,要注意陣列實際分配的空間大小是字串中字元個數加上末尾的,'/0',結束符。
  例如,下面的程式碼定義一個字元陣列:

  //*********************
    //**   ch7_4.cpp  **
    //*********************

    #include <iostream.h>

    void main()
    {
     char ch[]="how are you";

     cout <<"size of array: " <<sizeof(ch) <<endl;
     cout <<"size of string: " <<strlen("how are you")            <<endl;
    }


  執行結果為:
    size of array:12
    size of string:ll

  例中,陣列大小為12,而字串長度為11。
  省略陣列大小隻能在有初始化的陣列定義中
  例如,下面的程式碼將產生一個編譯錯誤:
    int a[];//error:沒有確定陣列大小
  在定義陣列的場合,無論如何,編譯器必須知道陣列的大小。