『壹』 c語言數組定義的幾種方式
數組的定義
數組就是指用於存儲同一類型數據的集合，一個數組實際上就是一連串的變數，數組按照使用可以分為一維數組、二維數組、多維數組
數組定義的方式
數組定義的方式有四種形式，分別是：
（1）類型名[] 數組名;
（2）類型名[] 數組名 = { 初始值列表 };
（3）類型名[] 數組名 = new 類型名[ 數組大小 ];
（4）類型名[] 數組名 = new 類型名[ 數組大小 ] { 初始值列表 };
數據類型：指的是數組元素的數據類型，常見的有整形、浮點型、與字元型等
數組名：是用來統一這組相同數據類型元素的名稱，其命名規則和變數的相同
『貳』 請問,什麼叫一維數組和二維數組呢
數組是一個由若干同類型變數組成的集合，引用這些變數時可用同一名字。數組均由連續的存儲單元組成，最低地址對應於數組的第一個元素，最高地址對應於最後一個元素，數組可以是一維的，也可以高吵判是多維的。
5.1 一維數組
一維數組的一般說明形式如下:
type-specifier var_name [size];
在C語言中，數組必須顯示地說明，以便編譯程序為它們分配內存空間。在上式中，類型說明符指明數組的類型，也就是數組中每一個元素個數，一維數組的總位元組數可按下式計算:
sizeof( 類型) *數組長度＝ 總位元組數
[例5-1] 將數字0到9裝入一個整型數組。
main( )
{
int x[10]; /* 定義包含1 0個整型數的數組，引用為x [ 0 ] ，x [ 1 ] . . . x [ 9 ] * /
int t ;
for (t=0; t<10;++t) x[t]=t;
}
C語言並不檢驗數組邊界，因此，數組的兩端都有可能越界而使其它變數的數組甚至程序代碼被破壞。在需要的時候，數組的邊界檢驗便是程序員的職責。例如，當使用gets( )接收字元輸入時，必須確認字元數組的長度足以存放最長的字元串。
一維數組在本質上是由同類數據構成的表，例如，對下列數組a :
char a[7]
圖5 - 1說明了數組a在內存中的情形，假定起始地址為1000。
5.1.1 向函數傳遞一維數組
將一維數組傳遞給函數時，把數組名作為參數直接調用函數即可，無需任何下標。這樣，數組的第一個元素的地址將傳遞給該函數。C語言並不是將整個數組作為實參來傳遞，而是用指針來代替它。例如，下面的程序將數組i的第一個元素的地址傳遞給函數func1( )。
main( )
{
int i[10];
func1(i); /*函數調用，實參是數組名* /
. . .
}
函數若要接收一維數組的傳遞，則可以用下面的二種方法之一來說明形式參數； 1) 有界數組；2) 無界數組。例如，函數func1 ( )要接收數組i可如下說明:
func1(str)
char str[10]; /* 有界數組，數組的下標只能小於或等於傳遞數組的大小。* /
{
.
. .
}
也可說明為:
func1(str)
char str[ ]; / * 無界數組* /
{
.
. .
}
這二種說明方法的效果是等價的，它們都通知編譯程序建立一個字元指針。第一種說明使用的是標準的數組說明；後一種說明使用了改進型的數組說明，它只是說明函數將要接收一個具有一定長度的整型數組。細想就會發現，就函數而言，數組究竟有多長並無關緊要，因為C語言並不進行數組的邊界檢驗。事實上，就編譯程序而言，下面的說明也是可行的。
func1 (str);
int str[32];
{
. . .
}
因為編譯程序只是產生代碼使函數func1( )接收一個指針，並非真正產生一個包含3 2個元素的數組。
5.1.2 字元串使用的一維數組
顯然，一維數組的最普通的用法是作為字元串。在C語言中，字元串碰梁被定義為一個以空字元終結的字元數組。空字元以『 \ 0』來標識，它通常是不顯示的。因此，在說明字元數組時，必須比它要存放的最長字元串多一個字元。例如，假如要定義一個存放長度為1 0的字元串的數組s，可以寫成:
char s[11];
這樣就給字元串末尾的空字元保留了空間。
盡管C語言並不把字元串定義為一種數據類戚改型，但卻允許使用字元串常量。字元串常量是由雙引號括起來的字元表。例如，下面兩個短語均為字元串常量:
"hello there"
"this is a test"
不必向字元串的末尾加空字元， C編譯程序會自動完成這一工作。
C語言支持多串操作函數，最常用的有:
名字功能
strcpy(s1 s2) 將s2拷貝到s1
strcat(s1 s2) 將s 2連接到s 1的末尾
strlen(s1) 返回s1的長度
strcmp(s1，s2) 若s1與s2相等，返回值為0
若s1 < s2，返回值小於0
若s1 > s2，返回值大於0
例5 - 2說明了這些函數的用法。
[例5 - 2 ]
#include<stdio.h>
main( )
{
char s1[80]，s2[80]; /*定義字元數組* /
gets (s1); /*輸入字元串* /
gets (s2);
printf ("lengthsf: %d %d\n" ,strlen(s1),strlen(s2));
if (!strcmp(s1,s2))
printf ("the strings are equal \n");
strcat(s1,s2);
printf ("%s\n",s1);
}
切記，當兩個串相等時，函數strcmp( )將返回Fa l s e，因而當測試串的等價性時，要像前例中的那樣，必須用邏輯運算符！將測試條件取反。
當程序運行並以「hello」和「hello」這兩個串作為輸入時，其輸出為:
hello
hello
lengths:5 5
The strings are equal
hellohello
5.2 二維數組
5.2.1 二維數組的一般形式
C語言允許使用多維數組，最簡單的多維數組是二維數組。實際上，二維數組是以一維數組為元素構成的數組，要將d說明成大小為（10，20）的二維整型數組，可以寫成:
int d[10][20]
請留心上面的說明語句， C不像其它大多數計算機語言那樣使用逗號區分下標，而是用方括弧將各維下標括起，並且，數組的二維下標均從0計算。
與此相似，要存取數組d中下標為（ 3，5）的元素可以寫成:
d[ 3 ][ 5 ]
在例5 - 3中，整數1到12被裝入一個二維數組。
[例5 - 3 ]
main ( )
{
int t，i，num[3][4]
for (t=0; t<3; ++t)
for (i=0;i<4;++i)
num[t][i] = (t * 4) + i + 1;
}
在此例中， num[0][0]的值為1，num[0][2]的值為3， . . . . . .，num[2][3]的值為1 2。可以將該數組想像為如下表格：
0 1 2 3
0 1 2 3 4
1 5 6 7 8
2 9 10 11 12
二維數組以行—列矩陣的形式存儲。第一個下標代錶行，第二個下標代表列，這意味著按照在內存中的實際存儲順序訪問數組元素時，右邊的下標比左邊的下標的變化快一些。圖5 - 2是一個二維數組在內存中的情形，實際上，第一下標可以認為是行的指針。
記住，一旦數組被證明，所有的數組元素都將分配相應的存儲空間。對於二維數組可用下列公式計算所需的內存位元組數：
行數×列數×類型位元組數＝總位元組數
因而，假定為雙位元組整型，大小為（ 10，5）的整型數組將需要：10×5×2=100 位元組,當二維數組用作函數的參數時，實際上傳遞的是第一個元素（如[ 0 ] [ 0 ]）的指針。不過該函數至少得定義第二維的長度，這是因為C編譯程序若要使得對數組的檢索正確無誤，就需要知道每一行的長度。例如，將要接收大小為（ 10，10）的二維數組的函數，可以說明如下：
func1(x)
int x[ ][10]
{
.
. .
}
第一維的長度也可指明，但沒有必要。
C編譯程序對函數中的如下語句：
X[2][4]
處理時，需要知道二維的長度。若行長度沒定義，那麼它就不可能知道第三行從哪兒開[例5-4] 用一個二維數組存放某一教師任教的各班學生的分數。假定教師有三個班，每班最多有三十名學生。注意各函數存取數組的方法。
#define classes 3
#define grades 30
#include <stdio.h>
main( )
{
void enter_grades()；
void disp_grades( );
int get_grade( );
int a[classes] [grades];/* 定義二維數組，每行存放一個班學生成績* /
char ch;
for( ; ;)
do { /*菜單顯示* /
printf("(E)nter grades\n");
printf("(R)eport grades\n");
printf("(Q)uit\n");
ch=toupper(getchar()); /* 將鍵盤輸入字元轉換為大寫* /
} while(ch!='E' && ch!='R' && ch!='Q');
switch(ch){
case 'E':
enter_grades( );
break;
case 'R':
disp_grades(grade);
break;
case 'Q':
exit(0);
}
}
}
void enter_grades(a)
int a[][grades];
{
int t, i;
for (t=0;t<classes;t++)
{
printf("class #%d:\n",t+1);
for(i=0; i<grades; i++)
a[t][i] = get_grade(i);
}
}
int get_grades(num)
int num;
{
char s[80];
printf("enter grade for student # %d:\n" ，n u m + 1 ) ;
gets(s);/ *輸入成績* /
return(atoi(s));
}
void disp_grades(g) /*顯示學生成績* /
int g[ ][grades];
{
int t,i;
for(t=0; t<classes; ++t) {
printf("class # %d:\n" ，t + 1);
for(i = 0 ; i < grades; ++i)
printf("grade for student #%d is %d\n" ，i + 1 ，g[t][i]);
}
}
我們將實際問題簡化為共有2個班，每班兩個學生，即將程序中的常量定義修改如下：
#define classes 2
#define grades 2
運行程序：
(E)nter grades
(R)eport grades
(Q)uit: e
class #1:
enter grade for student #1: 7 8
enter grade for student #2: 8 9
class #2
enter grade for student #1: 9 8
enter grade for student #2: 9 0
(E)nter grades
(R)eport grades
(Q)uit: r
class #1
grade for student #1 is 78
grade for student #2 is 89
class #2
grade for student #1 is 98
grade for student #2 is 90
(E)nter grades
(R)eport grades
(Q)uit :q
運行程序，我們首先看到一個菜單，選擇「 e」輸入成績，選擇「 r」顯示成績，選擇「q」
退出。atoi( )函數用於將實參字元串轉換為整型。
5.2.2 字元串數組
程序設計中經常要用到字元串數組。例如，資料庫的輸入處理程序就要將用戶輸入的命令與存在字元串數組中的有效命令相比較，檢驗其有效性。可用二維字元數組的形式建立字元串數組，左下標決定字元串的個數，右下標說明串的最大長度。例如，下面的語句定義了一個字元串數組，它可存放3 0個字元串，串的最大長度為8 0個字元：
char str_array[30][80];
要訪問單獨的字元串是很容易的，只需標明左下標就可以了。例如，下面的語句以數組str_array中的第三個字元串為參數調用函數gets( )。
gets(str_array[2]);
該語句在功能上等價於：
gets(&str_array[2][0]);
但第一種形式在專業程序員編制的C語言程序中更為常見。
為幫助理解字元串數組的用法，研究例5 - 5。它以一個字元串數組為基礎做簡單的文本編輯。
[例5 - 5 ]
#include<stdio.h>
#define MAX 100
#define LEN 80
char text [MAX][LEN]
/* 一個非常簡單的文本編輯器* /
main( )
{
register int t,i,j;
for(t=0;t<MAX; t++) /*逐行輸入字元串* /
{
printf("%d:",t);
gets(text[t]);
if(! text[t][0])
break; /* 空行退出*/
}
for(i = 0 ; i < t,i++) /*按行，逐個字元輸出字元串* /
{
for(j=0; text [i][j];j++)
putchar(text [i][j]);
putchar( '\n');
}
}
該程序輸入文本行直至遇到一個空行為止，而後每次一個字元地重新顯示各行。
5.3 多維數組
C語言允許有大於二維的數組，維數的限制（如果有的話）是由具體編譯程序決定的。多維數組的一般說明形式為：
Type-specifier name [a][b][c]...[z];
由於大量佔有內存的關系，二維或更多維數組較少使用。如前所述，當數組定義之後，所有的數組元素都將分配到地址空間。例如，大小為（ 10，6，9，4）的四維字元數組需要10×6×9×4即2160位元組。
如果上面的數組是兩位元組整型的，則需要4320位元組，若該數組是雙字型的（假定每個雙字為8位元組）則需要34560位元組，存儲量隨著維數的增加呈指數增長。
關於多維數組，需要注意一點：計算機要花大量時間計算數組下標，這意味著存取多維數組中的元素要比存取一維數組的元素花更多的時間。由於這些和其它原因，大量的多維數組一般採用C語言動態分配函數及指針的方法，每次對數組的一部分動態地分配存儲空間。
多維數組傳遞給函數時，除第一維外，其它各維都必須說明。例如，將數組m定義成：
int m[4][3][6][5];
那麼接收m的函數應寫成：
func1 (d)
int d[][3][6][5];
當然，如果願意，也可加上第一維的說明。
5.4 數組的初始化
5.4.1 數組初始化
C語言允許在說明時對全局數組和靜態局部數組初始化，但不能對非靜態局部數組初始化。
與其它變數相似，數組初始化的一般形式如下：
type-specifier array_name[size1]...[sizen]={value-list};
數值表是一個由逗號分隔的常量表。這些常量的類型與類型說明相容，第一個常量存入數組的第一個單元，第二個常量存入第二個單元，等等，注意在括弧「 }」後要加上分號。
下列中一個1 0元素整型數組被初始化裝入數字1到10：
int i[10]={1，2，3，4，5，6，7，8，9，10 } ;
這意味著i[0]的值為1，而i[9]的值為10。
存放字元串的字元數組的初始化可採用如下簡化的形式：
char array_name[size] = "string";
例如，以下代碼段將str 初始化為」hello」。
char str[6] = "hello";
上面代碼產生和下面代碼相同的結果：
char str[6]={'h'，' e ' ，' l ' ，' l ' ，' o ' ，'\o '};
因為C語言中的字元串都以空（ NULL）字元為終結，故要確認定義的數組足夠長以存放空字元。這就是為什麼h ello只有5個字元，而str 要有6個字元長的原因。使用字元串常量時，編譯程序自動地在末尾加上空字元。
多維數組初始化的方法與一維數組相同，例如，下式將sqrs初始化為從1到1 0及它們各自的平方數。
int sqrs[10][2]={
1，1，
2，4，
3，9，
4，1 6 ，
5，2 5 ，
6，3 6，
7，4 9 ，
8，6 4 ，
9，8 1，
1 0，1 0 0 ，
} ;
5.4.2 變長數組的初始化
設想用數組初始化的方法建立一個如下錯誤信息表：
char e1[12] = "read error\n";
char e2[13] = "write error\n";
char e3[18] = "cannot open file\n";
可以想像，如果用手工去計算每一條信息的字元數以確定數組的長度是何等的麻煩。利用變長數組初始化的方法可以使C自動地計算數組的長度。變長數組初始化就是使C編譯程序自動建立一個不指明長度的足夠大的數組以存放初始化數據。使用這種方法，以上信息表變為：
char e1[] = "read error\n";
char e2[] = "write error\n";
char e3[] = "cannot open file\n";
給定上面的初始化，下面的語句printf("%s has length %d\n" ，e2，sizeof(e2));
將列印出：
write error
has length 13
除了減少麻煩外，應用變長數組初始化使程序員可以修改任何信息，而不必擔心隨時可能發生的計算錯誤。
變長數組初始化的方法不僅僅限於一維數組。但在對多維數組初始化時，必須指明除了
第一維以外其它各維的長度，以使編譯程序能夠正確地檢索數組。其方法與數組形式參數的
說明類似。這樣就可以建立變長表，而編譯程序自動地為它們分配存儲空間。例如，下面用
變長數組初始化的方法定義數組sqrs:
int sqrs[ ][2]={
1，1，
2，4，
3，9，
4，1 6，
5，2 5，
6，3 6，
7，4 9，
8，6 4，
9，8 1，
1 0，1 0 0
} ;
相對定長數組的初始化而言，這種說明的優點在於可以在不改變數組各維長度的情況下，隨時增加或縮短表的長度。
5.5 應用程序舉例
[例5-6] 為比賽選手評分。
計算方法：從1 0名評委的評分中扣除一個最高分，扣除一個最低分，然後統計總分，並除以8，最後得到這個選手的最後得分(打分採用百分制)。
#include<stdio.h>
main( )
{
int score[10]; / * 10 個評委的成績* /
float mark; /* 最後得分* /
int i;
int max = -1; / *最高分* /
int min = 101; /*最低分* /
int sum = 0; /*10個評委的總和* /
for( i = 0 ; i < 10 ; i ++)
{
printf("Please Enter the Score of No. %d",i + 1 ) ;
scanf("%d\n",&score[i]);
sum = sum + score[i];
}
for(i = 0 ; i < 10 ; i++)
{
if(score[i] > max)
max = score[i];
}
for(i = 0;i < 10 ; i++)
{
if(score[i]<min)
min = score[i];
}
mark = ( sum - min - max ) / 8.0;
printf("The mark of the player is %.1f\n" ,mark);
}
[例5-7] 數列排序，採用選擇法實現對有5個數的數列進行排序。
選擇法的演算法思想是：（降序）
1. 將待排序的n個數放入數組num中，即num[0]、num[1]、. . . num[n-1]。
2. 讓num[ 0 ]與後續num[1] . . . num[ n - 1 ]依次比較，保證大數在前、小數在後。此次比較，num[0]是數組中最大。
3. 餘下n - 1個元素
4. num[1]與num[ 2 ] . . . num[ n - 1]依次比較，大數在前、小數在後，此次num[ 1 ]是全部元素的最大。
num[ n - 2 ]與num[ n - 1 ]比較，num[ n - 2 ]存大數。
num[ n - 1 ]存小數，比較結束，整理有序。
例：待排序5個數為： 44 76 82 63 71
一趟排序： 1次比較：76 44 82 63 71
2次比較：82 44 76 63 71
3次比較：82 44 76 63 71
4次比較：82 44 76 63 71
最大
#include <stdio.h>
main( )
{
int num[5];
int i，j ;
int temp;
num[0]=94; num[1]=76; num[2]=82; num[3]=63; num[4]=71;
for(i=0; i<4; i++)
for(j=i+1; j<5; j++)
{
if(num[i]>num[j])
{
temp = num[i];
num[i] = num[j];
num[j] = temp;
}
}
for(i=0; i<5; i++)
printf("%4d" ,num[i]);
printf("ok\n");
}
這是一個非常簡單的排序程序，我們只需稍加擴展就可以編制出很多功能強大的管理程序，如學生統計總分、平均排列年級名次等。
[例5-8] 簡易學生成績查詢系統。
圖5 - 3為學生成績登記表，下常式序完成如下功能：
1) 根據輸入的學生學號，給出各次考試成績及平均成績；
2) 根據輸入考試的次數，列印出該次考試中每個學生的成績，並給出平均分；
3) 根據學號查出學生某次考試成績；
4) 錄入考試成績。
#include <stdio.h>
main( )
{
int select;
int i，j ;
int score[5][7];
int average=0;
int sum=0;
do{
printf("本程序有4項功能\n");
printf("1、根據學號查詢學生成績\n");
printf("2、根據考試號統計成績\n");
printf("3、根據考試號和學號查詢成績\n");
printf("4、成績錄入\n");
printf("0、退出\n");
printf("請輸入選擇（0 - 4 ）:");
scanf("%d\n",&select);
switch(select)
{
case 0:
printf("OK\n");
exit(0)
break;
case 1:
printf("輸入學號：");
scanf("%d\n",&i);
for(j=1; j<7; j++)
{
printf("第%d科成績是%d\n",j,score[i][j]);
sum += score[i][j];
}
average = sum/6;
printf("學生的平均成績是%d\n",average);
break;
case 2:
printf("輸入考試號：");
scanf("%d\n",&j);
for(i=1; i<5; i++)
{
printf("第%d號學生本科成績是%d\n",i,score[i][j]);
sum += score[i][j];
}
average = sum/4;
printf("本科平均成績是%d\n",average);
break;
case 3:
printf("輸入學號和考試號：");
scanf("%d %d\n",&,i,&j);
printf("第%d 號學生的第%d 科考試成績是%d\n",i, j,score[i][j]);
break;
case 4:
printf("請輸入成績\n");
for(i=1; i<5; i++)
for(j=1; j<7; j++)
scanf("%d\n",&score[i][j]);
break;
default:
break;
}while(1);
『叄』 c語言一維數組定義方式為 類型說明符，數組名（）A常量表達式B整形常量或整形表達式，選哪個啊
B整形常量或整形表達式。
在 C 中要聲明一個數組，需要指定元素的類型和元素的數量，如下所示：
type arrayName [ arraySize ];
這叫做一維數組。arraySize必須是一個大於零的整數常量，type可以是任意有效的 C 數據類型。
例如，要聲明一個類型為 double 的包含 10 個元素的數組balance，聲明語句如下：
double balance[10];
現在balance是一個可用的數組，可以容納 10 個類型為 double 的數字。
(3)c語言一維數組一般表達形式擴展閱讀：
使用規則
1.可以只給部分元素賦初值。當{ }中值的個數少於元素個數時，只給前面部分元素賦值。例如：static int a[10]={0,1,2,3,4};表示只給a[0]～a[4]5個元素賦值，而後5個元素自動賦0值。
2.只能給元素逐個賦值，不能給數組整體賦值。例如給十個元素全部賦1值，只能寫為：static int a[10]={1,1,1,1,1,1,1,1,1,1};而不能寫為：static int a[10]=1。
3.若不給可初始化的數組賦初值，則全部元素均為0值。
4.假如給全部元素賦值，則在數組說明中， 可以不給出數組元素的個數。例如：static int a[5]={1,2,3,4,5};可寫為：static int a[]={1,2,3,4,5};動態賦值可以在程序執行過程中，對數組作動態賦值。這時可用循環語句配合scanf函數逐個對數組元素賦值。
『肆』 C語言中一維數組正確的定義
符號常量是用一個標識符來表示一個常量，一維數組的定義方法為：類型說明符+數組名+[常量表達式];
類型說明符是任一種基本數據類型或構造數據類型。數組名是用戶定義的數組標識符。方括弧中的常量表達式表示數組元素的個數或者長度，可以是常量或符號常量，不能為變數。
例如：
1、int x[8]; 表示定義一個整型數組x，數組長度為8.
2、float a[8],b[10];表示定義一個實型數組b，數組長度為8，一個實型數組c，數組長度為10
3、 ch[15]; 表示定義一個字元數組ch，數組長度為15。
(4)c語言一維數組一般表達形式擴展閱讀
在程序中可以使用下標變數，即說明這些變數的整體為數組，數組中的每個變數的數據類型是相同的。當數組中每個元素都只帶有一個下標時，稱這樣的數組為一維數組。
一維數組是由數字組成的以單純的排序結構排列的結構單一的數組。一維數組是計算機程序中最基本的數組。二維及多維數組可以看作是一維數組的多次疊加產生的。
數組是計算機編程中的重要概念，運用數組可以方便地處理大規模的數據。
『伍』 C語言中整形一維數組是什麼
一、一維數組的定義
類型說明符數組名[常量表達式];
說明：
1、類型說明符用來定義數組中各個數據元素的類型。在任何一個數組中，數據 , 元素的類型都是一致的。
2、數組名處定義數組的名稱。數組名的命名規則與變數名的命名規則（標識符的命名規則）相同。因為在C語言中我們將數組也當成一個變數來看待。
3、常量表達式是放在一對中括弧[]中。注意必須是中括弧[]，而不能是大括弧 { }或小括弧（），常量表達式用來表示數組中擁有的元素個數。
4、常量表達式中必須是由常量或符號常量組成的表達式，而不能有變數。因為在C語言中，所有的變數都必須是先定義，後使用。一旦定義好一個變數後，就不允許對 這個變數進行任何修改。所以在定義數組變數的時候，一旦數組中元素（也稱數組的大小）確定好以後，就絕對不允許改變數組的大小。
5、一維數組中的各個元素在內存中是按照下標規定的順序存放在內存中的。我們知道，在內存中是以位元組為基本單位來表示存儲空間的並且在內存中只能按照順序的方式存放數據。假設我們定義了一個整型的一維數組：int a[5];那麼這個數組中的每個元素都將佔用二個位元組。 下面我們給出從內存地址1000開始的數組存放方式。
二、一維數組的引用
在已經定義了一個數組以後，怎麼來使用數組中的元素呢？C語言規定只能一個一個地引用數組元素而不能一次引用數組中的全部元素。
數組的引用格式：數組名[下標]
說明：
1、數組名是表示要引用哪一個數組中的元素，這個數組必須已經定義。
2、下標用一對中括弧[]括起來，它表示要引用數組中的第幾個元素,可以是變數表達式也可以是常量表達式。
3、在C語言中，下標的取值范圍是從[0,元素個數減1]結束。假設我們定義了一個數組，含有N個元素（N為一個常量），那麼下標的取值范圍為 [0,N-1]。
好了，我們對一維數組的使用有了一定的了解。在上面這個程序中，我們看到,必須有一段程序向數組中賦值，它要佔用運行時間。我們能不能在程序運行之前，就將數組中的內容規定好呢？好，來看我們下面介紹的內容。
三、一維數組的初始化
數組的初始化操作是在定義數組的同時就規定數組中有什麼樣的內容，即各個數組元素取什麼值。這個初始化的過程是在源程序編譯的過程中由編譯程序完成的。它在程序運行前就已經規定好數組中各元素的取值。所以在使用數組時，最好對它進行初始化操作，可以節省程序運行時間。
對數組的初始化操作可以採取以下方式：static 類型說明符數組名[N]＝｛值1，值2，......值N｝;
說明：
1、對數組的初始化操作只能在定義數組時進行。
2、N表示數組含有的元素個數（可以是常量表達式）。
3、大括弧中的內容即為數組的初值。值1將賦給第0個元素、值2將賦給第1個元素等等，賦初值後數組內容如下表（以a數組為例）：static int a[N]={值1，值2，......值N};
4、關鍵字static表示定義了一個靜態變數。在C語言中規定，只有靜態變數和外部變數可以初始化（將在後面介紹）。但在TurboC中不加關鍵字static也可對變數進行初始化。
5、可以只給最前一部分數組元素賦初值。
6、如果想使數組中的元素全部被賦為0時，可以這樣：static int a[N]={0,0,0,......,0,0}; (要寫N個0) 或者寫成這樣：static int a[N]={0};（只寫一個0）
7、在對數組元素全部賦初值時，可以不指定數組的大小。
『陸』 定義一維數組
在C語言中，一維數組的定義方式:
類型說明符 數組名[元素個數]
其中，類型名確定所有元素的數據類型，元素個數給定數組要培兄包含的變數個數，它可以使用表達式形式，但該表達式中只能出現變數常量和運算符。
常用的類型：char ,int ,long .float,double.
數組元素的一般表示形式是：
數組名[下標]
其中，下標可以使用表達式形式，但必須是整型而且有確定的值，取值范圍是版0～元素個數-1.
注意：引用數配陸襲組元素時不應使用超范圍的下標，權因為對這種情況編譯時系統並不報錯，所以編寫程序時要悉搜格外注意。
『柒』 在C語言中,一維數組的定義方式
是選D
1+3.4就是常量表達式，但int a[1+3.4]是不允許的，因為不是整型的
int a, b;
a+b就是整型表達式，int a[a+b]是不允許的
10就是整型常量，int a[10]是允許的
『捌』 C語言中一維數組正確的定義
C語言中定義一維數組如下：
數據類型 數組名[數組枯頌罩長度]； // 不進行初始化的數組
數據類型 數組名[數組長度] = {數組沒鬧元素初始化值}； // 進行初始化的數組
舉例如下：
// 定義一個int型的未進行初始化數組data1
int data1[5]；
// 定義一個int型的數組data2，並對數組中各元櫻臘素進行初始化
int data2[5] = {5， 2， 4， 0， 3}；
『玖』 在c語言中的一維數組怎麼回事啦,怎麼運用
a[i]這樣的叫一維數組，a[i][n]這樣的叫二維數組，以此類推。。。多維數組。
例如a[4]，在內存單元中是這樣排列的a[0] a[1] a[2] a[3]
a[2][3]在內存單元是這樣排列的啊a[0][0] a[0][1] a[0][2] a[1][0] a[1][1] a[1][2]
以此類推，至於用法，數組是具有相同數據類型且按照一定次序排列的一組變數大羨的集合體，所前仿乎以呢，數組的用法和變數的用法基本類似慧悉。。。我是軟體專業的，這全是我一字一句打出來的，希望能夠幫到你。。。