结构体的定义与使用:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. struct Student
  5. {
  6. 	int num;
  7. 	char name[30];
  8. 	char age;
  9. };
  11. int main(int argc, char* argv[])
  12. {
  13. 	struct Student stu = { 1001, "lyshark", 22 };
  15. 	printf("普通引用: %d --> %s \n", stu.num, stu.name);
  17. 	struct Student *ptr;   // 定义结构指针
  18. 	ptr = &stu;            // 指针的赋值
  20. 	printf("指针引用: %d --> %s \n", ptr->num, ptr->name);
  22. 	system("pause");
  23. 	return 0;
  24. }

动态分配结构体成员:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int main(int argc, char* argv[])
  5. {
  6. 	struct Student
  7. 	{
  8. 		int num;
  9. 		char name[30];
  10. 		char age;
  11. 	};
  13. 	struct Student *stu = malloc(sizeof(struct Student));
  14. 	stu->num = 1001;
  15. 	stu->age = 24;
  16. 	strcpy(stu->name, "lyshark");
  17. 	printf("姓名: %s 年龄: %d \n", stu->name, stu->age);
  19. 	// ----------------------------------------------------------
  20. 	struct Person
  21. 	{
  22. 		char *name;
  23. 		int age;
  24. 	}person;
  26. 	struct Person *ptr = &person;
  28. 	ptr->name = (char *)malloc(sizeof(char)* 20);
  29. 	strcpy(ptr->name, "lyshark");
  30. 	ptr->age = 23;
  32. 	printf("姓名: %s 年龄: %d \n", ptr->name, ptr->age);
  33. 	free(ptr->name);
  35. 	system("pause");
  36. 	return 0;
  37. }

结构体变量数组:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef struct Person
  5. {
  6. 	int uid;
  7. 	char name[64];
  8. }Person;
  10. void Print(struct Person *p,int len)
  11. {
  12. 	for (int x = 0; x < len; x++)
  13. 	{
  14. 		printf("%d \n", p[x].uid);
  15. 	}
  16. }
  18. int main(int argc, char* argv[])
  19. {
  20. 	// 栈上分配结构体(聚合初始化)
  21. 	struct Person p1[] = {
  22. 		{ 1, "aaa" },
  23. 		{ 2, "bbb" },
  24. 		{ 3, "ccc" },
  25. 	};
  27. 	int len = sizeof(p1) / sizeof(struct Person);
  28. 	Print(p1, len);
  30. 	// 在堆上分配
  31. 	struct Person *p2 = malloc(sizeof(struct Person) * 5);
  33. 	for (int x = 0; x < 5; x++)
  34. 	{
  35. 		p2[x].uid = x;
  36. 		strcpy(p2[x].name, "aaa");
  37. 	}
  38. 	Print(p2, 5);
  40. 	system("pause");
  41. 	return 0;
  42. }

结构体深浅拷贝

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef struct Person
  5. {
  6. 	int uid;
  7. 	char *name;
  8. }Person;
  10. int main(int argc, char* argv[])
  11. {
  13. 	struct Person p1,p2;
  15. 	p1.name = malloc(sizeof(char)* 64);
  16. 	strcpy(p1.name, "admin");
  17. 	p1.uid = 1;
  19. 	p2.name = malloc(sizeof(char)* 64);
  20. 	strcpy(p2.name, "guest");
  21. 	p2.uid = 2;
  23. 	// p2 = p1;  浅拷贝
  25. 	// 深拷贝
  27. 	if (p1.name != NULL)
  28. 	{
  29. 		free(p1.name);
  30. 		p1.name == NULL;
  31. 	}
  33. 	p1.name = malloc(strlen(p2.name) + 1);
  34. 	strcpy(p2.name, p1.name);
  35. 	p2.uid = p1.uid;
  37. 	printf("p2 -> %s \n", p2.name);
  39. 	system("pause");
  40. 	return 0;
  41. }

结构体字段排序: 首先对比结构中的UID,通过冒泡排序将UID从小到大排列,也可以通过Name字段进行排序.

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. struct Student
  5. {
  6. 	int uid;
  7. 	char name[32];
  8. 	double score;
  9. };
  11. int StructSort(struct Student *stu,int len)
  12. {
  13. 	for (int x = 0; x < len - 1; x++)
  14. 	{
  15. 		for (int y = 0; y < len - x - 1; y++)
  16. 		{
  17. 			// if (strcmp(stu[y].name, stu[y + 1].name) > 0)
  18. 			if (stu[y].uid > stu[y + 1].uid)
  19. 			{
  20. 				// 结构体变量互换,将用户UID从小到大排列
  21. 				struct Student tmp = stu[y];
  22. 				stu[y] = stu[y + 1];
  23. 				stu[y+1] = tmp;
  24. 			}
  25. 		}
  26. 	}
  27. 	return 0;
  28. }
  30. void MyPrint(struct Student *stu,int len)
  31. {
  32. 	for (int x = 0; x < len; x++)
  33. 		printf("Uid: %d  Name: %s  Score: %.1f \n", stu[x].uid,stu[x].name,stu[x].score);
  34. }
  36. int main(int argc, char* argv[])
  37. {
  38. 	struct Student stu[3] = {
  39. 		{8,"admin",79.5},
  40. 		{5,"guest",89.5},
  41. 		{1,"root",99},
  42. 	};
  44. 	StructSort(stu, 3);    // 调用排序
  45. 	MyPrint(stu, 3);       // 输出结果
  47. 	system("pause");
  48. 	return 0;
  49. }

结构体数据之间的交换:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. struct Student
  6. {
  7. 	char *name;
  8. 	int score[3];
  9. };
  11. int StructExchange(struct Student *stu, int len, char *str1,char *str2)
  12. {
  13. 	struct Student *ptr1;
  14. 	struct Student *ptr2;
  16. 	// 找到两个名字所对应的成绩
  17. 	for (int x = 0; x < len; ++x)
  18. 	{
  19. 		if (!strcmp(stu[x].name, str1))
  20. 			ptr1 = &stu[x];
  21. 		if (!strcmp(stu[x].name, str2))
  22. 			ptr2 = &stu[x];
  23. 	}
  25. 	// 开始交换两个人的成绩
  26. 	for (int y = 0; y < 3; y++)
  27. 	{
  28. 		int tmp = ptr1->score[y];
  29. 		ptr1->score[y] = ptr2->score[y];
  30. 		ptr2->score[y] = tmp;
  31. 	}
  32. 	return 0;
  33. }
  35. void MyPrint(struct Student *stu,int len)
  36. {
  37. 	for (int x = 0; x < len; x++)
  38. 	{
  39. 		printf("Name: %s --> score: %d %d %d \n", stu[x].name, stu[x].score[0], stu[x].score[1], stu[x].score[2]);
  40. 	}
  41. }
  43. int main(int argc, char* argv[])
  44. {
  45. 	struct Student stu[3];
  47. 	// 动态开辟空间,并动态输入姓名与成绩
  48. 	// admin 1 1 1 / guest 2 2 2 / root 3 3 3
  49. 	for (int x = 0; x < 3; x++)
  50. 	{
  51. 		stu[x].name = (char *)malloc(sizeof(char) * 64);    // 开辟空间
  52. 		scanf("%s%d%d%d", stu[x].name, &stu[x].score[0], &stu[x].score[1], &stu[x].score[2]);
  53. 	}
  55. 	MyPrint(&stu, 3);
  56. 	// 开始交换两个人名的成绩
  57. 	StructExchange(&stu, 3, "root", "admin");
  58. 	printf("----------------------------\n");
  60. 	MyPrint(&stu, 3);
  62. 	// 动态内存的释放
  63. 	for (int y = 0; y < 3; y++)
  64. 		free(stu[y].name);
  66. 	system("pause");
  67. 	return 0;
  68. }

结构体偏移量计算:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stddef.h>
  5. int main(int argc, char* argv[])
  6. {
  8. 	struct Student
  9. 	{
  10. 		int uid;
  11. 		char *name;
  12. 	};
  14. 	struct Student stu = { 1, "lyshark" };
  15. 	int offset = (int *)( (char *)&stu + offsetof(struct Student, name) );
  16. 	printf("指针首地址: %x \n", offset);
  18. 	// =================================================================
  19. 	// 第二种嵌套结构体取地址
  21. 	struct SuperClass
  22. 	{
  23. 		int uid;
  24. 		char *name;
  25. 		struct stu
  26. 		{
  27. 			int sid;
  28. 			char *s_name;
  29. 		}stu;
  30. 	};
  32. 	struct SuperClass super = { 1001, "lyshark" ,1,"xiaowang"};
  34. 	int offset1 = offsetof(struct SuperClass, stu);
  35. 	int offset2 = offsetof(struct stu, sid);
  37. 	// SuperClass + stu 找到 sid 首地址
  38. 	int struct_offset = ((char *)&super + offset1) + offset2;
  39. 	printf("sid首地址: %x --> %x \n", struct_offset, &super.stu.sid);
  41. 	int stu_sid = *(int *) ((char *)&super + offset1) + offset2;
  42. 	printf("sid里面的数值是: %d \n", stu_sid);
  44. 	int stu_sid_struct = ((struct stu *)((char *)&super + offset1))->sid;
  45. 	printf("sid里面的数值是: %d \n", stu_sid_struct);
  47. 	system("pause");
  48. 	return 0;
  49. }

结构体嵌套一级指针

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef struct Person
  5. {
  6. 	int id;
  7. 	char *name;
  8. 	int age;
  9. }Person;
  11. // 分配内存空间,每一个二级指针中存放一个一级指针
  12. struct Person ** allocateSpace()
  13. {
  14. 	// 分配3个一级指针,每一个指针指向一个结构首地址
  15. 	struct Person **tmp = malloc(sizeof(struct Person *) * 3);
  16. 	for (int x = 0; x < 3; x++)
  17. 	{
  18. 		tmp[x] = malloc(sizeof(struct Person));    // (真正的)分配一个存储空间
  19. 		tmp[x]->name = malloc(sizeof(char) * 64);  // 分配存储name的空间
  20. 		sprintf(tmp[x]->name, "name_%d", x);
  21. 		tmp[x]->id = x;
  22. 		tmp[x]->age = x + 10;
  23. 	}
  24. 	return tmp;
  25. }
  27. // 循环输出数据
  28. void MyPrint(struct Person **person)
  29. {
  30. 	for (int x = 0; x < 3; x++)
  31. 	{
  32. 		printf("Name: %s \n", person[x]->name);
  33. 	}
  34. }
  36. // 释放内存空间,从后向前,从小到大释放
  37. void freeSpace(struct Person **person)
  38. {
  39. 	if (person != NULL)
  40. 	{
  41. 		for (int x = 0; x < 3; x++)
  42. 		{
  43. 			if (person[x]->name != NULL)
  44. 			{
  45. 				printf("%s 内存被释放 \n",person[x]->name);
  46. 				free(person[x]->name);
  47. 				person[x]->name = NULL;
  48. 			}
  50. 			free(person[x]);
  51. 			person[x] = NULL;
  52. 		}
  53. 		free(person);
  54. 		person = NULL;
  55. 	}
  56. }
  58. int main(int argc, char* argv[])
  59. {
  60. 	struct Person **person = NULL;
  62. 	person = allocateSpace();
  63. 	MyPrint(person);
  64. 	freeSpace(person);
  66. 	system("pause");
  67. 	return 0;
  68. }

结构体嵌套二级指针

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. struct Student
  5. {
  6. 	char * name;
  7. }Student;
  9. struct Teacher
  10. {
  11. 	char *name;
  12. 	char **student;
  13. }Teacher;
  15. void allocateSpace(struct Teacher ***ptr)
  16. {
  17. 	// 首先分配三个二级指针,分别指向三个老师的结构首地址
  18. 	struct Teacher **teacher_ptr = malloc(sizeof(struct Teacher *) * 3);
  20. 	for (int x = 0; x < 3; x++)
  21. 	{
  22. 		// 先来分配老师姓名存储字符串,然后赋初值
  23. 		teacher_ptr[x] = malloc(sizeof(struct Teacher));  // 给teacher_ptr整体分配空间
  24. 		teacher_ptr[x]->name = malloc(sizeof(char)* 64);  // 给teacher_ptr里面的name分配空间
  25. 		sprintf(teacher_ptr[x]->name, "teacher_%d", x);   // 分配好空间之后,将数据拷贝到name里面
  27. // -------------------------------------------------------------------------------------
  28. 		// 接着分配该老师管理的学生数据,默认管理四个学生
  29. 		teacher_ptr[x]->student = malloc(sizeof(char *) * 4);   // 给teacher_ptr 里面的student分配空间
  30. 		for (int y = 0; y < 4; y++)
  31. 		{
  32. 			teacher_ptr[x]->student[y] = malloc(sizeof(char) * 64);
  33. 			sprintf(teacher_ptr[x]->student[y], "%s_stu_%d", teacher_ptr[x]->name, y);
  34. 		}
  35. 	}
  36. 	// 最后将结果抛出去
  37. 	*ptr = teacher_ptr;
  38. }
  40. // 输出老师和学生数据
  41. void MyPrint(struct Teacher **ptr)
  42. {
  43. 	for (int x = 0; x < 3; x++)
  44. 	{
  45. 		printf("老师姓名: %s \n", ptr[x]->name);
  46. 		for (int y = 0; y < 4; y++)
  47. 		{
  48. 			printf("--> 学生: %s \n", ptr[x]->student[y]);
  49. 		}
  50. 	}
  51. }
  53. // 最后释放内存
  54. void freeSpace(struct Teacher **ptr)
  55. {
  56. 	for (int x = 0; x < 3; x++)
  57. 	{
  58. 		if (ptr[x]->name != NULL)
  59. 		{
  60. 			free(ptr[x]->name);
  61. 			ptr[x]->name = NULL;
  62. 		}
  64. 		for (int y = 0; y < 4; y++)
  65. 		{
  66. 			if (ptr[x]->student[y] != NULL)
  67. 			{
  68. 				free(ptr[x]->student[y]);
  69. 				ptr[x]->student[y] = NULL;
  70. 			}
  71. 		}
  72. 		free(ptr[x]->student);
  73. 		ptr[x]->student = NULL;
  74. 	}
  75. }
  77. int main(int argc, char* argv[])
  78. {
  79. 	struct Teacher **teacher_ptr = NULL;
  81. 	allocateSpace(&teacher_ptr);
  82. 	MyPrint(teacher_ptr);
  83. 	freeSpace(teacher_ptr);
  85. 	system("pause");
  86. 	return 0;
  87. }

结构体内嵌共用体:

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  5. struct Person
  6. {
  7. 	int uid;             // 编号
  8. 	char name[20];       // 姓名
  9. 	char jobs;           // 老师=t 或 学生 = s
  10. 	union
  11. 	{
  12. 		char stu_class[32];   // 学生所在班级
  13. 		char tea_class[32];   // 老师的所教课程
  14. 	}category;
  15. };
  17. int main(int argc, char* argv[])
  18. {
  19. 	struct Person person[3];
  21. 	for (int x = 0; x < 3; x++)
  22. 	{
  23. 		// 首先输入前三项,因为这三个数据是通用的,老师学生都存在的属性
  24. 		printf("输入: ID 姓名 工作类型(s/t) \n");
  25. 		scanf("%d %s %c", &person[x].uid, &person[x].name, &person[x].jobs);
  27. 		if (person[x].jobs == 's')                     // 如果是学生,输入stu_class
  28. 			scanf("%s", person[x].category.stu_class);
  29. 		if (person[x].jobs == 't')                     // 如果是老师,输入tea_class
  30. 			scanf("%s", person[x].category.tea_class);
  31. 	}
  33. 	printf("--------------------------------------------------------------\n");
  35. 	for (int y = 0; y < 3; y++)
  36. 	{
  37. 		if (person[y].jobs == 's')
  38. 			printf("老师: %s 职务: %s \n", person[y].name, person[y].category.tea_class);
  39. 		if (person[y].jobs == 't')
  40. 			printf("学生: %s 班级: %s \n", person[y].name, person[y].category.stu_class);
  41. 	}
  42. 	system("pause");
  43. 	return 0;
  44. }

结构体与链表

结构体基本定义：

  1. #include <stdio.h>
  3. typedef struct Person
  4. {
  5. 	int uid;
  6. 	char name[64];
  7. }Person;
  9. int main(int argc, char* argv[])
  10. {
  11. 	// 在栈上分配空间
  12. 	struct Person s1 = { 100, "admin" };
  13. 	printf("%s \n", s1.name);
  15. 	// 在堆上分配空间
  16. 	struct Person *s2 = malloc(sizeof(struct Person));
  17. 	strcpy(s2->name, "lyshark");
  18. 	printf("%s \n", s2->name);
  20. 	system("pause");
  21. 	return 0;
  22. }

结构体变量数组:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef struct Person
  5. {
  6. 	int uid;
  7. 	char name[64];
  8. }Person;
  10. void Print(struct Person *p,int len)
  11. {
  12. 	for (int x = 0; x < len; x++)
  13. 	{
  14. 		printf("%d \n", p[x].uid);
  15. 	}
  16. }
  18. int main(int argc, char* argv[])
  19. {
  20. 	// 栈上分配结构体(聚合初始化)
  21. 	struct Person p1[] = {
  22. 		{ 1, "aaa" },
  23. 		{ 2, "bbb" },
  24. 		{ 3, "ccc" },
  25. 	};
  27. 	int len = sizeof(p1) / sizeof(struct Person);
  28. 	Print(p1, len);
  30. 	// 在堆上分配
  31. 	struct Person *p2 = malloc(sizeof(struct Person) * 5);
  33. 	for (int x = 0; x < 5; x++)
  34. 	{
  35. 		p2[x].uid = x;
  36. 		strcpy(p2[x].name, "aaa");
  37. 	}
  38. 	Print(p2, 5);
  40. 	system("pause");
  41. 	return 0;
  42. }

结构体深浅拷贝

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef struct Person
  5. {
  6. 	int uid;
  7. 	char *name;
  8. }Person;
  10. int main(int argc, char* argv[])
  11. {
  13. 	struct Person p1,p2;
  15. 	p1.name = malloc(sizeof(char)* 64);
  16. 	strcpy(p1.name, "admin");
  17. 	p1.uid = 1;
  19. 	p2.name = malloc(sizeof(char)* 64);
  20. 	strcpy(p2.name, "guest");
  21. 	p2.uid = 2;
  23. 	// p2 = p1;  浅拷贝
  25. 	// 深拷贝
  27. 	if (p1.name != NULL)
  28. 	{
  29. 		free(p1.name);
  30. 		p1.name == NULL;
  31. 	}
  33. 	p1.name = malloc(strlen(p2.name) + 1);
  34. 	strcpy(p2.name, p1.name);
  35. 	p2.uid = p1.uid;
  37. 	printf("p2 -> %s \n", p2.name);
  39. 	system("pause");
  40. 	return 0;
  41. }

结构体嵌套一级指针

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef struct Person
  5. {
  6. 	int id;
  7. 	char *name;
  8. 	int age;
  9. }Person;
  11. // 分配内存空间,每一个二级指针中存放一个一级指针
  12. struct Person ** allocateSpace()
  13. {
  14. 	// 分配3个一级指针,每一个指针指向一个结构首地址
  15. 	struct Person **tmp = malloc(sizeof(struct Person *) * 3);
  16. 	for (int x = 0; x < 3; x++)
  17. 	{
  18. 		tmp[x] = malloc(sizeof(struct Person));    // (真正的)分配一个存储空间
  19. 		tmp[x]->name = malloc(sizeof(char) * 64);  // 分配存储name的空间
  20. 		sprintf(tmp[x]->name, "name_%d", x);
  21. 		tmp[x]->id = x;
  22. 		tmp[x]->age = x + 10;
  23. 	}
  24. 	return tmp;
  25. }
  27. // 循环输出数据
  28. void MyPrint(struct Person **person)
  29. {
  30. 	for (int x = 0; x < 3; x++)
  31. 	{
  32. 		printf("Name: %s \n", person[x]->name);
  33. 	}
  34. }
  36. // 释放内存空间,从后向前,从小到大释放
  37. void freeSpace(struct Person **person)
  38. {
  39. 	if (person != NULL)
  40. 	{
  41. 		for (int x = 0; x < 3; x++)
  42. 		{
  43. 			if (person[x]->name != NULL)
  44. 			{
  45. 				printf("%s 内存被释放 \n",person[x]->name);
  46. 				free(person[x]->name);
  47. 				person[x]->name = NULL;
  48. 			}
  50. 			free(person[x]);
  51. 			person[x] = NULL;
  52. 		}
  53. 		free(person);
  54. 		person = NULL;
  55. 	}
  56. }
  58. int main(int argc, char* argv[])
  59. {
  60. 	struct Person **person = NULL;
  62. 	person = allocateSpace();
  63. 	MyPrint(person);
  64. 	freeSpace(person);
  66. 	system("pause");
  67. 	return 0;
  68. }

结构体嵌套二级指针

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. struct Student
  5. {
  6. 	char * name;
  7. }Student;
  9. struct Teacher
  10. {
  11. 	char *name;
  12. 	char **student;
  13. }Teacher;
  15. void allocateSpace(struct Teacher ***ptr)
  16. {
  17. 	// 首先分配三个二级指针,分别指向三个老师的结构首地址
  18. 	struct Teacher **teacher_ptr = malloc(sizeof(struct Teacher *) * 3);
  20. 	for (int x = 0; x < 3; x++)
  21. 	{
  22. 		// 先来分配老师姓名存储字符串,然后赋初值
  23. 		teacher_ptr[x] = malloc(sizeof(struct Teacher));  // 给teacher_ptr整体分配空间
  24. 		teacher_ptr[x]->name = malloc(sizeof(char)* 64);  // 给teacher_ptr里面的name分配空间
  25. 		sprintf(teacher_ptr[x]->name, "teacher_%d", x);   // 分配好空间之后,将数据拷贝到name里面
  27. // -------------------------------------------------------------------------------------
  28. 		// 接着分配该老师管理的学生数据,默认管理四个学生
  29. 		teacher_ptr[x]->student = malloc(sizeof(char *) * 4);   // 给teacher_ptr 里面的student分配空间
  30. 		for (int y = 0; y < 4; y++)
  31. 		{
  32. 			teacher_ptr[x]->student[y] = malloc(sizeof(char) * 64);
  33. 			sprintf(teacher_ptr[x]->student[y], "%s_stu_%d", teacher_ptr[x]->name, y);
  34. 		}
  35. 	}
  36. 	// 最后将结果抛出去
  37. 	*ptr = teacher_ptr;
  38. }
  40. // 输出老师和学生数据
  41. void MyPrint(struct Teacher **ptr)
  42. {
  43. 	for (int x = 0; x < 3; x++)
  44. 	{
  45. 		printf("老师姓名: %s \n", ptr[x]->name);
  46. 		for (int y = 0; y < 4; y++)
  47. 		{
  48. 			printf("--> 学生: %s \n", ptr[x]->student[y]);
  49. 		}
  50. 	}
  51. }
  53. // 最后释放内存
  54. void freeSpace(struct Teacher **ptr)
  55. {
  56. 	for (int x = 0; x < 3; x++)
  57. 	{
  58. 		if (ptr[x]->name != NULL)
  59. 		{
  60. 			free(ptr[x]->name);
  61. 			ptr[x]->name = NULL;
  62. 		}
  64. 		for (int y = 0; y < 4; y++)
  65. 		{
  66. 			if (ptr[x]->student[y] != NULL)
  67. 			{
  68. 				free(ptr[x]->student[y]);
  69. 				ptr[x]->student[y] = NULL;
  70. 			}
  71. 		}
  72. 		free(ptr[x]->student);
  73. 		ptr[x]->student = NULL;
  74. 	}
  75. }
  77. int main(int argc, char* argv[])
  78. {
  79. 	struct Teacher **teacher_ptr = NULL;
  81. 	allocateSpace(&teacher_ptr);
  82. 	MyPrint(teacher_ptr);
  83. 	freeSpace(teacher_ptr);
  85. 	system("pause");
  86. 	return 0;
  87. }

静态链表 理解一下

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. // 定义链表节点类型
  5. struct LinkNode
  6. {
  7. 	int data;
  8. 	struct LinkNode *next;
  9. };
  11. int main(int argc, char* argv[])
  12. {
  13. 	struct LinkNode node1 = { 10, NULL };
  14. 	struct LinkNode node2 = { 20, NULL };
  15. 	struct LinkNode node3 = { 30, NULL };
  16. 	struct LinkNode node4 = { 40, NULL };
  18. 	node1.next = &node2;
  19. 	node2.next = &node3;
  20. 	node3.next = &node4;
  21. 	node4.next = NULL;
  23. 	// 遍历链表结构
  25. 	struct LinkNode *ptr = &node1;
  27. 	while (ptr != NULL)
  28. 	{
  29. 		printf("%d \n", ptr->data);
  30. 		ptr = ptr->next;
  31. 	}
  33. 	system("pause");
  34. 	return 0;
  35. }

动态链表

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. // 定义链表节点类型
  5. struct LinkNode
  6. {
  7. 	int data;
  8. 	struct LinkNode *next;
  9. };
  11. struct LinkNode *init_link()
  12. {  // 创建一个头结点,头结点不需要添加任何数据
  13. 	struct LinkNode *header = malloc(sizeof(struct LinkNode));
  14. 	header->data = 0;
  15. 	header->next = NULL;
  17. 	struct LinkNode *p_end = header;    // 创建一个尾指针
  19. 	int val = -1;
  20. 	while (1)
  21. 	{
  22. 		scanf("%d", &val);  // 输入插入的数据
  23. 		if (val == -1)      // 如果输入-1说明输入结束了
  24. 			break;
  26. 		// 先创建新节点
  27. 		struct LinkNode *newnode = malloc(sizeof(struct LinkNode));
  28. 		newnode->data = val;
  29. 		newnode->next = NULL;
  31. 		// 将节点插入到链表中
  32. 		p_end->next = newnode;
  33. 		// 更新尾部指针指向
  34. 		p_end = newnode;
  35. 	}
  36. 	return header;
  37. }
  39. // 遍历链表
  40. int foreach_link(struct LinkNode *header)
  41. {
  42. 	if (NULL == header || header->next == NULL)
  43. 		return 0;
  45. 	while (header->next != NULL)
  46. 	{
  47. 		printf("%d \n", header->data);
  48. 		header = header->next;
  49. 	}
  50. 	return 1;
  51. }
  53. // 在header节点中oldval插入数据
  54. void insert_link(struct LinkNode *header,int oldval,int newval)
  55. {
  56. 	struct LinkNode *pPrev = header;
  57. 	struct LinkNode *Current = pPrev->next;
  59. 	if (NULL == header)
  60. 		return;
  62. 	while (Current != NULL)
  63. 	{
  64. 		if (Current->data == oldval)
  65. 			break;
  67. 		pPrev = Current;
  68. 		Current = Current->next;
  69. 	}
  70. 	// 如果值不存在则默认插入到尾部
  71. 	//if (Current == NULL)
  72. 	//	return;
  74. 	// 创建新节点
  76. 	struct LinkNode *newnode = malloc(sizeof(struct LinkNode));
  77. 	newnode->data = newval;
  78. 	newnode->next = NULL;
  80. 	// 新节点插入到链表中
  81. 	newnode->next = Current;
  82. 	pPrev->next = newnode;
  83. }
  85. // 清空链表
  86. void clear_link(struct LinkNode *header)
  87. {
  88. 	// 辅助指针
  89. 	struct LinkNode *Current = header->next;
  91. 	while (Current != NULL)
  92. 	{
  93. 		// 保存下一个节点地址
  94. 		struct LinkNode *pNext = Current->next;
  95. 		printf("清空数据: %d \n", Current->data);
  96. 		free(Current);
  97. 		Current = pNext;
  98. 	}
  99. 	header->next = NULL;
  100. }
  102. // 删除值为val的节点
  103. int remove_link(struct LinkNode *header, int delValue)
  104. {
  105. 	if (NULL == header)
  106. 		return;
  108. 	// 设置两个指针,指向头结点和尾结点
  109. 	struct LinkNode *pPrev = header;
  110. 	struct LinkNode *Current = pPrev->next;
  112. 	while (Current != NULL)
  113. 	{
  114. 		if (Current->data == delValue)
  115. 		{
  116. 			// 删除节点的过程
  117. 			pPrev->next = Current->next;
  118. 			free(Current);
  119. 			Current = NULL;
  120. 		}
  121. 	}
  123. 	// 移动两个辅助指针
  124. 	pPrev = Current;
  125. 	Current = Current->next;
  127. }
  129. // 销毁链表
  130. void destroy_link(struct LinkNode *header)
  131. {
  132. 	if (NULL == header)
  133. 		return;
  135. 	struct LinkNode *Curent = header;
  136. 	while (Curent != NULL)
  137. 	{
  138. 		// 先来保存一下下一个节点地址
  139. 		struct LinkNode *pNext = Curent->next;
  141. 		free(Curent);
  143. 		// 指针向后移动
  144. 		Curent = pNext;
  145. 	}
  146. }
  148. // 反响排序
  149. void reverse_link(struct LinkNode *header)
  150. {
  151. 	if (NULL == header)
  152. 		return;
  154. 	struct LinkNode *pPrev = NULL;
  155. 	struct LinkNode *Current = header->next;
  156. 	struct LinkNode * pNext = NULL;
  158. 	while (Current != NULL)
  159. 	{
  160. 		pNext = Current->next;
  161. 		Current->next = pPrev;
  163. 		pPrev = Current;
  164. 		Current = pNext;
  165. 	}
  166. 	header->next = pPrev;
  167. }
  169. int main(int argc, char* argv[])
  170. {
  171. 	struct LinkNode * header = init_link();
  173. 	reverse_link(header);
  174. 	foreach_link(header);
  176. 	clear_link(header);
  177. 	system("pause");
  178. 	return 0;
  179. }

C/C++ 结构体与指针笔记的更多相关文章

  1. 【学习笔记】【C语言】指向结构体的指针

    1.指向结构体的指针的定义 struct Student *p;  2.利用指针访问结构体的成员 1> (*p).成员名称 2> p->成员名称 3.代码 #include < ...

  2. c语言中较常见的由内存分配引起的错误_内存越界_内存未初始化_内存太小_结构体隐含指针

    1.指针没有指向一块合法的内存 定义了指针变量,但是没有为指针分配内存,即指针没有指向一块合法的内浅显的例子就不举了,这里举几个比较隐蔽的例子. 1.1结构体成员指针未初始化 struct stude ...

  3. C#将结构体和指针互转的方法

    . 功能及位置 将数据从托管对象封送到非托管内存块,属于.NET Framework 类库 命名空间:System.Runtime.InteropServices 程序集:mscorlib(在 msc ...

  4. C语言结构体和指针

    指针也可以指向一个结构体,定义的形式一般为: struct 结构体名 *变量名; 下面是一个定义结构体指针的实例: struct stu{ char *name; //姓名 int num; //学号 ...

  5. 37深入理解C指针之---结构体与指针

    一.结构体与指针 1.结构体的高级初始化.结构体的销毁.结构体池的应用 2.特征: 1).为了避免含有指针成员的结构体指针的初始化复杂操作,将所有初始化动作使用函数封装: 2).封装函数主要实现内存的 ...

  6. 深入了解Windows句柄到底是什么（句柄是逻辑指针，或者是指向结构体的指针，图文并茂，非常清楚）good

    总是有新入门的Windows程序员问我Windows的句柄到底是什么,我说你把它看做一种类似指针的标识就行了,但是显然这一答案不能让他们满意,然后我说去问问度娘吧,他们说不行网上的说法太多还难以理解. ...

  7. 01.C语言关于结构体的学习笔记

    我对于学习的C语言的结构体做一个小的学习总结,总结如下: 结构体:structure 结构体是一种用户自己建立的数据类型,由不同类型数据组成的组合型的数据结构.在其他高级语言中称为记录(record) ...

  8. 关于C语言结构体，指针，声明的详细讲解。——Arvin

    关于结构体的详细分析 只定义结构体 struct Student { int age; char* name; char sex;//结构体成员 };//(不要忘记分号) Student是结构体的名字 ...

  9. c语言结构体&常指针和常量指针的区别

    结构体: 关系密切但数据类型不尽相同, 常指针和常量指针的区别: char * const cp : 定义一个指向字符的指针常数,即const指针,常指针. const char* p : 定义一个指 ...

  10. C#调用c++Dll 结构体数组指针的问题

    参考文章http://blog.csdn.net/jadeflute/article/details/5684687 但是这里面第一个方案我没有测试成功,第二个方案我感觉有点复杂. 然后自己写啦一个: ...

随机推荐

  1. Docker--简介&&安装

    Docker 是一种应用容器引擎 一 容器 Linux系统提供了Namespace和Cgroup技术实现环境隔离和资源控制 其中Namespace是Linux提供的一种内核级别环境隔离的方法,能使一个 ...

  2. Java字节码与反射机制

    字节码(Byte Code)是Java语言跨平台特性的重要保障,也是反射机制的重要基础.通过反射机制,我们不仅能看到一个类的属性和方法,还能在一个类里调用另外一个类的方法,但前提是我们得有相关类的字节 ...

  3. Java面试——数据库知识点

    MySQL 1.建 主键:数据库表中对储存数据对象予以唯一和完整标识的数据列或属性的组合.一个数据列只能有一个主键,且主键的取值不能缺失,即不能为空值(Null). 超键:在关系中能唯一标识元组的属性 ...

  4. 每天学五分钟 Liunx 1000 | 软件篇：源码安装

    软件安装流程 前面软件篇提到了通过 RPM 和 YUM 在线安装的机制安装软件,除了这两种方式之外还有一种通过源码来安装软件的方式.

  5. 【Altium Designer】五颜六色标识的PCB布板（增强PCB可视化特性）

    出现上图中五颜六色的网络标识,对比各个网络会更加清晰,实现步骤如下 打开或关闭  View--->Net Color Override Active   快捷键     F5 设置 displa ...

  6. 2023第十四届极客大挑战 — PWN WP

    WP可能有点简陋,因为是直接从docx导入到博客的,实在不想再重新写了!大家凑合着看吧!哈哈哈,问题不大! pwn方向出自:队友 nc_pwntools 只要过了chal1和chal2即可执行任意命令 ...

  7. 如何让pc端网站在手机上可以等比缩放的整个显示

      将 头部标签的  <meta name="viewport" content="width=device-width, initial-scale=1.0&qu ...

  8. [转帖]oracle 审计日志清理

    https://www.cnblogs.com/bangchen/p/7268086.html   --进入审计日志目录: cd $ORACLE_BASE/admin/$ORACLE_SID/adum ...

  9. [转帖]Jmeter之界面语言设置

    https://developer.aliyun.com/article/1173114#:~:text=%E6%B0%B8%E4%B9%85%E6%80%A7%E8%AE%BE%E7%BD%AE%E ...

  10. [转帖]linux 内核协议栈 TCP time_wait 原理、配置、副作用

    https://my.oschina.net/u/4087916/blog/3051356   0. 手把手教你做中间件.高性能服务器.分布式存储技术交流群 手把手教你做中间件.高性能服务器.分布式存 ...