c语言结构体链表,C语言中怎样用链表保存结构体数据(动态数据结构)
c语言结构体链表,C语言中怎样用链表保存结构体数据(动态数据结构)详细介绍
本文目录一览: C语言中,结构体与链表是什么关系
可以用结构体来实现链表啊。结构体相当于一种数据类型。链表是数据结构的一种,可以用结构体来实现链表。
没有绝对的关系
只是一般时候,链表使用结构体去实现
~~~~~~~~~~
链表的实现是建立在结构体上
C语言 怎么把结构体数组写入链表?
1.用头插法。因为数据追加和删除比较多,追加的话,头插法可以直接插,用尾插降低了时间效率,删除用两个一样。
2./*结构体定义*/
struct client{
char account[14];
char name[10];
char identity[20];
char address[15];
long int money;
};
/*链表结点定义*/
struct node{
struct client band_inf;
struct node *next;
};
应该把结构体结点定义成链表的成员,这样链表才对。如果像你那样定义的话,完全不用定义结构体,链表就搞定了。因为你在链表里面把结构的成员都又定义了。
3.
1),定义结点:p1=(struct node*)malloc(sizeof(struct node)) ;表示定义一个node型的结点指针
使用,这个要看具体怎么用了。比如说删除searchp,priorp是searchp的前面一个结点,这样写
priorp->next=searchp->next;
delete searchp; 即可
插入newnode在searchp的后面,可以这样:
newnode->next=searchp->next;
C语言中怎样用链表保存结构体数据(动态数据结构)
链表有多种形式,如:单向链表,双向链表,单向循环链表,双向循环链表。将链表结构定义为list_t,则该类型中一定(至少)存在一个指向下一节点的指针list_t
*next;除了这个指针,list_t
中可以包含其它类型的数据,包括结构体变量。比如:typedef
struct
{
struct
usr_struct
data;
list_t
*next;
}
list_t;
麻烦讲解一下C语言中的链表
1.free不会自动调用,程序员必需主动写代码显式的调用才发生
2.外部不是必需要定义三个指针的,一个全局的或静态的首结点指针,是必需的,其它的只是使用方便想定义就定义啦,并不是必需的
3.结构体中至少得有一个指向本结构体类型的指针,这是串成链表的必要条件
单向链表中相邻的两结点在内存空间上常常并不相邻,它们通过这个指针关联起来,除尾结点外,每一个结点都通过本结点中的指针指向下一个结点(结点的内存地址)
双向链表中除首结点外,每个结点都有一个指向上一结点的指针,通过向前和向后的指针,可以方便的向前向后遍历整个链表.
4.啥是我层结构呀?子结点不止一个的? 先把简单的搞明白吧,弄通透了,复杂的也就可以看懂并能学会了
struct Node
{
int data;
Node * next
};
如果你用vs2010作为编译器的话,你会发现head->next 这个指向会看到另外一个数据区,很直观
这么简单的问题有50分,肯定不止一个人回答的,不过我看LS的打那么多字,我就不回答了- -!
链表的最基本组成和功能,以单链表为例
首先单链表最基本要有一个数据区和一个指向区如下
_____________________
| 数据区 | 指向区 |
————————————
每个这样的结构称之为一个节点。每个节点又指向区连接。
这样通过链表的第一个几点地址就可以找到整个链表的节点从而获取节点中的数据了。
上面说的是最基本的链表,也称之为裸链表
双向链表和单链表类似,就是多了一个指向区,指向当前节点的上一个节点,好处是,因为单链表只能顺序向下读取,而不能你想读取,双项链就可以任意方向读取数据了。
一般链表在应用时,会额外建立一个链表头。在链表头里会有一些方便对链表操作的东西。
比如你说的free指针,链表的第一节点地址,链表的尾地址,甚至一些控制变量如链表容量等
至于链表的具体应用很复杂,但其根本不会改变,并且链表的数据区可以是任何类型的数据,甚至可以是子链表。
在C语言中,什么是链表呀?
链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构,操作复杂。由于不必须按顺序存储,链表在插入的时候可以达到O(1)的复杂度,比另一种线性表顺序表快得多,但是查找一个节点或者访问特定编号的节点则需要O(n)的时间,而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。
使用链表结构可以克服数组链表需要预先知道数据大小的缺点,链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。但是链表失去了数组随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大。链表最明显的好处就是,常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序,数据的存取往往要在不同的排列顺序中转换。链表允许插入和移除表上任意位置上的节点,但是不允许随机存取。链表有很多种不同的类型:单向链表,双向链表以及循环链表。链表可以在多种编程语言中实现。像Lisp和Scheme这样的语言的内建数据类型中就包含了链表的存取和操作。程序语言或面向对象语言,如C,C++和Java依靠易变工具来生成链表。
呵呵 ls回答的太全面了 我简单概括一下吧
简单的说,链表就是一串存储数据的链式结构。链式的优点在于,每个数据之间都是相关联的,你如果拿掉其中一个数据,整个链表就断了,需要重新把断开的部分连上,就像一条锁链一样。而你要添加一个数据,也要先断开一个锁链,把数据加进去,再重新连上。就是这么简单!
链表
链表链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构,链表比较方便插入和删除操作。
概况
链表(Linked list)是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储,链表在插入的时候可以达到O(1)的复杂度,比另一种线性表:顺序表快得多,但是查找一个节点或者访问特定编号的节点则需要O(n)的时间,而顺序表相应的时间复杂度分别是O(logn)和O(1)。使用链表结构可以克服数组链表需要预先知道数据大小的缺点,链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。但是链表失去了数组随机读取的优点,同时链表由于增加了结点的指针域,空间开销比较大。在计算机科学中,链表作为一种基础的数据结构可以用来生成其它类型的数据结构。链表通常由一连串节点组成,每个节点包含任意的实例数据(data fields)和一或两个用来指向明上一个/或下一个节点的位置的链接("links")。链表最明显的好处就是,常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序,数据的存取往往要在不同的排列顺序中转换。而链表是一种自我指示数据类型,因为它包含指向另一个相同类型的数据的指针(链接)。链表允许插入和移除表上任意位置上的节点,[1]但是不允许随机存取。链表有很多种不同的类型:单向链表,双向链表以及循环链表。链表可以在多种编程语言中实现。像Lisp和Scheme这样的语言的内建数据类型中就包含了链表的存取和操作。程序语言或面向对象语言,如C,C++和Java依靠易变工具来生成链表。
编辑本段特点
线性表的链式存储表示的特点是用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的,也可以是不连续的)。因此,为了表示每个数据元素 与其直接后继数据元素 之间的逻辑关系,对数据元素 来说,除了存储其本身的信息之外,还需存储一个指示其直接后继的信息(即直接后继的存储位置)。由这两部分信息组成一个"结点"(如概述旁的图所示),表示线性表中一个数据元素 。
编辑本段扩展
根据情况,也可以自己设计链表的其它扩展。但是一般不会在边上附加数据,因为链表的点和边基本上是一一对应的(除了第一个或者最后一个节点,但是也不会产生特殊情况)。不过有一个特例是如果链表支持在链表的一段中把前和后指针反向,反向标记加在边上可能会更方便。 对于非线性的链表,可以参见相关的其他数据结构,例如树、图。另外有一种基于多个线性链表的数据结构:跳表,插入、删除和查找等基本操作的速度可以达到O(nlogn),和平衡二叉树一样。 其中存储数据元素信息的域称作数据域(设域名为data),存储直接后继存储位置的域称为指针域(设域名为next)。指针域中存储的信息又称做指针或链。 由分别表示,,…, 的N 个结点依次相链构成的链表,称为线性表的链式存储表示,由于此类链表的每个结点中只包含一个指针域,故又称单链表或线性链表.
编辑本段三个链表函数(C语言描述)
#include
#include
#include
struct Node{
int data;//数据域
struct Node * next;//指针域
}; /************************************************************************************** *函数名称:insert
*函数功能:在链表中插入元素. *输入:head 链表头指针,p新元素插入位置,x 新元素中的数据域内容 *输出:无 *************************************************************************************/ void insert(Node * head,int p,int x)
{ Node * tmp = head; //for循环是为了防止插入位置超出了链表长度 for(int i = 0;i
<p;i++)
{
if(tmp == NULL)
return ;
if(i
<p-1)
tmp = tmp->next;
}
Node * tmp2 = new Node;
tmp2->data = x;
tmp2->next = tmp->next;
tmp->next = tmp2;
} /************************************************************************************** *函数名称:del *函数功能:删除链表中的元素 *输入:head 链表头指针,p 被删除元素位置 输出:被删除元素中的数据域.如果删除失败返回-1 **************************************************************************************/
int del(Node * head,int p)
{
Node * tmp = head;
for(int i = 0;i
<p;i++)
{
if(tmp == NULL)
return -1;
if(i
<p-1)
tmp = tmp->next;
}
int ret = tmp->next->data;
tmp->next = tmp->next->next;
return ret;
}
void print(Node *head)
{
for(Node *tmp = head;
tmp!=NULL; tmp = tmp->next)
printf("%d ",tmp->data);
printf("\n");
}
int main()
{
Node * head;
head = new Node;
head->data = -1;
head->next=NULL;
return 0;
}
编辑本段结语
C语言是学习数据结构的很好的学习工具。理解了C中用结构体描述数据结构,那么对于理解其C++描述,Java描述都就轻而易举了!
编辑本段两种链表形式
一、循环链表 循环链表是与单链表一样,是一种链式的存储结构,所不同的是,循环链表的最后一个结点的指针是指向该循环链表的第一个结点或者表头结点,从而构成一个环形的链。 循环链表的运算与单链表的运算基本一致。所不同的有以下几点: 1、在建立一个循环链表时,必须使其最后一个结点的指针指向表头结点,而不是象单链表那样置为NULL。此种情况还使用于在最后一个结点后插入一个新的结点。 2、在判断是否到表尾时,是判断该结点链域的值是否是表头结点,当链域值等于表头指针时,说明已到表尾。而非象单链表那样判断链域值是否为NULL。
二、双向链表 双向链表其实是单链表的改进。 当我们对单链表进行操作时,有时你要对某个结点的直接前驱进行操作时,又必须从表头开始查找。这是由单链表结点的结构所限制的。因为单链表每个结点只有一个存储直接后继结点地址的链域,那么能不能定义一个既有存储直接后继结点地址的链域,又有存储直接前驱结点地址的链域的这样一个双链域结点结构呢?这就是双向链表。 在双向链表中,结点除含有数据域外,还有两个链域,一个存储直接后继结点地址,一般称之为右链域;一个存储直接前驱结点地址,一般称之为左链域。
C语言可以在一个链表里保存两个结构体吗
当然可以拉
typedef
struct
ST1
ST1_T;
typedef
struct
ST2
ST2_T;
typedef
union
{
ST1_T
st1;
ST2_T
st2;
}
ST;
然后将ST作为
链表
的基本数据类型就是了
如果是同时存储的话,那么:
typedef
struct
{
ST1_T
st1;
ST2_T
st2;
}
ST;
链表是结点的有机(有序或无序)连接,这些结点的类型一般为构造数据类型。如果两条链表需要比较、合并等运算,那么这两条链表的结点类型一定是相同的,由此可见,一个结构体应该可以构造多条链表。
用C语言编写程序建立链表结构体类型实现链表初始化遍历和插入算法
我的C++ 链表源码 你可以参考下 你把 class 改成struct 就差不多了
个人源码(自编模板整合)
2010-09-28 16:47 (分类:默认分类)
#include
using namespace std;
template
struct Node
{
T data;
Node
*next;
};
template
class Sqlist
{
private:
Node
*head;
public:
Sqlist()
{
head=NULL;
}
~Sqlist()
{
Node
*p;
while(head)
{
p=head->next;
delete head;
head=p;
}
}
bool push(T x);
bool empty();
int length();
bool output();
bool replace(T x,T x2);
Node
*theone_find(int n,int i);
bool thetwo_insert(int i,T x);
bool thethree_Delete(int i,int n);
bool thefour_insert(T x);
void thefive(int k);
bool the_six(Sqlist
L2);
//bool clear();
};
template
bool Sqlist
::push(T x)
{
if(head==NULL)
{
Node
*p=new Node
;
p->data=x;
p->next=NULL;
head=p;
}
else {
Node
*p=head;
while(p->next!=NULL)p=p->next;
Node
*q=new Node
;
q->data=x;
q->next=NULL;
p->next=q;
}
return true;
}
template
bool Sqlist
::thethree_Delete(int i,int n)
{
Node
*p=head;
if(i<=0||i>n)return false;
if(i==1){head=p->next;delete p;return true;}
for(int j=2;j
next;
Node
*q=p->next;
p->next=q->next;
delete q;
return true;
}
template
bool Sqlist
::empty(){
return head==NULL;
}
template
int Sqlist
::length(){
Node
*p=head;
int n=0;
while(p!=NULL){n++;p=p->next;}
return n;
}
template
bool Sqlist
::output(){
Node
*p=head;
if(p==NULL)return false;
while(p!=NULL){cout<
data<<" ";p=p->next;}
cout<
<endl;
return true;
}
template
bool Sqlist
::replace(T x,T x2){
if(find(x)==NULL)return false;
Node
*p=find(x);
p->data=x2;
}
template
Node
*Sqlist
::theone_find(int n,int i){
Node
*p=head;
if(i>n||i<=0){p=NULL;return p;}
for(int j =1;j
next;
return p;
}
template
bool Sqlist
::thetwo_insert(int i,T x){
if(i>length()||i<0)return false;
if(i==length()){push(x);return true;}
Node
*p=new Node
;
p->data=x;
if(i==0){p->next=head;head=p;return true;}
Node
*q=head;
while(--i)q=q->next;
p->next=q->next;
q->next=p;
return true;
}
template
bool Sqlist
::thefour_insert(T x){
Node
*p=head;
if(x
data){
Node
*q=new Node
;
q->data=x;
q->next=p;
head=q;
return true;
}
while(p->next!=NULL){
if(x
next->data)break;
p=p->next;}
if(p->next==NULL){
Node
*q=new Node
;
q->data=x;q->next=NULL;
p->next=q;
}
else {
Node
*q=new Node
;
q->data=x;
q->next=p->next;
p->next=q;
}
return true;
}
template
void Sqlist
::thefive(int k)
{
Sqlist
a,b;
Node
*p=head;
for(int i=1;i<=k;i++)
{
if(i%2!=0){
a.push(p->data);
}
else b.push(p->data);
p=p->next;
}
a.output();
b.output();
}
template
bool Sqlist
::the_six(Sqlist
B)
{
Node
*p=head;
Node
*q=B.head;
Sqlist
L3;
while(p!=NULL)
{
while(q!=NULL)
{
if(p->data==q->data){L3.push(p->data);break;}
q=q->next;
}
p=p->next;
}
L3.output();
//cout<<"-----------"<
<endl;
return true;
}
int main(){
for(;;){
cout<<"1.求链表中第i个结点的指针"<
<endl;
cout<<"2.在第i个结点前插入值为x的结点"<
<endl;
cout<<"3.删除链表中第i个元素结点"<
<endl;
cout<<"4.在一个递增有序的链表L中插入一个值为x的元素"<
<endl;
cout<<"5.奇数项和偶数项结点分解开"<
<endl;
cout<<"6.L1和L2中的公共元素"<
<endl;
int a;
cin>>a;
switch(a)
{
case 1:
{
Sqlist
A;
int n,a;
cout<<"请输入n"<
<endl;
cin>>n;
for(int i=0;i
<n;i++)
{
cin>>a;A.push(a);
}
int i;
for(;;){
cout<<"请输入i"<
<endl;
cin>>i;
Node
*p;
p=A.theone_find(n,i);
if(p==NULL)cout<<"NULL"<
<endl;
else cout<<"!NULL"<
<endl;
int l;
cout<<"继续查找吗?否(1)是(2)"<
<endl;
cin>>l;
if(l==1)break;
}
break;
}
case 2:{
Sqlist
A;
int n,a;
cout<<"请输入n"<
<endl;
cin>>n;
for(int i=0;i
<n;i++)
{
cin>>a;A.push(a);
}
for(;;)
{
int i;int x;
cout<<"请输入位置i 数据x"<
<endl;
cin>>i>>x;
if(A.thetwo_insert(i-1,x)){cout<<"成功!"<
<endl;
A.output();}
else cout<<"失败!!"<
<endl;
char l;
cout<<"继续插入吗?否(n)是(Y)"<
<endl;
cin>>l;
if(l=='n')break;
}
break;
}
case 3:{
Sqlist
A;
int n,a;
cout<<"请输入n"<
<endl;
cin>>n;
for(int i=0;i
<n;i++)
{
cin>>a;A.push(a);
}
for(;;){
cout<<"请输入i"<
<endl;
int i ;cin>>i;
if(A.thethree_Delete(i,n)){cout<<"YES"<
<endl;
A.output();}
else cout<<"NO!!"<
<endl;
char l;
cout<<"继续删除吗?否(n)是(Y)"<
<endl;
cin>>l;
if(l=='n')break;
}
break;
}
case 4:{
Sqlist
A;
int n,a;
cout<<"请输入n"<
<endl;
cin>>n;
for(int i=0;i
<n;i++)
{
cin>>a;A.push(a);
}
for(;;)
{
int x;
cout<<"请输入X"<
<endl;
cin>>x;
A.thefour_insert(x);
A.output();
char l;
cout<<"继续插入吗?否(n)是(Y)"<
<endl;
cin>>l;
if(l=='n')break;
}
break;
}
case 5:{
Sqlist
A;
int n,a;
cout<<"请输入n"<
<endl;
cin>>n;
for(int i=0;i
<n;i++)
{
cin>>a;A.push(a);
}
A.thefive(n);
cout<
<endl;
A.output();
break;
}
case 6:{
Sqlist
A,B;
int n,a;
cout<<"请输入L1的n"<
<endl;
cin>>n;
for(int i=0;i
<n;i++)
{
cin>>a;A.push(a);
}
cout<<"请输入L2的n"<
<endl;
cin>>n;
for(int i=0;i
<n;i++)
{
cin>>a;B.push(a);
}
if(A.the_six(B))break;
}
default:{cout<<"选择错误!!"<
<endl;break;}
}
char l;
cout<
<endl;
cout<
<endl;cout<<endl;
cout<<"------还需要测试其他功能吗?否(n)是(y)------"<
<endl;
cin>>l;
if(l=='n')break;
system("cls");
}
return 0;
}
#include
#include
#define telemtype char
#define ok 1
#define error 0
#define overflow -1
typedef int status;
typedef struct bitnode
{
telemtype data;
struct bitnode *lchild,*rchild;
}bitnode,*bitree;
void preordertraverse(bitree T)
{
if(T)
{
printf("%c ",T->data);
preordertraverse(T->lchild);
preordertraverse(T->rchild);
}
}
status createbitree(bitree &T)
{
int ch;
ch=getchar();
if(ch==' ')
T=NULL;
else
{
if(!(T=(bitnode*)malloc(sizeof(bitnode))))
exit(overflow);
T->data=ch;
createbitree(T->lchild);
createbitree(T->rchild);
}
return ok;
}
void prinbtree(bitree T)
{
if(T!= NULL)
{
printf("%c", T->data);
if(T->lchild!=NULL||T->rchild!=NULL)
{
printf("(");
prinbtree(T->lchild);
if(T->rchild!=NULL)
{
printf(",");
}
prinbtree(T->rchild);
printf(")");
}
}
}
int main()
{
bitree T=NULL;
printf("先序输入二叉树:\n");
createbitree(T);
printf("先序遍历二叉树为:\n");
preordertraverse(T);
printf("\n");
prinbtree(T);
printf("\n");
return 0;
}
我写的,希望对你有用!
</endl;
</endl;cout<<endl;
</endl;
</endl;break;}
</n;i++)
</endl;
</n;i++)
</endl;
</endl;
</n;i++)
</endl;
</endl;
</endl;
</n;i++)
</endl;
</endl;
</endl;
</endl;
</endl;
</n;i++)
</endl;
</endl;
</endl;
</endl;
</endl;
</n;i++)
</endl;
</endl;
</endl;
</endl;
</endl;
</n;i++)
</endl;
</endl;
</endl;
</endl;
</endl;
</endl;
</endl;
</endl;
</endl;
C语言中怎样用链表保存结构体数据(动态数据结构)
1.用头插法。因为数据追加和删除比较多,追加的话,头插法可以直接插,用尾插降低了时间效率,删除用两个一样。
2./*结构体定义*/
struct client{
char account[14];
char name[10];
char identity[20];
char address[15];
long int money;
};
/*链表结点定义*/
struct node{
struct client band_inf;
struct node *next;
};
应该把结构体结点定义成链表的成员,这样链表才对。如果像你那样定义的话,完全不用定义结构体,链表就搞定了。因为你在链表里面把结构的成员都又定义了。
3.
1),定义结点:p1=(struct node*)malloc(sizeof(struct node)) ;表示定义一个node型的结点指针
使用,这个要看具体怎么用了。比如说删除searchp,priorp是searchp的前面一个结点,这样写
priorp->next=searchp->next;
delete searchp; 即可
插入newnode在searchp的后面,可以这样:
newnode->next=searchp->next;
searchp->next=newnode;
2)广义的二进制就是文件,你存成什么文件都行。.txt就行。
3)有保存的。if(fwrite(&stud[i],sizeof(struct student_type),1,fp)!=1)。里面有个fwrite就是写入文件,在判断的过程中,能写入文件的就已经写入了。 望采纳。
链表有多种形式,如:单向链表,双向链表,单向循环链表,双向循环链表。将链表结构定义为list_t,则该类型中一定(至少)存在一个指向下一节点的指针list_t *next;除了这个指针,list_t 中可以包含其它类型的数据,包括结构体变量。比如:typedef struct {
struct usr_struct data;
list_t *next;
} list_t;
p1=(struct studinf*)malloc(sizeof(struct studinf)) 表示开辟一段strunt 1.结构体和共用体类型数据的定义方法和引用方法。 2.用指针和结构体构成
单向链表很简单的,你这几这么就可以了:
struct client{
char account[14]; //账号
char name[10]; //名字
char identity[20]; //身份证号
char address[15]; //地址
long int money; //存款(可存可取)
client* pNext; //指向下一个节点,如果是最后一个节点则为NULL
};
然后,程序里只需要保存第一个节点就行了:
client* head = (client*)malloc(sizeof(client)); //第一个节点这么产生
head->pNext = NULL; //该表只有一个节点,所以第一个也是最后一个,别忘记赋0
插入的时候从头部插入就行了
client* p = (client*)malloc(sizeof(client));
p->pNext = head;
head = p; //将原来的头付给p的pNext指针,然后原来保存头元素的指针用p取代。
遍历链表更加容易了
client* pNode = head;
while (pNode)
{
printf(pNode->account); //比如打印所有客户的帐号
pNode = pNode->pNext; //让pNode指向下一个节点
//如果该节点是最后一个节点,那么pNode就会变成NULL,因为最后一个节点的pNext指针是NULL,while循环就会因为pNode为0而结束
}
保存进文件的时候相当于遍历一边所有的元素,读取的时候则一个一个读取,然后重新插入链表。最后,提醒一下的是别忘记用free释放由malloc分配的内存。
另外,考虑使用C++,可以更好的管理内存,思路也会更清晰。而且,如果是为了应用,根本不需要自己开发链表类,用STL就可以了,STL不仅提供双向链表,还有Map,HashMap等数据结构,非常适合特别大的数据量保存和查找,链表的查找很慢的,找一个数据相当于要把链表全部过一遍。
C语言结构体与链表问题【急】【急】【急】【急】【急】【急】【急】【急】【急】【急】【急】
#include
#include
int main( )
{
struct student
{ int num;
char name[20];
float score;
}stu, *p;
*p=stu;
stu.num=1001;
strcpy(p->name,"Mary");
scanf("%f", &p->score);
printf("%6d%10s%1.2f\n", p->num, p->name, p->score);
return 0;
}
2、
#include
#include
int main(int argc, char* argv[])
{
struct student
{ int num;
char name[20];
float score;
}stu, *p;
p=&stu;
stu.num=1001;
strcpy(p->name,"Mary");
scanf("%f", &p->score);
printf("%6d%10s%1.2f\n", p->num, p->name, p->score);
return 0;
}
目前我还没有学会
首先回答第一个问题,程序当中存在以下这几个问题:
(1) char name[ ]中的数组name没有指定大小,此处可以定义为name[20]
(2) p = stu也有错误,应该将结构体的首地址赋给指针p,从而使p指向该结构体。正确的写法是:
p = &stu;
(3) (*p).name = "Mary"也有错误,此处不能这么赋值。正确的写法是:strcpy(p->name, "Mary")
(4) scanf("%f", p->score)也有错误,此处p->score前面应加上取地址符&,正确写法是:
scanf("%f", &p->score)
将以上四个地方改完以后,就没有什么错误了!完整的程序是:
#include
#include
int main( )
{
struct student
{ int num;
char name[20];
float score;
} stu, *p;
p = &stu;
stu.num = 1001;
strcpy(p->name, ”Mary”);
scanf(“%f”, &p->score);
printf(“%6d%10s%6.2f\n”, p.num, p->name, p->score);
return 0;
}