数组结构体总结（C语言）

数组

定义：数组是有序的并且具有相同类型的数据的集合。

一维数组

1、一般形式：类型说明符 数组名[常量表达式]；例如： int a[10]; 元素为a[0]----a[9].

2、常量表达式中不允许包含变量，可以包含常量或符号常量。

3、数组元素下标可以是任何整型常量、整型变量或任何整型表达式。

4、可以对数组元素赋值，数组元素也可以参与运算，与简单变量一样使用。

5、使用数值型数组时，不可以一次引用整个数组，只能逐个引用元素。

6、需要整体赋值时只可以在定义的同时整体赋值。如

   int a[10]={0,1,2,3,4,5,6,7,8,9};正确。

   int a[10];    a[10]={0,1,2,3,4,5,6,7,8,9};错误。

或者用内存拷贝函数

7、可以只给一部分元素赋值。例如：

   int a[10]={5,8,7,6};后面没有赋值的元素值默认为0。

8、对全部数组元素赋值时可以不指定数组长度，例如：

   int a[10]={0,1,2,3,4,5,6,7,8,9};可以写成 int a[]={0,1,2,3,4,5,6,7,8,9};

   但是，既不赋初值，也不指定长度是错误的。例如：int a[];错误。

9、指向数组元素的指针

     int a[10], *p; 

//下面这两句是等价的：
     p=&a[0]; 
     p=a; 
根据地址运算规则, a+1为a[1]的地址, a+i就为a[i]的地址。 
    下面我们用指针给出数组元素的地址和内容的几种表示形式。 
    (1). p+i和a+i均表示a[i]的地址, 或者讲, 它们均指向数组第i号元素, 即 
指向a[i]。 
    (2). *(p+i)和*(a+i)都表示p+i和a+i所指对象的内容, 即为a[i]。 
    (3). 指向数组元素的指针, 也可以表示成数组的形式, 也就是说,  它允许 
指针变量带下标, 如p[i]与*(p+i)等价。 

二维数组

1、一般形式：类型说明符 数组名[常量表达式1][常量表达式2]；例如： 

   int a[3][4];可以看成是包含3个一维数组，每个一维数组里包含4个元素。一共3*4=12个元素。 

   所有元素为 a[0][0],a[0][1]，a[0][2]，a[0][3]

              a[1][0],a[1][1]，a[1][2]，a[1][3]

              a[2][0],a[2][1]，a[2][2]，a[2][3]

         ┏━━━━┓    ┏━┳━┳━┳━┓ 

 a─→┃  a[0]    ┃─→┃0 ┃1 ┃2 ┃3 ┃ 
         ┣━━━━┫    ┣━╋━╋━╋━┫ 
         ┃  a[1]    ┃─→┃4 ┃5 ┃6 ┃7 ┃ 
         ┣━━━━┫    ┣━╋━╋━╋━┫ 
         ┃  a[2]    ┃─→┃8 ┃9 ┃10┃11┃ 
         ┗━━━━┛    ┗━┻━┻━┻━┛

a代表二维数组的首地址,  当然也可看成是二维 数组第0行的首地址。a+1就代表第1行的首地址, a+2就代表第2行的首地址。如 果此二维数组的首地址为1000, 由于第0行有4个整型元素, 所以a+1为1008, a+2 
也就为1016（16位）。如下图所示 
                            a[3][4] 
                     a    ┏━┳━┳━┳━┓ 
              (1000)─→┃0 ┃1 ┃2 ┃3 ┃ 
                    a+1  ┣━╋━╋━╋━┫ 
              (1008)─→┃4 ┃5 ┃6 ┃7 ┃ 
                    a+2  ┣━╋━╋━╋━┫ 
              (1016)─→┃8 ┃9 ┃10┃11┃ 
                           ┗━┻━┻━┻━┛ 

2、与一维数组一样元素下标可以是是任何整型常量、整型变量或任何整型表达式。

3、需要整体赋值时只可以在定义的同时整体赋值。例如：

   int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};正确。

   int a[3][4]；  a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};错误。

4、可以把所有数据写在一个花括号内。例如：

   int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};正确。

5、可以只对部分元素赋值。例如：

   int a[3][4]={{1},{5},{9}};其余未赋值的元素默认为0。

   int a[3][4]={{1},{5,6}};可以看成是int a[3][4]={{1,0,0,0},{5,6,0,0},{0,0,0,0}};

6、对全部数组元素赋值时可以省略第一维长度，第二维不可以省略。例如：

   a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};

   可以写成a[][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};

   或者a[][4]={1,2,3,4,5,6,7,8,9,10,11,12};

7、在二维数组中, 我们还可用指针的形式来表示各元素的地址。

a[0]与*(a+0)等价, a[1]与*(a+1)等价, 因此a[i]+j就与*(a+i)+j等价, 它 
表示数组元素a[i][j]的地址。 
 

因此, 二维数组元素a[i][j]可表示成*(a[i]+j)或*(*(a+i)+j),  它们都与 
a[i][j]等价, 或者还可写成(*(a+i))[j]。

字符数组

1、定义：char a[10];字符数组a长度为10。每个元素只能存放一个字符。例如：

   a[0]='h';a[1]='a';a[2]='p';……

2、初始化：

   char a[]={'h','a','p','p','y'};注意，长度为5

   char a[]="happy";

   char a[]={"happy"}; 注意，因为字符串结尾自动加'\0',所以char a[]="happy";长度为6，不是5。

3、C语言中没有字符串变量，字符串的输入、存储、处理和输出等必须通过字符数组实现。  只能是数组指针都不行！

4、字符串的输入。

   scanf();可以用%C逐个字符输入比如char a[6];for(i=0;i<6;i++) scanf("%c",&a[i])；

           可以用%S以字符串的形式输入，比如char a[6];scanf("%s",a);注意，a前不用加&，因为a是数组名，已经代表了数组首地址。

           注意：以%S输入时，以第一个非空白字符开始，终止于第一个空白字符。比如：输入How are you时。只输出How.

   gets();作用为输入一个字符串。与scanf();功能一致，但空格和回车都存放在数组中，最后自动加入‘\0’.不会出现上面输出不全的情况。

         调用方式为：gets(数组名);需要包含头文件“stdio.h”.

5、字符串的输出。

    printf();可以使用%C逐个字符输出，比如：char a[6];for(i=0;i<6;i++) printf("%c",a[i])；

           可以用%S以字符串的形式输出，比如char a[6];printf("%s",a);

    puts();输出一个字符串，结尾自动换行。

         调用形式：puts(字符数组名或字符串常量);需包含头文件“stdio.h”

常用字符串处理函数(以下函数需要头文件“string.h”)

1、strlen()作用是测试字符串长度。这里不包括‘\0’.使用形式strlen(数组名或字符串常量)

2、strcat()作用是连接两个字符串。调用方式strcat(字符数组1名，字符数组2名)；合并后的字符串存放在字符数组1中。

3、strcmp()比较两个字符串是否相等。调用方式strcmp(字符串1，字符串2)；相等时值为0。1>2时为正数。1<2时为负数。

4、strcpy()复制字符串。调用方式strcpy(字符数组1，字符串2);2的内容复制到1中。1只能是字符数组名。

指针数组
1、定义int *p[10];//指针数组，含有10个指针元素
也就是说每一个元素都是指针

2、初始化：

char *week_day[8]= 

{"sunday", 

"monday", 

"tuesday",

"wednesday", 

"thursday", 

"friday", 

"saturday", 

NULL 

}; /* 说明指针数组。数组中的每个元素指向一个字符串 */ 

char *week_day[8]；

数组必须指定大小，char *week_day[]；是错误的。

可以不指定数组大小

char * week_day []=

{"sunday", 

"monday", 

"tuesday",

"wednesday", 

"thursday", 

"friday", 

"saturday", 

NULL 

}；

3、使用

int *p[10];

p[0]=”asdfghj”;

char *a=”asdfghjk”; 

p[1]=a;

4、指向结构体的指针数组

 typedef struct { 

char s1[81]; 

char s2[81]; 

char s3[81]; 

} Rec; 

Rec *a[10];

a[0]=(Rec *)malloc(sizeof(Rec)); 

strcpy(a[0]->s1, "hello"); 

free(a[0]);

如右图所示：

5、指向函数的指针数组

      int functionA(int event);

        int functionB(int event);

     …….

    int functionZ(int event);

  typdef  int (*pFunc)(int event);   // pFunc 是 int (*)(int event)的别名

  pFunc  functionlist[Z+1] =

{ 

functionA,

 functionB, 

…  ,

functionZ 

}; //指向函数名串的指针数组 

  使用：

functionlist[i](event);

数组指针

1、定义：

类型说明符  (*指针变量名)[长度]

注意“(*指针变量名)”两边的括号不可少。
int (*p)[10];//数组指针，这个指针能够用来指向含有10个元素的整数数组

2、使用

int a[10], b[3][4],

p = &a;  注意，取一次地址地址相当于加一级指针

p=b;

*p+1指向b[0][1], *(p+i)+j则指向数组元素b[i][j]。

结构体数组

1、 结构体数组的定义

   对应结构体变量定义方法1

struct student

{

 long num;

   char name[20];

char sex;

   char addr[20];

}；

struct student students[3];

struct 

{

 long num;

   char name[20];

char sex;

   char addr[20];

} students[3]；

2、结构体数组的初始化

   初始化方法： 在定义数组的后面加上  ={初值列表}

如: 

struct 

{  long num;

         char name[20];

         char sex;

         char addr[20];

}   students[3]={ {10101, "Li Lin", 'M', "Beijing"},{10102, "zhang",  'F',  "shanghai"} …...}；

3、使用

students [i].sex=‘F’；

 

数组作为函数参数

1、 数组元素作函数实参

数组元素作函数实参，与用变量作实参一样，是“单向的值传递”。

参数和形参类型要保持一致。

Fun(a[2]);//传递的是元素a[2]的值。

2、 数组名作函数的实参和形参。

如：

main()

{int array[10];

   ……

 f(array,10);

……

}

 f(int arr[],int n);

     {    ……

}//注意sizeof（arr）值为4，此处只是传递数组的第一个元素的地址。

array为实参数组名，arr为形参数组名。数组名就是数组的首地址，实参向形参传送数组名实际上就是传送数组的地址，形参得到该地址后也指向同一数组。这就好象同一件物品有两个彼此不同的名称一样。

    同样，指针变量的值也是地址，数组指针变量的值即为数组的首地址，也可作为函数的参数使用。

用数组名作为函数参数时还应注意以下几点：

a. 形参数组和实参数组的类型必须一致，否则将引起错误。

b. 形参数组和实参数组的长度可以不相同，因为在调用时，只传送首地址而不检查形参数组的长度。当形参数组的长度与实参数组不一致时，虽不至于出现语法错误(编译能通过)，但程序执行结果将与实际不符，这是应予以注意的。

c. 在函数形参表中，允许不给出形参数组的长度，或用一个变量来表示数组元素的个数。

例如，可以写为：

void fun(int a[])

或写为

void fun(int a[]，int n)

其中形参数组a没有给出长度，而由n值动态地表示数组的长度。n的值由主调函数的实参进行传送。

d. 多维数组也可以作为函数的参数。在函数定义时对形参数组可以指定每一维的长度，也可省去第一维的长度。因此，以下写法都是合法的。

      int MA(int a[3][10])

或

int MA(int a[][10])。

而int  MA (int a[3][])；是不允许的。