精华内容
下载资源
问答
  • c语言 结构体
    2021-05-24 01:01:37

    c语言结构体Tag内容描述:

    1、C语言中不同类型的结构体的指针间可以强制转换,很自由,也很危险。只要理解了其内部机制,你会发现C是非常灵活的。一.结构体声明如何内存的分布,结构体指针声明结构体的首地址,结构体成员声明该成员在结构体中的偏移地址。变量的值是以二进制形式存储在内存中的,每个内存字节对应一个内存地址,而内存存储的值本身是没有整型,指针,字符等的区别的,区别的存在是因为我们对它们有不同的解读,param的值就是一个32位值,并且存储在某个内存单元中,通过这个32位值就能找到param所指向的结构的起始地址,通过这个起始地址和各个结构所。

    2、1.有以下定义和语句:struct student int age;int num; ;struct student stu3=1001,20,1002,19,1003,21;main() struct student *p;p=stu; 则以下不正确的引用是 。A) (p+)-num B) p+ C) (*p).num D) p=&stu.age2.有以下结构体定义:struct example int x;int y; v1;则正确的引用或定义是 。A) example.x=10 B) example v2; v2.x=10;C) struct v2; v2.x=10; D) struct example v2=10;3.对于如下结构体定义,若对变量person的出生年份进行赋值,正确的赋值是 。struct date。

    3、结构体与链表11.1 结构体类型的定义结构体是由C语言中的基本数据类型构成的、并用一个标识符来命名的各种变量的组合,其中可以使用不同的数据类型。1. 结构体类型的定义Struct结构体名类型标识符1 成员名1;类型标识符2 成员名2;类型标识符n 成员名n;;Struct结构体名结构体类型名2. 关于结构体类型的说明:(1) “struct 结构体名”是一个类型名,它和int、float等作用一样可以用来定义变量。(2) 结构体名是结构体的标识符不是变量名,也不是类型名。(3) 构成结构体的每一个类型变量称为结构体成员,它像数组的元素一样,单数组中元素以。

    4、第十一章,结构体与共用体,本章要点,结构体的概念 结构体的定义和引用 结构体数组,11.1 概述 11.2 定义结构体类型变量的方法 11.3 结构体变量的引用 11.4 结构体变量的初始化 11.5 结构体数组 11.指向结构体类型数据的指针 11.7 用指针处理链表 11.8 共用体 11.9 枚举类型 11.10 用typedef定义类型,11.1 概述,问题定义: 有时需要将不同类型的数据组合成一个有机 的整体,以便于引用。如: 一个学生有学号/姓名/性别/年龄/地址等属性 int num; char name20; char sex; int age; int char addr30;,应当把它们组织成一个组合项,在一个组合 。

    5、第10章 结构体,C语言程序设计 - c语言第8章 结构体,2,内 容,结构体类型定义 结构体变量的定义 结构体变量的引用 结构体变量的初始化 结构数组 结构体和指针 结构体与函数 链表,C语言程序设计 - c语言第8章 结构体,3,一、 结构体类型定义 结构体是一种构造数据类型 用途:把不同类型的数据组合成一个整体-自定义数据类型 结构体类型定义,struct 结构体名 类型标识符 成员名; 类型标识符 成员名; . ;,C语言程序设计 - c语言第8章 结构体,4,例 struct student int num; char name20; char sex; int age; float score; char addr30; ;,结构。

    6、第十一章 结构体 11.1 概述 在实际应用中,有不少应用问题如果只采用已学的变量和数组作为数据结构显得很不方便。 例:输入100个学生的学号、姓名和考试成绩,编写程序找出高分者和低分者。 用变量和数组作数据结构可编写程序如下:,main() int i, num, maxnum, minnum; char name20, maxname20, minname20; int score, maxscore, minscore; maxscore=0; minscore=100; for(i=1; imaxscore) maxscore=score; maxnum=num; strcpy(maxname,name); if(scoreminscore) minscore=score; minnum=num; strcpy(minname,name); 输出 ,明显缺点: 变。

    更多相关内容
  • C语言结构体学习总结

    2020-08-03 18:32:05
    该文章讲述了C语言结构体学习.
  • 本文实例为大家分享了C语言结构体实现通讯录的具体代码,供大家参考,具体内容如下 用来存储1000个人的信息的通讯录,每个人的信息包括: 姓名、性别、年龄、电话、住址 程序如下: #include #include #include...
  • 主要介绍了详解C语言结构体中的函数指针,文中对函数指针的基本概念也有讲解,需要的朋友可以参考下
  • 1定义以下结构体类型 struct s { int a; char b; float f; }; 则语句 printf%d,sizeof(struct s) 的输出结果为 A)3 B)7 C)6 D) 4 2当定义一个结构体变量时系统为它分配的内存空间是 A结构中一个成员所需的内存容量 B...
  • 第 9 章 结构体 1定义以下结构体类型 struct s { int a; char b; float f; }; 则语句 printf%d,sizeof(struct s) 的输出结果为 A) 3 B) 7 C) 6 D) 4 2当定义一个结构体变量时系统为它分配的内存空间是 A结构中一个...
  • C语言结构体定义

    2021-01-19 22:46:38
    C语言中的“结构体”其实就相当于其他语言中的“记录”,结构体的定义方法如下:  例如: Struct student { int num;  char name[20];  char sex;  int age;  float score;  char addr[30]; };...
  • 第 9 章 结构体 1定义以下结构体类型 struct s { int a; char b; float f; }; 则语句 printf%d,sizeof(struct s) 3 B) 7 C) 6 D) 4 2当定义一个结构体变量时系统为它分配的内存空间是 结构中一个成员所需的内存容量 ...
  • 这里说的继承有点像C++里的父类和子类,实际上是结构体类型的强制转换,最近看Linux内核源码时经常接触到这种方法,在这里就当作是一个简单的学习吧。
  • 深度剖析C语言结构体

    2020-08-26 14:05:32
    今天小编就为大家分享一篇关于深度剖析C语言结构体,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • C语言教学课件:c语言结构体.ppt
  • 本文主要介绍C语言 结构体数组,这里整理了相关资料及简单示例代码,以便大家学习参考,有兴趣的小伙伴可以看下
  • C语言结构体

    2022-02-16 15:58:55
    C语言提供给用户自定义的数据类型,用户可以根据需求自己构建存储数据的方式。结构体的作用就是整合类型不同,但是互相关联的数据。 比如:可以在里面同时定义int,float,char或者数组。 结构体的定义 struct ...

    结构体的概括

            C语言提供给用户自定义的数据类型,用户可以根据需求自己构建存储数据的方式。结构体的作用就是整合类型不同,但是互相关联的数据。

    比如:可以在里面同时定义int,float,char或者数组。

    结构体的定义

    struct 结构体名
    {
    		数据类型1   成员名1;
    		数据类型2   成员名2;
    		……
    		数据类型n   成员名n;
    };   //注意不要漏掉这里的;
    
    
    比如:
    struct RESULTS
    {
    	char a;
    	int b;
    	float c;
    	int d[10];
    };

    小提示:

    • struct是C语言声明结构体类型时所必须使用的关键字,不能省略
    • 大括弧内的每一个类型声明语句右面都要用分号“;”作为语句结束标记,大括弧外也必须有一个分号“;”作为结构体类型声明语句的结束标志。
    • 结构体名通常用大写

    结构体变量

            由于结构体定义好后,没有变量的名称,所以需要先定义一个变量名。有三种办法:

    1)用结构体名去定义变量        

    struct RESULTS
    {
    	char a;
    	int b;
    	float c;
    	int d[10];
    };
    struct RESULTS str;    //定义结构体变量str

    2)定义结构体的同时定义变量

    struct RESULTS
    {
    	char a;
    	int b;
    	float c;
    	int d[10];
    }str;                  //定义结构体的同时定义结构体变量str

    3)直接定义结构体的变量(这种方法将类型定义和变量的定义合二为一,没有结构体名,以后无法再使用这种结构体定义其他的变量)。也就是说,之后的操作只能使用这个变量名,无法在使用这个结构体定义其他的变量名称(不建议使用)。

    struct
    {
    	char a;
    	int b;
    	float c;
    	int d[10];
    }str;

    结构体数据写入

            使用结构体变量依次输入数据,但某些地方比较麻烦;直接在定义的同时赋予初始值,会根据结构体中成员的位置依次赋值,但是赋值的时候要注意成员的数据类型。

    struct RESULTS
    {
    	char a[10];   //定义一个字符串数组
    	int b;
    	float c;
    }str;            //定义结构体的同时定义结构体变量str
    
    int main()
    {
        strcpy(str.a,"wind");                   //字符串赋值只能采用这个方式
        str.b = 100;                            //使用变量str引用结构体的成员b,并赋值给他
        str.c = 235;                            
    
        //定义的同时赋予初始值,会根据结构体中成员的位置依次赋值
        //赋值的时候要注意成员的类型
        struct RESULTS str1 = {"wifi",2,8};     
        return 0;
    }

    结构体数据输出

        printf("%s\n",str.a);
    	printf("%d\n",str.b);
    	printf("%s\n",str1.a);
    	printf("%.f\n",str1.c);

    上述的结果:

    结构体与数组

            结构体与数组的区别

                    1.数组只能存储同一种数据类型的数据,结构体可以存在多种数据类型。

                    2.结构体定义的是变量,变量可以相互赋值,数组不能相互赋值。

       结构体数组

        //定义结构体数组,并赋予初值
        struct RESULTS th[3] = {{"qiu",7,12},
    							{"cai",8,75},
    							{"shui",1,24}};
    							
        printf("%s\n",th[0].a);
        printf("%d\n",th[2].b);

      结构体数组的结果:

        

     结构体与指针

              之前学习指针与数组的结合,不过加了一点小细节。

    	//定义结构体数组 
    	struct RESULTS th[3] = {{"qiu",7,12},
    							{"cai",8,75},
    							{"shui",1,24}};
    	//定义结构体指针,并让指针指向数组首地址 
    	struct RESULTS *pa = th;
    	
    	//结构体指针访问成员 
    	printf("%s\n",(*pa).a);
    	//如果是地址访问,可使用指向符 
    	printf("%s\n",pa->a);

    结构体的内存大小

    参见《sizeof(结构体)和内存对齐.doc》和《pragma预编译指令》,求结构体sizeof的三个原则:

            1. 结构体变量的首地址是其最宽基本类型成员的整数倍

            2. 结构体每个成员相对于结构体首地址的偏移量, 都是该成员大小的整数倍

            3. 结构体的总大小是其最宽基本类型成员的整数倍

    例如:

            三个数据类型中,最大基本数据类型是4个字节,b+c就有了8个字节的内存,char a[10]按理来说应该占10个字节,但是10不是4的整数倍,所以它应该占12个字节。最后结果就为12+8=20个字节,输出结果就是20。

    展开全文
  • 本文主要介绍C语言 结构体和指针,这里整理了相关资料,并附示例代码和实现结果,以便大家学习参考,希望能帮助学习C语言的朋友
  • 今天小编就为大家分享一篇关于嵌入式项目使用C语言结构体位段特性实现断言宏校验数据范围有效性的方法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • C语言结构体传参

    千次阅读 2022-03-28 18:05:45
    目录C语言结构体传参1. 普通传参1.1 测试代码1.2 测试结果1.3 结果分析2. 单指针传参2.1 修改结构体数据2.1.1 测试代码2.1.2 测试结果2.1.3 结果分析2.2 修改结构体地址2.2.1 测试代码2.2.2 测试结果2.2.3 结果分析3...

    C语言结构体传参

    结构体传参包括三种传参方式

    1. 普通传参:函数接收到结构体参数后,会复制一份原来的结构体作为形参供函数使用,而函数内的任何操作都是对拷贝结构体的修改,不会影响到原本的结构体变化。
    2. 单指针传参:函数接收的是一个结构体的地址,该指针指向的是结构体起始地址,也就相当于传入了结构体内所有变量的地址,函数接收到该结构体指针后,我们就可以根据地址访问结构体中每个变量的真实数据,在函数内对结构体内数据的操作,都会影响到原本结构体内数据的变化
    3. 双指针传参:函数接收的是结构体指针变量的地址,因为一级指针代表的是结构体的地址,在函数中能够操作结构体内的数据,则二级指针指向的是结构体的地址,则同理我们可以根据二级指针访问修改结构体的地址
      即通过一级指针,对结构体内数据的操作会影响到原本结构体内数据的变化
      而通过二级指针,对结构体地址的操作会影响到原本结构体地址的变化,例如为结构体分配空间

    1. 普通传参

    1.1 测试代码

    #include <stdio.h>
    #include <stdlib.h>
    typedef struct Node
    {
        int age;
        struct Node *next;
    } Node;
    
    // 普通传参
    void test(Node p)
    {
    
        printf("test():\n");
    
        printf("数据: p.age = %d\n", p.age);
        printf("地址: p = %x, p->next = %x\n\n", &p, p.next);
    
        // 在函数内定义一个新的结构体
        Node q;
        q.age = 3;
        q.next = NULL;
        
        // 修改结构体内的数据
        p.age = 2;
        p.next = &q;
        printf("数据: p.age = %d\n", p.age);
        printf("地址: p = %x, p->next = %x\n", &p, p.next);
    
        printf("数据: q.age = %d\n", q.age);
        printf("地址: q = %x, q->next = %x\n\n", &q, q.next);
    }
    
    int main()
    {
        Node p;
        p.age = 1;
        p.next = NULL;
    
        printf("main():\n");
        printf("数据: p.age=%d\n", p.age);
        printf("地址: p=%x, p->next=%x\n\n", &p, p.next);
    
        test(p);
    
        printf("main():\n");
        printf("数据: p.age=%d\n", p.age);
        printf("地址: p=%x, p->next=%x\n\n", &p, p.next);
    
        return 0;
    }
    

    1.2 测试结果

    在这里插入图片描述

    1.3 结果分析

    由结果可得,通过普通传参

    • 函数内的操作对原结构体没有影响
    • p结构体的地址、数据均未发生变化

    其流程如下图:
    在这里插入图片描述

    2. 单指针传参

    2.1 修改结构体数据

    2.1.1 测试代码

    #include <stdio.h>
    #include <stdlib.h>
    typedef struct Node
    {
        int age;
        struct Node *next;
    }Node;
    
    // 单指针传参,修改结构体数据
    void ModifyData(Node *p)
    {
        printf("ModifyData:\n");
    
        printf("数据: p.age = %d\n", p->age);
        printf("地址: p = %x, p->next = %x\n\n", p, p->next);
    
        // 在函数内定义一个新的结构体
        Node q;
        q.age = 3;
        q.next = NULL;
        
        // 修改数据(age,next)
        p->age = 2;
        p->next = &q;
    
        printf("数据: p.age = %d\n", p->age);
        printf("地址: p = %x, p->next = %x\n\n", p, p->next);
    
        printf("数据: q.age = %d\n", q.age);
        printf("地址: q = %x, q->next = %x\n\n", &q, q.next);
    
    }
    
    int main()
    {
        Node p;
        p.age = 1;
        p.next = NULL;
    
        printf("main():\n");
        printf("数据: p.age = %d\n", p.age);
        printf("地址: p = %x, p->next = %x\n\n", &p, p.next);
    
        ModifyData(&p);
    
        printf("main():\n");
        printf("数据: p.age = %d\n", p.age);
        printf("地址: p = %x, p->next = %x\n\n", &p, p.next);
    
        return 0;
    }
    

    2.1.2 测试结果

    在这里插入图片描述

    2.1.3 结果分析

    通过ModifyData()函数,由以上测试结果可得

    • p结构体内的数据发生了变化
    • p结构体的原地址没有发生变化

    所以通过结构体的地址,我们可以找到数据的真实地址,进而修改真实数据
    在这里插入图片描述

    2.2 修改结构体地址

    2.2.1 测试代码

    #include <stdio.h>
    #include <stdlib.h>
    typedef struct Node
    {
        int age;
        struct Node *next;
    }Node;
    
    // 单指针传参, 尝试修改结构体地址
    Node *ModifyAddress(Node *p)
    {
        printf("ModifyAddress():\n");
    
        printf("数据: p.age = %d\n", p->age);
        printf("地址: p = %x, p->next = %x\n", p, p->next);
        printf("形参指针变量p的地址 = %x\n\n", &p);
    
        // 尝试为指针重新分配地址,并修改原本结构体内部数据
        p = (Node *)malloc(sizeof(Node));
        p->age = 4;
        p->next = NULL;
    
        printf("数据: p.age = %d\n", p->age);
        printf("地址: p = %x, p->next = %x\n", p, p->next);
        printf("形参指针变量p的地址 = %x\n\n", &p);
    
        // 返回修改后的结构体指针p
        return p;
    }
    
    int main()
    {
        Node p;
        p.age = 1;
        p.next = NULL;
    
        printf("main():\n");
        printf("数据: p.age = %d\n", p.age);
        printf("地址: p = %x, p->next = %x\n\n", &p, p.next);
    
        Node *new_p = ModifyAddress(&p);
    
        printf("main():\n");
        printf("数据: p.age = %d\n", p.age);
        printf("地址: p = %x, p->next = %x\n", &p, p.next);
    
        printf("数据: new_p.age = %d\n", new_p->age);
        printf("地址: new_p = %x, new_p->next = %x\n\n", new_p, new_p->next);
    
        return 0;
    }
    

    2.2.2 测试结果

    在这里插入图片描述

    2.2.3 结果分析

    由以上结果可得,在调用函数体内修改结构体的地址,对原结构体A没有任何影响,因为在调用函数体内修改了形参p的地址,就代表了指针p指向了另一片结构体空间B,如果修改结构体B的内容,这对结构体A来说完全就是八竿子打不着。
    在这里插入图片描述
    由上图我们可以知道,我们在函数内重新开辟了一个新的结构体空间 [731250],而通过动态开辟的空间在函数调用完毕后是不会被释放的,所以在函数调用完毕后,我们仍然可以通过地址 [731250] 访问该结构体的数据,而如果不再使用,我们应该及时释放掉该空间free()

    3. 双指针传参

    3.1 测试代码

    #include <stdio.h>
    #include <stdlib.h>
    typedef struct Node
    {
        int age;
        struct Node *next;
    } Node;
    
    // 双指针传参
    void test(Node **p)
    {
    
        printf("test:\n");
        printf("数据: p.age = %d\n", (*p)->age);
        printf("地址:p = %x, (*p) = %x, (*p)->next = %x\n", p, (*p), (*p)->next);
        printf("指针p的地址 = %x\n\n", &p);
        
        // 在函数内定义一个新的结构体
        Node q;
        q.age = 3;
        q.next = NULL;
        
    
        // 为结构体(*p)重新分配地址,并修改变量数据
        (*p) = (Node *)malloc(sizeof(Node));
        (*p)->age = 2;
        (*p)->next = &q;
        
        printf("数据: p.age = %d\n", (*p)->age);
        printf("地址:p = %x, (*p) = %x, (*p)->next = %x\n", p, (*p), (*p)->next);
        printf("指针p的地址 = %x\n\n", &p);
    
        printf("数据: q.age = %d\n", q.age);
        printf("地址: q = %x, q->next = %x\n\n", &q, q.next);
    }
    
    int main()
    {
    
        Node *p;
        // 为指针结构体p分配地址
        p = (Node *)malloc(sizeof(Node));
        p->age = 1;
        p->next = NULL;
    
        printf("main():\n");
        printf("数据: p.age = %d\n", p->age);
        printf("地址: p = %x, p->next = %x\n", p, p->next);
        printf("指针p的地址 = %x\n\n", &p);
    
        test(&p);
    
        printf("main():\n");
        printf("数据: p.age = %d\n", p->age);
        printf("地址: p = %x, p->next = %x\n", p, p->next);
        printf("指针p的地址 = %x\n\n", &p);
    
        return 0;
    }
    

    3.2 测试结果

    在这里插入图片描述

    3.2 结果分析

    由结果可得,通过双指针传参,我们可以对结构体的数据和地址都做出实际修改。
    其流程如下图:
    在这里插入图片描述

    展开全文
  • C语言结构体(struct)最全的讲解(万字干货)

    万次阅读 多人点赞 2020-02-15 13:16:22
    结构体的定义 结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合,也叫结构。 结构体和其他类型基础数据类型...由于C语言无法操作数据库,所以在项目中通过对结构体内部变量的操作将大量...

    结构体的定义

     

    结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合,也叫结构。

     

    结构体和其他类型基础数据类型一样,例如int类型,char类型只不过结构体可以做成你想要的数据类型。以方便日后的使用。

     

    在实际项目中,结构体是大量存在的。研发人员常使用结构体来封装一些属性来组成新的类型。由于C语言无法操作数据库,所以在项目中通过对结构体内部变量的操作将大量的数据存储在内存中,以完成对数据的存储和操作。

     

    在实际问题中有时候我们需要几种数据类型一起来修饰某个变量。

     

    例如一个学生的信息就需要学号(字符串),姓名(字符串),年龄(整形)等等。

     

    这些数据类型都不同但是他们又是表示一个整体,要存在联系,那么我们就需要一个新的数据类型。

     

    ——结构体,它就将不同类型的数据存放在一起,作为一个整体进行处理。


    结构体在函数中的作用不是简便,其最主要的作用就是封装。封装的好处就是可以再次利用。让使用者不必关心这个是什么,只要根据定义使用就可以了。


    结构体的大小不是结构体元素单纯相加就行的,因为我们现在主流的计算机使用的都是32Bit字长的CPU,对这类型的CPU取4个字节的数要比取一个字节要高效,也更方便。所以在结构体中每个成员的首地址都是4的整数倍的话,取数据元素时就会相对更高效,这就是内存对齐的由来。每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragmapack(n),n=1,2,4,8,16来改变这一系数,其中的n就是你要指定的“对齐系数”。
     

    规则


    1、数据成员对齐规则:结构(struct)(或联合(union))的数据成员,第一个数据成员放在offset为0的地方,以后每个数据成员的对齐按照#pragmapack指定的数值和这个数据成员自身长度中,比较小的那个进行。


    2、结构(或联合)的整体对齐规则:在数据成员完成各自对齐之后,结构(或联合)本身也要进行对齐,对齐将按照#pragmapack指定的数值和结构(或联合)最大数据成员长度中,比较小的那个进行。


    3、结合1、2可推断:当#pragmapack的n值等于或超过所有数据成员长度的时候,这个n值的大小将不产生任何效果。


    在C语言中,可以定义结构体类型,将多个相关的变量包装成为一个整体使用。在结构体中的变量,可以是相同、部分相同,或完全不同的数据类型。在C语言中,结构体不能包含函数。在面向对象的程序设计中,对象具有状态(属性)和行为,状态保存在成员变量中,行为通过成员方法(函数)来实现。C语言中的结构体只能描述一个对象的状态,不能描述一个对象的行为。在C++中,考虑到C语言到C++语言过渡的连续性,对结构体进行了扩展,C++的结构体可以包含函数,这样,C++的结构体也具有类的功能,与class不同的是,结构体包含的函数默认为public,而不是private。

     

    结构体声明

     

    //声明一个结构体 struct book {char title[MAXTITL];//一个字符串表示的titile 题目 ;char author[MAXAUTL];//一个字符串表示的author作者 ;float value;//一个浮点型表示的value价格;};//注意分号不能少,这也相当于一条语句;

     

    这个声明描述了一个由两个字符数组和一个float变量组成的结构体。

     

    但是注意,它并没有创建一个实际的数据对象,而是描述了一个组成这类对象的元素。

     

    因此,我们有时候也将结构体声明叫做模板,因为它勾勒出数据该如何存储,并没有实例化数据对象。

     

    下面介绍一下上面的结构体声明;

     

    1、首先使用关键字struct,它表示接下来是一个结构体。

     

    2、后面是一个可选的标志(book),它是用来引用该结构体的快速标记。

         

    因此我们以后就可以这样创建数据对象

     

    struct book library;//把library设为一个可以使用book结构体的结构体变量,则library这个变量就包含了其book结构体中的所有元素

     

    3、接下来就是一个花括号,括起了结构体成员列表,及每个成员变量,使用的都是其自己的声明方式来描述,用分号来结束描述;

     

    例如:char title[MAXTITL];字符数组就是这样声明的,用分号结束;

    注意:其中每个成员可以使用任何一种C数据结构甚至是其他的结构体,也是可以的;

     

    4、在结束花括号后的分号表示结构体设计定义的结束。

     

    关于其struct声明的位置,也就是这段代码要放到哪里。同样这也是具有作用域的。

     

    这种声明如果放在任何函数的外面,那么则可选标记可以在本文件中,该声明的后面的所有函数都可以使用。

     

    如果这种声明在某个函数的内部,则它的标记只能在内部使用,并且在其声明之后;

     

     

    关于我们不断说的,标记名是可选的,那么我们什么时候可以省略,什么时候一定不能省略呢?

     

    如果是上面那种声明定义的方法,并且想在一个地方定义结构体设计,而在其他地方定义实际的结构体变量,那么就必须使用标记;

     

    可以省略,设计的同时就创建该结构体变量,但是这种设计是一次性的。

     

    一般格式就是:

     

    struct 结构体名(也就是可选标记名){    成员变量;};//使用分号表示定义结束。

     

    C语言结构体定义的三种方式


    1、最标准的方式:
     

    #include <stdio.h>struct student //结构体类型的说明与定义分开。声明{int age;  /*年龄*/float score; /*分数*/char sex;   /*性别*/};int main (){struct student a={ 20,79,'f'}; //定义printf("年龄:%d 分数:%.2f 性别:%c\n", a.age, a.score, a.sex );return 0;

     

    2、不环保的方式
     

    #include <stdio.h>struct student /*声明时直接定义*/{int age;  /*年龄*/float score;  /*分数*/char sex;   /*性别*//*这种方式不环保,只能用一次*/} a={21,80,'n'};int main (){printf("年龄:%d 分数:%.2f 性别:%c\n", a.age, a.score, a.sex );


    3、最奈何人的方式
     

    #include <stdio.h>struct   //直接定义结构体变量,没有结构体类型名。这种方式最烂{int age;float score;char sex;} t={21,79,'f'};int main (){printf("年龄:%d 分数:%f 性别:%c\n", t.age, t.score, t.sex);return 0;}return 0;}}

     

    定义结构体变量

     

    之前我们结构体类型的定义(结构体的声明)只是告诉编译器该如何表示数据,但是它没有让计算机为其分配空间。

     

    我们要使用结构体,那么就需要创建变量,也就是结构体变量;

     

    创建一个结构体变量;
     

    •  
    struct book library;

     

    看到这条指令,编译器才会创建一个结构体变量library,此时编译器才会按照book模板为该变量分配内存空间,并且这里存储空间都是以这个变量结合在一起的。

     

    这也是后面访问结构体变量成员的时候,我们就要用到结构体变量名来访问。

     

    分析:

     

    struct book的作用:

     

    在结构体声明中,struct book所起到的作用就像int,,,,等基础数据类型名作用一样。

     

    •  
    struct book s1,s2,*ss;

     

    定义两个struct book结构体类型的结构体变量,还定义了一个指向该结构体的指针,其ss指针可以指向s1,s2,或者任何其他的book结构体变量。

     

    其实;

     

    •  
    struct book library;

     

    等效于;

     

    struct book{ char … …. ….. }librar;

     


    这两种是等效的,只是第一种可以减少代码的编写量;

     

    现在还是回到刚才提及的那个问题,可选标志符什么时候可以省略;

     

    其一;
     

    struct{    char title[MAXTITL];     char author[MAXAUTL];float value;}library;


    //注意这里不再是定义声明结构体类型,而是直接创建结构体变量了,这个编译器会分配内存的;


    //这样的确可以省略标识符也就是结构体名,但是只能使用一次;因为这是;声明结构体的过程和定义结构体变量的过程和在了一起;并且个成员变量没有初始化的;


    //如果你想多次使用一个结构体模块,这样子是行不通的;

     

    其二;

     

    用typedef定义新类型名来代替已有类型名,即给已有类型重新命名;
     

    一般格式为;typedef 已有类型 新类型名;

     

    typedef int Elem; typedef struct{    int date;    .....    .....}STUDENT;STUDENT stu1,stu2;

     

     

    总结一下关于结构体变量的定义;

     

    1、先定义结构体类型后再定义结构体变量;

     

    格式为;struct 结构体名 变量名列表;
     

    •  
    struct book s1,s2,*ss;//注意这种之前要先定义结构体类型后再定义变量;


    2、在定义结构体类型的同时定义结构体变量;

     

    格式为;

     

    struct 结构体名{成员列表;}变量名列表;//这里结构体名是可以省的,但尽量别省;struct book{char title[MAXTITL];//一个字符串表示的titile 题目 ;char author[MAXAUTL];//一个字符串表示的author作者 ;float value;//一个浮点型表示的value价格;}s1,s2

     

    直接定义结构体类型变量,就是第二种中省略结构体名的情况;

     

    这种方式不能指明结构体类型名而是直接定义结构体变量,并且在值定义一次结构体变量时适用,无结构体名的结构体类型是无法重复使用的。

     

    也就是说,后面程序不能再定义此类型变量了,除非再写一次重复的struct。

    对于结构体变量的初始化

     

    先回忆一下关于基本数据类型和数组类型的初始化;
     

    •  
    •  
    int a = 0;int array[4] = {1,2,3,4};//每个元素用逗号隔开

     

    回忆一下数组初始化问题;

     

     

    再回到结构体变量的初始化吧?

     

    关于结构体变量的初始化与初始化数组类似;

     

    也是使用花括号括起来,用逗号分隔的初始化好项目列表,注意每个初始化项目必须要和要初始化的结构体成员类型相匹配。

     

    struct book s1={//对结构体初始化         "yuwen",//title为字符串         "guojiajiaoyun",//author为字符数组         22.5    //value为flaot型     };//要对应起来,用逗号分隔开来,与数组初始化一样;

     

    加入一点小知识;关于结构体初始化和存储类时期的问题;如果要初始化一个具有静态存储时期的结构体,初始化项目列表中的值必须是常量表达式;

     

    注意如果在定义结构体变量的时候没有初始化,那么后面就不能全部一起初始化了;意思就是:

     

    /这样是可以的,在定义变量的时候就初始化了;struct book s1={//对结构体初始化         "guojiajiaoyun",//author为字符数组           "yuwen",//title为字符串           22.5    };/这种就不行了,在定义变量之后,若再要对变量的成员赋值,那么只能单个赋值了;struct book s1;    s1={          "guojiajiaoyun",//author为字符数组           "yuwen",//title为字符串           22.5  };//这样就是不行的,只能在定义的时候初始化才能全部赋值,之后就不能再全体赋值了,只能单个赋值;
    只能;
    s1.title = "yuwen";........//单个赋值;

     

    对于结构体的指定初始化;

     

     

    访问结构体成员

     

    结构体就像一个超级数组,在这个超级数组内,一个元素可以是char类型,下个元素就可以是flaot类型,再下个还可以是int数组型,这些都是存在的。

     

    在数组里面我们通过下标可以访问一个数组的各个元素,那么如何访问结构体中的各个成员呢?

     

    用结构成员运算符点(.)就可以了;

     

    结构体变量名.成员名; 

     

    注意,点其结合性是自左至右的,它在所有的运算符中优先级是最高的;

     

    例如,s1.title指的就是s1的title部分,s1.author指的就是s1的author部分,s1.value指的就是s1的value部分。

     

    然后就可以像字符数组那样使用s1.title,像使用float数据类型一样使用s1.value;

     

    注意,s1;虽然是个结构体,但是s1.value却是float型的。

     

    因此s1.value就相当于float类型的变量名一样,按照float类型来使用;

     

    例如;printf(“%s\n%s\n%f”,s1.title,s1.author,s1.value);//访问结构体变量元素

     

    注意scanf(“%d”,&s1.value); 这语句存在两个运算符,&和结构成员运算符点。

     

    按照道理我们应该将(s1。value括起来,因为他们是整体,表示s1的value部分)但是我们不括起来也是一样的,因为点的优先级要高于&。

     

    如果其成员本身又是一种结构体类型,那么可以通过若干个成员运算符,一级一级的找到最低一级成员再对其进行操作;

     

    结构体变量名.成员.子成员………最低一级子成员;

     

    struct date{    int year;    int month;    int day;};struct student{    char name[10];    struct date birthday;}student1;//若想引用student的出生年月日,可表示为;student.brithday.year;brithday是student的成员;year是brithday的成员;

     

    整体与分开

     

    可以将一个结构体变量作为一个整体赋值给另一相同类型的结构体变量,可以到达整体赋值的效果;这个成员变量的值都将全部整体赋值给另外一个变量;

     

    不能将一个结构体变量作为一个整体进行输入和输出;在输入输出结构体数据时,必须分别指明结构体变量的各成员;

     

     

    小结:除去“相同类型的结构体变量可以相互整体赋值”外,其他情况下,不能整体引用,只能对各个成员分别引用;

     

    结构体长度

     

     

    数据类型的字节数:
     

    16位编译器

    char :1个字节
    char*(即指针变量): 2个字节
    short int : 2个字节
    int:  2个字节
    unsigned int : 2个字节
    float:  4个字节
    double:   8个字节
    long:   4个字节
    long long:  8个字节
    unsigned long:  4个字节

    32位编译器

    char :1个字节
    char*(即指针变量): 4个字节(32位的寻址空间是2^32, 即32个bit,也就是4个字节。同理64位编译器)
    short int : 2个字节
    int:  4个字节
    unsigned int : 4个字节
    float:  4个字节
    double:   8个字节
    long:   4个字节
    long long:  8个字节
    unsigned long:  4个字节

     

    那么,下面这个结构体类型占几个字节呢?
     

    typedef struct{  char addr;  char name;  int  id;}PERSON;

     

    通过printf("PERSON长度=%d字节\n",sizeof(PERSON));可以看到结果:
     

     

    结构体字节对齐

     

     

    通过下面的方式,可以清楚知道为什么是8字节。
     

    1、定义20个char元素的数组
     

    •  
    char ss[20]={0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29};

     

    2、定义结构体类型的指针ps指向ss数组
     

    •  
    PERSON *ps=(PERSON *)ss;

     

    3、打印输出各个成员
     

    •  
    printf("0x%02x,0x%02x,0x%02x\n",ps->addr,ps->name,ps->id);printf("PERSON长度=%d字节\n",sizeof(PERSON));


     

    可以看到addr和name都只占一个字节,但是未满4字节,跳过2字节后才是id的值,这就是4字节对齐。结构体成员有int型,会自动按照4字节对齐。

     

     

    把结构体成员顺序调换位置,
     

    typedef struct{  char addr;  int  id;  char name;}PERSON;

     

     

    输出:

     

     


    按照下面的顺序排列:
     

    typedef struct{    int  id;  char addr;  char name;}PERSON;

     


    输出:
     


    可见,结构体成员顺序优化,可节省空间。

     

    如果全部成员都是char型,会按照1字节对齐,即
     

    typedef struct{    char addr;  char name;    char  id;}PERSON;

     

     

    输出结果:

     

     

     

    结构体嵌套

     

     

    结构体嵌套结构体方式:
     

    typedef struct{    char addr;  char name;    int  id;}PERSON;typedef struct{    char age;  PERSON  ps1;}STUDENT;

     

     

    先定义结构体类型PERSON,再定义结构体STUDENT,PERSON作为它的一个成员。

     

    按照前面的方法,打印各成员的值。
     

    1、定义STUDENT 指针变量指向数组ss
     

    •  
    STUDENT *stu=(STUDENT *)ss;

     

    2、打印输出各成员和长度

    •  
    •  
    printf("0x%02x,0x%02x,0x%02x,0x%02x\n",stu->ps1.addr,stu->ps1.name,stu->ps1.id,stu->age);printf("STUDENT长度=%d字节\n",sizeof(STUDENT));

     


    调换STUDENT成员顺序,即
     

    typedef struct{    PERSON  ps1;  char age;}STUDENT;

     


    输出结果:
     

     

    结构体嵌套其实没有太意外的东西,只要遵循一定规律即可:

     

    //对于“一锤子买卖”,只对最终的结构体变量感兴趣,其中A、B也可删,不过最好带着  struct A{            struct B{               int c;           }  b;  }  a;  //使用如下方式访问:a.b.c = 10;

     

    特别的,可以一边定义结构体B,一边就使用上:
     

     struct A{         struct B{                  int c;          }b;           struct B sb;   }a;  

     

    使用方法与测试:

     

    a.b.c = 11;  printf("%d\n",a.b.c);  a.sb.c = 22;  printf("%d\n",a.sb.c);

     


    结果无误。   

     

    但是如果嵌套的结构体B是在A内部才声明的,并且没定义一个对应的对象实体b,这个结构体B的大小还是不算进结构体A中。

     

    (结构体长度、结构体字节对齐、结构体嵌套内容来源于公众号“0基础学单片机”,作者:森林木,感谢原作者的分享)

     

    占用内存空间

     

    struct结构体,在结构体定义的时候不能申请内存空间,不过如果是结构体变量,声明的时候就可以分配——两者关系就像C++的类与对象,对象才分配内存(不过严格讲,作为代码段,结构体定义部分“.text”真的就不占空间了么?当然,这是另外一个范畴的话题)。

     

    结构体的大小通常(只是通常)是结构体所含变量大小的总和,下面打印输出上述结构体的size:

     

    •  
    •  
    printf("size of struct man:%d\n",sizeof(struct man));  printf("size:%d\n",sizeof(Huqinwei));

     

    结果毫无悬念,都是28:分别是char数组20,int变量4,浮点变量4.   

     

    下边说说不通常的情况

     

    对于结构体中比较小的成员,可能会被强行对齐,造成空间的空置,这和读取内存的机制有关,为了效率。通常32位机按4字节对齐,小于的都当4字节,有连续小于4字节的,可以不着急对齐,等到凑够了整,加上下一个元素超出一个对齐位置,才开始调整,比如3+2或者1+4,后者都需要另起(下边的结构体大小是8bytes),相关例子就多了,不赘述。

     

    struct s  {  char a;  short b;  int c;  }

     

     

    相应的,64位机按8字节对齐。不过对齐不是绝对的,用#pragma pack()可以修改对齐,如果改成1,结构体大小就是实实在在的成员变量大小的总和了。

     

    和C++的类不一样,结构体不可以给结构体内部变量初始化,。

    如下,为错误示范:

     

    #include<stdio.h>  //直接带变量名struct stuff{  //      char job[20] = "Programmer";  //      char job[];  //      int age = 27;  //      float height = 185;  };

     

     

    PS:结构体的声明也要注意位置的,作用域不一样。

     

    C++的结构体变量的声明定义和C有略微不同,说白了就是更“面向对象”风格化,要求更低。

     

    为什么有些函数的参数是结构体指针型

     

    如果函数的参数比较多,很容易产生“重复C语言代码”,例如:
     

    int get_video(char **name, long *address, int *size, time_t *time, int *alg){    ...}int handle_video(char *name, long address, int size, time_t time, int alg){    ...}int send_video(char *name, long address, int size, time_t time, int alg){    ...}

     

    上述C语言代码定义了三个函数:get_video() 用于获取一段视频信息,包括:视频的名称,地址,大小,时间,编码算法。


    然后 handle_video() 函数根据视频的这些参数处理视频,之后 send_video() 负责将处理后的视频发送出去。下面是一次调用:
     

    char *name = NULL;long address;int size, alg;time_t time;
    get_video(&name, &address, &size, &time, &alg);handle_video(name, address, size, time, alg);send_video(name, address, size, time, alg);

     

    从上面这段C语言代码来看,为了完成视频的一次“获取”——“处理”——“发送”操作,C语言程序不得不定义多个变量,并且这些变量需要重复写至少三遍。
     

    虽说C语言程序的代码风格因人而异,但是“重复的代码”永远是应尽力避免的,原因本专栏已经分析多次。不管怎么说,每次使用这几个函数,都需要定义很多临时变量,总是非常麻烦的。所以,这种情况下,完全可以使用C语言的结构体语法:
     

    struct video_info{    char *name;    long address;    int size;    int alg;    time_t time;};

     

    定义好 video_info 结构体后,上述三个C语言函数的参数可以如下写,请看:
     

    int get_video(struct video_info *vinfo){    ...}int handle_video(struct video_info *vinfo){    ...}int send_video(struct video_info *vinfo){    ...}

     

    修改后的C语言代码明显精简多了,在函数内部,视频的各个信息可以通过结构体指针 vinfo 访问,例如:
     

    printf("video name: %s\n", vinfo->name);long addr = vinfo->address;int size = vinfo->size;

     

    事实上,使用结构体 video_info 封装视频信息的各个参数后,调用这几个修改后的函数也是非常简洁的:
     

    struct video_info vinfo = {0};
    get_video(&vinfo);handle_video(&vinfo);send_video(&vinfo);

     

    从上述C语言代码可以看出,使用修改后的函数只需定义一个临时变量,整个代码变得非常精简。
     

    读者应该注意到了,修改之前的 handle_video() 和 send_video() 函数原型如下:
     

    •  
    •  
    int handle_video(char *name, long address, int size, time_t time, int alg);int send_video(char *name, long address, int size, time_t time, int alg);

     

    根据这段C语言代码,我们知道 handle_video() 和 send_video() 函数只需要读取参数信息,并不再修改参数,那为什么使用结构体 video_info 封装数据,修改后的 handle_video() 和 send_video() 函数参数是 struct video_info  *指针型呢?
     

    •  
    •  
    int handle_video(struct video_info *vinfo);int send_video(struct video_info *vinfo);

     

    既然 handle_video() 和 send_video() 函数只需要读取参数信息,那我们就无需再使用指针型了呀?的确如此,这两个函数的参数直接使用 struct video_info 型也是可以的:
     

    int handle_video(struct video_info vinfo){    ...}int send_video(struct video_info vinfo){    ...}

     

    似乎这种写法和使用  struct video_info  *指针型 参数的区别,无非就是函数内部访问数据的方式改变了而已。但是,如果读者能够想到我们之前讨论过的C语言函数的“栈帧”概念,应该能够发现,使用指针型参数的 handle_video() 和 send_video() 函数效率更好,开销更小。

     

     

    嵌入式开发中,C语言位结构体用途详解

     

    在嵌入式开发中,经常需要表示各种系统状态,位结构体的出现大大方便了我们,尤其是在进行一些硬件层操作和数据通信时。但是在使用位结构体的过程中,是否深入思考一下它的相关属性?是否真正用到它的便利性,来提高系统效率?

     

    下面将进行一些相关实验(这里以项目开发中的实际代码为例):

     

    1.位结构体类型设计
     

    [cpp] view plain copy print?//data structure except for number structure  typedef struct symbol_struct  {  uint_32 SYMBOL_TYPE     :5;  //data type,have the affect on "data display type"  uint_32 reserved_1      :4;  
    uint_32 SYMBOL_NUMBER  :7;  //effective data number in one element  uint_32 SYMBOL_ACTIVE  :1;//symbol active status     uint_32 SYMBOL_INDEX   :8;  //data index in norflash,result is related to "xxx_BASE_ADDR"  uint_32 reserved_2     :8;  
    }SYMBOL_STRUCT,_PTR_ SYMBOL_STRUCT_PTR;

     

    分析:这里定义了一个位结构体类型SYMBOL_STRUCT,那么用该类型定义的变量都哪些属性呢?
     

    看下面运行结果:

     

     

    WORDS是定义的另一个外层类型定义封装,可以把它当作变量来看待。WORDS变量里前5个数据域的地址都是0x1ffff082c,而reserved_2的地址0x1fff0830,紧接着的PressureState变量是0x1fff0834。
     

    开始以为:reserved_1和SYMBOL_TYPE不在一个地址上,因为他们5+4共9位,超过了1个字节地址,但实际他们共用首地址了;而且reserved_2只定义了8位,竟然实际占用了4个字节(0x1fff0834 - 0x1fff0830),我本来是想让他占用1个字节的。WORDS整体占了8个字节(0x1fff0834 - 0x1fff082c),设计时分析占用5个字节

     

    (SYMBOL_TYPE 1个;reserved_1 1个;SYMBOL_NUMBER+SYMBOL_ACTIVE 1个;SYMBOL_INDEX 1个;reserved_2 1个)。

     

    uint_32  reserved_2   : 8;  占用4个字节,估计是uint_32在起作用,而这里写的8位,只是我使用的有效位数,另外24位空闲,如果在下面再定义一个uint_32 reserved_3   : 8,地址也是一样的,都是以uint_32为单位取地址。

     

    同理,上面的5个变量,共用一个地址就不足为奇了。而且有效位的分配不是连续进行的,例如SYMBOL_TYPE+reserved_1 共9位,超过了一个字节,索性系统就分配两个字节给他们,每人一个;SYMBOL_NUMBER+SYMBOL_ACTIVE 共8位,一个字节就能搞定。

     

    2、修改数据结构,验证上述猜想

     

    [cpp] view plain copy print?//data structure except for number structure  typedef struct symbol_struct  {  uint_8 SYMBOL_TYPE    :5;  //data type,have the affect on "data display type"  uint_8 reserved_1     :4;  
    uint_8 SYMBOL_NUMBER   :7;  //effective data number in one element  uint_8 SYMBOL_ACTIVE   :1; //symbol active status  
    uint_8 SYMBOL_INDEX    :8;  //data index in norflash,result is related to "xxx_BASE_ADDR"  uint_8 reserved_2      :8;      }SYMBOL_STRUCT,_PTR_ SYMBOL_STRUCT_PTR;

     

    地址数据如下:

     

     

    当换成uint_8后,可以看到地址空间占用大大减小,reserved_2只占用1个字节(0x1fff069f - 0x1fff069e),其他变量也都符合上面的结论猜想。但是,注意看上面黄色和红色的语句,总感觉有些勉强,那么我又会想,前两个变量数据域是9位,那么他们实际上是不是真正的独立呢?虽然在uint_8上面他们是不同的地址,在uint_32的时候是不是也是不同的地址空间呢?

     

    3、分析结构体内部的数据域是否连续,看下图及结果

     


    本来假设: 由前2次试验的结论,一共占用8个字节,节空间占用:(2+4)+(4+4)+(2+2+4)+(2+2)+(6)。可是,实际效果并不是想的那样。实际只占用了4个字节,系统并没有按照预想的方式,为RESERVED变量分配4个字节。

     

    分析:
     

    这些数据域,整体相加一共32位,占用4个字节(不考虑数据对齐问题)。而实际确实是占用了4个字节,唯一的原因就是:这些数据域以紧凑的方式链接,没有任何空闲位。实际是不是这样呢?

     

    看下图和结果:

     


    这里为了验证是否紧凑链接,用到了一个union数据,后面会讲到用union不会对数据组织方式有任何影响,看实际与上次的一样,也能分析出来。

     

    主要是分析第2和第3个数据域是否紧密链接的。OBJECT_ACTIVE_PRE赋值0b00001111,NUMBER_ACTIVE赋值0b00000101,其他变量都是0,看到WORD数值0b1011111000000。分析WORD数据,可以看到这款MCU还是小端格式(高位数据在高端,低位数据在低端,这里不对大小端进行讨论),断开数据变成(0)10111 11000000,正好是0101+1111,OBJECT_ACTIVE_PRE数据域,跨越了两个字节,并不是刚开始设想的那样。这就印证了上面的紧密链接的结论,也符合数据结果输出。

     

    4、再次实验,分析数据是否紧密链接,看下图和结果

     


    可以看到,RESERVED数据域已经不再属于4个地址空间内了(0x1fff0518 - 0x1fff051b),但是他们整体加起来还是32个位域。这说明数据中间肯定有“空隙”存在了,空隙在哪?看一下NUMBER_STATE,如果紧密的话它应该跟NUMBER_ACTIVE在同一个字节地址上,可是他们并不在一块,“空隙”就存在这里。

     

    这两个结构体有什么不一样?数据类型不一致,一个是uint_32,一个是uint_8。综上所述:数据类型影响的是编译器在分配物理空间时的大小单位,uint_32是以4个字节为单位,而后面的位域则是指在已经分配好的物理空间内部再紧凑的方式分配数据位,当物理空间不能满足位域时,那么系统就再次以一定大小单位进行物理空间分配,这个单位就是上面提到的uint_8或者uint_32。

     

    举例:上面uint_32时,这些位域不管是不是在一个字节地址上,如果能够紧凑的分配在一个4字节空间大小上,就直接紧凑分配。如果不能则继续分配(总空间超过4字节),则再次以4字节空间分配,并把新的位域建立在新的地址空间上(条目1上的就是)。当uint_8时,很明显如果位域不能紧凑的放在一个字节空间上,那么就从新分配新的1字节空间大小,道理是一样的。

     

    5、结构体组合、共用体组合是否影响上述结论

     

     


    可以看到,系统并没有因为位结构体上面有uint_4的4字节变量或者共用体类型,就改变分配策略把位域都挤到4字节之内,看来他们是没有什么实质性联系的。这里把uint_32改成uint_8,或者把位结构体也替换掉,经我试验证明,都是没有任何影响的。

     

    总结:

     

    1、在操作位结构体时,要关注变量的位域是否在一个变量类型(uint_32或者uint_8)上,判断占用空间大小

     

    2、除了位域,还要关注变量定义类型,因为编译器空间分配始终是按类型分配的,位域只是指出了有效位(小于类型占用空间),而且如果位域大于类型空间,编译器直接报错(如 uint_8  test  :15,可自行实验)。

     

    3、这两个因素都影响变量占用空间大小,具体可以结合调试窗口,通过地址分配分析判断

     

    4、最重要的一点:上面的所有结果,都是基于我自己的CodeWarrior10.2和MQX3.8分析出来的,不同的编译环境和操作系统,都可能会有不同的结果;而且即便是环境相同,编译器的配置和优化选项都有可能影响系统处理结果。结论并不重要,主要想告诉大家这一块隐藏陷阱,在以后处理类似问题时,要注意分析避让并掌握方法。

    展开全文
  • 精心整理 第 9 章结构体 1定义以下结构体类型 structs { inta; charb; floatf; }; 则语句 printf%d,sizeof(structs) 的输出结果为 A)3 B)7 C)6 D)4 2当定义一个结构体变量时系统为它分配的内存空间是 A结构中一个...
  • c语言结构体学习整理(结构体初始化,结构体指针)

    万次阅读 多人点赞 2018-11-01 20:22:12
    c语言中交换两个结构体的值(结构体指针) 1关于语言的结构体: 首先我们为什么要用到结构体,我们都已经学了很多int char …等类型还学到了同类型元素构成的数组,以及取上述类型的指针,在一些小应用可以灵活...
  • 第9 章 结构体 1定义以下结构体类型 struct s { int a; char b; float f; }; 则语句printf%d,sizeof(struct s)的输出结果为 A) 3 B) 7 C) 6 D) 4 2 当定义一个结构体变量时系统为它分配的内存空间是 A结构中一个成员...
  • c 语言结构体程序设计心得体会 C 语言是在国内外广泛使用的一种计算机语言下面是 为大家准备的希望大家喜欢 ! 范文1 学习C语言已经一年多对 C也算得上半个 入门者期间也写过一些自娱自乐的代码其实个人认为无 论学习...
  • C语言结构体对齐详解

    千次阅读 2022-04-12 22:39:19
    详解如何快速判断C语言结构体占用空间大小
  • C语言结构体详解

    2022-06-01 22:25:24
    C语言结构体详解
  • C语言 结构体与位段

    2022-03-16 22:42:09
    C语言 结构体与位段一、结构体1.1 结构体是什么1.2 结构体声明1.3 结构体的特殊声明1.4 结构体的成员1.4 结构体变量的定义和初始化 一、结构体 1.1 结构体是什么  在之前C语言学习中我们接触了整形类型、浮点型类型...
  • C语言结构体知识汇总

    2018-01-15 12:28:35
    C语言结构体部分内容详解包括结构体定义及使用,结构体函数的定义及使用,指向结构体的指针

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 185,662
精华内容 74,264
关键字:

c语言 结构体

友情链接: 今日头条-微信.zip