那時在忙着整理文檔，沒在意
今天抽空調了一下，結論是，還是需要初始化的。
而且，不寫代碼你是不知道原因的（也許是對着電腦久了IQ和記性嚴重下跌吧）
測試代碼如下：
#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來分配內存，而是將另一個指針的值賦給它
頓時覺得挺無語的，確實，看了很多大學裏的教材，對於二叉樹的遍歷等算法定義的結構體無非是以下形式
struct node{
int data;
struct node* lchild, rchild;
};
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哥！
stu1 = (struct student*)malloc(sizeof(struct
student));/*2.結構體指針需要初始化*/
這一句可能會有人把sizeof裏邊也填成struct
student*
可以理解這樣的行爲，因爲stu本來就是struct student*，可是這樣子你就沒有爲結構體分配足夠的內存，使用中會因爲內存錯誤同樣報錯的。
當然，僅僅爲結構體指針分配內存還不夠，結構體成員指針仍然需要分配內存，如下：
自己在用結構體指針的時候遇到的引用問題，網上找的一段文字覺得挺不錯的，可能對大家有幫助。
在使用結構體指針變量的時候，往往容易犯一個“低級”錯誤。即定義一個結構體指針變量後就直接對結構體指針變量所指向的結構體成員進行操作，從而產生一些莫名其妙的錯誤。我們必須要給結構體指針變量賦予一個有效的結構體變量地址，才能正常操作結構體指針變量。比如：
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;
from :http://blog.csdn.net/tongxinxiao/article/details/8502311