C++ 结构体深入理解

Posted 2020-06-10

1、

结构体基础知识

有时需要将不同类型的数据组合成一个有机的整体，以供用户方便地使用。这些组合在一个整体中的数据是互相联系的。例如，一个学生的学号、姓名、性别、年龄、成绩、家庭地址等项，都是这个学生的属性，见图7.1。

图 7.1

可以看到学号(num)、姓名(name)、性别(sex)、年龄(age)、成绩(score )、地址(addr)是与姓名为“Li Fun”的学生有关的。如果在程序中将num,name,sex,age,score,addr分别定义为互相独立的变量，就难以反映出它们之间的内在联系。应当把它们组织成一个组合项，在一个组合项中包含若干个类型不同（当然也可以相同）的数据项。C和C++允许用户自己指定这样一种数据类型，它称为结构体。它相当于其他高级语言中的记录(record)。

例如，可以通过下面的声明来建立如图7.1所示的数据类型。

1. struct Student//声明一个结构体类型Student
2. {
3. int num; //包括一个整型变量num
4. char name[20]; //包括一个字符数组name，可以容纳20个字符
5. char sex; //包括一个字符变量sex
6. int age; //包括一个整型变量age
7. float score; //包括一个单精度型变量
8. char addr[30]; //包括一个字符数组addr，可以容纳30个字符
9. }; //最后有一个分号

这样，程序设计者就声明了一个新的结构体类型Student（struct是声明结构体类型时所必须使用的关键字，不能省略），它向编译系统声明： 这是一种结构体类型，它包括num， name， sex， age， score， addr等不同类型的数据项。应当说明Student是一个类型名，它和系统提供的标准类型（如int、char、float、double 一样，都可以用来定义变量，只不过结构体类型需要事先由用户自己声明而已。

声明一个结构体类型的一般形式为：
    struct  结构体类型名  {成员表列};

结构体类型名用来作结构体类型的标志。上面的声明中Student就是结构体类型名。大括号内是该结构体中的全部成员(member)，由它们组成一个特定的结构体。上例中的num，name，sex，score等都是结构体中的成员。在声明一个结构体类型时必须对各成员都进行类型声明即类型名 成员名；每一个成员也称为结构体中的一个域(field)。成员表列又称为域表。

声明结构体类型的位置一般在文件的开头，在所有函数（包括main函数）之前，以便本文件中所有的函数都能利用它来定义变量。当然也可以在函数中声明结构体类型。

在C语言中，结构体的成员只能是数据（如上面例子中所表示的那样）。C++对此加以扩充，结构体的成员既可以包括数据（即数据成员），又可以包括函数（即函数成员），以适应面向对象的程序设计。

但是由于C++提供了类(class )类型，一般情况下，不必使用带函数的结构体，因此在本章中只介绍只含数据成员的结构体，有关包含函数成员的结构体将在后续章节进行介绍。

结构体类型变量的定义方法及其初始化

以上只是指定了一种结构体类型，它相当于一个模型，但其中并无具体数据，系统也不为之分配实际的内存单元为了能在程序中使用结构体类型的数据，应当定义结构体类型的变量，并在其中存放具体的数据。

定义结构体类型变量的方法可以采取以下3种方法定义结构体类型的变量。

1) 先声明结构体类型再定义变量名
如上面已定义了一个结构体类型Student，可以用它来定义结构体变量。如：


在C语言中，在定义结构体变量时，要在结构体类型名前面加上关键字Sttuct，C++ 保留了C的用法，如：
struct  Student  studentl, student2;

提倡读者在编写C++程序时，使用C++新提出来的方法，即不必在定义结构体变量时加关键字Struct，这样使用更方便，而且与第8章中介绍的用类(class)名定义类对象的用法一致。

以上定义了student1和student2为结构体类型Student的变量，即它们具有Student类型的结构。如图7.2所示。

图7.2

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

2) 在声明类型的同时定义变量。例如：

1. struct Student //声明结构体类型Student
2. {
3. int num;
4. char name[20];
5. char sex;
6. int age;
7. float score;
8. char addr[30];
9. }student1, student2; //定义两个结构体类型Student的变量student1，student2

这种形式的定义的一般形式为：
struct 结构体名
{
    成员表列
}变量名表列;


3) 直接定义结构体类型变量。其一般形式为：
struct  //注意没有结构体类型名
{
    成员表列
}变量名表列;

这种方法虽然合法，但很少使用。提倡先定义类型后定义变量的第(1)种方法。在程序比较简单，结构体类型只在本文件中使用的情况下，也可以用第(2)种方法。

关于结构体类型，有几点要说明：
1) 不要误认为凡是结构体类型都有相同的结构。实际上，每一种结构体类型都有自己的结构，可以定义出许多种具体的结构体类型。

2) 类型与变量是不同的概念，不要混淆。只能对结构体变量中的成员赋值，而不能对结构体类型赋值。在编译时，是不会为类型分配空间的，只为变量分配空间。

3) 对结构体中的成员（即“域”），可以单独使用，它的作用与地位相当于普通变量。

4) 成员也可以是一个结构体变量。如：

1. struct Date //声明一个结构体类型Date
2. {
3. int month;
4. int day;
5. int year;
6. };
7. struct Student //声明一个结构体类型Student
8. {
9. int num;
10. char name[20];
11. char sex;
12. int age;
13. Date birthday;
14. char addr[30];
15. }student1, student2; //定义student1和student2为结构体类型Student的变量

首先声明一个Date类型，它代表“日期”，包括3个成员：rnomh(月)、day (日)、year(年)。然后在声明Studcm类型时，将成员birthday指定为Date类型。Student的结构见图 7.3所示。已声明的类型Date与其他类型(如im,char)—样，也可以用来定义成员的类型。

 

图 7.3

5) 结构体中的成员名可以与程序中的变量名相同，但二者没有关系。例如，程序中可以另定义一个整型变量num，它与student中的num是两回事，互不影响。

结构体变量的初始化

和其他类型变量一样，对结构体变量可以在定义时指定初始值。如：

1. struct Student
2. {
3. int num;
4. char name[20];
5. char sex;
6. int age;
7. float score;
8. char addr[30];
9. }student1={10001, "Zhang Xin", ‘M‘, 19, 90.5, "Shanghai"};

这样，变量student1中的数据如图7.2中所示。

也可以采取声明类型与定义变量分开的形式，在定义变量时进行初始化：
Student student2 = { 10002, "Wang Li", "F", 20, 98, "Beijing"};  //Student是已声明的结构体类型

 

 

2、

结构体数组

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

定义结构体数组和定义结构体变量的方法相仿，定义结构体数组时只需声明其为数组即可。如：

1. struct Student //声明结构体类型Student
2. {
3. int num;
4. char name[20];
5. char sex;
6. int age;
7. float score;
8. char addr[30];
9. };
10. Student stu[3]; //定义Student类型的数组stu

也可以直接定义一个结构体数组，如：

1. struct Student
2. {
3. int num;
4. char name[20];
5. char sex;
6. int age;
7. float score;
8. char addr[30];
9. }stu[3];

或

1. struct
2. {
3. int num;
4. char name[20];
5. char sex;
6. int age;
7. float score;
8. char addr[30];
9. }stu[3];

结构体数组的初始化与其他类型的数组一样，对结构体数组可以初始化。如：

1. struct Student
2. {
3. int num;
4. char name[20];
5. char sex;
6. int age;
7. float score;
8. char addr[30];
9. }stu[3]={
10. {10101,″Li Lin″, ′M′, 18,87.5, ″103 Beijing Road″},
11. {10102,″Zhang Fun″,′M′，19,99, ″130 Shanghai Road″},
12. {10104,″Wang Min″,′F′, 20,78.5, ″1010 Zhongshan Road″}
13. };

定义数组stu时，也可以不指定元素个数，即写成以下形式：
    stu[ ]={{…},{…},{…}};
编译时，系统会根据给出初值的结构体常量的个数来确定数组元素的个数。一个结构体常量应包括结构体中全部成员的值。

当然，数组的初始化也可以用以下形式：
    Student stu[ ]={{…},{…},{…}};  //已事先声明了结构体类型Student
由上可以看到，结构体数组初始化的一般形式是在所定义的数组名的后面加上 ={初值表列};

结构体数组应用举例

下面举一个简单的例子来说明结构体数组的定义和引用。

【例7.2】对候选人得票的统计程序。设有3个候选人，最终只能有1人当选为领导。今有10个人参加投票，从键盘先后输入这10个人所投的候选人的名字，要求最后输出这3个候选人的得票结果。

可以定义一个候选人结构体数组，包括3个元素，在每个元素中存放有关的数据。程序如下：

1. #include <iostream>
2. using namespace std;
3. struct Person //声明结构体类型Person
4. {
5. char name[20];
6. int count;
7. };
8. int main( )
9. {
10. //定义Person类型的数组，内容为3个候选人的姓名和当前的得票数
11. Person leader[3]={"Li",0,"Zhang",0,"Fun",0};
12. int i,j;
13. char leader_name[20]; //leader_name为投票人所选的人的姓名
14. for(i=0;i<10;i++)
15. {
16. cin>>leader_name; //先后输入10张票上所写的姓名
17. for(j=0;j<3;j++) //将票上姓名与3个候选人的姓名比较
18. //如果与某一候选人的姓名相同，就给他加一票
19. if(strcmp(leader_name,leader[j].name)==0) leader[j].count++;
20. }
21. cout<<endl;
22. for(i=0;i<3;i++) //输出3个候选人的姓名与最后得票数
23. {
24. cout<<leader[i].name<<":"<<leader[i].count<<endl;
25. }
26. return 0;
27. }

运行情况如下：
Zhang↙ (每次输入一个候选人的姓名)
Li↙
Fun↙
Li↙
Zhang↙
Li↙
Zhang↙
Li↙
Fun↙
Wang↙
Li:4  (输出3个候选人的姓名与最后得票数)
Zhang:3
Fun:2

程序定义一个全局的结构体数组leader，它有3个元素，每一元素包含两个成员，即name(姓名)和count(得票数)。在定义数组时使之初始化，使3位候选人的票数都先置零。

在这个例子中，也可以不用字符数组而用string方法的字符串变量来存放姓名数据，程序可修改如下：

1. #include <iostream>
2. #include <string>
3. using namespace std;
4. struct Person
5. {
6. string name;//成员name为字符串变量
7. int count;
8. };
10. int main( )
11. {
12. Person leader[3]={"Li",0,"Zhang",0,"Fun",0};
13. int i,j;
14. string leader_name;// leader_name为字符串变量
15. for(i=0;i<10;i++)
16. {
17. cin>>leader_name;
18. for(j=0;j<3;j++)
19. if(leader_name==leader[j].name) leader[j].count++//用“==”进行比较
20. }
21. cout<<endl;
22. for(i=0;i<3;i++)
23. {
24. cout<<leader[i].name<<":"<<leader[i].count<<endl;
25. }
26. return 0;
27. }

运行情况与前相同。显然后一个程序节省内存空间，使用更方便,易读性更好。但是 有些C++系统不能对包含string成员的结构体变量初始化，需要作一些修改才能运行， 读者可上机试一下。

 

3、

结构体 指针变量

今天来讨论一下C中的内存管理。

记得上周在饭桌上和同事讨论C语言的崛起时，讲到了内存管理方面
我说所有指针使用前都必须初始化，结构体中的成员指针也是一样
有人反驳说，不是吧，以前做二叉树算法时，他的左右孩子指针使用时难道有初始化吗
那时我不知怎么的想不出理由，虽然我还是坚信要初始化的

过了几天这位同事说他试了一下，结构体中的成员指针不经过初始化是可以用（左子树和右子树指针）
那时在忙着整理文档，没在意
今天抽空调了一下，结论是，还是需要初始化的。
而且，不写代码你是不知道原因的（也许是对着电脑久了IQ和记性严重下跌吧）
测试代码如下

 

1. #include    
2. #include    
3. #include    
4.   
5. struct student{   
6.   char *name;   
7.   int score;   
8.   struct student* next;   
9. }stu,*stu1;    
10.   
11. int main(){    
12.   stu.name = (char*)malloc(sizeof(char)); /*1.结构体成员指针需要初始化*/  
13.   strcpy(stu.name,"Jimy");   
14.   stu.score = 99;   
15.   
16.   stu1 = (struct student*)malloc(sizeof(struct student));/*2.结构体指针需要初始化*/  
17.   stu1->name = (char*)malloc(sizeof(char));/*3.结构体指针的成员指针同样需要初始化*/  
18.   stu.next  = stu1;   
19.   strcpy(stu1->name,"Lucy");   
20.   stu1->score = 98;   
21.   stu1->next = NULL;   
22.   printf("name %s, score %d \n ",stu.name, stu.score);   
23.   printf("name %s, score %d \n ",stu1->name, stu1->score);   
24.   free(stu1);   
25.   return 0;   
26. }  

#include 
#include 
#include 

struct student{
  char *name;
  int score;
  struct student* next;
}stu,*stu1; 

int main(){     
  stu.name = (char*)malloc(sizeof(char)); /*1.结构体成员指针需要初始化*/
  strcpy(stu.name,"Jimy");
  stu.score = 99;

  stu1 = (struct student*)malloc(sizeof(struct
student));/*2.结构体指针需要初始化*/
  stu1->name =
(char*)malloc(sizeof(char));/*3.结构体指针的成员指针同样需要初始化*/
  stu.next  = stu1;
  strcpy(stu1->name,"Lucy");
  stu1->score = 98;
  stu1->next = NULL;
  printf("name %s, score %d \n ",stu.name, stu.score);
  printf("name %s, score %d \n ",stu1->name, stu1->score);
  free(stu1);
  return 0;
}

写测试代码的过程中我明白了，同事所说的二叉树遍历算法中所用的左子树和右子树指针不需要初始化，其实是这样的，左子树和右子树指向的必须是二叉树节点类型的结构体指针（你填一个长度相同的指针也可以），而该结构体指针是需要初始化的（见注释2），也就是并没有通过malloc来分配内存，而是将另一个指针的值赋给它

顿时觉得挺无语的，确实，看了很多大学里的教材，对于二叉树的遍历等算法定义的结构体无非是以下形式
 

1. struct node{   
2.   int data;   
3.   struct node* lchild, rchild;   
4. };  

struct node{
  int data;
  struct node* lchild, rchild;
};

使用时都直接的
 

1. struct node* root;   
2.  root = (struct node*)malloc(sizeof(struct node));   
3.  root->data = 3;   
4.   
5.  struct node* nlchild;   
6.  nlchild = (struct node*)malloc(sizeof(struct node));   
7.  root->lchild = nlchild;   
8.  nlchild->data = 2;    
9.   
10.  struct node* nrchild;   
11.  nlrchild = (struct node*)malloc(sizeof(struct node));   
12.  root->rchild = nrchild;   
13.  nrchild->data = 4;   

 struct node* root;
  root = (struct node*)malloc(sizeof(struct node));
  root->data = 3;

  struct node* nlchild;
  nlchild = (struct node*)malloc(sizeof(struct node));
  root->lchild = nlchild;
  nlchild->data = 2; 

  struct node* nrchild;
  nlrchild = (struct node*)malloc(sizeof(struct node));
  root->rchild = nrchild;
  nrchild->data = 4; 

这样子给人造成一种错觉好像结构体成员指针是不用初始化的。

可是，只要是指针，要使用它前就必须保证指针变量的值是一个有效的值；否则，它指向的内存一定是垃圾数据！
C语言的内存管理很重要，集魄力和麻烦于一身，看你自己的心态如何了。如果你积极的面对，你正在控制一切；如果你觉得烦躁，你正不得不控制一切。C仍旧是博大精深的语言，信C哥！

/*附加：仍旧是指针*/
 

1. stu1 = (struct student*)malloc(sizeof(struct student));/*2.结构体指针需要初始化*/  

  stu1 = (struct student*)malloc(sizeof(struct
student));/*2.结构体指针需要初始化*/

这一句可能会有人把sizeof里边也填成struct student*
可以理解这样的行为，因为stu本来就是struct student*，可是这样子你就没有为结构体分配足够的内存，使用中会因为内存错误同样报错的。
当然，仅仅为结构体指针分配内存还不够，结构体成员指针仍然需要分配内存，如下
 

1. stu1->name = (char*)malloc(sizeof(char));  

 

 

 

 

 

 

 

 

 

 

自己在用结构体指针的时候遇到的引用问题，网上找的一段文字觉得挺不错的，可能对大家有帮助。

在使用结构体指针变量的时候，往往容易犯一个“低级”错误。即定义一个结构体指针变量后就直接对结构体指针变量所指向的结构体成员进行操作，从而产生一些莫名其妙的错误。我们必须要给结构体指针变量赋予一个有效的结构体变量地址，才能正常操作结构体指针变量。比如：

struct UART{

             int a;

             uchar b;

          }

main()

{

      struct UART  *p;

      p->a = 0xXXX;

      p->b = 0xXX;

     printf("%i,%c",p->b,p->a);

}

这个程序输出的值将是不可预知的，因为“在程序中只是定义了一个结构体指针变量，并没有给该结构体指针变量赋一个有效值，因此该结构体变量所指向的地址将不确定，从而不能得到预期结果”

应该改为：

struct UART{

             int a;

             uchar b;

       }

main()

{

      struct UART  *p;

     struct UART dd；

      p = &dd；               //这句一定要有，否则将出现不可预知的问题

      p->a = 0xXXX;

      p->b = 0xXX;

     printf("%i,%c",p->b,p->a);

}

 

 

C/C++中

 

结构体(struct)知识点强化 为了进一部的学习结构体这一重要的知识点，我们今天来学习一下链表结构。

　　结构体可以看做是一种自定义的数据类型，它还有一个很重要的特性，就是结构体可以相互嵌套使用，但也是有条件的，结构体可以包含结构体指针，但绝对不能在结构体中包含结构体变量。

　　 struct test
　　 {
　　 char name[10];
　　 float socre;
　　 test *next;
　　 };//这样是正确的!
　　 struct test
　　 {
　　 char name[10];
　　 float socre;
　　 test next;
　　 };//这样是错误的!

　　 利用结构体的这点特殊特性，我们就可以自己生成一个环环相套的一种射线结构，一个指向另一个。

　　链表的学习不像想象的那么那么容易，很多人学习到这里的时候都会碰到困难，很多人也因此而放弃了学习，在这里我说,一定不能放弃，对应它的学习我们要进行分解式学习，方法很重要，理解需要时间，不必要把自己逼迫的那么紧，学习前你也得做一些最基本的准备工作，你必须具备对堆内存的基本知识的了解，还有就是对结构体的基本认识，有了这两个重要的条件，再进行分解式学习就可以比较轻松的掌握这一节内容的难点。

　　下面我们给出一个完整的创建链表的程序，不管看的懂看不懂希望读者先认真看一下，想一想，看不懂没有关系，因为我下面会有分解式的教程，但之前的基本思考一定要做，要不即使我分解了你也是无从理解的。

　　 代码如下，我在重要部分做了注解：

　　 #include
　　 using namespace std;

　　 struct test
　　 {
　　 char name[10];
　　 float socre;
　　 test *next;
　　 };

　　 test *head;//创建一个全局的引导进入链表的指针

　　 test *create()
　　 {
　　 test *ls;//节点指针
　　 test *le;//链尾指针
　　 ls = new test;//把ls指向动态开辟的堆内存地址
　　 cin>>ls->name>>ls->socre;
　　 head=NULL;//进入的时候先不设置head指针指向任何地址,因为不知道是否一上来就输入null跳出程序
　　 le=ls;//把链尾指针设置成刚刚动态开辟的堆内存地址,用于等下设置le->next,也就是下一个节点的位置

　　 while(strcmp(ls->name,"null")!=0)//创建循环条件为ls->name的值不是null,用于循环添加节点
　　 {
　　 if(head==NULL)//判断是否是第一次进入循环
　　 {
　　 head=ls;//如果是第一次进入循环,那么把引导进入链表的指针指向第一次动态开辟的堆内存地址
　　 }
　　 else
　　 {
　　 le->next=ls;//如果不是第一次进入那么就把上一次的链尾指针的le->next指向上一次循环结束前动态创建的堆内存地址
　　 }
　　 le=ls;//设置链尾指针为当前循环中的节点指针,用于下一次进入循环的时候把上一次的节点的next指向上一次循环结束前动态创建的堆内存地址
　　 ls=new test;//为下一个节点在堆内存中动态开辟空间
　　 cin>>ls->name>>ls->socre;
　　 }

　　 le->next=NULL;//把链尾指针的next设置为空,因为不管如何循环总是要结束的,设置为空才能够在循环显链表的时候不至于死循环
　　 delete ls;//当结束的时候最后一个动态开辟的内存是无效的,所以必须清除掉
　　 return head;//返回链首指针
　　 }

　　 void showl(test *head)
　　 {
　　 cout<<"链首指针:"< <
　　 while(head)//以内存指向为null为条件循环显示先前输入的内容
　　 {
　　 cout< name<<"|"< socre<
　　 head=head->next;
　　 }
　　 }

　　 void main()
　　 {
　　 showl(create());
　　 cin.get();
　　 cin.get();
　　 }
　　 上面的代码我们是要达到一个目的：就是要存储你输入的人名和他们的得分，并且以链状结构把它们组合成一个链状结构。

程序种有两个组成部分
　　 test *create()
　　 和 void showl(test *head)
　　 这两个函数，create是用来创建链表的 ，showl是用来显示链表的。

　　 create函数的返回类型是一个结构体指针，在程序调用的时候我们用了showl(create());，而不用引用的目的原因是引导指针是一个全局指针变量，我们不能在showl()内改变它，因为showl()函数内有一个移动操作head=head->next;，如果是引用的话我们就破坏了head指针的位置，以至于我们再也无法找会首地址的位置了。

　　 下面我们来分解整个程序，以一个初学者的思想来思考整个程序，由浅入深的逐步解释。

　　首先，我们写这个程序，要考虑到由于是一个链表结构，我们不可能知道它的大小到底是多大，这个问题我们可以用动态开辟堆内存来解决，因为堆内存在程序结束前始终是有效的，不受函数栈空间生命期的限制，但要注意的是我们必须有一个指针变量来存储这一链状结构的进入地址，而在函数内部来建立这一指针变量显然是不合适的，因为函数一旦退出，这个指针变量也随之失效，所以我们在程序的开始声明了一个全局指针变量。

　　 test *head;//创建一个全局的引导进入链表的指针
　　 好解决了这两个问题，我们接下去思考

　　有输入就必然有输出，由于输出函数和输入函数是相对独立的，为了不断测试程序的正确性好调试我们先写好输出函数和main函数捏的调用，创建函数我们先约定好名为create。

　　 我们先写出如下的代码：

　　 #include
　　 using namespace std;

　　 struct test
　　 {
　　 char name[10];
　　 float socre;
　　 test *next;
　　 };

　　 test *head;//创建一个全局的引导进入链表的指针

　　 test *create()
　　 {

　　 return head;//返回链首指针
　　 }

　　 void showl(test *head)
　　 {
　　 cout<<"链首指针:"< <
　　 while(head)//以内存指向为null为条件循环显示先前输入的内容
　　 {
　　 cout< name<<"|"< socre<
　　 head=head->next;
　　 }
　　 }

　　 void main()
　　 {
　　 showl(create());
　　 cin.get();
　　 cin.get();
　　 }
　　 程序写到这里，基本形态已经出来，输入和调用我们已经有了。

　　下面我们来解决输入问题，链表的实现我们是通过循环输入来实现的，既然是循环我们就一定得考虑终止循环的条件，避免死循环和无效循环的发生。

　　 在create()函数内部我们先写成这样：

　　 test *create()
　　 {
　　 test *ls;//节点指针
　　 test *le;//链尾指针
　　 ls = new test;//把ls指向动态开辟的堆内存地址
　　 cin>>ls->name>>ls->socre;
　　 head=NULL;//进入的时候先不设置head指针指向任何地址,因为不知道是否一上来就输入null跳出程序
　　 le=ls;//把链尾指针设置成刚刚动态开辟的堆内存地址,用于等下设置le->next,也就是下一个节点的位置

　　 le->next=NULL;//把链尾指针的next设置为空,因为不管如何循环总是要结束的,设置为空才能够在循环显链表的时候不至于死循环
　　 delete ls;//当结束的时候最后一个动态开辟的内存是无效的,所以必须清除掉
　　 return head;//返回链首指针
　　 }
　　 在循环创建之前我们必须考虑一个都不输入的情况。

　　程序一单进入create函数我们首先必然要创建一个节点，我们先创建一个节点指针，后把者个节点指针指向到动态开辟的test类型的动态内存地址位置上。

　　 test *ls;
　　 ls = new test;
　　 程序既然是循环输入，而结构成员test *next又是用来存储下一个接点的内存地址的，每次循环我们又要动态创建一个新的内存空间，所以我们必须要有一个指针来存储上一次循环动态开辟的内存地址，于是就有了

　　 test *le;
　　 接下来在进入循环前我们要创建链表的第一个节点，第一个节点必然是在循环外创建，于是就有了

　　 cin>>ls->name>>ls->socre;
　　程序执行者的情况是位置的，所以我们必然要考虑，一上来就不想继续运行程序的情况，所以我们一开始先把head引导指针设置为不指向任何地址也就是

　　 head=NULL;

　　为了符合le也就是链尾指针的设计思路，我们在循环前一定要保存刚刚动态开辟的内存地址，好在下一次循环的时候设置上一个节点中的next成员指向，于是我们便有了：

　　 le=ls;
　　 为了实现循环输入我们又了下面的代码：

本文来自: 站长(http://www.qqcf.com) 详细出处参考：http://study.qqcf.com/web/171/19838.htm