结构体

结构体

一、什么是结构体

结构体指的是有一个结构，在这个结构中，可以存不同类型的变量，而且相互不影响，是一种自定义类型

C语言的结构体中，不能写函数

二、结构体的定义

struct  //结构体名
{
    //成员==>成员就是定义的变量
}；//以分号结尾
//C语言中的结构体，结构体必须要有至少一个成员
//定义结构体   由不同变量组合在一起的结构
struct Student
{
    char name[20];
    int id;
    char sex[3];
    char classnum[100];
};

1.结构体变量，访问里面的成员，通过 . 访问

初始化赋值及访问

#include <stdio.h>
#include<string.h>
struct Student
{
	char name[20];
	int id;
	char sex[3];
	char classnum[100];
};

int main()
{
	//定义结构体变量
	//struct Student stu1;
	//通过变量名.成员名
	//stu1.id = 1;
    
    //从键盘输入
    scanf（"%d",&(stu1.id));
    
	//strcpy(stu1.name, "苏宇");

	struct Student stu1 = {
		"苏宇",1,"男","2011期"
	};
	printf("%s	%d	%s	%s
", stu1.name, stu1.id, stu1.sex, stu1.classnum);
	getchar();
	getchar();
	return 0;
}

三、结构体数组

数组：类型 数组名[大小]

1.结构体数组：

struct student stu[5];

#include <stdio.h>
#include<string.h>
struct Student
{
	char name[20];
	int id;
	char sex[3];
	char classnum[100];
};

int main()
{
	struct Student stu1[5] = {
	{"苏宇",1,"男","2011"},
	{"小宇",2,"男","2012"},
	{"大宇",3,"男","2013"},
	{"老宇",4,"男","2014"},
	{"英语",5,"女","2015"}
	};
    
    //同等类型的结构体变量之间可以相互赋值
    stu1[1]=stu1[2];
    
	for (int i = 0; i < 5; i++)
	{
		printf("%s	%d	%s	%s
", 
			stu1[i].name, stu1[i].id, stu1[i].sex, stu1[i].classnum);
	}
	getchar();
	getchar();
	return 0;
}

2.计算结构体的内存

struct node
{
	int a;
	double b;
};
int main()
{
    printf("%d", sizeof(struct node));
    //内存占16个字节
    //这是自动补齐内存
    struct node n={1.23,99};
    printf("%lf	%d
",n.b,n.a);
    
    //用指针操作
    double* p=(double*)&n;//必须要强转成相同类型
    printf("%d
",*p);//只能打印1.23000002
    printf("%d
",*(int*)(p+1));//只能打印99
    
}
/*
如果是char[10]这样的数组，计算内存时
struct node 
{
	int a;
	char b[5];
	char c[6];
}
计算这个结构体的大小是：先找最大的int占4个字节，再去补后面的char
0000==>int      完整的   0000
0000 				   0000
0==>char[5] 		    0000
0000				   0000
00==>char[6]
所以一共是16个字节

四、结构体指针

1.如果直接用结构体指针指向成员，那么就是结构体指针->成员名

2.如果还是用.成员的方式，那么就先解引用结构体指针得到结构体变量，然后.成员

值传递，址传递

struct stu
{
	int id;
	char name[20];
};
void func1(struct stu n)//值传递
{
    n.id;
    n.name;
}
void func2(struct stu* p)//用指针进行地址传递
{
    p->id;
    p->name;
}
int main()
{
	struct stu n = { 1,"苏宇" };
	struct stu* p = &n;
	//访问可以使用 (*p).id
	printf("%d	%s
", p->id, p->name);
	printf("%d	%s
", (*p).id, (*p).name);
}

3.动态申请内存(堆区)

要包含头文件 #include<stdlib.h>

#include<stdio.h>
#include<stdlib.h>

struct stu
{   
    int id;  
 	char name[20];
};
int main()
{
    //节省内存
    struct stu* pn=(struct stu*)malloc(sizeof(struct stu));
    pn->id=123;
    //相当于是
    //（*pn).id=123;
    printf("%d
",pn->id);
    free(pn);
    pn=NULL;
    //使用完之后，释放内存，再置空
}

五、公用体 联合

union node 
{
    int num;
    float hight;
};
int main()
{
    union node n;
    n.num=123;
    printf("%d
",n.num);//输出123
    n.hight=175;
    printf("%d
",n.num);//输出的是一个乱码
    //因为公用体同一时间只能存放同一类型的值
}

都是用来优化程序的

六、枚举

穷举：把所有的东西一一列举出来

enum week//枚举是从0开始的，后面的值等于前面的值加一
{
    one,two,three,four,
    five,six,seven
};

enum dir
{
    hero=2;
    wall=1;
    box=3;
}
        

int main()
{
    enum week w;
    w=4;
    //one==0,two==1  .....
    switch (w)//输入w,双击后，按enter键
	{
	case one:
		break;
	case two:
		break;
	case three:
		break;
	case four:
		break;
	case five:
            printf("666
");
		break;
	case six:
		break;
	case seven:
		break;
	default:
		break;
	}

    
}

七、typedef

//typedef 真名  别名
struct node 
{
    int id;
    struct 
    {
        int asd;
        int a;
    }n1,n2,n3;//n1,n2,n3是这个结构体定义的变量
};
typedef struct node N;

int main()
{
    //访问
    N n;
    n.n1.a;
    n.id=123;
    printf("%d
",n.id);
}
//N就代替了struct node


//也可以

typedef struct node1
{
    int id;
}A;//A是别名

struct Student stu[20] = {

{"王飞",1,"女","2011期C语言"},

{"李飞",2,"男","2012期C++"},

{"张飞",3,"男","2013期数据结构"},

{"不飞",4,"女","2014期"} , {

"老飞",5,"男","不知道是那一期"},

}; 要实现的效果，将3删除掉

#include <stdio.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>
#define SIZE 10
#define size strcmp(a1,a2)
//可以运用到推箱子这样的程序，循环比较多的，方便改动

/*
	struct Student stu[20] = {
	{"王飞",1,"女","2011期C语言"},
	{"李飞",2,"男","2012期C++"},
	{"张飞",3,"男","2013期数据结构"},
	{"不飞",4,"女","2014期"} ,
	{"老飞",5,"男","不知道是那一期"},
	};
	要实现的效果，将3删除掉
*/
typedef struct Student
{
	char name[20];
	int id;
	char sex[3];
	char classnum[100];
}stu;

stu* pStu = NULL;//动态数组  结构体指针
int len = 0;//表示元素个数               //全局普通变量
int maxSize = 10;//动态数组当前最大容量

void init()//初始化数组，用来初始化数组
{
	pStu = (stu*)malloc(sizeof(stu)*maxSize);
	//申请到的内存空间，系统默认是void类型的字节，
	//需要void*去接收，不过这里是stu*类型的指针
	//sizeof不用pStu是因为他是指针类型只有四个字节
	
}

void initsert(stu* s)//把一个元素放入动态数组末尾
//stu* s=struct Student* s  一个叫s的结构体指针 
{
	if (len >= maxSize)
	//如果动态数组元素>动态数组最大容量，就需要扩容了
	{
		//申请一块新内存
		stu* temp = (stu*)malloc(sizeof(stu)*(maxSize * 2));
		memcpy(temp, pStu, sizeof(stu)*len);
		if (pStu != NULL)
		{
			free(pStu);
		}
		pStu = temp;
	}
	//pStu[len++] = *s;
	*(pStu + len) = *s;//赋值，一次只赋一个值
	len++;
}
void Print()//输出结构体
{
	for (int i = 0; i < len; i++)
	{
		printf("%s	%d	%s	%s
",
			pStu[i].name, pStu[i].id, pStu[i].sex, pStu[i].classnum
		);
	}
}

void delete_id(int id)//删除操作
{
	for (int i = 0; i < len; i++)
	{
		if (pStu[i].id == id)
		{
			for (int j = i; j < len; j++)
			{
				pStu[j] = pStu[j + 1];
			}
			len--;
		}
	}
}




int main()
{
	struct Student sten[20] = {
	{"王飞",1,"女","2011期C语言"},
	{"李飞",2,"男","2012期C++"},
	{"张飞",3,"男","2013期数据结构"},
	{"不飞",4,"女","2014期"} ,
	{"老飞",5,"男","不知道是那一期"},
	{"王飞",1,"女","2011期C语言"},
	{"李飞",2,"男","2012期C++"},
	{"张飞",3,"男","2013期数据结构"},
	{"不飞",4,"女","2014期"} ,
	{"老飞",5,"男","不知道是那一期"},
	{"王飞",1,"女","2011期C语言"},
	{"李飞",2,"男","2012期C++"},
	{"张飞",3,"男","2013期数据结构"},
	{"不飞",4,"女","2014期"} ,
	{"老飞",5,"男","不知道是那一期"},
	{"王飞",1,"女","2011期C语言"},
	{"李飞",2,"男","2012期C++"},
	{"张飞",3,"男","2013期数据结构"},
	{"不飞",4,"女","2014期"} ,
	{"老飞",5,"男","不知道是那一期"},
	};
	
	init();//初始化数组
	for (int i = 0; i < 20; i ++ )
	{
		//initsert(sten + i);//stu=s
		//struct Student* s=struct Student* (stu+i)
		initsert(&sten[i]);
		
		//因为initsert(形参），里面的形参是struct Student* s是指针类型
		//所以要取内容，才能得到值
		//相当于initsert(*sten)
		//将sten中的内容取出来
	}
	delete_id(3);
	delete_id(4);
	Print();
	free(pStu);
	pStu = NULL;
	getchar();
	getchar();
	return 0;
}