一、 结构体的根本用法
1.1 界说
结构体是由一批数据组合而成的结构型数据。组成结构型数据的每个数据称为结构型数据的“成员” ，其描述了一块内存区间的巨细及解释意义。
1.2 界说格局
struct 结构体名
{
数据类型 成员变量1;
数据类型 成员变量2;
数据类型 成员变量3;
...
};
举例：结构一个新的数据类型叫student,用来描述学生。
struct student
{
char name[32];
int age;
float score;
};
1.3 结构体变量
1.3.1 概念
经过结构体数据类型界说的变量
1.3.2 格局
struct 结构体名 变量名;
1.3.3 界说结构体变量
(1) 先界说结构体，再界说结构体变量。
struct 结构体名
{
成员变量;
};
struct 结构体名 变量名;
例如：
struct student
{
char name[32];
int age;
float score;
};
struct student s1;
(2) 界说结构体的一起，界说结构体变量。
struct 结构体名
{
成员变量;
} 变量名;
例如：
struct person
{
char name[32];
int age;
} per1;
也能够缺省结构体名界说结构体变量：
struct
{
成员变量;
} 变量名;
1.3.4 结构体变量赋值
先界说一个结构体：
struct student
{
int id;
char name[32];
int age;
};
(1) 界说结构体变量时直接用花括号赋值
struct student stu1 ={1,"xiaofang", 18};
(2) 界说结构体变量时直接用点等法赋值:
struct student stu2 ={
.id = 2,
.name = "xiaoming",
.age = 42
};
(3) 界说结构体变量时未初始化，需求挨个独自赋值:
struct student stu3;
stu3.id = 3;
stu3.age = 69;
strcpy(stu3.name,"laowang");
1.3.5 访问结构体成员变量
经过.访问： 结构体变量名.结构体成员变量名。
struct student stu4;
scanf("%d %s %d",&stu4.id,stu4.name,&stu4.age);
printf("%d %s %d\n",stu4.id,stu4.name,stu4.age);
操练：创立一个名为student的结构体，包括名字，学号，班级, 从终端输入学生的信息并打印。
#include <stdio.h>
#include <string.h>
struct student
{
char name[32];
int id;
int class;
};
int main()
{
struct student stu1;
scanf("%s %d %d",stu1.name,&stu1.id,&stu1.class);
printf("%s %d %d\n",stu1.name,stu1.id,stu1.class);
}
1.3.6 重界说 typedef
重界说的意义便是给语句另起一个名字
例如：
typedef int size_t;
此刻int a; 也能够写成 size_t a;
typedef int* int_pointer;
int a;
此刻int* p=&a; 能够写成 int_pointer p=&a;
(1) 界说结构体的一起重界说
#include <stdio.h>
#include <string.h>
typedef struct flower
{
char type[32];
int size;
char color[32];
} flo;
int main()
{
flo f1 = {"rose",10,"red"};
printf("%s %d %s\n",f1.type,f1.size,f1.color);
}
(2) 先界说结构体，再进行重界说
struct animal
{
char type[32];
char class[32];
int wight;
};
typedef struct animal ANIMAL;
int main()
{
ANIMAL an1 = {"dog","buru",200};
printf("%s %s %d\n",an1.type,an1.class,an1.wight);
}
操练：创立一个描述手机的结构体叫phone, 包括品牌，型号，色彩，价格。从终端输入你自己手机的信息并打印。
typedef struct phone
{
char brand[32];
char typde[32];
char color[32];
int price;
} pho;
int main()
{
pho ph1;
scanf("%s %s %s %d", ph1.brand, ph1.typde, ph1.color, &ph1.price);
printf("%s %s %s %d\n", ph1.brand, ph1.typde, ph1.color, ph1.price);
return 0;
}
二、结构体数组
2.1 概念
本质是数组，结构体类型相同的变量组成的数组
2.2 界说格局
（1）界说结构体一起界说结构体数组
struct student
{
int id;
int age;
float score;
} stu[5];
（2）先界说结构体，再界说结构体数组
struct student
{
int id;
int age;
float score;
};
struct student stu[5];
2.3 初始化和赋值
（1）界说结构体数组的一起赋值
办法一：
#include <stdio.h>
#include <string.h>
struct hero
{
char name[32];
char postion[32];
char skill1[32];
char skill2[32];
char skill3[32];
char skill4[32];
int price;
};
int main()
{
struct hero h[2] =
{
{"ali","fashi","1","2","3","4",4300},
{"shitou","tanke","1","2","3","4",3150}
};
printf("%s %s %s %s %s %s %d\n", h[1].name, h[1].postion, h[1].skill1, h[1].skill2, h[1].skill3, h[1].skill4, h[1].price);
return 0;
}
办法二：“点等法”
#include <stdio.h>
struct student
{
int num;
float score;
char name[32];
};
int main(int argc, const char *argv[])
{
#if 0
struct student stu[3] = {1,99.9,"zhangsan",2,88.8,"lisi",3,98.9,"wangwu"};
#endif
#if 0
struct student stu[3]=
{
[0] = {
.num = 1,
.score = 99.9,
.name = "zhangsan",
},
[2] = {
.num = 3,
.score = 77.7,
.name = "lisi",
}
};
int i;
for(i = 0; i < sizeof(stu)/sizeof(struct student);i++)
{
printf("%d,%f,%s\n",stu[i].num,stu[i].score,stu[i].name);
}
#endif
struct student stu =
{
.num = 1,
.score = 99.9,
.name = "wangwu",
};
#if 0
stu.num = 1;
stu.score = 99.9;
#endif
printf("%d,%f,%s\n",stu.num,stu.score,stu.name);
return 0;
}
（2）先界说结构体数组，再对数组内每个元素别离赋值
#include <stdio.h>
#include <string.h>
struct hero
{
char name[32];
char postion[32];
char skill1[32];
char skill2[32];
char skill3[32];
char skill4[32];
int price;
};
int main()
{
struct hero he[2];
strcpy(he[0].name,"namei");
strcpy(he[0].postion,"fashi");
he[0].price = 6300;
printf("%s %s %d\n", he[0].name, he[0].postion,he[0].price);
return 0;
}
这里要注意，结构体成员变量为字符串类型，要为其单个赋值时，要用strcpy函数。
2.4 结构体数组输入输出（经过循环）
#include <stdio.h>
#include <string.h>
struct hero
{
char name[32];
char postion[32];
int life;
int magic;
float speed;
int price;
};
int main()
{
struct hero h[5] =
{
{"ali", "magicer", 596, 481, 53.04, 6300},
{"gailun", "tank", 700, 0, 55.04, 450},
{"jee", "ad", 596, 200, 55.04, 6300},
{"cat", "helfer", 400, 400, 45, 6300},
{"ez", "adc", 550, 450, 53.04, 6300},
};
for (int i = 0; i < 5; i++)
{
printf("%s %s %d %d %f %d\n",h[i].name,h[i].postion,h[i].life,h[i].magic,h[i].speed
,h[i].price);
}
return 0;
}
2.5 结构体巨细
（1）= 结构体类型巨细 元素个数
（2）用sizeof(struct 结构体名) 或许sizeof(结构体变量名)
例如接着上面的操练：
printf("struct hero:%d %d\n",sizeof(struct hero),sizeof(h));//80 400
三、结构体巨细以及对齐准则
3.1 结构体巨细用sizeof核算
#include <stdio.h>
#include <string.h>
struct st
{
char a;
char b;
int c;
};
struct s
{
char a;
int b;
char c;
};
int main()
{
printf("%d\n",sizeof(struct st)); //8
printf("%d\n",sizeof(struct s)); //12
return 0;
}
3.2 字节对齐准则
（1）第一个成员在相对于结构体变量起始方位偏移量为0的地址处。浅显点来说，便是第一个成员变量的地址与结构体起始方位的地址是相同的。如下图所示：
（2）用结构体成员里面最大的数据类型的巨细和字节进行比较，然后按照字节数小的为单位拓荒空间。例如上图比如，每个成员都要给他以4字节为单位拓荒空间。
3.3 节约空间准则
为了减少空间浪费，把占用空间小的成员会集到一起
四、结构体指针
4.1 概念
指向结构体变量的指针
4.2 界说格局
*struct 结构体名 结构体指针名；
例如：
struct student
{
int id;
char name[32];
}s1,s2;
struct work
{
int id;
int age;
}w1,w2;
struct student *sp = &s1;
//struct student *p=&w1; //错误，结构体类型不同
4.3 结构体指针成员变量赋值
格局：指针变量名->成员变量名 或许：**(指针变量名).成员变量名*
#include <stdio.h>
#include <string.h>
struct student
{
int id;
char name[32];
}s1,s2;
int main()
{
struct student *sp = &s1;
strcpy(sp->name,"xiaoming");
sp->id=123;
printf("%s %d\n",s1.name,s1.id);
printf("%s %d\n",sp->name,sp->id);
return 0;
}
注：结构体指针巨细：4字节，由于本质仍是指针。
五、结构体内包括结构体
假如结构体内成员自身归于另一种结构体，得用若干个成员运算符一级级找到最初级的成员变量。
#include <stdio.h>
#include <string.h>
struct work
{
int ip;
};
struct student
{
int id;
int age;
struct work w1;
} stu1, stu2;
int main()
{
stu1.w1.ip = 2;
stu1.id = 1;
stu1.age = 20;
printf("%d %d %d\n", stu1.w1.ip, stu1.id, stu1.age);
return 0;
}
结构体总结：
- 不能把结构体类型变量作为全体引证，只能对结构体内变量中的各个成员别离引证。
- 假如成员自身归于另一种结构体类型，要用若干个成员运算符.一级级找到最初级成员变量。
- 能够把成员变量当成普通变量运算
- 数组中，成员之间不能彼此赋值，可是结构体变量能够相互赋值。
操练1： 创立一个结构体数组，数组名为book，结构体成员包括编号，书名，价格（数据类型自己设定）。写一个函数，包括两个形参，别离接纳结构体数组的首地址和一个指定的价格，函数的功能为打印结构体数组中价格大于指定价格的书的信息。
#include <stdio.h>
#include <string.h>
typedef struct book
{
int number;
char name[32];
int price;
} BOOK;
BOOK b[5]={
{1,"santi",25},
{2,"hongloumeng",45},
{3,"jinpingmei",50},
{4,"xiyouji",87},
{5,"sanguo",67}
};
void book_Pri(BOOK *p, int n)
{
for(int i=0;i<5;i++)
{
if(p->price >= n)
printf("%d %s %d\n",p->number,p->name,p->price);
p++;
}
}
int main()
{
book_Pri(b,50);
return 0;
}
操练2：创立一个名为student的结构体数组，包括学号，名字，分数,(数据类型自己界说),从终端输入学生的信息并打印分数及格的学生信息（输入3人即可）。封装函数完成把其中第几个学生信息清零。
#include <stdio.h>
#include <string.h>
typedef struct student
{
int id;
char name[32];
float score;
} STU;
STU s[3];
void delStudent(STU *p, int n)
{
n--;
/*第一种清零方法 */
// (p+n)->id=0;
// strcpy((p+n)->name,"\0");
// (p+n)->score=0;
/*第二种清零方法 */
//memset((p+n),0,sizeof(struct student));
/*第三种清零方法*/
STU stu2 ={0,"\0",0};
p[n] = stu2;
}
int main()
{
printf("pls input student information:\n");
for(int i=0;i<3;i++)
scanf("%d %s %f",&s[i].id,s[i].name,&s[i].score);
for(int i=0;i<3;i++)
{
if(s[i].score >= 60)
printf("%d %s %f\n",s[i].id,s[i].name,s[i].score);
}
delStudent(s,2);
printf("student information:\n");
for(int j=0;j<3;j++)
printf("%d %s %f\n",s[j].id,s[j].name,s[j].score);
return 0;
}
操练3：创立一个结构体数组,数组名为lolHero,成员包括名称, 方位, 血量和价格。给出每个lol英豪信息，封装函数完成按价格从低到高打印英豪信息。（用冒泡排序）
#include <stdio.h>
#define N 5
typedef struct hero
{
char *name;
char *position;
int blood;
int price;
} HERO;
void sort(HERO *p, int n)
{
HERO temp;
for (int i = 1; i < N ; i++)
{
for (int j = 0; j < N - i; j++)
{
if (p[j].price > p[j + 1].price)
{
temp = p[j];
p[j] = p[j + 1];
p[j + 1] = temp;
}
}
}
}
int main(void)
{
HERO lolHero[N] = {
{"ali", "ap", 596, 6300},
{"gailun", "tank", 700, 450},
{"jee", "ad", 596, 6000},
{"cat", "helfer", 400, 6300},
{"ez", "adc", 550, 6500}
};
sort(lolHero, N);
for (int i = 0; i < N; i++)
printf("%d. %8s %8s %8d %8d\n",i+1, lolHero[i].name, lolHero[i].position, lolHero[i].blood, lolHero[i].price);
}
操练4：已知字符数组a[10]和b[10]中元素的值递增有序，封装函数并用指针完成将两个数组中元素按照递增顺序输出。
如：char a[10]=”acdgjmno” ; char b[10]=”befhil”;->”abcdefghijlmno”
思路：运用指针比较两字符数组中的元素，若a中的小，打印a中字符，然后a的指针移动到下一个元素继续比较，反之打印b然后移动b指针到下一个元素继续比较。最后判别字符串是否完毕，打印没有完毕的字符串剩余部分
#include <stdio.h>
void fun(char *p1, char *p2)
{
while (*p1 != '\0' && *p2 != '\0') //判别是否到两个数组的结束
{
if (*p1 < *p2) //进行比较，把小的数据打印出来
{
printf("%c", *p1);
p1++;
}
else
{
printf("%c", *p2);
p2++;
}
}
if (*p1 == '\0') //把其中剩余的数据打印出来
printf("%s\n", p2);
else if (*p2 == '\0')
printf("%s\n", p1);
}
int main(int argc, char const *argv[])
{
char a[10] = "acegijkm";
char b[10] = "bdfh";
fun(a, b);
return 0;
}
六、共用体
共用体有时候也称联合体，用法相似结构体struct,区别在于结构体所占内存巨细等于一切成员占用内存总和。而共用体运用了内存覆盖技能，同一时刻只能保存一个成员的值，假如对新成员赋值，就会把原来成员的值覆盖掉。
6.1格局
union 共用体名
{
成员列表;
};
6.2 界说共用体union变量
#include <stdio.h>
union val
{
int a;
char ch;
};
union val v;
int main(int argc, char const *argv[])
{
v.a=10;
v.ch='c';
printf("%d\n",v.a);
return 0;
}
得出共用体变量共用一块空间
6.3 特性
-
(1) 共用体成员一起运用一块内存空间
-
(2) 赋值顺序以最后顺次赋值为准
-
(3) 共用体的巨细为成员中数据类型最大的数据为巨细
6.4 运用共用体测试巨细端：
#include <stdio.h>
union val
{
int a;
char ch;
};
union val v;
int main(int argc, char const *argv[])
{
v.a=10;
if(v.ch == 10)
printf("small\n");
else if(v.ch == 0)
printf("big\n");
printf("%d\n",v.ch);
return 0;
}
七、枚举
7.1 界说
用户自界说数据类型，能够用于声明一组常数。
在实际编程中，有些数据的取值往往是有限的，只能是非常少量的整数，并且最好为每个值都起一个名字。
例如以每周七天为比如，我们能够运用宏界说#define来为每天命名：
#define MON 1
#define TUES 2
…
虽然能解决问题可是宏名过多导致代码看起来很松散，所以C语言供给了一种枚举enum，能够列出一切或许的取值，并给它们起一个名字。
7.2 格局
enum 枚举名
{
value 1,
value 2,
value 3,
...
};
未赋初值时，第一个常数会默认为0，然后下面的顺次加一。每个元素都能够赋值，假如有元素没有赋值则默认值为上一个元素加一。
比如：
#include <stdio.h>
enum week
{
MON,
THES = 2,
WED,
};
int main(int argc, char const *argv[])
{
int day = 0;
scanf("%d", &day);
switch (day)
{
case MON:
printf("%d\n", MON);
break;
case THES:
printf("%d\n", THES);
break;
case WED:
printf("%d\n", WED);
break;
default:
break;
}
printf("MON:%d\n", MON);
printf("THES:%d\n", THES);
printf("WED:%d\n", WED);
return 0;
}
八、数据类型总结
- 根本数据类型：根本数据类型首要的特点是其值不能够再分解为其他类型，也便是说，根本数据类型是自我阐明的。如: short int long float double signed unsigned
- 结构数据类型：结构数据类型是依据已界说的一个或多个数据类型用结构的办法来界说的。也便是说一个结构型的值能够分解成若干个“成员”或许“元素”。每个“成员”都是一个根本数据类型或许又是一个结构型。struct结构体、union联合体、enum枚举和数组。
- 指针类型：指针是一个特殊的数据类型。其值用来标识某个变量再内存中的地址。虽然指针变量的取值相似于整型，但这两个类型彻底不同，不能混杂。界说时要加*。
- 空类型：空类型void用来界说任意类型的指针和无返回值的函数。
