【C语言】结构体详解

【C语言】结构体详解

---

---

前言

---

本篇文章会讲到结构体的基本使用，结构体的深浅拷贝，结构体嵌套一级指针练习，结构体嵌套二级指针练习，结构体偏移量，内存对齐的有关知识。

一、结构体的基本使用

代码中讲述了如何定义结构体，以及哟个typedef给结构体起别名，如何创建结构体，在堆区和栈上的不同创建形式，以及在栈上和堆区里分配内存。

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


//用typedef起别名
//struct Person
//{
//	char name[64];
//	int age;
//};
//typedef struct Person myPerson

typedef struct Person
{
	char name[64];
	int age;
}myPerson;



void test01()
{
	struct Person p = { "Tom",18 };
	myPerson p2 = { "Jerry",20 };
}


struct Person2
{
	char name[64];
	int age;
}myPerson2 = { "aaa",20 };

void test02()
{
	printf("姓名：%s 年龄：%d", myPerson2.name, myPerson2.age);  
}

//匿名结构体
struct
{
	char name[64];
	int age;
}myPerson3 = { "bbb",13 };

void test03()
{
	printf("姓名：%s 年龄：%d", myPerson3.name, myPerson3.age);
}


//结构体的创建
void test04()
{
	//创建在栈上
	struct Person p = { "aaa",10 };
	printf("姓名：%s 年龄：%d", p.name, p.age);

	//创建在堆区
	struct Person* p2 = malloc(sizeof(struct Person));
	strcpy(p2->name, "bbb");
	p2->age = 18;
	printf("姓名：%s 年龄：%d", p2->name, p2->age);

	if (p2!= NULL)
	{
		free(p2);
		p2 = NULL;
	}

}



void printArray(struct Person personArray[],int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("姓名：%s,年龄：%d\n", personArray[i].name, personArray[i].age);
	}
}
//结构体变量数组创建
void test05()
{
	//在栈上分配内存
	struct Person persons[] = {
		{"aaa",18},
		{"bbb",19},
		{"ccc",20},
		{"ddd",21},
	};
	int len = sizeof(persons) / sizeof(struct Person);
	//printArray(persons,len); 

	//在堆区分配内存
	struct Person* pArray = malloc(sizeof(struct Person) * 4);
	for (int i = 0; i < 4; i++)
	{
		sprintf(pArray[i].name, "name_%d", i + 1); 
		pArray[i].age = 18 + i;

	}
	printArray(pArray, 4);
	if (pArray != NULL);
	{
		free(pArray);
		pArray = NULL;
	}

}



int main()
{

	//test01();
	//test02();
	//test03();
	//test04();
	test05();
	return 0;
}

---

二、结构体的深浅拷贝

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

struct Person
{
	char name[64];
	int age;

};

void test1()
{
	struct Person p1 = { "Tom",18 };
	
	struct Person p2 = { "Jerry",20 };

	p1 = p2;//浅拷贝，按字节拷贝

	printf("p1的姓名： %s 年龄：%d\n", p1.name, p1.age);
	printf("p2的姓名： %s 年龄: %d\n", p2.name, p2.age);

}




struct Person2
{
	char* name;
	int age;
};

void test2()
{
	struct Person2 p1;
	p1.name = malloc(sizeof(char) * 64);
	strcpy(p1.name, "Tom");
	p1.age = 18;

	struct Person2 p2;
	p2.name = malloc(sizeof(char) * 128);
	strcpy(p2.name, "Jerry");
	p2.age = 20;

	//p1=p2;   //系统提供的复制操作是简单的浅拷贝，我们需要做手动复制，提供深拷贝
	
	/手动赋值/
	//先释放原来的堆区内容
	if (p1.name != NULL)
	{
		free(p1.name);
		p1.name = NULL;
	}
	//在堆区创建内存
	p1.name = malloc(strlen(p2.name) + 1);
	strcpy(p1.name, p2.name);
	p1.age = p2.age;

	/

	printf("p1的姓名：%s 年龄：%d\n", p1.name, p1.age);
	printf("p2的姓名：%s 年龄：%d\n", p2.name, p2.age);

	if (p1.name != NULL)
	{
		free(p1.name);
		p1.name = NULL;
	}
	if (p2.name != NULL)
	{
		free(p2.name);
		p2.name = NULL;
	}
}




int main()
{
	test1();
	test2();

	return 0;
}

---

三、结构体嵌套一级指针

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

struct Person
{
	char* name;
	int age;
};

struct Person** allocateSpace()
{
	struct Person** temp = malloc(sizeof(struct Person*) * 3);

	for (int i = 0; i < 3; i++)
	{
		//创建结构体内存
		temp[i] = malloc(sizeof(struct Person));

		//将结构体姓名 创建在堆区
		temp[i]->name = malloc(sizeof(char) * 64);

		//给姓名赋值
		sprintf(temp[i]->name, "name_%d", i + 1);

		temp[i]->age = 18 + i;
	}
	return temp;
}


void printPerson(struct Person** pArray, int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("姓名：%s,年龄：%d\n", pArray[i]->name, pArray[i]->age);

	}
}


void freeSpace(struct Person** pArray, int len)
{
	if (pArray == NULL)
	{
		return;
	}

	if (len <= 0)
	{
		return;
	}

	for (int i = 0; i < 3; i++)
	{
		if (pArray[i]->name != NULL)
		{
			printf("%s被释放了\n", pArray[i]->name);
			free(pArray[i]->name);
			pArray[i]->name = NULL;
		}
		free(pArray[i]);
		pArray[i] = NULL;
	}

}



void test07()
{
	struct Person** pArray = NULL;

	pArray = allocateSpace();

	//打印数组
	printPerson(pArray, 3);

	//释放内存
	freeSpace(pArray,3);
	pArray = NULL;

}
int main() {
	test07();


	system("pause");
	return EXIT_SUCCESS;
}

---

四、结构体嵌套二级指针

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

struct Teacher
{
	char* name;
	char** students;
};

void allocateSpace02(struct Teacher*** teachers)
{
	if (teachers == NULL)
	{
		return;
	}
	
	//开辟内存
	struct Teacher**ts=malloc(sizeof(struct Teacher*) * 3);
	
	//给每个老师分配内存
	for (int i = 0; i < 3; i++)
	{
		ts[i] = malloc(sizeof(struct Teacher));

		//给老师的姓名分配内存
		ts[i]->name = malloc(sizeof(char) * 64);

		//给老师起名字
		sprintf(ts[i]->name, "Teacher_ % d", i + 1);

		//给学生的数组分配内存
		ts[i]->students = malloc(sizeof(char*)*4);

		//给学生的姓名开辟内存 以及赋值
		for (int j = 0; j < 4; j++)
		{
			ts[i]->students[j] = malloc(sizeof(char) * 64);
			sprintf(ts[i]->students[j], "%s_Student_%d", ts[i]->name, j + 1);
		}
	}
	*teachers = ts;
}


void printTeachers(struct Teacher** pArray)
{
	if (pArray == NULL)
	{
		return;
	}
	for (int i = 0; i < 3; i++)
	{
		printf("%s\n", pArray[i]->name);
		for (int j = 0; j < 4; j++)
		{
			printf("            %s\n", pArray[i]->students[j]);
		}
	}
}


void freeSpace02(struct Teacher** pArray)
{
	if (pArray == NULL)
	{
		return;
	}

	for (int i = 0; i < 3; i++)
	{
		//先释放老师姓名
		if (pArray[i]->name != NULL)
		{
			free(pArray[i]->name);
			pArray[i]->name = NULL;
		}
		//释放学生姓名
		for (int j = 0; j < 4; j++)
		{
			if (pArray[i]->students[j] != NULL)
			{
				free(pArray[i]->students[j]);
				pArray[i]->students[j] = NULL;
			}
		}

		//释放学生数组
		if (pArray[i]->students != NULL)
		{
			free(pArray[i]->students);
			pArray[i]->students = NULL;
		}

		//释放老师
		if (pArray[i] != NULL)
		{
			free(pArray[i]);
			pArray[i] = NULL;
		}
	}
	//释放老师数组
	if (pArray != NULL)
	{
		free(pArray);
		pArray = NULL;
	}
}


void test08()
{
	struct Teacher** pArray = NULL;
	//开辟内存
	allocateSpace02(&pArray);

	//打印数组
	printTeachers(pArray);

	//释放数组
	freeSpace02(pArray);
	pArray = NULL;
}


int main()
{
	test08();
	return 0;
}

---

五、结构体的偏移量

#include <stddef.h>
offsetof(struct Teacher, b)

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include <stddef.h>

struct Teacher
{
	char a; //0 ~ 3
	int b;  //4 ~ 7
};


void test01()
{
	struct Teacher t1;
	struct Teacher* p = &t1;

	printf("b的属性偏移量为：%d\n", (int)&(p->b) - (int)p);

	printf("b的属性偏移量为：%d\n", offsetof(struct Teacher, b));
}



//通过偏移量 操作内存
void test02()
{
	struct Teacher t1 = { 'a', 10 };

	printf("t1.b = %d\n", *(int*)((char*)&t1 + offsetof(struct Teacher, b)));

	printf("t1.b = %d\n", *(int*)((int*)&t1 + 1));

}


struct Teacher2
{
	char a;
	int b;
	struct Teacher c;
};

void test03()
{
	struct Teacher2 t1 = { 'a', 10, 'b', 20 };

	int offset1 = offsetof(struct Teacher2, c);
	int offset2 = offsetof(struct Teacher, b);

	printf("%d\n", *(int*)((char*)&t1 + offset1 + offset2));


	printf("%d\n", ((struct Teacher*)((char*)&t1 + offset1))->b);

}


int main() {
	//test01();
	//test02();
	test03();
	system("pause");
	return EXIT_SUCCESS;
}

---

六、内存对齐

#pragma pack(show) //查看当前对齐模数 ，对齐模数是可以改的，改成2的N次方
内存对齐要求：
第一个属性开始 从0开始偏移
第二个属性开始 要放在 该类型的大小 与 对齐模数比 取小的值 的整数倍
所有属性都计算完后，再整体做二次偏移，将整体计算的结果 要放在 结构体最大类型 与对齐模数比 取小的值的 整数倍上

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>


#pragma pack(show) //查看当前对齐模数 ，对齐模数是可以改的，改成2的N次方


typedef struct _STUDENT {

	int a;    //0 ~ 3      
	char b;   //4 ~ 7      
	double c; //8 ~ 15     
	float d;  //16 ~ 19    
}Student;


void test09()
{
	printf("sizeof  student  = %zd\n", sizeof(Student));//24

}


//结构体嵌套结构体时候，子结构体放在该结构体中最大类型 和对齐模数比 的整数倍上即可
typedef struct _STUDENT2 {
	char a;  // 0 ~ 7
	Student b; // 8  ~ 31
	double c;  //32 ~ 39
}Student2;


void test10()
{
	printf("sizeof  student  = %d\n", sizeof(Student2));
}



int main() {
	test09();
	test10();

	system("pause");
	return EXIT_SUCCESS;
}

总结

到这里这篇文章的内容就结束了，谢谢大家的观看，如果有好的建议可以留言喔，谢谢大家啦！