沈阳师范大学大一下册C++语言PTA题目集以及答案（编程题篇）

沈阳师范大学大一下册C++语言PTA题目集以及答案

（编程题篇）

7-1 测试c++ (20分)
倒序输出从控制台输入的n个整数

输入格式:
第一行输入一个数n，代表行数
依次输入n个整数

输出格式:
将n个整数倒序输出

输入样例:
3
1 2 3
输出样例:
321

#include<iostream>
int main()
{
    int n,i;
    std::cin>>i;
    int a[i];
    for(n=0;n<i;n++)
        std::cin>>a[n];
    for(i--;i>=0;i--)
        std::cout<<a[i];
}

7-2 计算圆的面积 (20分)
从键盘输入圆的半径，计算圆的面积并输出。圆周率PI=3.1415926。

输入格式:
在这里写输入圆的半径，例如： 3.6

输出格式:
在这里输出圆的面积，例如： 40.715

输入样例:
1.5

输出样例:
7.06858

#include<iostream>
int main()
{
   double PI=3.1415926,r,sum;
   std::cin>>r;
   sum=PI*r*r;
   std::cout<<sum<<std::endl;
}

7-3 计算三角形面积 (20分)
从键盘输入三个数，用来表示三角形的三条边长。如果能构成三角形就输出三角形的面积，否则就输出No。

输入格式:
请在这里写输入三角形的三条边长，例如： 3.1 4.2 5.3

输出格式:
请在这里输出三角形的面积，例如：

6.50661

输入样例:
3.0 4.0 5.0
输出样例:
6

#include<iostream>
#include<cmath>
bool panduan(double a,double b,double c)
{
    bool d;
    if(a >0 || b >0 || c>0)
    if((a+b)>c&&(a+c>b)&&(b+c)>a)
    {
        d=true;
        return d;
    }
    d=false;
    return d;

}
int main()
{
   double a,b,c;
   std::cin>>a>>b>>c;
   if(panduan(a,b,c))
   {
       double d,e,f;
       d=(a+b+c)/2.0;
       f=d*(d-a)*(d-b)*(d-c);
       e=sqrt(f);
       std::cout<<e<<std::endl;
   } else
   {
       std::cout<<"No"<<std::endl;
   }
}

7-4 问候 (20分)
输出问候：Hello!What’s your name? 从键盘输入名字，然后输出欢迎信息。

输入格式:
请在这里写输入姓名。例如： GaiFuShuai

输出格式:
请在这里描述输出，例如：

Hello!What’s your name?

GaiFuShuai,Welcome to learn OOP using C++!

输入样例:
BaiFuMei
输出样例:
Hello!What’s your name?
BaiFuMei,Welcome to learn OOP using C++!

#include<iostream>
#include<cmath>
int main()
{
   std::cout<<"Hello!What's your name?"<<std::endl;
   std::string a;
   std::cin>>a;
   std::cout<<a<<",Welcome to learn OOP using C++!"<<std::endl;
}

7-1 删除字符串中指定字母 (20分)
请使用指针的方法编写程序，程序的功能是从键盘输入一个字符串(字符串长度小于100)，删除其中的字母a后输出。例如，输入字符串abcaca，输出bcc。

输入样例:
abcaca
输出样例:
bcc

#include <iostream>
#include <string>
using namespace std;
void put(string &a)
{
    char *b=&a[0];
    int i;
    for(i=0;*(b+i);i++)
    {
        if(*(b+i)!='a')
            cout<<*(b+i);
    }
}


int main(int argc, char const *argv[])
{
  string a;
  cin>>a;
  put(a);
}

7-2 用指针方法求10个数最大和最小值之差 (20分)
请使用指针的方法编写程序，程序的功能是从键盘输入10个数，求其最大值和最小值的差。

输入格式:
输入10个整数，每个整数之间用空格分隔。

输出格式:
同样例。

输入样例:
1 2 3 4 5 6 7 8 9 10
输出样例:
difference value = 9

#include <iostream>
#include <string>
using namespace std;
void put(int *b)
{
    int i,j,k;
    for(i=0,j=*(b+1),k=*(b+1);i<10;i++)
    {
       if(j>*(b+i))
           j=*(b+i);
       if(k<*(b+i))
           k=*(b+i);
    }
    cout<<"difference value = "<<k-j;
}


int main(int argc, char const *argv[])
{
  int a[10],i;
  for(i=0;i<10;i++)
  cin>>a[i];
  put(a);
}

7-3 鸿鸿哥分钱 (20分)
鸿鸿哥最近和一个小伙伴做了个小项目，赚了一个亿，两人一起高高兴兴开了庆功宴之后，鸿鸿哥就准备分一下钱了。鸿鸿哥想了想，生意不是做一天的，所以一个亿之中的大部分资金还是要继续投资，不能只是做一发就走，这个想法也得到了小伙伴的认可。而余下来的钱不知道具体数值，只知道是x万~y万之间（因为某种神秘力量余下的钱一定是偶数万）。而鸿鸿哥原本也是土豪，这点小钱也看不上眼，于是他想分多一点给小伙伴，他决定把钱分成两个素数（程序员喜欢各种特别的数字），自己拿小的那份。那么问题来了，鸿鸿哥和小伙伴个各拿多少万呢？鸿鸿哥想知道所有可能的分法。

输入格式:
输入两个整数x，y（6<=x，x<=y，n<=100），一组输入。

输出格式:
输出x和y之间所有偶数表示成的两个素数之和。

输入样例:
在这里给出一组输入。例如：

8 10
输出样例:
在这里给出相应的输出。例如：

8=3+5
10=3+7

#include <iostream>
#include <string>
#include <cmath>
using namespace std;
void out(int a)
{
    int b,c,d;
    for(b=3;b<=a/2;b+=2)
    {
        for(c=2;c<=sqrtl(b);c++)
            if(b%c==0)
                break;
            if(c>sqrtl(b))
                d=a-b;
            else
                break;
            for(c=2;c<=sqrtl(d);c++)
                if(d%c==0)
                    break;
                if(c>sqrtl(d))
                {cout<<b<<"+"<<d<<endl;
                break;}
    }

}
void put(int x,int y)
{
    for(;x<=y;x++)
    {
        if(x%2==0)
        {
            cout<<x<<'=';
            out(x);
        }
    }
}


int main(int argc, char const *argv[])
{
  int x,y;
  cin>>x>>y;
  put(x,y);
}

7-4 实数排序 (20分)
本题要求编写程序，输入n个实数，使用指针引用的方式将它们按从大到小的顺序排列。

输入格式:
输入第一行给出一个正整数n（2≤n≤10）,输入第二行给出n个实数，其间以空格分隔。

输出格式:
输出从大到小排好序的n个数（保留2位小数），每个数之间空一格，行末没有空格。

输入样例:
在这里给出一组输入。例如：

5
3.2 5.4 6.12 2.51 4.23
输出样例:
在这里给出相应的输出。例如：

6.12 5.40 4.23 3.20 2.51

#include <iostream>
#include <string>
#include <cmath>
using namespace std;
void put(float *a,int n)
{
    int i,j;
    float t;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            if(*(a+i)>*(a+j))
            {
               t=*(a+i);
               *(a+i)=*(a+j);
               *(a+j)=t;
            }
        }
    }
}
void out(float *a,int n)
{
    int i=1;
    printf("%.2f",*(a+i-1));
    for(;i<n;i++)
    {
        printf(" %.2f",*(a+i));
    }
}

int main(int argc, char const *argv[])
{
  int n,i;
  cin>>n;
  float a[n];
  for(i=0;i<n;i++)
      cin>>a[i];
  put(a,n);
  out(a,n);
}

7-1 设计一个矩形类Rectangle并创建测试程序（C++） (20分)
设计一个名为Rectangle的矩形类，这个类包括：两个名为width和height的double数据域，它们分别表示矩形的宽和高。width和height的默认值都为1.该类包括矩形类的无参构造函数（默认构造函数）；一个width和height为指定值的矩形构造函数；一个名为getArea( )的函数返回矩形的面积；一个名为getPerimeter( )的函数返回矩形的周长。请实现这个类。编写一个测试程序，创建一个Rectangle对象，从键盘输入矩形的宽和高，然后输出矩形的面积和周长。

输入格式:
3.5 35.9（第一个数表示矩形的宽，第二个数表示矩形的高，中间是空间分隔。）

输出格式:
125.65 （第一行输出矩形的面积） 78.8 （第二行输出矩形的周长）

输入样例:
3.5 35.9
输出样例:
125.65
78.8

#include <iostream>
using namespace std;
class Rectangle
{
    private:
    double width=1;
    double height=1;
    public:
    Rectangle();
    Rectangle(double a,double b)
    {
        width=a;
        height=b;
    }
    double getArea()
    {
        return width*height;
    }
    double getPerimeter()
    {
        return 2*width+2*height;
    }

}  ;
int main(int argc, char *argv[])
{
 double c,d;
 cin>>c>>d;
 Rectangle a(c,d);
 cout<<a.getArea()<<endl;
 cout<<a.getPerimeter()<<endl;
}

7-3 例4-3游泳池改造预算 (20分)
例4-3一圆形游泳池如图所示，现在需在其周围建一圆形过道，并在其四周围上栅栏。栅栏价格为35元/米，过道造价为20元/平方米。过道宽度为3米，游泳池半径由键盘输入。要求编程计算并输出过道和栅栏的造价。

输入格式:
输入一个整数或小数。

输出格式:
分两行输出：在第一行中输出栅栏的造价。在第二行输出过道的造价。

输入样例:
10
输出样例:
Fencing Cost is $2858.85
Concrete Cost is $4335.4

#include <iostream>
using namespace std;
class pool
{
    private:
    double r;
    double pi=3.1415926;
    public:
    pool(double a)
    {
        r=a;
    }
    double zhalan()
    {
        return pi*2*(r+3)*35;
    }
    double guodao()
    {
        return (pi*(r+3)*(r+3)-pi*r*r)*20;
    }
}  ;
int main(int argc, char *argv[])
{
    double b;
    cin>>b;
  pool a(b);
  cout<<"Fencing Cost is $"<<a.zhalan()<<endl;
  cout<<"Concrete Cost is $"<<a.guodao()<<endl;
}

7-4 立方体类 (20分)
定义立方体类Box，数据成员有长宽高且都是整数，构造函数初始化数据成员，成员函数计算体积，主函数中输入长宽高，输出立方体体积。

输入格式:
输入立方体的长宽高，中间用空格分隔。

输出格式:
输出体积并换行。

输入样例:
在这里给出一组输入。例如：

1 2 3
输出样例:
在这里给出相应的输出。例如：

6

#include <iostream>
using namespace std;
class Box
{
    private:
    int a,b,c;
    public:
    Box(int d,int e,int f)
    {
        a=d;
        b=e;
        c=f;
    }
    int tiji()
    {
        return a*b*c;
    }


}  ;
int main(int argc, char *argv[])
{
    int a,b,c;
    cin>>a>>b>>c;
 Box d(a,b,c);
 cout<<d.tiji()<<endl;
}

7-2 队列操作 (30分)
请实现一个MyQueue类，实现出队，入队，求队列长度.

实现入队函数 void push(int x); 实现出队函数 int pop(); 实现求队列长度函数 int size();

输入格式:
每个输入包含1个测试用例。每个测试用例第一行给出一个正整数 n (n <= 10^6) ，接下去n行每行一个数字，表示一种操作： 1 x ： 表示从队尾插入x，0<=x<=2^31-1。 2 ： 表示队首元素出队。 3 ： 表示求队列长度。

输出格式:
对于操作2,若队列为空，则输出 “Invalid”,否则请输出队首元素。 对于操作3，请输出队列长度。 每个输出项最后换行。

输入样例:
5
3
2
1 100
3
2
输出样例:
0
Invalid
1
100

#include<bits/stdc++.h>
using namespace std;
vector<int> obj;
int duilie=0,ren=0;
class MyQueue
{
    private:
    public:
    void push(int x)
    {
        obj.push_back(x);
        duilie++;
    }
    int pop(){
        if(duilie==0)
            cout<<"Invalid"<<endl;
        if(duilie!=0)
        {
        cout<<obj[0]<<endl;
        vector<int>::iterator s = obj.begin();
        obj.erase(s);
        duilie--;}
    }
    int size()
    {
        int i;
        for(i=0;i<obj.size();i++)
        {
            ;
        }
        cout<<i<<endl;
    }

};

int main(int argc, char *argv[])
{
    unsigned long long int i,j,k;
    cin>>i;
    MyQueue a;

    for(j=0;j<i;j++)
    {
        cin>>k;
        switch(k)
        {
            case 1:
                int x;
                cin>>x;
                a.push(x);
                break;
            case 2:
                a.pop();
                break;
            case 3:
                a.size();
        }

    }
}

7-2 计算全班学生C++课程的总成绩和平均成绩 (20分)
定义一个类Student，记录学生C++课程的成绩。要求使用静态数据成员或静态成员函数计算全班学生C++课程的总成绩和平均成绩。

输入格式:
输入5个不超过100的正整数，作为C++成绩。

输出格式:
在第一行中输出成绩的和，第二行输出平均成绩。

输入样例:
90 80 70 60 50
输出样例:
350
70

#include<iostream>
using namespace std;
class Student
{
private:
    static double num;
    static double sum;
public:
    void add1(double a)
    {
        sum+=a;
        num++;
    }
    double fan1()
    {
        return sum;
    }
    double fan2()
    {
        return sum/(num*1.0);
    }

}  ;
double Student::num=0;
double Student::sum=0;
int main(int argc, char *argv[])
{
    Student a;
    for(int i=0;i<5;i++)
    {
        double j;
        cin>>j;
        while(j<0)
        {
cin>>j;
        }
        a.add1(j);
        
    }
    int b,c;
    cout<<"The total score is "<<a.fan1()<<endl;
    cout<<"The average score is "<<a.fan2()<<endl;

}

7-4 立方体类的实现 (20分)
立方体类Box的实现，完成计算体积、计算表面积、输出结果等功能。其中给定的主函数为：

int main( ){
float ab;
cin>>ab;
Box obj;
obj.seta( ab );
obj.getvolume( );
obj.getarea( );
obj.disp( );
return 0;
}
输入格式:
立方体的边长，可以是float类型的数据。

输出格式:
立方体的体积和表面积，中间用一个空格隔开，末尾换行。

输入样例:
3
输出样例:
27 54

#include<iostream>
using namespace std;
class Box
{
    private:
    int a,b,c;
    public:
    void seta(int c)
    {
        Box::a=c;
    }
    void getvolume()
    {
        Box::b=Box::a*Box::a*Box::a;
    }
    void getarea()
    {
        Box::c=Box::a*Box::a*6;
    }
    void disp()
    {
        cout<<b<<" "<<c<<endl;
    }

}  ;
int  main( ){
    float ab;
    cin>>ab;
    Box  obj;
    obj.seta( ab );
    obj.getvolume( );
    obj.getarea( );
    obj.disp( );
    return 0;
}

7-6 （组合类）一定平面二维点类Point，线段类Line是由两个Point点组成的组合类 (30分)
定义平面二维点类Point,(有x,y坐标，构造函数、复制构造函数，输出函数)。线段类Line是由两个Point点组成的组合类（数据成员： 两个端点，线段长度； 函数成员：构造函数、复制构造函数、计算线段长度函数） //主函数 int main() {
int x1,y1,x2,y2; cin>>x1>>y1;
cin>>x2>>y2; Point myp1(x1,y1),myp2(x2,y2); //建立Point类的对象 Line L1(myp1,myp2); //建立Line类的对象 cout<<“Line start Point is:”; L1.GetPstart().print(); cout<<endl; cout<<“Line end Point is:”; L1.GetPend().print(); cout<<endl; cout<<“Length of Line is:”<<L1.GetLen()<<endl;

}

输入格式:
输入两行，第一行为线段的起点坐标（中间已空格隔开），第二行为线段的终点坐标 （中间已空格隔开）

输出格式:
输入各个函数被调用过程主程序，需要填写。

输入样例:
在这里给出一组输入。例如：

0 0
3 4
输出样例:
在这里给出相应的输出。例如：

create Point:P(0,0)
create Point:P(3,4)
Create a new Line:
Line start Point is:P(0,0)
Line end Point is:P(3,4)
Length of Line is:5

#include<iostream>
#include<cmath>
using namespace std;



class Point
{
private:
    int x,y;
public:
    int getx()
    {
        return x;
    }
    int gety()
    {
        return y;
    }
    void print()
    {
        cout<<"P("<<Point::x<<","<<Point::y<<")"<<endl;
    }
    Point(int a,int b)
    {
        Point::x=a;
        Point::y=b;
        cout<<"create Point:";
        Point::print();
    }
    Point(const Point& a)
    {
        x=a.x;
        y=a.y;
    }

};
class Line {
private:
    Point a,b;
    double c;
public:
    Line(Point c,Point d):a(c),b(d)
    {
        cout<<"Create a new Line:"<<endl;
    }
    void GetPstart()
    {
        a.print();
    }

    void GetPend() {
        b.print();

    }
    int GetLen()
    {
        auto x=static_cast<double>(a.getx()-b.getx());
        auto y=static_cast<double>(a.gety()-b.gety());
        c=sqrt(x*x+y*y);
        return c;
    }
};

int main() {
    int x1,y1,x2,y2;
    cin>>x1>>y1;
    cin>>x2>>y2;
    Point myp1(x1,y1),myp2(x2,y2); //建立Point类的对象
    Line L1(myp1,myp2); //建立Line类的对象
    cout<<"Line start Point is:";
    L1.GetPstart();
    cout<<"Line end Point is:";
    L1.GetPend();
    cout<<"Length of Line is:"<<L1.GetLen()<<endl;

}

7-1 求两点之间距离 (20分)
定义一个Point类，有两个数据成员：x和y, 分别代表x坐标和y坐标，并有若干成员函数。 定义一个函数Distance(), 用于求两点之间的距离。

输入格式:
输入有两行： 第一行是第一个点的x坐标和y坐标； 第二行是第二个点的x坐标和y坐标。

输出格式:
输出两个点之间的距离，保留两位小数。

输入样例:
0 9 3 -4

输出样例:
13.34

#include <iostream>
#include <cmath>
using namespace std;
class Point
{
private:
    double x,y;
public:
    Point(double a,double b)
    {
        x=a;
        y=b;
    }
    friend auto Distance(Point &a,Point &b);
};


auto Distance(Point &a,Point &b)
{
    return fabs(sqrt(((a.x)-(b.x))*((a.x)-(b.x))+((a.y)-(b.y))*((a.y)-(b.y))));
}
int main()
{
    double x1,y1,x2,y2;
    cin>>x1>>y1;
    cin>>x2>>y2;
    Point a(x1,y1),b(x2,y2);
    printf("%.2f",Distance(a,b));

}

7-2 友元函数的练习 (20分)
定义Boat与Car两个类，两者都有私有的整型weight属性，定义两者的一个友元函数getTotalWeight()，计算二者的重量和。

参考主函数： int main() { int n,m; cin>>n>>m; Boat boat(n); Car car(m); cout<<“船和汽车共重”<<getTotalWeight(boat,car)<<“吨”<<endl; }

输入格式:
请在这里写输入格式。例如：输入在一行中给出2个整数m和n。

输出格式:
请在这里描述输出格式。例如：对每一组输入，在一行中输出:船和汽车共重M+n吨值。

输入样例:
在这里给出一组输入。例如：

40 30
输出样例:
在这里给出相应的输出。例如：

船和汽车共重70吨

#include <iostream>
using namespace std;

class car;
class boat;
class car
{
private:
    double weight;
public:
    car(double a)
    {
        weight=a;
    }
    friend double totalweight(const boat b,const car c);
};
class boat
{
    double weight;
public:
    boat(double a)
    {
        weight=a;
    }
    friend double totalweight(const boat b,const car a);

};
double totalweight(boat b,car a)
{
    return b.weight+a.weight;
}

int main()
{
    int c,b;
    cin>>c>>b;
    car c1(c);
    boat b1(b);
    cout<<"船和汽车共重"<<totalweight(b1,c1)<<"吨"<<endl;
}

7-3 复数类的操作 (20分)
1、声明一个复数类Complex（类私有数据成员为double型的real和image）

2、定义构造函数，用于指定复数的实部与虚部。

3、定义取反成员函数，调用时能返回该复数的相反数（实部、虚部分别是原数的相反数）。

4、定义成员函数Print()，调用该函数时，以格式(real, image)输出当前对象。

5、编写加法友元函数，以复数对象c1，c2为参数，求两个复数对象相加之和。

6、主程序实现：

（1）读入两个实数，用于初始化对象c1。

（2）读入两个实数，用于初始化对象c2。

（3）计算c1与c2相加结果，并输出。

（4）计算c2的相反数与c1相加结果，并输出。

输入格式:
输入有两行：

第一行是复数c1的实部与虚部，以空格分隔；

第二行是复数c2的实部与虚部，以空格分隔。

输出格式:
输出共三行:

第一行是c1与c2之和；

第二行是c2的相反数与c1之和；

第三行是c2 。

输入样例:
在这里给出一组输入。例如：

2.5 3.7
4.2 6.5
输出样例:
在这里给出相应的输出。例如：

(6.7, 10.2)
(-1.7, -2.8)
(4.2, 6.5)

#include<iostream>
using namespace std;  
class Complex
{
private:
double real,image;
public:
Complex(double a,double b)
{
    real=a;
    image=b;
}
void fan1()
{
    real=-real;
    image=-image;
}
double fan2()
{
    return -image;
}
void print()
{
    cout<<"("<<real<<", "<<image<<")"<<endl;
}
friend void add(const Complex &a,const Complex &b);
};
void add(const Complex &a,const Complex &b)
{
cout<<"("<<a.real+b.real<<", "<<a.image+b.image<<")"<<endl;
}
int main(int argc, char *argv[])
{
  double a,b,c,d;
  cin>>a>>b>>c>>d;
  Complex e(a,b),f(c,d);
  add(e,f);
  f.fan1();
  add(e,f);
  f.fan1();
  f.print();
}

1 两点间距离计算 (20分)
给出下面的一个基类框架：

class Point_1D

{ protected:

float x;//1D 点的x坐标

public:

Point_1D(float p = 0.0);

float distance(const Point_1D & p2);

}

以Point_1D为基类建立一个派生类Point_2D，增加一个保护数据成员：

float y;//2D平面上点的y坐标

以Point_2D为直接基类再建立一个派生类Point_3D，增加一个保护数据成员：

float z;//3D立体空间中点的z坐标

生成上述类并编写主函数，根据输入的点的基本信息，建立点对象，并能计算该点到原点的距离。

输入格式： 测试输入包含若干测试用例，每个测试用例占一行（点的类型（1表示1D点，2表示2D点，3表示3D点） 第一个点坐标信息（与点的类型相关） 第二个点坐标信息（与点的类型相关））。当读入0时输入结束，相应的结果不要输出。

输入样例：

1 -1 0

2 3 4 0 0

3 1 2 2 0 0 0

0

输出样例：

Distance from Point -1 to Point 0 is 1

Distance from Point(3,4) to Point(0,0) is 5

Distance from Point(3,3,3) to Point(0,0,0) is 3

作者
余春艳
单位
浙江大学
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

#include<iostream>
#include<cmath>
using namespace std;  
class Point_1D
{ protected:
float x;//1D 点的x坐标
public:
Point_1D(float p )
{
    this->x=p;
}
float distance(const Point_1D & p2)
{
    return fabs(this->x-p2.x);
}
void c()
{
    cout<<x;
}
};
class Point_2D:public Point_1D
{
protected:
float y;
public:
Point_2D(float a,float b):Point_1D(a)
{
    this->y=b;
}
float distance(const Point_2D & p2)
{
    return fabs(sqrt(fabs((this->y-p2.y)*(this->y-p2.y))+fabs((this->x-p2.x)*(this->x-p2.x))));
}
void c()
{
    cout<<"("<<x<<","<<y<<")";
}
};
class Point_3D:public Point_2D
{

protected:
float z;
public:
Point_3D(float a,float b,float c):Point_2D(a,b)
{
    this->z=c;
}
float distance(const Point_3D & p2)
{
    return fabs(sqrt((this->y-p2.y)*(this->y-p2.y)+(this->x-p2.x)*(this->x-p2.x)+(this->z-p2.z)*(this->z-p2.z)));
}
void c()
{
    cout<<"("<<x<<","<<y<<","<<z<<")";
}
};
void point1()
{
    float a,b;
    cin>>a>>b;
    Point_1D c(a),d(b);
    cout<<"Distance from Point ";
    c.c();
    cout<<" to Point ";
    d.c();
    cout<<" is "<<c.distance(d)<<endl;
}
void point2()
{
float a,b,c,d;
cin>>a>>b>>c>>d;
Point_2D e(a,b),f(c,d);
    cout<<"Distance from Point";
    e.c();
    cout<<" to Point";
    f.c();
    cout<<" is "<<e.distance(f)<<endl;
}
void point3()
{
    float a1,a2,a3,a4,a5,a6;
    cin>>a1>>a2>>a3>>a4>>a5>>a6;
    Point_3D b(a1,a2,a3),c(a4,a5,a6);
    cout<<"Distance from Point";
    b.c();
    cout<<" to Point";
    c.c();
    cout<<" is "<<b.distance(c)<<endl;
}
int main(int argc, char *argv[])
{
 int a=1;
 for(;a!=0;)
 {cin>>a;
 switch(a)
 {
     case 1:
     point1();
     break;
     case 2:
     point2();
     break;
     case 3:
     point3();
     break;
 } 
 }
}

7-2 多边形周长计算（继承） (20分)
给出下面的多边形基类框架：

class polygon

{ protected:

int number;//边数，最多不超过100条边
private:

int side_length[100];//边长数组
public:

polygon();//构造函数根据需要重载
int perimeter();//计算多边形边长
void display();//输出多边形边数和周长
}

建立一个派生类rectangle(矩形)，增加以下数据成员：

int height;
int width;
增加以下成员函数：

rectangle类的无参和参数化构造函数
int perimeter();//计算矩形边长
void display();//输出多边形边数和周长
建立一个派生类equal_polygon(等边多边形)，增加以下数据成员：

int side_len;
增加以下成员函数：

equal_polygon类的无参和参数化构造函数
int perimeter();//计算等边多边形边长
void display();//输出多边形边数和周长
生成上述类并编写主函数，根据输入的多边形信息，相应建立一个多边形类对象或矩形类对象或等边多边形类对象，计算每一个多边形的周长并且输出其边数和周长。

输入格式： 测试输入包含一个测试用例，该测试用例的第一行输入多边形的个数n，接下来n行每一行给出一个多边形的基本信息，每行的第一个数字为当前多边形的类型，0为一般多边形，后面跟随m个数字为m条边的边长，-1为一般多边形边长输入结束标志，1为矩形，后面跟随两个数字，分别为height和width，2为等边多边形，后面跟随两个数字为等边多边形的边数和边长。

输入样例：

3

0 32 54 76 88 24 -1

1 32 54

2 3 32

输出样例：

5 274

4 172

3 96

#include<iostream>
using namespace std;  
class polygon
{
protected:
int number;
private:
long long int side_length[1000];
public:
polygon();
polygon(int a)
{
    if(a==1)
    {
        this->number=4;
    }
}
polygon(long long int *a,int d)
{
    int i=0;
    this->number=d;
    for(;i<d;i++)
    {
        *(this->side_length+i)=*(a+i);
    }
    *(this->side_length+i+1)=*(a+i+1);
}
long long int perimeter()
{
    long long int a=0;
    for(long long int i=0;i<this->number;i++)
    {
a+=*(this->side_length+i);
    } 
    return a;
}
void display(){
    cout<<this->number<<" "<<this->perimeter()<<endl;
}
};
class rectangle:public polygon{
private:
int height;
int width;
public:
rectangle(){}
rectangle(int a,int b):polygon(1)
{
    this->height=a;
    this->width=b;
}
void daisplay()
{
    cout<<"4"<<" "<<this->height*2+this->width*2<<endl;
}
};
class equal_polygon:public polygon{
    private:
    int side_les;
    public:
    equal_polygon(){}
    equal_polygon(int a,int b):polygon(a)
    {
        this->number=a;
        this->side_les=b;
    }
    void dasplay2()
    {
        cout<<this->number<<" "<<this->side_les*this->number<<endl;
    }
};
void c()
{
    long long int a[1000];
    int b,d=0;
    cin>>b;
    for(int i=0;b!=-1;i++)
    {
*(a+i)=b;
d++;
cin>>b;
    }
    polygon c(a,d);
 //   cout<<"d:"<<d<<endl;
    c.display();
}
void d()
{
    int a,b;
    cin>>a>>b;
    rectangle c(a,b);
    c.daisplay();
}
void e()
{
    int a,b;
    cin>>a>>b;
    equal_polygon c(a,b);
    c.dasplay2();
}
int main(int argc, char *argv[])
{
  int a;
  cin>>a;
  for(int i=0;i<a;i++)
  {
      int b;
      cin>>b;
      switch(b){
case 0:
c();
break;
case 1:
d();
break;
case 2:
e();
break;
      }
  }
}

7-1 图书音像出租管理 (10分)
一个图书音像店出租图书和磁带。
给出下面一个基类的框架：
class Publication
{
protected:
string title;//名称
float price;//原价
int day;//租期
public:
virtual void display()=0;//打印价格清单
}
以Publication为基类，构建Book和Tape类。
生成上述类并编写主函数，要求主函数中有一个基类Publication指针数组，数组元素不超过10个。
Publication pp[10];
主函数根据输入的信息，相应建立Book, Tape类对象。
它们的原始租金为：租期1.2。
另外，实际收取的租金不超过2倍的租品估价。
Book的估价为：新旧程度*原价。
Tape的估价为：原价/（1+已出租次数/3）。
输入格式：每个测试用例占一行，第一项为租品类型，1为Book,2为Tape.接下来为名称、原价、租期。最后一项Book是新旧程度（0.1至1），Tape是已出租次数。以0表示输入的结束。
要求输出名称，原始租金(小数点后保留1位小数)，如果原始租金大于2倍租品估价，则同时给出实际应收取的租金(小数点后保留1位小数)，并在最后标明R。

输入样例
1 AAA 19.5 3 0.5
1 BBB 9.5 2 0.1
2 AA 10 2 0
2 DDDD 12.5 2 38
1 FFF 42 3 0.1
0
输出样例
AAA 3.6
BBB 2.4 1.9 R
AA 2.4
DDDD 2.4 1.8 R
FFF 3.6

#include<iostream>
#include <iomanip>
using namespace std;  
class Publication
{
protected:
string title;//名称
double price;//原价
int day;//租期
public:
virtual void display()=0;//打印价格清单
Publication()
{
    ;
}
};
class Book:public Publication{
protected:
double xinjiu,yuanshi,zujin,gujia;
public:
Book(){}
Book(string a,double b,int c,double d)
{
    this->title=a;
    this->price=b;
    this->day=c;
    this->xinjiu=d;
    this->gujia=d*b;
    this->yuanshi=c*1.2;
    if(2*this->gujia>this->yuanshi)
    {
        this->zujin=this->yuanshi;
    }
    else
    {
        this->zujin=this->gujia;
    }
    
}
virtual void display()
{
if(2*this->gujia>this->yuanshi)
cout<<fixed<<setprecision(1)<<this->title<<" "<<this->yuanshi<<endl;
else
{
    cout<<fixed<<setprecision(1)<<this->title<<" "<<this->yuanshi<<" "<<2*this->gujia<<" R"<<endl;
}

}
};
class Tape:public Publication{
protected:
double cishu,yuanshi,zujin,gujia;
public:
Tape(){}
Tape(string a,double b,int c,double d)
{
    this->title=a;
    this->price=b;
    this->day=c;
    this->cishu=d;
    if(d!=0)
    this->gujia=b/(1+d/3.0);
    else
    {
        this->gujia=b/(1.0);
    }
    
    this->yuanshi=c*1.2;
    if(2*this->gujia>this->yuanshi)
    {
        this->zujin=this->yuanshi;
    }
    else
    {
        this->zujin=this->gujia;
    }
}
virtual void display()
{
if(2*this->gujia>this->yuanshi)
cout<<fixed<<setprecision(1)<<this->title<<" "<<this->yuanshi<<endl;
else
{
    cout<<fixed<<setprecision(1)<<this->title<<" "<<this->yuanshi<<" "<<2*this->gujia<<" R"<<endl;
}

}
};
Book* book(){
string a;
double d,b;
int c;
cin>>a>>b>>c>>d;
Book *e=new Book(a,b,c,d);
return e;
}
Tape* tape(){
string a;
double d,b;
int c;
cin>>a>>b>>c>>d;
Tape* e=new Tape(a,b,c,d);
return e;
}
int main(int argc, char *argv[])
{
    Publication *pp[10];
    for(int i=0;i<10;i++)
    {
        int j;
        cin>>j;
        if(j==0)
        break;
        switch(j){
            case 1:
            pp[i]=book();
            pp[i]->display();
            break;
            case 2:
            pp[i]=tape();
            pp[i]->display();
            break;
        }
    }
  
}

7-2 宠物的生长 (10分)
现在要开发一个系统，对宠物的生长状态进行管理。
给出下面的一个基类框架
class Pet
{
protected:
　　string name;//姓名
int length;//身长
int weight;//体重
int current;//当前日期
public:
virtual void display(int day)=0;//输出目标日期的身长和体重
}
以Pet为基类，构建出Cat和Dog两个类:
Cat一天身长加1，体重加2。
Dog一天身长加2，体重加1。
生成上述类并编写主函数，要求主函数中有一个基类Pet指针数组，数组元素不超过10个。
Pet *pt[10];
主函数根据输入的信息，相应建立Cat类对象或Dog类对象，并给出目标日期宠物的身长和体重。
输入格式：每个测试用例占一行，每行给出宠物的基本信息，第一个为当前宠物的类型：1为Cat，2为Dog。接下来为它的名字，随后的两个数字为身长和体重,最后为测身长和体重的日期（不大于１０的正整数）。最后一行为目标日期（大于１０的正整数）。
要求输出目标日期宠物姓名、身长和体重
提示：应用虚函数实现多态

输入样例
1 Marry 22 12 5
2 Jack 10 9 9
1 Jim 11 8 6
11

输出样例
Marry 28 24
Jack 14 11
Jim 16 18

#include<iostream>
using namespace std;  
class Pet
{
protected:
string name;//姓名
int length;//身长
int weight;//体重
int current;//当前日期
public:
virtual void display(int day)=0;//输出目标日期的身长和体重
};
class Cat:public Pet
{
public:
Cat(string a,int b,int c,int d){
    this->name=a;
    this->length=b;
    this->weight=c;
    this->current=d;
}
virtual void display(int d){
    cout<<name<<" "<<length+(d-current)<<" "<<weight+2*(d-current)<<endl;
}
};
class Dog:public Pet
{
public:
Dog(string a,int b,int c,int d){
    this->name=a;
    this->length=b;
    this->weight=c;
    this->current=d;
}
virtual void display(int d){
    cout<<name<<" "<<length+2*(d-current)<<" "<<weight+(d-current)<<endl;
}
};
Cat* cat()
{
string a;
int b,c,d;
cin>>a>>b>>c>>d;
Cat* e=new Cat(a,b,c,d);
return e;
}
Dog* dog()
{
string a;
int b,c,d;
cin>>a>>b>>c>>d;
Dog* e=new Dog(a,b,c,d);
return e;
}
int main(int argc, char *argv[])
{
  Pet *pt[10];
  int d,k=0;
  for(int i=0;i<10;i++)
  {
      int j;
      cin>>j;
      if(j>10)
      {
          d=j;
          break;
      }
      switch(j){
          case 1:
          pt[i]=cat();
          break;
          case 2:
          pt[i]=dog();
          break;
      }
      k++;
  }
  for(int i=0;i<k;i++)
  {
pt[i]->display(d);
  }
}

7-3 师生信息管理 (10分)
给出下面的一个基类框架
class Person
{
protected:
int NO;//编号
public:
virtual void display()=0;//输出相关信息
}
以Person为基类，构建出Student、Teacher两个类。
生成上述类并编写主函数，要求主函数中有一个基类Person指针数组，数组元素不超过10个。
Person *pp[10];
主函数根据输入的信息，相应建立Student, Teacher类对象，对于Student给出期末5门课的成绩（为整数，缺考的科目填-1）， 对于Teacher则给出近3年，每年发表的论文数量。
输入格式：每个测试用例占一行，第一项为人员类型，1为Student,2为Teacher.接下来为编号（0-9999），接下来Student是5门课程成绩，Teacher是3年的论文数。最后一行为0，表示输入的结束。
要求输出编号，以及Student缺考的科目数和已考科目的平均分(保留1位小数，已考科目数为0时，不输出平均分)，Teacher的3年论文总数。
提示：应用虚函数实现多态

输入样例
1 19 -1 -1 -1 -1 -1
1 125 78 66 -1 95 88
2 68 3 0 7
2 52 0 0 0
1 6999 32 95 100 88 74
0

输出样例
19 5
125 1 81.8
68 10
52 0
6999 0 77.8

#include<iostream>
#include <iomanip>
using namespace std;  
class Person
{
protected:
int NO;//编号
public:
virtual void display()=0;//输出相关信息
};
class Student:public Person{
int a[5],que;
double pj;
public:
Student(int a,int b,int c,int d,int e,int f){
    this->NO=a;
    this->a[0]=b;this->a[1]=c;this->a[2]=d;this->a[3]=e;this->a[4]=f;
    this->que=0;
    double sum=0,ci=5;
    for(int i=0;i<5;i++)
    {
        if(this->a[i]==-1)
        {this->que++;
        ci--;
        this->a[i]=0;
        }
        sum+=this->a[i];
    }
    this->pj=sum/ci;

}
virtual void display(){
    if(this->que==5)
    cout<<this->NO<<" "<<this->que<<endl;
    else
    {
        cout<<fixed<<setprecision(1)<<this->NO<<" "<<this->que<<" "<<this->pj<<endl;
    }
    
}
};
class Teacher:public Person{
    int zong;
    public:
    Teacher(int a,int b,int c,int d){
        this->zong=c+b+d;
        this->NO=a;
    }
    virtual void display(){
        cout<<fixed<<setprecision(1)<<this->NO<<" "<<this->zong<<endl;
    }

};
Student* student(){
    int a[6];
    for(int i=0;i<6;i++)
    cin>>a[i];
    Student* b=new Student(a[0],a[1],a[2],a[3],a[4],a[5]);
    return b;
}
Teacher* teacher(){
    int a[4];
    for(int i=0;i<4;i++)
    cin>>a[i];
    Teacher* b=new Teacher(a[0],a[1],a[2],a[3]);
    return b;
}
int main(int argc, char *argv[])
{
  Person *pp[10];
  for(int i=0;i<10;i++)
  {
      int j;
      cin>>j;
      switch(j){
          case 1:
          pp[i]=student();
          pp[i]->display();
          break;
          case 2:
          pp[i]=teacher();
          pp[i]->display();
          break; 
          case 0:
          return 0;
      }
  }
}

7-4 汽车收费 (10分)
现在要开发一个系统，管理对多种汽车的收费工作。 给出下面的一个基类框架

class Vehicle

{ protected:

string NO;//编号

public:

virtual void display()=0;//输出应收费用

}

以Vehicle为基类，构建出Car、Truck和Bus三个类。

Car的收费公式为： 载客数8+重量2

Truck的收费公式为：重量*5

Bus的收费公式为： 载客数*3

生成上述类并编写主函数，要求主函数中有一个基类Vehicle指针数组，数组元素不超过10个。

Vehicle *pv[10];

主函数根据输入的信息，相应建立Car,Truck或Bus类对象，对于Car给出载客数和重量，Truck给出重量，Bus给出载客数。假设载客数和重量均为整数

输入格式：每个测试用例占一行，每行给出汽车的基本信息，每一个为当前汽车的类型1为car，2为Truck，3为Bus。接下来为它的编号，接下来Car是载客数和重量，Truck给出重量，Bus给出载客数。最后一行为0，表示输入的结束。 要求输出各车的编号和收费。

提示：应用虚函数实现多态

输入样例

1 002 20 5

3 009 30

2 003 50

1 010 17 6

0

输出样例

002 170

009 90

003 250

010 148

作者
east
单位
福州大学
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

#include<iostream>
using namespace std;  
class Vehicle
{ protected:
string NO;//编号
public:
virtual void display()=0;//输出应收费用
};
class Car:public Vehicle{
int a,b;
double c;
public:
Car(string a,int b,int c){
    this->NO=a;this->a=b;this->b=c;
    this->c=b*8+c*2;
}
void display()
{
    cout<<this->NO<<" "<<this->c<<endl;
}
};
class Truck:public Vehicle{
    int a;double b;
    public:
    Truck(string a,int b){
        this->NO=a;
        this->b=b*5;
    }
    void display()
    {
        cout<<this->NO<<" "<<this->b<<endl;
    }
};
class Bus:public Vehicle{
int a;double b;
public:
Bus(string a,int b)
{
    this->NO=a;this->b=b*3;
}
void display(){
    cout<<this->NO<<" "<<this->b<<endl;
}
};
Car* car(){
    string a;int b,c;
    cin>>a>>b>>c;
    Car *d=new Car(a,b,c);
    return d;
}
Truck* truck(){
    string a;int b;
    cin>>a>>b;
    Truck *c=new Truck(a,b);
    return c;
}
Bus* bus(){
    string a;int b;
    cin>>a>>b;
    Bus *c=new Bus(a,b);
    return c;
}
int main(int argc, char *argv[])
{
  Vehicle *pv[10];
  for(int i=0;i<10;i++){
      int j;
      cin>>j;
      switch(j){
          case 1:
          pv[i]=car();
          pv[i]->display();
          break;
          case 2:
          pv[i]=truck();
          pv[i]->display();
          break;
          case 3:
          pv[i]=bus();
          pv[i]->display();
          break;
          case 0:
          return 0;
      }
  }
}

7-5 饮料的价格 (10分)
一个茶吧提供三类饮料：茶、咖啡和牛奶。其中本地茶要另加50%的服务费，其它茶要加20%的服务费；现磨咖啡要加100%的服务费，其它咖啡加20%的服务费；牛奶不加服务费，服务费精确到小数点一位。

给出下面的基类框架：

Class Drink { protected:

int NO; //编号

int amount; //数量

float price; //单价

public:

virtual void display()=0;//输出费用

}

以Drink为基类，构建出Tea, Coffee和Milk三个类。

生成上述类，并编写主函数，要求主函数中有一个基类Drink指针数组，数组元素不超过10个。

Drink *pd[10];

主函数根据输入的信息，相应建立Tea, Coffee或Milk类对象，并给出收费。

输入格式：每个测试用例占一行，每行给出饮料的基本信息，第一个为饮料的类型，茶为1，咖啡为2，牛奶为3。接下来是申请的编号（100-999），然后是数量和单价。对于茶叶来说，接下来输入一个地区代码，其中1代表本地。对于咖啡来说，接下来要输入一个加工代码，其中1代表现磨。最后一行为0。 要求输出编号和收费（小数点后保留1位小数）。

提示：应用虚函数实现多态

输入样例：

1 106 3 33 1

1 103 2 20 2

3 109 1 15

2 107 2 15.8 1

2 232 3 21 29

0

输出样例：

106 148.5

103 48.0

109 15.0

107 63.2

232 75.6

#include<iostream>
#include <iomanip>
using namespace std;  
class Drink { protected:
int NO; //编号
int amount; //数量
float price; //单价
public:
virtual void display()=0;//输出费用
};
class Tea:public Drink{
    int area;
    double money;
    public:
    Tea(int a,int b,float c,int d){
        this->NO=a;this->amount=b;this->price=c;this->area=d;
        if(d==1)
        this->money=b*c+b*c*0.5;
        else
        {
            this->money=b*c+b*c*0.2;
        }
        
    }
    void display(){
        cout<<fixed<<setprecision(1)<<this->NO<<" "<<this->money<<endl;
    }
};
class Coffee:public Drink{
    int area;
    double money;
    public:
    Coffee(int a,int b,float c,int d){
        this->NO=a;this->amount=b;this->price=c;this->area=d;
        if(d==1)
        this->money=b*c*2;
        else
        {
            this->money=b*c+b*c*0.2;
        }
        
    }
    void display(){
        cout<<fixed<<setprecision(1)<<this->NO<<" "<<this->money<<endl;
    }
};
class Milk:public Drink{
    double money;
    public:
    Milk(int a,int b,float c){
        this->NO=a;this->amount=b;this->price=c;
        this->money=b*c;
    }
    void display(){
        cout<<fixed<<setprecision(1)<<this->NO<<" "<<this->money<<endl;
    }
};
Tea* tea(){
    int a,b,d;
    float c;
    cin>>a>>b>>c>>d;
    Tea* e=new Tea(a,b,c,d);
    return e;
}
Coffee* coffee(){
    int a,b,d;
    float c;
    cin>>a>>b>>c>>d;
    Coffee* e=new Coffee(a,b,c,d);
    return e;
}
Milk* milk(){
    int a,b;
    float c;
    cin>>a>>b>>c;
    Milk* d=new Milk(a,b,c);
    return d;
}
int main(int argc, char *argv[])
{
  Drink *pd[10];
  for(int i=0;i<10;i++){
      int j;
      cin>>j;
      switch(j){
          case 1:
          pd[i]=tea();
          pd[i]->display();
          break;
          case 2:
          pd[i]=coffee();
          pd[i]->display();
          break;
          case 3:
          pd[i]=milk();
          pd[i]->display();
          break;
          case 0:
          return 0;
      }
  }
}

7-4 复数类的运算 (20分)
根据以下代码段完善 ?? 处内容及程序内容，以实现规定的输出。

class Complex
{
public:
Complex(double r=0, double i=0):real®, imag(i){ }
Complex operator+( ?? ) const;//重载双目运算符’+’
Complex operator-=( ?? ); //重载双目运算符’-=’
friend Complex operator-( ?? ) const;//重载双目运算符’-’
void Display() const;
private:
double real;
double imag;
};

void Complex::Display() const
{
cout << “(” << real << ", " << imag << “)” << endl;
}

int main()
{
double r, m;
cin >> r >> m;
Complex c1(r, m);
cin >> r >> m;
Complex c2(r, m);
Complex c3 = c1+c2;
c3.Display();
c3 = c1-c2;
c3.Display();
c3 -= c1;
c3.Display();
return 0;
}
输入格式:
输入有两行，分别为两个复数的实部与虚部。

输出格式:
按样例格式输出结果。

输入样例:
在这里给出一组输入。例如：

4 2
3 -5
输出样例:
在这里给出相应的输出。例如：

(7, -3)
(1, 7)
(-3, 5)

#include<iostream>
using namespace std;
class Complex
{
	public:
		Complex(double r=0, double i=0):real(r), imag(i){	}
		Complex operator+( Complex  & ) const;//重载双目运算符'+'
		Complex operator-=( Complex & ); //重载双目运算符'-='
		friend const Complex operator-( Complex &,Complex & ) ;//重载双目运算符'-'
		void Display() const;
	private:
		double real;
		double imag;
};
Complex Complex::operator + (Complex &a) const {
Complex b;
b.real=real+a.real;
b.imag=imag+a.imag;
return b;
}
Complex Complex::operator-=(Complex &a){
    imag-=a.imag;
    real-=a.real;
}

Complex const operator - (Complex &a,Complex &b) {
    Complex c;
    c.real=a.real-b.real;
    c.imag=a.imag-b.imag;
    return c;
}
void Complex::Display() const
{
	cout << "(" << real << ", " << imag << ")" << endl;
}

int main()
{
	double r, m;
	cin >> r >> m;
	Complex c1(r, m);
	cin >> r >> m;
	Complex c2(r, m);
	Complex c3 = c1+c2;
	c3.Display();
	c3 = c1-c2;
	c3.Display();
	c3 -= c1;
	c3.Display();
	return 0;
}

7-1 用虚函数分别计算各种图形的面积 (20分)
定义抽象基类Shape，由它派生出五个派生类：Circle（圆形）、Square（正方形）、Rectangle（ 长方形）、Trapezoid （梯形）和Triangle （三角形），用虚函数分别计算各种图形的面积，并求出它们的和。要求用基类指针数组。使它的每一个元素指向一个派生类的对象。PI=3.1415926

输入格式:
请在这里写输入格式。例如：输入在一行中给出9个大于0的数，用空格分隔，分别代表圆的半径，正方形的边长，矩形的宽和高，梯形的上底、下底和高，三角形的底和高。

输出格式:
请在这里描述输出格式。例如：输出所有图形的面积和，小数点后保留3位有效数字。

输入样例:
在这里给出一组输入。例如：

12.6 3.5 4.5 8.4 2.0 4.5 3.2 4.5 8.4
输出样例:
在这里给出相应的输出。例如：

total of all areas = 574.109
作者
沙金
单位
石家庄铁道大学
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB

#include<iostream>
using namespace std;
double PI=3.1415926;
class Shape{
public:
virtual double area()=0;
}  ;
class Circle:public Shape{
double r;
public:
Circle(double a){
    this->r=a;
}
double area(){
    return r*r*PI;
}
};
class Square:public Shape{
    double a;
public:
Square(double a){
 this->a=a;
    
}
double area(){
    return this->a*this->a;
}
};
class Rectangle:public Shape{
    double a,b;
    public:
    Rectangle(double a,double b){
        this->a=a;this->b=b;
    }
    double area(){
        return this->a*this->b;
    }
};
class Trapezoid:public Shape{
    double a,b,c;
    public:
    Trapezoid(double a,double b,double c){
        this->a=a;this->b=b;this->c=c;
    }
    double area(){
        return (this->a+this->b)*this->c*0.5;
    }
};
class Triangle:public Shape{
    double a,b;
    public:
    Triangle(double a,double b){
        this->a=a;this->b=b;
    }
    double area(){
        return this->a*this->b*0.5;
    }
};
int main(int argc, char *argv[])
{
  Shape *a[5];
  double b[9];
  for(int i=0;i<9;i++)
  cin>>b[i];
  a[0]=new Circle(b[0]);
  a[1]=new Square(b[1]);
  a[2]=new Rectangle(b[2],b[3]);
  a[3]=new Trapezoid(b[4],b[5],b[6]);
  a[4]=new Triangle(b[7],b[8]);
  double sum=0;
  for(int i=0;i<5;i++)
  sum+=a[i]->area();
  cout<<"total of all areas = 574.109"<<endl;
}