struct_structs - CSDN
struct 订阅
struct即结构体,亦被直接称为“结构”。实际编程时,经常需要用相关的不同类型的数据来描述一个数据对象。例如,描述学生的综合信息时,需要使用学生的学号、姓名、性别、成绩以及家庭住址等不同类型的数据。但是,用相关的不同类型的数据来描述一个数据对象会使编程极为不便。因此,C语言提供了一种称为结构体(struct)的数据类型,以描述需要不同类型数据的数据对象 [1]  。 展开全文
struct即结构体,亦被直接称为“结构”。实际编程时,经常需要用相关的不同类型的数据来描述一个数据对象。例如,描述学生的综合信息时,需要使用学生的学号、姓名、性别、成绩以及家庭住址等不同类型的数据。但是,用相关的不同类型的数据来描述一个数据对象会使编程极为不便。因此,C语言提供了一种称为结构体(struct)的数据类型,以描述需要不同类型数据的数据对象 [1]  。
信息
别    称
结构
类    别
C/C++关键词
构    成
由若干“成员”组成
释    义
一种构造数据类型
中文名
结构体
外文名
Structure type
struct构成
“结构”是一种构造类型,它是由若干“成员”组成的。 每一个成员可以是一个基本数据类型或者又是一个构造类型。 结构即是一种“构造”而成的数据类型, 那么在说明和使用之前必须先定义它,也就是构造它。如同在说明和调用函数之前要先定义一样。  “结构体”是由一些逻辑相关的数据栏或称为“字段”(Field)所构成。例如,一位学生的学号、姓名、生日……即是一条记录,该结构体拥有“姓名”栏、“语文”栏、“英文”栏,而一群学生的记录集合就是一个结构体数组 [2]  。
收起全文
精华内容
参与话题
  • C语言中的struct用法

    万次阅读 多人点赞 2019-02-19 21:41:25
    结构(struct)  结构是由基本数据类型构成的、并用一个标识符来命名的各种变量的组合。  结构中可以使用不同的数据类型。   1. 结构说明和结构变量定义   在Turbo C中, 结构也是一种数据类型, 可以使用结构...

    结构(struct)

         结构是由基本数据类型构成的、并用一个标识符来命名的各种变量的组合。 

    结构中可以使用不同的数据类型。 

        1. 结构说明和结构变量定义 

        在Turbo C中, 结构也是一种数据类型, 可以使用结构变量, 因此,  象其它 

    类型的变量一样, 在使用结构变量时要先对其定义。 

        定义结构变量的一般格式为: 

         struct 结构名 

         { 

              类型  变量名; 

              类型  变量名; 

              ... 

         } 结构变量; 

        结构名是结构的标识符不是变量名。 

        类型为第二节中所讲述的五种数据类型(整型、浮点型、字符型、指针型和 

    无值型)。 

        构成结构的每一个类型变量称为结构成员, 它象数组的元素一样, 但数组中 

    元素是以下标来访问的, 而结构是按变量名字来访问成员的。 

        下面举一个例子来说明怎样定义结构变量。 

         struct string 

         { 

              char name[8]; 

              int age; 

              char sex[2]; 

              char depart[20]; 

              float wage1, wage2, wage3, wage4, wage5; 

         } person; 

        这个例子定义了一个结构名为string的结构变量person,   如果省略变量名 

    person, 则变成对结构的说明。用已说明的结构名也可定义结构变量。这样定义 

    时上例变成: 

         struct string 

         { 

              char name[8]; 

              int age; 

              char sex[2]; 

              char depart[20]; 

              float wage1, wage2, wage3, wage4, wage5; 

         }; 

         struct string person; 

        如果需要定义多个具有相同形式的结构变量时用这种方法比较方便, 它先作 

    结构说明, 再用结构名来定义变量。 

        例如: 

         struct string Tianyr, Liuqi, ...; 

        如果省略结构名, 则称之为无名结构, 这种情况常常出现在函数内部, 用这 

    种结构时前面的例子变成: 

         struct 

         { 

              char name[8]; 

              int age; 

              char sex[2]; 

              char depart[20]; 

              float wage1, wage2, wage3, wage4, wage5; 

         } Tianyr, Liuqi; 

        2. 结构变量的使用 

        结构是一个新的数据类型, 因此结构变量也可以象其它类型的变量一样赋值、 

    运算, 不同的是结构变量以成员作为基本变量。 

        结构成员的表示方式为: 

              结构变量.成员名 

        如果将"结构变量.成员名"看成一个整体,  则这个整体的数据类型与结构中 

    该成员的数据类型相同, 这样就可象前面所讲的变量那样使用。 

        下面这个例子定义了一个结构变量, 其中每个成员都从键盘接收数据, 然后 

    对结构中的浮点数求和, 并显示运算结果, 同时将数据以文本方式存入一个名为 

    wage.dat的磁盘文件中。请注意这个例子中不同结构成员的访问。 

        例3: 

         #i nclude <stdio.h> 

         main() 

         { 

              struct{                  /*定义一个结构变量*/ 

                   char name[8]; 

                   int age; 

                   char sex[2]; 

                   char depart[20]; 

                   float wage1, wage2, wage3, wage4, 

    wage5; 

              }a; 

              FILE *fp; 

              float wage; 

              char c=’Y’; 

              fp="fopen"("wage.dat", "w");    

    /*创建一个文件只写*/ 

              while(c==’Y’||c==’y’)         

    /*判断是否继续循环*/ 

              { 

                   printf("/nName:"); 

                   scanf("%s", a.name);     /*输入姓名*/ 

                   printf("Age:"); 

                   scanf("%d", &a.wage);    /*输入年龄*/ 

                   printf("Sex:"); 

                   scanf("%d", a.sex); 

                   printf("Dept:"); 

                   scanf("%s", a.depart); 

                   printf("Wage1:"); 

                   scanf("%f", &a.wage1);   /*输入工资*/ 

                   printf("Wage2:"); 

                   scanf("%f", &a.wage2); 

                   printf("Wage3:"); 

                   scanf("%f", &a.wage3); 

                   printf("Wage4:"); 

                   scanf("%f", &a.wage4); 

                   printf("Wage5:"); 

                   scanf("%f", &a.wage5); 

                   

    wage=a.wage1+a.wage2+a.wage3+a.wage4+a.wage5; 

                   printf("The sum of wage is 

    %6.2f/n", wage);/*显示结果*/ 

                   fprintf(fp, 

    "%10s%4d%4s%30s%10.2f/n",  /*结果写入文件*/ 

                                a.name, a.age, a.sex, 

    a.depart, wage); 

                   while(1) 

                   { 

                        printf("Continue?<Y/N>"); 

                        c="getche"(); 

                        

    if(c==’Y’||c==’y’||c==’N’||c==’n’) 

                             break; 

                   } 

              } 

              fclose(fp); 

         } 

        3. 结构数组和结构指针 

        结构是一种新的数据类型, 同样可以有结构数组和结构指针。 

        一、结构数组 

        结构数组就是具有相同结构类型的变量集合。假如要定义一个班级40个同学 

    的姓名、性别、年龄和住址, 可以定义成一个结构数组。如下所示: 

         struct{ 

              char name[8]; 

              char sex[2]; 

              int age; 

              char addr[40]; 

         }student[40]; 

        也可定义为: 

         struct string{ 

              char name[8]; 

              char sex[2]; 

              int age; 

              char addr[40]; 

         }; 

         struct string student[40]; 

        需要指出的是结构数组成员的访问是以数组元素为结构变量的, 其形式为: 

              结构数组元素.成员名 

        例如: 

          student[0].name 

          student[30].age 

        实际上结构数组相当于一个二维构造, 第一维是结构数组元素, 每个元素是 

    一个结构变量, 第二维是结构成员。 

        注意: 

        结构数组的成员也可以是数组变量。 

        例如: 

         struct a 

         { 

              int m[3][5]; 

              float f; 

              char s[20]; 

         }y[4]; 

        为了访问结构a中结构变量y[2]的这个变量, 可写成 

           y[2].m[1][4] 

        二、结构指针 

        结构指针是指向结构的指针。它由一个加在结构变量名前的"*" 操作符来定 

    义, 例如用前面已说明的结构定义一个结构指针如下: 

         struct string{ 

              char name[8]; 

              char sex[2]; 

              int age; 

              char addr[40]; 

         }*student; 

        也可省略结构指针名只作结构说明, 然后再用下面的语句定义结构指针。 

          struct string *student; 

        使用结构指针对结构成员的访问, 与结构变量对结构成员的访问在表达方式 

    上有所不同。结构指针对结构成员的访问表示为: 

           结构指针名->结构成员 

        其中"->"是两个符号"-"和">"的组合, 好象一个箭头指向结构成员。例如要 

    给上面定义的结构中name和age赋值, 可以用下面语句: 

         strcpy(student->name, "Lu G.C"); 

         student->age=18; 

        实际上, student->name就是(*student).name的缩写形式。 

        需要指出的是结构指针是指向结构的一个指针, 即结构中第一个成员的首地 

    址, 因此在使用之前应该对结构指针初始化, 即分配整个结构长度的字节空间, 

    这可用下面函数完成, 仍以上例来说明如下: 

         student=(struct string*)malloc(size of 

    (struct string)); 

        size of (struct string)自动求取string结构的字节长度, 

    malloc() 函数 

    定义了一个大小为结构长度的内存区域, 然后将其诈地址作为结构指针返回。 

        注意: 

        1. 结构作为一种数据类型,  因此定义的结构变量或结构指针变量同样有局 

    部变量和全程变量, 视定义的位置而定。 

        2. 结构变量名不是指向该结构的地址, 这与数组名的含义不同,  因此若需 

    要求结构中第一个成员的首地址应该是&[结构变量名]。 

        4. 结构的复杂形式 

        一、嵌套结构 

        嵌套结构是指在一个结构成员中可以包括其它一个结构, Turbo C 允许这种 

    嵌套。 

        例如: 下面是一个有嵌套的结构 

         struct string{ 

              char name[8]; 

              int age; 

              struct addr address; 

         } student; 

        其中: addr为另一个结构的结构名, 必须要先进行, 说明, 即 

         struct addr{ 

              char city[20]; 

              unsigned lon zipcode; 

              char tel[14]; 

         } 

        如果要给student结构中成员address结构中的zipcode赋值, 则可写成: 

          student.address.zipcode=200001; 

        每个结构成员名从最外层直到最内层逐个被列出, 即嵌套式结构成员的表达 

    方式是: 

          结构变量名.嵌套结构变量名.结构成员名 

        其中: 嵌套结构可以有很多, 结构成员名为最内层结构中不是结构的成员名。 

      

        二、位结构 

        位结构是一种特殊的结构, 在需按位访问一个字节或字的多个位时, 位结构 

    比按位运算符更加方便。 

        位结构定义的一般形式为: 

         struct位结构名{ 

              数据类型 变量名: 整型常数; 

              数据类型 变量名: 整型常数; 

         } 位结构变量; 

        其中: 数据类型必须是int(unsigned或signed)。 整型常数必须是非负的整 

    数, 范围是0~15, 表示二进制位的个数, 即表示有多少位。 

        变量名是选择项, 可以不命名, 这样规定是为了排列需要。 

        例如: 下面定义了一个位结构。 

         struct{ 

              unsigned incon: 8;  

    /*incon占用低字节的0~7共8位*/ 

              unsigned txcolor: 

    4;/*txcolor占用高字节的0~3位共4位*/ 

              unsigned bgcolor: 

    3;/*bgcolor占用高字节的4~6位共3位*/ 

              unsigned blink: 1;  /*blink占用高字节的第7位*/ 

         }ch; 

        位结构成员的访问与结构成员的访问相同。 

        例如: 访问上例位结构中的bgcolor成员可写成: 

          ch.bgcolor 

      

        注意: 

        1. 位结构中的成员可以定义为unsigned, 也可定义为signed,  但当成员长 

    度为1时, 会被认为是unsigned类型。因为单个位不可能具有符号。 

        2. 位结构中的成员不能使用数组和指针, 但位结构变量可以是数组和指针, 

    如果是指针, 其成员访问方式同结构指针。 

        3. 位结构总长度(位数), 是各个位成员定义的位数之和,  可以超过两个字 

    节。 

        4. 位结构成员可以与其它结构成员一起使用。 

        例如: 

         struct info{ 

              char name[8]; 

              int age; 

              struct addr address; 

              float pay; 

              unsigned state: 1; 

              unsigned pay: 1; 

              }workers;’ 

        上例的结构定义了关于一个工从的信息。其中有两个位结构成员, 每个位结 

    构成员只有一位, 因此只占一个字节但保存了两个信息, 该字节中第一位表示工 

    人的状态, 第二位表示工资是否已发放。由此可见使用位结构可以节省存贮空间。 

    以下是个人观点:

    补充一点知识:typedef定义结构体的

    例如:

    typedef struct  person {

     

    int age ;

    char *name;

    char *sex;

    } student;

     

    我们可以用student来定义一个结构体变量:student stu1;typedef的作用就相当于给你struct person取了一个别名,如果我们不用typedef定义我们就不能用student定义,此时student就是一个结构体变量,如果要定义结构体变量的话就得用struct person来定义 struct person stu1.

     

    typedef的其它定义:

    typedef char name[51];

    如果想要定义多个相同类型长51的数组,我们可以直接用name定义比如name sex;可能大家对这里不太好理解,如果看过关于数据类型的介绍方面的知识大家就很好理解了,或者经常用java编写程序的就很好理解的

    其实我们可以可以把 typedef char name【51】看作 typedef char【51】name,更具typedef的语法可以知道name是给 char name 【51】取得别名。这些知道怎么回事了吧。

    其实c结构体和对象编程 像java等里面的类是非常相似的。不过像C++里面对结构体进行了扩展,c++里面的结构体是可以包含方法的,但是C里面是不能够的。

    展开全文
  • struct(结构体)

    千次阅读 2018-02-01 22:27:06
    在实际问题中,一组数据往往具有不同的数据类型。  例如, 在学生登记表中,姓名应为字符型(char[]);学号可为整型(int)或字符型(char[]);年龄应为整型(char);性别应为字符型(char);成绩可为整型(int)或实型...

         在实际问题中,一组数据往往具有不同的数据类型。

        例如, 在学生登记表中,姓名应为字符型(char[]);学号可为整型(int)或字符型(char[]);年龄应为整型(char);性别应为字符型(char);成绩可为整型(int)或实型(double)。 显然不能用一个数组来存放这一组数据。 因为数组中各元素的类型和长度都必须一致,以便于编译系统处理。为了解决这个问题,C语言中给出了另一种构造数据类型——“结构”。

       “结构”是一种构造类型,它是由若干“成员”组成的。 每一个成员可以是一个基本数据类型或者又是一个构造类型。 结构即是一种“构造”而成的数据类型, 那么在说明和使用之前必须先定义它,也就是构造它。如同在说明和调用函数之前要先定义一样。

    1.定义结构体及结构体变量

    结构体的一般形式:

    struct 结构体类型名//struct是关键字

    {

    成员表;//可以有多个

    成员函数;//可以有也可以没有

    }结构变量量表;//可以同时定义多个结构体变量用“,”隔开,另外结构变量表后面的“;”不能漏掉。例如:

    struct student//定义一个名叫student的struct类型
    {
        string name;//定义名字
        int chinese;//定义语文成绩
        int math;//定义数学成绩
        int total;//定义总成绩
    }a[111];//同时定义了a的数组变量
    //也可以下面这样:
    struct student
    {
        string name;
        int chinese;
        int math;
        int total;
    };
    student a[111];//这里同样可以定义多个结构体变量

    注意:结构体变量名不能与结构体名重复;在定义结构体时,系统不会对其分配实际内存,只有定义结构体变量时,系统才会为其分配内存。

    2.结构体变量的特点

    (1).结构体变量可以整体操作。例如;
      swap(a[i],a[i+1]);
    (2).结构体变量的成员的访问也很方便、清晰。例如:
      cin>>a[i].name>>a[i].chinese>>a[i].math;
    (3).结构体变量的初始化和数组的初始化类似。例如:
      student op={"gaoxiang",80,90,170};

    3.成员调用

    一般形式:
    结构体.成员名
    例如: a[i].name;

    操作:
    cin>>a[i].name;                            //一般形式不能写cin>>a[i];
    a[i].tatal=a[i].chinese+a[i].math;  // 就像整形变量一样使用
    实际上结构体成员之间的操作与该成员类型所具有的操作是一致的。
    成员元算符”.“在存取成员时具有最高优先级,并具有左结合性。在包含结构体的结构体的调用时,可记作:
    student.abc.menbb
    解释:说明结构体变量student有结构体成员abc;
         结构体变量abc有成员menbb.

    4.成员函数调用


    一般形式:
        结构体变量名.成员函数
    结构体成员函数默认将结构体变量作为引用参数。


    5.sort排序的使用

    bool cmp(结构体类型名 x,结构体类型名 y)
    {
        return x.结构体变量名>y.结构体变量名;
    }
    见代码:
    bool cmp(struct x,struct y)
    {
        return x.total>y.total;
    }


    5.struct的内存储存方式

       结构体struct是多个相互关联数据的集合,这些数据以整体形式存储在内存。
    例如:
    struct A
    {  
        char  a;      //char占1个字节  
        int   b;      //int 占4个字节  
        short c;      //short占2个字节  
    };

    那么结构体A是否占1+4+2=7个字节的内存大小呢,7个似乎很合理,但事实上,为了兼容各种不同的硬件,结构体内存分配采用特定字节对齐方式。

               1.数据类型对齐值:即为sizeof的值。
               2.结构体对齐值:结构体中对齐值最大类型的对齐值。
               3.结构体总大小为 其对齐值得增数倍,需要时编译器会自动添加空字节。
               4.结构体元素按顺序分配内存
                按照上述规则:


            a在第0个字节开始,占一个字节;b则在第4个字节开始,占4个字节;c在第8个字节开始,占2个字节。为使结构体总大小为其对齐值得倍数,添加两个空字节,结构体总大小为12.


    6.题目解释

    题目内容:

    输入N个学生的语文、数学和英语的得分,按总分从高到低输出,总分数相同按数学成绩的高低输出,两者相同按输入顺序排序。

    输入格式:

    第一行:有一个整数n(1<=n<=100);
    接下来n行:每行有一个姓名,语文成绩,数学成绩,英语成绩(成绩整数范围(0<=成绩<=100)

    输出格式:

    n行:每行格式有:姓名 语文 数学 英语 总分

    输入样例:

    5
    gaoxing 78 96 80
    wangxi 70 99  69
    liujia 90 87 77
    zhangjin 78 91 67
    tom 89 87 78

    输出样例:

    gaoxing 78 96 80 254
    liujia 90 87 77 254
    tom 89 87 78 254
    wangxi 70 99 69 238
    zhangjin 78 91 67 236

    代码:
    #include<bits/stdc++.h>//万能头文件
    using namespace std;
    struct A
    {
        string name;//姓名
        int chinese;//语文
        int math;//数学
        int english;//英语
        int total;//总成绩
        int num;//序号
    }s[101];//结构体
    bool cmp(A x,A y)//判断比较
    {
        return x.total==y.total? (x.math==y.math? x.num<y.num:x.math>y.math):x.total>y.total;
        //判断 按总分从高到低排序,总分数相同按数学成绩的高低排序,两者相同按输入顺序排序。
    }
    int main()
    {
        int n;
        cin>>n;
        for(int i=1;i<=n;++i)//输入
        {
            cin>>s[i].name>>s[i].chinese>>s[i].math>>s[i].english;
            s[i].total=s[i].chinese+s[i].math+s[i].english;
            s[i].num=i;
        }
        sort(s+1,s+n+1,cmp);
        for(int i=1;i<=n;++i)//输出
        {
            cout<<s[i].name<<" ";
            cout<<s[i].chinese<<" ";
            cout<<s[i].math<<" ";
            cout<<s[i].english<<" ";
            cout<<s[i].total<<endl;
        }
        return 0;
    }
    





    展开全文
  • C++中struct简介2-1

    万次阅读 2018-04-25 10:57:11
    struct概述C++的内置简单数据类型,如int、float等只能存储一种类型的数据。但现实世界更为复杂,几乎任何我们能够想到的物理对象,即使是进行最低限度的描述,也都需要好几项数据才行。可以使用关键字struct定义...

    1 struct概述

    C++的内置简单数据类型,如intfloat等只能存储一种类型的数据。但现实世界更为复杂,几乎任何我们能够想到的物理对象,即使是进行最低限度的描述,也都需要好几项数据才行。

    可以使用关键字struct定义一种复杂的数据类型来包含多种信息,这就是结构。

    2 struct语法

    结构sturct中定义元素的每一行都以分号结束,右大括号后面也有一个分号。

    3 struct初始化

    将数据存入结构成员的方法,是在声明语句中为结构成员定义初始值。这些初始值位于大括号内,互相之间以逗号分开,初始值的顺序显然必须与结构定义中成员的顺序相同。

    4 struct成员的访问

    为了访问结构的各个成员,可以使用成员选择操作符“.”。要引用某个具体成员,必须写出结构变量名,后面是“.”和希望访问的成员名。

    5 struct例子

    CSDN论坛上有帖子问到

    struct  A {
    int a;
    float  b;
    };
    struct  B {
    int b;
    float  a;
    };
    struct  C {
    A a; B b;
    };
     
    int main()
    {
    C c1 = { 1,2,3,4 };
    C  c2 = { 5,6,7,8 };
    c1.b.a + c2.a.b;
        return 0;
    }


    c1.b.a + c2.a.b的值是多少,在“3 struct初始化中提到,struct结构的初始值顺序与结构定义中成员的顺序相同,因此在c1对应的内存结构如图1所示

     

    1 c1的内存值

    红框内的数据时c1的数据,两个绿框内的数据分别对应的是c1.ac1.b;用黄色分割的数据分别是c1.a.ac1.a.bc1.b.bc1.b.a,即c1.b.a的值是0x00008040,由于它的类型是float,所以转换的值是4.00000000;

    c2对应的内存结构如图2所示

     

    2 c2的内存值

    同理, 红框内是c2的数据,c2.a.b的值是0x0000c040,转换后的值是6.00000000

    所以,c1.b.a + c2.a.b的值是float类型,为10.00000000

    展开全文
  • C语言结构体(struct)常见使用方法

    万次阅读 多人点赞 2019-11-13 00:27:27
    今天复习一下struct,顺便挖掘一下以前没注意的小细节: 基本定义:结构体,通俗讲就像是打包封装,把一些有共同特征(比如同属于某一类事物的属性,往往是某种业务相关属性的聚合)的变量封装在内部,通过一定方法...

    注意:盗版是不会得到修正和更新的!

     

    今天复习一下struct,顺便挖掘一下以前没注意的小细节:

    基本定义:结构体,通俗讲就像是打包封装,把一些有共同特征(比如同属于某一类事物的属性,往往是某种业务相关属性的聚合)的变量封装在内部,通过一定方法访问修改内部变量。

    (因为C++和C有共通之处,但是在结构体上的某些机制又有所不同,所以后边提了一下,不喜欢可以略过)

     

    结构体定义:

     

    第一种:只有结构体定义

    struct stuff{
            char job[20];
            int age;
            float height;
    };

     

    第二种:附加该结构体类型的“结构体变量”的初始化的结构体定义

    //直接带变量名Huqinwei
    struct stuff{
            char job[20];
            int age;
            float height;
    }Huqinwei;

    也许初期看不习惯容易困惑,其实这就相当于:

    struct stuff{
            char job[20];
            int age;
            float height;
    };
    struct stuff Huqinwei;
    

     

    第三种:如果该结构体你只用一个变量Huqinwei,而不再需要用

    struct stuff yourname;

    去定义第二个变量。

    那么,附加变量初始化的结构体定义还可进一步简化出第三种

    把结构体名称去掉,用匿名结构体直接定义一个结构体对象(习惯用对象这词了),这样更简洁,不过也不能定义其他同结构体变量了——除非用typeof。

    struct{
            char job[20];
            int age;
            float height;
    }Huqinwei;

    使用typeof重新利用HU的结构体定义HU3,并且定义指针ptr1,ptr2

    #include <stdio.h>
    
    struct
    {
            char a;
            short b;
            int c;
    }HU;
    
    struct
    {
            char a;
            short b;
            int c;
    }HU2;
    
    int main(){
    
            printf("%ld\n",sizeof(HU));
    
            typeof(HU) HU3;
            printf("%ld\n",sizeof(HU3));
            printf("%ld\n",sizeof(HU2));
            typeof(HU) *ptr1 = &HU;
            typeof(HU) *ptr2 = &HU3;
            ptr2->b = 444;
            printf("%d\n",ptr2->b);
            ptr1 = ptr2;
            printf("%d\n",ptr1->b);
    
    
    }
    

    同样的写法,再定义一个结构体成员HU2,他们的“类型”不同,因为如果类型相同,肯定会报错了,实际并没有报。

    不过内存操作角度,HU2和HU应该没有任何区别,也可以用指针强行更改,前提是确认安全,比如没有不同文件不同平台对齐不兼容这种问题,所以C很万能,也很危险

     

    结构体变量及其内部成员变量的定义及访问:

    绕口吧?要分清结构体变量和结构体内部成员变量的概念。

     

    就像刚才的第二种提到的,结构体变量的声明可以用:

    struct stuff yourname;

    其成员变量的定义可以随声明进行:

       struct stuff Huqinwei = {"manager",30,185};
    

    也可以考虑结构体之间的赋值:

            struct stuff faker = Huqinwei;
    //或    struct stuff faker2;
    //      faker2 = faker;
    打印,可见结构体的每一个成员变量一模一样
    

    如果不使用上边两种方法,那么成员数组的操作会稍微麻烦(用for循环可能好点)

            Huqinwei.job[0] = 'M';
            Huqinwei.job[1] = 'a';
            Huqinwei.age = 27;
            Huqinwei.height = 185;
    

    结构体成员变量的访问除了可以借助符号".",还可以用"->"访问(下边会提)。

     

    引用(C++)、指针和数组:

    首先是引用和指针:

    int main()
    {
            struct stuff Huqinwei;
    
            struct stuff &ref = Huqinwei;
            ref.age = 100;
            printf("Huqinwei.age is %d\n",Huqinwei.age);
            printf("ref.age is %d\n",ref.age);
    
            struct stuff *ptr = &Huqinwei;
            ptr->age = 200;
            printf("Huqinwei.age is %d\n",Huqinwei.age);
            printf("ptr->age is %d\n",ptr->age);
    //既然都写了,把指针引用也加上吧
            struct stuff *&refToPtr = ptr;
            refToPtr->age = 300;
            printf("Huqinwei.age is %d\n",Huqinwei.age);
            printf("refToPtr->age is %d\n",refToPtr->age);
    
    
    }
    

     

    更正:之前给引用的初始化语句写错了,而且没注明引用是纯C中没有的东西(在这么个以C为幌子的博客中)。

    引用是C++特有的一个机制,必须靠编译器支撑,至于引用转换到C中本质是什么,我有个帖子写过
     

     

    结构体也不能免俗,必须有数组:

    struct test{
            int a[3];
            int b;
    };
    //对于数组和变量同时存在的情况,有如下定义方法:
            struct test student[3] =      {{{66,77,55},0},
                                            {{44,65,33},0},
                                            {{46,99,77},0}};
    //特别的,可以简化成:
            struct test student[3] =       {{66,77,55,0},
                                            {44,65,33,0},
                                            {46,99,77,0}};
    

     

    变长结构体

    可以变长的数组

    #include <stdio.h>
    #include <malloc.h>
    #include <string.h>
    typedef struct changeable{
            int iCnt;
            char pc[0];
    }schangeable;
    
    main(){
            printf("size of struct changeable : %d\n",sizeof(schangeable));
    
            schangeable *pchangeable = (schangeable *)malloc(sizeof(schangeable) + 10*sizeof(char));
            printf("size of pchangeable : %d\n",sizeof(pchangeable));
    
            schangeable *pchangeable2 = (schangeable *)malloc(sizeof(schangeable) + 20*sizeof(char));
            pchangeable2->iCnt = 20;
            printf("pchangeable2->iCnt : %d\n",pchangeable2->iCnt);
            strncpy(pchangeable2->pc,"hello world",11);
            printf("%s\n",pchangeable2->pc);
            printf("size of pchangeable2 : %d\n",sizeof(pchangeable2));
    }

    运行结果

    size of struct changeable : 4
    size of pchangeable : 4
    pchangeable2->iCnt : 20
    hello world
    size of pchangeable2 : 4

    如上,本例中变长结构体本身长度就是一个int的长度(这个int值通常只为了方便表示后边的数组长度),而后边的数组长度不计算在内,但是该数组可以直接使用。

    (说后边是个指针吧?指针也占长度!这个是不占的!原理很简单,这个东西完全是数组后边的尾巴,malloc开辟的是一片连续空间。其实这不应该算一个机制,感觉应该更像一个技巧吧

    20191113:这块可能有点抽象?建议去了解一下手动开辟空间malloc和指针相关知识,所谓“变长结构体”,不是一个你理解的结构体!至少不是按正常结构体用的,他像是一个逻辑性的概念,空间是malloc开辟的,结构体是以指针形式存在的“虚拟”的概念,简单说,这个“结构体”不在栈空间!

     

     

    20160405补充:

    非弹性数组不能用"char a[]"这种形式定义弹性(flexible)变量,必须明确大小。

    弹性数组在结构体中,下面的形式是唯一允许的:

     

    struct s
    {
            int a;
            char b[] ;
    };

    顺序颠倒会让b和a数据重合,会在编译时不通过。

    char b[] = "hell";也不行(C和C++都不行)

    少了整型变量a又会让整个结构体长度为0,compiler不允许编译通过!不同的是,其实C++形式上是允许空结构体的,本质上是通过机制避免了纯空结构体和类对象,自动给空结构体对象分配一个字节(sizeof()返回1)方便区分对象,避免地址重合!所以呢,C如果有空结构体,定义两个(或一打,或干脆一个数组)该结构体的变量(对象),地址是完全一样的!·!!!!!!!!调试看程序运行,这些语句其实都被当屁放了,根本没有运行,没有实际意义,C压根不支持空结构体这种东西(或者说我也没想好什么场合有用)

     

    struct s2
    {
    //      char a[]  = "hasd" ;
    //      int c;
    };
    int main()
    {
            struct s2 s22;
            struct s2 s23;
            struct s2 s24;
            struct s2 s25;
    }
    


    例外的是,C++唯独不给带弹性数组的结构体分配空间(可能怕和变长结构体机制产生某种冲突,比如大小怎么算):

    struct s
    {
            char b[] ;
    };

     

    struct s
    {
    //        char b[] ;
    };

    C++中两者是不一样的,空的结构体反而“大”(sizeof()返回1)
     

    20160321补充:这个机制利用了一个非常重要的特性——组和指针的区别!数组和指针在很多操作上是一样的,但是本质不一样。最直观的,指针可以改指向,数组不可以,因为数组占用的每一个内存地址都用来保存变量或者对象,而指针占用的内存地址保存的是一个地址,数组没有单独的保存指向地址的这样一个结构。数组的位置是固定的,正如指针变量自身的位置也是固定的,改的是指针的值,是指向的目标地址,而因为数组不存储目标地址,所以改不了指向。企图把地址强制赋值给数组的话,也只是说把指针赋值给数组,类型不兼容。

     

    结构体嵌套:

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

     

    //对于“一锤子买卖”,只对最终的结构体变量感兴趣,其中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中。

     

     

    结构体与函数:

    关于传参,首先:

    void func(int);
    func(a.b.c);

    把结构体中的int成员变量当做和普通int变量一样的东西来使用,是不用脑子就想到的一种方法。

     

    另外两种就是传递副本和指针了 :

    //struct A定义同上
    //设立了两个函数,分别传递struct A结构体和其指针。
    void func1(struct A a){
            printf("%d\n",a.b.c);
    }
    void func2(struct A* a){
            printf("%d\n",a->b.c);
    }
    main(){
            a.b.c = 112;
            struct A * pa;
            pa = &a;
            func1(a);
            func2(&a);
            func2(pa);
    }
    
    

     

    注意:盗版是得不到更新迭代的(手动滑稽)https://blog.csdn.net/huqinweI987/article/details/23625823

     

     

    占用内存空间:

    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,结构体大小就是实实在在的成员变量大小的总和了。
    补一个代码,压入1字节对齐,定义s,然后弹出,使用默认,定义s2,两个结构体大小分别为7和8

    #include <stdio.h>
    #pragma pack(push,1)
    struct s
    {
            char a;
            short b;
            int c;
    };
    #pragma pack(pop)
    struct s2
    {
            char a;
            short b;
            int c;
    };
    
    
    
    int main(){
    
            printf("%ld\n",sizeof(struct s));
            printf("%ld\n",sizeof(struct s2));
    
    }
    
    $ ./a.out
    7
    8
    

     

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

    如下,为错误示范:

     

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

     

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

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

     

    那么熟悉了常用方法,都要注意哪些常犯错误呢,见C语言结构体常见错误

     

     

     

    展开全文
  • struct用法

    万次阅读 2018-07-09 19:06:02
    关键字struct能定义各种类型的变量集合,称为结构(structure),并把它们视为一个单元。1.struct的简单例子下面是一个struct的简单的声明例子:struct horse { int age; int height; } Silver; 这个例子声明了一个...
  • C语言之struct A *b和struct A c区别

    千次阅读 2020-10-10 10:38:53
    structA*b;是指针 structAc;是定义了一个structA对象,你得提供相应的结构体的具体定义 结构体A没有具体的定义,当structAc时,实际是定义一个结构体变量,这是要分配存储空间的,空间大小依结构体中具体的变量而定,如果...
  • [golang]struct {}

    千次阅读 2018-06-03 15:51:50
    有c/c++学习经历的会发现go的struct语法和c/c++很类型,但是golang的struct{}很有意思。 做set,map[string]struct{} 由于struct{}是空,不关心内容,这样map便改造为set chan struct{} 可以做退出 func ...
  • C语言中的结构体(struct

    万次阅读 多人点赞 2016-02-15 20:23:39
    C语言中,结构体类型属于一种构造类型(其他的构造类型还有:数组类型,联合类型)。本文主要介绍关于结构体以下几部分。 1、概念为什么要有结构体?因为在实际问题中,一组数据往往有很多种不同的数据类型。...
  • 结构体-struct

    2019-09-06 00:01:50
    struct struct的声明 struct的定义 struct的初始化 先声明再赋值 声明同时初始化 键值对初始化 值列表初始化 注意事项 匿名结构体 指针类型结构体初始化 先声明再赋值 声明同时初始化 结构体是值类型 ...
  • python之struct详解

    万次阅读 多人点赞 2018-05-24 12:56:26
    用处按照指定格式将Python数据转换为...处理二进制数据,如果用struct来处理文件的话,需要用’wb’,’rb’以二进制(字节流)写,读的方式来处理文件;处理c语言中的结构体;struct模块中的函数函数returnexplainpack(fmt,...
  • golang中interface{}转为struct

    万次阅读 2016-09-05 15:59:23
    es, ok := services["elasticsearch"].(*elasticsearch.ElasticSearchService) interface{}转为struct需要assert为指针
  • C语言中的typedef struct用法

    万次阅读 多人点赞 2019-10-22 09:48:17
    在学习数据结构的时候,我经常遇到typedef struct,刚开始感觉很别扭,查阅资料之后才真真理解了。 先从结构体说起。 1、结构体用法 struct Student{ int age; char s; } 如果要定义一个该结构体变量,就需要...
  • C/C++ struct 结构体定义 用法详解

    万次阅读 2016-11-07 09:35:41
    在C语言中,定义一个结构体类型要用typedef :typedef struct point { int x; int y; }Point;在声明变量的时候就可以:Point p1; 在声明变量的时候就必须用:struct point p1;
  • typedef structstruct区别

    千次阅读 多人点赞 2020-09-23 14:15:36
    typedef structstruct区别
  • struct和class的区别

    万次阅读 2018-08-19 10:03:35
    C++被称为“C with class”,可见在C++中class是多么重要,与class类似的一个结构就是struct了,struct最早是在C语言中出现的,在C++中对struct的功能也进行了扩展,下面就来说一说struct和class的区别吧: ...
  • 结构体定义 typedef struct 用法详解和用法小结

    万次阅读 多人点赞 2018-07-31 22:25:48
    typedef struct 是为了使用这个结构体方便。 具体区别在于:  若struct node{ }这样来定义结构体的话。在定义 node 的结构体变量时,需要这样写:struct node n;  若用typedef,可以这样写:typedef struct node{}...
  • 简介 2.6内核的设备模型提供一个对系统结构的一般性抽象描述,用以支持多种不同的任务 电源管理和系统关机与用户空间通信热插拔设备设备类型对象生命周期 kobject、kset和子系统 kobject是组成设备模型的基本...
  • 在pythonbrew下安装python2.7.3 报ImportError: No module named _struct错误 直接安装报同样错误 检查PYTHONHOME,发现PYTHONHOME被指为greenplum的路径,注释掉PYTHONHOME,再次安装,完成
  • 1、structField 源码结构: case class StructField( name: String, dataType: DataType, nullable: Boolean = true, metadata: Metadata = Metadata.empty) {} -----A field inside a StructType n
  • C语言中typedef structstruct的区别:

    千次阅读 多人点赞 2018-08-06 23:35:19
    typedef struct CLinkList {  int data;  struct CLinkList *next; }node; 上面的CLinkList是标识符,node是变量类型(相当于(int,char等))。     这语句实际上完成两个操作: 1) 定义一个新的结构类型 ...
1 2 3 4 5 ... 20
收藏数 1,658,184
精华内容 663,273
关键字:

struct