double date什么意思

C++写一个日期类Date

写一个日期类Date，（1）定义私有数据成员年、

月、日；（2）定义公有成员函数，(a)void

tDate(inty,intm,intd);//要求对数据成员赋

值;(b)voidoutput();//要求按年-月-日输出；

(c)voidIsLeap();//判断年份是否是闰年；(d)void

addOneday();//加上一天后的日期。

usingnamespacestd;

#include

classDate

{

private:

intyear,month,day;

public:

voidtDate(inty,intm,intd)

{

year=y;

month=m;

day=d;

}

voidoutput()

{

cout<

;

}

voidIsLeap()

{

if(year%400==0||(year%4==0&&year%100!

=0))

{

cout<<"是闰年"<

}

el

{

cout<<"不是闰年"<

}

}

voidaddOneday()

{

if((month==2&&day==29)||((year%4!=0||(yea

r%100==0&&year%400!=0))&&month==2&&

day==28))

{

day=1;

month++;

}

el

if(month==1||month==3||month==5||month==7||

month==8||month==10||month==12)

{

if(month==12&&day==31)

{

year++;

month=1;

day=1;

}

elif(day==31)

{

month++;

day=1;

}

}

el

if((month==4||month==6||month==9||month==11

)&&day==30)

{

month++;

day=1;

}

el

{

day++;

}

cout<

;

}

};

voidmain()

{

Datea;

e(2000,2,28);

();

();

day();

}

--------------------------------------------------------------

--------------------------------------------------------

作业2，设计圆类

实现圆类的成员函数，并在主函数中进行测试。

classCircle//圆类

{

private:

doubleradius;//半径

public://以下是公有成员函数

voidSetRadius(doubler);//设置半径

doubleCalculateArea();//求面积

doubleCalculateCircumference();//求周长

doubleGetRadius();//获取半径

voidPrint();//输出半径

};

usingnamespacestd;

#include

classCircle

{

private:

doubleradius;

public:

voidSetRadius(doubler)

{

radius=r;

}

doubleCalculateArea()

{

returnradius*radius*3.14;

}

doubleCalculateCircumference()

{

return2*3.14*radius;

}

doubleGetRadius()

{

returnradius;

}

voidPrint()

{

cout<<"半径："<

}

};

voidmain()

{

Circlea;

ius(5);

cout<<"面积"<

cout<<"周长

"<

cout<<"获取半径"<

();

}

--------------------------------------------------------------

-----------------------------------------------------

（1）数据成员有：横坐标doublex、纵坐标

doubley；

（2）提供两个构造函数：无参构造函数将数据

成员初始化为（0，0），有参构造函数利用参数

对数据成员赋值；

（3）提供拷贝构造函数；

（4）成员函数voidmoveto(doublea,doubleb)，

表示点移动到新的坐标位置（a,b）；

（5）成员函数voiddisplay()，输出点的坐标；

（6）友元函数doubledistance(CPoint

&p1,CPoint&p2)，求两点的距离；（求平方根

sqrt函数math.h中）；

（7）定义主函数，完成点类的测试。

#include

#include

classCPoint

{

private:

doublex,y;

public:

CPoint(doublex,doubley)

{

this->x=x;

this->y=y;

}

CPoint()

{

x=0;

y=0;

}

CPoint(constCPoint&p)

{

x=p.x;

y=p.y;

}

voidmoveto(doublea,doubleb)

{

x=a;

y=b;

}

voiddisplay()

{

cout<<"("<

}

frienddoubledistance(CPoint&p1,CPoint

&p2)

{

double

temp=sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(

p1.y-p2.y));

returntemp;

}

};

voidmain()

{

CPointa(0,0),b(3,4);

cout<<"距离："<

(2,2);

y();

CPointc(b);

y();

}

//1)定义基类CMathA，有保护数据成员3个，

分别为三个整数，公有成员函数3个，分别是有

参构造函数、求这三个数的最大值，和最小值。

//(2)定义派生类CMathB，公有继承CMathA，

私有数据成员2个，分别是两个整数，公有成员

函数3个，分别是有参构造函数（别忘记调用基

类有参构造函数）、求5个数据成员的和，与积。

//(3)定义主函数，完成基类与派生类所有成员函

数的测试。

usingnamespacestd;

#include

classCMathA

{

protected:

intx,y,z;

public:

CMathA(inta,intb,intc)

{

x=a;y=b;z=c;

}

voidmax()

{

intmax;

if(x>y)

{

max=x;

}

el

{

max=y;

}

if(max

{

max=z;

}

cout<<"最大值："<

}

voidmin()

{

intmin;

if(x

{

min=x;

}

el

{

min=y;

}

if(min>z)

{

min=z;

}

cout<<"最小值："<

}

};

classCMathB:publicCMathA

{

private:

intm,n;

public:

CMathB(inta,intb,intc,intd,inte)

:CMathA(a,b,c)

{

m=d;

n=e;

}

voidsum()

{

inttemp=x+y+z+m+n;

cout<<"和："<

}

voidmultiply()

{

inttem=x*y*z*m*n;

cout<<"乘积："<

}

};

voidmain()

{

CMathAa(1,3,2);

();

();

CMathBb(1,3,2,4,5);

ly();

();

}

--------------------------------------------------------------

-----------------

（1）编写点类Point，包括两个私有数据成员

doublex,y表示横纵坐标，成员函数包括两个分

别是Point(doublex,doubley);//构造函数和

Point(doublex,doubley);//显示函数

（2）编写几何图形的类Circle，包括两个属性：

圆心Pointcenter;和半径doubleR;成员函数包

括：圆心位置获取函数PointGetCenter();半径

获取函数doubleGetR()、半径设置函数void

SetR(doubler)、圆的位置移动函数void

MoveTo(Pointp2);以及圆的信息打印函数void

displayCircle()。

（3）编写主函数，完成圆类中所有成员函数的

测试。

usingnamespacestd;

#include

classPoint

{

private:

doublex,y;

public:

Point(doublea,doubleb)

{

x=a;

y=b;

}

voiddisPlay()

{

cout<<"圆心是：

("<

}

};

classCircle

{

private:

doubler;

Pointcenter;

public:

Circle(doubler,Pointp1)

:center(p1)

{

this->r=r;

}

PointGetCenter()

{

returncenter;

}

voidSetR(doubler)

{

this->r=r;

}

doubleGetR()

{

returnr;

}

voiddisplayCircle()

{

y();

cout<<"半径："<

}

voidMoveTo(Pointp2)

{

center=p2;

}

};

voidmain()

{

Pointp1(2,7),p2(3,7);

Circlecc(9,p1);

yCircle();

(p2);

yCircle();

cout<<()<

}

--------------------------------------------------------------

-------------------------------------

1．设计平面坐标系中的点类CPoint：

（1）私有数据成员有：横坐标doublex、纵坐

标doubley；

（2）公有提供两个构造函数：无参构造函数将

数据成员初始化为（0，0），有参构造函数利用

参数对数据成员赋值；

（3）公有提供拷贝构造函数；

（4）公有成员函数doubleGetX()，求点的横

坐标；

（5）公有成员函数doubleGetY()，求点的纵

坐标；

2．设计线类

（1）私有数据成员有：斜率和截距；

（2）公有提供两个有参构造函数：

CLine(doublek,doubleb)；CLine(CPoint

p1,CPointp2)

（3）公有成员函数doubleGetK()，求直线的

斜率

（4）公有成员函数boolIncludePoint(CPoint

p1)，判断一个点是否在直线上；

（5）公有成员函数voidDisplay()，显示直线

方程。

3．定义主函数，完成线类所有测试。

usingnamespacestd;

#include

classCPoint

{

private:

doublex,y;

public:

CPoint(doublex,doubley)

{

this->x=x;

this->y=y;

}

CPoint()

{

x=0;y=0;

}

CPoint(CPoint&p)

{

x=p.x;

y=p.y;

}

doubleGetX()

{

returnx;

}

doubleGetY()

{

returny;

}

};

classCLine

{

private:

doublek,b;

public:

CLine(doublek,doubleb)

{

this->k=k;

this->b=b;

}

CLine(CPointp1,CPointp2)

{

k=(()-())/(()-

());

b=()-k*();

}

boolIncludePoint(CPointp3)

{

if(()==k*()+b)

{

returntrue;

}

el

{

returnfal;

}

}

doubleGetK()

{

returnk;

}

voidDisplay()

{

if(b<0)

{

cout<<"直线方程：

y="<

}

elif(b==0)

{

cout<<"直线方程：y="<

}

el

{

cout<<"直线方程：

y="<

}

}

};

voidmain()

{

CPointp1,p2(2,7),p3(3,9);

CLineline1(p1,p2);

y();

cout<<"该直线的斜率是：

"<<()<

if(ePoint(p3)==true)

{

cout<<"该点在直线上"<

}

el

{

cout<<"该点不在直线上"<

}

}

--------------------------------------------------------------

------------------

设计圆类Circle，保护数据成员半径，公有成员

函数：输出圆面积voidarea()；

设计球体类Sphere，公有继承圆类，公有成员

函数：输出球体表面积voidarea()；

设计测试类，实现多态性，指向基类的指针，可

以指向派生类对象，并调用派生类的成员函数。

usingnamespacestd;

#include

classCircle

{

protected:doubleR;

public:

Circle(doubler)

{

R=r;

}

virtualvoidarea()

{

cout<<"圆面积为："<<3.14*R*R<

}

};

classSphere:publicCircle

{

public:

Sphere(doubler):Circle(r)

{

R=r;

}

virtualvoidarea()

{

cout<<"球表面积为：

"<<4*3.14*R*R<

}

};

voidmain()

{

Circlec1(2);

Circle*p;

Spheres1(5);

p=&c1;

p->area();

p=&s1;

p->area();

}

usingnamespacestd;

#include

//（1）定义类CShape，包含显示图形面积的含

纯虚函数virtualvoidDisplay_Area()=0；

//（2）定义圆类CCircle，公有继承CShape，

定义私有数据成员半径doubler，有参构造函

数，重写CShape类中的voidDisplay_Area()

函数，显示圆面积；

//（3）定义长方形类CSqure，公有继承CShape，

定义数据成员长和宽分别为doublelength和

doublewidth，重写CShape类中的void

Display_Area()函数，显示长方形面积；

//（4）定义主函数，创建CShape类指针数组，

分别指向圆和长方形对象，圆的半径为2，长方

形的长和宽分别为3和4，显示圆和长方形的面

积。

//（5）主函数参考代码；

//voidmain()

//{

//CShape*aa[2];

//aa[0]=newCCircle(2);

//aa[1]=newCSqure(3,4);

//for(inti=0;i<2;i++)

//{

//aa[i]->Display_Area();

//}

//}

classCShape

{

public:

virtualvoidDisplay_Area()=0;

};

classCCircle:publicCShape

{

private:doubler;

public:

CCircle(doublex)

{

r=x;

}

virtualvoidDisplay_Area()

{

cout<<"圆面积："<<3.14*r*r<

}

};

classCSqure:publicCShape

{

private:doublelength,width;

public:

CSqure(doublea,doubleb)

{

length=a;

width=b;

}

virtualvoidDisplay_Area()

{

cout<<"矩形面积："<

}

};

voidmain()

{

CShape*aa[2];

aa[0]=newCCircle(2);

aa[1]=newCSqure(3,4);

for(inti=0;i<2;i++)

{

aa[i]->Display_Area();

}

}

--------------------------------------------------------------

----------------

定义复数类Complex，

（1）定义私有数据成员，实部和虚部；

（2）定义带默认值的构造函数，给数据成员赋

值，默认值为0；

（3）定义输出函数voiddisplay()，输出格式如

“3+4i”或“-3-4i”；

（4）定义复数与复数的加、减运算符重载；复

数加实数运算符重载；赋值运算符重载；

（5）定义主函数，对上述成员函数进行测试。

usingnamespacestd;

#include

classComplex

{

private:doublea,b;

public:

Complex(doublea=0,doubleb=0)

{

this->a=a;

this->b=b;

}

Complexoperator+(Complexc)

{

Complextemp;

temp.a=a+c.a;

temp.b=b+c.b;

returntemp;

}

Complexoperator-(Complexc)

{

Complextemp;

temp.a=a-c.a;

temp.b=b-c.b;

returntemp;

}

Complexoperator+(doublec)

{

Complextemp;

temp.a=a+c;

temp.b=b;

returntemp;

}

Complex&operator=(Complexc)

{

a=c.a;

b=c.b;

return*this;

}

voiddisplay()

{

if(b<0)

{

cout<

}

el

{

cout<

}

}

};

intmain()

{

Complexc1(2,5),c2(3,7),c3,c4,c5,c6;

cout<<"c1=";

y();

cout<<"c2=";

y();

c3=c1+c2;

cout<<"c3=c1+c2;c3=";

y();

c4=c1-c2;

cout<<"c4=c1-c2;c4=";

y();

c5=c1+5;

cout<<"c5=c1+5;c5=";

y();

c6=c2;

cout<<"c6=c2;c6=";

y();

}

--------------------------------------------------------------

----------------

usingnamespacestd;

#include

//定义时钟类Clock，

//（1）定义私有数据成员，时、分和秒；

//（2）定义带默认值的构造函数，给数据成员赋

值，默认值为0；要求对数据进行合法性判断，

小时只能在0—23之间，分和秒都在0—60之间；

//（3）定义输出函数voiddisplay()，输出格式如

“h:m:s”；

//（4）定义时钟前缀++运算符重载，和后缀++

运算符重载；

//（5）定义主函数，对上述成员函数进行测试。

classClock

{

private:doubleh,m,s;

public:

Clock(doubleh=0,doublem=0,doubles=0)

{

if(h>=0&&h<24&&m>=0&&m<60&&s>=0&

&s<60)

{

this->h=h;

this->m=m;

this->s=s;

}

el

{

cout<<"timeerror!"<

}

}

voiddisplay()

{

cout<

}

Clock&operator++()

{

s++;

if(s>=60)

{

s=s-60;

m++;

if(m>=60)

{

m=m-60;

h++;

if(h>=24)

{

h=h-24;

}

}

}

return*this;

}

Clockoperator++(int)

{

s++;

if(s>=60)

{

s=s-60;

m++;

if(m>=60)

{

m=m-60;

h++;

if(h>=24)

{

h=h-24;

}

}

}

return*this;

}

};

intmain()

{

Clocka(23,59,59);

a++;

y();

++a;

y();

}

usingnamespacestd;

#include

//设计体积类

//（1）定义CVolume类，包含求体积的纯虚函

数virtualdoublevolumeValue()=0；

//（2）定义球类CSphere，公有继承CVolume，

定义私有数据成员求半径doubler，定义有参构

造函数，重写CVolume类中的double

volumeValue()函数，求球的体积；

//（3）定义立方体类CCube，公有继承CVolume，

定义私有数据成员棱长为doubleside，定义有参

构造函数，重写CVolume类中的double

volumeValue()函数，求立方体的体积；

//（4）定义主函数，完成上述功能的测试。

classCVolume

{

public:

virtualdoublevolumeValue()=0;

};

classCSphere:publicCVolume

{

private:doubler;

public:

CSphere(doubler=0)

{

this->r=r;

}

virtualdoublevolumeValue()

{

return3.14*4*r*r*r/3;

}

};

classCCube:publicCVolume

{

private:doubleside;

public:

CCube(doubles=0)

{

side=s;

}

virtualdoublevolumeValue()

{

returnside*side*side;

}

};

intmain()

{

CCubea(5);

cout<<"立方体体积：

"<

CSphereb(5);

cout<<"球体积："<

}

--------------------------------------------------------------

----------------------------

//（1）设计求三个数的最大数的函数模板T

max(Ta,Tb，Tc)；

//（2）在主函数中，分别用int、double对上述

模板实例化，并测试结果。

usingnamespacestd;

#include

template

Tmax(Ta,Tb,Tc)

{

Tmax;

if(a

{

max=b;

}

el

{

max=a;

}

if(max

{

max=c;

}

returnmax;

}

intmain()

{

inta=2,b=1,c=5;

cout<<"最大值为："<

doublex=3.14,y=3.8,z=3.5;

cout<<"最大值为："<

}

--------------------------------------------------------------

-------------------------

（1）设计父亲类Father，保护的数据成员char

fname[6]表示父亲的姓，私有成员charsname[10]

表示父亲的名;定义公有的有参构造函数

Father(charffname[],charssname[])，给数据成

员赋值；定义voiddisplayfather()函数，显示父

亲的名字。

（2）设计母亲类Mother，私有数据成员char

mfname[6],charmsname[10]分别表示母亲的姓

和名，定义公有的有参构造函数Mother(char

ffname[],charssname[])给数据成员赋值，定义

voiddisplaymother()函数，显示母亲的名字。

（3）设计子女类Child，公有继承父亲类和母

亲类，私有数据成员charcname[10]，表示子女

的名，子女的姓，将从父亲类继承而来；定义公

有的有参构造函数Child(charfname[],char

sname[],charmname[],charmsname[],char

ccname[])，并调用基类的构造函数，同时给私

有数据赋值；定义voiddisplay()函数，调用基类

的显示函数，显示父亲姓名和母亲姓名，再输出

自己的姓名。

（4）设计主函数，对上述功能进行测试。

主函数的参考代码如下：

voidmain()

{

Childcc("陈","国安","王","红","志刚");

y();

}

usingnamespacestd;

#include

#include

classFather

{

private:

charsname[10];

protected:

charfname[6];

public:

Father(charffname[],charssname[])

{

strcpy(fname,ffname);

strcpy(sname,ssname);

}

voiddisplayfather()

{

cout<<"父亲姓名为：

"<

}

};

classMother

{

private:

charmsname[10];

charmfname[6];

public:

Mother(charffname[],charssname[])

{

strcpy(mfname,ffname);

strcpy(msname,ssname);

}

voiddisplaymother()

{

cout<<"母亲姓名为：

"<

}

};

classChild:publicFather,publicMother

{

private:

charcname[10];

public:

Child(charfname[],charsname[],char

mname[],charmsname[],charccname[])

:Father(fname,sname),Mother(mname,msn

ame)

{

strcpy(cname,ccname);

}

voiddisplay()

{

Father::displayfather();

Mother::displaymother();

cout<<"孩子姓名为："<

}

};

intmain()

{

Childcc("陈","国安","王","红","志刚");

y();

}

--------------------------------------------------------------

--------------------------------------

usingnamespacestd;

#include

//使用虚函数编写程序，求球体和圆柱体的体积

和表面积。

//（1）定义基类Circle

//定义数据成员Radius；

//定义两个纯虚函数分别是：

//voidArea();//显示表面积

//voidVolumn();//显示体积

//（2）定义派生类球体类Sphere，公有继承Circle

类，求出球体的表面积和体积；

//（3）定义派生类圆柱体类Volum，公有继承

Circle类，求出圆柱体的表面积和体积；

//（4）定义测试类，完成上面代码所有的测试。

classCircle

{

protected:

doubleRadius;

public:

virtualvoidArea()=0;

virtualvoidVolumn()=0;

};

classSphere:publicCircle

{

public:

Sphere(doubler)

{

Radius=r;

}

virtualvoidArea()

{

doublearea;

area=4*3.14*Radius*Radius;

cout<<"球的表面积="<

}

virtualvoidVolumn()

{

doublet;

t=4*3.14*Radius*Radius*Radius/3;

cout<<"球的体积="<

}

};

classVolum:publicCircle

{

private:

doublehigh;

public:

Volum(doubler,doubleh)

{

high=h;

Radius=r;

}

virtualvoidArea()

{

doublearea;

area=2*3.14*Radius*Radius+2*3.14*Radius*

high;

cout<<"圆柱体的表面积="<

}

virtualvoidVolumn()

{

doublet;

t=3.14*Radius*Radius*high;

cout<<"圆柱体的体积="<

}

};

intmain()

{

Spheres1(5);

();

();

Volumv1(5,5);

();

();

}

--------------------------------------------------------------

-------------------------------------

（1）定义基类Person类

定义私有数据成员charname[10];

定义公有的无参构造函数，对私有数据赋空值

（即空字符串），

公有函数voidinrt_name(charpname[])//

对name重新赋值

voidprint()//输出name

（2）定义派生类Student类，公有继承虚基类

Person

定义私有数据成员charid[12];//学号

定义公有的无参构造函数，对私有数据赋空值

（即空字符串），并调用基类的无参构造函数；

公有函数voidinrt_id(charpid[])//对id重

新赋值

voidprint()//调用基类输出name，同时输出

id

（3）定义派生类Teacher类，公有继承虚基类

Person

定义私有数据成员doublesal;//工资

定义公有的无参构造函数，对私有数据赋空值

（即sal=0），并调用基类的无参构造函数；

公有函数voidinrt_sal(doublesal)//对sal重

新赋值

voidprint()//调用基类输出name，同时输出

sal

（4）定义派生类DepatementStudent，公有继承

Student

定义私有数据成员chardn[20];//部门

定义公有的无参构造函数，对私有数据赋空值

（即空字符串），并调用基类的无参构造函数；

公有函数voidinrt_dn(charpdn[])//对dn重

新赋值

voidprint()//调用基类输出name,id，同时输

出dn

（5）定义派生类Tpost（做兼职的学生类），公

有继承Teacher类，公有继承

DepatementStudent类：

定义公有的无参构造函数，调用基类Teacher类

和DepatementStudent类的无参构造函数；

voidprint()//调用基类Teacher的输出函数，

再调用基类DepatementStudent的输出函数

（6）定义主函数，并进行测试。

usingnamespacestd;

#include

classPerson

{

private:

charname[10];

public:

Person()

{

strcpy_s(name,"");

}

voidinrt_name(charpname[])

{

strcpy_s(name,pname);

}

voidprint()

{

cout<<"姓名："<

}

};

classStudent:virtualpublicPerson

{

private:

charid[12];

public:

Student():Person()

{

strcpy_s(id,"");

}

voidinrt_id(charpid[])

{

strcpy_s(id,pid);

}

voidprint()

{

Person::print();

cout<<"学号："<

}

};

classTeacher:virtualpublicPerson

{

private:

doublesal;

public:

Teacher():Person()

{

sal=0;

}

voidinrt_sal(doublesal)

{

this->sal=sal;

}

voidprint()

{

Person::print();

cout<<"薪水："<

}

};

classDepatementStudent:publicStudent

{

private:

chardn[20];

public:

DepatementStudent():Student()

{

strcpy_s(dn,"");

}

voidinrt_dn(charpdn[])

{

strcpy_s(dn,pdn);

}

voidprint()

{

Student::print();

cout<<"部门："<

}

};

classTpost:publicTeacher,public

DepatementStudent

{

public:

Tpost():Teacher(),DepatementStudent()

{

cout<<"兼职学生"<

}

voidprint()

{

Teacher::print();

DepatementStudent::print();

}

};

voidmain()

{

Teachera;

Tpostb;

_name("LiMin");

_sal(2000);

_name("ZhangHua");

_sal(1500);

_id("03410101");

_dn("Computer");

();

();

}

--------------------------------------------------------------

-----------------------

作业9：设计函数模板

（1）定义函数模板，对含有n个元素的a数组，

统计所有元素之和。

（2）在主函数中，分别用int和double类型对

模板实例化，并测试结果。

usingnamespacestd;

#include

template

voidprintsum(Ta[],intn)

{

Tsum=a[0];

for(inti=1;i

{

sum=sum+a[i];

}

cout<

}

voidmain()

{

inta[4]={5,0,3,8};

printsum(a,4);

doubleb[4]={1,1.2,5.2,0};

printsum(b,4);

}

--------------------------------------------------------------

---------------------------------------

设计模板类

（1）定义模板类CValue，包含一个属性value；

（2）定义有参构造函给value属性赋值；

（3）定义display函数，显示value属性的值；

（4）在主函数中，分别用int、double和char

类型对模板实例化，并测试结果。

usingnamespacestd;

#include

template

classCValue

{

private:

Tvalue;

public:

CValue(Tval)

{

value=val;

}

voiddisplay()

{

cout<

}

};

voidmain()

{

inta=5;

doubleb=3.5;

charc='A';

CValuec1(a);

y();

CValuec2(b);

y();

CValuec3(c);

y();

}

--------------------------------------------------------------

-------------------------------------------------

编写一个函数模板，它返回两个值中的最小者。但同时保证能正确处理字符串。

usingnamespacestd;

#include

#include

template

TMin(Ta,Tb)

{

returna

}

char*Min(char*a,char*b)

{

if(strcmp(a,b)<0)

{

returna;

}

el

{

returnb;

}

}

voidmain()

{

inta=5,b=3;

cout<

charx[10]="Hello";

chary[10]="Gold";

cout<

}

--------------------------------------------------------------

----------------------------------

设计类模板

（1）定义类模板Ccomp，包含两个属性a和b；

（2）定义有参构造函数给a、b属性赋值；

（3）定义min函数，显示a、b属性的最小值；

（4）定义max函数，显示a、b属性的最大值；

（5）重载min函数，实现对“字符串类型数据”求最小值；

（6）重载max函数，实现对“字符串类型数据”求最大值；

（7）在主函数中，分别用int、double和char*类型对模板实例

化，并测试结果。

usingnamespacestd;

#include

#include

template

classCcomp

{

private:Ta,b;

public:

Ccomp(Tx,Ty){a=x;b=y;}

TMin(){returna

TMax(){returna>b?a:b;}

char*Min(intz)

{

if(strcmp(a,b)<0)

{

returna;

}

el

{

returnb;

}

}

char*Max(intz)

{

if(strcmp(a,b)>0)

{

returna;

}

el

{

returnb;

}

}

};

voidmain()

{

inta=59,b=88;

Ccompc1(a,b);

cout<<"max"<<()<

cout<<"min"<<()<

doublem=59.1,n=88.1;

Ccompc2(m,n);

cout<<"max"<<()<

cout<<"min"<<()<

char*x="student";

char*y="teacher";

Ccompc3(x,y);

cout<<"max"<<(1)<

cout<<"min"<<(1)<

}

--------------------------------------------------------------

----------

定义复数类的加法与减法，使之能够执行下列运

算：

Complexa(2,5),b(7,8),c(0,0);

c=a+b;

c=4.1+a;

c=b+5.6;

usingnamespacestd;

#include

classComplex

{

private:

doublea,b;

public:

Complex(doublea=0,doubleb=0)

{

this->a=a;

this->b=b;

}

Complexoperator+(Complexc)

{

Complextemp;

temp.a=a+c.a;

temp.b=b+c.b;

returntemp;

}

Complexoperator-(Complexc)

{

Complextemp;

temp.a=a-c.a;

temp.b=b-c.b;

returntemp;

}

Complexoperator+(doublec)

{

Complextemp;

temp.a=a+c;

temp.b=b;

returntemp;

}

Complex&operator=(Complexc)

{

a=c.a;

b=c.b;

return*this;

}

voiddisplay()

{

if(b<0)

{

cout<

}

if(b==0)

{

cout<

}

el

{

cout<

}

}

friendComplexoperator+(doublec,Complex

x);

};

Complexoperator+(doublec,Complexx)

{

Complextemp;

temp.a=x.a+c;

temp.b=x.b;

returntemp;

}

voidmain()

{

Complexc1(2,5),c2(7,8),c3;

c3=c1+c2;

y();

c3=4.1+c1;

y();

c3=c2+5.6;

y();

}

--------------------------------------------------------------

---------------------------------

//1、输出100以内的有序数。

//2、输出200以内的素数。

usingnamespacestd;

#include

boolPrime(intn);

boolsxs(intn);

intmain()

{

inti;

cout<<"200以内的素数："<

for(i=2;i<200;i++)

{

if(Prime(i))

{

cout<

}

}

cout<

cout<<"100以内升序数："<

for(i=10;i<100;i++)

{

if(sxs(i))

{

cout<

}

}

cout<

}

boolPrime(intn)

{

inti=2;

for(;i

{

if(n%i==0)

{

break;

}

}

if(n==i)

{

returntrue;

}

el

{

returnfal;

}

}

boolsxs(intn)

{

inttemp;

temp=n;

while(n>0)

{

if(n%10<=n/10%10)

{

returnfal;

}

n=n/10;

}

returntrue;

}

--------------------------------------------------------------

---------------------------------------------------

（1）将100以内的素数，写入d:文件

中；

（2）读取d:文件中的数据，显示在屏

幕上。

usingnamespacestd;

#include

#include

boolPrime(intn);

intmain()

{

ofstreamfout("d:");

inti;

for(i=2;i<100;i++)

{

if(Prime(i))

{

fout<

}

}

();

ifstreamfin("d:");

while(fin>>i)

{

cout<

}

();

}

boolPrime(intn)

{

inti=2;

for(;i

{

if(n%i==0)

{

break;

}

}

if(n==i)

{

returntrue;

}

el

{

returnfal;

}

}