|
文章可能比较长，如果想仔细了解结构体知识的话请大佬们耐心看完。
文章目录
一、结构体基本使用二、结构体常见赋值问题及解决三、结构体偏移量四、内存对齐问题五、结构体与一级指针嵌套六、结构体与二级指针嵌套
一、结构体基本使用
基本规则与使用方法： 1.正常结构体定义时不能赋初值；
struct Person
{
char name[64];
//int age = 50;//定义时不能赋初值，只有使用变量时才赋初值。
int age;
};
2.使用typedef对结构体取别名；
typedef struct Person
{
char name[64];
int age;
}MyPerson;//MyPerson为struct Person类型的别名；
void test()
{
MyPerson p = {"aaa",10};//可以直接用别名使用；
}
3.没有写时typedef是定义了一个结构体变量(与上面对比)，可以对其直接使用；
struct Person
{
char name[64];
int age;
}MyPerson = {"小米",200};//定义了一个结构体变量,可以直接使用
void test()
{
printf("姓名：%s 年龄：%d\n",MyPerson.name,MyPerson.age);
}
输出结果：  4.匿名类型下创建一个结构体变量，只有一个MyPerson3结构体变量可以使用，无法创建新的变量，也可对其直接使用；局限性强，基本不会使用。
struct
{
char name[64];
int age;
}MyPerson3 = {"小白",30};
void test()
{
printf("姓名：%s 年龄：%d\n",MyPerson3.name,MyPerson3.age);
}
输出结果：  5.在栈区与堆区创建结构体变量；
void test()
{
//在栈上创建结构体
struct Person p1 = {"aaa",10};
//在堆区创建结构体变量
struct Person* p2 = (struct Person*)malloc(sizeof(struct Person));
p2->age = 66;
strcpy(p2->name,"bbb");
}
6.在栈上与堆上创建结构体变量数组；
typedef struct Person
{
char name[64];
int age;
}MyPerson;
void PrintArray(struct Person persons[],int len)
{
for (int i=0; i
//在栈上创建结构体变量数组
struct Person persons[] =
{
{"aaa",10},
{"bbb",20},
{"ccc",30},
{"ddd",40}
};
int len = sizeof(persons)/sizeof(struct Person);
PrintArray(persons,len);
//在堆区创建结构体变量数组
struct Person* personArr = (struct Person*)malloc(sizeof(struct Person)*4);
for (int i=0; i
free(personArr);
personArr = NULL;
}
}
打印结果：输出成功。 
二、结构体常见赋值问题及解决
结构体常见赋值问题以及解决： 1.结构体变量赋值问题：在栈上开辟内存 : 将p2赋值给了p1
struct Person
{
char name[64];
int age;
};
void test()
{
struct Person p1 = {"Tom",20};
struct Person p2 = {"Jerry",18};
p1 = p2;//将p2赋值给p1
printf("p1的姓名：%s p1的年龄：%d\n",p1.name,p1.age);
printf("p2的姓名：%s p2的年龄：%d\n",p2.name,p2.age);
}
那么系统做了什么操作呢？ 系统提供了浅拷贝操作，将p2每个字节拷贝到p1上，拷贝成功。  输出结果：赋值成功；  2.结构体变量赋值问题：在堆区开辟内存(浅拷贝出现的问题) : 若将上面代码改为如下代码：
struct Person2
{
char* name;
int age;
};
void test2()
{
struct Person2 p1;
p1.age = 18;
p1.name = (char*)malloc(sizeof(char)*64);
strcpy(p1.name,"Tom");
struct Person2 p2;
p2.age = 20;
p2.name = (char*)malloc(sizeof(char)*128);
strcpy(p2.name,"Jerry");
printf("p1的姓名：%s p1的年龄：%d\n",p1.name,p1.age);
printf("p2的姓名：%s p2的年龄：%d\n",p2.name,p2.age);
}
先打印一下，打印成功。  此时，我们再将p2赋值给p1。
p1 = p2;//p2赋值给p1
再打印一下：还是没问题的  但是我们此时是在堆区开辟的内存，需要手动释放(堆区才会出现的问题，栈区不会出现该问题)，我们执行如下代码后。
if (p1.name != NULL)
{
free(p1.name);
p1.name = NULL;
}
if (p2.name != NULL)
{
free(p2.name);
p2.name = NULL;
}
程序崩溃！未响应，关了半天才关掉！  为什么会发生这样的结果呢？我们来研究一下：  那么如何解决它呢？ C语言里面解决它的方案：手动做一个赋值操作。开辟新的空间，最后释放。  代码操作：先将p1释放干净，重新手动开辟一块新的空间，手动使用strcpy赋值，最后再释放。
struct Person2
{
char* name;
int age;
};
void test2()
{
struct Person2 p1;
p1.age = 18;
p1.name = (char*)malloc(sizeof(char)*64);
strcpy(p1.name,"Tom");
struct Person2 p2;
p2.age = 20;
p2.name = (char*)malloc(sizeof(char)*128);
strcpy(p2.name,"Jerry");
//p1 = p2;//p2赋值给p1
//自己提供一个赋值操作
//先释放原有的内容
if (p1.name != NULL)
{
free(p1.name);
p1.name = NULL;
}
p1.name = (char*)malloc(strlen(p2.name)+1);
strcpy(p1.name,p2.name);
p1.age = p2.age;
printf("p1的姓名：%s p1的年龄：%d\n",p1.name,p1.age);
printf("p2的姓名：%s p2的年龄：%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;
}
}
输出一下：打印成功，也没有崩溃，堆区数据也释放干净。 
三、结构体偏移量
我们已知一个结构体：如何计算结构体中某个变量它的偏移量呢? 方式一：口算 如下，我们明白内存对齐的方式，会自动补齐；因此a补齐为0-3，b的偏移量就是4了。
struct Person
{
char a;//0~3
int b;//4~7
};
方式二：利用offsetof宏 offsetof 会生成一个类型为 size_t 的整型常量，其功能是一个结构成员相对于结构开头的字节偏移量。
宏声明：offsetof(type, member-designator)
参数：
type：这是一个class类型，其中，member-designator是一个有效的成员指示器。
member-designator：这是一个class类型的成员指示器。
返回值：该宏返回类型为 size_t 的值，表示 type 中成员的偏移量。
代码实例：
struct Person
{
char a;//0~3
int b;//4~7
};
void test()
{
struct Person p1;
struct Person* p = &p1;
printf("b的偏移量为：%d\n",offsetof(struct Person,b));
}
可以直接计算出来偏移量：4  方式三：利用地址计算 ： 利用b的地址减去a的地址
printf("b的偏移量为：%d\n",(int)&(p->b)-(int)p);//即b的地址减去a的地址
偏移量也为：4 实际案例1：通过偏移量获取结构体里面的数据
struct Person
{
char a;
int b;
};
void test2()
{
struct Person p1 = {'a',10};
printf("p.b = %d\n",*(int*)((char*)&p1 + offsetof(struct Person,b)));
printf("p.b = %d\n",*(int*)((int*)&p1 + 1));
}
输出结果：  实际案例2：通过偏移量找到结构体中嵌套结构体的数据 结构体中嵌套结构体本质是将其展开。
struct Person
{
char a;
int b;
};
struct Person2
{
char a;
int b;
struct Person c;//相当于将上面的结构体展开
};
void test()
{
struct Person2 p = {'a',10,'c',20};
int offset1 = offsetof(struct Person2,c);
int offset2 = offsetof(struct Person,b);
printf("方式1访问偏移量为：%d\n",*(int*)((char*)&p+offset1+offset2));//方式1
printf("方式2访问偏移量为：%d\n",((struct Person*)((char*)&p+offset1))->b);//方式2
}
打印结果：成功找到 
四、内存对齐问题
为什么需要内存对齐？ 内存的最小单元是一个字节，当CPU从内存中读取数据的时候，是一个一个字节读取。但是实际上CPU将内存当成多个块，每次从内存中读取一个块，这个块的大小可能是2、4、8、16等。内存对齐是操作系统为了提高访问内存的策略，操作系统再访问内存的时候，每次读取一定的长度(这个长度是操作系统默认的对齐数，或者默认对齐数的整数倍)。如果没有对齐，为了访问一个变量可能产生二次访问。内存对齐的优势：以空间换时间。  那么如何进行内存对齐？ 1.对于标准数据类型，它的地址只要是它的长度的整数倍。 2.对于非标准数据类型，如结构体，要遵循以下对齐原则： ①从第一个属性开始，偏移为0； ②从第二个属性开始，地址要放在该类型整数倍与对齐模数(系统中默认为8)比取小的值的整数倍上。 ③所有的属性都计算完成后，整体在做二次对齐，整体需要放在属性中最大类型与对齐模数比取效地整数倍上。 如何查看对齐模数：输入下列代码，重新生成下；对齐模数可以改为2^n；
#pragma pack(show)//查看对齐模数，输出该代码，不要运行，重新生成以下就好了
可以看到编译器最下面：  实例1：计算结构体大小
typedef struct _STUDENT
{
int a;//0-3
char b;//4-7
double c;//8-15
float d;//16-24
}Student;
void test()
{
printf("sizeof = %d\n",sizeof(Student));
}
输出结果：根据内存对齐为24  实例2：修改对齐模数为1(相当于没有内存对齐，挨个相加)后计算
#pragma pack(1)
typedef struct _STUDENT
{
int a;//0-3
char b;//4
double c;//5-12
float d;//13-16
}Student;
void test()
{
printf("sizeof = %d\n",sizeof(Student));
}
输出结果：修改对齐模数为1，挨个数据类型相加即为结果。  实例3：结构体嵌套结构体时，只需要看子结构体中最大数据类型就可以了。
typedef struct _STUDENT
{
int a;
char b;
double c;
float d;//总大小为24
}Student;
typedef struct _STUDENT2
{
char a;//0-7
Student b;//8-31
double c;//32-39
}Student2;
void test()
{
printf("sizeof = %d\n",sizeof(Student2));
}
输出结果：总大小为40字节 
五、结构体与一级指针嵌套
我们直接看一个例子来使用它：大致在堆区创建结构如下。需求为打印出来这里面所有人的年龄和姓名。 大致流程如下： ①设计一个结构体struct Person{char* name,int age} ②在堆区创建结构体指针数组malloc(sizeof(struct Person*)*3); ③给每个结构体也分配到堆区 ④给每个结构体的姓名分配到堆区 ⑤打印数组中所有人的信息 ⑥释放堆区数据。  实现代码：
struct Person
{
char* name;
int age;
};
void printArray(struct Person **pArray,int len)
{
for (int i=0; i
for (int i=0; i
printf("%s被释放了\n",pArray[i]->name);
free(pArray[i]->name);
pArray[i]->name = NULL;
}
free(pArray[i]);//释放结构体
pArray[i] = NULL;
}
free(pArray);//释放数组
pArray = NULL;
}
struct Person** allocateSpace()
{
struct Person** pArray = (struct Person**)malloc(sizeof(struct Person*)*3);//分配空间
for (int i=0; i
struct Person** pArray = NULL;//利用被调函数分配内存
pArray = allocateSpace();
printArray(pArray,3);
freeSpace(pArray,3);
pArray = NULL;
}
输出结果：成功实现结构体与一级指针嵌套使用。 
六、结构体与二级指针嵌套
我们直接看一个例子来使用它：  代码实现：
struct Teacher
{
char* name;
char** Students;
};
void allocateSpace(struct Teacher*** teachers)//分配内存
{
struct Teacher** pArray = (struct Teacher**)malloc(sizeof(struct Teacher*)*3);
for (int i=0; i
pArray[i]->Students[j] = (char*)malloc(sizeof(char)*64);
sprintf(pArray[i]->Students[j],"%s_Student_%d",pArray[i]->name,j+1);
}
}
*teachers = pArray;
}
void ShowArray(struct Teacher** pArray,int len)
{
for (int i=0; i
printf(" %s\n",pArray[i]->Students[j]);
}
}
}
void freeSpace(struct Teacher** pArray,int len)
{
for (int i=0; i
free(pArray[i]->name);
pArray[i]->name = NULL;
}
for (int j=0; j
free(pArray[i]->Students[j]);
pArray[i]->Students[j] = NULL;
}
}
//释放学生数组
free(pArray[i]->Students);
pArray[i]->Students = NULL;
//释放老师
free(pArray[i]);
pArray[i] = NULL;
}
//释放老师数组
free(pArray);
pArray = NULL;
}
void test()
{
struct Teacher** pArray = NULL;
allocateSpace(&pArray);//分配内存
ShowArray(pArray,3);//打印数组
freeSpace(pArray,3);//释放
pArray = NULL;
}
打印结果：成功实现结构体与一级指针嵌套使用。 
|