碼上歡樂
相關內容    簡體    繁體

c語言結構體指針初始化

本文轉載自   查看原文   2012-11-15 23:59   65646    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. }  
 
        

寫測試代碼的過程中我明白了，同事所說的二叉樹遍歷算法中所用的左子樹和右子樹指針不需要初始化，其實是這樣的，左子樹和右子樹指向的必須是二叉樹節點類型的結構體指針（你填一個長度相同的指針也可以），而該結構體指針是需要初始化的（見注釋2），也就是並沒有通過malloc來分配內存，而是將另一個指針的值賦給它

頓時覺得挺無語的，確實，看了很多大學里的教材，對於二叉樹的遍歷等算法定義的結構體無非是以下形式
 
 
         
         
        
 
         
 
          

            C代碼 
           復制代碼 
          
 
         
 
         
     
          
  1. struct node{   
    2.  
          
  2.   int data;   
    3.  
          
  3.   struct node* lchild, rchild;   
    4.  
          
  4. };  
    5.  
         
 
        
 
        

使用時都直接的
 
 
        
 
         
 
          

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

這樣子給人造成一種錯覺好像結構體成員指針是不用初始化的。

可是，只要是指針，要使用它前就必須保證指針變量的值是一個有效的值；否則，它指向的內存一定是垃圾數據！
C語言的內存管理很重要，集魄力和麻煩於一身，看你自己的心態如何了。如果你積極的面對，你正在控制一切；如果你覺得煩躁，你正不得不控制一切。C仍舊是博大精深的語言，信C哥！

/*附加：仍舊是指針*/
 
 
         
         
        
 
         
 
          

            C代碼 
           復制代碼 
          
 
         
 
         
     
          
  1. stu1 = (struct student*)malloc(sizeof(struct student));/*2.結構體指針需要初始化*/  
    2.  
         
 
        
 
        
 
        
這一句可能會有人把sizeof里邊也填成struct student*
可以理解這樣的行為，因為stu本來就是struct student*，可是這樣子你就沒有為結構體分配足夠的內存，使用中會因為內存錯誤同樣報錯的。
當然，僅僅為結構體指針分配內存還不夠，結構體成員指針仍然需要分配內存，如下
 
 
        
 
         
 
          

            C代碼 
           復制代碼 
          
 
         
 
         
     
          
  1. stu1->name = (char*)malloc(sizeof(char));  
    2.  
         
 
        
 
        
 
 
        
 
         
 
 
         
 
 
         
 
 
         
 
 
         
 
 
         
 
 
         
 
 
         
 
 
         
 
 
         
自己在用結構體指針的時候遇到的引用問題，網上找的一段文字覺得挺不錯的，可能對大家有幫助。
 
         
在使用結構體指針變量的時候，往往容易犯一個“低級”錯誤。即定義一個結構體指針變量后就直接對結構體指針變量所指向的結構體成員進行操作，從而產生一些莫名其妙的錯誤。我們必須要給結構體指針變量賦予一個有效的結構體變量地址，才能正常操作結構體指針變量。比如：
 
         
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
 
       
 
        
       
 
        
 
 
       
 
        
       
 
       
 
      
 
      
 
      
 
     
 
     
 
      
 
      
 
        
       
免責聲明！
 
       
本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。
 
      
 
      

      
 
     
 
    
 
     
    
 
     
 
      猜您在找 
        【C語言】指向結構體的指針必須初始化  
        c語言結構體指針初始化  
        c語言結構體指針必須初始化  
        C語言定義結構體指針數組並初始化;里面全是結構體的地址  
        【C語言】結構體初始化  
        結構體指針初始化方法  
        c語言中結構體成員的初始化  
        淺談C語言中結構體的初始化  
        C語言結構體初始化的幾種方法  
        c++ 結構體容器(vector)類型初始化及結構體vector指針傳遞  
      
 
      
 
     
 
    
 
   
 
  
 
  

    
  
 
  
 
   
 
   
 
   
 
    粵ICP備18138465號  
    © 2018-2025 CODEPRJ.COM