【c语言编程题】构造函数运用更相减损术求最大公约数

1.第20行中直接书写这个语句，只打印gcd函数中的输出部分，虽然也能得到返回值，但不会打印返回值。并不是不能得到返回值。

创新互联建站秉承实现全网价值营销的理念，以专业定制企业官网，网站建设、网站设计，小程序定制开发，网页设计制作，手机网站开发，成都营销网站建设帮助传统企业实现“互联网+”转型升级专业定制企业官网,公司注重人才、技术和管理，汇聚了一批优秀的互联网技术人才,对客户都以感恩的心态奉献自己的专业和所长。

2.printf("%d",gcd(x,y)运行过程：先运行函数gcd()，当然运行过程中，函数内包含的打印语句照样全部打印；最后再输出gcd函数得到的返回值。并不是只打印返回值。

3.如果不要求函数可以输出形参值a和b以便观察函数gcd（）的递归计算过程，图二写法也是正确的。第5行和第7行没有else也是对的，是因为两个return语句与if语句完美配合，间接实现了分支语句的全部功能。

c语言构造函数问题

速度快，不易出错！在一些关于多文件，或者类的程序中用内敛函数实现构造函数不易产生二义性！

C语言 类的构造函数和析构函数(考试在线等！急！！！）

类是编程人员表达自定义数据类型的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;

}

这样，两个函数都默认为内联函数了。

一道C语言题目，求教，非常感谢

#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;

}

急解一个数据结构的题（C语言）

楼主真是太有缘了，我也正学数据结构，这是老师给我们提供的源代码，希望有用

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;

}

新闻标题：c语言构造函数题 c++构造函数语法
文章路径：http://azwzsj.com/article/dodoisj.html