C/C++结构体与指针笔记

结构体的定义与使用:

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

struct Student
{
int num;
char name[30];
char age;
};


int main(int argc, char* argv[])
{
struct Student stu = { 1001, "lyshark", 22 };

printf("普通引用: %d --> %s \n", stu.num, stu.name);

struct Student *ptr; // 定义结构指针
ptr = &stu; // 指针的赋值

printf("指针引用: %d --> %s \n", ptr->num, ptr->name);


system("pause");
return 0;
}

动态分配结构体成员:

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

int main(int argc, char* argv[])
{
struct Student
{
int num;
char name[30];
char age;
};

struct Student *stu = malloc(sizeof(struct Student));
stu->num = 1001;
stu->age = 24;
strcpy(stu->name, "lyshark");
printf("姓名: %s 年龄: %d \n", stu->name, stu->age);

// ----------------------------------------------------------
struct Person
{
char *name;
int age;
}person;

struct Person *ptr = &person;

ptr->name = (char *)malloc(sizeof(char)* 20);
strcpy(ptr->name, "lyshark");
ptr->age = 23;

printf("姓名: %s 年龄: %d \n", ptr->name, ptr->age);
free(ptr->name);

system("pause");
return 0;
}

结构体变量数组:

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

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



void Print(struct Person *p,int len)
{
for (int x = 0; x < len; x++)
{
printf("%d \n", p[x].uid);
}
}

int main(int argc, char* argv[])
{
// 栈上分配结构体(聚合初始化)
struct Person p1[] = {
{ 1, "aaa" },
{ 2, "bbb" },
{ 3, "ccc" },
};

int len = sizeof(p1) / sizeof(struct Person);
Print(p1, len);

// 在堆上分配
struct Person *p2 = malloc(sizeof(struct Person) * 5);

for (int x = 0; x < 5; x++)
{
p2[x].uid = x;
strcpy(p2[x].name, "aaa");
}
Print(p2, 5);

system("pause");
return 0;
}

结构体深浅拷贝

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

typedef struct Person
{
int uid;
char *name;
}Person;

int main(int argc, char* argv[])
{

struct Person p1,p2;

p1.name = malloc(sizeof(char)* 64);
strcpy(p1.name, "admin");
p1.uid = 1;

p2.name = malloc(sizeof(char)* 64);
strcpy(p2.name, "guest");
p2.uid = 2;

// p2 = p1; 浅拷贝

// 深拷贝

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

p1.name = malloc(strlen(p2.name) + 1);
strcpy(p2.name, p1.name);
p2.uid = p1.uid;

printf("p2 -> %s \n", p2.name);

system("pause");
return 0;
}

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

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

struct Student
{
int uid;
char name[32];
double score;
};

int StructSort(struct Student *stu,int len)
{
for (int x = 0; x < len - 1; x++)
{
for (int y = 0; y < len - x - 1; y++)
{
// if (strcmp(stu[y].name, stu[y + 1].name) > 0)
if (stu[y].uid > stu[y + 1].uid)
{
// 结构体变量互换,将用户UID从小到大排列
struct Student tmp = stu[y];
stu[y] = stu[y + 1];
stu[y+1] = tmp;
}
}
}
return 0;
}

void MyPrint(struct Student *stu,int len)
{
for (int x = 0; x < len; x++)
printf("Uid: %d Name: %s Score: %.1f \n", stu[x].uid,stu[x].name,stu[x].score);
}

int main(int argc, char* argv[])
{
struct Student stu[3] = {
{8,"admin",79.5},
{5,"guest",89.5},
{1,"root",99},
};

StructSort(stu, 3); // 调用排序
MyPrint(stu, 3); // 输出结果

system("pause");
return 0;
}

结构体数据之间的交换:

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

struct Student
{
char *name;
int score[3];
};

int StructExchange(struct Student *stu, int len, char *str1,char *str2)
{
struct Student *ptr1;
struct Student *ptr2;

// 找到两个名字所对应的成绩
for (int x = 0; x < len; ++x)
{
if (!strcmp(stu[x].name, str1))
ptr1 = &stu[x];
if (!strcmp(stu[x].name, str2))
ptr2 = &stu[x];
}

// 开始交换两个人的成绩
for (int y = 0; y < 3; y++)
{
int tmp = ptr1->score[y];
ptr1->score[y] = ptr2->score[y];
ptr2->score[y] = tmp;
}
return 0;
}

void MyPrint(struct Student *stu,int len)
{
for (int x = 0; x < len; x++)
{
printf("Name: %s --> score: %d %d %d \n", stu[x].name, stu[x].score[0], stu[x].score[1], stu[x].score[2]);
}
}

int main(int argc, char* argv[])
{
struct Student stu[3];

// 动态开辟空间,并动态输入姓名与成绩
// admin 1 1 1 / guest 2 2 2 / root 3 3 3
for (int x = 0; x < 3; x++)
{
stu[x].name = (char *)malloc(sizeof(char) * 64); // 开辟空间
scanf("%s%d%d%d", stu[x].name, &stu[x].score[0], &stu[x].score[1], &stu[x].score[2]);
}

MyPrint(&stu, 3);
// 开始交换两个人名的成绩
StructExchange(&stu, 3, "root", "admin");
printf("----------------------------\n");

MyPrint(&stu, 3);

// 动态内存的释放
for (int y = 0; y < 3; y++)
free(stu[y].name);

system("pause");
return 0;
}

结构体偏移量计算:

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

int main(int argc, char* argv[])
{

struct Student
{
int uid;
char *name;
};

struct Student stu = { 1, "lyshark" };
int offset = (int *)( (char *)&stu + offsetof(struct Student, name) );
printf("指针首地址: %x \n", offset);

// =================================================================
// 第二种嵌套结构体取地址

struct SuperClass
{
int uid;
char *name;
struct stu
{
int sid;
char *s_name;
}stu;
};

struct SuperClass super = { 1001, "lyshark" ,1,"xiaowang"};

int offset1 = offsetof(struct SuperClass, stu);
int offset2 = offsetof(struct stu, sid);

// SuperClass + stu 找到 sid 首地址
int struct_offset = ((char *)&super + offset1) + offset2;
printf("sid首地址: %x --> %x \n", struct_offset, &super.stu.sid);

int stu_sid = *(int *) ((char *)&super + offset1) + offset2;
printf("sid里面的数值是: %d \n", stu_sid);

int stu_sid_struct = ((struct stu *)((char *)&super + offset1))->sid;
printf("sid里面的数值是: %d \n", stu_sid_struct);

system("pause");
return 0;
}

结构体嵌套一级指针

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

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

// 分配内存空间,每一个二级指针中存放一个一级指针
struct Person ** allocateSpace()
{
// 分配3个一级指针,每一个指针指向一个结构首地址
struct Person **tmp = malloc(sizeof(struct Person *) * 3);
for (int x = 0; x < 3; x++)
{
tmp[x] = malloc(sizeof(struct Person)); // (真正的)分配一个存储空间
tmp[x]->name = malloc(sizeof(char) * 64); // 分配存储name的空间
sprintf(tmp[x]->name, "name_%d", x);
tmp[x]->id = x;
tmp[x]->age = x + 10;
}
return tmp;
}

// 循环输出数据
void MyPrint(struct Person **person)
{
for (int x = 0; x < 3; x++)
{
printf("Name: %s \n", person[x]->name);
}
}

// 释放内存空间,从后向前,从小到大释放
void freeSpace(struct Person **person)
{
if (person != NULL)
{
for (int x = 0; x < 3; x++)
{
if (person[x]->name != NULL)
{
printf("%s 内存被释放 \n",person[x]->name);
free(person[x]->name);
person[x]->name = NULL;
}

free(person[x]);
person[x] = NULL;
}
free(person);
person = NULL;
}
}


int main(int argc, char* argv[])
{
struct Person **person = NULL;

person = allocateSpace();
MyPrint(person);
freeSpace(person);

system("pause");
return 0;
}

结构体嵌套二级指针

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

struct Student
{
char * name;
}Student;

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

void allocateSpace(struct Teacher ***ptr)
{
// 首先分配三个二级指针,分别指向三个老师的结构首地址
struct Teacher **teacher_ptr = malloc(sizeof(struct Teacher *) * 3);

for (int x = 0; x < 3; x++)
{
// 先来分配老师姓名存储字符串,然后赋初值
teacher_ptr[x] = malloc(sizeof(struct Teacher)); // 给teacher_ptr整体分配空间
teacher_ptr[x]->name = malloc(sizeof(char)* 64); // 给teacher_ptr里面的name分配空间
sprintf(teacher_ptr[x]->name, "teacher_%d", x); // 分配好空间之后,将数据拷贝到name里面

// -------------------------------------------------------------------------------------
// 接着分配该老师管理的学生数据,默认管理四个学生
teacher_ptr[x]->student = malloc(sizeof(char *) * 4); // 给teacher_ptr 里面的student分配空间
for (int y = 0; y < 4; y++)
{
teacher_ptr[x]->student[y] = malloc(sizeof(char) * 64);
sprintf(teacher_ptr[x]->student[y], "%s_stu_%d", teacher_ptr[x]->name, y);
}
}
// 最后将结果抛出去
*ptr = teacher_ptr;
}

// 输出老师和学生数据
void MyPrint(struct Teacher **ptr)
{
for (int x = 0; x < 3; x++)
{
printf("老师姓名: %s \n", ptr[x]->name);
for (int y = 0; y < 4; y++)
{
printf("--> 学生: %s \n", ptr[x]->student[y]);
}
}
}

// 最后释放内存
void freeSpace(struct Teacher **ptr)
{
for (int x = 0; x < 3; x++)
{
if (ptr[x]->name != NULL)
{
free(ptr[x]->name);
ptr[x]->name = NULL;
}

for (int y = 0; y < 4; y++)
{
if (ptr[x]->student[y] != NULL)
{
free(ptr[x]->student[y]);
ptr[x]->student[y] = NULL;
}
}
free(ptr[x]->student);
ptr[x]->student = NULL;
}
}

int main(int argc, char* argv[])
{
struct Teacher **teacher_ptr = NULL;

allocateSpace(&teacher_ptr);
MyPrint(teacher_ptr);
freeSpace(teacher_ptr);

system("pause");
return 0;
}

结构体内嵌共用体:

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

struct Person
{
int uid; // 编号
char name[20]; // 姓名
char jobs; // 老师=t 或 学生 = s
union
{
char stu_class[32]; // 学生所在班级
char tea_class[32]; // 老师的所教课程
}category;
};

int main(int argc, char* argv[])
{
struct Person person[3];

for (int x = 0; x < 3; x++)
{
// 首先输入前三项,因为这三个数据是通用的,老师学生都存在的属性
printf("输入: ID 姓名 工作类型(s/t) \n");
scanf("%d %s %c", &person[x].uid, &person[x].name, &person[x].jobs);

if (person[x].jobs == 's') // 如果是学生,输入stu_class
scanf("%s", person[x].category.stu_class);
if (person[x].jobs == 't') // 如果是老师,输入tea_class
scanf("%s", person[x].category.tea_class);
}

printf("--------------------------------------------------------------\n");

for (int y = 0; y < 3; y++)
{
if (person[y].jobs == 's')
printf("老师: %s 职务: %s \n", person[y].name, person[y].category.tea_class);
if (person[y].jobs == 't')
printf("学生: %s 班级: %s \n", person[y].name, person[y].category.stu_class);
}
system("pause");
return 0;
}

结构体与链表

结构体基本定义:

#include <stdio.h>

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

int main(int argc, char* argv[])
{
// 在栈上分配空间
struct Person s1 = { 100, "admin" };
printf("%s \n", s1.name);

// 在堆上分配空间
struct Person *s2 = malloc(sizeof(struct Person));
strcpy(s2->name, "lyshark");
printf("%s \n", s2->name);


system("pause");
return 0;
}

结构体变量数组:

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

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



void Print(struct Person *p,int len)
{
for (int x = 0; x < len; x++)
{
printf("%d \n", p[x].uid);
}
}

int main(int argc, char* argv[])
{
// 栈上分配结构体(聚合初始化)
struct Person p1[] = {
{ 1, "aaa" },
{ 2, "bbb" },
{ 3, "ccc" },
};

int len = sizeof(p1) / sizeof(struct Person);
Print(p1, len);

// 在堆上分配
struct Person *p2 = malloc(sizeof(struct Person) * 5);

for (int x = 0; x < 5; x++)
{
p2[x].uid = x;
strcpy(p2[x].name, "aaa");
}
Print(p2, 5);

system("pause");
return 0;
}

结构体深浅拷贝

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

typedef struct Person
{
int uid;
char *name;
}Person;

int main(int argc, char* argv[])
{

struct Person p1,p2;

p1.name = malloc(sizeof(char)* 64);
strcpy(p1.name, "admin");
p1.uid = 1;

p2.name = malloc(sizeof(char)* 64);
strcpy(p2.name, "guest");
p2.uid = 2;

// p2 = p1; 浅拷贝

// 深拷贝

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

p1.name = malloc(strlen(p2.name) + 1);
strcpy(p2.name, p1.name);
p2.uid = p1.uid;

printf("p2 -> %s \n", p2.name);







system("pause");
return 0;
}

结构体嵌套一级指针

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

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

// 分配内存空间,每一个二级指针中存放一个一级指针
struct Person ** allocateSpace()
{
// 分配3个一级指针,每一个指针指向一个结构首地址
struct Person **tmp = malloc(sizeof(struct Person *) * 3);
for (int x = 0; x < 3; x++)
{
tmp[x] = malloc(sizeof(struct Person)); // (真正的)分配一个存储空间
tmp[x]->name = malloc(sizeof(char) * 64); // 分配存储name的空间
sprintf(tmp[x]->name, "name_%d", x);
tmp[x]->id = x;
tmp[x]->age = x + 10;
}
return tmp;
}

// 循环输出数据
void MyPrint(struct Person **person)
{
for (int x = 0; x < 3; x++)
{
printf("Name: %s \n", person[x]->name);
}
}

// 释放内存空间,从后向前,从小到大释放
void freeSpace(struct Person **person)
{
if (person != NULL)
{
for (int x = 0; x < 3; x++)
{
if (person[x]->name != NULL)
{
printf("%s 内存被释放 \n",person[x]->name);
free(person[x]->name);
person[x]->name = NULL;
}

free(person[x]);
person[x] = NULL;
}
free(person);
person = NULL;
}
}

int main(int argc, char* argv[])
{
struct Person **person = NULL;

person = allocateSpace();
MyPrint(person);
freeSpace(person);

system("pause");
return 0;
}

结构体嵌套二级指针

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

struct Student
{
char * name;
}Student;

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

void allocateSpace(struct Teacher ***ptr)
{
// 首先分配三个二级指针,分别指向三个老师的结构首地址
struct Teacher **teacher_ptr = malloc(sizeof(struct Teacher *) * 3);

for (int x = 0; x < 3; x++)
{
// 先来分配老师姓名存储字符串,然后赋初值
teacher_ptr[x] = malloc(sizeof(struct Teacher)); // 给teacher_ptr整体分配空间
teacher_ptr[x]->name = malloc(sizeof(char)* 64); // 给teacher_ptr里面的name分配空间
sprintf(teacher_ptr[x]->name, "teacher_%d", x); // 分配好空间之后,将数据拷贝到name里面

// -------------------------------------------------------------------------------------
// 接着分配该老师管理的学生数据,默认管理四个学生
teacher_ptr[x]->student = malloc(sizeof(char *) * 4); // 给teacher_ptr 里面的student分配空间
for (int y = 0; y < 4; y++)
{
teacher_ptr[x]->student[y] = malloc(sizeof(char) * 64);
sprintf(teacher_ptr[x]->student[y], "%s_stu_%d", teacher_ptr[x]->name, y);
}
}
// 最后将结果抛出去
*ptr = teacher_ptr;
}

// 输出老师和学生数据
void MyPrint(struct Teacher **ptr)
{
for (int x = 0; x < 3; x++)
{
printf("老师姓名: %s \n", ptr[x]->name);
for (int y = 0; y < 4; y++)
{
printf("--> 学生: %s \n", ptr[x]->student[y]);
}
}
}

// 最后释放内存
void freeSpace(struct Teacher **ptr)
{
for (int x = 0; x < 3; x++)
{
if (ptr[x]->name != NULL)
{
free(ptr[x]->name);
ptr[x]->name = NULL;
}

for (int y = 0; y < 4; y++)
{
if (ptr[x]->student[y] != NULL)
{
free(ptr[x]->student[y]);
ptr[x]->student[y] = NULL;
}
}
free(ptr[x]->student);
ptr[x]->student = NULL;
}
}

int main(int argc, char* argv[])
{
struct Teacher **teacher_ptr = NULL;

allocateSpace(&teacher_ptr);
MyPrint(teacher_ptr);
freeSpace(teacher_ptr);

system("pause");
return 0;
}

静态链表 理解一下

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

// 定义链表节点类型
struct LinkNode
{
int data;
struct LinkNode *next;
};


int main(int argc, char* argv[])
{
struct LinkNode node1 = { 10, NULL };
struct LinkNode node2 = { 20, NULL };
struct LinkNode node3 = { 30, NULL };
struct LinkNode node4 = { 40, NULL };

node1.next = &node2;
node2.next = &node3;
node3.next = &node4;
node4.next = NULL;

// 遍历链表结构

struct LinkNode *ptr = &node1;

while (ptr != NULL)
{
printf("%d \n", ptr->data);
ptr = ptr->next;
}

system("pause");
return 0;
}

动态链表

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

// 定义链表节点类型
struct LinkNode
{
int data;
struct LinkNode *next;
};

struct LinkNode *init_link()
{ // 创建一个头结点,头结点不需要添加任何数据
struct LinkNode *header = malloc(sizeof(struct LinkNode));
header->data = 0;
header->next = NULL;

struct LinkNode *p_end = header; // 创建一个尾指针

int val = -1;
while (1)
{
scanf("%d", &val); // 输入插入的数据
if (val == -1) // 如果输入-1说明输入结束了
break;

// 先创建新节点
struct LinkNode *newnode = malloc(sizeof(struct LinkNode));
newnode->data = val;
newnode->next = NULL;

// 将节点插入到链表中
p_end->next = newnode;
// 更新尾部指针指向
p_end = newnode;
}
return header;
}

// 遍历链表
int foreach_link(struct LinkNode *header)
{
if (NULL == header || header->next == NULL)
return 0;

while (header->next != NULL)
{
printf("%d \n", header->data);
header = header->next;
}
return 1;
}

// 在header节点中oldval插入数据
void insert_link(struct LinkNode *header,int oldval,int newval)
{
struct LinkNode *pPrev = header;
struct LinkNode *Current = pPrev->next;

if (NULL == header)
return;


while (Current != NULL)
{
if (Current->data == oldval)
break;

pPrev = Current;
Current = Current->next;
}
// 如果值不存在则默认插入到尾部
//if (Current == NULL)
// return;

// 创建新节点

struct LinkNode *newnode = malloc(sizeof(struct LinkNode));
newnode->data = newval;
newnode->next = NULL;

// 新节点插入到链表中
newnode->next = Current;
pPrev->next = newnode;
}

// 清空链表
void clear_link(struct LinkNode *header)
{
// 辅助指针
struct LinkNode *Current = header->next;

while (Current != NULL)
{
// 保存下一个节点地址
struct LinkNode *pNext = Current->next;
printf("清空数据: %d \n", Current->data);
free(Current);
Current = pNext;
}
header->next = NULL;
}


// 删除值为val的节点
int remove_link(struct LinkNode *header, int delValue)
{
if (NULL == header)
return;

// 设置两个指针,指向头结点和尾结点
struct LinkNode *pPrev = header;
struct LinkNode *Current = pPrev->next;

while (Current != NULL)
{
if (Current->data == delValue)
{
// 删除节点的过程
pPrev->next = Current->next;
free(Current);
Current = NULL;
}
}

// 移动两个辅助指针
pPrev = Current;
Current = Current->next;


}

// 销毁链表
void destroy_link(struct LinkNode *header)
{
if (NULL == header)
return;

struct LinkNode *Curent = header;
while (Curent != NULL)
{
// 先来保存一下下一个节点地址
struct LinkNode *pNext = Curent->next;

free(Curent);

// 指针向后移动
Curent = pNext;
}
}

// 反响排序
void reverse_link(struct LinkNode *header)
{
if (NULL == header)
return;

struct LinkNode *pPrev = NULL;
struct LinkNode *Current = header->next;
struct LinkNode * pNext = NULL;

while (Current != NULL)
{
pNext = Current->next;
Current->next = pPrev;

pPrev = Current;
Current = pNext;
}
header->next = pPrev;
}

int main(int argc, char* argv[])
{
struct LinkNode * header = init_link();

reverse_link(header);
foreach_link(header);

clear_link(header);
system("pause");
return 0;
}