数组是一组有序数据的集合，每个元素都属于同一个数据类型。

一维数组的定义:

类型符  数组名[常量表达式]

常量表达式中，可以包括常量和符号常量，int a[3+5]是合法的。但是不能包含int a[n]，C语言不允许动态数组。

子函数中是可以存在int a[2*n]的，但是不能是static局部变量，因为子函数中的数据在执行时，n已经确认，可以在

栈中分配出int n[2*n]的地址空间。

在定义时，初始化:

1) int a[10] = {0,1,2,...,9};  //使用{}l=括号

2) int a[10] = {0,1,2,3,4};  //部分赋值,未赋值的元素自动赋值0

3) int a[] ={1,2,3,4,5};  //可以不需要指定数组长度

一维数据的引用，数组名[下标]

二维数据定义:

类型符 数组名[常量表达式][常量表达式]

二维数组的引用 数组名[下标][下标]

二维数组的初始化

1) int a[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};   //每个行元素单独赋值

2) int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};   //所有元素写在一起赋值

3) int a[3][4] = {{1},{5},{9}};   //对每个行元素，都部分赋值

4) int a[][4] = {1,2,3,4,5,6,7,8,9,10,11,12};  //C语言可自动推断出行元素个数

用来存放字符的数组，字符数组。其中的每个元素存放一个字符。最后自动加空字符'\0'

char [10];

字符数组的初始化，char c[10] = {'I',' ','a',....'y'};    //' '表示空格

C中的字符串是通过字符数组的形式来处理的，结束标志'\0'，在ASCII中表示0。

可以通过字符串来对字符数组进行赋值。

char[] = "I am happy";

如果定义的字符数据长度比字符长，系统自动补'\0'

char c[10] = {"china"};  printf("%s",c);  //输出只打印到第5个字符

C语言函数提供的字符串处理的函数。必须包含#include<string.h>

1) puts(字符数组);

  　　char str[] = {"string"};    puts(str);  //输出时将'\0'转换为\n，

2) gets(字符数组);

  　　char str[10];  gets(str);  //输入字符，自动加'\0'

 　　puts和gets函数只能处理一个字符数组。

3) strcat(字符串1，字符串2);

 　　char str1[30] = {""};

 　　char str2[] = {"china"};

　　 printf("%s", strcat(str1,str2));   //str1必须足够大，将str2链接到str1后

4) strcpy(字符数字1，字符串2);

 　　char str1[10],str2[] = "china";

 　　strcpy(str1,str2);   //str1只能是数组名的形式，字符数组1必须定义的足够大，

                            　　 //赋值时，只是将6个元素，放在str1的前6个单元(包括'\0')，之后的4个单元，仍是str1的字符。

　　 strncpy(str1,str2,n);  //将str2的前n个字符，copy到str1的前n个字符，不包括'\0'。‘’

 　　//字符串之间不能直接用str1  = str2

5) strcmp(字符串1，字符串2);

 　　strcmp(str1,str2);  //比较str1和str2，直到出现不同的字符和'\0'为止。

                             　　//str1 == str2，则返回值0，str1 > str2, 则返回正整数，str1 < str2, 则返回负整数

 　　//字符串之间不能直接用 str1 > str2

6) strlen(字符数组);

 　　char str[10] = "China";

 　　printf("%d", strlen(str));   //输出结果为5，表示实际的字符的个数，不包括'\0'

7) strlwr(字符串);   //将字符串的大写转换为小写字母

8) strupr(字符串)；  //将字符串的小写转换为大写字母

用户自定义结构体类型:

struct  结构体名  {成员表列};

struct Student {int num;  char name[20];}  student1;

定义结构体变量:

结构体名  结构体变量

struct Student  student1;   //必须加struct来执行结构体类型名

也可以不指定类型名，直接指定结构体变量

　　struct {int num;  char name[20];}  student1;

1)在定义结构体变量时，初始化:

　　struct Student b = {.name = "zhang"};   //对结构体成员的引用，必须使用成员运算符"."

　　struct Student b = {name ："zhang”};

　　struct Student b = {"zhang"}

2)通过结构体变量名.成员名来引用结构体变量的成员

　　student1.num = 10010;

3)如果成员本身就是一个结构体，可以多次使用"."来引用:

　　student1.birthday.month

4)同类型的结构体变量可以相互赋值:

　　student1 = student2;

5)可以引用结构体变量的地址，也可以引用结构体变量成员的地址:

　　&student1.num   &student1

结构体类型的指针，只能通过->来引用其中的成员变量

定义结构体数组:

结构体类型  数组名[数组长度]

struct Person leader[3];

定义结构体指针:

struct Student *pt;  //如果p指向一个结构体变量stu，结构体变量.成员名(stu.num)

                                                                        (*p).成员名((*p).num)

                                                                        p->成员名(p->num)等价

指向结构体数组的指针

struct Student {int num; char name[];};

struct Student stu[3];

struct Student *p;

for(p=stu; p <stu +3; p++);

用结构体变量的数组或指针做函数参数

void input(struct Student stu[]);

共用体类型，同一段存储空间中，存储不同的数据结构，每次只能选择一种。

定义共用体变量:

union 共用体名 {成员表列}  变量表列；

union Data {int i; char ch; float f;} a,b,c;

引用共用体变量: a.i、a.ch、a.f

使用共用体类型数据时，同一内存段某一时间段内，只能用来存放一种数据结构

共用体中起作用的是最后一次被赋值的元素。

a.ch = 'a';  a.f = 1.5;  a.i=40;   //a中的值为40

共用体指针，也是通过.来引用其中的变量

如果一个变量的值只能是几种可能的值，可以定义为枚举(enum)类型

声明枚举类型: enum [枚举名] {枚举元素列表}

enum Weekend {sun, mon, tue, wed, thu, fri, sat};

声明枚举变量: 枚举类型名 变量名

enum Weekend workday;

C编译器对枚举元素是按常量来处理的。故称为枚举常量，所以不能对枚举变量进行赋值。

C语言按顺序，对他们进行赋值0,1,2，，，

printf("%d", workday);   //输出相应的值

用typedef来重新声明类型。

typedef int integer;

typedef struct {int month; int day; int year;} Date;  //声明一个新类型名Date

typedef int Num[100];   //声明Num为整型数组类型名  Num a; a为整型数组名，有100个元素

　　NUM n;   n就是一个数组，含有100个元素

typedef char * String;    //String p，定义String为字符类型指针

typedef int (*Pointer) ();    //声明Pointer为指向函数的指针类型

结构体中允许嵌套：

　　1)结构体的自引用，结构体内部，包含指向自身类型的结构体指针；

　　2)结构体的相互引用，结构体内部，包含指向其他类型的结构体的指针；

需要注意：

　　1)结构体中可以嵌套其他结构体类型的变量，但是不能嵌套自己结构体类型的变量；

　　2)可以嵌套自己类型的结构体指针；

自我嵌套时：

struct tag1 {

　　struct tag1 A；　　//不可以嵌套自己类型的变量，这样在编译时，无法分配正确的空间

　　int value；

}

struct tag1 {

　　struct tag1 *A；　　//可以嵌套自己类型的变量指针，在编译时，只分配一个int类型的指针就可以

　　int value；

}

相互嵌套时：

typedef struct taga {　　　　//由于B类型声明在后边，所以此处不可以引用，需要先声明B类型的结构体

　　B *bp；

　　int value；

} A；

typedef struct tagb {

　　A *ap；

　　int value；

} B；

先声明结构体类型：

typedef struct taga A；

typedef struct tagb B；

struct taga {

　　B *bp；

　　int value；

}

struct tagb {

　　A *ap；

　　int value；

}