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

    2020-09-04 09:54:37
    结构体、联合体、枚举 1、结构体 声明 struct Teacher { int age;...使用结构体定义变量时,前面struct可写可不写 struct Teacher { int age; char isCool; }teacher; int _tma...

    结构体、联合体、枚举

     

    1、结构体

     

    声明

     

    struct Teacher
    {
        int age;
        char isCool;
    };

     

    声明+定义变量

    struct Teacher
    {
        int age;
        char isCool;
    }teacher;

    使用

     

    使用结构体定义变量时,前面的struct可写可不写

    struct Teacher
    {
        int age;
        char isCool;
    }teacher;
    
    int _tmain(int argc, _TCHAR* argv[])
    {
        struct Teacher t1;
        Teacher t2;
    
        t1.age = 11;
        t2.age = 22;
        
        // 接收用户的输入
        getchar();
    
        return 0;
    }

     

    定义+赋初值

    struct Teacher
    {
        int age;
        char isCool;
    }teacher;
    
    int _tmain(int argc, _TCHAR* argv[])
    {
        Teacher t1 = {11, 1};
        
        // 接收用户的输入
        getchar();
    
        return 0;
    }

     

    声明+定义变量

    struct Teacher
    {
        int age;
        char isCool;
    }teacher;
    
    int _tmain(int argc, _TCHAR* argv[])
    {
        teacher.age = 10;
    
        printf("%d\n", teacher.age);
        
        // 接收用户的输入
        getchar();
    
        return 0;
    }

     


    结构体数组

     


    结构体指针

     

    访问结构体成员时用->,而不是.

     

    // 32bit,4字节对齐
    struct Teacher
    {
        int age;        // 4
        char isCool;    // 1
    };
    
    void print1(Teacher t)
    {
        printf("%d\n", t.age);
    }
    
    void print2(Teacher *t)
    {
        printf("%d\n", t->age);
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
        struct Teacher teacher;
        teacher.age = 10;
        teacher.isCool = 1;
    
        // 为什么差8个字节,因为结构体长度是8
    //  printf("%X, %X\n", &teacher, &teacher + 1);
    
    //  printf("%d\n", *(char *)(&teacher + 4));
    
        printf("%d\n", *(char *)((char *)&teacher + 4));
    
    
        print1(teacher);
    
        print2(&teacher);
    
        // 接收用户的输入
        getchar();
    
        return 0;
    }

    结构体嵌套结构体

     


    结构体做函数参数

     

    值传递、引用传递

     

    struct Teacher
    {
        int age;
        char isCool;
    }teacher;
    
    void print_1(Teacher t)
    {
        printf("%d\n", t.age);
    }
    
    void print_2(Teacher *t)
    {
        printf("%d\n", t->age);
    }
    
    void print_3(Teacher &t)
    {
        printf("%d\n", t.age);
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
        Teacher t1 = {11, 1};
    
        print_1(t1);
        print_2(&t1);
        print_3(t1);
    
        
        // 接收用户的输入
        getchar();
    
        return 0;
    }

    加const修饰(重要!!读源码经常看到这个语法)

     

    目的是为了防止外部拿到结构体变量的引用修改结构体成员的值

     

    struct Teacher
    {
        int age;
        char isCool;
    }teacher;
    
    void print(Teacher *t)
    {
        t->age = 20;
    
        printf("%d\n", t->age);
    }
    
    void print_1(const Teacher *t)
    {
        t->age = 20;
    
        printf("%d\n", t->age);
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
        Teacher t1 = {11, 1};
    
        print(&t1);
    
        printf("%d\n", t1.age);
    
        
        // 接收用户的输入
        getchar();
    
        return 0;
    }

     

    2、联合体(union)

     

    允许在相同的内存位置存储不同的数据类型

    但是任何时候只能有一个成员带有值

    联合体的大小由字节数最多的成员决定

     

    3、枚举(enum)

     

    跟Java中的差不多

     

    引用

     

    可理解为:给变量起别名

     

    其本质其实就是指针常量:int * const a = &b;

     

    语法:

    int a = 10;
    int &b = a;

    注意:

    1、引用必须初始化

    2、引用初始化后无法修改

     


    引用做函数参数

    struct Teacher
    {
        int age;
        char isCool;
    }teacher;
    
    void print(Teacher &t)
    {
        t.age = 30;
    
        printf("%d\n", t.age);
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
        Teacher t1 = {11, 1};
    
        print(t1);
    
        printf("%d\n", t1.age);
    
        
        // 接收用户的输入
        getchar();
    
        return 0;
    }

    引用做函数返回值

     

    注意:不能返回局部变量的引用,因为局部变量在函数调用完以后就释放掉了。那持有的引用有点野指针的味道

     

    int & add()
    {
        int a = 10;
    
        return a;
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
        int &a = add();
    
        printf("%d\n", a);
        printf("%d\n", a);
        printf("%d\n", a);
        
        // 接收用户的输入
        getchar();
    
        return 0;
    }

     

    如果函数的返回值是引用,这个函数可以作为左值使用

    int & add()
    {
        static int a = 10;
    
        return a;
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
        int &a = add();
    
        printf("%d\n", a);
        printf("%d\n", a);
    
        add() = 100;
    
        printf("%d\n", a);
        
        // 接收用户的输入
        getchar();
    
        return 0;
    }
    struct Teacher
    {
        int age;
        char isCool;
    };
    
    Teacher& print1(Teacher &teacher)
    {
        teacher.age = 100;
    
        return teacher;
    }
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
        Teacher teacher;
        teacher.age = 10;
        teacher.isCool = 1;
    
    
        Teacher t = print1(teacher);
    
        // 看两个问题
        // 1、在print1改了age,外面发生了改动吗
    
        printf("%d, %d\n", teacher.age, t.age);
    
    
        //2、print1返回的是传入的对象吗
    
        printf("%X, %X\n", &teacher, &t);
    
        // 接收用户的输入
        getchar();
    
        return 0;
    }

    常量引用

     

    const int &a = b;

    练习

    1、自实现字符串处理库

    2、实现数据结构栈

    3、实现数据结构队列

    展开全文
  • C语言结构体C语言结构体指针,java对象引用,传值,传地址,传引用 传值 把实参值赋值给行参 那么对行参修改,不会影响实参值 传地址 传值一种特殊方式,只是他传递是地址,不是普通如int 那么传地址...

    C语言结构体,C语言结构体指针,java对象引用,传值,传地址,传引用

    传值
    把实参的值赋值给行参
    那么对行参的修改,不会影响实参的值

    传地址
    传值的一种特殊方式,只是他传递的是地址,不是普通的如int
    那么传地址以后,实参和行参都指向同一个对象

    传引用
    真正的以地址的方式传递参数
    传递以后,行参和实参都是同一个对象,只是他们名字不同而已
    对行参的修改将影响实参的值

     

    所谓变量是内存地址的一个抽象名字,在静态编译的程序中,所有变量名都会在编译时转换成内存地址,机器不知道变量名,只知道地址。

    C 语言结构体变量名 在编译后,会变成地址,指向结构体的指针是显示的指明地址,结构体变量名,在编译后变为地址,相当于隐式指明地址。

     

    转载于:https://www.cnblogs.com/loongqiang/p/3751876.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. };  



    /*以下为自引用程序,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那个别名吗?

    转自百度知道:http://zhidao.baidu.com/link?url=bj97sp1QEwGMXnR0tQ2-9PRn2ip2eObrVvTFGORjf4sSjEbK382NurJ-w3VK-6tF539pnYVV10j2wz000bThfq

    提问:

    struct listNode{
       char data;
       struct listNode *nextPtr;
    };
    
    typedef struct listNode ListNode;
    typedef ListNode *ListNodePtr;
    
    请问第二个typedef中那个别名的指针是什么意思,是将那个指针代替ListNode那个别名吗?

    回答:

    typedef ListNode *ListNodePtr;
    的意思是ListNode * 取一个别名为 ListNodePtr
    在定义变量的时候会很方便。
    比如:ListNode * temp;
              ListNodePtr temp;
    它们是一个效果,但是写法会变得简单。

    展开全文
  • c语言结构体

    2014-06-03 18:26:23
    大一c语言课程之c语言结构体。详细讲解了结构体数据类型,结构体变量应用结构体数据类型定义及其变量申明和引用
  • [img=https://img-bbs.csdn.net/upload/202009/12/1599880442_962431.jpg][/img] 怎样对结构体成员引用及赋值、输出操作?
  • 在写栈一个应用时遇见这样...通过这样一个代码引用的时候,会导致程序出现异常 经过一番调试之后发现如果把程序修改成这样,程序就不会有问题 SqStack sq; (&sq)->base = (int*)malloc(sizeof(int)...
  • C语言结构体

    2018-12-17 11:22:00
    C语言结构体初始化四种方法 C语言聚合数据类型包括数组和结构体,其中数组中是相同类型元素集合,可以通过下标引用或之子很间接访问,但结构体各个成员可以是不同数据类型。 结构声明 完整结构声明:...
  • C语言结构体类型定义和使用(一)

    万次阅读 多人点赞 2019-08-16 16:50:39
    0x00 前言 文章中文字可能存在语法错误以及标点错误,请谅解; 如果在文章中发现代码错误或其它问题请告知,感谢! 0x01 结构体类型定义 0x02 结构体类型变量定义 ...0x03 结构体类型变量初始化和引用 ...
  • c语言结构体引用元素“.”与“->”辨析 后缀表达式后跟一个圆点和一个标识符仍是后缀表达式。第一个操作数表达式类型必须是结构或联合,标识符必须是结构或联合成员名字。结果值是结构或联合中命名成员,...
  • 个人认为是C语言实现面向对象编程非常重要的数据类型之一结构体的使用分为定义、引用、初始化,之后还有结构体数组、结构体指针、结构体作为函数参数和包含结构的结构。结构体的定义、引用、初始化定义结构体为用户...
  • 关于结构体引用变量符号 . 和 -&gt; 区别。 目前得到结论是: 变量引用 . 直针引用 -&gt; 如下列程序: struct students{ char*name[10]; long number; char*address[100]; }Stu; //变量...
  • 成员名”方式引用结构体变量中成员,除了这种方法以外还能够使用指针。前面讲过,&student1 表示结构体变量 student1 首地址,即 student1 第一个项地址。若是定义一个指针变量 p 指向这个地址话,p ...
  • C语言结构体指针

    2018-10-04 18:30:42
    结构体指针,C语言结构体指针详解 结构体指针,可细分为指向结构体变量指针和指向结构体数组指针。 指向结构体变量指针 前面我们通过“结构体变量名.成员名”方式引用结构体变量中成员,除了这种方法之外...
  • c语言结构体学习整理(结构体初始化,结构体指针)

    千次阅读 多人点赞 2019-06-02 15:16:47
    1、C语言结构体 1.1几种常用的结构体定义 1.2注意: 2、关于结构体变量的定义和引用 3、结构体的存储(内存对齐) 3.1结构体成员优化 4、结构体自引用 5、结构体的不完整声明 6、结构体传参 结论 7、...
  • 1.概述:结构体变量的引用和赋值,有两种形式,一种是用符号”.”,一种是用符号”->”。结构体指针变量一般用”->”,非结构体指针变量,也就是一般结构体变量,一般用”.”。2.一般结构体变量struct{uint8_t...
  • 结构体 是由一批数据组合而成的一种新的数据类型。组成结构型数据的每个数据称为结构型数据的“成员”。 结构体的声明 struct tag{ member-list; }variavle-list; //例如学生结构体 ...结构体的引用必须使用指针
  • 懒得自己写了,顺便搬过来这是...c语言结构体引用与相互引用: http://blog.csdn.net/daheiantian/article/details/6233058 typedef and struct and 指针: http://blog.sina.com.cn/s/blog_5f70c7060101201e.html
  • 有关结构体数组初始化问题struct _m_usmart_nametab usmart_nametab[]=本文引用地址:http://www.eepw.com.cn/article/201611/322298.htm{#if USMART_USE_WRFUNS==1 //如果使能了读写操作(void*)read_addr,"u32 ...
  • C语言结构体专题

    2020-10-31 09:18:34
    结构体变量的引用 . 结构体变量的指针 -> 02、结构体做函数参数 结构体赋值编译器行为研究 结构体变量做函数参数 PK 结构体指针做函数参数 结构体做函数参数(//结构体赋值和实参形参赋值行为研究) 内存四区调用...
  • C语言结构体变量

    2020-08-25 10:01:46
    结构体是一个或多个变量集合,这些变量可以是不同类型,为了处理方便而将这些变量组织在一个名字之下。...结构体就是将不同类型数据组合成一个有机整体,以便于引用。如定义一个学生信.
  • 第九章 结构体与共用体 第九章 结构体与共用体 结构体 结构体变量的定义 结构体变量的引用 结构体变量的初始化 结构体数组 结构体和指针 共用体 9.1 结构体 结构体是一种构造数据类型 用途把不同类型的数据组合成一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 903
精华内容 361
关键字:

c语言结构体的引用

c语言 订阅