结构体

有时我们需要将不同类型的数据组合成一个有机的整体，如：一个学生有学号/姓名/性别/年龄/地址等属性。显然单独定义以上变量比较繁琐，数据不便于管理。Ｃ语⾔中给出了另一种构造数据类型——结构体。

定义和初始化

定义结构体变量的方式：

先声明结构体类型再定义变量名
在声明类型的同时定义变量
直接定义结构体类型变量（⽆类型名）

结构体类型和结构体变量关系：

结构体类型：指定了一个结构体类型，它相当于一个模型，但其中并⽆具体数据，系统对之也不分配实际内存单元。
结构体变量：系统根据结构体类型（内部成员状况）为之分配空间。

//结构体类型的定义
struct stu{
    char name[50];
    int age; 
};

//先定义类型，再定义变量（常用） 
struct stu s1 = { "mike", 18 };

//定义类型同时定义变量
struct stu2{
    char name[50]; 
    int age;
}s2 = { "lily", 22 };

struct{
    char name[50]; 
    int age;
}s3 = { "yuri", 25 };

注意

定义结构体类型时不要直接给成员赋值，结构体只是一个类型，编译器还没有为其分配空间，只有根据其类型定义变量时，才分配空间，有空间后才能赋值。

结构体变量的初始化

cpp

struct Person{ char name[64]; int age; }p1 = {"john",10}; //定义类型同时初始化变量

struct{ char name[64]; int age; }p2 = {"Obama",30}; //定义类型同时初始化变量

struct Person p3 = {"Edward",33}; //通过类型直接定义

结构体成员的使用

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

//结构体类型的定义
struct stu {
    char name[50];
    int age;
};

int main(void) {
    struct stu s1;

    //如果是普通变量，通过点运算符操作结构体成员
    strcpy(s1.name, "abc");
    s1.age = 18;
    printf("s1.name = %s, s1.age = %d\n", s1.name, s1.age);

    //如果是指针变量，通过->操作结构体成员
    strcpy((&s1)->name, "test");
    (&s1)->age = 22;
    printf("(&s1)->name = %s, (&s1)->age = %d\n", (&s1)->name, (&s1) -> age);

    return 0;
}

程序输出：

shell

s1.name = abc, s1.age = 18
(&s1)->name = test, (&s1)->age = 22

cpp

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

void test(){ 
    //在栈上分配空间 
    struct Person p1;
    strcpy(p1.name, "John"); 
    p1.age = 30; 
    //如果是普通变量，通过点运算符操作结构体成员 
    printf("Name:%s Age:%d\n", p1.name, p1.age);

    //在堆上分配空间 
    struct Person* p2 = (struct Person*)malloc(sizeof(struct Person)); 
    strcpy(p2->name, "Obama"); 
    p2->age = 33; 
    //如果是指针变量，通过->操作结构体成员 
    printf("Name:%s Age:%d\n", p2->name, p2->age);
}

结构体数组

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

//统计学生成绩
struct stu {
    int num;
    char name[20];
    char sex;
    float score;
};

int main(void) {
    //定义一个含有5个元素的结构体数组并将其初始化
    struct stu boy[5] = {
            {101, "Li ping", 'M', 45},
            {102, "Zhang ping", 'M', 62.5},
            {103, "He fang", 'F', 92.5},
            {104, "Cheng ling", 'F', 87},
            {105, "Wang ming", 'M', 58}};

    int i = 0;
    int c = 0;
    float ave, s = 0;

    for (i = 0; i < 5; i++) {
        s += boy[i].score;//计算总分
        if (boy[i].score < 60) {
            c += 1;//统计不及格人的分数
        }
    }

    printf("s=%.2f\n", s);//打印总分数

    ave = s / 5;                               //计算平均分数
    printf("average=%.2f\ncount=%d\n\n", ave, c);//打印平均分与不及格人数

    for (i = 0; i < 5; i++) {
        printf(" name=%s, score=%.2f\n", boy[i].name, boy[i].score);
        // printf(" name=%s, score=%f\n", (boy+i)->name, (boy+i)->score);
    }

    return 0;
}

程序输出：

shell

s=345.00
average=69.00
count=2

 name=Li ping, score=45.00
 name=Zhang ping, score=62.50
 name=He fang, score=92.50
 name=Cheng ling, score=87.00
 name=Wang ming, score=58.00

cpp

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

void test(){
    //在栈上分配空间 
    struct Person p1[3] = {
        { "John", 30 },
        { "Obama", 33 },
        { "Edward", 25} 
    };
    struct Person p2[3] = { "John", 30, "Obama", 33, "Edward", 25 };

    for (int i = 0; i < 3;i ++){
        printf("Name:%s Age:%d\n",p1[i].name,p1[i].age);
    } 
    printf("-----------------\n");

    for (int i = 0; i < 3; i++){
        printf("Name:%s Age:%d\n", p2[i].name, p2[i].age);
    } 
    printf("-----------------\n"); 
    
    //在堆上分配结构体数组 
    struct Person* p3 = (struct Person*)malloc(sizeof(struct Person) * 3);

    for (int i = 0; i < 3;i++){
        sprintf(p3[i].name, "Name_%d", i + 1);
        p3[i].age = 20 + i;
    }

    for (int i = 0; i < 3; i++){
        printf("Name:%s Age:%d\n", p3[i].name, p3[i].age);
    }
}

嵌套结构体

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

struct person {
    char name[20];
    char sex;
};

struct stu {
    int id;
    struct person info;
};

int main(void) {
    struct stu s[2] = {1, "lily", 'F', 2, "yuri", 'M'};
    int i = 0;
    for (i = 0; i < 2; i++) {
        printf("id = %d\tinfo.name=%s\tinfo.sex=%c\n", s[i].id, s[i].info.name, s[i].info.sex);
    }

    return 0;
}

程序输出：

shell

id = 1  info.name=lily  info.sex=F
id = 2  info.name=yuri  info.sex=M

结构体赋值

相同的两个结构体变量可以相互赋值，把一个结构体变量的值拷贝给另一个结构体，这两个变量还是两个独⽴的变量。

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

//结构体类型的定义
struct stu {
    char name[50];
    int age;
};

int main(void) {
    struct stu s1;

    //如果是普通变量，通过点运算符操作结构体成员
    strcpy(s1.name, "abc"); s1.age = 18;                printf("s1.name = %s, s1.age = %d\n", s1.name, s1.age);

    //相同类型的两个结构体变量，可以相互赋值
    //把s1成员变量的值拷贝给s2成员变量的内存
    //s1和s2只是成员变量的值一样而已，它们还是没有关系的两个变量
    struct stu s2 = s1;
    //memcpy(&s2, &s1, sizeof(s1));
    printf("s2.name = %s, s2.age = %d\n", s2.name, s2.age);

    return 0;
}

程序输出：

shell

s1.name = abc, s1.age = 18
s2.name = abc, s2.age = 18

cpp

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

void test(){ 
    //在栈上分配空间
    struct Person p1 = { "John" , 30};
    struct Person p2 = { "Obama", 33 };

    printf("Name:%s Age:%d\n", p1.name, p1.age); 
    printf("Name:%s Age:%d\n", p2.name, p2.age); 
    
    //将p2的值赋值给p1
    p1 = p2;

    printf("Name:%s Age:%d\n", p1.name, p1.age); 
    printf("Name:%s Age:%d\n", p2.name, p2.age);
}

深拷贝和浅拷贝

//一个⽼师有N个学生 
typedef struct _TEACHER{ char* name; }Teacher;

void test(){
    Teacher t1; 
    t1.name = malloc(64); 
    strcpy(t1.name , "John");

    Teacher t2;
    t2 = t1;

    //对⼿动开辟的内存，需要⼿动拷贝 
    t2.name = malloc(64); 
    strcpy(t2.name, t1.name);

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

成员偏移量

//一旦结构体定义下来，则结构体中的成员内存布局就定下了 
#include <stddef.h>

struct Teacher{
char a;
int b; 
};

void test01(){
    struct Teacher t1;
    struct Teacher*p = &t1;
    
    int offsize1 = (int)&(p->b) - (int)p; //成员b 相对于结构体 Teacher的偏移量
    int offsize2 = offsetof(struct Teacher, b);
    
    printf("offsize1:%d \n", offsize1); //打印b属性对于⾸地址的偏移量 
    printf("offsize2:%d \n", offsize2);
}

字节对齐

在用sizeof运算符求算某结构体所占空间时，并不是简单地将结构体中所有元素各⾃占的空间相加，这里涉及到内存字节对齐的问题。

从理论上讲，对于任何变量的访问都可以从任何地址开始访问，但是事实上不是如此，实际上访问特定类型的变量只能在特定的地址访问，这就需要各个变量在空间上按一定的规则排列，而不是简单地顺序排列，这就是内存对齐。

内存对齐

内存对齐原因

我们知道内存的最⼩单元是一个字节，当cpu从内存中读取数据的时候，是一个一个字节读取，所以内存对我们应该是⼊下图这样：

但是实际上cpu将内存当成多个块，每次从内存中读取一个块，这个块的⼤⼩可能是2、4、 8、16等。

那么下⾯，我们来分析下非内存对齐和内存对齐的优缺点在哪？

内存对齐是操作系统为了提⾼访问内存的策略。操作系统在访问内存的时候，每次读取一定长度(这个长度是操作系统默认的对齐数，或者默认对齐数的整数倍)。如果没有对齐，为了访问一个变量可能产生二次访问。

至此大家应该能够简单明白，为什么要简单内存对齐？

提⾼存取数据的速度。比如有的平台每次都是从偶地址处读取数据，对于一个int型的变量，若从偶地址单元处存放，则只需一个读取周期即可读取该变量；但是若从奇地址单元处存放，则需要2个读取周期读取该变量。
某些平台只能在特定的地址处访问特定类型的数据，否则抛出硬件异常给操作系统。

如何内存对齐

对于标准数据类型，它的地址只要是它的长度的整数倍。
对于非标准数据类型，比如结构体，要遵循一下对齐原则：
- 数组成员对齐规则。第一个数组成员应该放在offset为0的地⽅，以后每个数组成员应该放在offset为*min（当前成员的大小，#pargama pack(n)）*整数倍的地⽅开始（比如int在32位机器为４字节，#pargama pack(2)，那么从2的倍数地⽅开始存储）。
- 结构体总的⼤⼩，也就是sizeof的结果，必须是*min（结构体内部最大成员，#pargama pack(n)）*的整数倍，不⾜要补齐。
- 结构体做为成员的对齐规则。如果一个结构体B里嵌套另一个结构体A,还是以最⼤成员类型的⼤⼩对齐，但是结构体A的起点为A内部最⼤成员的整数倍的地⽅。（struct B里存有struct A，A里有char，int，double等成员，那A应该从8的整数倍开始存储。），结构体A中的成员的对齐规则仍满⾜原则1、原则2。

手动设置对齐模数:

#pragma pack(show) 显⽰当前packing alignment的字节数，以warning message的形式被显⽰。
#pragma pack(push) 将当前指定的packing alignment数组进行压栈操作，这里的栈是the internal compiler stack,同事设置当前的packing alignment为n；如果n没有指定，则将当前的packing alignment数组压栈。
#pragma pack(pop) 从internal compiler stack中删除最顶端的reaord; 如果没有指定n,则当前栈顶record即为新的packing alignement数值；如果指定了n，则n成为新的packing alignment值
#pragma pack(n) 指定packing的数值，以字节为单位，缺省数值是8，合法的数值分别是1,2,4,8,16。

内存对齐案例

#pragma pack(4)

typedef struct _STUDENT{ 
    int a; 
    char b; 
    double c; 
    float d; 
}Student;
typedef struct _STUDENT2{ 
    char a; 
    Student b; 
    double c; 
}Student2;

void test01(){ 
    //Student 
    //a从偏移量0位置开始存储 
    //b从4位置开始存储 
    //c从8位置开始存储 
    //d从12位置开存储 
    //所以Student内部对齐之后的⼤⼩为20 ，整体对齐，整体为最⼤类型的整数倍 也就是8 的整数倍 为24

    printf("sizeof Student:%d\n",sizeof(Student));

    //Student2 
    //a从偏移量为0位置开始 
    //b从偏移量为Student内部最⼤成员整数倍开始，也就是8开始 
    //c从8的整数倍地⽅开始,也就是32开始 
    //所以结构体Sutdnet2内部对齐之后的⼤⼩为：40 ， 由于结构体中最⼤成员为8，必须 为8的整数倍 所以⼤⼩为40 
    printf("sizeof Student2:%d\n", sizeof(Student2)); 
}

结构体和指针

指向普通结构体变量的指针

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

//结构体类型的定义
struct stu {
    char name[50];
    int age;
};

int main(void) {
    struct stu s1 = {"lily", 18};
    //如果是指针变量，通过->操作结构体成员
    struct stu *p = &s1;

    printf("p->name = %s, p->age=%d\n", p->name, p->age);
    printf("(*p).name = %s, (*p).age=%d\n", (*p).name, (*p).age);

    return 0;
}

程序输出：

shell

p->name = lily, p->age=18
(*p).name = lily, (*p).age=18

堆区结构体变量

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

//结构体类型的定义
struct stu {
    char name[50];
    int age;
};

int main(void) {
    struct stu *p = NULL;
    p = (struct stu *) malloc(sizeof(struct stu));
    //如果是指针变量，通过->操作结构体成员
    strcpy(p->name, "test");
    p->age = 22;

    printf("p->name = %s, p->age=%d\n", p->name, p->age);
    printf("(*p).name = %s, (*p).age=%d\n", (*p).name, (*p).age);
    free(p);
    p = NULL;

    return 0;
}

程序输出：

shell

p->name = test, p->age=22
(*p).name = test, (*p).age=22

结构体嵌套一级指针

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

//结构体类型的定义
struct stu {
    char *name;//一级指针
    int age;
};

int main(void) {
    struct stu *p = NULL;
    p = (struct stu *) malloc(sizeof(struct stu));
    p->name = malloc(strlen("test") + 1);
    strcpy(p->name, "test");
    p->age = 22;

    printf("p->name = %s, p->age=%d\n", p->name, p->age);
    printf("(*p).name = %s, (*p).age=%d\n", (*p).name, (*p).age);

    if (p->name != NULL) {
        free(p->name);
        p->name = NULL;
    }

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

    return 0;
}

程序输出：

shell

p->name = test, p->age=22
(*p).name = test, (*p).age=22

cpp

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

void allocate_memory(struct Person **person) {
    if (person == NULL) { return; }
    struct Person *temp = (struct Person *) malloc(sizeof(struct Person));
    if (temp == NULL) { return; }

    //给name指针分配内存
    temp->name = (char *) malloc(sizeof(char) * 64);
    strcpy(temp->name, "John");
    temp->age = 100;
    *person = temp;
}

void print_person(struct Person *person) { printf("Name:%s Age:%d\n", person->name, person->age); }

void free_memory(struct Person **person) {
    if (person == NULL) { return; }

    struct Person *temp = *person;

    if (temp->name != NULL) {
        free(temp->name);
        temp->name = NULL;
    }

    free(temp);
}

void test() {
    struct Person *p = NULL;

    allocate_memory(&p);
    print_person(p);
    free_memory(&p);
}

结构体嵌套二级指针

//一个⽼师有N个学生
typedef struct _TEACHER {
    char name[64];
    char **students;
} Teacher;

void create_teacher(Teacher **teacher, int n, int m) {
    if (teacher == NULL) { return; }

    //创建⽼师数组
    Teacher *teachers = (Teacher *) malloc(sizeof(Teacher) * n);
    if (teachers == NULL) { return; }

    //给每一个⽼师分配学生
    int num = 0;
    for (int i = 0; i < n; i++) {
        sprintf(teachers[i].name, "⽼师_%d", i + 1);
        teachers[i].students = (char **) malloc(sizeof(char *) * m);
        for (int j = 0; j < m; j++) {
            teachers[i].students[j] = malloc(64);
            sprintf(teachers[i].students[j], "学生_%d", num + 1);
            num++;
        }
    }
    *teacher = teachers;
}

void print_teacher(Teacher *teacher, int n, int m) {
    for (int i = 0; i < n; i++) {
        printf("%s:\n", teacher[i].name);
        for (int j = 0; j < m; j++) {
            printf(" %s", teacher[i].students[j]);
        }
        printf("\n");
    }
}

void free_memory(Teacher **teacher, int n, int m) {
    if (teacher == NULL) { return; }

    Teacher *temp = *teacher;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            free(temp[i].students[j]);
            temp[i].students[j] = NULL;
        }
        free(temp[i].students);
        temp[i].students = NULL;
    }
    free(temp);
}

void test() {
    Teacher *p = NULL;
    create_teacher(&p, 2, 3);
    print_teacher(p, 2, 3);
    free_memory(&p, 2, 3);
}

结构体做函数参数

结构体普通变量做函数参数

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

//结构体类型的定义
struct stu {
    char name[50];
    int age;
};

//函数参数为结构体普通变量
void set_stu(struct stu tmp) {
    strcpy(tmp.name, "mike");
    tmp.age = 18;
    printf("tmp.name = %s, tmp.age = %d\n", tmp.name, tmp.age);
}

int main(void) {
    struct stu s = {0};
    set_stu(s);//值传递
    printf("s.name = %s, s.age = %d\n", s.name, s.age);

    return 0;
}

程序输出：

shell

tmp.name = mike, tmp.age = 18
s.name = , s.age = 0

结构体指针变量做函数参数

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

//结构体类型的定义
struct stu {
    char name[50];
    int age;
};

//函数参数为结构体指针变量
void set_stu_pro(struct stu *tmp) {
    strcpy(tmp->name, "mike");
    tmp->age = 18;
}

int main(void) {
    struct stu s = {0};
    set_stu_pro(&s);//地址传递
    printf("s.name = %s, s.age = %d\n", s.name, s.age);

    return 0;
}

程序输出：

shell

s.name = mike, s.age = 18

结构体数组名做函数参数

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

//结构体类型的定义
struct stu {
    char name[50];
    int age;
};

//void set_stu_pro(struct stu tmp[100], int n)
//void set_stu_pro(struct stu tmp[], int n)
void set_stu_pro(struct stu *tmp, int n) {
    int i = 0;
    for (i = 0; i < n; i++) {
        sprintf(tmp->name, "name%d%d%d", i, i, i);
        tmp->age = 20 + i;
        tmp++;
    }
}

int main(void) {
    struct stu s[3] = {0};
    int i = 0;
    int n = sizeof(s) / sizeof(s[0]);
    set_stu_pro(s, n);//数组名传递
    for (i = 0; i < n; i++) {
        printf("%s, %d\n", s[i].name, s[i].age);
    }

    return 0;
}

程序输出：

shell

name000, 20
name111, 21
name222, 22

const修饰结构体指针形参变量

//结构体类型的定义
struct stu {
    char name[50];
    int age;
};

void fun1(struct stu *const p) {
    //p = NULL; //err
    p->age = 10;//ok
}

//void fun2(struct stu const*p)
void fun2(const struct stu *p) {
    p = NULL;//ok
    //p->age = 10; //err
}

void fun3(const struct stu *const p) {
    //p = NULL; //err
    //p->age = 10; //err
}

结构体 ​

定义和初始化 ​

结构体成员的使用 ​

结构体数组 ​

嵌套结构体 ​

结构体赋值 ​

深拷贝和浅拷贝 ​

成员偏移量 ​

字节对齐 ​

内存对齐 ​

内存对齐原因 ​

如何内存对齐 ​

内存对齐案例 ​

结构体和指针 ​

指向普通结构体变量的指针 ​

堆区结构体变量 ​

结构体嵌套一级指针 ​

结构体嵌套二级指针 ​

结构体做函数参数 ​

结构体普通变量做函数参数 ​

结构体指针变量做函数参数 ​

结构体数组名做函数参数 ​

const修饰结构体指针形参变量 ​

结构体

定义和初始化

结构体成员的使用

结构体数组

嵌套结构体

结构体赋值

深拷贝和浅拷贝

成员偏移量

字节对齐

内存对齐

内存对齐原因

如何内存对齐

内存对齐案例

结构体和指针

指向普通结构体变量的指针

堆区结构体变量

结构体嵌套一级指针

结构体嵌套二级指针

结构体做函数参数

结构体普通变量做函数参数

结构体指针变量做函数参数

结构体数组名做函数参数

const修饰结构体指针形参变量