学习了数组，可以声明一个int integer[10];的数组，在其中包含 10 个整数型的元素。通过数组，可以管理和使用这些类型一致的数组元素。

那如果希望把类型不一致的元素放到一起，C 语言中有没有类似数组一样的做法呢？

结构体

通过定义一个结构体，可将一系列类型相同或不同的元素放在一起。
例如，希望定义一种存放个人基本信息的结构，就可以通过定义结构体的关键字struct完成这一过程：

struct person {
    char name[20];  // 姓名
    int age;        // 年龄
    char gender;    // 性别
    float height;   // 身高
};

结构体初始化时，条目用分号结束；结构体在赋值时候，使用等号操作，结尾的分号很重要，结构体内部元素值用逗号分隔；

在这样一个被定义的结构体类型中，包含了姓名（字符数组）、年龄（整型）、性别（字符型）、身高（浮点型）。

定义了person结构体类型后，如果需要保存tom的信息，我们就不再需要分别声明四个不同类型变量，而只需要使用结构体类型直接声明结构体变量：

struct person tom;

结构体的元素可以通过成员运算符.进行访问。被访问的结构体元素可以被视为任何一个普通变量，我们可以通过scanf读入值到结构体变量的元素、也可以通过 printf输出它的值。例如，对于上面已有的结构体变量tom我们可以进行如下的赋值：

strcpy(tom.name, "Tom Cruise");
tom.age = 54;
tom.gender = 'm';
tom.height = 170.18f;

无论是结构体中哪个成员元素变量，都需要在结构体变量名后加上成员运算符后才可被访问。结构体变量名加上成员运算符 . 再加上成员元素名作为一个整体，在被使用时与一个普通的变量完全一致。

也可以通过类似于数组初始化的方式直接在声明结构体的时候，就让其中的成员元素获得初值。

struct person tom = { "Tom Cruise", 54, 'm', 170.18f };

初始化的信息特别长时，也可以分行写：

struct person tom = {
    "Tom Cruise",
    54,
    'm',
    170.18f
};

如果希望声明一个符合某一结构设计的结构体类型的变量，但又确定这种结构体类型不会再用于其它变量。可以直接在定义结构体的同时完成变量声明。例如，我们也可以直接通过下面的方式获得一个和之前存储的数据完全一致的结构体变量tom。

struct {
    char name[20];  // 姓名
    int age;        // 年龄
    char gender;    // 性别
    float height;   // 身高
} tom;

示例：两点距离：

#include <stdio.h>
#include <math.h>
// 请在这里定义结构体
struct point{
    float x;
    float y;
};
int main() {
    struct point p1 = { 2.3f, 4.5f };
    struct point p2 = { 4.3f, 2.4f };
    printf("%f\n",sqrt( pow(p1.x-p2.x, 2)+pow(p1.y - p2.y, 2)) );

    return 0;
}

也可以结构体之间进行嵌套，例如：

#include <stdio.h>
#include <math.h>
struct point {
    float x;
    float y;
};
// 在这里定义描述矩形的结构体
struct rectangle {
    struct point p1;
    struct point p2;
};
int main() {            //通过对角线两个坐标的点计算矩形面积
    struct rectangle rect = {
        {3.4f, 2.6f},
        {2.7f, 4.9f}
    };
    printf("%f\n", fabs(rect.p1.x - rect.p2.x) * fabs(rect.p1.y - rect.p2.y));
    return 0;
}

结构体的性质：

• 成员类型可以相同也可以不同；
• 结构体成员元素在结构体描述中的顺序会影响结构体使用时所需要的内存大小；
• 成员可以是另一个结构体

题目

完成给定点是否在给定矩形中的判断。
输入两行，第一行输入两个整数，横坐标和纵坐标；
第二行输入四个整数，表示矩形某对角线上两顶点。
前两个整数表示其中一个顶点的横坐标和纵坐标；
后两个整数表示另一个顶点的横坐标和纵坐标。

样例输入1

1 4
0 0 5 5

样例输出1

YES

样例输入2

1 4
3 3 0 0

样例输出2

NO

代码：

#include <stdio.h>
#include <math.h>

struct point {
    int x;
    int y;
};
struct rectangle {
    struct point p1;
    struct point p2;
};
void inandout (int x, int y, int leftx, int lefty, int rightx, int righty){
    if (((x >= leftx )&&( x <= rightx)&& (y >= lefty )&&( y <= righty))\
    ||((x <= leftx )&&( x >= rightx)&& (y <= lefty )&&( y >= righty))\
    ||((x <= leftx )&&( x >= rightx)&& (y >= lefty )&&( y <= righty))\
    ||((x >= leftx )&&( x <= rightx)&& (y <= lefty )&&( y >= righty))){
        printf("YES");
    }else{
        printf("NO");
    }
    return;
}

int main() {
    struct point a;
    struct rectangle rect;
    scanf ("%d%d%d%d%d%d",&a.x,&a.y,&rect.p1.x,&rect.p1.y,&rect.p2.x,&rect.p2.y);
    inandout(a.x, a.y, rect.p1.x, rect.p1.y, rect.p2.x, rect.p2.y);
    return 0;
}

类型别名

在之前的学习中，我们已经学会了如何定义和使用结构体。但是，每当我们需要使用结构体的时候，我们都会需要写一次struct关键字。

C 语言中提供了一种为某一已知类型添加别名的方式——typedef（表示 type define）。

typedef 原类型 类型别名

例如，对于一个已经定义好的结构体模板，我们可以给其一个别名，使它可以像int、float这些基础类型一样被方便地使用：

typedef struct point Point;

在这里被设置别名的原类型为struct point，类型别名为Point。
完成了设置别名后，我们如果再进行变量的声明时，我们就可以不写：

struct point point1;

而直接写：

Point point1;

一步到位

也可以在定义结构体的时候，就同时在前面加上typedef，那样我们就可以把这两步二合一，得到：

typedef struct point {
    float x;
    float y;
} Point;

同样的，当我们将结构体定义和起别名一次性完成后，我们也可以直接通过

Point point1;

的方式声明新的符合结构体类型定义的变量了。

注意

我们并不是只能对结构体类型进行别名的设置。如果我们希望会大量的用整数型的数字表示尺寸，我们也可以使用typedef定义一个int类型的别名Size：
typedef int Size;
定义了这一类型别名之后，我们在关于长度一些场合，就可以直接使用Size声明变量了。举例来说，直接声明变量时我们就可以写：
Size rule_length;
在定义一个描述盒子的结构体时，我们就可以写：

typedef struct box {
    Size width;
    Size height;
    Size length;
} Box;

注意一个风格习惯问题。在进行类型别名的定义时，被定义出的类型的首字母一般会使用大写。这是约定俗成的好习惯。
实际使用大写开头的这种做法，可以尽可能减小和 C 语言中的关键字和程序中定义的变量名、函数名发生冲突的可能性。

题目：向量相加、相乘（使用了以向量为自变量和参变量的函数）

#include <stdio.h>
#include <math.h>

typedef struct point {
    float x;
    float y;
} Vector;
Vector vector_add(Vector v1, Vector v2){
    v1.x += v2.x;
    v1.y += v2.y;
    return v1;
}
int main() {                                                 //向量相加
    Vector v1 = {2.4f,2.5f};
    Vector v2 = {3.7f,4.4f};
    Vector v_result;
    v_result= vector_add(v1,v2);
    printf("(%f, %f)\n", v_result.x,v_result.y);
    return 0;
}

#include <stdio.h>
#include <math.h>

typedef struct point {
    int x;
    int y;
} Vector;

int vector_dotprod(Vector v1, Vector v2) {
    return( v1.x*v2.x + v1.y*v2.y);
}

int main() {                        //向量点乘积
    Vector v1;
    Vector v2;
    int dotprod_result;                     

    scanf("%d%d", &(v1.x), &(v1.y));
    scanf("%d%d", &(v2.x), &(v2.y));

    dotprod_result = vector_dotprod(v1, v2);

    printf("%d", dotprod_result);

    return 0;
}

结构体指针

函数传入的形参太多效率低下，换成指针形式可以节省资源；结构体做函数参数的效率不如直接传结构体的地址,在函数参数中用指针变量接收高效
以下的代码形式还可以改变：

#include <stdio.h>
#include <math.h>

typedef struct point {
    float x;
    float y;
} Vector;

Vector vector_add(Vector *v1, Vector *v2) {
    Vector v_result;
    v_result.x = (*v1).x + (*v2).x;
    v_result.y = (*v1).y + (*v2).y;
    return v_result;
}

int main() {
    Vector v1 = { 2.4f, 2.5f };
    Vector v2 = { 3.7f, 4.4f };
    Vector v_result;
    v_result = vector_add(&v1, &v2);    //传入的是地址
    printf("(%f, %f)\n", v_result.x, v_result.y);
    return 0;
}

在vector_add函数中,通过 (*v1).x 的方式取结构体指针的值,并访问它的成员元素,当v1是一个结构体的指针时,我们可以通过 v1->x 访问v1指向的结构体的成员x。也就是输哦上述代码可以替换成

#include <stdio.h>
#include <math.h>

typedef struct point {
    float x;
    float y;
} Vector;

Vector vector_add(Vector *v1, Vector *v2) {
    Vector v_result;
    v_result.x = v1->x + v2->x;
    v_result.y = v1->y + v2->y;
    return v_result;
}

int main() {
    Vector v1 = { 2.4f, 2.5f };
    Vector v2 = { 3.7f, 4.4f };
    Vector v_result;
    v_result = vector_add(&v1, &v2);           //传入的是地址
    printf("(%f, %f)\n", v_result.x, v_result.y);
    return 0;
}

结果是一样的了。
再用到

(*结构体指针名).结构体成员元素名

形式的代码时,我们都可以将其写为

结构体指针名->结构体成员元素名