精华内容
下载资源
问答
  • 关注、星标公众号,直达精彩内容来源:技术让梦想更伟大作者:李肖遥最近在做通信协议的解析处理、传递分析等问题,总是遇到通信帧中的结构体拷贝等问题,遇到了一些坑,也是比较基础但是易错的C语言知...

    关注、星标公众号,直达精彩内容

    来源:技术让梦想更伟大

    作者:李肖遥

    最近在做通信协议的解析处理、传递分析等问题,总是遇到通信帧中的结构体拷贝等问题,遇到了一些坑,也是比较基础但是易错的C语言知识,一起来探究一下结构体的深拷贝和浅拷贝。

    浅拷贝

    C语言中的浅拷贝是指在拷贝过程中,对于指针型成员变量只拷贝指针本身,而不拷贝指针所指向的目标,它按字节复制的。我们分几种情况举例子来看一下。

    结构体中不存在指针成员变量时

    代码如下:

    //在win10_64位+vs2017
    //来源:技术让梦想更伟大
    //作者:李肖遥
    #include <stdio.h>
    typedef struct {
        char name[64];
        int age;
    }Member;
    
    int main(){
        Member stu1 = { "LiMing", 18 };
        Member stu2;
        stu2 = stu1;
        printf("%s,%d\n", stu2.name, stu2.age);
        system("pause");
        return 0;
    }
    

    运行如下:

    结构体中存在指针成员变量时

    代码如下:

    //在win10_64位+vs2017
    //来源:技术让梦想更伟大
    //作者:李肖遥
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    typedef struct {
     char *name;
     int age;
    }Member;
    
    int main() {
     Member Member1, Member2;
     Member1.name = malloc(sizeof(char) * 64);
     if (NULL == Member1.name)
     {
      printf("malloc failed\n");
     }
     memset(Member1.name, 0, 64);
     //strcpy(Member1.name, "LiMing");
     snprintf(Member1.name, 64, "LiMing");
     Member1.age = 18;
    
     Member2 = Member1;/*拷贝*/
     snprintf(Member2.name, 64, "LiXiaoYao");
     Member2.age = 29;
    
     printf("%s, %d\n", Member1.name, Member1.age);
    
     if (NULL != Member1.name) {
      free(Member1.name);
      Member1.name = NULL;
     }
    
     system("pause");
     return 0;
    }
    

    运行如下:

    从中我们看到,改变Member2的值,Member1的值也改变了,这说明一片空间被两个不同的子对象共享了,改变一个对象的值另外一个也会随之改变。

    我们改变Member2写法,申请内存的代码如下:

    //在win10_64位+vs2017
    //来源:技术让梦想更伟大
    //作者:李肖遥
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    typedef struct {
     char *name;
     int age;
    }Member;
    
    int main() {
     Member Member1;
     Member1.name = malloc(sizeof(char) * 64);
     if (NULL == Member1.name)
     {
      printf("malloc failed\n");
     }
     memset(Member1.name, 0, 64);
     //strcpy(Member1.name, "LiMing");
     snprintf(Member1.name, 64, "LiMing");
     Member1.age = 18;
      
      Member Member2;
     Member2.name = malloc(sizeof(char) * 64);
     if (NULL == Member2.name)
     {
      printf("malloc failed\n");
     }
     memset(Member2.name, 0, 64);
     //strcpy(Member2.name, "LiMing");
     snprintf(Member2.name, 64, "LiXiaoYao");
     Member2.age = 29;
    
     Member1 = Member2;
    
     printf("%s, %d\n", Member2.name, Member2.age);
    
     if (NULL != Member1.name) {
      free(Member1.name);
      Member1.name = NULL;
     }
     if (NULL != Member2.name) {
      free(Member2.name);
      Member2.name = NULL;
     }
     system("pause");
     return 0;
    }
    

    运行如下:

    从中我们看到,当数据成员中有指针时,两个类中的两个指针将指向同一个地址,当对象快结束时,会调用两次free函数,此时Member2已经是野指针(图中有X的错误标志),这个野指针指向的内存空间已经被释放掉,再次释放会报异常错误,要解决这个问题就要涉及到深拷贝了。

    深拷贝

    深拷贝除了拷贝其成员本身的值之外,还拷贝成员指向的动态内存区域内容,深拷贝会在堆内存中另外申请空间来储存数据。

    解决的思路是在释放掉被赋值指针变量的旧指向内存时,重新对其开辟新内存,这种情况下两个结构体中指针地址不同,但是指向的内容是一致的。代码如下:

    //在win10_64位+vs2017
    //来源:技术让梦想更伟大
    //作者:李肖遥
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct {
     char *name;
     int age;
    }Member;
    
    int main() {
     Member Member1;
     Member1.name = malloc(sizeof(char) * 64);
     if (NULL == Member1.name)
     {
      printf("malloc failed\n");
     }
     memset(Member1.name, 0, 64);
     //strcpy(Member1.name, "LiMing");
     snprintf(Member1.name, 64, "LiMing");
     Member1.age = 18;
    
      Member Member2;
     Member2.name = malloc(sizeof(char) * 64);
     if (NULL == Member2.name)
     {
      printf("malloc failed\n");
     }
     memset(Member2.name, 0, 64);
     //strcpy(Member2.name, "LiMing");
     snprintf(Member2.name, 64, "LiXiaoYao");
     Member2.age = 29;
    
     if (Member1.name != NULL) {
      free(Member1.name);
      Member1.name = NULL;
     }
     Member1.name = malloc(strlen(Member2.name) + 1);
     strcpy(Member1.name, Member2.name);
    
     printf("%s, %d\n", Member1.name, Member1.age);
    
     if (NULL != Member1.name) {
      free(Member1.name);
      Member1.name = NULL;
     }
     if (NULL != Member2.name) {
      free(Member2.name);
      Member2.name = NULL;
     }
     system("pause");
     return 0;
    }
    

    运行如下:

    结论

    使用C语言来说,深拷贝浅拷贝的概念我们不需要深究,在进行结构体拷贝的时候,结构体成员是非指针的话,那么直接赋值是没有任何问题的,建议使用这种方式,避免浅拷贝这类不易发现的错误产生。

    如果成员有指针类型,我们就需要重写拷贝函数,自己定义拷贝行为了,这一点我们需要尤为注意。

    ‧‧‧‧‧‧‧‧‧‧‧‧‧‧‧‧  END  ‧‧‧‧‧‧‧‧‧‧‧‧‧‧‧‧

    推荐阅读:

    嵌入式编程专辑Linux 学习专辑C/C++编程专辑
    Qt进阶学习专辑
    

    关注我的微信公众号,回复“加群”按规则加入技术交流群。


    点击“阅读原文”查看更多分享。

    展开全文
  • 最近在做通信协议的解析处理、传递分析等问题,总是遇到通信帧中的结构体拷贝等问题,遇到了一些坑,也是比较基础但是易错的C语言知识,一起来探究一下结构体的深拷贝和浅拷贝。浅拷贝C语言中的浅拷贝...

    最近在做通信协议的解析处理、传递分析等问题,总是遇到通信帧中的结构体拷贝等问题,遇到了一些坑,也是比较基础但是易错的C语言知识,一起来探究一下结构体的深拷贝和浅拷贝。

    浅拷贝

    C语言中的浅拷贝是指在拷贝过程中,对于指针型成员变量只拷贝指针本身,而不拷贝指针所指向的目标,它按字节复制的。我们分几种情况举例子来看一下。

    结构体中不存在指针成员变量时

    代码如下:

    //在win10_64位+vs2017
    //来源:技术让梦想更伟大
    //作者:李肖遥
    #include <stdio.h>
    typedef struct {
        char name[64];
        int age;
    }Member;
    
    int main(){
        Member stu1 = { "LiMing", 18 };
        Member stu2;
        stu2 = stu1;
        printf("%s,%d\n", stu2.name, stu2.age);
        system("pause");
        return 0;
    }
    

    运行如下:

    结构体中存在指针成员变量时

    代码如下:

    //在win10_64位+vs2017
    //来源:技术让梦想更伟大
    //作者:李肖遥
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    typedef struct {
     char *name;
     int age;
    }Member;
    
    int main() {
     Member Member1, Member2;
     Member1.name = malloc(sizeof(char) * 64);
     if (NULL == Member1.name)
     {
      printf("malloc failed\n");
     }
     memset(Member1.name, 0, 64);
     //strcpy(Member1.name, "LiMing");
     snprintf(Member1.name, 64, "LiMing");
     Member1.age = 18;
    
     Member2 = Member1;/*拷贝*/
     snprintf(Member2.name, 64, "LiXiaoYao");
     Member2.age = 29;
    
     printf("%s, %d\n", Member1.name, Member1.age);
    
     if (NULL != Member1.name) {
      free(Member1.name);
      Member1.name = NULL;
     }
    
     system("pause");
     return 0;
    }
    

    运行如下:

    从中我们看到,改变 Member2 的值,Member1 的值也改变了,这说明一片空间被两个不同的子对象共享了,改变一个对象的值另外一个也会随之改变。

    我们改变 Member2 写法,申请内存的代码如下:

    //在win10_64位+vs2017
    //来源:技术让梦想更伟大
    //作者:李肖遥
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    typedef struct {
     char *name;
     int age;
    }Member;
    
    int main() {
     Member Member1;
     Member1.name = malloc(sizeof(char) * 64);
     if (NULL == Member1.name)
     {
      printf("malloc failed\n");
     }
     memset(Member1.name, 0, 64);
     //strcpy(Member1.name, "LiMing");
     snprintf(Member1.name, 64, "LiMing");
     Member1.age = 18;
      
      Member Member2;
     Member2.name = malloc(sizeof(char) * 64);
     if (NULL == Member2.name)
     {
      printf("malloc failed\n");
     }
     memset(Member2.name, 0, 64);
     //strcpy(Member2.name, "LiMing");
     snprintf(Member2.name, 64, "LiXiaoYao");
     Member2.age = 29;
    
     Member1 = Member2;
    
     printf("%s, %d\n", Member2.name, Member2.age);
    
     if (NULL != Member1.name) {
      free(Member1.name);
      Member1.name = NULL;
     }
     if (NULL != Member2.name) {
      free(Member2.name);
      Member2.name = NULL;
     }
     system("pause");
     return 0;
    }
    

    运行如下:

    从中我们看到,当数据成员中有指针时,两个类中的两个指针将指向同一个地址,当对象快结束时,会调用两次 free 函数,此时 Member2 已经是野指针(图中有X的错误标志),这个野指针指向的内存空间已经被释放掉,再次释放会报异常错误,要解决这个问题就要涉及到深拷贝了。

    深拷贝

    深拷贝除了拷贝其成员本身的值之外,还拷贝成员指向的动态内存区域内容,深拷贝会在堆内存中另外申请空间来储存数据。

    解决的思路是在释放掉被赋值指针变量的旧指向内存时,重新对其开辟新内存,这种情况下两个结构体中指针地址不同,但是指向的内容是一致的。代码如下:

    //在win10_64位+vs2017
    //来源:技术让梦想更伟大
    //作者:李肖遥
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct {
     char *name;
     int age;
    }Member;
    
    int main() {
     Member Member1;
     Member1.name = malloc(sizeof(char) * 64);
     if (NULL == Member1.name)
     {
      printf("malloc failed\n");
     }
     memset(Member1.name, 0, 64);
     //strcpy(Member1.name, "LiMing");
     snprintf(Member1.name, 64, "LiMing");
     Member1.age = 18;
    
      Member Member2;
     Member2.name = malloc(sizeof(char) * 64);
     if (NULL == Member2.name)
     {
      printf("malloc failed\n");
     }
     memset(Member2.name, 0, 64);
     //strcpy(Member2.name, "LiMing");
     snprintf(Member2.name, 64, "LiXiaoYao");
     Member2.age = 29;
    
     if (Member1.name != NULL) {
      free(Member1.name);
      Member1.name = NULL;
     }
     Member1.name = malloc(strlen(Member2.name) + 1);
     strcpy(Member1.name, Member2.name);
    
     printf("%s, %d\n", Member1.name, Member1.age);
    
     if (NULL != Member1.name) {
      free(Member1.name);
      Member1.name = NULL;
     }
     if (NULL != Member2.name) {
      free(Member2.name);
      Member2.name = NULL;
     }
     system("pause");
     return 0;
    }
    

    运行如下:

    结论

    使用C语言来说,深拷贝浅拷贝的概念我们不需要深究,在进行结构体拷贝的时候,结构体成员是非指针的话,那么直接赋值是没有任何问题的,建议使用这种方式,避免浅拷贝这类不易发现的错误产生。

    如果员有指针类型,我们就需要重写拷贝函数,自己定义拷贝行为了,这一点我们需要尤为注意。

    1.如何应对AIoT对芯片的碎片化需求?

    2.2021你值得入手的嵌入式系统线上课程在这里!

    3.嵌入式编程中使用qemu能够做什么?

    4.曝英特尔拟20亿美元收购SiFive!

    5.英伟达的阳谋,收购Arm的危险讯号︱调研英伟达收购Arm影响

    6.华为官方通知:鸿蒙不再属于华为!

    免责声明:本文系网络转载,版权归原作者所有。如涉及作品版权问题,请与我们联系,我们将根据您提供的版权证明材料确认版权并支付稿酬或者删除内容。

    展开全文
  • #include #include<string.h>//定义一个结构体,名为Student struct Student { int sid; int age; char name[200]; } int main(void) { struct Student st = {2017, 21, "Zhangsan"}; printf("si
    #include<stdio.h>
    #include<string.h>
    
    //定义一个结构体,名为Student
    struct Student 
    {
        int sid;
        int age;
        char name[200];
    }
    int main(void)
    {
        struct Student st = {2017, 21, "Zhangsan"};
        printf("sid = %d, age = %d, name = %s", st.sid, st.age, st.name);    //正确
        st.age = 21;
        st.sid = 2016;
        st.name = "zhangsan";       //字符串赋值是错误的,不允许这样赋值
        /*正确赋值方法*/
        strcpy(st.name, "zhangsan");   
    
        return 0;
    }
    展开全文
  • C语言结构体直接赋值

    万次阅读 多人点赞 2018-10-21 10:47:29
    FROM:http://codewenda.com/c语言结构体直接赋值/ 在C语言中结构体变量之间可以进行赋值操作吗? 简单结构体的赋值 先说结论:一般来说,C语言中的结构体变量可以用另一个变量对其进行赋值或初始化。简单结构体...

    FROM:http://codewenda.com/c语言结构体直接赋值/

    在C语言中结构体变量之间可以进行赋值操作吗?

    简单结构体的赋值

    先说结论:一般来说,C语言中的结构体变量可以用另一个变量对其进行赋值或初始化。简单结构体(不包含指针成员)直接赋值没有问题。
    我们先下面一段代码:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    #include <stdio.h>

    #include <stdlib.h>

     

    struct MyStruct

    {

        int a;

        int b;

        char c[10];

    };

     

    int main()

    {

        struct MyStruct t1 = {1, 2, "hello"};

        struct MyStruct t2 = {3, 4, "world"};

        t2 = t1; //将t1赋值给t2

        printf("MyStruct t1: %d, %d, %s\n", t1.a, t1.b, t1.c);

        printf("MyStruct t2: %d, %d, %s\n", t2.a, t2.b, t2.c);

     

        return 0;

    }

    以上代码的输出为:

    1

    2

    MyStruct t1: 1, 2, hello

    MyStruct t2: 1, 2, hello

    以上用t1给t2进行初始化,结果也相同。可以看到简单的结构体(结构体的成员没有指针成员)变量之间直接赋值是没有问题的。

    有指针成员的结构体赋值

    而通常情况下,稍微复杂一点的结构体里面会有指针成员,那么以上的浅拷贝则会有问题了,我们假设MyStruct里面的成员c不是数组,而是字符指针,会有什么问题呢?
    看如下代码:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    #include <stdio.h>

    #include <stdlib.h>

    #include <string.h>

     

    struct MyStruct

    {

        int a;

        int b;

        char* c;

    };

     

    int main()

    {

        struct MyStruct t1;

        t1.a = 1;

        t1.b = 2;

        // 为指针区域赋值

        char *p = (char*)malloc(10*sizeof(char));

        strcpy(p, "hello");

        t1.c = p;

     

        struct MyStruct t2;

        t2 = t1;

        printf("MyStruct t1: %d, %d, %s\n", t1.a, t1.b, t1.c);

        // 释放了t1的内存

        // free(p);

        printf("MyStruct t2: %d, %d, %s\n", t2.a, t2.b, t2.c);

     

     

        printf("t1 pointer addr: %p\n", t1.c);

        printf("t2 pointer addr: %p\n", t2.c);

     

        return 0;

    }

    上面的输出结果为:

    1

    2

    3

    4

    MyStruct t1: 1, 2, hello

    MyStruct t2: 1, 2, hello

    t1 pointer addr: 0x6000284d0

    t2 pointer addr: 0x6000284d0

    可以看到,赋值会直接将t1的指针变量赋值给t2.c,如果我们在赋值之后将t1所用的资源释放掉,那么使用t2的话则可能导致内存泄漏了。如果上面的代码,我们没有注释掉 free(p);,那么输出t2时结果这不确定了:

    1

    2

    3

    4

    MyStruct t1: 1, 2, hello

    MyStruct t2: 1, 2, (/.?

    t1 pointer addr: 0x6000284d0

    t2 pointer addr: 0x6000284d0

     

    所以,如果struct中有指针成员,那么结构体赋值不能简单的直接复制了,而需要为指针成员另外分配内存,并将数据拷贝过去,当然我们可以将这些处理封装在单独的函数中来完成。
    示例代码如下:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    #include <stdio.h>

    #include <stdlib.h>

    #include <string.h>

     

    struct MyStruct

    {

        int a;

        int b;

        char* c;

    };

     

    int main()

    {

        struct MyStruct t1;

        t1.a = 1;

        t1.b = 2;

        // 为指针区域赋值

        char *p = (char*)malloc(10*sizeof(char));

        strcpy(p, "hello");

        t1.c = p;

     

        struct MyStruct t2;

        // 各个成员分别赋值,可以进行封装

        t2.a = t1.a;

        t2.b = t1.b;

        char *p2 = (char*)malloc(10*sizeof(char));

        strcpy(p2, t1.c);

        t2.c = p2;

     

        printf("MyStruct t1: %d, %d, %s\n", t1.a, t1.b, t1.c);

        // 释放了t1的内存

        free(p);

        printf("MyStruct t2: %d, %d, %s\n", t2.a, t2.b, t2.c);

        // 释放了t2的内存

        free(p2);

     

        printf("t1 pointer addr: %p\n", t1.c);

        printf("t2 pointer addr: %p\n", t2.c);

     

        return 0;

    }

    以上代码输出结果为:

    1

    2

    3

    4

    MyStruct t1: 1, 2, hello

    MyStruct t2: 1, 2, hello

    t1 pointer addr: 0x6000284d0

    t2 pointer addr: 0x600062e10

     

    展开全文
  • FROM:http://codewenda.com/c语言结构体直接赋值/ 在C语言中结构体变量之间可以进行赋值操作吗? 简单结构体的赋值 先说结论:一般来说,C语言中的结构体变量可以用另一个变量对其进行赋值或初始化。简单结构体...
  • C语言结构体能否整体赋值

    千次阅读 2020-09-01 17:54:17
    C语言结构体的能否整体赋值 先放结论 可以将一个结构体变量的值赋给另一个具有相同结构的结构体变量,但是需要满足一个条件。 整体赋值规则 ansi/iso C规定:“相同类型的结构体是可以直接赋值的”; 合法赋值: 如...
  • c语言结构体赋值问题

    2020-07-03 10:15:18
    一般来说,C语言中的结构体变量可以用另一个变量对其进行赋值或初始化。简单结构体(不包含指针成员)直接赋值没有问题。但是稍微复杂一点的结构体里面会 有指针成员,那么以上的浅拷贝则会有问题。 1)赋值会直接将...
  • 1结构体赋值 #include <windows.h> struct MyStruct { int a; int b; char c[20]; }; int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int ..
  • C语言结构体赋值问题

    2019-09-20 14:44:46
    之前的系统参数用一个结构体变量tempBasicInfo来保存,成员类型有:uint8_t、uint16_t、结构体,结构体成员为uint8_t、uint16_t;今天需要添加一系列参数,用了一个uint8_t和三个uint8_t数组;以前配置完tempBasic.....
  • 结构体如下 struct ff{ int b; int *c; }; struct ff *p=(struct ff *)malloc(sizeof(struct)); p->c=(int *)malloc(sizeof(int)*5); *(p->c+1)=5; 最后一句这样的指针运算,引用,赋值。是否合法。
  • // // Created by kangs on 2020/9/2. // #include <stdio.h> #include <string.h> struct Books { char title[50]; char author[50]; char subject[100];... /* 声明 Book1,类型
  • 134_C语言结构体成员定义时初始化

    千次阅读 2019-08-23 20:17:35
    在此之前,定义结构体类型的变量的时候我一般不会初始化,必须初始化的先定义之后再赋值。因为觉得直接定义起来,有一点点麻烦。今天看了一段别人的代码,也是第一次看到这种风格的代码。我在好奇,究竟是我当初...
  • C语言结构体

    2021-01-15 08:26:13
    C语言结构体 一、结构体基础知识 1.结构体类型的定义 2.结构体变量的定义 3.结构体变量的初始化 4.结构体成员的使用 5.结构体赋值 赋值基本概念 深拷贝和浅拷贝 6.结构体数组 struct Person{ char name[64]; ...
  • C语言结构体赋值

    千次阅读 2015-05-09 00:08:13
    对一个结构体赋值时,经常采用的方式是,分别对其成员变量赋值。那么能否将一个结构体赋值号(“=”)直接赋值给另一个结构体呢?网上的答案不一,有说可以的,有说不可以的,有说这样的话两个结构体共用一块内存...
  • C语言结构体浅见

    千次阅读 多人点赞 2020-11-23 03:12:40
    文章目录前言一、对结构体的理解1、整(数)型:2、浮点型3、字符型二、结构体的定义1.标准定义的格式说明2.含typedef定义的格式说明三....最忙碌的一周已然结束,疲惫之余想和大家聊一聊对C语言结构体
  • 1 对成员赋值.例如结构体struct st1 {int a;int b;int c;}1.1 用{}形式.struct st1 st1 = {1,2,3);1.2 linux kernel风格.struct st1 st1 =...
  • C语言 结构体 共用体

    2020-09-22 19:21:37
    C语言 结构体 结构体 结构体 1、结构体定义 a、 struct 结构体名称{ 成员列表; }; struct 结构体名称 结构体变量名;... 创建结构体变量后需要给成员赋值,没有赋值就使用会导致程序异常; 4> 结构体
  • 如何对结构体成员赋值和初始化

    万次阅读 2013-01-13 14:34:18
    // 结构体赋值和初始化.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include //定义结构体 struct Student { float score; char sex; char name[20]; }; int main(void) {...
  • C语言 结构体

    2020-09-05 14:07:48
    1.结构体 类似于java中的对象(student.java) 1)结构体的定义(关键字 struct) ... 2)结构体成员的内存布局 结构体所占的空间为各成员变量的所占空间之和(注意字节对齐,下面总结) 各成员变量
  • C语言结构体初始化的四种方法 ericbars 2018-03-15 17:17:19 160301 收藏 183 分类专栏: 技术基础 文章标签: 结构体初始化 C语言 版权 定义 struct InitMember { int first; double second; char* third; ...
  • c语言 结构体

    2018-12-11 20:55:40
    根据某一成员进行排序: 注意:结构体可以直接进行赋值。可以把结构体当作普通的变量去使用。 结构体所占的空间:
  • C语言结构体知识温故知新1. 定义一个结构体的一般形式2. 结构类型变量的说明3. 结构变量成员的表示方法4. 结构体变量的赋值5. 结构变量的初始化6. 结构数组的定义7. 结构指针变量的说明和使用(1). 指向结构变量的...
  • 1、结构体形式: struct 结构体名 { 结构体成员; } 结构变量; 示例 1 定义结构体,也定义一个结构体变量: struct student { int age; //结构体成员 ... //结构体成员赋值 stu1.name = 'Z'; ...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 327
精华内容 130
关键字:

c语言结构体成员赋值

c语言 订阅