精华内容
下载资源
问答
  • 结构体指针初始化

    千次阅读 2017-12-01 01:21:42
    结构体指针初始化需要初始化

    结构体指针初始化需要初始化

    https://www.cnblogs.com/lijumiao/p/3624066.html

    展开全文
  • C 结构体指针初始化

    千次阅读 2019-04-26 23:18:31
    原文 C 结构体指针初始化,CSDN同步发布。 转载请注明出处,谢谢! 在使用指针之前,务必要将其初始化。这个是我们最早学习 C 语言的时候,书上经常说的一个问题。在工作中,我们反而会经常忘记这条金科玉律。 本篇...

    原文 C 结构体指针初始化,CSDN同步发布。

    转载请注明出处,谢谢!


    在使用指针之前,务必要将其初始化。这是我们最早学习 C 语言的时候,书上经常说的一个问题。在工作中,我们反而会经常忘记这条金科玉律。

    本篇文章的所有代码都经 gcc-7 编译器编译过。关于在 macOS 中如何安装和使用 gcc,可以参考 GCC: Homebrew 安装 GCC 和 Binutils 这篇文章。

    强力推荐-不要错过,万一能帮助到自己呢?

    朋友做了一个关于 人工智能的教程,教程不仅是零基础,通俗易懂,而且非常风趣幽默,像看小说一样!点 这里 可以跳转到教程,对人工智能感兴趣的同学可以了解一下。

    结构体成员指针的初始化

    结构体成员指针的初始化,指的是初始化结构体中指针变量的成员。

    我们举个例子,下面是 Animal 的结构体。

    struct Animal {
        char *name; //指针成员
        int age;
        char info[200]; //字符数组
        struct Animal *nextAnimal; //指针成员
    };
    

    结构体 Animal 含有4个成员变量,其中 nameinfonextAnimal 是指针变量。

    写一段测试代码,如下:

    int main(int argc, const char *argv[])
    {
        struct Animal animal;
        
        printf("animal's name: %s, age: %i, info: %s\n", animal.name, animal.age, animal.info);
        
        return 0;
    }
    

    运行结果正常,终端输出如下:

    animal's name: (null), age: 0, info: 
    

    我们来验证一下 Animal *nextAnimal 在没有初始化的情况下,会不会有什么问题。

    int main(int argc, const char *argv[])
    {
        struct Animal animal;
        
        printf("animal's name: %s, age: %i, info: %s\n", animal.name, animal.age, animal.info);
        
        printf("animal.nextAnimal: %p\n", animal.nextAnimal);
        
        printf("animal.nextAnimal->name: %s, age: %i, info: %s\n", animal.nextAnimal->name, animal.nextAnimal->age, animal.nextAnimal->info);
        
        return 0;
    }
    

    程序编译没有问题,运行报错

    animal's name: (null), age: 0, info: 
    animal.nextAnimal: 0x1127fa036
    Segmentation fault: 11
    

    修改一下代码,初始化一下 animal.nextAnimal 这个指针,如下:

    int main(int argc, const char *argv[])
    {
        struct Animal animal;
        
        printf("animal's name: %s, age: %i, info: %s\n", animal.name, animal.age, animal.info);
        
        printf("animal.nextAnimal: %p\n", animal.nextAnimal);
        
        // 初始化指针变量
        animal.nextAnimal = (struct Animal *)malloc(sizeof(struct Animal));
        
        printf("animal.nextAnimal->name: %s, age: %i, info: %s\n", animal.nextAnimal->name, animal.nextAnimal->age, animal.nextAnimal->info);
        
        return 0;
    }
    

    再次编译重新运行,还是报错。还需要初始化 animal.nextAnimal->name 这个变量。

    int main(int argc, const char *argv[])
    {
        struct Animal animal;
        
        printf("animal's name: %s, age: %i, info: %s\n", animal.name, animal.age, animal.info);
        
        printf("animal.nextAnimal: %p\n", animal.nextAnimal);
        
        // 初始化指针变量
        animal.nextAnimal = (struct Animal *)malloc(sizeof(struct Animal));
        
        // 初始化 name 变量
        animal.nextAnimal->name = "cat";
        
        printf("animal.nextAnimal->name: %s, age: %i, info: %s\n", animal.nextAnimal->name, animal.nextAnimal->age, animal.nextAnimal->info);
        
        return 0;
    }
    

    编译运行,一切正常。

    animal's name: (null), age: 0, info: 
    animal.nextAnimal: 0x10f0f1036
    animal.nextAnimal->name: cat, age: 0, info: 
    

    通过上面的例子,结构体指针变量有些会给默认值,有些又不会给,所以都要初始化指针变量。
    修改一下代码,示例如下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    struct Animal {
        char *name; //指针成员
        int age;
        char info[200]; //字符数组
        struct Animal *nextAnimal; //指针成员
    };
    
    int main(int argc, const char *argv[])
    {
        struct Animal animal;
        
        animal.name = "cat";
        strcpy(animal.info, "This is a cat.");
        printf("animal's name: %s, age: %i, info: %s\n", animal.name, animal.age, animal.info);
        
        printf("animal.nextAnimal: %p\n", animal.nextAnimal);
        
        // 初始化指针变量
        animal.nextAnimal = (struct Animal *)malloc(sizeof(struct Animal));
        
        // 初始化变量
        animal.nextAnimal->name = "cat";
        strcpy(animal.nextAnimal->info, "This is a cat.");
        
        printf("animal.nextAnimal->name: %s, age: %i, info: %s\n", animal.nextAnimal->name, animal.nextAnimal->age, animal.nextAnimal->info);
        
        return 0;
    }
    
    

    结构体指针的初始化

    指的是初始化结构体指针变量。

    int main(int argc, const char *argv[])
    {  
        struct Animal *ptAnimal;
            
        printf("ptAnimal's name: %s, age: %i, info: %s\n", ptAnimal->name, ptAnimal->age, ptAnimal->info);
        
        return 0;
    }
    

    编译运行报错:

    Segmentation fault: 11
    

    同样的道理,需要初始化指针变量。完成后的示例代码如下:

    int main(int argc, const char *argv[])
    {
        struct Animal *ptAnimal;
        
        // 初始化结构体指针
        ptAnimal = (struct Animal *)malloc(sizeof(struct Animal));
        
        ptAnimal->name = "dog";
        strcpy(ptAnimal->info, "This is a big dog");
        
        printf("ptAnimal's name: %s, age: %i, info: %s\n", ptAnimal->name, ptAnimal->age, ptAnimal->info);
        
        // 初始化结构体指针的成员指针变量 nextAnimal
        ptAnimal->nextAnimal = (struct Animal *)malloc(sizeof(struct Animal));
        ptAnimal->nextAnimal->name = "dog";
        strcpy(ptAnimal->nextAnimal->info, "This is a big dog");
        
        printf("ptAnimal->nextAnimal's name: %s, age: %i, info: %s\n",
               ptAnimal->nextAnimal->name, ptAnimal->nextAnimal->age, ptAnimal->nextAnimal->info);
        
        return 0;
    }
    

    完整示例

    main.c

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    struct Animal {
        char *name; //指针成员
        int age;
        char info[200]; //字符数组
        struct Animal *nextAnimal; //指针成员
    };
    
    int main(int argc, const char *argv[])
    {
        /// 验证结构体指针成员变量
        {
            struct Animal animal;
            
            animal.name = "cat";
            strcpy(animal.info, "This is a cat.");
            printf("animal's name: %s, age: %i, info: %s\n", animal.name, animal.age, animal.info);
            
            printf("animal.nextAnimal: %p\n", animal.nextAnimal);
            
            // 初始化指针变量
            animal.nextAnimal = (struct Animal *)malloc(sizeof(struct Animal));
            
            // 初始化变量
            animal.nextAnimal->name = "cat";
            strcpy(animal.nextAnimal->info, "This is a cat.");
            
            printf("animal.nextAnimal->name: %s, age: %i, info: %s\n", animal.nextAnimal->name, animal.nextAnimal->age, animal.nextAnimal->info);
        }
        
        /// 验证结构体指针
        {
            struct Animal *ptAnimal;
            
            // 初始化结构体指针
            ptAnimal = (struct Animal *)malloc(sizeof(struct Animal));
            
            ptAnimal->name = "dog";
            strcpy(ptAnimal->info, "This is a big dog");
            
            printf("ptAnimal's name: %s, age: %i, info: %s\n", ptAnimal->name, ptAnimal->age, ptAnimal->info);
            
            // 初始化结构体指针的成员指针变量 nextAnimal
            ptAnimal->nextAnimal = (struct Animal *)malloc(sizeof(struct Animal));
            ptAnimal->nextAnimal->name = "dog";
            strcpy(ptAnimal->nextAnimal->info, "This is a big dog");
            
            printf("ptAnimal->nextAnimal's name: %s, age: %i, info: %s\n",
                   ptAnimal->nextAnimal->name, ptAnimal->nextAnimal->age, ptAnimal->nextAnimal->info);
        }
        
        return 0;
    }
    

    编译

    gcc-7 main.c -o main
    

    运行

    ./main
    

    运行结果如下:

    animal's name: cat, age: 0, info: This is a cat.
    animal.nextAnimal: 0x0
    animal.nextAnimal->name: cat, age: 0, info: This is a cat.
    ptAnimal's name: dog, age: 0, info: This is a big dog
    ptAnimal->nextAnimal's name: dog, age: 0, info: This is a big dog
    

    Never give up~

    展开全文
  • 最近使用结构体比较多,然鹅结构体是c语言的最后部分略带学了一点,所以知识不太牢固,这不,最近遇到点问题。 引用上一篇博客中的例子: 博客链接:c语言读入txt文件到结构体数组 ...定义的结构体指针...

    最近使用结构体比较多,然鹅结构体是c语言的最后部分略带学了一点,所以知识不太牢固,这不,最近遇到点问题。

    引用上一篇博客中的例子:

    博客链接:c语言读入txt文件到结构体数组

    定义的结构体如下:

    typedef struct
    {
        int num;
        char name[30];
        char start[30];
        char end[30];
    }Bus;
    

    定义的结构体指针如下:

     Bus *bus=(Bus *)malloc(sizeof(Bus)*BUS_NUM);
    

    fscanf格式化输入如下:

    while(fscanf(fp,"%d%s%s%s",&bus[i].num,bus[i].name,bus[i].start,bus[i].end)!=EOF)
        {
            i++;
        }
    

    完整代码如下:

    #include<stdio.h>
    #include<stdlib.h>
    #define BUS_NUM 30
    typedef struct
    {
        int num;
        char name[30];
        char start[30];
        char end[30];
    }Bus;
    int main()
    {
        FILE *fp=fopen("buses.txt","r");
        int i=0,j;
    
        Bus *bus=(Bus *)malloc(sizeof(Bus)*BUS_NUM);
    
        if(fp==NULL)
        {
            printf("File opening failure!\n");
            exit(0);
        }
    
        while(fscanf(fp,"%d%s%s%s",&bus[i].num,bus[i].name,bus[i].start,bus[i].end)!=EOF)
        {
            i++;
        }
    
        for(j=0;j<i;j++)
        {
            printf("公交编号:%-2d 公交名:%-9s 起始站点:%-22s 终端站点:%-22s\n",bus[j].num,bus[j].name,bus[j].start,bus[j].end);
        }
    
        return 0;
    }
    
    

    但是我今天对结构体稍做了一些改动就出现了错误:

    改动后的结构体如下:

    typedef struct
    {
        int num;
        char *name;
        char *start;
        char *end;
    }Bus;
    

    其他都没有改变,输出结果如下:
    在这里插入图片描述
    这里出现错误的原因是结构体成员指针没有初始化!!!

    • 我们对结构体指针进行了初始化后,还需要对结构体成员指针进行初始化!!!!!

    • 凡是指针都需要初始化!!!!!

    指针初始化有两种:

    🔺:把字符串常量赋值给指针,这是相当于把字符串的地址给到了指针变量

    #include<stdio.h>
    #include<stdlib.h>
    typedef struct
    {
        char *name;
    }Bus;
    int main()
    {
        int i=0;
    
        Bus *bus=(Bus *)malloc(30*sizeof(Bus));
    
        for(i=0;i<5;i++)
        {
            bus[i].name="12345";
            printf("%s\n",bus[i].name);
        }
    
        return 0;
    }
    
    

    运行结果如下:
    在这里插入图片描述
    🔺:为指针变量申请空间,然后通过格式化输入

    #include<stdio.h>
    int main()
    {
        char *name=(char *)malloc(30*sizeof(char));
        while(scanf("%s",name)!=EOF)
        {
            printf("%s\n",name);
        }
        return 0;
    }
    

    运行结果如下:
    在这里插入图片描述
    手动输入EOF:
    文件结尾:键盘输入ctrl+Z 然后 换行

    展开全文
  • c语言结构体指针初始化 今天来讨论一下C中的内存管理。 记得上周在饭桌上和同事讨论C语言的崛起时,讲到了内存管理方面 我说所有指针使用前都必须初始化,结构体中的成员指针也是一样 有人反驳说,...

    c语言结构体指针初始化

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

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

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

     

    C代码 复制代码
    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来分配内存,而是将另一个指针的值赋给它

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

    C代码 复制代码
    1. struct node{   
    2.   int data;   
    3.   struct node* lchild, rchild;   
    4. };  
    struct node{
      int data;
      struct node* lchild, rchild;
    };
    


    使用时都直接的
     

    C代码 复制代码
    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哥!

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

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


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

    C代码 复制代码
    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

    展开全文
  • 1 结构体指针初始化: // 1. 使用malloc分配内存,注意此方法需手动回收内存 MyData *myData = (MyData *) malloc(sizeof(MyData)); // 2. 先定义临时变量,然后取地址。注意此方法会自动回收内存,不适合作为...
  • (1)结构体指针是否需要初始化 struct student{ char* name; int score; struct student* next; }stu,*stu1; stu.name=(char*)malloc(sizeof(char)); &nbsp;//1 结构体成员指针需要初始化 strcpy(stu.name,&...
  • C语言结构体指针初始化

    千次阅读 2016-12-08 16:49:54
    今天刚刚了如何使用C语言中的结构体,...需要指出的是:结构体指针在使用之前是需要初始化的! 同时需要注意的是:  (2)结构体变量中的元素访问方式:只有一种,用"."或者"->"的方式来访问。(.和->访问结构体元素其
  • 今天来讨论一下C中的内存管理。 记得上周在饭桌上和同事讨论C语言的崛起时,讲到了内存管理方面 ...过了几天这位同事说他试了一下,结构体中的成员指针不经过初始化是可以用(左子树和右子树指针) 那

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 137,877
精华内容 55,150
关键字:

结构体指针初始化