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(); 
}

　　到此关于结构体的内容已经所有讨论结束，链表的创建删除插入操做能够很好的对前面所学知识进行一个总结，它既考察了程序员对内存大理解(堆内存操做、指针操做)也考察了对结构化编程掌握的熟悉程序