一、结构体

C语言中语序用户自己建立由不同类型数据组成的集合型的数据结构，他称为结构体。相较于另一个数据集合数组而言，它可以存放不同类型的数据，但是数组只能存储相同类型的数据。

类似C++、Java中的类。

1、声明结构体类型与定义结构体变量

• 1、声明结构体一般式：

struct 结构体名 {
    类型名 成员名1;
    类型名 成员名2;
    ...
};

struct Dog { //声明Dog结构体
    char *name;
    int age ;
}
struct Dog dog3 = {"有才",5} ; //初始化Dog结构体类型变量dog3;
printf("dog: %-20s %d \n",dog3.name,dog3.age);

• 2、声明和定义放在一起进行

struct 结构体名 {
    类型名 成员名1;
    类型名 成员名2;
    ...
} 变量名列表；

struct Dog {
    char *name;
    int age ;
} dog2 = {"旺财",2}; //定义结构体的同时，初始化结构体变量dog2
printf("dog: %-20s %d \n",dog2.name,dog2.age);

• 3、不指定类型名直接定义结构体类型变量

struct { //定义结构体类型，但没有结构体名
    char *name;
    int age ;
} dog1 = {"旺旺",2}; //初始化结构体变量dog1
printf("dog: %-20s %d \n",dog1.name,dog1.age);
  

注：

1、定义结构体变量并初始化，不允许先定义再直接初始化，如struct Dog dog3;dog3 = {"xxx",1};这是错误的，如果在定义结构体变量的时候未初始化，可以分别赋值：dog3.name = "xiaosan";dog3.age=3;

2、结构体中可以引用结构体类型，前面要加struct关键字。

struct Date {
    int year;
    int month;
    int day;
};
struct Dog{
    char name[20];
    int age ;
    struct Date birthday;
}

struct Dog dog3 = {"有才",5,{2017,2,3}} ;
    
printf("dog: %-20s %d %d-%2d-%2d\n",dog3.name,dog3.age,dog3.birthday.year,dog3.birthday.month,dog3.birthday.day);

3、结构体变量的成员的值可以通过成员运算符.函数的方式获取：结构体成员变量名.成员名，dog.name,dog.age。如果成员本身有属于一个结构体类型，则要若干个成员运算符,一级一级的找到最低一级的成员。同时，只能对最低一级的成员进行赋值、存取以及运算。

4、结构体变量成员可以像普通变量一样进行各种运算。

5、同类型的结构体变量可以互相赋值。

6、可以引用结构体变量成员的地址，也可以引用结构体变量的地址:&dog3,&dog3.age。

2、结构体数组

• 1、定义结构体数组一般形式

struct 结构体名 {
    成员表列;
} 数组名[数组长度] = {初值列表};

struct Student {
    int number;
    char name[20];
    float score;
} stus[4] = {1,"zhangsan",100,2,"lisi",89,3,"wangwu",90,4,"zhaoliu",67};

//{{1,"zhangsan",100},{2,"lisi",89},{3,"wangwu",90},{4,"zhaoliu",67}}

• 2、先声明一个结构体类型，在用此类型定义结构体数组

struct 结构体名 {
    成员表列;
};
结构体类型 数组名[数组长度] = {初值列表};

struct Student {
    int number;
    char name[20];
    float score;
};

struct Student stus[4] = {1,"zhangsan",100,2,"lisi",89,3,"wangwu",90,4,"zhaoliu",67};
//{{1,"zhangsan",100},{2,"lisi",89},{3,"wangwu",90},{4,"zhaoliu",67}}

3、结构体指针

• 1、结构体指针
  结构体指针就是指向结构体变量的指针，一个结构体变量的起始地址就是这个结构体变量的指针。如果把一个结构体变量的起始地址存放在一个指针变量中，那么，这个指针变量就指向该结构体变量。

指向结构体变量的指针可以指向结构体变量，也可以指向结构体数组中的元素。指针变量的基类型必须与结构体变量的类型相同:struct 结构体名 * p;

struct Student {
    int number;
    char name[20];
    float score;
};

struct Student student1 = {100,"xiaoming",120};
struct Student *ps = &student1;
    
printf("%5d %-20s %.2f \n",(*ps).number,(*ps).name,(*ps).score);
printf("%5d %-20s %.2f \n",ps->number,ps->name,ps->score);
printf("%5d %-20s %.2f \n",student1.number,student1.name,student1.score);

打印结果 ：
100 xiaoming             120.00 
100 xiaoming             120.00 
100 xiaoming             120.00 

注：

struct Student *ps = &student1;中(*ps)表示ps指向的结构体变量，(*ps).number是ps指向结构体变量中的成员number。(*p)两侧的括号不可省略，因为成员运算符.优先于*运算符

C语言中可以用->表示指向结构体变量中成员的符号，如下面三种用法是等价的:

结构体成员变量.成员名 (student1.number);
(*ps).成员名 ((*p).number);
p->成员名 (p->number);

• 2、指向结构体数组的指针
  在用法上与一般数组指针相同，内容元素对应结构体。

struct Student stus[4] = {{1,"zhangsan",100,{199,5,12}},{2,"lisi",89},{3,"wangwu",90},{4,"zhaoliu",67}};
    
for (int i = 0; i < 4; i ++) {
    printf("%5d %-20s %6.2f\n",stus[i].number,stus[i].name,stus[i].score);
}

struct Student *p ; //定义结构体指针
p = stus; //指向结构体体数组

for (; p  < stus + 4; p ++) { //遍历数组
    printf("%5d %-20s %6.2f\n",(*p).number,(*p).name,(*p).score);
}

数组指针p指向的是结构体数组的首元素地址，对应的是一个结构体变量，是一个结构体变量的指针。

二、链表

链表是一种数据结构，他是动态地进行存储分配的一种结构。链表中各元素在内存中的地址可以是不连续的，要找某一元素，必须先找到上一个元素，根据它提供下一元素地址才能找到下一元素。链表是根据需要开辟内存单元，不同于数组需要开辟固定的长度。

链表有一个“头指针”变量，存放一个地址，指向一个元素。链表中每一个元素成为节点，每个节点包括两部分：(1)用户需要用的实际数据，(2)下一个节点地址。

链表，必须利用指针标量才能实现，即一个节点中应包含一个指针变量，用它存放下一节点的地址。

前面说了结构体变量，用它建立链表是最合适的。

1、简单静态链表

struct Student {
    int number;
    float score;
    struct Student *next;
};

int main(int argc, const char * argv[]) {
    
    struct Student a,b,c,*head,*p;
    a.number = 1001;a.score = 100;
    b.number = 1002;b.score = 90;
    c.number = 1003;c.score = 98;
    head = &a;
    a.next = &b;
    b.next = &c;
    c.next = NULL;
    p = head;
    
    do {
        printf("%5d %5f \n",p->number,p->score);
        p = p->next;
    } while (p != NULL) ;
    
    
    return 0;
}

打印结果：
 1001 100.000000 
 1002 90.000000 
 1003 98.000000 

2、动态链表

这是一个不断开辟存储空间，增加数据的过程，并把后一个元素指针存放到前一个元素的成员里。

struct Student {
    long number;
    float score;
    struct Student *next;
};

int n;//链表长度

struct Student * create(void) {
    struct Student *p,*np,*head = NULL;
    n = 0;
    p = np = (struct Student *)malloc(LEN);//开辟一个新单元
    printf("请输入学生编号 成绩(编号为0退出)：");
    scanf("%ld %f",&np->number,&np->score);
    while (np -> number != 0) { //设定条件，如果输入编号为0，退出
        n += 1;
        if (n == 1) { //第一个元素
            head = np;
        } else {
            p->next = np;
        }
        p = np;
        
        np = (struct Student *)malloc(LEN);//开辟动态存储区，把起始地址赋值给np
        printf("请输入学生编号 成绩(编号为0退出)：");
        scanf("%ld %f",&np->number,&np->score);
    }
    p->next = NULL;//链表最后一个元素的next为NULL
    return head;
}

void prin(struct Student *head) {
    struct Student *pt;
    pt = head;
    if (pt != NULL) {
        do {
            printf("%5ld  %.2f \n",pt->number,pt->score);
            pt = pt->next;
        } while (pt != NULL);
    }
    
}

int main(int argc, const char * argv[]) {
    
    struct Student *pt;
    pt = create();
    
    prin(pt);
 
    return 0;
}

打印结果：
请输入学生编号 成绩(编号为0退出)：1001 100
请输入学生编号 成绩(编号为0退出)：1002 90
请输入学生编号 成绩(编号为0退出)：1003 89
请输入学生编号 成绩(编号为0退出)：1008 98
请输入学生编号 成绩(编号为0退出)：0 12
 1001  100.00 
 1002  90.00 
 1003  89.00 
 1008  98.00 

结构体和指针的应用领域很广，除了单向链表之外，还有环形链表和双向链表。此外还有队列、树、栈、图等数据结构。这里只是简单了解链表的数据结构，有个初步认识。

三、共用体

共用体类型结构：几个不同的变量共享同一段内存的结构。有些地方也被叫做“联合”

定义共同体的一般形式：

union 共同体名{
    成员表列
} 变量表列;

如：
//方式1
union Data {
    int i;
    char c;
    float f;
}a,b,c;

//方式2
union Data {
    int i;
    char c;
    float f;
};

union Data a,b,c;

//方式3
union {
    int i;
    char c;
    float f;
}a,b,c;

与结构体有些类似，但含义不同。

结构体变量所占内存长度是各成员占的内存长度之和。每个成员分别占有其自己的内存单元。二共用体变量所占的内存长度等于最长成员的长度。如上面共用体Data的变量a,b,c各占4个字节，而不是4+1+4=9个字节。

共同体类型数据的特点：

1、同一个内存段可以存放几种不同类型的成员，但在每一瞬间只能存放其中一个成员，而不能同时存放几个。在每一个瞬间，存储单元只能有唯一的内容，也就是说，在共用体变量中只能存放一个值

2、可以对共用体变量初始化，但初始化表中只能有一个常量。

union Data {
    int i;
    char c;
    float f;
} a = {1,'a',1.2};
//这种方法是不对的。三个成员变量占用同一个存储单元。

union Data a = {16};
union Data a = {.c = 'a'};

3、共用体变量中起作用的成员是最后一次被赋值的成员，在对共用体中的一个成员赋值后，原有变量存储单元中的值就取代。

举个简单例子
union Data {
    int i;
    int sum;
    int oth;
};

int main(int argc, const char * argv[]) {
    
    union Data a;
    a.i = 10;
    printf("%d \n",a.i);
    a.sum = 100;
    printf("%d \n",a.sum);
    printf("%d \n",a.i); //值被覆盖
    a.i = 11;
    printf("%d \n",a.sum);
    printf("%d \n",a.i); //值被覆盖
    printf("%d \n",a.oth);//即使没有给这个成员赋值，它依然会有共用体其他成员赋值的结果
}

打印结果：
10 
100 
100 
11 
11 
11 

4、共用体变量的地址和它的成员地址都是统一地址。

5、不能对共用体变量名赋值，也不能企图引用变量名来得到一个值。a = 1;int m = a;,都是不对的。

6、共用体类型可以出现在结构体类型定义中，也可以定义共用体数组。反之，结构体也可以出现在共用体类型定义中，数组也可以作为共用体成员。

什么情况下会用到共用体类型数据呢？往往在数据处理中，有时需要对同一段空间安排不同的哦用途，这时用共用体类型比较方便，能增加程序处理的灵活性。

struct Person {
    char *name;
    char *job;
    union {
        int number;    //员工 编号
        char *roomname; //经理 办公室名称
    } position;
};

//对于同一个Person结构体来说
//员工与经理的办公位置是同一个属性，
//但是却有很大差别，这个时候就可以通过共同体来处理这个成员。

四、枚举类型

枚举，就是指把可能的值一一列举出来，变量的值只限于列举出来的值的范围内。

枚举类型，具有有限个可能值的数据类型，C语言对枚举类型的枚举元素按常量处理，故称枚举常量。

声明枚举一般形式：enum 枚举名 {枚举元素列表}

enum WeekDay{
    sun,
    mon,
    tue,
    wed,
    thu,
    fri,
    sta,
    
};

int main(int argc, const char * argv[]) {
    
    enum WeekDay workDay;
    workDay = sun;
    
    //每一个枚举元素代表一个整数，枚举成员默认值从0开始。
    for (; workDay <= sta; workDay ++) {
        printf("%d \n",workDay);
    }
    
    return 0;
}

五、用typedef声明新类型名

typedef用来指定新的类型名来代替已有的类型名。

1、简单地用一个新的类型名代替原有类型名

typedef int  Integer;

typedef int  Count;

int main(int argc, const char * argv[]) {
   
    Integer index = 100;
    printf("%d\n",index);
    
    Count number = 10;
    printf("%d \n",number);
    
    return 0;
}

2、命名一个简单的类型名代替复杂的类型表示方法

按照定义变量的方式，把变量名换上新类型名，并且在最前面加typedef，就声明了新类型名代替原来的类型。

声明一个新类型名的方法：

• 1、先按定义变量的方法写出定义体(如:int i;)
• 2、将变量名换成新类型名(如:间隔i换成Count)
• 3、在最前面加typedef(如:typedef int Count)
• 4、然后可以用新类型名去定义变量。

char *p;
char * String;
typedef char * String;
String p;

typedef是在编译阶段处理的，它不是作简单的字符替换。是为特定的类型指定了一个同义字(synonyms)。typedef只是对已经存在的类型指定一个新的类型名，而没有创造新的类型。