结构体

定义

数据类型：基本类型 / 自定义类型

基本类型就是系统提供，用户可以直接使用：float double char int

自定义类型就是系统没有用户可以根据自己需要来创建的数据类型，这种类型的特点：一个变量不单能够包含若干数据，同时还能是不同的类型；

int x;

int a[]；这两种数据都是单一类型，仅仅存储 int 变量；

结构体数据类型，即多又不同；

在 c program 中，自定义类型主要提供两种：结构体数据，共用体类型（共同体）

结构体数据类型的创建:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


struct 结构体类型名                    // 定义结构体类型，一般定义在全局
{
    int a;                           //成员类型 成员名；
    float b;                         //  成员类型 成员名；
    char c;
    char d[100];
};

struct 结构体类型名 结构体变量名；        // 定义结构体变量


struct intfloat a = {23,1.02,'a',"aaaa"};    // 结构体变量初始化

printf("%d",a.a);        // 结果为23， 结构体名.成员名  引用方法
printf("%s",a.d);        // 结果为 aaaa
a.c = 'k';               // 单个成员赋值 

a.d = "bbbb"；           // 字符串在初始化过后不可以直接复制；
strcpy(x.d,"abcdefg");   // 这样能够变相赋值

在结构体中想包含哪些数据，就定义对应变量；

结构体指针

如果用结构体指针来引用成员，格式为：

1
2
3
4
5


struct intfloat *p;
struct intfloat a;
p = &a;

printf("%s",p->d);             // 结构为 aaaa，无须带星号

Q1 从键盘输入 10 个同学的考试信息，考试信息包含

学号：long

性别：char m/w

成绩：int

输出最高分同学的所有信息；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


struct student{
    long number;
    char x;
    int score;
};

main(){

    struct student data[10],*p;
    int k,i,max;
    p = &data;
    for(i=0; i<10; i++){
        scanf("%ld %c %d",&p[i].number,&p[i].x,&p[i].score);
    }
    max=data[0].score;
    for(i=1; i<10; i++){
        if(p[i]->score > max)
            max = p[i]->score;
            k = i;
    }
    printf("%ld %c %d\n",p[k]->number,p[k]->x,p[k]->score);
}

结构体的类型长度

1
2
3


sizeof(struct std);        // 结构体类型长度等于各个成员类型长度之和

// 如上题，4+1+4 = 9，即 9 字节； 实际输出12个字节，求出最大字节数乘以成员数，即 4*3 =12

共同体

共用体关键字：union

共用体所有的成员共用一个空间，这个空间就是成员当中最大的那个！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


union std {
    long xh;
    double x;
    int j;
};

main(){
    union std data;
    data.xh = 12;
    data.j = 1.333;
    printf("%ld",data.xh);
}
// 结果为 1.333

// 因为在共用体里，所有成员都是用同一个空间，所有元素的结果 等于最后一次赋值的结果；

存储类型

在 c program 中存储类型有三种：

auto	动态存储类型
static	静态存储类型
register	寄存器类型

auto 存储类型是最常用的，最有效；随用随给，不用回收；

static 静态类型，一旦将存储空间分配给某个变量，在程序没有结束前，这个空间是不能收回的，永远保存存储的数据，在函数内不会消亡。

**Q2 **

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


int x;
int fun(int x){
    int a=1,b=1;
    static c = 1;
    a++;
    b++;
    c++
    return a+b+c+x;
}

main(){
    int i;
    for(i=1; i<=3; i++)
        printf("%d",fun(i));
}

// 第一轮循环
// i=1,a=b=c=2  ,re = 6+1 = 7
// 第二轮循环
// i=2,a=b=2,c=3 re = 7+2 = 9
// 第三轮
// i=3,a=b=2,c=4,re=8+3 = 11