• C语言C位出道心法(二):结构体

    C语言C位出道心法(一):基础语法

    C语言C位出道心法(二):结构体|结构体指针|链表

    C语言C位出道心法(三):共用体|枚举

     C语言C位出道心法(四):文件操作

    一:C语言结构体认知

    C语言中的结构体认知升维:
       (1)C语言中的基本数据类型定义的变量,比如字符变量,数组变量,数字类型的变量,布尔变量等由基本数据类型声明的变量,表达的抽象化数据比较有限,而数组只能存储同类型的数据,
       其向系统申请的内存连续的区域;为表达更为复杂的数据类型,需要引入结构体类型,结构体类型是一种符合类型,它由基本的数据类型的各种语句指令组成一个完整的数据类型;
       既然结构体是一种数据类型,那么久可以使用该结构体体声明变量,被声明的变量叫作结构体变量;
       (2)结构体类型是一种构造类型,它由若干成员组成,其中的每一个成员可以是一个基本类型,它也可以是一个构造类型；
       (3)声明结构体一般形式如下:
            struct 结构体名称 {
              成员1;
              成员2;
              成员..
              成员n;
            }; 末尾的分号不能省略;

       (4)使用结构体作为数据类型来定义结构体变量,定义结构体变量通常有三种形式:
          4.1: 先声明,在定义的方式
             struct 结构体名 {
                 成员列表;
             };
             struct 结构体名称  变量名; 
         4.2: 声明同时定义结构体变量
             struct 结构体名 {
                 成员列表;
             }变量名列表;
         4.2: 匿名结构体
          struct {
               成员类别;
          }变量列表;

     (5)结构体成员初始化通常有两种形式
        5.1: 声明定义同时初始化
          struct 结构体名 {
             成员列表;
         }变量名 = {以结构体成员顺序一致的值列表: 各成员值直接使用逗号分隔}; 注意:最后的分号不能省略;
        5.2: 通过成员访问符来对结构体成员进行初始化 
          结构体变量名.成员名=成员值；

    1. #include 
    2.  
    3. /*
    4.    C语言中的结构体认知升维:
    5.       (1)C语言中的基本数据类型定义的变量,比如字符变量,数组变量,数字类型的变量,布尔变量等由基本数据类型声明的变量,表达的抽象化数据比较有限,而数组只能存储同类型的数据,
    6.       其向系统申请的内存连续的区域;为表达更为复杂的数据类型,需要引入结构体类型,结构体类型是一种符合类型,它由基本的数据类型的各种语句指令组成一个完整的数据类型;
    7.       既然结构体是一种数据类型,那么久可以使用该结构体体声明变量,被声明的变量叫作结构体变量;
    8.       (2)结构体类型是一种构造类型,它由若干成员组成,其中的每一个成员可以是一个基本类型,它也可以是一个构造类型；
    9.       (3)声明结构体一般形式如下:
    10.            struct 结构体名称 {
    11.              成员1;
    12.              成员2;
    13.              成员..
    14.              成员n;
    15.            }; 末尾的分号不能省略;
    17.       (4)使用结构体作为数据类型来定义结构体变量,定义结构体变量通常有三种形式:
    18.          4.1: 先声明,在定义的方式
    19.             struct 结构体名 {
    20.                 成员列表;
    21.             };
    22.             struct 结构体名称  变量名; 
    23.         4.2: 声明同时定义结构体变量
    24.             struct 结构体名 {
    25.                 成员列表;
    26.             }变量名列表;
    27.         4.2: 匿名结构体
    28.          struct {
    29.               成员类别;
    30.          }变量列表;
    32.     (5)结构体成员初始化通常有两种形式
    33.        5.1: 声明定义同时初始化
    34.          struct 结构体名 {
    35.             成员列表;
    36.         }变量名 = {以结构体成员顺序一致的值列表: 各成员值直接使用逗号分隔}; 注意:最后的分号不能省略;
    37.        5.2: 通过成员访问符来对结构体成员进行初始化 
    38.          结构体变量名.成员名=成员值
    39. */
    40.  
    41. // 定义结构体描述手机基本信息
    42. struct telephone { // 声明手机信息的结构体
    43.     const char *brandName=""; // 品牌名称
    44.     int price; // 报价
    45.     const char *screen=""; // 主屏幕尺寸
    46.     const char *processor=""; // 处理器
    47.     int battery; // 电池容量
    48. }telephoneEntity01 = {"华为",99999,"曲面折叠屏","854-麒麟-10001A",10000};
    49.  
    50. // 定义结构体变量
    51. struct telephone telephoneEntity; // 定义了数据类型为telephone结构体类型的变量telephoneEntity
    52. struct telephone* telephonePtr = &telephoneEntity; // 定义结构体类型的指针变量,并赋值telephoneEntity01变量的地址
    53.  
    54. int main() {
    55.     printf("========================结构体为显示初始化时,系统会默认给成员赋对应数据类型的初始化值====================\n");
    56.     printf("手机名称: %s \n", telephoneEntity.brandName);
    57.     printf("手机的报价: %d\n", telephoneEntity.price);
    58.     printf("手机的电池容量: %d\n", telephoneEntity.battery);
    59.     printf("手机主屏: %s \n", telephoneEntity.screen);
    60.     printf("手机的处理器: %s\n", telephoneEntity.processor);
    61.     printf("========================给结构体赋初始化值===========================");
    62.     
    63.     printf("========================赋值后显示的结构体成员值====================\n");
    64.     printf("手机名称: %s \n", telephoneEntity01.brandName);
    65.     printf("手机的报价: %d\n", telephoneEntity01.price);
    66.     printf("手机主屏: %s \n", telephoneEntity01.screen);
    67.     printf("手机的处理器: %s\n", telephoneEntity01.processor);
    68.     printf("手机的电池容量: %d\n", telephoneEntity01.battery);
    69.     printf("========================通过指针访问符访问成员并给成员赋值====================\n");
    70.     telephonePtr->price = 2500;
    71.     telephonePtr->brandName = "华为旗舰版Plus";
    72.     telephonePtr->screen = "折叠屏";
    73.     telephonePtr->processor = "高通 晓龙587";
    74.     printf("手机名称: %s \n", telephonePtr->brandName);
    75.     printf("手机的报价: %d\n", telephonePtr->price);
    76.     printf("手机主屏: %s \n", telephonePtr->screen);
    77.     printf("手机的处理器: %s\n", telephonePtr->processor);
    78.     printf("手机的电池容量: %d\n", telephonePtr->battery);
    79.   
    80.     printf("C语言使用结构体定义字符串成员时,尽量使用字符串指针定义成员,避免使用字符数组定义字符串成员,否则赋值时容易参数错误;");
    81.     printf("\n");
    82.     return 0;
    83. }

    运行效果：

    ========================结构体为显示初始化时,系统会默认给成员赋对应数据类型的初始化值====================
    手机名称:
    手机的报价: 0
    手机的电池容量: 0
    手机主屏:
    手机的处理器:
    ========================给结构体赋初始化值===================================================赋值后显示的结构体成员值====================
    手机名称: 华为
    手机的报价: 99999
    手机主屏: 曲面折叠屏
    手机的处理器: 854-麒麟-10001A
    手机的电池容量: 10000
    ========================通过指针访问符访问成员并给成员赋值====================
    手机名称: 华为旗舰版Plus
    手机的报价: 2500
    手机主屏: 折叠屏
    手机的处理器: 高通 晓龙587
    手机的电池容量: 0
    C语言使用结构体定义字符串成员时,尽量使用字符串指针定义成员,避免使用字符数组定义字符串成员,否则赋值时容易参数错误;

    D:\program_file\C++_workspace\ProjectCodeToStruct\x64\Debug\ProjectCodeToStruct.exe (进程 2008)已退出，代码为 0。
    要在调试停止时自动关闭控制台，请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。
    按任意键关闭此窗口. . .

     二:C语言结构体数组认知升维

    结构体数组认知升维:
          (1)使用结构体定义数组,即数组中的元素为结构体类型的元素,这样的数组叫作结构体数组;
          结构体数组与基本的数组不一样的地方是,结构体数组中的元素是根据要求定义的结构体类型,而不是基本的数据类型;
          (2)结构体数组定义有三种方式:
              2.1: 先定义结构体类型,在定义结构体数组
              struct 结构体名{
                 成员列表;
              };  // 注意默认的分号不能漏掉
              // 定义结构体类型的数组
              struct 结构体名 数组名[数组长度]; // 定义结构体数组
              2.2: 定义结构体类型的同时定义结构体数组
              struct 结构体名 {
                成员列表;
              }数组名[数组长度];
              2.3: 匿名结构体数组,也就是不给出结构体类型名;
              struct {
                成员列表;
              }数组名[数组长度];

    1. #include 
    2. #include 
    3.  
    4. /*
    5. * 结构体数组认知升维:
    6.       (1)使用结构体定义数组,即数组中的元素为结构体类型的元素,这样的数组叫作结构体数组;
    7. 	  结构体数组与基本的数组不一样的地方是,结构体数组中的元素是根据要求定义的结构体类型,而不是基本的数据类型;
    8. 	  (2)结构体数组定义有三种方式:
    9. 	      2.1: 先定义结构体类型,在定义结构体数组
    10. 		  struct 结构体名{
    11. 		     成员列表;
    12. 		  };  // 注意默认的分号不能漏掉
    13. 		  // 定义结构体类型的数组
    14. 		  struct 结构体名 数组名[数组长度]; // 定义结构体数组
    15. 		  2.2: 定义结构体类型的同时定义结构体数组
    16. 		  struct 结构体名 {
    17. 		    成员列表;
    18. 		  }数组名[数组长度];
    19. 		  2.3: 匿名结构体数组,也就是不给出结构体类型名;
    20. 		  struct {
    21. 		    成员列表;
    22. 		  }数组名[数组长度];
    23. */
    24. // 定义学生信息结构体,并初始化
    25. struct StudentStruct {
    26. 	int studentId; // id
    27. 	char name[20]; // 姓名
    28. 	int sex; // 性别: 0-男,1-女;
    29. 	char address[100]; // 居住地址
    30. 	char college[20]; // 毕业学校
    31. }students[3] = { 
    32. 	{200010,"小米",0,"北京市海淀区中关村软件园创新中心","北京大学"},
    33. 	{200011,"小明",0,"北京市海淀区中关村软件园创新中心","清华大学"},
    34. 	{200012,"小王",0,"北京市海淀区中关村软件园创新中心","中央财经大学"}
    35. }; // 定义了三个元素的数组students;元素的类型为结构体
    36.  
    37. // 定义教师信息结构体
    38. struct TeacherStruct {
    39. 	int teacherId; //id
    40. 	const char* teacherName="";// 教师名称,默认初始值为空串
    41. 	int teacherSex; // 性别: 0-男,1-女;
    42. 	const char* teacherAddress; // 居住地
    43. 	const char *teacherClass; // 教学班级
    44. };
    45.  
    46. // 定义结构体数组,并初始化
    47. struct TeacherStruct teacherArray[2] = { 
    48. 	{10010,"张老师",0,"北京市海淀区马连洼街道20院10020路!","初一三班"},
    49. 	{10011,"杨老师",0,"北京市朝阳区马连洼街道20院10020路!","初三二班"}
    50. };
    51.  
    52. // 定义
    53. int main() {
    54.  
    55. 	for (int i = 0; i < 3; i++) {
    56. 		printf("学生ID: %d \n", students[i].studentId);
    57. 		printf("学生姓名: %s \n", students[i].name);
    58. 		printf("学生性别: %d \n", students[i].sex);
    59. 		printf("学生居住地址: %s \n", students[i].address);
    60. 		printf("学生毕业学校: %s \n", students[i].college);
    61. 		printf("\n");
    62. 	}
    63.  
    64. 	return 0;
    65. }

    运行效果:

    学生ID: 200010
    学生姓名: 小米
    学生性别: 0
    学生居住地址: 北京市海淀区中关村软件园创新中心
    学生毕业学校: 北京大学

    学生ID: 200011
    学生姓名: 小明
    学生性别: 0
    学生居住地址: 北京市海淀区中关村软件园创新中心
    学生毕业学校: 清华大学

    学生ID: 200012
    学生姓名: 小王
    学生性别: 0
    学生居住地址: 北京市海淀区中关村软件园创新中心
    学生毕业学校: 中央财经大学


    D:\program_file\C++_workspace\ProjectToStructArray\x64\Debug\ProjectToStructArray.exe (进程 6656)已退出，代码为 0。
    要在调试停止时自动关闭控制台，请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。
    按任意键关闭此窗口. . .

     三:C语言结构体指针

    C语言结构体指针认知升维:
        (1)一个指向变量的指针表示的是变量所占用内存中的起始地址,如果一个指针指向结构体变量;
        那么该指针指向的是结构体变量的起始地址,同样指针变量也可以执行结构体数组中的元素;
        (2)指向结构体的指针,由于指针指向结构体变量的地址,因此可以使用指针类访问结构体变量中的成员,定义结构体指针一般形式如下：
         struct 结构体类型名  *指针名 ; // 例如: struct telephone  *pStruct; ,telephone为预先定义的结构体
        (3)使用指向结构体的指针变量访问结构体成员有两种方式
           3.1 使用点运算符(或者称为成员访问符)引用成员
               (*pStruct).成员; // 结构体变量可以使用点运算符对其中的成员进行引用。*pStruct 整体表示指向结构体变量,
                                // 因此可以使用点运算符可以应用结构体变量中的成员
               注意: *pStruct 一定要使用括号,因此点运算符的优先级是最高的,如果不使用括号,就会先执行点运算符然后从才执行
               "*"运算; 如: (*Pstruct).price = 3099;

           3.2 使用指针专用的成员访问符"->"
               pStruct ->成员名;  // pStruct->price = 3299;

           3.3 三种等效的结构体成员访问效果等价
              假如telephone1为结构体变量,pStruct为执行结构体变量的指针,则下面3种形式等价
              telephone1.成员名;
              (*pStruct).成员名;
              pStruct ->成员名;

           3.4 使用指针专用成员访问符"->"引用成员时,要注意分析以下情况;
               3.4.1 pStruct->price表示指向的结构体变量中成员price的值;
               3.4.2 pStruct->price++ 表示指向的结构体变量中成员price的值,使用后该值加1; 
               3.4.3 ++pStruct->price 表示指向的结构体变量中成员price的值加1,计算后再进行使用;
         (4)结构体数组的指针
              当指针变量指向结构体数组时,该变量称为指向结构体数组的指针;此时该指针变量的值为结构体数组首元素的地址;
         (5)结构体变量,结构体体指针,结构体变量的成员都可以作为函数的参数,结构体变量与结构体成员作函数参数传递时,都是值
         传递,此时的形参都是同类型的结构体或结构体成员,此时是指传递;而指针作实参传递时,由于指针表示的是某类变量的地址,
         故其相对于值传递,占用内存少时间短,故执行效率高且快; 
         提示:传值时,实参与形参的类型要保持一致;

         (6)C语言中没有类的概念,但可用把结构体这种类型类别于Java,Python,C++,Scala中类作关联类比区分;
         而面向对象编程中三大特性: 封装,继承,多态
          C语言中的结构体可类比于其他高级语言中的类
          C语言中的结构体嵌套可类比于其他高级语言中的继承

    1. #include 
    2.  
    3. /*
    4.   C语言结构体指针认知升维:
    5.       (1)一个指向变量的指针表示的是变量所占用内存中的起始地址,如果一个指针指向结构体变量;
    6.       那么该指针指向的是结构体变量的起始地址,同样指针变量也可以执行结构体数组中的元素;
    7.       (2)指向结构体的指针,由于指针指向结构体变量的地址,因此可以使用指针类访问结构体变量中的成员,定义结构体指针一般形式如下：
    8.        struct 结构体类型名  *指针名 ; // 例如: struct telephone  *pStruct; ,telephone为预先定义的结构体
    9.       (3)使用指向结构体的指针变量访问结构体成员有两种方式
    10.          3.1 使用点运算符(或者称为成员访问符)引用成员
    11.              (*pStruct).成员; // 结构体变量可以使用点运算符对其中的成员进行引用。*pStruct 整体表示指向结构体变量,
    12.                               // 因此可以使用点运算符可以应用结构体变量中的成员
    13.              注意: *pStruct 一定要使用括号,因此点运算符的优先级是最高的,如果不使用括号,就会先执行点运算符然后从才执行
    14.              "*"运算; 如: (*Pstruct).price = 3099;
    16.          3.2 使用指针专用的成员访问符"->"
    17.              pStruct ->成员名;  // pStruct->price = 3299;
    19.          3.3 三种等效的结构体成员访问效果等价
    20.             假如telephone1为结构体变量,pStruct为执行结构体变量的指针,则下面3种形式等价
    21.             telephone1.成员名;
    22.             (*pStruct).成员名;
    23.             pStruct ->成员名;
    25.          3.4 使用指针专用成员访问符"->"引用成员时,要注意分析以下情况;
    26.              3.4.1 pStruct->price表示指向的结构体变量中成员price的值;
    27.              3.4.2 pStruct->price++ 表示指向的结构体变量中成员price的值,使用后该值加1; 
    28.              3.4.3 ++pStruct->price 表示指向的结构体变量中成员price的值加1,计算后再进行使用;
    29.        (4)结构体数组的指针
    30.             当指针变量指向结构体数组时,该变量称为指向结构体数组的指针;此时该指针变量的值为结构体数组首元素的地址;
    31.        (5)结构体变量,结构体体指针,结构体变量的成员都可以作为函数的参数,结构体变量与结构体成员作函数参数传递时,都是值
    32.        传递,此时的形参都是同类型的结构体或结构体成员,此时是指传递;而指针作实参传递时,由于指针表示的是某类变量的地址,
    33.        故其相对于值传递,占用内存少时间短,故执行效率高且快; 
    34.        提示:传值时,实参与形参的类型要保持一致;
    36.        (6)C语言中没有类的概念,但可用把结构体这种类型类别于Java,Python,C++,Scala中类作关联类比区分;
    37.        而面向对象编程中三大特性: 封装,继承,多态
    38.         C语言中的结构体可类比于其他高级语言中的类
    39.         C语言中的结构体嵌套可类比于其他高级语言中的继承
    42. */
    43. // 生日信息结构体
    44. struct Birthday {
    45.     int year; // 年
    46.     int month; // 月
    47.     int day; // 日
    48. };
    49. // 表示学生信息的结构体
    50. struct Student {
    51.     char name[30]; // 姓名
    52.     int num; // 学号
    53.     char sex; // 性别:
    54.     struct Birthday birthday; // 出生日期
    55. }student = { "老高",200000200,'M',{1990,2,30} };
    56.  
    57. int main() {
    58.     printf("------------------学生入学信息---------------------\n");
    59.     printf("Name: %s\n", student.name);
    60.     printf("Number: %d\n", student.num);
    61.     printf("Sex: %c\n", student.sex);
    62.     printf("Birthday: %d,%d,%d\n", student.birthday.year, student.birthday.month, student.birthday.day);
    63.     return 0;
    64. }

    运行效果：

    ------------------学生入学信息---------------------
    Name: 老高
    Number: 200000200
    Sex: M
    Birthday: 1990,2,30

    D:\program_file\C++_workspace\ProjectToStructPoint\x64\Debug\ProjectToStructPoint.exe (进程 18820)已退出，代码为 0。
    要在调试停止时自动关闭控制台，请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。
    按任意键关闭此窗口. . .

     四:C语言中链表动态创建方法论

    链表的认知升维:
          (1)数据是信息的载体,是描述客观事物属性的数,字符已经所有能输入到计算机中并被计算机程序识别和处理的集合。
          数据结构是指数据对象以及其中的相互关系和构造方法。在数据结构中有一个线性存储结构称为"线性表"。我们知道数组是存放同类
          数据的容器,在使用数组时,需要指定数组的长度,即数组能容纳元素个数是确定的,如果往数组中添加元素超过数组的长度,便不能将内容全部保存;
          如我们定义一个数值来容纳学生信息,小班有30个同学,大班有50个同学,那么在定义数组时,我们只能定义该数组的长度为50,而不是30,因为定义30个长度的数组,
          便不能容纳50个同学,如果用这数组去装30个同学信息,那么白白浪费了20个元素容量,有没有一种容量不固定,容量会随着元素的增加而增长的容器呢,答案是有,这种
          数据结构就叫作"链表";
          (2)"链表"是一种数据结构体,其存储的元素个数是不受限制的,当添加元素时存储的个数就会随之改变;
          (3)在链表的数据结构中,必须利用指针才能实现,因此链表中的节点应该包含一个指针变量来保存下一个节点的地址; 

    4.1 链表是概念
    首先我们来了解一下线性存储结构。线性存储结构是一种最常见的存储结构。其特点是数据元素之间存在一一对应的关系。线性存储结构又分为两种，即顺序存储结构和链式存储结构。
    1.首先，我们来了解一下顺序存储结构。顺序存储的线性表称为顺序表（数组）。其原理是逻辑上相邻的元素在物理位置上也相邻。
    我们可以理解为一堆按照一定顺序摆放的书。我们在知道它的排列规律之后就可以通过它的排列规律来找到我们想找到的那本书。我们也可以通过一本一本的去找，来找到我们想要找到的那本书。
    我们可以很方便的理解，要在这一堆有顺序的书中放进去一本或者拿出来一本，我们必然要先找到要它的位置在进行操作，而且我们需要一个连续的地方来放这一堆书。
    2.其次，我们来了解一下链式存储结构（链表）。它的特点是逻辑上不相邻的两个元素在物理位置上也相邻。我们可以理解为有一本书，这本书在你打开它之后会看到它本身的内容，也会得到第二本书所在的地址。你可以通过这个地址来寻找第二本书。
    不难理解，如果我们要在这组书中加入一本书，只需要在某一本书后边加上这本书所在的地址，在在这本书后边加上原本那本书后边的地址即可。而且我们并不需要一块很大的连续的空间来存放这堆书。
    链表是一种类似于数组又不同于数组的一种线性表。
     
     4.2 链表的节点视图

    1. #define _CRT_SECURE_NO_WARNINGS
    2. #include 
    3.  
    4. /*
    5. *  链表的认知升维:
    6.       (1)数据是信息的载体,是描述客观事物属性的数,字符已经所有能输入到计算机中并被计算机程序识别和处理的集合。
    7.       数据结构是指数据对象以及其中的相互关系和构造方法。在数据结构中有一个线性存储结构称为"线性表"。我们知道数组是存放同类
    8.       数据的容器,在使用数组时,需要指定数组的长度,即数组能容纳元素个数是确定的,如果往数组中添加元素超过数组的长度,便不能将内容全部保存;
    9.       如我们定义一个数值来容纳学生信息,小班有30个同学,大班有50个同学,那么在定义数组时,我们只能定义该数组的长度为50,而不是30,因为定义30个长度的数组,
    10.       便不能容纳50个同学,如果用这数组去装30个同学信息,那么白白浪费了20个元素容量,有没有一种容量不固定,容量会随着元素的增加而增长的容器呢,答案是有,这种
    11.       数据结构就叫作"链表";
    12.       (2)"链表"是一种数据结构体,其存储的元素个数是不受限制的,当添加元素时存储的个数就会随之改变;
    13.       (3)在链表的数据结构中,必须利用指针才能实现,因此链表中的节点应该包含一个指针变量来保存下一个节点的地址;
    15.       
    16. */
    17.  
    18. // 定义一个链表来表示班级,其中的链表的节点表示学生;
    19.  
    20. struct Student {
    21.     char cName[20]; // 姓名;
    22.     int iNumberNo; // 学号;
    23.     struct Student* pNext; // 指向下一个节点的指针;
    24. }; // 末位的分号不能少;
    25. int iCount; // 全局表示链表节点数的变量;
    26. // 定义一个创建链表的函数,放函数将会返回链表的头指针
    27. struct Student* createLinkTable() {
    28.     struct Student* pHead = NULL; // 初始化链表头指针为空;
    29.     struct Student* pEnd, *pNew; // 
    30.     // 初始化链表的长度
    31.     iCount = 0;
    32.     // 给指针变量pEnd与pNew分配内存空间,
    33.     pEnd = pNew = (struct Student*)malloc(sizeof(struct Student)); // 给结构体Student分配内存空,并把指针pEnd与pNew指向这内存块;
    34.     printf("please first Name,then Number\n");
    35.     scanf("%s", &pNew->cName);// 把输入的值赋值给cName
    36.     scanf("%d", &pNew->iNumberNo); // 把输入的学号赋值被iNumberNo变量成员
    37.     while (pNew->iNumberNo != 0) { // 学号不等于零作为循环终止条件
    38.         iCount++;
    39.         if (iCount == 1) {
    40.             pNew->pNext = pHead; // 将头指针赋值给新时节点的指针成员 头节点的指针成员为空;
    41.             pEnd = pNew; // 把新时节点赋值个pEnd节点
    42.             pHead = pNew; // 把新时节点赋值给头节点,把头节点指向新节点
    43.         }else { // 最后一个节点的指针成员一定为空
    44.             pNew->pNext = NULL; // 新节点的指针为空
    45.             // 原链表的尾节点的指针指向该新节点
    46.             pEnd->pNext = pNew;
    47.             pEnd=pNew; // 再把原未节点指向新节点;
    48.         }
    49.         // 没循环一次需分配一次内存
    50.         pNew = (struct Student*)malloc(sizeof(struct Student));// 每次循环都分配节点的内存空间
    51.         scanf("%s", &pNew->cName);// 把输入的值赋值给cName
    52.         scanf("%d", &pNew->iNumberNo); // 把输入的学号赋值被iNumberNo变量成员
    53.     }
    54.     free(pNew);// 释放没有用到的内存空间
    55.     return pHead;
    56. }
    57.  
    58. // 输出链表节点数据
    59. void print(struct Student* pHead) {
    60.     struct Student* pTemp; // 循环所用的临时指针
    61.     int iIndex = 1;// 表示链表中节点的序号
    62.     printf("------------------the List has %d members:-----------\n", iCount);
    63.     printf("\n");
    64.     // 临时指针指向首节点
    65.     pTemp = pHead;
    66.     while (pTemp != NULL) {
    67.         printf("序号: %d \n", iIndex);
    68.         printf("名称: %s\n", pTemp->cName);
    69.         printf("学号: %d\n", pTemp->iNumberNo);
    70.         printf("\n");
    71.         // 取出数据成员后,在把临时指针指向下一个节点
    72.         pTemp = pTemp->pNext;
    73.         iIndex++;
    74.     }
    75. }
    76. int main() {
    77.     struct Student* pStudent;
    78.     pStudent= createLinkTable();
    79.     print(pStudent);
    80. 	return 0;
    81. }

    运行效果：

    please first Name,then Number
    老杨 1
    老李 2
    老高 3
    老表 4
    老板 5
    exit 0
    ------------------the List has 5 members:-----------

    序号: 1
    名称: 老杨
    学号: 1

    序号: 2
    名称: 老李
    学号: 2

    序号: 3
    名称: 老高
    学号: 3

    序号: 4
    名称: 老表
    学号: 4

    序号: 5
    名称: 老板
    学号: 5


    D:\program_file\C++_workspace\ProjectCToClassLinkTable\x64\Debug\ProjectCToClassLinkTable.exe (进程 14816)已退出，代码为 0。
    要在调试停止时自动关闭控制台，请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。
    按任意键关闭此窗口. . .

    忙着去耍帅,后期补充完整...........

  • 相关阅读:
    组合和为N的数量-第13届蓝桥杯选拔赛Python真题精选
    Qt小项目2 图片查看器
    【MATLAB源码-第45期】基于matlab的16APSK调制解调仿真，使用卷积编码软判决。
    关于f-stack转发框架的几点分析思考
    MySQL的事务和存储引擎
    Reset信号如何同步？
    笔试强训第16天
    示例—使用Pytorch堆叠一个神经网络的基础教程
    Oracle（2-5）Usage and Configuration of the Oracle Shared Server
    C++/Qt音视频通话开发MetaRTC源码解读，sdp交互流程
  • 原文地址：https://blog.csdn.net/u014635374/article/details/134256659