C语言基础之结构体

最新推荐文章于 2024-07-25 23:20:14 发布
最新推荐文章于 2024-07-25 23:20:14 发布
阅读量750 收藏 20
点赞数 18
分类专栏： C语言学习 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52154565/article/details/136606083
版权

文章目录

一、结构体

1、结构体概述

将多种数据结构封装在一起 形成新的结构叫结构体

每种数据结构 都有自己独立的空间

结构体的关键字 struct

2、结构体类型的定义方式

（1）先定义结构体类型，再定义结构体变量

struct str
{
    int num;//结构体成员
    char name;
};
struct str array;//定义结构体变量

（2）结构体类型、变量同时定义

struct str
{
    int num;//结构体成员
    char name;
}array;//定义结构体变量
struct str data;//定义结构体新变量

（3）一次性结构体

struct 
{
     int num;   
}asd;//定义变量

3、结构体成员的初始化

(1)结构体初始化

#include <stdio.h>

struct stu
{
    int num;
    char str[128];
    int data[32];
};
int main(int argc, char const *argv[])
{
    struct stu array = {100,"hello",{200,300}};
    printf("%d %s %d\n",array.num, array.str, array.data[1]);
    return 0;
}

(2)清空结构体

#include <stdio.h>
#include <string.h>
struct stu
{
    int num;
    char str[128];
    int data[32];
};
int main(int argc, char const *argv[])
{
    struct stu array;
    memset(&array,0,sizeof(array));
    printf("%d\n",sizeof(array));//260 = 1*4+128+32*4
    return 0;
}

(3)键盘给结构体赋值

#include <stdio.h>
#include <string.h>
struct stu
{
    int num;
    char str[128];
    int data[32];
};
int main(int argc, char const *argv[])
{
    struct stu array;
    memset(&array,0,sizeof(array));
    scanf("%d %s",&array.num, array.str);//键盘获取内容
    printf("%d  %s\n",array.num, array.str);
    return 0;
}

#include <stdio.h>
#include <string.h>
struct date
{
    int num;
    char str[128];
};
int main(int argc, char const *argv[])
{
    struct date arr[3];
    memset(arr,0,sizeof(arr));
    int n = sizeof(arr)/sizeof(arr[0]);

    //获取键盘数组
    printf("请输入%d个学生信息num str\n",n);
    int i = 0;
    for ( i = 0; i < n; i++)
    {
        scanf("%d %s",&arr[i].num,arr[i].str);
    }
    
    for ( i = 0; i < n; i++)
    {
        printf("%d %s\n",arr[i].num,arr[i].str);
    }   
}

4、结构体成员操作

int类型

zxc.num +=100;

char类型

strcpy(zxc.str,"name");

5、相同类型的结构体操作

#include <stdio.h>
#include <string.h>
struct stu
{
    int num;
    char str[128];
    int data[32];
};
int main(int argc, char const *argv[])
{
	struct stu array = {100,"hello",200};
    struct stu array2;
    #if 1
    //方式一；成员逐个赋值
        array2.num = array.num;
        *array2.data = *array.data;
        strcpy(array2.str,array.str);
    #elif 0
    //方式二；相同类型的结构体变量，可以直接赋值
        array2 = array;
    #else
    //方式三
    memcpy(&array2,&array,sizeof(array));

    #endif
    printf("%d %s %d\n",array2.num,array2.str, *array2.data);
    return 0;
}

6、结构体嵌套

#include <stdio.h>
#include <string.h>
struct stu
{
    int num;
    char str[128];
    int data[32];
};
struct date
{
    int year;
    int month;
    int day;
    struct stu ob;
};
int main(int argc, char const *argv[])
{
	struct date lucy = {2023,07,28,{666,"xixi",999}};
    printf("year=%d month=%d day=%d\n",lucy.year,lucy.month,lucy.day);
    printf("str = %s data = %d\n",lucy.ob.str,*lucy.ob.data);
    return 0;
}

结果：

year=2023 month=7 day=28
str = xixi data = 999

7、结构体数组

#include <stdio.h>
#include <string.h>
struct stu
{
    int num;
    char name[128];
};
int main(int argc, char const *argv[])
{
	struct date2 arr[3] = {{100,"qwe"},{232,"asdas"},{7897,"ksjs"}};
    int n = 0;
    n = sizeof(arr)/sizeof(arr[0]);
    
    int i = 0;
    for ( i = 0; i < n; i++)
    {
        printf("%d  %s\n",arr[i].num,arr[i].name);
    } 
    return 0;
}

8、结构体指针变量

结构体指针变量 本质是指针变量 保存的是结构体变量的地址

p->num 根据地址获取num

(*p).num

左边是 地址 使用 ->

左边是 变量 使用 .

#include <stdio.h>
#include <string.h>
struct stu
{
    int num;
    char str[128];
    int data[32];
};
int main(int argc, char const *argv[])
{
	struct stu ob = {100,"xixi",200};
    struct stu *p = &ob;
    printf("%d %s %d\n",p->num,p->str,*(*p).data);
    return 0;
}

9、结构体数组元素的指针

#include <stdio.h>
#include <string.h>
struct data
{
    int num;
    char str[128];
};
void input_stu_data(struct data *arr,int n)
{
    printf("请输入%d个学生信息num arr\n",n);
    int i = 0;
    for ( i = 0; i < n; i++)
    {
        printf("请输入第%d个学生信息：",i+1);
        scanf("%d %s",&(arr+i)->num,arr[i].str);
    }   
    return;
}
void sort_arr_array(struct data *arr ,int n)
{
    int i = 0;
    for ( i = 0; i < n-1; i++)
    {
        int min = i;
        int j = min +1;
        for ( ; j < n; j++)
        {
            if(arr[min].num>arr[j].num)
                min = j;
        }
        if(i != min)
        {
            struct data tmp = arr[min];
            arr[min] = arr[i];
            arr[i] = tmp;
        }
    }
    return;
}
int main(int argc, char const *argv[])
{
    struct data arr[5];
    memset(arr,0,sizeof(arr));

    int n = sizeof(arr)/sizeof(arr[0]);
    //键盘输入
    input_stu_data(arr,n);
    //对结构体数组排序
    sort_arr_array(arr , n);
    int i = 0;
    for ( i = 0; i < n; i++)
    {
        printf("%d %s\n",arr[i].num,arr[i].str);
    }
    return 0;
}

10、结构体的指针指向堆区空间

当结构体有指针成员时须为其申请指针空间

#include <stdio.h>
#include <string.h>
struct stu
{
    int num;
    char *name;
};
int main(int argc, char const *argv[])
{
    struct stu lucy;
    lucy.num = 100;
    lucy.name = (char *)calloc(1,128);//申请空间
    strcpy(lucy.name, "hellow world");
    printf("%d %s\n",lucy.num,lucy.name);
    printf("%c\n",lucy.name[1]);
    lucy.name[1] = 'D';
    printf("%d %s\n",lucy.num,lucy.name);
    //释放lucy.name指向的堆区空间
    if(lucy.name != NULL)
    {
        free(lucy.name);
        lucy.name = NULL;
    }
    return 0;
}

11、结构体深层拷贝

如果结构体中含有指针成员，尽量使用深拷贝

（如果使用浅拷贝，拷贝完成后需要对lucy、ob申请的空间进行释放，由于指向同一空间，就造成空间重复释放，所以使用深拷贝，为ob重新申请一个空间，使用完成后进行释放）

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct stu
{
    int num;
    char *name;
};


int main(int argc, char const *argv[])
{
    struct stu lucy;
    struct stu ob;
    lucy.num = 100;
    lucy.name = (char *)calloc(1,128);//申请空间
    ob.name = (char *)calloc(1,128);
    
    ob.num = lucy.num;
    strcpy(ob.name,lucy.name);
    strcpy(lucy.name, "hellow world");
    printf("%d %s\n",lucy.num,lucy.name);
    printf("%c\n",lucy.name[1]);
    
    lucy.name[1] = 'D';
    printf("%d %s\n",lucy.num,lucy.name);
    //释放lucy.name指向的堆区空间
    if(lucy.name != NULL)
    {
        free(lucy.name);
        lucy.name = NULL;
    }
    if(ob.name != NULL)
    {
        free(ob.name);
        ob.name = NULL;
    }
    return 0;
}

如果结构体中没有指针成员 赋值 不会出现浅拷贝。

如果结构体中有指针成员 赋值 容易造成浅拷贝

12、结构体与结构体成员都在堆区

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct stu
{
    int num;
    char *name;
};
int main(int argc, char const *argv[])
{
    //结构体本身在堆区
    struct stu *p = NULL;
    p = (struct stu *)calloc(1,sizeof(struct stu));

    //为结构体指针成员申请空间
    
    p->name = (char *)calloc(1,128);//(*p).name = (char *)calloc(1,128);
    p->num = 100;
    strcpy(p->name,"hello world");
    printf("%d %s\n",p->num,p->name);
    //先释放成员空间
    if(p->name != NULL)
    {
        free(p->name);
        p->name = NULL;
    }
    //在释放结构体空间
    if(p != NULL)
    {
        free(p);
        p = NULL;
    }
}

13、结构体对齐

(1)结构体自动类型对齐

①确定分配单位（一行分配多少字节）

​ 结构体中最大的基本类型长度决定

②确定成员偏移量

​ 成员偏移量 = 成员本身类型的整数倍

③收尾工作

​ 结构体的总大小 = 分配单位整数倍

#include <stdio.h>
struct array
{
    char str;
    int num;
    char name;
};

int main(int argc, char const *argv[])
{
    struct array A;
    printf("%d\n",sizeof(A));
    printf("%p\n",&A.str);
    printf("%p\n",&A.num);
    printf("%p\n",&A.name);
    return 0;
}

结果：

12
000000000061FDE4
000000000061FDE8
000000000061FDEC

案例1：画出以下结构体的对齐

struct Data
{
    char a;
    short b;
    int c;
    char d;
    short e;
};

在这里插入图片描述

(2)结构体嵌套结构体 自动对齐规则

①确定分配单位（一行分配多少字节）

​ 所有结构体中最大的基本类型长度决定

②确定成员的偏移量

​ 普通成员偏移量 = 成员自身类型的整数倍

​ 结构体成员的偏移量 = 结构体中最大的基本类型整数倍

③收尾工作

​ 结构体成员大小 = 该结构体中最大的基本类型整数倍

​ 结构体的总大小 = 分配单位整倍数

#include <stdio.h>
struct data1
{  
    char str;
    char str2;
    int num;
};
struct data2
{ 
    char str1;
    struct data1 bob;
    short num1;
};

int main(int argc, char const *argv[])
{
    struct data2 bob2;
    printf("%d\n",sizeof(bob2));
    //结构体自动对齐
    printf("%p\n",&bob2.str1);
    printf("%p\n",&bob2.bob.str);
    printf("%p\n",&bob2.bob.str2);
    printf("%p\n",&bob2.bob.num);
    printf("%p\n",&bob2.num1); 
    return 0;
}

结果：

16
000000000061FDE0
000000000061FDE4
000000000061FDE5
000000000061FDE8
000000000061FDEC

(3)结构体强制对齐

​ #prangma pack(value)是指定对齐值

​ valu值为1，2，4，8，16

①确定分配单位（一行分配多少字节）

​ 分配单位 = min（结构体中最大的基本类型，value）

②确定成员的偏移量

​ 成员偏移量 = 成员自身类型的整数倍

③收尾工作

​ 结构体的总大小 = 分配单位整倍数

#include <stdio.h>
#pragma pack(2)
struct array
{
    char str;
    int num;
    char name;
};

int main(int argc, char const *argv[])
{
    struct array A;
    printf("%d\n",sizeof(A));
    printf("%p\n",&A.str);
    printf("%p\n",&A.num);
    printf("%p\n",&A.name);
    return 0;
}

结果：

8
000000000061FDE8
000000000061FDEA
000000000061FDEE

14、位域

在结构体中，以位为单位的成员，称之为位段（位域）

struct A
{
    unsigned int a:2;
    unsigned int b:6;
    unsigned int c:4;
    unsigned int d:3;
    unsigned int e;
}data;

​ a为无符号整型，大小只占2位二进制位

​ 位域可以是unsigned int ，unsigned char

​ 没有非位域隔开的位域 叫相邻位域（a，c）

​ 相邻位域可以压缩

​ 位段的大小不能超过存储单元的大小

​ 不要对位域取地址。

如：a=9 == 1001 ，但a的存储单元只有两位所以只能存储01

​ b=9 == 1001，b的存储单元有6位可以存储1001

#include <stdio.h>

struct A
{
    unsigned int a:2;
    unsigned int b:6;
    unsigned int c:4;
    unsigned char :8;
    unsigned int d:3;
    unsigned int e;
}data;
int main(int argc, char const *argv[])
{
    printf("sizeof(struct A)=%lu\n",sizeof(struct A));
    return 0;
}

无意义位段

#include <stdio.h>
struct A
{
    unsigned char a : 2;
    unsigned char :2;  //两位无意义位段
    unsigned char b : 2;
    unsigned char c : 2;
    //int num;
};

int main(int argc, char const *argv[])
{
    printf("sizeof(struct A)=%lu\n",sizeof(struct A));
}

在这里插入图片描述

#include <stdio.h>
struct B
{
    unsigned char addr : 2;
    unsigned char : 1;
    unsigned char opt :2;
    unsigned char : 1;
    unsigned char data : 2;
};
int main(int argc, char const *argv[])
{
    struct B reg;
    reg.addr = 2;
    reg.opt = 1;
    reg.data = 1;
}

二、共用体

共用体：所有成员共享同一块空间

结构体：所有成员拥有独立空间

union C
{
    int a;
    short b;
    char c;
};

成员a b c共享同一块空间。空间大小 由最大的成员空间决定，即c

union C ob;
ob.a = 10;//空间内容为10
ob.b = 20;//空间内容为20
ob.c = 30;//空间内容为30
ob.a + ob.b + ob.c = 90;

三、枚举enum

枚举：将枚举变量要赋的值一一列举出来

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

enum ha{data1,data2,data3=14,data4};
int main(int argc, char const *argv[])
{
    enum ha num = data2;
    printf("%d\n",num);
}

枚举默认从0开始依次递增即，data1 = 0 ; data2 = 1 ; data3 = 14 ; data4 = 15 ;

四、如有错误欢迎指正
如要转发请告知

（王子变青蛙）
关注
  • 18
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言学习—结构体的定义与使用
98同学吖的博客
12-09 9万+
结构体的定义与使用
C语言基础—结构体
98同学吖的博客
09-11 1695
结构体
C语言基础 之 结构体(8)
qq_38620559的博客
08-04 197
C 语言结构体
c语言结构体讲解,C语言基础之结构体讲解
weixin_29660659的博客
05-19 224
结构体结构体是一种数据结构。 int 、float等是基本数据结构。 数组也是一种数据结构，但是数组存放的数据类型比较单一，结构体解决了数组里不能存放多种类型数据的这种缺陷。1、结构体的声名声名时，不占空间，只是声名了一种数据类型，定义时才分配空间// struct声名结构体是必须有，infor是该种结构体的类型名，可自定义。struct infor{char a[10];float b;int ...
c语言基础语法六——结构体（完结）
热门推荐
zw1996的博客
12-24 28万+
1；关于c语言结构体的引入； 在前面已经介绍了整形（int，long，….），浮点型（flaot，double），字符型（char），还介绍了数组（存储一组具有相同类型的数据），字符串。但是在实际问题中只有这些数据类型是不够的，有时候我们需要其中的几种一起来修饰某个变量，例如一个学生的信息就需要学号（字符串），姓名（字符串），年龄（整形）等等，这些数据类型都不同但是他们又是表示一个整体，要存在联系
C语言基础-结构体基础
恰柠的博客
04-07 767
在C语言中，结构是另一种用户自定义的可用数据类型，它允许您存储不同的数据类型，结构体是属于自定义数据结构。
C语言基础之结构体与联合体
qq_45549336的博客
01-19 144
不是什么文档，也不是教程，只是监督自己打卡学习C语言，记录的只是自己一些小笔记。如有错处，十分感谢您指出！！！ 一、结构体 结构体的内存对齐是根据结构体里面的数据类型来的 #pragma packZ()，可以设置对齐方式 c11支持_Alignas()，_Alignof(结构体.变量名) msvc中使用(#include<stddef.h>),offsetof(结构体,变量名) 二、联合体 和结构体一样，但是会共用 今天学习的很少，批评一下 ...
C语言基础之结构体、枚举
Dream-Just do it !
12-08 681
一、变量类型 1.局部变量  1>定义：在函数（代码块）内部定义的变量  2>作用域：从定义变量的那一行开始，一直到代码块结束  3>生命周期：从定义变量的那一行开始分配存储空间，代码块结束后，就会被回收  4>没有固定的初始值 2.全局变量  1>定义：在函数外面定义的变量  2>作用域：从定义变量的那一行开始，一直到文件结尾（能被后面的所有函数共享）  3>生命周期：程序一启
C语言进阶：结构体的声明
Zbldx的博客
05-02 965
这个其实在我们的熟悉结构体当中已经详细的讲解了连接在这里初识C语言结构体-CSDN博客。
C语言基础 - 结构体.pdf
01-02
结构体变量在内存中占据的总大小是所有成员大小之和，例如`struct student`占据的存储空间是59字节（不同平台可能略有差异，因为对齐规则的影响）。 此外，结构体还可以用于定义结构体数组和指向结构体的指针，这...
C语言作业七 结构体.zip
01-05
在本主题中，我们将深入探讨C语言中...总的来说，这个C语言作业涵盖了结构体、数组、排序算法和文件I/O等核心概念，这些都是C语言编程中的基础且重要的知识点。通过解决这样的问题，可以提升对C语言的理解和编程技能。
学习C语言中的结构体.docx
07-20
学习C语言中的结构体（Struct）需要循序渐进，从基础知识入手，逐步掌握其高级用法。下面是一个系统的学习计划，帮助你全面理解结构体的使用： 1. 理解基本概念 定义：结构体是一种复合数据类型，可以将不同类型的...
SPT-C语言基础-结构体和结构体数组.pptx
09-14
SPT-C语言基础-结构体和结构体数组.pptx
C语言结构体之位域详解
07-25
文章主要对C语言结构体的位域知识进行详细介绍。
C语言 | Leetcode C语言题解之第278题第一个错误的版本
m0_59237910的博客
07-23 443
C语言 | Leetcode C语言题解之第278题第一个错误的版本
C语言中的文件创建、写入与读取
博客
07-22 358
通过上述介绍，我们了解了C语言中文件操作的基本流程和常用函数。掌握文件操作对于编写需要持久化数据的程序至关重要。希望这篇文章能帮助你更好地理解和应用C语言中的文件操作功能。想看视频课程点击这里，跟着郭老师学c语言精品课程。
C语言 定义结构体变量并计算该日在本年中是第几天
Random_N1的博客
07-25 199
3. 计算天数：编写一个函数 `dayOfYear`，该函数接受一个 `Date` 类型的变量作为参数，返回该日期在该年中的第几天。函数首先确定每个月的天数（考虑到闰年二月的不同天数），然后累加至给定日期，计算出天数。2. 判断闰年：编写一个函数 `isLeapYear`，用于判断给定年份是否为闰年。闰年的判断依据是：年份能被4整除但不能被100整除，或者能被400整除。定义一个结构体变量(包括年、月、日)。1. 定义结构体：定义一个名为 `Date` 的结构体，其中包括年、月、日三个成员变量。
Windows图形界面(GUI)-MFC-C/C++ - MFC菜单
最新发布
0xCC说逆向
07-25 446
CMenu类：MFC提供的菜单管理类，用于创建和管理菜单。在Visual Studio中，通过资源视图创建菜单资源。菜单类型：顶层菜单（菜单栏）和弹出式菜单（上下文菜单）。参数包括菜单显示位置、对齐方式和拥有者窗口。创建弹出式菜单资源，设置菜单项。宏将菜单ID与消息处理函数关联。在函数中编写菜单命令的处理逻辑。在指定位置显示弹出式菜单。设置菜单项的ID和标题。选中或取消选中菜单项。类型的消息处理函数。工程项目右键资源文件。
C语言：掌握结构体数组指针基础
在C语言编程入门教程中，我们重点探讨了如何使用指针操作结构体数组。首先，理解结构体（struct）是C语言中自定义的数据类型，可以包含多个不同类型的变量。例如，`struct student`可能包含姓名(name)、数字(num)和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值