c++课程设计职工工资管理系统.docx

c++课程设计职工工资管理系统.docx

《c++课程设计职工工资管理系统.docx》由会员分享，可在线阅读，更多相关《c++课程设计职工工资管理系统.docx（37页珍藏版）》请在冰豆网上搜索。

c++课程设计职工工资管理系统

题目c++面向对象程序设计课程设计

清单：

5小题+职工工资管理系统（类、链表实现）

姓名：

学号：

专业：

计算机科学与技术

学院：

指导教师：

2018年6月17日

Part1:

小程序练习

1类的继承

定义一个point类，包含私有数据成员x，y，成员函数包括无参构造函数，带参构造函数，set和get属性函数。

定义circle类，从point类公有派生，增加数据成员半径r，成员函数包括无参构造函数，带参构造函数，计算面积函数getarea。

在main函数中定义一个circle的对象，并计算其面积。

/*

1．定义Point类，设置其成员函数（构造函数，拷贝构造函数和析构函数）以及setx（）sety（）getx（）gety（）四个属性函数。

2．定义circle类，设置其成员函数（构造函数，拷贝构造函数和析构函数）以及获取半径r的函数get_r（）计算面积并获取面积的函数getarea（）。

3．在主函数中定义类的对象c1并初始化r=2。

再调用getarea（）函数输出面积

*/

#include

usingnamespacestd;

classpoint//定义point类

{

public:

point（）{}

point（intx,inty）

{

}

voidset_x（intx）

{

this->x=x;

}

intget_x（）

{

returnx;

}

voidset_y（inty）

{

this->y=y;

}

intget_y（）

{

returny;

}

private:

//私有对象xy

intx;

inty;

};

classcircle:

publicpoint//circle类公有派生point

{

public:

circle（）{}

circle（doubler,intx,inty）:

point（x,y）

{

this->r=r;

}

doubleget_r（）

{

returnr;

}

doublegetarea（）

{

return（3.14*r*r）;

}

private:

intr;//circle私有对象r

};

intmain（）

{

circlec1（2,3,6）;

cout<<"r="<

cout<<"该圆面积="<

system（"pause"）;

return0;

}

//发现问题：

定义的r好像只显示出int类型

运行结果分析：

主函数中r=2，输出圆面积12.56

2运算符重载，友元函数和this指针

定义一个计数器类counter，具备自增，自减功能（前后缀）；输入输出>>,<<功能。

在main函数里测试该类。

/*

1.定义counter类，私有成员数据weight，设置其成员函数（构造函数和析构函数）

2.重载自加自减运算符和<<、>>运算符。

3.在主函数中实现运算符重载。

4.友元函数需要声明。

*/

#include

#include

usingnamespacestd;

classcounter;

istream&operator>>（istream&is,counter&a）;

ostream&operator<<（ostream&os,counter&a）;

classcounter//定义类counter

{

private:

doubleP;

public:

counter（）{}//无参构造函数

counter（doublep）:

P（p）{}//带参构造函数

counteroperator++（）;//重载前置++

counteroperator++（int）;//重载后置++

counteroperator--（）;//重载前置--

counteroperator--（int）;//重载后置--

friendistream&operator>>（istream&is,counter&a）;//声明友元，重载输入运算符>>

friendostream&operator<<（ostream&os,counter&a）;//同上

};

countercounter:

:

operator++（）//前置++重载实现

{

++P;

return*this;

}

countercounter:

:

operator++（int）//后置++重载实现

{

countera=*this;

++（*this）;

returna;

}

countercounter:

:

operator--（）//前置--重载实现

{

--P;

return*this;

}

countercounter:

:

operator--（int）//后置--重载实现

{

countera=*this;

--（*this）;

returna;

}

istream&operator>>（istream&in,counter&a）//运算符>>重载实现

{

in>>a.P;

if（!

in）

cerr<<"输入错误！

"<

returnin;

}

ostream&operator<<（ostream&out,counter&a）//运算符<<重载实现

{

out<

returnout;

}

intmain（）

{

counterc1（236）,c2（632）;

cout<<"c1="<

cout<<"++c1="<<++c1<

cout<<"c1++="<

cout<<"c2--="<

cout<<"--c2="<<--c2<

system（"pause"）;

return0;

}

运行结果分析：

定义c1的值为236，c2的值为632；

此时++c1的数值为237；c1++输出时为237，输出后为238；

此时c2--输出时为632；--c2输出时为630，输出后为630；

3虚函数和抽象类

定义一个抽象类shape，包括公有的计算面积area函数，计算体积volume函数，输出基本信息函数printinfo（三个函数均为纯虚函数）。

从shape公有派生point类，增加私有数据成员x,y坐标，以及构造函数，析构函数。

从point公有派生circle类，增加私有数据成员半径r，以及构造函数，析构函数。

从circle公有派生cylinder类，增加私有数据成员高度h，以及构造函数，析构函数。

（在定义三个派生类的过程中，自己考虑需要重定义哪个虚函数）。

在main函数中，定义shape类的指针，指向派生类的对象，输出三类对象的基本信息，面积，体积；（将shape指针改为引用再尝试）。

/*

1．先定义基类shape。

设置三个纯虚函数并且声明：

声明计算面积纯虚函数area（）；声明计算体积纯虚函数volume（）；声明输出基本信息纯虚函数printinfo（）；

2．定义类point共有继承自类shape。

并且在该类中实现三个纯虚函数。

3．定义类circle共有继承自类point。

并且在该类中实现三个纯虚函数。

4．定义类cylinder共有继承自类circle。

并且在该类中实现三个纯虚函数。

5．在主函数中分别创建类point的对象a，circle的对象b，cylinder的对象c，并初始化；

6．在主函数中分别定义shape类的指针和引用，调用printinfo（）函数。

*/

#include

#include

#definePi3.141516

usingnamespacestd;

classshape

{

public:

virtualdoublearea（）=0;//三个纯虚函数：

面积，体积，基本输出

virtualdoublevolume（）=0;

virtualvoidprintinfo（）=0;

};

classpoint:

publicshape//shape派生的point类；点并没有体积面积，所以只写printinfo函数

{

public:

point（）{}

point（doublex,doubley）

{

this->x=x;

this->y=y;

}

voidprintinfo（）

{

cout<<"x="<

}

~point（）{}

private:

doublex;

doubley;

};

classcircle:

publicpoint//同理；circle类（圆）需重写两个虚函数；

{

public:

circle（）{}

circle（doubler,doublex,doubley）:

point（x,y）

{

this->r=r;

}

doublearea（）

{

returnPi*r*r;

}

voidprintinfo（）

{

point:

:

printinfo（）;

cout<<"半径为"<

cout<<"圆的面积是"<

}

~circle（）{}

private:

doubler;

};

classcylinder:

publiccircle//圆柱，同理，不多说

{

public:

cylinder（）{}

cylinder（doubleh,doublex,doubley,doubler）:

circle（x,y,r）

{

this->h=h;

}

/*doublearea（）

{

return2*Pi*this->r+circle:

:

area（）;//未实现计算圆柱表面积

}

*/

doublevolume（）

{

returnh*circle:

:

area（）;

}

voidprintinfo（）

{

circle:

:

printinfo（）;

cout<<"高为"<

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

}

~cylinder（）{}

private:

doubleh;

};

intmain（）

{

cylindertemp（6,2,3,3）;

shape*s;//实例化一个圆柱对象

s=&temp;

（*s）.printinfo（）;

printf（"\n"）;

cout<<"temp中数据构成的圆面积为"<area（）<

cout<<"体积为"<<（*s）.volume（）<

system（"pause"）;

return0;

}

运行结果：

4模板

编写一个使用类模板对数组进行查找、求元素和、重载下标[]运算符，以及输出的程序。

1）设计一个类模板:

形式1为templateclassArray；形似2为templateclassArray；用于对T类型的数组进行构造和输出；

2）产生模板类Array和Array进行测试；

3）产生模板类Array和Array进行测试。

//先实现第

（2）小题

#include

#include

usingnamespacestd;

template

classArray

{

private:

T*list;

intsize;

public:

Array（intsize=10）;//构造函数

~Array（）;//析构函数

T&operator[]（inti）;//重载"[]”

constT&operator[]（inti）const;

Tsum（intn）;

intsearch（Te,intn）;

intgetSize（）const;

voidresize（intsz）;

};

templateArray:

:

Array（intsz）//构造函数

{

assert（sz>=0）;

size=sz;

list=newT[size];

}

templateArray:

:

~Array（）//析构函数

{

delete[]list;

}

//重载下标运算符[]

template

T&Array:

:

operator[]（intn）

{

assert（n>=0&&n

returnlist[n];

}

template

constT&Array:

:

operator[]（intn）const

{

assert（n>=0&&n

returnlist[n];

}

//取当前数组的大小

template

intArray:

:

getSize（）const

{

returnsize;

}

//将数组大小修改为sz

template

voidArray:

:

resize（intsz）

{

assert（sz>=0）;

if（sz==size）

return;

T*newList=newT[sz];

intn=（sz

sz:

size;

for（inti=0;i

newList[i]=list[i];

delete[]list;//删除原数组

list=newList;//使list指向新数组

size=sz;//更新size

}

template

TArray:

:

sum（intn）

{

Tsum=list[0];

for（inti=1;i

sum+=list[i];

returnsum;

}

//查找

template

intArray:

:

search（Te,intn）

{

for（inti=0;i

if（list[i]==e）

returni;

return-1;

}

intmain（）

{

Arraya（5）;

inti,n,m,count=0;

cout<<"请输入数字个数:

";

cin>>n;

for（i=1;i<=n;i++）

{

cin>>m;

if（count==a.getSize（））a.resize（count*2）;

a[count++]=m;

}

for（i=0;i

cout<<""<

cout<

cout<<"数组和为：

"<

cout<<"数字4在数组中的位置是：

"<

/*Array进行测试

Arraya（5）;

inti,n,m,count=0;

cout<<"请输入数字个数:

";

cin>>n;

for（i=1;i<=n;i++）

{

cin>>m;

if（count==a.getSize（））a.resize（count*2）;

a[count++]=m;

}

for（i=0;i

cout<

cout<

cout<<"数组和为：

"<

cout<<"数字4在数组中的位置是：

"<

*/

return0;

}

//然后实现第（3）小题

#include

#include

usingnamespacestd;

template

classArray

{

private:

T*list;

public:

Array（）;//构造函数

~Array（）;//析构函数

T&operator[]（inti）;//重载"[]”

constT&operator[]（inti）const;

Tsum（）;

intsearch（Te）;

};

templateArray:

:

Array（）//构造函数

{

list=newT[n];

}

templateArray:

:

~Array（）//析构函数

{

delete[]list;

}

//重载下标运算符[]

template

T&Array:

:

operator[]（inti）

{

returnlist[i];

}

template

TArray:

:

sum（）

{

Tsum=list[0];

for（inti=1;i

sum+=list[i];

returnsum;

}

//查找

template

intArray:

:

search（Te）

{

for（inti=0;i

if（list[i]==e）

returni;

return-1;

}

intmain（）

{

Arraya;

inti,n,m,count=0;

cout<<"请输入数字个数:

";

cin>>n;

for（i=1;i<=n;i++）

{

cin>>m;

a[count++]=m;

}

for（i=0;i

cout<<""<

cout<

cout<<"数组和为：

"<

cout<<"数字4在数组中的位置是：

"<

/*Array进行测试

Arraya;

inti,n,m,count=0;

cout<<"请输入数字个数:

";

cin>>n;

for（i=1;i<=n;i++）

{

cin>>m;

if（count==a.getSize（））a.resize（count*2）;

a[count++]=m;

}

for（i=0;i

cout<

cout<

cout<<"数组和为：

"<

cout<<"数字4在数组中的位置是：

"<

*/

return0;

}

运行结果：

5文件读写

定义学生类数组，有N个人（N=5），包括姓名和语数外三名课的成绩，通过重载<<和>>运算符实现学生数组的文件读写。

/*

1.定义student类，私有数据成员字符数组name[20]；

2.定义运算符<<，>>重载；

3.在住函数中定义student类数组s[N];并以输出和二进制的方式打开文件

*/

#include

#include

#include

#defineN5

usingnamespacestd;

classstudent;

ostream&operator<<（ostream&os,students）;

istream&operator>>（istream&is,student&s）;

classstudent//student类：

姓名+4门成绩

{

public:

student（）{}

student（stringname,intchinese_socre,intmaths_score,intenglish_score）

{

this->name=name;

this->chinese_score=chinese_score;

this->maths_score=maths_score;

this->english_score=english_score;

}

friendostream&operator<<（ostream&os,students）//声明友元，重写<<、>>

{

os<

returnos;

}

friendistream&operator>>（istream&is,student&s）

{

is>>s.name>>s.chinese_score>>s.maths_score>>s.english_score;

returnis;

}

private:

stringname;

intchinese_score;

intmaths_score;

intenglish_score;

};

intmain（）

{

inti;

students[N];

for（i=0;i

cin>>s[i];

ofstreamofs（"c:

\\test\\test.txt",ios_base:

:

out）;

if（!

ofs）

{

cerr<<"fileopenfailed"<

exit

（1）;

}

for（i=0;i

{

ofs.write（reinterpret_cast（&s[i]）,sizeof（student））;

}

ifstreamifs（"c:

\\test\\test.txt",ios_base:

:

out）;

if（!

ifs）

{

cerr<<"fileopenfailed"<

exit

（1）;

}

for（i=0;i

{

ifs.read

（reinterpret_cast（&s[i]）,sizeof（student））;

}

for（i=0;i

cout<

system（"pause"）;

return0;

}

运行结果：

Par