【C结构体】结构体都不会，学啥数据结构（进阶版）

                       智者不为情所困

用结构体描述一个复杂对象的基本信息：学生
struct Stu
{//Stu是结构体标签，struct Stu才是结构体类型,相当于int
	char name[20];名字
	int age;年龄
	char sex[2];性别
	char id[20];学号
};分号不能丢

正确的结构体自引用：结构体的
struct Stu1
{
	int a;
	char b;
	struct Stu1* c;结构体指针变量
};


错误的结构体自引用：
struct Stu2
{
	int a;
	char b;
	struct Stu2 c;结构体
};

单链表中结构体中包含结构体指针的使用：
typedef struct Node
{
	int date;
	struct Node* ps;但不能写成ListNode* ps
//因为这个typedef声明的类型名直到声明的末尾才被定义
}ListNode;

typedef类型重命名前定义结构体变量：
struct Node newnode;

typedef类型重命名后定义结构体变量：(是不是少些了个struct,适当偷懒)
ListNode newnode；

struct Stu
{
	char name[20];
	int age;
	char sex[2];
}student1={{宋小宝},18,男};

typedef struct date
{
	int year;
	int month;
	int day;
}Date;

struct Stu
{
	Date a;
	int number;
};

给你举个例子画个图吧
struct AKIGN
{
	char a;第一个数不用考虑内存对齐，直接放
	int b;第二个数放的位置（偏移量）要是int字节(4)的整数倍，也就是4
	char c;第三个数放的位置（偏移量）要是char字节（1）的整数倍,也就是9
};

// 练习2
struct S2
{
	char c1;   1
	char c2;   1-2
	int i;     4-8
};
printf("%d\n", sizeof(struct S2));//要是double（8）个字节的整数倍，答案：占8个字节
//练习3
struct S3
{
	double d;     1-8
	char c;       9
	int i;        12-16
};
printf("%d\n", sizeof(struct S3));//要是double（8）个字节的整数倍，答案：占16个字节
//练习4-结构体嵌套问题
//如果嵌套了结构体，嵌套的结构体对齐到自己的最大对齐数的整数倍中
struct S4
{
	char c1;           1
	struct S3 s3;      8-16
	double d;          16-24
};
printf("%d\n", sizeof(struct S4));//要是double（8）个字节的整数倍，答案：占24个字节

#include <stdio.h>
#pragma pack(4)//设置默认对齐数为4
struct S1
{
 char c1;
 double i;默认对齐数（4）和成员变量的字节数（8）比较取最小的为默认对齐数（4）：4个字节
 char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
#pragma pack(1)//设置默认对齐数为8
struct S2
{
 char c1;
 int i;
 char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
int main()
{
    //输出的结果是什么？
    printf("%d\n", sizeof(struct S1));答案是16个字节
    printf("%d\n", sizeof(struct S2));答案是6个字节
    return 0;
}

1.传结构体本身：
print_struct(struct Stu);

2.传结构体地址：
print_struct(&struct Stu);

struct S
{
 int data[1000];
 int num;
};
struct S s = {{1,2,3,4}, 1000};
//结构体传参
void print1(struct S s)
{
 printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps)
{
 printf("%d\n", ps->num);
}
int main()
{
 print1(s);  //传结构体
 print2(&s); //传地址
 return 0;
}

struct S
{
 char a : 3;
 char b : 4;
 char c : 5;
 char d : 4;
};
int main()
{

	struct S s = { 0 };
	s.a = 10;
	s.b = 12;
	s.c = 3;
	s.d = 4;

	printf("%d\n", sizeof(struct S));
}

#include<stdio.h>
union UN//如果省去UN就是匿名结构体类型，只能使用一次
{
	int a;
	char ch;
};
int main()
{
	//判断猜测：共用同一块内存
	union UN u;
	printf("%p\n", &(u.ch));//地址1
	printf("%p\n", &(u.a));//地址1
	printf("%d\n", sizeof(u));//4

	u.a = 1;
	printf("%d\n", u.a);//1
	//通过共用一块内存通过改变u.c就能改变u.a
	u.ch = 0;
	printf("%d\n", u.ch);//0

    //判断是大端还是小端
	printf("%d\n", u.ch);//0
	return 0;
}

union un
{
	int a;
	char c;
};

int test1()
{
	int n = 1;;
	return *(char*)&n;
}


int test2()
{
	union un u;
	u.a = 1;
	return u.c==1;
}

//这里都是使得int类型的变量赋值为1，也就是十六进制的都是00 00 00 01，然后通过让char或者联合本身的特点访问其中的低地址的内容，如果最低的字节内容是1，则是整数的最低字节的内容放在了低地址处，则是小端，反之。。

int main()
{
	int ret=test1();
	if (ret == 0) printf("大端\n");
	else if(ret==1) printf("小端\n");
}