美文网首页
C语言结构体

C语言结构体

作者: 码无不至 | 来源:发表于2020-09-13 12:24 被阅读0次

    结构体

    本文介绍C语言结构体，struct 在C++中功能相对C较多,相当于类，这里暂时不讨论，本文单独讨论C语言中的结构体知识。
    结构体定义:

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

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

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

    结构体变量定义:

    struct{
    char name[64];
    int age;
}p2; //定义类型同时定义变量
struct Person p3; //通过类型直接定义 (这种方式用得比较多)

    结构体变量初始化:

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

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

    结构体成员的使用:

    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);
}

    结构体赋值:
    相同的两个结构体变量可以相互赋值，把一个结构体变量的值拷贝给另一个结构体，这里就涉及到基本类型和指针类型赋值，默认是浅拷贝，如果是手动申请分配内存，自己需要拷贝内存，否则指针指向同一段内存，就容易出现野指针的问题。

    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;
    }
}

    结构体数组:

    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);
    }
    for (int i = 0; i < 3; i++){
        printf("Name:%s Age:%d\n", p2[i].name, p2[i].age);
    }
    //在堆上分配结构体数组
    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);
    }
}

    嵌套指针的结构体:

    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);
}

    结构体嵌套二级指针，相对来说复杂很多了，首先结构体成员里面包含了一个二级指针(指向指针的指针)

    //一个老师有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);
}

    内存对齐

    内存对齐是操作系统为了提高访问内存的策略。操作系统在访问内存的时候，每次读取一定长度(这个长度是操作系统默认的对齐数，或者默认对齐数的整数倍)。如果没有对齐，为了访问一个变量可能产生二次访问，内存对齐可以提高数据存取的速度。我们知道内存的最小单元是一个字节，当cpu从内存中读取数据的时候，是一个一个字节读取，但是实际上cpu将内存当成多个块，每次从内存中读取一个块，这个块的大小可能是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));
}

    经过验证Mac 和windows上平台编译器处理有差异，以上结论对windows有效。

    相关文章

      网友评论

          本文标题：C语言结构体

          本文链接：https://www.haomeiwen.com/subject/pwkisktx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|C语言结构体|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！