C语言结构体学习疑惑

一、问题起源       

       最近在看一本讲解比较通俗的C算法书，看到了链表部分，里面讲到了一个结构体的定义：

        struct node
        {
              int data;
              struct node *next;
        };
       根据书中所说，上面这段代码中，定义了一个叫做node 的结构体类型，这个结构体类型有两个成员。第一个成员是整型data，用来存储具体的数值；第二个成员是一个指针，用来存储下一个结点的地址。因为下一个结点的类型也是struct node，所以这个指针的类型也必须是struct node * 类型的指针。

         那根据我的粗浅直观的理解，此时是不是就是次结构体定义时已经嵌套调用了自身？因为struct node结构体的第二个成员就是struct node型的指针。

       为了搞明白，只好回头翻C语言教程了，于是把结构体又学习了一遍。

二、 结构体的概念

       翻了下谭浩强老师的C语言教程，有时需要将不同类型的数据组合成一个有机的整体，以便于引用，在C语言中提供了一种这样的数据结构，叫结构体。结构体的定义有3种方法：

1.先声明结构体类型再定义变量名

          struct student
          {
              int num;

              char name[20];

              char sex;
              int age;

              float score;

              char addr[30];
           }；

        struct  student       student1, student2;

         在定义了结构体变量后，系统会为之分配内存单元。例如:student1和student2在内存中各占59个字节（2+20+1+2+4+30=59）。

2.在声明类型的同时定义变量

              即：

         struct　结构体名
        ｛
            成员表列
         ｝变量名表列；

如：

        struct student
          {
              int num;

              char name[20];

              char sex;
              int age;

              float score;

              char addr[30];
           }  student1, student2;

          它的作用与第一种方法相同，即定义了两个struct student 类型的变量student1,student2 。

3.直接定义结构体类型变量

         struct
          {
              int num;

              char name[20];

              char sex;
              int age;

              float score;

              char addr[30];
           }  student1, student2;

        C语言中有这三种方法可以定义结构体。基于这三种方法，还有一种预定义的方式，后续再说。      

        对结构体的理解：

       1.此时要明白，将一个变量定义为标准类型（基本数据类型）与定义为结构体类型不同之处在于后者不仅要求指定变量为结构体类型，而且要求指定为某一特定的结构体类型，因为可以定义出许许多多种具体的结构体类型。也即结构体的定义包含了两级含义，一个是struct表明了这种类型是结构体，但仅仅如此是不够，还必须将此结构体具体化，比如 struct student，那此时 struct student就相当于int、char等在定义整形、字符型变量时的作用。可以由很多个 struct student型，但是每一个的名称不同，也就是可以由很多个struct student 型变量。

       2.类型与变量是不同的概念，不要混同。只能对变量赋值、存取或运算，而不能对一个类型赋值、存取或运算。在编译时，对类型是不分配空间的，只对变量分配空间。
       3.对结构体中的成员（即“域”），可以单独使用，它的作用与地位相当于普通变量。

       4.成员也可以是一个结构体变量。

       5.成员名可以与程序中的变量名相同,二者不代表同一对象。

（由于时间不早，余下内容待续，一定要彻底理解结构体。20151201 23:02）

三.结构体变量的引用

      在定义了结构体变量以后,就可以引用这个变量。但应遵守以下规则:   
 (1)不能将一个结构体变量作为一个整体进行输入和输出。
      例如: 已定义student1和student2为结构体变量并且它们已有值。
      不能这样引用：     printf(″%d,%s,%c,%d,%f,%＼n″,student1);

      引用结构体变量中成员的方式为：    结构体变量名.成员名
      例如， student1.num表示student1变量中的num成员,即student1的num(学号)项。可以对变量的成员赋值,例如:student1.num=10010;

       其中“.”是成员(分量)运算符,它在所有的运算符中优先级最高,因此可以把student1.num作为一个整体来看待。上面赋值语句的作用是将整数10010赋给student1变量中的成员num。

(2) 如果成员本身又属一个结构体类型,则要用若干个成员运算符,一级一级地找到最低的一级的成员。只能对最低级的成员进行赋值或存取以及运算。
       例如: 对上面定义的结构体变量student1, 可以这样访问各成员:
              student1.num
              student1.birthday.month

不能用student1.birthday来访问student1变量中的成员birthday,因为birthday本身是一个结构体变量。

(3) 对结构体变量的成员可以像普通变量一样进行各种运算（根据其类型决定可以进行的运算）。
       例如：
              student2.score=student1.score;
              sum=student1.score+student2.score;
              student1.age++;  
              ++student2.age;

由于“．”运算符的优先级最高，因此ｓｔｕｄｅｎｔ１．ａｇｅ＋＋是对ｓｔｕｄｅｎｔ１．ａｇｅ进行自加运算，而不是先对ａｇｅ进行自加运算。

(4) 可以引用结构体变量成员的地址，也可以引用结构体变量的地址。
       例如：
             scanf(″%d″，&student1.num); （输入student1.num的值）
             printf(″%o″，＆student1）；   （输出student1的首地址）
但不能用以下语句整体读入结构体变量，
       例如：
              scanf（″%d，％s，％c，％d，％f，％s″，＆student1）；
 结构体变量的地址主要用作函数参数，传递结构体的地址。

（由于时间不早，余下内容待续，一定要彻底理解结构体。20151202 22:50）

四.结构体变量的初始化

        和其它类型的变量一样，结构体变量可以在定义时指定初始值。

#include <stdio.h>

void main（）   

{

      struct student    

     ｛long int num；      

        char name[20];      

        char sex；      

        char addr[20]；     

     ｝a={10101，″LiLin″，′M′，″123 Beijing Road″｝； /* 对结构体变量a赋初值*/

      printf(″No.:%ld＼nname:%s＼nsex:%c＼naddress:%s＼n″，a.num，a.name，a.sex，a.addr);　　  

｝

运行结果：
    No.：10101
    name：LiLin
    sex：Ｍ
    address：123 Beijing Road

（由于时间不早，余下内容待续，一定要彻底理解结构体。20151203 22:58）

五.结构体数组

       一个结构体变量中可以存放一组数据（如一个学生的学号、姓名、成绩等数据）。如果有１０个学生的数据需要参加运算，显然应该用数组，这就是结构体数组。结构体数组与以前介绍过的数值型数组不同之处在于每个数组元素都是一个结构体类型的数据，它们都分别包括各个成员（分量）项。

（1）定义结构体数组
       和定义结构体变量的方法相仿，只需说明其为数组即可。例如：
       struct student
       {

            int num;

            char name[20];

            char sex;

            int age;
            float score;

            char addr[30];
        };

        struct student  stu[3];

       以上定义了一个数组stu，数组有３个元素，均为struct student类型数据。也可以直接定义一个结构体数组，例如：
       struct student
        {

              int num;
              …

        }stu[3];
或：
       strcut
        {

            int num;
            …

        }stu[3];

如图所示：

          

        数组各元素在内存中连续存放。

(2)结构体数组的初始化
        与其他类型的数组一样，对结构体数组可以初始化。例如：
        struct student
      ｛

             int num;

             char name[20]；

             char sex；     
             int age；

             float score;

             char addr[30]；
　     }stu［2］＝{{10101，″LiLin″，′M′，18，87.5，″103 BeijingRoad″｝，｛10102，″Zhang Fun″，′M′，19，99，″130 Shanghai Road″}}；

                                  　

        当然，数组的初始化也可以用以下形式：
              struct student
　         ｛

                  int num；
                 …
             ｝；
              struct student　str[]{{…},{…},{…}}；    
        即先声明结构体类型，然后定义数组为该结构体类型，在定义数组时初始化。

        结构体数组初始化的一般形式是在定义数组的后面加上“＝｛初值表列｝；”。

（3） 结构体数组应用举例

        例：对候选人得票的统计程序。设有3个候选人，每次输入一个得票的候选人的名字，要求最后输出各人得票结果。(下面例子在DEV C++和VC6中运行通过)      

#include <string.h>
#include <stdio.h>

struct person{
    char name[20];
    int count;
}leader[3]= {"Li",0,"Zhang",0,"Fun",0};

void main(){
    int i,j;
    char leader_name[20];
    for(i=1;i<=10;i++){
        scanf("%s",leader_name);    
        for(j=0;j<3;j++)
            if(strcmp(leader_name,leader[j].name)==0)leader[j].count++;
    }
    printf("\n");
    for(i=0;i<3;i++)   

        printf("%5s:%d\n",leader[i].name,leader[i].count);

}

输入：

       Ｌｉ↙

       Ｌｉ↙

　　Ｆｕｎ↙
　　Ｚｈａｎｇ↙
　　Ｚｈａｎｇ↙
　　Ｆｕｎ↙
　　Ｌｉ↙
　　Ｆｕｎ↙
　　Ｚｈａｎｇ↙
　　Ｌｉ↙

运行结果：

　　Ｌｉ:４
　　Ｚｈａｎｇ:３
　　Ｆｕｎ:３
       程序定义一个全局的结构体数组leader，它有３个元素，每一个元素包含两个成员name（姓名）和count（票数）。在定义数组时使之初始化，使3位候选人的票数都先置零。

       主函数中定义字符数组leader_name，代表被选人的姓名，10次循环每次先输入一个被选人的具体人名，然后把它与三个候选人姓名相比，看它和哪一个候选人名字（leader[i].name）相同，如果相同则使该元素的成员count的值加1。在输入和统计结束之后，将3人的名字和得票数输出。

（由于时间不早，余下内容待续，一定要彻底理解结构体。20151204 22:46）

六.指向结构体类型数据的指针

       一个结构体变量的指针就是该变量所占据的内存段的起始地址。可以设一个指针变量，用来指向一个结构体变量，此时该指针变量的值是结构体变量的起始地址。指针变量也可以用来指向结构体数组中的元素。

（1）指向结构体变量的指针

      下面通过一个简单例子来说明指向结构体变量的指针变量的应用。

#include <string.h>

#include <stdio.h>

void main()

{

    struct student

    {long num;

     char name[20];                   

     char   sex;

     float score;

    };        

    struct student stu_1;        

    struct student* p;

    p=&stu_1;      

    stu_1.num=89101;

    strcpy(stu_1.name,”LiLin”);      

    stu_1.sex=‘M’;

    stu_1.score=89.5;    

    printf(″No.:%ld＼nname:%s＼nsex:%c＼nscore:%f＼n″，

              stu-1.num，stu-1.name，stu-1.sex，stu-1.score);           

    printf(″No.:%ld＼nname:%s＼nsex:%c＼nscore:%f＼n″，

             (*p).num，(*p).name，(*p).sex，(*p).score);

}

      在主函数中定义了struct student类型，然后定义了一个struct student类型的变量stu_1。同时又定义了指针变量p，它指向struct student 类型的数据。在函数的执行部分将结构体变量ｓｔｕ-１的起始地址赋给指针变量ｐ，也就是使ｐ指向ｓｔｕ-１（如图）,然后对ｓｔｕ-１的各成员赋值。第一个ｐｒｉｎｔｆ函数是输出ｓｔｕ-１的各个成员的值。用ｓｔｕ-１．ｎｕｍ表示ｓｔｕ-１中的成员ｎｕｍ，依此类推。第二个ｐｒｉｎｔｆ函数也是用来输出ｓｔｕ-１各成员的值，但使用的是（*ｐ）．ｎｕｍ这样的形式。（*ｐ）表示p指向的结构体变量，（*ｐ）．ｎｕｍ是p指向的结构体变量中的成员num。

   
        注意，（*ｐ）．ｎｕｍ中 *ｐ 两侧的括号不可省，因为成员运算符“ . ”优先于“ * ”运算符，因此*ｐ．ｎｕｍ就等价于*（ｐ．ｎｕｍ）了。

       程序的运行结果：

    Ｎｏ．：89101　　　　　　   Ｎｏ．：89101
    name：LiLin                             name：LiLin
    sex：Ｍ                                   sex：Ｍ 
    score：89.500000                  score：89.500000

       可见两个printf函数输出的结果是相同的。

       在C语言中为了方便和直观，可以把（*ｐ）．ｎｕｍ改用p->num来代替，即p所指向的结构体变量中的num成员。也就是说，以下3种形式等价：
      1.   结构体变量．成员名
      2.  （*ｐ）．成员名
      3.  ｐ->成员名
其中->称为指向运算符。以下三种情况要注意区分：

        ｐ->ｎ           得到ｐ指向的结构体变量中的成员ｎ的值。
        ｐ->ｎ＋＋　得到ｐ指向的结构体变量中的成员ｎ的值，用完该值后使它加１。
 ＋＋ｐ->ｎ　       得到ｐ指向的结构体变量中的成员ｎ的值加１，然后再使用它。

（2）指向结构体数组的指针
       对结构体数组及其元素也可以用指针或指针变量来指向。

例： 指向结构体数组的指针的应用

    #include <stdio.h>

    struct student

    {  int num;

       char name[20];

       char sex;

       int age;

    };

    struct student stu[3]=｛｛10101，″Li Lin″，′M′，18｝，｛10102，″Zhang Fun″，′M′，19｝，｛10104，″WangMing″，′F′，20｝｝;

    void main()

   {     struct student *p;      

         printf(″  No.      Name     sex      age＼ｎ″）；      

         for（ｐ＝stu；ｐ＜str＋３；p＋＋）       //数组名代表数组首地址，ｐ＝ stu 即 p = &stu[0]，而ｐ+1 = &stu[1]

               printf(″%5d %-20s %2c %4d＼n″，p->num， p->name， p->sex， p->age); 

   }

    运行结果：
    Ｎｏ．　          Ｎａｍｅ　        ｓｅｘ      ａｇｅ　  
   １０１０１        LiLin                   Ｍ　          18　
   １０１０２　    Zhang Fun 　     Ｍ　          19　
   １０１０４       WangMing 　     Ｆ               20

程序分析：
       ｐ是指向struct student结构体类型数据的指针变量。在for语句中先使ｐ的初值为stu，也就是数组stu第一个元素的起始地址。如下图中p的指向。在第一次循环中输出stu[0]的各个成员值。然后执行ｐ＋＋，使ｐ自加１。ｐ加１意味着p所增加的值为结构体数组stu的一个元素所占的字节数。执行ｐ++后p的值等于stu ＋1，ｐ指向stu[1]。在第二次循环中输出stu[1]的各成员值。在执行ｐ＋＋后,p的值等于stu+2，再输出stu [2]的各成员值。在执行ｐ++后，ｐ的值变为stu +３， 已不再小于stu+3了，不再执行循环。

       注意：
       (1) 如果ｐ的初值为stu，即指向第一个元素，则ｐ加１后p就指向下一个元素。例如:
            (++p)->num　先使ｐ自加１，然后得到它指向的元素中的num成员值（即10102）。
            (p++)->num　先得到ｐ->num的值（即10101），然后使ｐ自加１，指向stu[1]。
  请注意以上二者的不同。
      (2) 程序已定义了ｐ是一个指向struct student类型数据的指针变量，它用来指向一个struct student类型的数据,不应用来指向stu数组元素中的某一成员。
       例如:  ｐ＝ｓｔｕ［1］．ｎaｍｅ;是不对的。
       如果要将某一成员的地址赋给p，可以用强制类型转换，先将成员的地址转换成p的类型。
例如：ｐ＝（ｓｔｒｕｃｔ　ｓｔｕｄｅｎｔ *）ｓｔｕ［0］．ｎaｍｅ；
       此时p的值是stu[0]元素的name成员的起始地址。可以用"printf("%s",p);"输出stu[0]中成员name的值。但是p仍然保持原来的类型。

      如果执行“printf("%s",p+1);”则会输出stu[1]中name的值。执行p+1时，p的值增加了结构体struct student的长度。

（由于时间不早，余下内容待续，一定要彻底理解结构体。20151210 22:38）

（3）用结构体变量和指向结构体的指针作函数参数 

       将一个结构体变量的值传递给另一个函数，有3个方法:
       (1)用结构体变量的成员作参数，此时和普通变量做函数参数一样，都属于“值传递”的方式，需要保持形参和实参类型一致。
       (2) 用结构体变量作实参，也属于“值传递”的方式，将结构体变量所占的内存单元的内容全部顺序传递给形参，形参也必须是同类型的结构体变量。在函数调用期间，形参也要占用内存单元，这种传送方式在时间和空间开销很大，如果结构体的规模较大时，开销是很可观的，会严重地降低程序的效率 。此外由于采用了值传递的方式，如果在执行被调用函数期间改变了形参（也就是结构体变量）的值，该值不能返回主调函数，这往往造成使用上的不便。因此一般不使用这种方式。
       (3) 用指向结构体变量（或数组）的指针作实参，将结构体变量（或数组）的地址传给形参。

      

       下面用两个例子进行对比，可以体会用结构体变量和指向结构体的指针分别作函数参数的使用方法。

       1.用结构体变量作函数参数的使用方法：

       有一个结构体变量stu，内含学生学号、姓名和3门课程的成绩。要求在main函数中赋予值，在另一函数print中将它们输出。

       #include <stdio.h>

       struct student

       {      int num;          

             char name[20];          

             float score[3];

       };

      void main()

      {        void print(struct student);       

              struct student stu;       

              stu.num=12345;

              strcpy(stu.name,  ″LiLin″）;

              stu.score[0]=67.5;

              stu.score[1]=89;

              stu.score[2] =78.6       

              print(stu);

      }

      void print(struct student stu)

      { 

             printf(FORMAT，stu.num，stu.name， stu.score[0]， stu.score[1]，stu.score[2]）；     

             printf（″\n″）；

      }

运行结果：
１２３４５
Ｌｉ Ｌｉ
67.500000
89.000000
78.599998

      2.用指向结构体的指针指向结构体的指针指向结构体的指针指向结构体的指针指向结构体的指针指向结构体的指针指向结构体的指针作函数参数的使用方法：

     将上题改用指向结构体变量的指针作实参。

      #include <stdio.h>

      struct student

      {     

           int num;           

           char name[20];          

           float score[3];

      };stu={12345, ″LiLi″,67.5,89,78.6};

    void main()

    {   

     void print(struct student *);               /*形参类型修改成指向结构体的指针变量*/         

     print(&stu);                                    /*实参改为stu的起始地址*/ /*实参改为stu的起始地址*/ /*实参改为stu的起始地址*/

     }             

   

     void print(struct student *p)                    /*形参类型修改了*/

     {                     

          printf(FORMAT，p->num，p->name，p->score［0］，

                                    p->score［1］，p->score［2］）；          /*用指针变量调用各成员的值*/

          printf（″＼ｎ″）；

     }

 运行结果：
１２３４５
Ｌｉ Ｌｉ
67.500000
89.000000
78.599998

程序分析：
       此程序改用在定义结构体变量stu时赋初值，这样程序可简化些。print函数中的形参ｐ被定义为指向struct student类型数据的指针变量。注意在调用print函数时，用结构体变量str的起始地址＆stu作实参。在调用函数时将该地址传送给形参p(p是指针变量）。这样ｐ就指向stu。在print函数中输出ｐ所指向的结构体变量的各个成员值，它们也就是stu的成员值.
　　main函数中的对各成员赋值也可以改用scanf函数输入，这里不再详述，谭浩强的C程序设计第三版中有讲述（个人感觉，谭书第三版最适合做为查阅资料用，关于C的内容在他的四个版本中还是比较全面的，而第四版有些内容移入了学习辅导教程中就需要两本书了）。

结构体的内容就到这里了，我觉得基本上已经理解了，下来就是应用了，在应用中加深理解，真正学懂。

                                                                                                                                           -20151213 22:47

指向结构体的指针