甜橘子，专注成都网站制作网站设计与营销型网站建设与优化
QQ :532337155
电话：028-86922220
1.第20行中直接书写这个语句，只打印gcd函数中的输出部分，虽然也能得到返回值，但不会打印返回值。并不是不能得到返回值。
创新互联建站秉承实现全网价值营销的理念，以专业定制企业官网，网站建设、网站设计，小程序定制开发，网页设计制作，手机网站开发，成都营销网站建设帮助传统企业实现“互联网+”转型升级专业定制企业官网,公司注重人才、技术和管理，汇聚了一批优秀的互联网技术人才,对客户都以感恩的心态奉献自己的专业和所长。
2.printf("%d",gcd(x,y)运行过程：先运行函数gcd()，当然运行过程中，函数内包含的打印语句照样全部打印；最后再输出gcd函数得到的返回值。并不是只打印返回值。
3.如果不要求函数可以输出形参值a和b以便观察函数gcd（）的递归计算过程，图二写法也是正确的。第5行和第7行没有else也是对的，是因为两个return语句与if语句完美配合，间接实现了分支语句的全部功能。
速度快，不易出错！在一些关于多文件，或者类的程序中用内敛函数实现构造函数不易产生二义性！
类是编程人员表达自定义数据类型的C++机制。它和C语言中的结构类似，C++类
支持数据抽象和面向对象的程序设计，从某种意义上说，也就是数据类型的设
计和实现。
一、类的设计
1.类的声明
class 类名
{
private: //私有
...
public: //公有
...
};
2.类的成员
一般在C++类中，所有定义的变量和函数都是类的成员。如果是变量，我们就叫
它数据成员如果是函数，我们就叫它成员函数。
3.类成员的可见性
private和public访问控制符决定了成员的可见性。由一个访问控制符设定的可
访问状态将一直持续到下一个访问控制符出现，或者类声明的结束。私有成员
仅能被同一个类中的成员函数访问，公有成员既可以被同一类中的成员函数访
问，也可以被其他已经实例化的类中函数访问。当然，这也有例外的情况，这
是以后要讨论的友元函数。
类中默认的数据类型是private，结构中的默认类型是public。一般情况下，变
量都作为私有成员出现，函数都作为公有成员出现。
类中还有一种访问控制符protected，叫保护成员，以后再说明。
4.初始化
在声明一个类的对象时，可以用圆括号()包含一个初始化表。
看下面一个例子：
#include iostream.h
class Box
{
private:
int height,width,depth; //3个私有数据成员
public:
Box(int,int,int);
~Box();
int volume(); //成员函数
};
Box::Box(int ht,int wd,int dp)
{
height=ht;
width=wd;
depth=dp;
}
Box::~Box()
{
//nothing
}
int Box::volume()
{
return height*width*depth;
}
int main()
{
Box thisbox(3,4,5); //声明一个类对象并初始化
cout return 0;
}
当一个类中没有private成员和protected成员时，也没有虚函数，并且不是从
其他类中派生出来的，可以用{}来初始化。(以后再讲解)
5.内联函数
内联函数和普通函数的区别是：内联函数是在编译过程中展开的。通常内联函
数必须简短。定义类的内联函数有两种方法：一种和C语言一样，在定义函数时
使用关键字inline。如：
inline int Box::volume()
{
return height*width*depth;
}
还有一种方法就是直接在类声明的内部定义函数体，而不是仅仅给出一个函数
原型。我们把上面的函数简化一下：
#include iostream.h
class Box
{
private:
int height,width,depth;
public:
Box(int ht,int wd,int dp)
{
height=ht;
width=wd;
depth=dp;
}
~Box();
int volume()
{
return height*width*depth;
}
};
int main()
{
Box thisbox(3,4,5); //声明一个类对象并初始化
cout return 0;
}
这样，两个函数都默认为内联函数了。
#include iostream
using namespace std;
class Time{
public:
Time(int Hour, int Minute, int Second)
{
hour = Hour;
minute = Minute;
second = Second;
}
Time()
{
hour = minute = second = 0;
}
~Time()
{
cout"Goodbye!"endl;
}
void print_time()
{
couthour":"minute":"secondendl;
}
int getHour()
{
return hour;
}
int getMinute()
{
return minute;
}
int getSecond()
{
return second;
}
Time(Time time)
{
hour = time.getHour();
minute = time.getMinute();
second = time.getSecond();
}
private:
int hour, minute, second;
};
int main()
{
Time a(12, 34, 56), b;
a.print_time();
b.print_time();
b = a;
b.print_time();
return 0;
}
楼主真是太有缘了，我也正学数据结构，这是老师给我们提供的源代码，希望有用
Status MakeNode(Link *p,ElemType e)
{ /* 分配由p指向的值为e的结点，并返回OK；若分配失败。则返回ERROR */
*p=(Link)malloc(sizeof(LNode));
if(!*p)
return ERROR;
(*p)-data=e;
return OK;
}
void FreeNode(Link *p)
{ /* 释放p所指结点 */
free(*p);
*p=NULL;
}
Status InitList(LinkList *L)
{ /* 构造一个空的线性链表 */
Link p;
p=(Link)malloc(sizeof(LNode)); /* 生成头结点 */
if(p)
{
p-next=NULL;
(*L).head=(*L).tail=p;
(*L).len=0;
return OK;
}
else
return ERROR;
}
Status ClearList(LinkList *L)
{ /* 将线性链表L重置为空表，并释放原链表的结点空间 */
Link p,q;
if((*L).head!=(*L).tail)/* 不是空表 */
{
p=q=(*L).head-next;
(*L).head-next=NULL;
while(p!=(*L).tail)
{
p=q-next;
free(q);
q=p;
}
free(q);
(*L).tail=(*L).head;
(*L).len=0;
}
return OK;
}
Status DestroyList(LinkList *L)
{ /* 销毁线性链表L，L不再存在 */
ClearList(L); /* 清空链表 */
FreeNode((*L).head);
(*L).tail=NULL;
(*L).len=0;
return OK;
}
Status InsFirst(LinkList *L,Link h,Link s) /* 形参增加L,因为需修改L */
{ /* h指向L的一个结点，把h当做头结点，将s所指结点插入在第一个结点之前 */
s-next=h-next;
h-next=s;
if(h==(*L).tail) /* h指向尾结点 */
(*L).tail=h-next; /* 修改尾指针 */
(*L).len++;
return OK;
}
Status DelFirst(LinkList *L,Link h,Link *q) /* 形参增加L,因为需修改L */
{ /* h指向L的一个结点，把h当做头结点，删除链表中的第一个结点并以q返回。 */
/* 若链表为空(h指向尾结点)，q=NULL，返回FALSE */
*q=h-next;
if(*q) /* 链表非空 */
{
h-next=(*q)-next;
if(!h-next) /* 删除尾结点 */
(*L).tail=h; /* 修改尾指针 */
(*L).len--;
return OK;
}
else
return FALSE; /* 链表空 */
}
Status Append(LinkList *L,Link s)
{ /* 将指针s(s-data为第一个数据元素)所指(彼此以指针相链,以NULL结尾)的 */
/* 一串结点链接在线性链表L的最后一个结点之后,并改变链表L的尾指针指向新 */
/* 的尾结点 */
int i=1;
(*L).tail-next=s;
while(s-next)
{
s=s-next;
i++;
}
(*L).tail=s;
(*L).len+=i;
return OK;
}
Position PriorPos(LinkList L,Link p)
{ /* 已知p指向线性链表L中的一个结点，返回p所指结点的直接前驱的位置 */
/* 若无前驱，则返回NULL */
Link q;
q=L.head-next;
if(q==p) /* 无前驱 */
return NULL;
else
{
while(q-next!=p) /* q不是p的直接前驱 */
q=q-next;
return q;
}
}
Status Remove(LinkList *L,Link *q)
{ /* 删除线性链表L中的尾结点并以q返回，改变链表L的尾指针指向新的尾结点 */
Link p=(*L).head;
if((*L).len==0) /* 空表 */
{
*q=NULL;
return FALSE;
}
while(p-next!=(*L).tail)
p=p-next;
*q=(*L).tail;
p-next=NULL;
(*L).tail=p;
(*L).len--;
return OK;
}
Status InsBefore(LinkList *L,Link *p,Link s)
{ /* 已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之前， */
/* 并修改指针p指向新插入的结点 */
Link q;
q=PriorPos(*L,*p); /* q是p的前驱 */
if(!q) /* p无前驱 */
q=(*L).head;
s-next=*p;
q-next=s;
*p=s;
(*L).len++;
return OK;
}
Status InsAfter(LinkList *L,Link *p,Link s)
{ /* 已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之后， */
/* 并修改指针p指向新插入的结点 */
if(*p==(*L).tail) /* 修改尾指针 */
(*L).tail=s;
s-next=(*p)-next;
(*p)-next=s;
*p=s;
(*L).len++;
return OK;
}
Status SetCurElem(Link p,ElemType e)
{ /* 已知p指向线性链表中的一个结点，用e更新p所指结点中数据元素的值 */
p-data=e;
return OK;
}
ElemType GetCurElem(Link p)
{ /* 已知p指向线性链表中的一个结点，返回p所指结点中数据元素的值 */
return p-data;
}
Status ListEmpty(LinkList L)
{ /* 若线性链表L为空表，则返回TRUE，否则返回FALSE */
if(L.len)
return FALSE;
else
return TRUE;
}
int ListLength(LinkList L)
{ /* 返回线性链表L中元素个数 */
return L.len;
}
Position GetHead(LinkList L)
{ /* 返回线性链表L中头结点的位置 */
return L.head;
}
Position GetLast(LinkList L)
{ /* 返回线性链表L中最后一个结点的位置 */
return L.tail;
}
Position NextPos(Link p)
{ /* 已知p指向线性链表L中的一个结点，返回p所指结点的直接后继的位置 */
/* 若无后继，则返回NULL */
return p-next;
}
Status LocatePos(LinkList L,int i,Link *p)
{ /* 返回p指示线性链表L中第i个结点的位置，并返回OK，i值不合法时返回ERROR */
/* i=0为头结点 */
int j;
if(i0||iL.len)
return ERROR;
else
{
*p=L.head;
for(j=1;j=i;j++)
*p=(*p)-next;
return OK;
}
}
Position LocateElem(LinkList L,ElemType e,Status (*compare)(ElemType,ElemType))
{ /* 返回线性链表L中第1个与e满足函数compare()判定关系的元素的位置， */
/* 若不存在这样的元素，则返回NULL */
Link p=L.head;
do
p=p-next;
while(p!(compare(p-data,e))); /* 没到表尾且没找到满足关系的元素 */
return p;
}
Status ListTraverse(LinkList L,void(*visit)(ElemType))
{ /* 依次对L的每个数据元素调用函数visit()。一旦visit()失败，则操作失败 */
Link p=L.head-next;
int j;
for(j=1;j=L.len;j++)
{
visit(p-data);
p=p-next;
}
printf("\n");
return OK;
}
Status OrderInsert(LinkList *L,ElemType e,int (*comp)(ElemType,ElemType))
{ /* 已知L为有序线性链表，将元素e按非降序插入在L中。（用于一元多项式） */
Link o,p,q;
q=(*L).head;
p=q-next;
while(p!=NULLcomp(p-data,e)0) /* p不是表尾且元素值小于e */
{
q=p;
p=p-next;
}
o=(Link)malloc(sizeof(LNode)); /* 生成结点 */
o-data=e; /* 赋值 */
q-next=o; /* 插入 */
o-next=p;
(*L).len++; /* 表长加1 */
if(!p) /* 插在表尾 */
(*L).tail=o; /* 修改尾结点 */
return OK;
}
Status LocateElemP(LinkList L,ElemType e,Position *q,int(*compare)(ElemType,ElemType))
{ /* 若升序链表L中存在与e满足判定函数compare()取值为0的元素，则q指示L中 */
/* 第一个值为e的结点的位置，并返回TRUE；否则q指示第一个与e满足判定函数 */
/* compare()取值0的元素的前驱的位置。并返回FALSE。（用于一元多项式） */
Link p=L.head,pp;
do
{
pp=p;
p=p-next;
}while(p(compare(p-data,e)0)); /* 没到表尾且p-data.expne.expn */
if(!p||compare(p-data,e)0) /* 到表尾或compare(p-data,e)0 */
{
*q=pp;
return FALSE;
}
else /* 找到 */
{
*q=p;
return TRUE;
}
}
typedef struct LNode /* 结点类型 */
{
ElemType data;
struct LNode *next;
}LNode,*Link,*Position;
typedef struct LinkList /* 链表类型 */
{
Link head,tail; /* 分别指向线性链表中的头结点和最后一个结点 */
int len; /* 指示线性链表中数据元素的个数 */
}LinkList;
typedef LinkList polynomial;
#define DestroyPolyn DestroyList /* 与bo2-6.cpp中的函数同义不同名 */
#define PolynLength ListLength /* 与bo2-6.cpp中的函数同义不同名 */
Status OrderInsertMerge(LinkList *L,ElemType e,int(* compare)(term,term))
{ /* 按有序判定函数compare()的约定，将值为e的结点插入或合并到升序链表L的适当位置 */
Position q,s;
if(LocateElemP(*L,e,q,compare)) /* L中存在该指数项 */
{
q-data.coef+=e.coef; /* 改变当前结点系数的值 */
if(!q-data.coef) /* 系数为0 */
{ /* 删除多项式L中当前结点 */
s=PriorPos(*L,q); /* s为当前结点的前驱 */
if(!s) /* q无前驱 */
s=(*L).head;
DelFirst(L,s,q);
FreeNode(q);
}
return OK;
}
else /* 生成该指数项并插入链表 */
if(MakeNode(s,e)) /* 生成结点成功 */
{
InsFirst(L,q,s);
return OK;
}
else /* 生成结点失败 */
return ERROR;
}
int cmp(term a,term b) /* CreatPolyn()的实参 */
{ /* 依a的指数值、=或b的指数值，分别返回-1、0或+1 */
if(a.expn==b.expn)
return 0;
else
return (a.expn-b.expn)/abs(a.expn-b.expn);
}
void CreatPolyn(polynomial *P,int m) /* 算法2.22 */
{ /* 输入m项的系数和指数，建立表示一元多项式的有序链表P */
Position q,s;
term e;
int i;
InitList(P);
printf("请依次输入%d个系数，指数：\n",m);
for(i=1;i=m;++i)
{ /* 依次输入m个非零项（可按任意顺序） */
scanf("%f,%d",e.coef,e.expn);
if(!LocateElemP(*P,e,q,cmp)) /* 当前链表中不存在该指数项,cmp是实参 */
if(MakeNode(s,e)) /* 生成结点并插入链表 */
InsFirst(P,q,s);
}
}
void PrintPolyn(polynomial P)
{ /* 打印输出一元多项式P */
Link q;
q=P.head-next; /* q指向第一个结点 */
printf(" 系数 指数\n");
while(q)
{
printf("%f %d\n",q-data.coef,q-data.expn);
q=q-next;
}
}
void AddPolyn(polynomial *Pa,polynomial *Pb) /* 算法2.23 */
{ /* 多项式加法:Pa=Pa+Pb,并销毁一元多项式Pb */
Position ha,hb,qa,qb;
term a,b;
ha=GetHead(*Pa);
hb=GetHead(*Pb); /* ha和hb分别指向Pa和Pb的头结点 */
qa=NextPos(ha);
qb=NextPos(hb); /* qa和qb分别指向Pa和Pb中当前结点（现为第一个结点） */
while(!ListEmpty(*Pa)!ListEmpty(*Pb)qa)
{ /* Pa和Pb均非空且ha没指向尾结点(qa!=0) */
a=GetCurElem(qa);
b=GetCurElem(qb); /* a和b为两表中当前比较元素 */
switch(cmp(a,b))
{
case -1:ha=qa; /* 多项式Pa中当前结点的指数值小 */
qa=NextPos(ha); /* ha和qa均向后移一个结点 */
break;
case 0: qa-data.coef+=qb-data.coef;
/* 两者的指数值相等,修改Pa当前结点的系数值 */
if(qa-data.coef==0) /* 删除多项式Pa中当前结点 */
{
DelFirst(Pa,ha,qa);
FreeNode(qa);
}
else
ha=qa;
DelFirst(Pb,hb,qb);
FreeNode(qb);
qb=NextPos(hb);
qa=NextPos(ha);
break;
case 1: DelFirst(Pb,hb,qb); /* 多项式Pb中当前结点的指数值小 */
InsFirst(Pa,ha,qb);
ha=ha-next;
qb=NextPos(hb);
}
}
if(!ListEmpty(*Pb))
{
(*Pb).tail=hb;
Append(Pa,qb); /* 链接Pb中剩余结点 */
}
DestroyPolyn(Pb); /* 销毁Pb */
}
void AddPolyn1(polynomial *Pa,polynomial *Pb)
{ /* 另一种多项式加法的算法:Pa=Pa+Pb,并销毁一元多项式Pb */
Position qb;
term b;
qb=GetHead(*Pb); /* qb指向Pb的头结点 */
qb=qb-next; /* qb指向Pb的第一个结点 */
while(qb)
{
b=GetCurElem(qb);
OrderInsertMerge(Pa,b,cmp);
qb=qb-next;
}
DestroyPolyn(Pb); /* 销毁Pb */
}
void Opposite(polynomial Pa)
{ /* 一元多项式系数取反 */
Position p;
p=Pa.head;
while(p-next)
{
p=p-next;
p-data.coef*=-1;
}
}
void SubtractPolyn(polynomial *Pa,polynomial *Pb)
{ /* 多项式减法:Pa=Pa-Pb,并销毁一元多项式Pb */
Opposite(*Pb);
AddPolyn(Pa,Pb);
}
void MultiplyPolyn(polynomial *Pa,polynomial *Pb)
{ /* 多项式乘法:Pa=PaPb,并销毁一元多项式Pb */
polynomial Pc;
Position qa,qb;
term a,b,c;
InitList(Pc);
qa=GetHead(*Pa);
qa=qa-next;
while(qa)
{
a=GetCurElem(qa);
qb=GetHead(*Pb);
qb=qb-next;
while(qb)
{
b=GetCurElem(qb);
c.coef=a.coef*b.coef;
c.expn=a.expn+b.expn;
OrderInsertMerge(Pc,c,cmp);
qb=qb-next;
}
qa=qa-next;
}
DestroyPolyn(Pb); /* 销毁Pb */
ClearList(Pa); /* 将Pa重置为空表 */
(*Pa).head=Pc.head;
(*Pa).tail=Pc.tail;
(*Pa).len=Pc.len;
}