C语言进阶（六）—— 结构体

news2025/4/28 6:48:22

1. 结构体基础知识

1.1 结构体类型的定义

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

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

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

1.2 结构体变量的定义

struct Person{
    char name[64];
    int age;
}p1; //1.定义类型同时定义变量

struct{
    char name[64];
    int age;
}p2; //2.定义类型同时定义变量

struct Person p3; //3.通过类型直接定义

1.3 结构体变量的初始化

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

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

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

1.4 结构体成员的使用

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

1.5 结构体赋值

1.5.1 赋值基本概念

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

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

1.5.2 深拷贝和浅拷贝

系统提供的赋值操作是简单的值拷贝，逐字节拷贝---- 浅拷贝,上方“赋值基本概念”案例。

如果结构体属性中有指向堆区的内容， 浅拷贝在释放期间会导致堆区重复释放，并且还有内存泄露。解决方案：利用深拷贝，手动赋值。

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

void test(){
    
    Person p1;
    p1.name = malloc(64);
    strcpy(p1.name , "John");
    p1.age = 30;

    Person p2;
    p2.name = malloc(128);
    strcpy(p2.name , "Obama");
    p2.age = 33;

    //p1 = p2; 由于浅拷贝导致 1.堆区数据重复释放 2.内存泄漏

    //对手动开辟的内存，需要手动拷贝 （深拷贝）
    //1.释放原有堆区内存
    if(p1.name != NULL){
        free(p1.name);
    }
    //2.分配内存
    p1.name = malloc(strlen(p2.name) + 1);
    strcpy(p1.name, p2.name);
    p1.age = p2.age;
    
    printf("Name:%s Age:%d\n", p1.name, p1.age);
    printf("Name:%s Age:%d\n", p2.name, p2.age);

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

1.6 结构体数组

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

2. 结构体嵌套指针

2.1 结构体嵌套一级指针

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

2.2 结构体嵌套二级指针

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

3. 结构体成员偏移量

//一旦结构体定义下来，则结构体中的成员内存布局就定下了
#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);
}

4. 结构体字节对齐

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

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

4.1 内存对齐

4.1.1 内存对齐原因

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

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

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

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

4.1.2 如何内存对齐

  • 对于标准数据类型，它的地址只要是它的长度的整数倍。

  • 对于非标准数据类型，比如结构体，要遵循一下对齐原则：

  1. 数组成员对齐规则。第一个数组成员应该放在offset为0的地方，以后每个数组成员应该放在offset为min（当前成员的大小，#pargama pack(n)）整数倍的地方开始（比如int在32位机器为４字节，#pargama pack(2)，那么从2的倍数地方开始存储）。

  1. 结构体总的大小，也就是sizeof的结果，必须是min（结构体内部最大成员，#pargama pack(n)）的整数倍，不足要补齐。

  1. 结构体做为成员的对齐规则。如果一个结构体B里嵌套另一个结构体A,还是以最大成员类型的大小对齐，但是结构体A的起点为A内部最大成员的整数倍的地方。（structB里存有struct A，A里有char，int，double等成员，那A应该从8的整数倍开始存储。），结构体A中的成员的对齐规则仍满足原则1、原则2。

手动设置对齐模数:
#pragmapack(show)
显示当前packing alignment的字节数，以warning message的形式被显示。

#pragmapack(n)
指定packing的数值，以字节为单位，缺省数值是8，合法的数值分别是1,2,4,8,16。

4.2 内存对齐案例

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/364945.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【Kubernetes 入门实战课】Day02——初识容器

【Kubernetes 入门实战课】Day02——初识容器

系列文章目录 【Kubernetes 入门实战课】Day01——搭建kubernetes实验环境(一) 文章目录系列文章目录前言一、Docker的诞生二、Docker的形态1、Docker Desktop2、Docker Engine二、Docker的安装1、服务器连接外网安装2、服务器不通外网三、Docker的使用三、Docker的架构总结前…
阅读更多...
JavaWeb11-死锁

JavaWeb11-死锁

目录 1.死锁定义 1.1.代码演示 1.2.使用jconsole/jvisualvm/jmc查看死锁 ①使用jconsole&#xff1a;最简单。 ②使用jvisualvm&#xff1a;&#xff08;Java虚拟机&#xff09;更方便&#xff0c;更直观&#xff0c;更智能&#xff0c;更高级&#xff0c;是合适的选择。 …
阅读更多...
Melis4.0[D1s]:2.启动流程（GUI桌面加载部分）跟踪笔记

Melis4.0[D1s]:2.启动流程（GUI桌面加载部分）跟踪笔记

文章目录0. 控制台输出信息等级设置0.1 设置log level 4 无法正常启动1.宏观启动流程1.1 控制台入口函数finsh_thread_entry()执行《startup.sh》1.2 《startup.sh》启动桌面GUI模块1.2.1 《startup.sh》加载 desktop.mod1.2.2 desktop.mod加载 init.axf1.2.3 init.axf 介绍1.…
阅读更多...
C#与三菱PLC MC协议通信,Java与三菱PLC MC协议通信

C#与三菱PLC MC协议通信,Java与三菱PLC MC协议通信

三菱PLC的MC协议是一种常用的通信协议&#xff0c;用于实现三菱PLC与其他设备之间的通信。以下是一些关于MC协议的基本信息&#xff1a;协议格式MC协议的通信数据格式如下&#xff1a;数据头网络编号PC编号目标模块IO编号目标模块站号本机模块IO编号本机模块站号请求数据长度请…
阅读更多...
Linud SSH与SCP的配置

Linud SSH与SCP的配置

目录 配置SSH协议 配置服务器通过密钥进行认证 配置SCP完成文件传输 ssh协议讲解 SSH协议理论讲解_静下心来敲木鱼的博客-CSDN博客https://blog.csdn.net/m0_49864110/article/details/128500490?ops_request_misc%257B%2522request%255Fid%2522%253A%2522167704203816800…
阅读更多...
不加大资金投入，仅凭智能名片如何解决企业营销难题的？

不加大资金投入，仅凭智能名片如何解决企业营销难题的？

中国90%以上的中小企业想要竞争和发展&#xff0c;就必须推广自己的品牌&#xff0c;提高自己的知名度。在小程序之前&#xff0c;APP是主流&#xff0c;但大多数中小企业负担不起APP的开发和昂贵的营销成本。 进入微信互联网时代后&#xff0c;为了帮助企业以更低的成本获得…
阅读更多...
浙大MEM现场小组复试经验分享

浙大MEM现场小组复试经验分享

作为2019年上岸浙大MEM项目的学姐一枚&#xff0c;很高兴收到杭州达立易考教育老师的邀请&#xff0c;给大家分享下现场面试的经历。先来看下复试流程是怎么样的。1、体检所有考生须参加。体检需在复试前完成&#xff08;未体检考生不得参加复试&#xff09;。 2、资格审查&…
阅读更多...
历时半年！从外包到现在阿里网易25K，分享一下自己的涨薪经验

历时半年！从外包到现在阿里网易25K，分享一下自己的涨薪经验

前言 首先自我介绍一下&#xff0c;本人普通一本毕业&#xff0c;年初被老东家裁员干掉了&#xff0c;之后一直住在朋友那混吃等死&#xff0c;转折是今年年后&#xff0c;二月初的时候和大佬吃了个饭&#xff0c;觉得自己不能这样下去了&#xff0c;拿着某大佬给我的面试资料…
阅读更多...
你知道IT运维的本质是什么吗？

你知道IT运维的本质是什么吗？

大家好&#xff0c;我是技福的小咖老师。 之前看到个文章&#xff0c;说运维的本质是“可视化”&#xff0c;甚至还有人说是DevOps。不可否认&#xff0c;“可视化”是运维过程中非常重要的一个环节&#xff1b;DevOps则是开发运维一体化非常重要的工具。 究其根本&#xff0…
阅读更多...
【09-JVM面试专题-实例化过程详细讲讲？对象的基本结构你知道吗？TLAB堆上内存分配是怎么样的？你了解这个TLAB吗？】

【09-JVM面试专题-实例化过程详细讲讲？对象的基本结构你知道吗？TLAB堆上内存分配是怎么样的？你了解这个TLAB吗？】

实例化过程详细讲讲&#xff1f;对象的基本结构你知道吗&#xff1f;TLAB堆上内存分配是怎么样的&#xff1f;你了解这个TLAB吗&#xff1f; 实例化过程详细讲讲&#xff1f;对象的基本结构你知道吗&#xff1f;TLAB堆上内存分配是怎么样的&#xff1f;你了解这个TLAB吗&#x…
阅读更多...
EMR Studio Workspace 访问 Github ( 公网Git仓库 )

EMR Studio Workspace 访问 Github ( 公网Git仓库 )

EMR Studio Workspace访问公网Git仓库 会遇到很多问题，由于EMR Studio不能给出任何有用的错误信息，导致排查起来非常麻烦。下面总结了若干项注意事项，可以避免踩坑。如果你遇到了同样的问题，请根据以下部分或全部建议去修正你的环境，问题即可解决。本文地址：https://laur…
阅读更多...
pc端集成企业微信的扫码登录及遇到的问题

pc端集成企业微信的扫码登录及遇到的问题

集成步骤&#xff1a; 1、在企业微信后台中添加应用 2、记录下应用的相关信息&#xff0c;在后文要用到 3、引入企业微信js 旧版&#xff1a;http://rescdn.qqmail.com/node/ww/wwopenmng/js/sso/wwLogin-1.0.0.js 新版&#xff08;20210803更新&#xff09;&#xff1a;http…
阅读更多...
kotlin学习教程

kotlin学习教程

kotlin的方法 可以直接调用 不用 new? 2.kotlin关于字符串 用 $拼接变量 3.kotlin 类 方法 变量 可以同级的&#xff0c;同级的 方法 和 变量(常量) 是 生成了 一个新的 xxxKt.class &#xff0c;并且都是 static的&#xff0c; 4.kotlin的类&#xff0c;方法&#xff0c;默认…
阅读更多...
JVM调优方式

JVM调优方式

对JVM内存的系统级的调优主要的目的是减少GC的频率和Full GC的次数。 1.Full GC 会对整个堆进行整理&#xff0c;包括Young、Tenured和Perm。Full GC因为需要对整个堆进行回收&#xff0c;所以比较慢&#xff0c;因此应该尽可能减少Full GC的次数。 2.导致Full GC的原因 1)年老…
阅读更多...
消息中间件

消息中间件

为什么要使用消息中间件同步通信&#xff1a;耗时长&#xff0c;受网络波动影响&#xff0c;不能保证高成功率&#xff0c;耦合性高。1.同步方式&#xff08;耗时长&#xff09;&#xff1a;同步方式的问题&#xff1a;当一个用户提交订单到成功需要300ms300ms300ms20ms 920ms…
阅读更多...
民锋国际期货：2023，既艰难又充满希望，既纷乱又有无数机会。

民锋国际期货：2023，既艰难又充满希望，既纷乱又有无数机会。

不管是官方还是民间&#xff0c;各种信号都表明&#xff0c;2023年是一个拼经济的年份。 通货膨胀带来的需求量的增加&#xff0c;与中国经济高速发展带来的供给量增加&#xff0c;二者共同构成了我们的物价。 做一个长期主义者&#xff0c;做一个坚定看好中国未来的人&#…
阅读更多...
SpringBoot（powernode）（内含教学视频+源代码）

SpringBoot（powernode）（内含教学视频+源代码）

SpringBoot&#xff08;powernode&#xff09;&#xff08;内含教学视频源代码&#xff09; 教学视频源代码下载链接地址&#xff1a;https://download.csdn.net/download/weixin_46411355/87484637 目录SpringBoot&#xff08;powernode&#xff09;&#xff08;内含教学视频…
阅读更多...
AcWing3490.小平方——学习笔记

AcWing3490.小平方——学习笔记

目录 题目 代码 AC结果 思路 题目 3490. 小平方 - AcWing题库https://www.acwing.com/problem/content/3493/ 代码 import java.util.Scanner;public class Main {public static void main(String[] args){Scanner input new Scanner(System.in);int target input.nextI…
阅读更多...
Python 自动化测试必会技能板块—unittest框架

Python 自动化测试必会技能板块—unittest框架

说到 Python 的单元测试框架&#xff0c;想必接触过 Python 的朋友脑袋里第一个想到的就是 unittest。的确&#xff0c;作为 Python 的标准库&#xff0c;它很优秀&#xff0c;并被广泛应用于各个项目。但其实在 Python 众多项目中&#xff0c;主流的单元测试框架远不止这一个。…
阅读更多...
谷歌seo关键词怎么做？Google如何优化关键词

谷歌seo关键词怎么做？Google如何优化关键词

本文主要分享谷歌seo关键词怎么去操盘才能更好的提升排名&#xff0c;我们立刻来学习一下。 本文由光算创作&#xff0c;有可能会被剽窃和修改&#xff0c;我们佛系对待这种行为吧。 谷歌seo关键词如何优化&#xff1f;这里我们提供一个谷歌seo优化的公式 答案是&#xff1a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023