精华内容
下载资源
问答
  • #include <stdio.h> typedef struct Student { char name[64]; int id; }Student; typedef struct Teacher ...//1 结构体中套一个结构体 //2 结构体的指针 //3 结构中套一个 自己类型的结构体元素==err
    #include <stdio.h>
    
    typedef struct Student 
    {
    	char name[64];
    	int id;
    
    }Student;
    
    typedef struct Teacher 
    {
    	char name[64];
    	int id;
    	char *p;
    	char **p2;
    	Student s1;
    	Student *p3;
    }Teacher;
    
    //1 结构体中套一个结构体
    //2	 			结构体的指针
    //3 结构中套一个 自己类型的结构体元素==error
    //4 结构体中 套一个 指向自己类型的指针
    
    //数据类型本质:固定大小内存块的别名 
    
    /*
    typedef struct AdvTeacher 
    {
    	char name[64];
    	int id;
    	struct AdvTeacher AdvTeacher;
    }AdvTeacher;  //在自己类型大小 还没有确定的情况下 引用自己类型的元素 是不正确的
    //结构体不能嵌套定义 (确定不了数据类型的内存大小,分配不了内存)
    */
    
    typedef struct AdvTeacher2 
    {
    	char name[64];
    	int id;
    	struct AdvTeacher2 *p2;
    }AdvTeacher;
    
    int main(int argc, const char * argv [])
    {
    	Teacher t1;
    
        printf("%lu, %lu\n", sizeof(char *), sizeof(t1));
        
    	return 0;
    }
    

    测试结果

    在这里插入图片描述

    展开全文
  • c 结构体嵌套引用解读

    万次阅读 2013-06-23 11:11:28
    背景:在Linux内核系统中经常能看到如下例1形式的结构体嵌套引用,在代码追踪、走读的时候令人费解。所以在弄清楚结构体的嵌套调用就很有用处了。 概念:   1、结构的自引用  在一个结构内部包含一个类型为...

    c  结构体的嵌套引用解读

    背景:在Linux内核系统中经常能看到如下例1形式的结构体嵌套引用,在代码追踪、走读的时候令人费解。所以在弄清楚结构体的嵌套调用就很有用处了。

    概念: 

                     1、结构的自引用

            在一个结构内部包含一个类型为该结构体自身的成员是不合法的。

    如下: 

    struct SELF_REF1 {

    int  a;

    struct  SELF_REF1 b;

    int  c;

    };

    引用成员b是另一个完整的结构,其内部还将包含它自己的成员b,这第二个成员又包含一个完整的结构,它还将包括它自己的成员b,这样重复下去永无休止。所以        不合法。

          那么要如何引用自身结构呢,可以使用结构体指针的方式,如下:

          struct  SELF_REF2 {

    int a;

               struct  SELF_REF2 *b;

    int c;

    }

     这个声明和前面那个声明的区别是b现在时一个指针,而不是结构;编译器在结构的长度确定之前就已经知道指针的长度,所以这种自引用是合法的。

    结构体的自引用在实现链表,树等高级的操作时用处很大。

    注意:

    在使用过程中可能出现如下的声明,是不合法的:

    typedef struct {

    int a;

    SELF_REF3 *B;

    int c;

    }SELF_REF3;

    这个声明的目的是为这个结构创建类型名SELF_REF3,但是失败了,类型名直到声明的末尾在定义,所以在结构声明的内部它尚未定义。

                            要解决可以用如下方式:

    typedef struct  SELF_REF3_TAG {

    int a;

    struct SLEF_REF3_TAG *b;

    int c;

    }SELF_REF3;

     

    2、嵌套引用

    在linux 内核中,经常能看到数据结构之间存在依赖关系。也就是说、其中一个结构包含了另一个结构的一个或者多个成员。和自引用一样,至少有一个结构必须在另一个结构的内部以指针的形式存在。

    问题:如果每个结构体都引用了其他结构的标签,哪个结构应该首先声明呢?

    这个问题必须实现不完整声明,它声明一个作为结构体标签的标识符。然后我们可以把这个标签用在不需要知道这个结构长度的声明中,如声明指向这个结构体的指针。

    例:

    struct B;

                    

    struct A {

    struct B *partner;

    >>>>>

    };

    struct B {

    struct A *partner;

    >>>>>>>;

    };



    展开全文
  • 结构体嵌套: 将一个已经声明的结构体在另一个结构体内作为成员变量进行定义,并在外层结构体初始化的同时最自己进行行初始化,使用花括号包裹自身成员变量。 打印时注意为:结构体名称.结构体成员结构体.结构体...

    结构体嵌套:

    将一个已经声明的结构体在另一个结构体内作为成员变量进行定义,并在外层结构体初始化的同时最自己进行行初始化,使用花括号包裹自身成员变量。

    打印时注意为:结构体名称.结构体成员结构体.结构体成员结构体的成员

    #include <stdio.h>
    
    struct Date
    {
    	int year;
    	int month;
    	int day;
    };
    
    struct Book
    {
    	char title[128];
    	char author[40];
    	float price;
    	struct Date date;  //结构体的嵌套
    	char publisher[40];
    } book = {
    	 "《C语言》",
    	 "abc",
    	 99.9,
    	{2020,02,29},
    	"出版社"
    };
    
    int main(void)
    {
    	printf("书名:%s\n", book.title);
    	printf("作者:%s\n", book.author);
    	printf("售价:%f\n", book.price);
    	//注意这里的输出方式:三个数据%d%d%d中间的-也会打印,每个数据寻找到最底层,book.date.year
    	printf("出版日期:%d-%d-%d\n", book.date.year, book.date.month, book.date.day);
    	printf("出版社:%s\n", book.publisher);
    	return 0;
    }

    结构体数组:

    同定义结构体的形式

    仅仅把定义时的数组名换为数组名+长度。

     struct 结构体名称                                                                                                                                                                               {                                                                                                                                                                                                                     结构体成员;                                                                                                                                                                               } 数组名 [长度];

    第二种:

     struct 结构体名称                                                                                                                                                                               {                                                                                                                                                                                                                     结构体成员;                                                                                                                                                                               };

    struct 结构体名称 数组名[长度];

    初始化结构体数组:

    可以在定义的同时进行初始化:

    
    struct Date
    {
    	int year;
    	int month;
    	int day;
    };
    
    struct Book
    {
    	char title[128];
    	char author[40];
    	float price;
    	struct Date date;  //结构体的嵌套
    	char publisher[40];
    
    };
    
    struct Book book[3] = {  //定义长度为三的结构体数组book,book内嵌结构体date。初始化时用{}。
    	{"《C语言》","abc",99.9,{2020,02,29},"出版社"},
    	{"《C++》","abcd",99.9,{2020,02,29},"出版社"},
    	{"《C#》","abcde",99.9,{2020,02,29},"出版社"},
    };

    毕竟本质还是数组,若想全部打印,只需要加入一点循环就可以了~

    for (int i = 0; i < 3; i++)
    {
    	printf("书名:%s\n", book[i].title);
    	printf("作者:%s\n", book[i].author);
    	printf("出版日期:%d-%d-%d\n", book[i].date.year,book[i].date.month,book[i].date.day);
    }

    结构体指针:

    指针可以指向任何数据,当然也可以指向结构体,指向结构体变量的指针我们称为结构体指针。

    struct Book * pt就是一个指向Book结构体类型的指针变量pt,也具备指针的特点,指向的数据类型放在前面。

    数组名指向数组第一个元素的地址,所以可以把数组名的地址赋值给指针。但是,结构体不是这样的,结构体的变量名不是指向结构体的地址的,所以对结构体变量的取值必须使用取址符&。

    pt = &book;

    通过结构体指针访问结构体成员有两种方法:

    1,(* 结构体指针).成员名-----------与普通指针同理,对结构体变量解引用就是结构体变量就可以进行(.)运算。

    2,结构体指针->成员名------------(->)也是运算符,为成员选择(指针)运算符,(.)是成员选择(对象)运算符,他们两个使用形式相同。区别就是一个是对象取成员,一个是指向对象的指针取成员,实现上是完全等价的。

    使用第一种解引用方法访问结构体成员:

    #include <stdio.h>
    
    struct Date
    {
    	int year;
    	int month;
    	int day;
    };
    
    struct Book
    {
    	char title[128];
    	char author[40];
    	float price;
    	struct Date date;  //结构体的嵌套
    	char publisher[40];
    } book = {
    	 "《C语言》",
    	 "abc",
    	 99.9,
    	{2020,02,29},
    	"出版社"
    };
    
    int main(void)
    {
    	struct Book *pt;  //指向数据类型为Book结构体的指针*pt
    	pt = &book;  //指针pt指向了已经初始化的结构体变量book
            //均为解引用的形式打印出数据
    	printf("书名:%s\n", (*pt).title);
    	printf("作者:%s\n", (*pt).author);
    	printf("售价:%f\n", (*pt).price);
    	printf("出版日期:%d-%d-%d\n", (*pt).date.year, (*pt).date.month, (*pt).date.day);
    	printf("出版社:%s\n", (*pt).publisher);
    	
    	return 0;
    }

    使用(->)打印:

    
    int main(void)
    {
    	struct Book *pt;  //指向数据类型为Book结构体的指针*pt
    	pt = &book;  //指针pt指向了已经初始化的结构体变量book
    
    	printf("书名:%s\n",pt->title);
    	printf("作者:%s\n", pt->author);
    	printf("售价:%f\n", pt->price);
    	//注意这里的输出方式:三个数据%d%d%d中间的-也会打印,每个数据寻找到最底层,book.date.year
    	printf("出版日期:%d-%d-%d\n", pt->date.year, pt->date.month, pt->date.day);
    	printf("出版社:%s\n", pt->publisher);
    	
    	return 0;
    }

     

    展开全文
  • 结构体指针 & 结构体嵌套使用...

    千次阅读 2016-01-02 04:31:51
    #include struct Airplane { ...// 结构体指针 & 结构体嵌套使用 // 结构体不可以嵌套自己变量(可以嵌套其他结构体的变量), 可以嵌套指向自己这种类型的指针. int main(int argc, const char * ar


    #include <stdio.h>
    
    struct Airplane {
        int lunzi;
        int speed;
    };
    
    void remake(struct Airplane * air);
    // 结构体指针 & 结构体嵌套使用
    // 结构体不可以嵌套自己变量(可以嵌套其他结构体的变量), 可以嵌套指向自己这种类型的指针.
    int main(int argc, const char * argv[])
    {
    
    	struct Car {
    		int lunzi;
    		int speed;
    	} car;
    	struct Car * p = NULL;
    
    	car = (struct Car){ 4, 100 };
    
    	p = &car;
    
    	// 方法1:(*p) 取出结构体, 再用结构体访问里面的内容
    	printf("lunzi = %d , speed = %d\n", (*p).lunzi, (*p).speed);
    	// 方法2: p->lunzi 直接访问
    	printf("lunzi = %d , speed = %d\n", p->lunzi, p->speed);
    
        //************************ stone ***
    
        // 表示月份的时候有用
        printf("%02d\n",2);
    
        struct Time {
            int hour;
            int minute;
            int second;
        };
        struct Calendar {
            int year;
            int month;
            int day;
            struct Time time;
        };
    
        struct Time time = {03,56,55};
        struct Calendar cal = {2016,1,1,time};
    
        printf("%d年%02d月%02d日 %02d时%02d分%02d秒\n",cal.year,cal.month,cal.day,cal.time.hour,cal.time.minute,cal.time.second);
    
        // 嵌套自己的指针
        struct Person {
            char * name;
            int age;
            struct Person * child;
        };
        struct Person xiaofangzi = {"房祖名",28,NULL};
        struct Person jackiechan = {"成龙",55,&xiaofangzi};
    
        printf("%s\n",jackiechan.child -> name);
    
        //************************ stone ***
    
    
        struct Airplane air = {4,500};
    
        remake(&air);
    
        printf("%d\n",air.lunzi);
    
    	return 0;
    }
    
    // 值传递 是 赋值, 指针传递 才能指向同一个地址, 才能修改.
    void remake(struct Airplane * air)
    {
        air ->lunzi = 8;
    }


    展开全文
  • 结构体(struct) 1、基本概念 结构体-----将不同类型的数据成员组织到统一的名字之下,适用于对关系紧密,逻辑相关、具有相同或不同类型的数据进行处理 2、结构体定义格式 struct 结构名(也可称作结构标识符) ...
  • 结构体嵌套对齐以及结构体中含有数组的对齐 32位系统环境 规则一:结构体中含有数组,数组元素类型和结构中其余的最大类型取较大者 对齐 规则二:结构体S2中嵌套结构体S1,则按照S1的最大元素类型和S2中各元素类型...
  • 双重嵌套结构体嵌套的调用

    千次阅读 2020-02-06 21:42:24
    //需要创建一个Qlist结构体类型的空间,因为结构体指针只能说明创建了一个指针指向了这个结构体但是却没有实际的给它开辟空间,所以需要给它开一个结构体类型的空间 s->p_2 = (Stu*)malloc(sizeof(Stu));...
  • 结构体嵌套中的问题

    2019-06-12 11:18:00
    结构体的自引用(self reference),就是在结构体内部,包含指向自身类型结构体的指针。 结构体的相互引用(mutual reference),就是说在多个结构体中,都包含指向其他结构体的指针。 1. 自引用结构体 1.1不使用...
  • 结构体嵌套 自身嵌套 相互嵌套

    万次阅读 多人点赞 2018-05-16 00:01:59
    结构体嵌套的问题有哪些? 结构体的自引用,就是在结构体内部,包含指向自身类型结构体的指针。 结构体的相互引用,就是说在多个结构体中,都包含指向其他结构体的指针。 结构体应该注意的问题? 结构体定义中...
  • 可以打印结构体嵌套指针地址内部数据的格式化库 Formatting library that can print the internal data of the nested pointer address of the struct Github https://github.com/mix-go/xfmt Overview 在 Golang 中...
  • 1.结构体一 struct GstCollectData{ GstCollectPads *collect; GstPad *pad; GstBuffer *buffer; } 2.结构体二 ... //嵌套结构体一 guint32 fourcc; gboolean is_out_of_order; guint sample_size;.
  • /bin/pythonfrom socket import *from time import time,ctimehost = ""port = 12345bufsize = 1024addr = (host,port)socket = socket(AF_INET,SOCK_STR...
  • [图片说明](https://img-ask.csdn.net/upload/201603/06/1457247080_689879.png)我大概的想法是用结构体嵌套, 嗯~ 打个比喻, 班上每个同学的学号是外结构体的数据, 之后用学号来找同学。 每个同学的各科...
  • 使用指针 //可以通过解引用的方式来找到指针指向的内存 //指针前加 * 代表解引用,找到指针指向的内存 比如:*p cout ; cout *p=" *p ; *p = 1000;//指针变量p指向储存在内存中a_zz的数值,并将a_zz赋值1000 cout ;/...
  • 结构体嵌套结构体

    万次阅读 多人点赞 2016-08-12 22:09:41
    结构体嵌套问题 结构体的自引用(self reference),就是在结构体内部,包含指向自身类型结构体的指针。 结构体的相互引用(mutual reference),就是说在多个结构体中,都包含指向其他结构体的指针。 1. ...
  • 结构体指针 &student1 表示结构体变量 student1 的首地址,即 student1 第一个项的地址。如果定义一个指针变量 p 指向这个地址的话,p 就可以指向结构体变量 student1 中的任意一个成员。 那么,这个指针变量...
  • 结构体引用

    2016-02-22 11:35:28
    1结构体引用 使用结构体遇到自引用问题,比入之前使用串口回调函数用到结构体引用,使用代码如下: struct Callbacklist {  int hd;  P_Callback callbackfun;  char *pexitflag;  struct ...
  • 一直想用gorm查询到嵌套结构体,可惜自定义嵌套结构体好像不支持?下次按这个思路再试试,可能也行哦。 用join查询虽然强大,但是无法将查询结构映射到嵌套结构体。 下面3个结构体嵌套关系,3层嵌套(或是2层...
  • 结构体嵌套问题

    千次阅读 2018-06-15 08:37:36
    结构体的相互引用(mutual reference),就是说在多个结构体中,都包含指向其他结构体的指针。1. 自引用结构体1.1 不使用typedef时错误的方式:struct ...
  • Keil 结构体变量初始化tujidi1csd25142016-09-30一维数组结构体数组结构体数组,通过改变指针类型改变访问数组的方式toto129748850424332014-08-01mfc结构体指针、结构体数组指针... 容器初始化】结构体嵌套复杂结构...
  • 结构体引用

    2018-06-15 18:01:00
    今天关于结构体一些疑问,在这里标记一下...结构体的定义如下所示,struct为结构体关键字,tag为结构体的标志,member-list为结构体成员列表,其必须列出其所有成员;variable-list为此结构体声明的变量。 1 s...
  • c++ 结构体嵌套使用

    千次阅读 2017-03-24 08:18:26
    c++ 结构体嵌套使用
  • 详细介绍了,结构体的声明,初始化,与使用成员变量的各种方法,其中最大的亮点是结构体嵌套使用,类和联合也是同样的道理,大家共同学习呀!!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,127
精华内容 6,450
关键字:

结构体嵌套引用