C/C++中結構體(struct)

c++ 裏面struct能夠new，
另外：

C＋＋中，struct關鍵字與Class關鍵字基本是同樣的,可是，有兩點不一樣
  1  struct定義的數據類型裏面全部成員默認級別都是共有的，而class裏面全部成員默認級別都是私有的
  2 在模板定義中，只能用class 或者typename  而不能用struct

提問者評價

講的很好，很清楚，感謝高人

http://blog.sina.com.cn/s/blog_3fabd4ba0100od67.html

結構體能夠看作是一種自定義的數據類型，它還有一個很重要的特性，就是結構體能夠相互嵌套使用，但也是有條件的，結構體能夠包含結構體指針，但絕對不能在結構體中包含結構體變量。

struct test 
{ 
    char name[10]; 
    float socre; 
    test *next; 
};//這樣是正確的!

struct test 
{ 
    char name[10]; 
    float socre; 
    test next; 
};//這樣是錯誤的!

　　利用結構體的這點特殊特性，咱們就能夠本身生成一個環環相套的一種射線結構，一個指向另外一個。

　　鏈表的學習不像想象的那麼那麼容易，不少人學習到這裏的時候都會碰到困難，不少人也所以而放棄了學習，在這裏我說,必定不能放棄，對應它的學習咱們要進行分解式學習，方法很重要，理解須要時間，沒必要要把本身逼迫的那麼緊，學習前你也得作一些最基本的準備工做，你必須具有對堆內存的基本知識的瞭解，還有就是對結構體的基本認識，有了這兩個重要的條件，再進行分解式學習就能夠比較輕鬆的掌握這一節內容的難點。

　　下面咱們給出一個完整的建立鏈表的程序，無論看的懂看不懂但願讀者先認真看一下，想想，看不懂沒有關係，由於我下面會有分解式的教程，但以前的基本思考必定要作，要不即便我分解了你也是無從理解的。

　　代碼以下，我在重要部分作了註解：

#include <iostream> 
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<<"鏈首指針:"<<head<<endl; 
    while(head)//之內存指向爲null爲條件循環顯示先前輸入的內容 
    { 
        cout<<head->name<<"|"<<head->socre<<endl; 
        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指針的位置，以致於咱們再也沒法找會首地址的位置了。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

 

#include <iostream> 
using namespace std; 
struct test 
{ 
    int number; 
    float socre; 
    test *next; 
}; 
test *head;//建立一個全局的引導進入鏈表的指針 
 
test *create() 
{ 
    test *ls;//節點指針 
    test *le;//鏈尾指針 
    ls = new test;//把ls指向動態開闢的堆內存地址 
    cin>>ls->number>>ls->socre; 
    head=NULL;//進入的時候先不設置head指針指向任何地址,由於不知道是否一上來就輸入null跳出程序 
    le=ls;//把鏈尾指針設置成剛剛動態開闢的堆內存地址,用於等下設置le->next,也就是下一個節點的位置 
    while(ls->number!=0)//建立循環條件爲ls->number的值不是null,用於循環添加節點 
    { 
        if(head==NULL)//判斷是不是第一次進入循環 
        { 
            head=ls;//若是是第一次進入循環,那麼把引導進入鏈表的指針指向第一次動態開闢的堆內存地址 
        } 
        else 
        { 
            le->next=ls;//若是不是第一次進入那麼就把上一次的鏈尾指針的le->next指向上一次循環結束前動態建立的堆內存地址 
        } 
        le=ls;//設置鏈尾指針爲當前循環中的節點指針,用於下一次進入循環的時候把上一次的節點的next指向上一次循環結束前動態建立的堆內存地址 
        ls=new test;//爲下一個節點在堆內存中動態開闢空間 
        cin>>ls->number>>ls->socre; 
    } 
    le->next=NULL;//把鏈尾指針的next設置爲空,由於無論如何循環老是要結束的,設置爲空纔可以在循環顯鏈表的時候不至於死循環 
    delete ls;//當結束的時候最後一個動態開闢的內存是無效的,因此必須清除掉 
    return head;//返回鏈首指針 
} 
void showl(test *head) 
{ 
    cout<<"鏈首指針:"<<head<<endl; 
    while(head)//之內存指向爲null爲條件循環顯示先前輸入的內容 
    { 
        cout<<head->number<<"|"<<head->socre<<endl; 
        head=head->next; 
    } 
} 
void deletel(test *&head,int number)//這裏若是參數換成test *head,意義就徹底不一樣了,head變成了複製而不是原有鏈上操做了,特別注意,不少書上都不對這裏 
{ 
    test *point;//判斷鏈表是否爲空 
    if(head==NULL) 
    { 
        cout<<"鏈表爲空,不能進行刪除工做!"; 
        return; 
    } 
    if(head->number==number)//判刪除的節點是否爲首節點 
    { 
        point=head; 
        cout<<"刪除點是鏈表第一個節點位置!"; 
        head=head->next;//從新設置引導指針 
        delete point; 
        return; 
    } 
    test *fp=head;//保存連首指針 
    for(test *&mp=head;mp->next;mp=mp->next) 
    { 
        if(mp->next->number==number) 
        { 
            point=mp->next; 
            mp->next=point->next; 
            delete point; 
            head=fp;//因爲head的不斷移動丟失了head,把進入循環前的head指針恢復! 
            return; 
        } 
    } 
} 
void main() 
{ 
    head=create();//調用建立 
    showl(head); 
    int dp; 
    cin>>dp; 
    deletel(head,dp);//調用刪除 
    showl(head); 
    cin.get(); 
    cin.get(); 
}

 

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

　最後我學習一下如何在已有的鏈表上插入節點

　　咱們要考慮四中狀況,

　　1.鏈表爲空!

　　2.插入點在首節點前

　　3.插入點找不到的狀況咱們設置放在最後!

　　4.插入點在中間的狀況!

　　今天的程序在昨天的基礎上作了進一步的修改,能夠避免刪除點找不到的狀況,若是找不到刪除點就退出函數!

#include <iostream> 
using namespace std; 
struct test 
{ 
    int number; 
    float socre; 
    test *next; 
}; 
test *head;//建立一個全局的引導進入鏈表的指針 
 
test *create() 
{ 
    test *ls;//節點指針 
    test *le;//鏈尾指針 
    ls = new test;//把ls指向動態開闢的堆內存地址 
    cout<<"請輸入第一個節點number和節點score,輸入0.0跳出函數"<<endl; 
    cin>>ls->number>>ls->socre; 
    head=NULL;//進入的時候先不設置head指針指向任何地址,由於不知道是否一上來就輸入null跳出程序 
    le=ls;//把鏈尾指針設置成剛剛動態開闢的堆內存地址,用於等下設置le->next,也就是下一個節點的位置 
    while(ls->number!=0)//建立循環條件爲ls->number的值不是null,用於循環添加節點 
    { 
        if(head==NULL)//判斷是不是第一次進入循環 
        { 
            head=ls;//若是是第一次進入循環,那麼把引導進入鏈表的指針指向第一次動態開闢的堆內存地址 
        } 
        else 
        { 
            le->next=ls;//若是不是第一次進入那麼就把上一次的鏈尾指針的le->next指向上一次循環結束前動態建立的堆內存地址 
        } 
        le=ls;//設置鏈尾指針爲當前循環中的節點指針,用於下一次進入循環的時候把上一次的節點的next指向上一次循環結束前動態建立的堆內存地址 
        ls=new test;//爲下一個節點在堆內存中動態開闢空間 
        cout<<"請下一個節點number和節點score,輸入0.0跳出函數"<<endl; 
        cin>>ls->number>>ls->socre; 
    } 
    le->next=NULL;//把鏈尾指針的next設置爲空,由於無論如何循環老是要結束的,設置爲空纔可以在循環顯鏈表的時候不至於死循環 
    delete ls;//當結束的時候最後一個動態開闢的內存是無效的,因此必須清除掉 
    return head;//返回鏈首指針 
} 
void showl(test *head) 
{ 
    cout<<"鏈首指針:"<<head<<endl; 
    while(head)//之內存指向爲null爲條件循環顯示先前輸入的內容 
    { 
        cout<<head->number<<"|"<<head->socre<<endl; 
        head=head->next; 
    } 
} 
void deletel(test *&head,int number)//這裏若是參數換成test *head,意義就徹底不一樣了,head變成了複製而不是原有鏈上操做了,特別注意,不少書上都不對這裏 
{ 
    test *point;//判斷鏈表是否爲空 
    if(head==NULL) 
    { 
        cout<<"鏈表爲空,不能進行刪除工做!"; 
        return; 
    } 
 
    int derror=1;//設置找不到的狀況的條件,預先設置爲真 
    test *check=head; 
    while(check)//利用循環進行查找 
    { 
        if (check->number==number) 
        { 
            derror=0;//條件轉爲假 
        } 
        check=check->next; 
    } 
    if(derror)//若是爲假就跳出函數 
    { 
        return; 
    } 
 
    if(head->number==number)//判刪除的節點是否爲首節點 
    { 
        point=head; 
        cout<<"刪除點是鏈表第一個節點位置!"; 
        head=head->next;//從新設置引導指針 
        delete point; 
        return; 
    } 
    test *fp=head;//保存連首指針 
    for(test *&mp=head;mp->next;mp=mp->next) 
    { 
        if(mp->next->number==number) 
        { 
            point=mp->next; 
            mp->next=point->next; 
            delete point; 
            head=fp;//因爲head的不斷移動丟失了head,把進入循環前的head指針恢復! 
            return; 
        } 
    } 
} 
 
void insterl(int number) 
{ 
    test *point=new test; 
    cout<<"請輸入節點number和節點score"<<endl; 
    cin>>point->number>>point->socre; 
 
    if(head==NULL)//鏈表爲空的狀況下插入 
    { 
        head=point; 
        point->next=NULL; 
        return; 
    } 
 
    int ierror=1;//設置找不到的狀況的條件,預先設置爲真 
    test *le; 
    test *check=head; 
    while(check)//利用循環進行查找 
    { 
        if (check->number==number) 
        { 
            ierror=0;//條件轉爲假 
        } 
        le=check; 
        check=check->next; 
    } 
    if(ierror) 
    { 
        cout<<le->number; 
        le->next=point; 
        point->next=NULL; 
        return; 
    } 
 
   if(head->number==number)//檢測是不是在第一個節點處插入 
    { 
        point->next=head; 
        head=point; 
        return; 
    } 
 
    for(test *&mp=head;mp->next;mp=mp->next)//在鏈表中間插入 
    { 
        if(mp->next->number==number) 
        { 
            point->next=mp->next; 
            mp->next=point; 
            return; 
        } 
    } 
 
} 
void main() 
{ 
    head=create();//調用建立 
    showl(head); 
    int dp; 
    cout<<"請輸入刪除點若是找不到就跳出函數"<<endl; 
    cin>>dp; 
    deletel(head,dp);//調用刪除 
    showl(head); 
    int ip; 
    cout<<"請輸入插入點若是找不到就在鏈尾添加"<<endl; 
    cin>>ip; 
    insterl(ip); 
    showl(head); 
    cin.get(); 
    cin.get(); 
}

　　到此關於結構體的內容已經所有討論結束，鏈表的創建刪除插入操做能夠很好的對前面所學知識進行一個總結，它既考察了程序員對內存大理解(堆內存操做、指針操做)也考察了對結構化編程掌握的熟悉程序