精华内容
下载资源
问答
  • 结构体自引用

    2016-02-22 11:35:28
    1结构体自引用 使用结构体遇到自引用问题,比入之前使用串口回调函数用到结构体自引用,使用代码如下: struct Callbacklist {  int hd;  P_Callback callbackfun;  char *pexitflag;  struct ...

    1结构体自引用

    使用结构体遇到自引用问题,比入之前使用串口回调函数用到结构体自引用,使用代码如下:

    struct   Callbacklist
    {
        int hd;
        P_Callback       callbackfun;
        char *pexitflag;


        struct Callbacklist  pnext;
    };

    编译显示错误,检查后发现这种声明方式,实际上是结构体里套结构体,无线循环下去。分配内存时,由于是无限嵌套,无法确定结构体长度,所以非法。这种情况应该使用指针来完成嵌套,因为在系统中指针的长度是确定的。

    struct   Callbacklist
    {
        int hd;
        P_Callback       callbackfun;
        char *pexitflag;


        struct Callbacklist  *pnext;
    };

    编译成功。

    查找资料时,发现另外一种嵌套方式:使用typedef来定义。方式多,结构灵活。(参考博客:http://www.cnblogs.com/renyuan/archive/2012/11/30/2796792.html)

    typedef struct tag_1{
        int value;
        struct tag_1 *link; 
    } NODE;
    
    
    struct tag_2;
    typedef struct tag_2 NODE;
    struct tag_2{
        int value;
        NODE *link;   
    };
    
    
    struct tag_3{
        int value;
        struct tag_3 *link; 
    };
    typedef struct tag_3 NODE;

    展开全文
  • 结构体 自引用

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

    转载网址:http://tscsh.blog.163.com/blog/static/20032010320138249183520/

    今天关于结构体一些疑问,在这里标记一下

    1.定义与声明

    结构体的定义如下所示,struct为结构体关键字,tag为结构体的标志,member-list为结构体成员列表,其必须列出其所有成员;variable-list为此结构体声明的变量。

     

    1 struct tag 
    2 {
    3      member-list 
    4 } variable-list ;

     

    在一般情况下,tag、member-list、variable-list这3部分至少要出现2个。以下为示例:

     

     1 //此声明声明了拥有3个成员的结构体,分别为整型的a,字符型的b和双精度的c
     2 //同时又声明了结构体变量s1 
     3 //这个结构体并没有标明其标签
     4 struct {
     5 int a;
     6 char b;
     7 double c;
     8 } s1;
     9 
    10 
    11 //此声明声明了拥有3个成员的结构体,分别为整型的a,字符型的b和双精度的c
    12 //结构体的标签被命名为SIMPLE,没有声明变量
    13 struct SIMPLE{
    14 int a;
    15 char b;
    16 double c;
    17 };
    18 //用SIMPLE标签的结构体,另外声明了变量t1、t2、t3
    19 struct SIMPLE t1, t2[20], *t3;
    20 //也可以用typedef创建新类型
    21 typedef struct{
    22 int a;
    23 char b;
    24 double c;
    25 } Simple2;
    26 //现在可以用Simple2作为类型声明新的结构体变量
    27 Simple2 u1, u2[20], *u3;

     

    在上面的声明中,第一个和第二声明被编译器当作两个完全不同的类型,即使他们的成员列表是一样的,如果令t3=&s1,则是非法的。结构体的成员可以包含其他结构体,也可以包含指向自己结构体类型的指针,而通常这种指针的应用是为了实现一些更高级的数据结构如链表和树等。

     如果两个结构体互相包含,则需要对其中一个结构体进行不完整声明,如下所示:

    //结构体A中包含指向结构体B的指针    
    struct A  
    { 
         struct B *partner;
        //other members;
    };
    //结构体B中包含指向结构体A的指针,在A声明完后,B也随之进行声明
    struct B
    {
            struct A *partner;
            //other members;
    };        

    2. 自引用 结构体

    1.1 不使用typedef时

    错误的方式:

     

    1 struct tag_1
    2 {  
    3          struct tag_1 A;   /* 结构体 */  
    4          int value;  
    5 };     

     

           这种声明是错误的,因为这种声明实际上是一个无限循环,成员b是一个结构体,b的内部还会有成员是结构体,依次下去,无线循环。在分配内存的时候,由于无限嵌套,也无法确定这个结构体的长度,所以这种方式是非法的。

    正确的方式: (使用指针):

     

    1 struct tag_1
    2 {  
    3     struct tag_1 *A;  /* 指针 */  
    4     int value;  
    5 }; 

     

      由于指针的长度是确定的(在32位机器上指针长度为4),所以编译器能够确定该结构体的长度。

    1.2 使用typedef 时

    错误的方式:

    1 typedef struct
    2  {  
    3     int value;  
    4     NODE *link;  /* 虽然也使用指针,但这里的问题是:NODE尚未被定义 */  
    5 } NODE; 

    这里的目的是使用typedef为结构体创建一个别名NODEP。但是这里是错误的,因为类型名的作用域是从语句的结尾开始,而在结构体内部是不能使用的,因为还没定义。

    正确的方式:有三种,差别不大,使用哪种都可以。

     1 /*  方法一  */  
     2 typedef struct tag_1{  
     3     int value;  
     4     struct tag_1 *link;    
     5 } NODE;  
     6   
     7   
     8 /*  方法二  */  
     9 struct tag_2;  
    10 typedef struct tag_2 NODE;  
    11 struct tag_2{  
    12     int value;  
    13     NODE *link;      
    14 };  
    15   
    16   
    17 /*  方法三  */  
    18 struct tag_3{  
    19     int value;  
    20     struct tag_3 *link;    
    21 };  
    22 typedef struct tag_3 NODE;  

     

    3. 相互引用 结构体

    错误的方式:

    1 typedef struct tag_a{  
    2     int value;  
    3     B *bp;  /* 类型B还没有被定义 */  
    4 } A;  
    5   
    6 typedef struct tag_b{  
    7     int value;  
    8     A *ap;  
    9 } B;   

         错误的原因和上面一样,这里类型B在定义之 前 就被使用。

    正确的方式:(使用“不完全声明”)

     

     1 /* 方法一   */   
     2 struct tag_a{  
     3     struct tag_b *bp;  /* 这里struct tag_b 还没有定义,但编译器可以接受 */  
     4     int value;  
     5 };  
     6 struct tag_b{  
     7     struct tag_a *ap;  
     8     int value;  
     9 };  
    10 typedef struct tag_a A;  
    11 typedef struct tag_b B;   
    12   
    13   
    14 /*  方法二   */   
    15 struct tag_a;   /* 使用结构体的不完整声明(incomplete declaration) */  
    16 struct tag_b;  
    17 typedef struct tag_a A;   
    18 typedef struct tag_b B;  
    19 struct tag_a{  
    20     struct tag_b *bp;  /* 这里struct tag_b 还没有定义,但编译器可以接受 */  
    21     int value;  
    22 };  
    23 struct tag_b{  
    24     struct tag_a *ap;  
    25     int value;  
    26 };  

     

    转载于:https://www.cnblogs.com/liangbo-1024/p/9188497.html

    展开全文
  • 结构体自引用(self reference),就是在结构体内部,包含指向自身类型结构体的指针。  结构体的相互引用(mutual reference),就是说在多个结构体中,都包含指向其他结构体的指针。 1. 自引用 结构体 1.1 ...

    结构体的自引用(self reference),就是在结构体内部,包含指向自身类型结构体的指针。

            结构体的相互引用(mutual reference),就是说在多个结构体中,都包含指向其他结构体的指针。

    1. 自引用 结构体

    1.1 不使用typedef时

    错误的方式:

    1. struct tag_1{  
    2.     struct tag_1 A;   /* 结构体 */  
    3.     int value;  
    4. };  

            这种声明是错误的,因为这种声明实际上是一个无限循环,成员b是一个结构体,b的内部还会有成员是结构体,依次下去,无线循环。在分配内存的时候,由于无限嵌套,也无法确定这个结构体的长度,所以这种方式是非法的。

    正确的方式: (使用指针):

    1. struct tag_1{  
    2.     struct tag_1 *A;  /* 指针 */  
    3.     int value;  
    4. };  

            由于指针的长度是确定的(在32位机器上指针长度为4),所以编译器能够确定该结构体的长度。

    1.2 使用typedef 时

    错误的方式:

    1. typedef struct {  
    2.     int value;  
    3.     NODE *link;  /* 虽然也使用指针,但这里的问题是:NODE尚未被定义 */  
    4. } NODE;  

    这里的目的是使用typedef为结构体创建一个别名NODEP。但是这里是错误的,因为类型名的作用域是从语句的结尾开始,而在结构体内部是不能使用的,因为还没定义。

    正确的方式:有三种,差别不大,使用哪种都可以。

    1. /*  方法一  */  
    2. typedef struct tag_1{  
    3.     int value;  
    4.     struct tag_1 *link;    
    5. } NODE;  
    6.   
    7.   
    8. /*  方法二  */  
    9. struct tag_2;  
    10. typedef struct tag_2 NODE;  
    11. struct tag_2{  
    12.     int value;  
    13.     NODE *link;      
    14. };  
    15.   
    16.   
    17. /*  方法三  */  
    18. struct tag_3{  
    19.     int value;  
    20.     struct tag *link;    
    21. };  
    22. typedef struct tag_3 NODE;  

    2. 相互引用 结构体

    错误的方式:

    1. typedef struct tag_a{  
    2.     int value;  
    3.     B *bp;  /* 类型B还没有被定义 */  
    4. } A;  
    5.   
    6. typedef struct tag_b{  
    7.     int value;  
    8.     A *ap;  
    9. } B;   

            错误的原因和上面一样,这里类型B在定义之 前 就被使用。

    正确的方式:(使用“不完全声明”)

    1. /* 方法一   */   
    2. struct tag_a{  
    3.     struct tag_b *bp;  /* 这里struct tag_b 还没有定义,但编译器可以接受 */  
    4.     int value;  
    5. };  
    6. struct tag_b{  
    7.     struct tag_a *ap;  
    8.     int value;  
    9. };  
    10. typedef struct tag_a A;  
    11. typedef struct tag_b B;   
    12.   
    13.   
    14. /*  方法二   */   
    15. struct tag_a;   /* 使用结构体的不完整声明(incomplete declaration) */  
    16. struct tag_b;  
    17. typedef struct tag_a A;   
    18. typedef struct tag_b B;  
    19. struct tag_a{  
    20.     struct tag_b *bp;  /* 这里struct tag_b 还没有定义,但编译器可以接受 */  
    21.     int value;  
    22. };  
    23. struct tag_b{  
    24.     struct tag_a *ap;  
    25.     int value;  
    26. };  

     

    本文链接:http://blog.csdn.net/daheiantian/archive/2011/01/27/6233058.aspx

    展开全文
  • 结构体自引用(self reference),就是在结构体内部,包含指向自身类型结构体的指针。  结构体的相互引用(mutual reference),就是说在多个结构体中,都包含指向其他结构体的指针。 1. 自引用 结构体 1.1 不...

          结构体的自引用(self reference),就是在结构体内部,包含指向自身类型结构体的指针。

            结构体的相互引用(mutual reference),就是说在多个结构体中,都包含指向其他结构体的指针。

    1. 自引用 结构体

    1.1 不使用typedef时

    错误的方式:

    1. struct tag_1{  
    2.     struct tag_1 A;   /* 结构体 */  
    3.     int value;  
    4. };  

            这种声明是错误的,因为这种声明实际上是一个无限循环,成员b是一个结构体,b的内部还会有成员是结构体,依次下去,无线循环。在分配内存的时候,由于无限嵌套,也无法确定这个结构体的长度,所以这种方式是非法的。

    正确的方式: (使用指针):

    1. struct tag_1{  
    2.     struct tag_1 *A;  /* 指针 */  
    3.     int value;  
    4. };  

            由于指针的长度是确定的(在32位机器上指针长度为4),所以编译器能够确定该结构体的长度。

    1.2 使用typedef 时

    错误的方式:

    1. typedef struct {  
    2.     int value;  
    3.     NODE *link;  /* 虽然也使用指针,但这里的问题是:NODE尚未被定义 */  
    4. } NODE;  

    这里的目的是使用typedef为结构体创建一个别名NODEP。但是这里是错误的,因为类型名的作用域是从语句的结尾开始,而在结构体内部是不能使用的,因为还没定义。

    正确的方式:有三种,差别不大,使用哪种都可以。

    1. /*  方法一  */  
    2. typedef struct tag_1{  
    3.     int value;  
    4.     struct tag_1 *link;    
    5. } NODE;  
    6.   
    7.   
    8. /*  方法二  */  
    9. struct tag_2;  
    10. typedef struct tag_2 NODE;  
    11. struct tag_2{  
    12.     int value;  
    13.     NODE *link;      
    14. };  
    15.   
    16.   
    17. /*  方法三  */  
    18. struct tag_3{  
    19.     int value;  
    20.     struct tag *link;    
    21. };  
    22. typedef struct tag_3 NODE;  

    2. 相互引用 结构体

    错误的方式:

    1. typedef struct tag_a{  
    2.     int value;  
    3.     B *bp;  /* 类型B还没有被定义 */  
    4. } A;  
    5.   
    6. typedef struct tag_b{  
    7.     int value;  
    8.     A *ap;  
    9. } B;   

            错误的原因和上面一样,这里类型B在定义之 前 就被使用。

    正确的方式:(使用“不完全声明”)

    1. /* 方法一   */   
    2. struct tag_a{  
    3.     struct tag_b *bp;  /* 这里struct tag_b 还没有定义,但编译器可以接受 */  
    4.     int value;  
    5. };  
    6. struct tag_b{  
    7.     struct tag_a *ap;  
    8.     int value;  
    9. };  
    10. typedef struct tag_a A;  
    11. typedef struct tag_b B;   
    12.   
    13.   
    14. /*  方法二   */   
    15. struct tag_a;   /* 使用结构体的不完整声明(incomplete declaration) */  
    16. struct tag_b;  
    17. typedef struct tag_a A;   
    18. typedef struct tag_b B;  
    19. struct tag_a{  
    20.     struct tag_b *bp;  /* 这里struct tag_b 还没有定义,但编译器可以接受 */  
    21.     int value;  
    22. };  
    23. struct tag_b{  
    24.     struct tag_a *ap;  
    25.     int value;  
    26. };  



    /*以下为自引用程序,VC6.0编译通过*/

    #include <stdio.h>


    typedef struct student_tag //student是标识符,stu_type是类型符号,struct student=stu_type
    {
        int num;             /*定义成员变量学号*/
        int age;             /*定义成员变量年龄*/
        struct student_tag* stu_point;
    }stu_type;






    void main()
    {
        /*给结构体变量赋值*/
        //struct student stu ={001,"lemon",'F',23,95};
        
    stu_type stu ={001,26,&stu};
      
    printf("学生信息如下:\n");         /*输出学生信息*/
        printf("学号:%d\n",stu.num);        /*输出学号*/
       
       
        printf("年龄:%d\n",stu.age);       /*输出年龄*/




    printf("%p\n",stu.stu_point);    /*指针变量的值,为四个字节*/



    printf("%d\n",sizeof(stu));    /*结构体类型stu_type占了12个字节*/

        
    }


    /*下面为程序运行结果*/



    /*以下为互引用程序,使用结构体的不完整声明(incomplete declaration)*/



    #include <stdio.h>


     struct teacher; //此条语句可省去
     struct student
     {
        int stu_num;           
        struct teacher* tea_point;/* struct teacher省去的话,编译器也可以接受 */  


    };


    struct teacher
    {
        int tea_num;            
        struct student* stu_point;
    };
    typedef struct student stu_type;
    typedef struct teacher tea_type;




    void main()
    {
        


       tea_type tea1={000,NULL};
       stu_type stu1={005,NULL};


            stu1.stu_num=001;
                 stu1.tea_point=&tea1;


    tea1.tea_num=002;
                 tea1.stu_point=&stu1;
    printf("%d \n",(stu1.tea_point)->tea_num);
    printf("%p \n",(stu1.tea_point)->stu_point);




    printf("%d \n",(tea1.stu_point)->stu_num);
    printf("%p \n",(tea1.stu_point)->tea_point);


    }


    /*下面为程序运行结果*/




    展开全文
  • c语言结构体自引用指针

    千次阅读 2014-06-10 10:59:38
    百度知道: 提问: struct listNode{ char data; struct listNode *nextPtr; }; typedef struct listNode ListNode; typedef ListNode *ListNodePtr; 请问第二个typedef中那个别名的指针是什么意思,是将...
  • 结构体自引用

    2019-11-07 10:29:37
    总结一下结构体自引用问题 typedef struct _A { int a; struct _A *b; }A; 结构体A中定义了一个指针b,该指针指向一个结构体A类型。为什么可以这么做呢?因为编译器在编译时已经知道一个指针所占的空间长度4...
  • 结构体是各种数据类型的集合,结构体自引用结构体一个特殊的数据成员: typedef struct _A { int a; struct _A *b; }A; 结构体A中定义了一个指针b,该指针指向一个结构体A类型。为什么可以这么做呢?因为...
  • 主要介绍了C语言中结构体自引用和相互引用,详细解析了结构体中指针的指向情况,需要的朋友可以参考下
  • 结构体引用结构体指针的引用

    千次阅读 2014-05-04 15:07:43
    结构体引用结构体指针的引用结构体是一个指针时要引用结构体的成员就用-> 而如果不是指针就用. 如: struct msg_st {  int a; }; struct msg_st msg; struct msg_st *ms;//需要初始化 msg.a = ...
  • C++结构体变量的引用 C++在定义了结构体变量以后,可以引用这个变量。 可以将一个结构体变量的值赋给另一个具有相 同结构的结构体变量。 student1= student2; 可以引用一个结构体变量中的一个成员的值。
  • 结构体引用结构体成员变量

    千次阅读 2020-11-05 17:02:01
    引用结构体成员变量 一个结构体包含一个或者多个成员变量,在实际使用中,就需要对其成员变量进行引用,对于一个已经定义了的结构体变量和一个指向该结构体的指针变量。 可以用一下三种情况引用结构体 成员变量。 1...
  • C语言 - 结构体自引用和相互引用

    千次阅读 2017-09-25 14:02:53
    结构体自引用(self reference),就是在结构体内部,包含指向自身类型结构体的指针。 结构体的相互引用(mutual reference),就是说在多个结构体中,都包含指向其他结构体的指针。 1. 自引用 结构体 1.1 不...
  • Matlab结构体内容引用自结构体数组对象matlab的gui报错axes(handles.axes1)如何解决起因代码 matlab的gui报错axes(handles.axes1) 废话不多说,直接上bug 如何解决 特别简单,我们运行GUI的.m文件,而不是双击...
  • 结构体自引用及相互引用

    千次阅读 2017-12-04 17:25:25
    在用C来实现数据结构以及部分算法时,经常用到结构体,比如实现树以及树的子节点时,就需要该结构体包含自身类型的成员变量。而最近在研究OC的匿名函数实现时,也涉及到了...故简单总结一下C语言结构体自引用语法。
  • cvx _begin quiet variable u_N(4*N) minimize ( (1/2)*quad_form(u_N,H) + d'*u_N ) u_N *ones(4*N,1); u_N >= -u_limit*ones(4*N,1); Z*u_N *x0 + x_lim_vec_full; Z*u_N >= -P*x0 - x_lim_vec_...
  • 设计一个结构体,存储某个学生的主要学籍信息,包括姓名,性别,班级和学号等,使用结构体实现对结构体变量成员的输入和输出 #include<stdio.h> struct si { char name[30]; char sex[10]; unsigned int ...
  • Swift 结构体引用

    2019-10-23 11:04:27
    swift中结构体引用赋值时独立存在的。结构体总是通过被复制的方式在代码中传递 例如一下实例,构造一个结构体MarksStruct,赋值给aStruct,然后再将aStruct赋值给bStruct,此时aStruct,bStruct的值是一样的都是...
  • 结构体数组和结构体指针的应用,结构体成员引用的表示方法 //结构体数组和结构体指针的应用,结构体成员引用的表示方法 // Created by acer on 2020/8/30. #include<stdio.h> struct student{ int num; char...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 116,754
精华内容 46,701
关键字:

结构体自引用