目录
结构体诞生 构造新类型！
道家思想：“道生一，一生二，二生三，三生万物”
也就是 ： 从单变量->数组->结构体
1:1 一个变量，一个类型 单一类型变量
N:1 N个变量，一个类型 数组
N:M N个变量，M个类型 结构体
为了更方便的描述事情，C语言对变量类型 开放权限，允许在基础类型的基础上进行自由构造。
typedef struct stu
{
int num;
char name[20];
char sex;
float score;
}Stu;
Stu s1; //定义 与 int a; 地位等价结构体构造类型 typedef
（1）typedef 使用
1、先用原类型定义变量
2、定义之前加 typedef
3、将原变量的名字 换成你需要的类型名
注意：typedef 只是对现有类型 取别名，不能创造新类型。
（2）typedef 与 define
Define 构成的语句在预处理阶段——进行文本替换，不过脑子的那种替换
typedef 构成C语言的语句；参与编译
#define pointer char*
pointer m,n;
printf("\nsizeof(m) = %d\t sizeof(n) = %d\n",sizeof(m),sizeof(n));
typedef pointer char*
pointer m,n;
printf("\nsizeof(m) = %d\t sizeof(n) = %d\n",sizeof(m),sizeof(n));
结构体初始化&赋值
1、初始化
- 凡是基本类型，既可以在定义的时候初始化，也可以先定义再赋值。
int a = 100;
int a; a = 100;- 凡是构造类型，可以在定义的时候初始化，也可以先定义再对每个成员进行赋值~ 绝不可以先定义再以初始化的方式赋值
//数组
int arr[10] = {1,2,3,4}; //定义的同时初始化
int arr[10];
arr[0] = 1; arr[2] = 2; //先定义 再对每个成员赋值
int arr[10];
arr[10] = {1,2,3,4}; //先定义再以初始化的形式赋值 不可以哦
//结构体也是如此
struct stu s = {"jiaomingxin",07,'f',100}; //定义+初始化
s.num = 10; //每个成员赋值
s.score = 100;
strcpy(s.name,"jiao"); //对于字符数组的赋值可以使用strcpy拷进去
手动 scanf 赋值
scanf("%s%d %c%f",s.name,&s.num,&s.sex,&s.score); （1）和 %c 打交道的时候 容易出错
在输入num %d的数值之后，空格或者换行都会占据 %c 的位置！使 %c 成功被忽略。在连续输入时，%c前边加一个空格解决此类问题。
（2）取地址符 &
结构体定义时，name为数组类型，num、sex、score都是基本类型。 取地址时，数组不用 &符号，其他得用。
结构体类型作参数和返回值
分两种：一种为结构体变量整个作参数并返回；一种是以结构体指针形式作参并返回。
1、结构体变量 作参数和返回值
结构体作参数或返回值，会发生同类型复制（本质是赋值）。同类型结构体间，是可以相互赋值的。
BUT 当结构体内的变量数目较大的时候，会进行大量的内存拷贝。可能会导致栈的进程空间不足而崩溃。
#include <stdio.h>
typedef struct _Mycomplex
{
float real;
float imag;
}Mycomplex;
Mycomplex ADDcomplex (Mycomplex pa,Mycomplex pb)
{
Mycomplex t;
t.real = pa.real + pb.real;
t.imag = pa.imag + pb.imag;
return t;
}
int main()
{
//结构体变量 作参数
Mycomplex s1,s2,res;
s1.real = 1;
s1.imag = 2;
s2.real = 3;
s2.imag = 4;
res = ADDcomplex(s1,s2);
printf("%.2f+%.2f",res.real,res.imag);
return 0;
}
2、结构体指针作参数 ——提升效率
传结构体的成本是很高的，用指针作参数有一个好处，就是避免了同类型复制，无论结构体多大，只传 4 个字节的指针。
（注意：结构体变量的 点成员运算符 和 地址的 指向成员运算符 的使用）
#include <stdio.h>
typedef struct _Mycomplex
{
float real;
float imag;
}Mycomplex;
Mycomplex ADDcomplex (Mycomplex *pa,Mycomplex *pb)
{
Mycomplex t;
t.real = pa->real + pb->real;
t.imag = pa->imag + pb->imag;
return t;
}
int main()
{
//传地址
Mycomplex s1 = {1,2},s2 = {3,4},res;
//s1.real = 6;
//s1.imag = 2;
//s2.real = 3;
//s2.imag = 4;
//要么在结构体初始化时赋值，要么对结构体成员单独赋值。不存在 s1 = {1,2};
res = ADDcomplex(&s1,&s2);
printf("%.2f+%.2f",res.real,res.imag);
return 0;
}
//传地址与返回地址
/*
Mycomplex * ADDcomplex (Mycomplex *pa,Mycomplex *pb)
{
Mycomplex *t;
t->real = pa->real + pb->real;
t->imag = pa->imag + pb->imag;
return t;
}
int main()
{
//传地址
Mycomplex s1 = {1,2},s2 = {3,4};
Mycomplex * res;
res = ADDcomplex(&s1,&s2);
printf("%.2f+%.2f",res->real,res->imag);
return 0;
}
*/
.结构体数组
结构体数组的本质还是一维数组，只不过一维数组的每一个成员又是结构体。
#include <stdio.h>
typedef struct stu
{
int num;
char name[20];
char sex;
float score;
}Stu;
int main()
{
//结构体数组
Stu s[] ={{101,"jiaomingxin",'m',100},{102,"jackma",'m',99},{103,"mars",'f',20}};
int n = sizeof(s)/sizeof(*s);
for(int i=0; i<n; i++)
{
printf("s[%d]num --> %d\n",i,s[i].num);
printf("s[%d]name --> %s\n",i,s[i].name);
printf("s[%d]sex --> %c\n",i,s[i].sex);
printf("s[%d]score --> %.1f\n",i,s[i].score);
puts("");
}
return 0;
}结构体 sizeof 大小 以及内存对齐
（1）什么是内存对齐 （见下图）
首成员在低地址，尾成员在高地址
（2）对齐规则
x86(linux 默认#pragma pack(4), window 默认#pragma pack(8))。linux 最大支持 4
字节对齐。
方法：
①取 pack(n)的值（n= 1 2 4 8--),取结构体中类型最大值 m。两者取小即为外对齐大
小 Y= (m<n?m:n)。
②将每一个结构体的成员大小与 Y 比较取小者为 X,作为内对齐大小.
③所谓按 X 对齐，即为地址(设起始地址为 0)能被 X 整除的地方开始存放数据。
④外部对齐原则是依据 Y 的值(Y 的最小整数倍)，进行补空操作。
#include <stdio.h>
#include <string.h>
#pragma pack(8)
typedef struct _staff
{
char sex;
int age;
short num;
}Staff;
#if 0
x86(linux 默认#pragma pack(4), window 默认#pragma pack(8))。linux 最大支持 4
字节对齐。
具体操作步骤：
①取 pack(n)的值（n= 1 2 4 8--),取结构体中类型最大值 m。两者取小即为外对齐大
小 Y= (m<n?m:n)。
②将每一个结构体的成员大小与 Y 比较取小者为 X,作为内对齐大小.
③所谓按 X 对齐，即为地址(设起始地址为 0)能被 X 整除的地方开始存放数据。
④外部对齐原则是依据 Y 的值(Y 的最小整数倍)，进行补空操作。
以此为例：
#pragma pack(8)
typedef struct _staff
{
char sex;
int age;
short num;
}Staff;
1、pack n = ? 结构体中类型最大的 m Y=min（m,n） 外对齐 n=8;m=4 --> Y=4
2、每个成员
char sex; 1 与Y相比取小值为X X = 1
int age; 4 4
short num; 2 2
存储位置
3、按X对齐 sex 0 - 1 （1字节） 往后找能被1整除的 那就1了
(设起始地址为 0) age 1 - 5 （4字节） 往后招能被4整除的 到了 8
num 8 - 10（2字节） OK存完了
4、外部对齐原则是依据 Y 的值(Y 的最小整数倍)，进行补空操作。 Y=4 4的最小整倍数，10不是，找到12
分析完毕！
#endif
int main()
{
Staff s;
printf("sizeof(Staff) = %d\n",sizeof (Staff));
printf("sizeof(s) = %d\n\n",sizeof (s));
printf("&(s) = %p\n",&s);
printf("&(sex) = %p\n",&s.sex);
printf("&(age) = %p\n",&s.age);
printf("&(num) = %p\n",&s.num);
return 0;
}
结构体使用注意事项
1、向未分配空间的结构体指针拷贝！
应用指针之前，一定要确保指针已有空间！否则没有指向合法的地址，考进去就是一堆乱码，并且后续也无法正常访问空间。
#include <stdio.h>
#include<string.h>
#include <stdlib.h>
typedef struct stu
{
char *name;
}Stu;
int main()
{
Stu s;
// strcpy(s.name,"mars");
// printf("s. name = %s\n",s.name); //错误1 向未分配空间的指针赋值
s.name = (char *)malloc(20);
strcpy(s.name,"mars");
printf("s. name = %s\n",s.name);
Stu *p;
p = (Stu *)malloc(sizeof(Stu *)); //为整个结构体指针分配空间
p->name = (char *)malloc(20); //还得为name指针分配空间
strcpy(p->name,"marsss");
printf("s. name = %s",p->name);
free(p->name); //先释放内层空间
free(p); //后释放外层的
return 0;
}
注意：
1）结构体中，包含指针，注意指针的赋值，切不可向未知区域拷贝
2）name 指针未初始化时，并没有指向一个合法的地址，这时候其内部存的只是一些乱码。所以在调用 strcpy 函数时，会将字符串 "mars" 往乱码所指的内存上拷贝,内存 name 指针根本就无权访问，导致出错
在所有涉及指针的时候，要么先定义的时候初始化，要么在使用之前进行malloc分配堆空间。
3）多层指针每个都要初始化。为指针变量 （Stu） p 分配了内存，但是同样没有给 name 指针分配内存。（p只是申请了name指针的指针类型的4个字节，与2）情况一样崩溃）错误与上面上一种情况一样，解决的办法也一样。这里用了一个 malloc 给人一种错觉，以为也给name 指针分配了内存。
4）记得：完了要释放结构体内指针所指向的空间，由内而外逐个释放。-->内存泄漏（先释放p，p.name就找不到了 也就无法释放，造成内存泄漏）
573
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
