C语言学习笔记-9

九、结构体

构造类型：

不是基本类型的数据结构也不是指针类型，它是若干个相同或不同类型的数据构成的集合

结构体类型：

结构体是一种构造类型的数据结构，是一种或多种基本类型或构造类型的数据的集合。

1.结构体类型定义

定义：

(1).先定义结构体类型，再去定义结构体变量

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

struct stu{
int num;
char name[20];
char sex;
};
//有了结构体类型后， 就可以用类型定义变量了
struct stu lucy,bob,lilei;//定义了三个 struct stu 类型的变量，每个变量都有三个成员， 分别是 num name sex

(2).在定义结构体类型的时候顺便定义结构体变量，以后还可以定义结构体变量

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

struct 结构体类型名变量 3，变量 4；

struct stu{
int num;
char name[20];
char sex;
}lucy,bob,lilei;
struct stu xiaohong,xiaoming；

无结构体类型名

在定义结构体类型的时候，没有结构体类型名，顺便定义结构体变量，

因为没有类型名，所以以后不能再定义相关类型的数据了

struct {
成员列表;
}变量 1，变量 2;

struct {
int num;
char name[20];
char sex;
}lucy,bob;
//以后没法再定义这个结构体类型的数据了， 因为没有类型名

最常用：

通常咱们将一个结构体类型重新起个类型名，用新的类型名替代原先的类型

typedef struct stu{
int num;
char name[20];
char sex;
}STU;
//以后 STU 就相当于 struct stu
STU lucy;和 struct stu lucy;是等价的。

2.结构体变量的定义初始化及使用

1、结构体变量的定义和初始化

(1):在定义结构体变量之前首先得有结构体类型，然后再定义变量
(2):在定义结构体变量的时候，可以顺便给结构体变量赋初值，被称为结构体的初始化
(3):结构体变量初始化的时候，各个成员顺序初始化

struct stu{
int num;
char name[20];
char sex;
};struct stu boy;
struct stu lucy={
101,
"lucy",
'f'
};
//结构体内后面的变量可以不初始化，中间的变量必须初始化

2、结构体变量的使用

(1).结构体变量成员的引用方法：结构体变量.成员名

struct stu{
int num;
char name[20];
char sex;
char* addr;
};
struct stu bob;
bob.num=101;//bob 是个结构体变量，但是 bob.num 是个 int 类型的变量
bob.name 是个字符数组，是个字符数组的名字，代表字符数组的地址，是个常量
//bob.name ="bob";是不可行，是个常量
strcpy(bob.name,"bob");strcpy(bob.addr,"beijing")//错误，bob.addr是个野指针
bob.addr="beijing";//正确

#include <stdio.h>
struct stu{
int num;
char name[20];
int score;
char *addr;
};
int main(int argc, char *argv[])
{
struct stu bob;
printf("%d\n",sizeof(bob));
printf("%d\n",sizeof(bob.name));
printf("%d\n",sizeof(bob.addr));
return 0;
}
//结构体大小，为各元素的大小之和

3、相同类型的结构体变量相互赋值

#include <stdio.h>
struct stu{
int num;
char name[20];
char sex;
};int main(int argc, char *argv[])
{
struct stu bob={101,"bob",'m'};
struct stu lilei;
lilei=bob;//类型相同
printf("%d %s %c\n",lilei.num,lilei.name,lilei.sex);
return 0;
}

3.结构体数组

结构体数组是个数组，由若干个相同类型的结构体变量构成的集合

1、结构体数组的定义方法

struct 结构体类型名数组名[元素个数];

struct stu{
int num;
char name[20];
char sex;
};
struct stu edu[3];//定义了一个 struct stu 类型的结构体数组 edu，
这个数组有3个元素分别是 edu[0]、 edu[1]、edu[2]

结构体数组元素的引用：数组名[下标]

数组元素的使用

edu[0].num =101;//用 101 给 edu 数组的第 0 个结构体变量的 num 赋值
strcpy(edu[1].name,"lucy");

#include <stdio.h>
typedef struct student
{
int num;
char name[20];
float score;
}STU;
STU edu[3]={
{101,"Lucy",78},
{102,"Bob",59.5},
{103,"Tom",85}
};
int main()
{
int i;
float sum=0;
for(i=0;i<3;i++)
{sum+=edu[i].score;} 
printf("平均成绩为%f\n",sum/3);
return 0;
}

4.结构体指针

即结构体的地址，结构体变量存放内存中，也有起始地址。咱们定义一个变量来存放这个地址，那这个变量就是结构体指针变量。
结构体指针变量也是个指针，既然是指针在 32 位环境下，指针变量的占 4 个字节，存放一个地址编号。

1、结构体指针变量的定义方法：

struct 结构体类型名 * 结构体指针变量名;

struct stu{
int num;
char name[20];
};
struct stu * p;//定义了一个 struct stu *类型的指针变量
//变量名是p，p占4个字节，用来保存结构体变量的地址编号
struct stu boy;
p=&boy;boy.num=101;//可以，通过 结构体变量名.成员名
(*p).num=101;//可以，*p 相当于 p 指向的变量 boy
p->num=101;//可以，指针->成员名
//通过结构体指针来引用指针指向的结构体的成员， 前提是指针必须先指向一个结构体变量。

2、应用场景

(1)：保存结构体变量的地址

typedef struct stu{
int num;
char name[20];
float score;
}STU;int main()
{
STU *p,lucy;
p=&lucy;
p->num=101;
strcpy(p->name,"baby");
//p->name="baby";//错误，因为 p->name 相当于 lucy.name 是个字符数组的名字，是个常量
}

(2)：函数传结构体变量的地址

#include<stdio.h>
#include<string.h>
typedef struct stu{
int num;
char name[20];
float score;
}STU;
void fun(STU *p)
{
p->num=101;
(*p).score=87.6;
strcpy(p->name,"lucy");
} int main()
{
STU girl;
fun(&girl);
printf("%d %s %f\n",girl.num,girl.name,girl.score);
return 0;
}

(3)：传结构体数组的地址

结构体数组，是由若干个相同类型的结构体变量构成的集合。存放在内存里，
也有起始地址，其实就是第 0 个结构体变量的地址。

#include<stdio.h>
#include<string.h>
typedef struct stu{
int num;
char name[20];
float score;
}STU;
void fun(STU *p)
{
p[1].num=101;
(*(p+1)).score=88.6;
}
int main()
{
STU edu[3];
fun(edu);
printf("%d %f\n",edu[1].num,edu[1].score);
return 0;
}

注意：

(1)：结构体变量的地址编号和结构体第一个成员的地址编号相同，但指针的类型不同

#include <stdio.h>
typedef struct stu{
int num;
char name[20];
int score;
}STU;
int main(int argc, char *argv[])
{
STU bob;
printf("%p\n",&bob);//STU*
printf("%p\n",&(bob.num));//int*
return 0;
}

(2)：结构体数组的地址就是结构体数组中第 0 个元素的地址

#include <stdio.h>
struct stu{
int num;
char name[20];
int score;
};int main(int argc, char *argv[])
{
struct stu edu[3];
printf("%p\n",edu);//struct stu *
printf("%p\n",&(edu[0]));//struct stu *
printf("%p\n",&(edu[0].num));//int *
return 0;
}//各地址相同

5.结构体内存分配

规则 1：以多少个字节为单位开辟内存

(1)：成员中只有 char 型数据，以 1 字节为单位开辟内存。
(2)：成员中出现了 short int 类型数据，没有更大字节数的基本类型数据。以 2 字节为单位开辟内存
(3)：出现了 int ，float 没有更大字节的基本类型数据的时候以 4 字节为单位开辟内存。
(4)：出现了 double 类型的数据
情况 1：
在 vc6.0 和 Visual Studio 中里，以 8 字节为单位开辟内存。
情况 2：
在 Linux 环境 gcc 里，以 4 字节为单位开辟内存。
无论是那种环境， double 型变量，占 8 字节。

(5)：如果出现指针的话，没有占字节数更大的类型的，以 4 字节为单位开辟内存。

struct stu{
char sex;
int age;
}lucy;
//lucy 的大小是 4 的倍数。

规则 2：字节对齐

(1)： char 1 字节对齐，即存放 char 型的变量，内存单元的编号是 1 的倍数即可。
(2)： short int 2 字节对齐，即存放 short int 型的变量，起始内存单元的编号是 2 的倍数即可。

(3)： int 4 字节对齐，即存放 int 型的变量，起始内存单元的编号是 4 的倍数即可
(4)： long int 在 32 位平台下,4 字节对齐，即存放 long int 型的变量，起始内存单元的编号是 4
的倍数即可
(5)： float 4 字节对齐，即存放 float 型的变量，起始内存单元的编号是 4 的倍数即可
(6)： double
vc6.0 和 Visual Studio 环境下
8 字节对齐，即存放 double 型变量的起始地址，必须是 8 的倍数， double 变量占 8 字节

gcc 环境下
4 字节对齐，即存放 double 型变量的起始地址，必须是 4 的倍数， double 变量占 8 字节。

注意 3：当结构体成员中出现数组的时候，可以看成多个变量。
注意 4：开辟内存的时候，从上向下依次按成员在结构体中的位置顺序开辟空间

#include<stdio.h>
struct stu{
char a;
short int b;
int c;
}temp;
int main()
{
printf("%d\n",sizeof(temp));
printf("%p\n",&(temp.a));
printf("%p\n",&(temp.b));
printf("%p\n",&(temp.c));
return 0;
}

在这里插入图片描述

结果分析：
a 的地址和 b 的地址差 2 个字节
b 的地址和 c 的地址差 2 个字节

#include<stdio.h>
struct stu{
char a;
int c;
short int b;
}temp;
int main()
{
printf("%d\n",sizeof(temp));
printf("%p\n",&(temp.a));
printf("%p\n",&(temp.b));
printf("%p\n",&(temp.c));
return 0;
}

在这里插入图片描述

结果分析：
a 和 c 的地址差 4 个字节
c 和 b 的地址差 4 个字节

struct stu{
char buf[10];
int a;
}temp;
//temp 占 16 个字节

在这里插入图片描述

在 vc 和 Visual Studio 中占 16 个字节 a 和 b 的地址差 8 个字节
在 gcc 中占 12 个字节 a 和 b 的地址差 4 个字节
#include<stdio.h>
struct stu{
char a;
double b;
}temp;
int main()
{
printf("%d\n",sizeof(temp));
printf("%p\n",&(temp.a));
printf("%p\n",&(temp.b));
return 0;
}