40道c++程序填空题（2）
第二版
传送门1：网页版
传送门2：word版
传送门3：图片版
C++程序填空复习
Test1：
#include<iostream>
#include<cmath>
#include<cstdlib>
using namespace std;
int main(){
double a,b,c;
double delta,x1,x2;
const double zero=1e-9;//定义一个很小的常数
int sign;
cout<<“输入三个系数a(a!=0),b,c:”<<endl;
cin>>a>>b>>c;//输入a、b、c的值
if（fabs(a)<zero）{ //绝对值很小的数即被认为是0
cout<<“二次项系数为0，方程的根是-c/b”；
exit(0);
}
cout<<“a=”<<a<<’\t’<<“b=”<<b<<’\t’<<”c=”<<c<<endl;
delta=b*b-4*a*c;
if(fabs(delta)<zero){
cout<<“方程有两个相等的实根：”；
cout<<“x1=x2=”<<-b/(2*a)<<endl;
}else{
if(delta>0) sign=1;
else sign=0;
delta=sqrt(fabs(delta));
x1=-b/(2*a);
x2=delta/(2*a);
if(sign!=0){
cout<<“方程有两个不同的实根：”；
cout<<”x1=”<<x1+x2<<’\t’<<”x2=”<<x1-x2<<endl;
}else {// sign==0
cout<<“方程有两个不同的复数根：”；
cout<<“x1=”<<x1<<“+i”<<x2<<’\t’<<“x2=”<<x1<<”-I”<<x2<<endl;
}
}return 0;
}
Test2:设计程序将输入夫人百分制成绩转化为五分制输出，90分以上为5分，80~89分为四分，70~79分为3分，60~69分为2分，60分以下为1分.（提示：百分制成绩的分档用整除10的方法实现）
#include <iostream>// [1]
using namespace std;
int main() {
int mark, result; //mark是百分制成绩，result是5分制
cout<<"请输入百分制成绩："<<endl;
cin>>mark;
if(mark<0) {
cout<<"缺考！"<<endl;
return 0;
}
switch(mark/10) { //对百分制成绩进行分档 [2](mark]
case 10:
case 9 ://[3]case 9:
result=5;
cout<<"输出五分制成绩："<<result<<endl;
break;
case 8:
result=4;
cout<<"输出五分制成绩："<<result<<endl;
break; //[4]break;
case 7:
result=3;
cout<<"输出五分制成绩："<<result<<endl;
break;
case 6:
result=2;
cout<<"输出五分制成绩："<<result<<endl;
break;
case 5: case 4: case 3: case 2: case 1: case 0:
result=1;
cout<<"输出五分制成绩："<<result<<endl;
break;
default:
cout<<"输入错误！"<<endl;
}
}
Test3:输入n，求1！+2！+3！+…+n!。（提示：通常求和作为外循环，阶乘作为内循环）
using namespace std;
【1】int main(){
int n, i, jch; //jch是阶乘
double result=0; //result是结果
【2】 cin>>n; //输入n的值
if(n<1) {
cout<<"输入错误！"<<endl;
return 0;
}
result=1;
for(i=2,jch=1; i<=n; 【3】 i++) {
【4】jch=jch*i; //计算阶乘
result+=jch;
}
cout<<result<<endl;
return 0;
}
Test4：编写一个函数，将一个数插入到已是升序的数组中，且插入后该数组仍是升序数组。已是升序数组的内容由主函数给出，待插入的数在主函数中输入。
#include <iostream>
using namespace std;
int main() {
int i, j, number, a[11]= {1,2,4,6,8,9,12,15,20,30};
cout<<"请输入一个数:";
cin>>number; //输入number的值
cout<<"开始的数组:";
for(i=0; i<10; i++)
cout<<a[i]<<" ";
cout<<endl;
i=0;
while (i<10&&number>=a[i]) i++;
for(j=10; j>=i; j--)
a[j]=a[j-1];
a[i]=number;
cout<<"插入后的数组:";
for(i=0; 【4】i<11; i++)
cout<<a[i]<<" ";
return 0;
}
Test5：编程找出1~500之中满足除以3余2，除以5余3，除以7余2的整数。
【1】#include <iostream>
using namespace std;
int main() {
int i;
for(i=1; 【2】i<=500; i++)
if((i%3==2)&&(i%5==3)&&【3】i%7==2 )
【4】cout<<i<<endl;
return 0;
}
Test6：编程求1000之内的所有完全数。所谓完全数是指一个。例如6=1+2+3，就是一个完全数。（提示：采用穷举法。两两循环，外层是1到999依次处理，内层是求该数的所有因子之和）
#include <iostream>
【1】using namespace std;
int main() {
int i, a, sum; //sum是a的因子和
for(【2】a=1; a<1000; a++) {
sum=0;
for(i=1; i<a; i++)
if(a%i==0 ) 【3】sum+=i; //如果i是a的一个因子，则求因子和
if(【4】sum==a) //如果这个数等于它的所有因子和
cout<<a<<endl;
}
return 0;
}
Test7：设计函数factors(num,k),返回值整数num包含因子k的个数，如果没有该因子，则返回0。
#include <iostream>
using namespace std;
int factors(int num, int k) {
int count=0; //count用来统计个数
while (num%k==0) {
【1】count++;
num/=k;
}
【2】return count;
}
【3】int main(){ //
【4】cout<<"factors(64,3)="<<factors(64,3)<<endl;
return 0;
}
Test8:函数myStrCat(char*dst,char*src)将字符串src连接到字符串dst的后面，填写适当的代码，是的mySum（）完成正确的功能。
#include <iostream>
#include <cstring>
using namespace std;
char myStrCat(char *dst, char *src) ; //myStrCat函数的声明
int main() {
void dst[100]="Hello, ";
char src[100]="Good luck!";
myStrCat(dst, src);
cout << dst << endl;
return 0;
}
void myStrCat(char *dst, char *src) {//【3】______
int i=0, len;
len = strlen(dst);
while(src[i]) {
dst[len] = src[i];
len++;
i++;
}
dst[len] = '\0';
}
Test9：定义max函数实现求三个实数中的最大值。
#include<iostream>
using namespace std;
double max(double a, double b, double c) {//【1】______
if(a>b&&a>c) return a;
if(b>a&&b>c) return b;//[2]
return c;//[3]
}
int main() {
cout<<max(3.2,7.4,4.5)<<endl;//[4]
return 0;
}
Test10:编写函数getSum()，求整数m的各位数字之和并返回该值。例如m=25时，各位数字之和为9。
#include<iostream>//【1】______
using namespace std;
int getSum(int m);
int main() {
int m,s=0;
m=252;
s=getSum(m);//【2】______; 求m的各位数字之和并赋值给s
cout<<s;
return 0;
}
int getSum(int m) { //求m的各位数字之和
int s=0,n; //n记录各个位上的数字
while(m!=0) {
n=m%10;//【3】______; 求m各个位上的数字
s+=n;
m=m/10;
}
return s;//[4]
}
Test11:编写函数reverse，对给定的10个数置逆序排列。
#include<iostream>
using namespace std;
#define N 10 //[1]符号常量的定义
void reverse(int a[], int len) { //a是待操作的数组，len是数组中元素的数目
int i, t;
for(i=0;i<N/2; i++) {//[2]
t = a[i];
a[i]=a[N-1-i];//[3]
a[N-1-i]=t;
}
}
int main() {
int a[N], k;
for(k=0; k<N; k++)
cin>>a[k];//[4]
reverse(a,N);
for(k=0; k<N; k++)
cout<<a[k]<<endl;
return 0;
}
Test12：函数compare比较两个长度为N的数组是否相等（即两个数组中下标相同的数组元素均相等）。请完成该函数。
#include <iostream>
using namespace std;
void compare(int a[], int b[], int n) {
bool equal = true;//[1]
for(int index=0; index<n; index++) {
if(a[index] != b[index]) {
equal = false;//[2]
//[3]
}
}
if(equal==true)
cout << "Equal!" << endl;
else
cout << "Not equal!" << endl;
}
void input(int a[], int b[], int n) {
int index;
for(index=0; index<n; index++) {//[4]
cin >> a[index];
}
for(index=0; index<n; index++) {
cin >> b[index];
}
}
int main() {
int a[5], b[5];
input(a, b, 5);
compare(a, b, 5);
return 0;
}
Test13：编写一个函数void changeString(char str[]);功能是把其中的大写字母变成小写字母，小写字母变成大写字母，非字母的字符不作变换。变换结果依旧保存在str数组内。大写字母的ASCII码值比对应的小写字母 的ASCII码值小32，如A的ASCII码值比a的ASCII码值小32.
#include <iostream>
using namespace std;
void changeString(char str[]) {
for(int i=0; str[i]!='\0'; i++) {//[1]
if(str[i]>='a'&&str[i]<='z')
str[i]-= 32;//【2】______
else if(str[i]>='A'&&str[i]<='Z')
str[i] += 32;
}
}
int main() {
char str[50];//[3]
cout<<"输入要变换的字符串：";
cin>>str;
changeString(str);//[4]
cout<<"变换结果是："<<str<<endl;
return 0;
}
Test14：
#include <iostream>
#include <cstring>
using namespace std;
void conv(char s[]);//conv函数的声明
int main(){
char s[10];
int i;
cin>>s;
conv(s);
cout<<s<<endl;
return 0;
}
void conv(char *s) {
int len = strlen(s), j,c;
for (j=0;j<len/2; j++) {
char c = s[j];
s[j]= s[len-1-j];
s[len-1-j]=c;
}
}
Test15：利用冒泡法将10个数按降序排列。
#include<iostream>
using namespace std;
int main() {
int arr[10],i,j,k;
for(i=0;i<10;i++)//遍历数组元素进行赋值[1]
cin>>arr[i];
for(i=0; i<10; i++) {
for(j=0; j<10; j++) {//[2]
if(arr[j]<arr[j+1]) {//[3]
k=arr[j+1];
arr[j+1]=arr[j];
arr[j]=k;
}
}
}
for(i=0; i<10; i++)
cout<<arr[i] <<" ";//[4]
return 0;
}
Test16：声明人民币类IntRMB,私有数据成员包括：元（IYuan）、角（Jiao）、分（Fen），均为整形。类型转换函数将人民币类强制转化为浮点数，以“元”为单位。例如：“10元25角3分”转换成“12.53元”。（参考：类类型可以通过类型转换函数实现类型强制转换，它只能是类的成员函数，不能是友元函数。格式为：operator转换后的数据类型（）{…}使用时的格式为：转换后的数据类型（对象名）；或（转换后的数据类型）对象名；）
#include <iostream>
using namespace std;
class IntRMB { //人民币类
private: //访问属性
int IYuan;
int Jiao;
int Fen;
public:
IntRMB(int y=0,int j=0,int f=0); //构造函数的声明
void print();
operator float() { //float类型转换函数的定义
float temp;
temp=float(IYuan+(Jiao/10.0)+(Fen/100.0));
return temp;
}
};
IntRMB::IntRMB(int y,int j,int f) { //构造函数的实现
IYuan=y;
Jiao=j;
Fen=f;
}
void IntRMB::print() {
cout <<IYuan << "元" <<Jiao << "角" <<Fen <<"分" <<endl;
}
int main() {
float a;
IntRMB m(10,25,3); //定义人民币对象
cout << "***转换前***" <<endl;
m.print();
a=(float)m
..; //使用重载类型float进行强制类型转换
cout << "***转换后***" <<endl;
cout<<a<<"圆"<<endl;
return 0;
}
Test17：生命complex类表示负数类型，私有数据成员表示其实部，img表示其虚部。在类中以成员函数的形式定义运算符+的重载函数实现两个复数的加法，并返回结果。
#include <iostream>
using namespace std;
class Complex {
private:
float real;
float img;
public:
Complex(float r=0, float i=0):real(r),img(i) {}
//定义运算符+的成员重载函数，形参是Complex对象的常引用two
Complex operator+(Complex&two){//[1]
return Complex(real+two.real,img+two.img );//[2]
}
void display(){
cout<<"加法的结果为："<<real;//[3]
if(img>=0) cout << "+"; //如果虚部为负数，负数本身有一个"-"号
cout <<img<<"i"<<endl;
}
};
int main() {
Complex one(1.3,-5.2),two(3.7,2.1),result;
result=one+two; //计算复数one和two的加法[4]
result.display();
return 0;
}
Test18：有一个Time类，数据成员有时，分，秒。要求模拟秒表，每次走一秒，满60秒进位，秒又从零开始计数；满60分进位，分又从零开始计数；时使用24小时制，并以“时：分：秒”的格式输出时间。
#include <iostream>
using namespace std;
class Time {
public:
//在Time类的构造函数中使用成员初始化列表初始化数据成员
Time(int h=0, int m=0, int s=0): hour(h),minute(m),sec(s) {}//【1】
Time operator++() { //前置++运算符重载函数
sec++;
if(sec>=60) {//【2】
sec=sec-60;
minute++;
if(minute>=60) {
minute=minute-60;
hour++;
if(hour>24) hour=hour%24;//【3】
}
}
return *this;
}
Time operator++(int) {//【4】 //后置++运算符重载函数
Time temp(*this); //保存修改前的对象做返回值
++(*this);
return temp;
}
void Time::display() {
cout<<hour<<":"<<minute<<":"<<sec<<endl;
}
private:
int hour ;
int minute;
int sec;
};
int main()
{
Time time1(21,34,59), time2;
cout<<" time1 : ";
time1.display();
++time1;
cout<<"++time1: ";
time1.display();
time2 = time1++;
cout<<"time1++: ";
time1.display();
cout<<" time2 : ";
time2.display();
return 0;
}
Test19：利用函数模板设计一个求所有数组元素的和的函数。
#include <iostream>
using namespace std;
template<typename T>
T sum(T a[],int n){//求数组a所有元素的和
int i;
T s=0;
for(i=0;i<n;i++)
s = s + a[i];
return s;
}
int main() {
int a[5]={1,2,3,4,5}, s;
s=sum(a,5); //求数组a所有元素的和
cout<<s<<endl;
return 0;
}
Test20：用函数模板实现3个数值的升序排列。
#include <iostream>
using namespace std;
template <typename T>//[1]
void sort(T a, T b, T c) {
int array[3], temp;//[2]
array[0] = a;
array[1] = b;
array[2] = c;
int i,j;
for(i=0;i<3;i++) {
for(j=0;j<2;j++)
if(array[j]>array[j+1]) { //[3]如果条件为真，则交换两个数的位置
temp = array[j];
array[j] = array[j+1];
array[j+1]=temp;//【4】______
}
}
cout<< array[0]<< ' ' << array[1]<< ' ' << array[2]<< endl;
}
int main() {
sort(15,10,9);
return 0;
}
Test21：编写一个程序，该程序使用new运算符建立一个动态的double数组，然后为数组元素赋值，并显示元素值，最后使用delete运算符释放这个动态数组。
#include<iostream>//【1】______
using namespace std;
int main() {
int i, n, temp=0;
cout<<"输入数组大小:";
cin>>n; //输入需要的数组大小
double *array = new double[n];//【2】______; //动态申请数组
cout<<"给每个数组元素赋值："<< endl;
for(i=0; i<n; i++) {
cout<<"array["<< i <<"] = ";
cin>>array[i];//【3】______; //输入各个数组元素的值
}
cout<<"动态数组个元素的值如下："<< endl;
for(i=0; i<n; i++) {
cout<<"array["<< i <<"] = "<< array[i] << endl; //打印数组元素
}
delete[] array; //[4]释放动态数组
return 0;
}
Test22：设计一个圆类，从圆类派生圆柱，用成员函数输出它们的面积和体积。
#include <iostream>
using namespace std;
class Circular { //圆类
public:
Circular(double a) { //[1]圆类的构造函数
r = a;
area = 3.1415926 * r * r;
}
double getArea() { //计算圆面积
return area;
}
private: //[2]数据成员的访问属性
double r;
double area;
};
class Column: public Circular { //从圆类派生圆柱类
protected:
double h;
double cubage;
public:
Column(double a, double b) :Circular(a) { //[3]成员初始化
h = b; //派生类数据成员的赋值
cubage = getArea() * h;
}
double getCubage() { //计算圆柱体积
return cubage;
}
};
int main() {
Circular circular(45);
Column column(12, 10);
cout<<"圆的面积："<< circular.getArea() << endl; //[4]输出圆的面积
cout<<"圆柱的体积："<< column.getCubage() << endl;
return 0;
}
Test23:
#include<iostream>
using namespace std;
class Box{//类的声明
public:
int wight;
int length;
int high;
void box_shape(int w,int l,int h);
int box_volume(int w,int l,int h);
int box_area(int w,int l,int h);
};
void Box::box_shape(int w,int l,int h){//判断盒子的形状
if((w==l)&&(l==h))
cout<<“这是一个正方体！”<<endl;
else
cout<<“这是一个长方体！”<<endl;
}
int main(){
Box mybox;//对象定义
cout<<“请输入盒子的长、宽、高：”；
cin>>mybox.width>>mybox.length>>mybox.hight;
//调用成员函数box_shape判断形状
mybox.box_shape(mybox.width,mybox.length,mybox.hight;
return 0;
}
Test24设计一个圆类，从圆类派生圆柱，用成员函数输出它们的面积和体积
#include <iostream>
using namespace std;
class Box {
private:
int length;
int width;
int hight;
public: //访问属性 1】______ //访问属性
Box(int l,int w,int h) { //构造函数2】______
length = l;
width = w;
hight = h;
}
int volume() {
return hight * width * length;
}
};
int main() {
Box box1(30, 20, 10); //定义对象box1 【3】______ box1(30, 20, 10);
cout << "Box1's volume = " << box1.volume() << endl; //输出box1的体积cout << "Box1's volume = " << 【4】______ << endl;
return 0;
}
Test25：声明一个模板，利用他们分别实现两个整数和浮点数的比较，输出最大数。
#include <iostream>
using namespace std;
template <class numtype> //[1]类模板声明
class Compare {
public:
Compare(numtype a,numtype b) { //[2]构造函数定义
x=a;
y=b;
}
numtype max() {//[3]
return (x>y)?x:y;}
numtype min(){
return (x<y)?x:y;}
private:
numtype x,y;
};
int main() {
Compare<int> cmp1(3,4); //定义对象cmp1实现两个整数的比较
cout<<cmp1.max()<<" is the Maximum of two inteder numbers."<<endl;
cout<<cmp1.min()<<" is the Minimum of two inteder numbers."<<endl<<endl;
Compare<float> cmp2(45.78,93.6); //[4]定义对象cmp2实现两个单精度浮点数的比较
cout<<cmp2.max()<<" is the Maximum of two float numbers."<<endl;
cout<<cmp2.min()<<" is the Minimum of two float numbers."<<endl<<endl;
return 0;
}
Test26：建立一个对象数组，内放5个学生的数据（学号，成绩），用指针指向数组的首地址，使用该指针输出第1，3，5个学生的数据。其中，对象数组名必须是stud。
#include<iostream>
using namespace std;
class Student {
public:
Student(int n,int s):num(n) ,score(s){ } //[1]构造函数使用成员初始化列表进行初始化
void display() {
cout<<num<<" "<<score<<endl;
}
private:
int num;
int score;
};
int main() {
Student stud[5] = {Student(1,70) ,Student(2,71), Student(3,72),//[2]
Student(4,73), Student(5,74)};
Student *p=stud;
for(int i=0; i<=2; i++) { //输出第1，3，5个学生的数据
p->display(); //[3]调用成员函数display
p=p+2; //[4]更新指针变量p
}
return 0;
}
Test27：建立一个对象数组，内放5个学生的数据（学号，成绩），设立一个函数max，用指向对象的指针作函数参数，在max函数中找出5个学生中成绩最高者，并输出其学号。
#include<iostream>
using namespace std;
class Student {
public:
Student(int n,int s):num(n),score(s) {}
int num;
int score;
};
int max(Student*arr) { //【1】max函数的参数是一个Student类的指针变量arr
float max_score=arr[0].score; //用max_ score记录最高的成绩
int i, max_num=0; //用max_num记录成绩最高的学生的学号
for(i=0; i<3; i++)
{ if(arr[i].score>max_score) { //[2]比较大小，并把大值保存在变量max_score中
max_score=arr[i].score;
max_num=i+1; } //[3]更新max_num
}
cout<<max_score<<" "<<max_num<<endl;
return 0;
}
int main() {
Student stud[3] = {Student(1,70),Student(2,71),Student(3,72)};
Student *p =&stud[0]; //[4]初始化指向对象数组首地址的指针变量
max(p);
return 0;
}
Test28：定义一个复数类Complex，重载运算符“+”，使之能用于复数的加法运算。参加运算的两个运算量可以都是类对象，也可以其中有一个是整数，顺序任意。例如：c1+c2,i+c1,c1+i均合法（设i为整数，c1、c2为复数）。编程序，分别求两个复数之和、整数和复数之和。
#include <iostream>
using namespace std;
class Complex {
private:
double real;
double imag;
public:
Complex() {
real=0;
imag=0;
}
Complex(double r,double i) {
real=r;
imag=i;
}
Complex operator+(Complex &c) { //[1]两个复数的加法，参数使用引用形式
return Complex(real+c.real, imag+c.imag );
}
Complex operator+(int &i) { //复数+整数，参数使用引用
return Complex(i+real,imag);//[2]
}
friend Complex operator+(int &i,Complex &c); //[3]友元函数声明
void display() {
cout<<"("<<real<<","<<imag<<"i)"<<endl;
}
};
Complex operator+(int &i,Complex &c) { //整数+复数
return Complex(i+c.real,c.imag);
}
int main() {
Complex c1(3,4),c2(5,-10),c3; //[4]对象的定义
int i=5;
c3=c1+c2;
cout<<"c1+c2=";
c3.display();
c3=i+c1;
cout<<"i+c1=";
c3.display();
c3=c1+i;
cout<<"c1+i=";
c3.display();
return 0;
}
Test29：有两个矩阵a和b，均为2行3列。求两个矩阵之和。重载运算符“+”，使之能用于矩阵相加。如a+b。
#include <iostream>
using namespace std;
class Matrix { //定义Matrix类
public:
Matrix(); //默认构造函数
friend Matrix operator+(Matrix &,Matrix &); //【1】运算符"+"的友元重载函数
void input(); //输入函数
void display(); //输出函数
private:
int mat[2][3];
};
Matrix::Matrix() { //定义构造函数
for(int i=0; i<2; i++)
for(int j=0; j<3; j++)
mat[i][j]=0;
}
Matrix operator+(Matrix &a,Matrix &b) { //定义重载运算符"+"函数
Matrix c;
for(int i=0; i<2; i++)
for(int j=0; j<3; j++) {
c.mat[i][j]=a.mat[i][j]+b.mat[i][j];
}
return c;//【2】______;
}
void Matrix::input() { //[3]定义输入函数
cout<<"input value of matrix:"<<endl;
for(int i=0; i<2; i++)
for(int j=0; j<3; j++)
cin>>mat[i][j];
}
void Matrix::display() { //定义输出函数
for (int i=0; i<2; i++) {
for(int j=0; j<3; j++) {
cout<<mat[i][j]<<" ";
}
cout<<endl;
}
}
int main() {
Matrix a,b,c;
a.input();
b.input();
cout<<endl<<"Matrix a:"<<endl;
a.display();
cout<<endl<<"Matrix b:"<<endl;
b.display();
c=a+b;//【4】______; //用重载运算符"+"实现两个矩阵相加
cout<<endl<<"Matrix c = Matrix a + Matrix b :"<<endl;
c.display();
return 0;
}
Test30：声明一个字符串类，用来存放不定长的字符串。重载运算符“==”，用于两个字符串的等于关系的比较运算。
#include <iostream>
#include <cstring>
using namespace std;
class MyString {
public:
MyString() {p=NULL;}
MyString(char *str) {p=str;} //数据成员赋值
friend bool operator==(MyString &string1,MyString &string2); //友元函数声明
void display() {cout<<p;} //输出P所指向的字符串
private:
char *p;
};
bool operator==(MyString &string1,MyString &string2) {
if(strcmp(string1.p,string2.p)!=0) return true; //比较两个字符串
else return false;
}
void compare(MyString &string1,MyString &string2) {
if(operator==(string1,string2)==0) { //调用运算符重载函数比较两个字符串
string1.display();
cout<<"=";
string2.display();
} else {
string1.display();
cout<<"!=";
string2.display();
}
cout<<endl;
}
int main() {
MyString string1("Hello"),string2("Book"),string3("Hello");
compare(string1,string2);
compare(string1,string3);
return 0;
}
Test31：先建立一个Point（点）类，包含数据成员下，有（坐标点）。以它为基类，派生出一个Circle（圆类，增加数据成员r（半径），再以Circle类为直接基类，派生出一个Cylinder（圆柱体）类，在增加数据成员h（高）。编写程序，重载运算符“<<”和“>>”,使之能够用于输出以上类的对象。
#include <iostream>
using namespace std;
class Point {
protected:
int x,y;
public:
Point() {x=0; y=0;}
Point(int a, int b) {x=a; y=b;}
void setX(int a) {x=a;}
void setY(int b) {y=b;}
int getX() {return x;}
int getY() {return y;}
};
class Circle: public Point {
protected:
int r;
public:
Circle(int x,int y,int r):Point(x,y) {this->r=r;}
void setR(int a) {r=a;}
int getR() {return r;}
};
class Cylinder: public Circle {
protected:
int h;
public:
Cylinder():Circle(0,0,0),h(0) {}
Cylinder(int x,int y,int r,int h):Circle(x,y,r) {this->h = h;}
void setH(int a) {h=a;}
int getH() {return h;}
friend istream & operator>>(istream &, Cylinder &);
friend ostream & operator<<(ostream &, Cylinder &);
};
istream & operator>>(istream &input, Cylinder &cc) {
int _x, _y, _r, _h;
cout<<"Enter the Cylinder: "<<endl;
cin >>_x >>_y >>_r >>_h;
cc.setX(_x);
cc.setY(_y);
cc.setR(_r);
cc.setH(_h);
return input;
}
ostream & operator<<(ostream & output, Cylinder & cc) {
output<<cc.getX()<<' '<<cc.getY()<<' '<<cc.getR()<<' '<<cc.getH()<<endl;
return output;
}
int main() {
Cylinder cc;
cin>>cc;
cout<<cc;
return 0;
}
Test32：写一个程序，定义抽象类Shape，由他派生的三个类：Circle（圆形），Rectangle（矩形），Trapezoid（梯形），用一个函数print Area分别输出三者的面积，3个图形的数据在定义对象是给定的。
// P188
#include <iostream>
using namespace std;
class Shape { //形状类
public:
virtual double area() const=0; //纯虚函数area()的声明
};
class Circle: public Shape { //圆形类
private:
double r;
public:
Circle(double a):r(a) {} //构造函数的定义
virtual double area() const {
return 3.14 * r * r;
}
};
class Rectangle: public Shape {
private:
double h, w;
public:
Rectangle(double a, double b):h(a),w(b) {} //构造函数的成员初始化列表
virtual double area() const {
return h * w;
}
};
class Trapezoid: public Shape { //梯形类
private:
double h, w;
public:
Trapezoid(double a, double b):h(a),w(b) {}
virtual double area() const {
return 0.5 * h * w;
}
};
void printArea(const Shape &c) {
cout <<c.area()<< endl; //输出对象c的面积
}
int main() {
Circle c(2);
printArea(c);
Rectangle r(2,4);
printArea(r);
Trapezoid t(3,5);
printArea(t);
return 0;
}
Test33：定义一个学生类Student做基类，再派生一个Graduate类，学生类有学号，姓名，和分数，研究生增加工资，他们有同名的函数display（），利用虚函数，变成分别输出学生和研究生的数据，具体数据自拟。
#include <iostream>
#include <string>
using namespace std;
class Student {
protected://【1】______ //声明数据成员的访问属性
int id;
string name;
int score;
public:
Student(int,string,int);
virtual void display();
};
Student::Student(int i, string n, int cr) {
id = i;
name = n;
score = cr;
}
void Student::display() {
cout << id << ": " << name << endl;
cout << score << endl;
}
class Graduate:public Student { //[2]Graduate类公有继承Student类
protected:
int salary;
public:
Graduate(int i,string n,int cr,int sa)//【3】______ //构造函数的定义
:Student(i, n, cr),salary(sa) {}
void display();
};
void Graduate::display() { //[4]Graduate类成员函数display()函数的定义
cout << id << ": " << name << endl;
cout << score << endl;
cout << salary << endl;
}
int main() {
Student stu(1, "John", 99);
stu.display();
Graduate gra(2, "JOHNLIU", 100, 5000);
gra.display();
return 0;
}
Test34商店销售某一商品，商店每天公布统一的折扣（discount）。同时允许销售人员在销售时活掌握售价(price)，在此基础上，对一次购买10件以上者，还可以享受9.8折扣优惠。现在已知当天3名销售员的销售情况为：
售货员工号（num） 售出商品数目（quantity） 商品单价（price）
101 5 23.5
102 12 24.56
103 100 21.5
请编写程序，计算当日此商品的总销售额sum，以及每件商品的平均售价。要求用静态数据成员和静态成员函数。（提示：将折扣discount、总销售额sum和商品总销售数目n声明为静态数据成员，再定义静态成员函数average（求平均售价）和display（输出结果）。
//P145
#include <iostream>
using namespace std;
class Product {
public:
Product(int n,int q,float p):num(n),quantity(q),price(p) {};
void total(); //计算总销售额和总销售数目
static float average(); //静态average()函数的声明，求平均售价
static void display(); //输出总销售额和平均售价
private:
int num; //售货员工号
int quantity; //售出商品数目
float price; //商品单价
static float discount; //统一的折扣
static float sum; //总销售额
static int n; //总销售数目
};
void Product::total() {
float rate=1.0;
if(quantity>10) rate=0.98*rate;
sum=sum+quantity*price*rate*(1-discount);
n=n+quantity;
}
void Product::display(){ //静态display()函数的定义
cout<<sum<<endl;
cout<<average()<<endl;
}
float Product::average() {
return(sum/n);
}
float Product::discount =0.05; //静态成员数据discount的初始化
float Product::sum=0;
int Product::n=0;
int main() {
Product Prod[3]=
{Product(101,5,23.5),Product(102,12,24.56),Product(103,100,21.5)};
for(int i=0; i<3; i++)
Prod[i].total();
Product::display(); //调用静态成员函数display()输出总销售额和平均售价
return 0;
}
Test35 请编写程序，处理一个复数与一个double数相加的运算，结果存放在一个double型的变量d1中，输出d1的值，再以复数的形式输出此值。定义Complex（复数）类，在成员函数中包含重载类型转换运算符：operator double（）{return real；}。
#include <iostream>
using namespace std;
class Complex {
public:
Complex() {
real=0;
imag=0;
}
Complex(double r){ //类型转换构造函数，将double类型转换为Complex类型
real=r;
imag=0;
}
Complex(double r,double i) {
real=r;
imag=i;
}
operator double(){ //类型转换成员函数，将Complex类型转换为double类型
return real;
}
void display();
private:
double real;
double imag;
};
void Complex::display() {
cout<<"("<<real<<", "<<imag<<")"<<endl;
}
int main() {
Complex c1(3,4),c2;
double d1;
d1=c1+2.5 ;// double型常量2.5与复数c1相加，运算结果存放在d1中
cout<<"d1="<<d1<<endl;
c2=d1; //将double型变量d1转换为复数类型
cout<<"c2=";
c2.display();
return 0;
}
Test36 有一个Time类，包含数据成员mintue(分)和sec（秒），模拟秒表，每次走疫苗，满60秒进一分钟，此时秒又从0开始算。要求输出分和秒的值，且对后置自增运算符的重载。
#include <iostream>
using namespace std;
class Time {
public:
Time() {
minute=0;
sec=0;
}
Time(int m,int s):minute(m),sec(s) {}
Time operator++() { //前置++的重载成员函数
if(++sec>=60) {
sec-=60;
++minute;
}
return *this;//return 【1】______;
}
Time operator++(int) { //后置++的重载成员函数Time【2】______
Time temp(*this);
sec++;
if(sec++>=60 ) {// if(【3】______ )
sec-=60;
++minute;
}
return temp;//return 【4】______;
}
void display() {
cout<<minute<<":"<<sec<<endl;
}
private:
int minute;
int sec;
};
int main() {
Time time1(34,0), time2(35,0);
for (int i=0; i<61; i++) {
++time1;
time1.display();
}
for (int j=0; j<61; j++) {
time2++;
time2.display();
}
return 0;
}
Test37定义一个国家基类Country，包含国名、首都、人口等属性，派生出省类Province，增加省会城市、人口数量属性。
#include<iostream>
#include<string>
using namespace std;
/*【1】*/class Country {
public:
/*【2】*/Country(string nam,string c,int cp=0) { //初始化构造函数的定义
name=nam;
capital=c;
country_population=cp;
}
protected:
string name;
string capital;
long int country_population;
};
class Province:public Country {
public:
//派生类构造函数的定义
Province(string nam,string c,long int cp,string pc,long int pp):/*【3】*/Country(nam,c,cp){
Province_capital=pc;
Province_population=pp;
};
void show() {
cout<<"name:"<<name<<endl;
cout<<"capital:"<<capital<<endl;
cout<<"country_population:"<<country_population<<endl;
cout<<"Province_capital:"<<Province_capital<<endl;
cout<<"Province_population:"<<Province_population<<endl;
}
private:
string Province_capital;
long int Province_population;
};
int main() {
//对象定义
/*【4】*Province prov1("China","Beijing",1300000000,"Nanchang",45000000);
prov1.show();
return 0;
}
Test38定义一个车基类Vehicle，含私有成员speed，weight。派生出自行车类Bicycle，增加high成员；汽车类Car，增加seatnum（座位数）成员。从bicycle和car中派生出摩托车类Motocycle。
#include<iostream>
using namespace std;
class Vehicle {
public:
Vehicle(float sp,float w) { //构造函数的定义
speed=sp;
weight=w;
}
void display() {
cout<<"speed:"<<speed<<" weight"<<weight<<endl;
}
private:
float speed;
float weight;
};
class Bicycle: virtual public Vehicle { //声明Vehicle为虚基类
public:
Bicycle(float sp,float w,float h):Vehicle(sp,w) { //构造函数的定义
high = h;
}
protected:
float high;
};
class Car:virtual public Vehicle {
public:
Car(float sp,float w,int num):Vehicle(sp,w) { //构造函数的定义
seatnum = num;
}
protected:
int seatnum;
};
class Motorcycle: public Bicycle, public Car {
public:
Motorcycle(float sp,float w,float h,int num):
Vehicle(sp,w),Bicycle(sp,w,h),Car(sp,w,num) {} //成员初始化
void display() {
Vehicle::display();
cout<<" high:"<<high<<" seatnum:"<<seatnum<<endl;
}
};
int main() {
Motorcycle m(120,120,120,1); //对象定义
m.display();
return 0;
}
Test39声明一个哺乳动物Mammal类，再由此派生出狗Dog类，二者都定义Speak（）成员函数，基类中定义为虚函数。声明一个Dog类的对象，调用Speak（）函数，观察运行结果
#include <iostream>
class Mammal {
public:
Mammal():itsAge(1) {
cout << "Mammal constructor"<<endl;
}
~Mammal() { //析构函数的定义
cout << "Mammal destructor"<<endl;
}
virtual void Speak() const { //虚函数Speak()的定义
cout << "Mammal speak!"<<endl;
}
private:
int itsAge;
};
class Dog : public Mammal {
public:
Dog() {
cout << "Dog Constructor" <<endl;
}
~Dog() {
cout << "Dog destructor" <<endl;
}
void Speak() const {
cout << "Woof!"<<endl;
}
};
int main() {
Mammal *pDog = new Dog;
pDog->Speak(); //使用pDog调用Speak()函数
delete pDog; //释放对象
return 0;
}
Test40定义一个抽象类Cshape，包含纯虚数Area（用来计算面积）。然后派生出三角形Ctriangle类、矩形Crect类、圆Ccircle类，分别求其面积。最后定义一个CArea类，计算着几个形状的面积之和，各形状的数据通过CArea类构造函数或成员函数来设置。
#include<iostream>
using namespace std;
class Cshape {
public:
virtual float Area() const=0; //纯虚函数Area()的声明 【1】______ float Area()【2】______;
};
class CTriangle: public Cshape {
int vect;
public:
CTriangle(int v):vect(v) {}
float Area() {
return vect*1.732/4;
}
};
class CRect: public Cshape {
int length,height;
public:
CRect(int l,int h):length(l),height(h) {}
float Area() {
return length*height;
}
};
class CCircle: public Cshape {
int radius;
public:
CCircle(int r):radius(r) {}
float Area() {
return 3.14*radius*radius;
}
};
class Area {
CTriangle t;
CRect r;
CCircle c;
public:
Area(int v,int l,int h,int r):t(v),r(l,h),c(r) {} //子对象初始化列表 不会
float sum() {
return t.Area()+r.Area()+c.Area();
}
};
int main() {
Area a(10,20,30,5); //对象定义 4】______ a(10,20,30,5);
cout<<a.sum()<<endl;
return 0;
}