首页 > 编程语言 >c/c++零基础坐牢第十七天

c/c++零基础坐牢第十七天

时间：2023-05-31 13:46:41浏览次数：63  
标签：const 函数 Point double void c++ 第十七 坐牢 构造函数

c/c++从入门到入土（17）

开始时间2023-05-30 21:31:54

结束时间2023-05-31 13:29:07

前言：第九章多态性从作业七作业八实验三和读书笔记及体会四个方面进行学习分享，课本知识参考于清华大学出版社郑莉老师的《C++语言程序设计》第五版，以下为自制思维导图：

 第九章 多态性

 1 面向对象程序设计的真正力量不仅仅在于继承，还在于将派生类对象当基类对象一样处理的功能。支持这种功能就是多态和动态绑定。
 2 多态是指同样的消息被不同类型的对象接受时导致不同的行为，所谓消息是指对类的成员函数的调用，不同的行为是指不同的实现，也就是调用了不同的函数。
 3 面向对象的多态性可以分为四类，重载多态、强制多态、包含多态和参数多态。
 4 前面两种称为专用多态，而后面两种称为通用多态。
 5 强制多态是指将一个变元的类型加以变化，以符合一个函数或者操作的要求。
 6 包含多态是类族中定义于不同类中的同名成员函数的多态行为，主要是通过虚函数来实现。
 7 参数多态与类模板相关联，在使用时必须赋予实际的类型才可以实例化。
 8 多态从实现的角度来讲可以划分为两类：编译时多态和运行时多态。
 9 前者是在编译的过程中确定了同名操作的具体操作对象，后者则是在程序运行中才动态地确定操作所针对的具体对象。
10 这种确定操作所针对的具体对象的过程就是绑定。
11 绑定是指计算机程序自身彼此关联的过程，也就是把一个标识符名和一个存储地址联系在一起的过程；用面向对象的术语讲，就是把一条消息和一个对象的方法相结合的过程。
12 绑定工作在编译阶段连接完成的情况称为静态绑定。在编译、连接过程中，系统就可以根据类型匹配等特征确定程序中操作调用与执行该操作代码的关系，即确定了某一个同名标识到底是要调用哪一段程序代码。
13 绑定工作在程序运行阶段完成的情况称为动态绑定，也称为晚期绑定或后绑定。在编译、连接阶段中无法解决的绑定问题，要等到程序开始运行之后再来确定，包括多态操作对象的确定就是通过多态绑定完成的。
多态性概述 
 1 运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据时导致的不同行为。
 2 运算符重载的实质就是函数重载。在实现过程中，首先把指定的运算表达式转化为对运算符函数的调用，运算对象转化为运算符函数的实参，然后根据实参的类型来确定需要调用的函数，这个过程是在编译过程中完成的。
 3 运算符重载的规则如下：
 4 （1）c++语言中的运算符除了少数几个外，全部可以重载，而且只能重载c++中已经存在的运算符。
 5 （2）重载之后运算符的优先级和结合性都不会改变。
 6 （3）运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。一般来讲，重载的功能应当与原有功能相类似，不能改变原运算符的操作对象个数，同时至少要有一个操作对象是自定义类型。
 7 C++标准规定，有些操作符是不能重载的，它们是类属关系运算符“.”、成员指针运算符“.*”、作用域分辨符“::”和三目运算符“?:”。前面两个运算符保证了C++语言中访问成员功能的含义不被改变。作用域分辨的操作符是类型，而不是普通的表达式，也不具备重载的特征。
 8 运算符重载为类的成员函数的一般语法形式为：
 9 返回类型 类名::operator 运算符（形参表）
10 {
11     函数体
12 }
13 运算符重载为非成员函数的一般语法形式为：
14 返回类型 operator 运算符（形参表）
15 {
16   函数体          
17 }
18 返回值类型指定了重载运算符的返回值类型，也就是运算结果类型；
19 operator是定义运算符重载函数的关键字；
20 运算符即是要重载的运算符名称，必须是C++中可重载的运算符。
21 形参表中给出重载运算符所需要的参数和类型。
22 当以非成员函数形式重载运算符时，有需要访问运算符参数所涉及类的私有成员，这时可以把该函数声明为类的有元函数。
23 当运算符重载为类的成员函数时，函数的参数个数比原来操作数个数要少一个；当重载为非成员函数时，参数个数与原操作数个数相同。
24 两种情况的参数个数有所差异的原因是，重载为类的成员函数时，第一个操作数会被作为函数调用的目的对象，因此无须出现现在参数表中，函数体中可以直接访问第一个操作数的成员；而重载为非成员函数时，运算符的所有操作数必须显式通过参数传递。
25 运算符重载的主要优点就是可以改变现有运算符的操作方式，以用于类类型，使得程序括起来更加直观。
26 运算符重载的实质上就是函数重载，重载为成员函数，它就可以自由地访问本类的数据成员。
27 实际使用时，总是通过该类的某个对象来访问重载的运算符，如果是双目运算符，左操作数是对象本身的数据，由this指针指出，右操作数则需要通过运算符重载函数的参数表来传递；如果是单目运算符，操作数由对象的this指针给出，就不再需要任何参数。
28 仅在需要访问类的私有成员或保护成员时将重载运算符的非成员函数声明为类的有元函数。如果不将其声明为有元函数，该函数仅依赖于类的接口，只要类的接口不变化，该函数的实现就无须变化；如果将其声明为有元函数，该函数会依赖类的实现，即使类的接口不变化，只要类的私有数据成员的设置发生了变化，该函数的实现就需要变化。
29 以下原因必须使用非成员函数的重载方式：
30 （1）要重载的操作符的第一个操作数不是可以更改的类型，比如“<<”运算符的第一个操作数的类型为ostream，是标准库的类型，无法向其中添加成员函数。
31 （2）以非成员函数形式重载，支持更灵活的类型转换。
32 （3）“=”“[]”“()”"->"只能被重载为成员函数，而且派生类中的“=”运算符函数总会隐藏基类中的“=”运算符函数.
运算符重载 
 1 一般虚函数成员的声明语法是：
 2 virtual 函数类型 函数名（形参表）;
 3 这实际上就是在类的定义中使用virtual关键字来限定成员函数，虚函数声明只能出现在类定义中的函数原型声明中，而不能在成员函数实现的时候。
 4 运行过程中的多态需要满足3个条件，首先类之间满足赋值兼容规则，其二是要声明虚函数，第三是要由成员函数来调用或者是通过指针、引用来访问虚函数。
 5 习惯 虚函数一般不声明为内联函数，因为对写函数的调用需要动态绑定，而对内联函数的处理是静态的，所以虚函数一般不能以内联函数处理。但将虚函数声明为内联函数也不会引起错误。
 6 系统会遵循以下规则来判断派生类的一个函数成员是不是虚函数：
 7 （1）该函数是否与基类的虚函数有相同的名称。
 8 （2）该函数是否与基类的虚函数有相同的参数个数及相同的对应参数类型。
 9 （3）该函数是否与基类的虚函数有相同的返回值或者满足赋值兼容规则的指针、引用型的返回值。
10 如果派生类的函数满足上述条件，就会自动确定为虚函数。这时派生类的虚函数便覆盖了基类的虚函数。不仅如此，派生类中的虚函数还会隐藏基类中同名函数的所有其他重载形式。
11 在C++中，不能声明虚构造函数，但是可以声明虚析构函数。析构函数没有类型，也没有参数。
12 虚析构函数的声明语法为：
13 virtual ~类名();
14 如果一个类的析构函数是虚函数，那么，由它派生而来的所有子类的析构函数也是虚函数。析构函数设置为虚函数之后，在使用指针引用时可以动态绑定，实现运行时的多态，保证使用基类类型的指针就能够调用适当的析构函数针对不同的对象进行清理工作。
虚函数 
1 建立抽象类，就是为了通过它多态地使用其中的成员函数。抽象类处于类层次的上层，一个抽象类自身无法实例化，也就是说我们无法定义一个抽象类的对象，只能通过继承机制，生成抽象类的非抽象派生类，然后再实例化。
2 纯虚函数是一个在基类中声明的虚函数，它在该基类中没有定义具体的操作内容，要求各派生类根据实际需要定义自己的版本，纯虚函数的声明格式为：
3 virtual 函数类型 函数名（参数表）=0;
4 实际上，它与一般虚函数成员的原型在书写格式上的不同就在于后面加了“=0”。声明为纯虚函数之后，基类中就可以不再给出函数的实现部分。
5 带有纯虚函数的类是抽象类。抽象类的主要作用是通过它为一个类族建立一个公共的接口，使它们能够更有效地发挥多态特性。抽象类声明了一族派生类的共同接口，而接口的完整实现，即纯虚函数的函数体，要由派生类自己定义。
6 抽象类不能实例化，即不能定义一个抽象类的对象，但是，我们可以定义一个抽象类的指针和引用。通过指针或引用，就可以指向并访问派生类对象，进而访问派生类的成员，这种访问具有多态性。
纯虚函数与抽象类

 作业七 运算符重载

判断题

对每个可重载的运算符来讲，它既可以重载为友元函数，又可以重载为成员函数，还可以重载为非成员函数。

 答案：错误

体会：有三种情况不能用成员函数的方式重载，需要使用非成员函数重载，详见第二部分运算符重载，或课本P314下面。

重载operator+时，返回值的类型应当与形参类型一致。
比如以下程序中，operator+的返回值类型有错：

class A {

int x;
public:

 A(int t=0):x(t){     }

    int operator+(const A& a1){ return x+a1.x;  }
};

答案：错误

体会：返回值类型正确，返回x+a1.x为类型A中声明的int X，所以重载返回值一致。

选择题

下列运算符中，（ ）运算符不能重载。

A.＆＆

B.[ ]

C.::

D.<<

答案：C

体会：类属运算符.、成员指针运算符.*、作用域分辨符::和三目运算符?:不能重载。

编程题 复数类的运算

根据以下代码段完善 ?? 处内容及程序内容，以实现规定的输出。

class Complex
{
    public:
        Complex(double r=0, double i=0):real(r), 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)
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
问题描述 
#include <iostream>
using namespace std;
class Complex
{
    public:
        Complex(double r=0, double i=0):real(r), imag(i){    }
        Complex operator+(Complex c) const;//重载双目运算符'+'
        Complex operator-=(Complex c); //重载双目运算符'-='
        friend Complex operator-(Complex c1,Complex c2) ;//重载双目运算符'-'
        void Display() const;
    private:
        double real;
        double imag;
};
Complex Complex::operator+ (Complex c)const{
c.imag=c.imag+this->imag;
c.real=c.real+this->real;
return c;
}
Complex Complex::operator-=(Complex c){
this->imag=this->imag-c.imag;
this->real=this->real-c.real;
return *this;

}
Complex operator-(Complex c1,Complex c2){
c1.imag=c1.imag-c2.imag;
c1.real=c1.real-c2.real;
return c1;
}

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;
}
源代码

作业八 抽象类

判断题

抽象类是指一些没有说明对象的类。

答案：错误

体会：抽象类不仅仅是没有说明对象的类，更重要的是抽象类是包含至少一个纯虚函数（Pure Virtual Function）的类，这些纯虚函数在类中没有实现，只有函数原型，因此抽象类无法直接实例化对象。如果一个类包含至少一个纯虚函数，那么这个类就是一个抽象类，它的主要作用是为继承它的子类提供一个统一的接口和规范。子类必须实现继承自父类的所有纯虚函数才能被正常创建对象使用。

单选题

关于动态绑定的下列描述中，（ ）是错误的。

A.动态绑定是以虚函数为基础的

B.动态绑定在运行时确定所调用的函数代码

C.动态绑定调用函数操作是通过指向对象的指针或对象引用来实现的

D.动态绑定是在编译时确定操作函数的

答案：D

体会：绑定工作在程序运行阶段完成的情况称为动态绑定。

设有如下代码段:

class A {
public:
    void func1() {
        cout << "A1" << endl;
    }
    virtual void func2() {
        cout << "A2" << endl;
    }
};
class B : public A {
public:
    void func1() {
        cout << "B1" << endl;
    }
    void func2() {
        cout << "B2" << endl;
    }
};

int main() {
    A *a = new B;
    a->func1();
    a->func2();
}
则输出结果为:
A.A1 A2

B.A1 B2

C.B1 A2

D.B1 B2

答案：B

分析：

首先执行a->func1()，它调用的是类A的成员函数func1()，因为a的类型是A*，且A类中的func1()函数不是虚函数，所以调用的是A类中的实现，输出结果为A1。

然后执行a->func2()，它调用的是类B的成员函数func2()，因为在A类中，func2()函数被声明为virtual虚函数，所以在子类B中对这个函数的重新实现会覆盖掉父类A中的实现，此时会调用子类B中的func2()函数，输出结果为B2。

关于虚函数的描述中，（ ）是正确的。

A.虚函数是一个static 类型的成员函数

B.虚函数是一个非成员函数

C.基类中说明了虚函数后，派生类中与其对应的函数可不必说明为虚函数

D.派生类的虚函数与基类的虚函数具有不同的参数个数和类型

答案：C

体会：A因为虚函数不是一个静态成员函数，而是一个动态绑定的成员函数。静态成员函数不具备多态性。B虚函数是一个类的成员函数，而非非成员函数。D派生类中重载基类的虚函数时，必须保证参数列表（包括参数的类型、个数和顺序）相同。否则会被视为另外一个函数，而不是基类的虚函数被重载。

编程题 虚函数的应用

补充下列代码，使得程序的输出为：

A:3

A:15

B:5

3

15

5

类和函数接口定义：
参见裁判测试程序样例中的类和函数接口。
裁判测试程序样例：
#include <iostream>
using namespace std;
class CMyClassA {
    int val;
public:
    CMyClassA(int);
    void virtual print();
};
CMyClassA::CMyClassA(int arg) {
    val = arg;
    printf("A:%d\n", val);
}
void CMyClassA::print() {
    printf("%d\n", val);
    return;
}

/* 在这里填写代码 */

int main(int argc, char** argv) {
    CMyClassA a(3), *ptr;
    CMyClassB b(5);
    ptr = &a;
    ptr->print();
    a = b;
    a.print();
    ptr = &b;
    ptr->print();
    return 0;
}
输入样例：
None
输出样例：
A:3
A:15
B:5
3
15
5
来源：
openjudge.cn
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
问题描述 
class CMyClassB:public CMyClassA{
    
    private:
          int val;
    public:
          CMyClassB(int b):CMyClassA(3*b)
          {
              val=b;
              printf("B:%d\n",val);
          }
    void virtual print()
    {
        printf("%d\n",val);
        return ;
    }
};
源代码

实验三 CPP多态编程

第一题

定义一个整数加法器类Adder，对其重载运算符“+”、“++”，main(void)函数完成对其的测试。

Adder类结构说明：
Adder类的数据成员包括：
①私有数据成员：数值域num(int型)。
Adder类成员函数包括：
①有参构造函数Adder(int)和拷贝构造函数Adder(const  Adder  &)，其中有参构造函数参数默认值为0，输出信息“Adder Constructor run”，拷贝构造函数输出信息“Adder CopyConstructor run”
②析构函数，析构函数输出信息“Adder Destructor run”
③公有函数成员void  setNum(int)和int getNum() const分别返回和设置数值域。
④重载“+”运算符，实现两个Adder对象相加的运算
⑤重载“++”运算符，实现Adder对象自增运算
⑥公有成员函数void show() const用于显示加法器的信息，显示格式为：Adder(<数值域>)
裁判测试程序样例：
#include <iostream>
using namespace std;

/*请在这里填写答案*/

//主函数
int main(void){
    int x;
    Adder a1,a2(a1);
    cin>>x;
    (a1++).show();
    a1.show();
    a2.setNum(x);
    (++a2).show();
    a2.show();
    (a1+a2).show();
    return 0;
}
输入样例：
1
输出样例：
Adder Constructor run
Adder CopyConstructor run
Adder CopyConstructor run
Adder(0)
Adder Destructor run
Adder(1)
Adder(2)
Adder(2)
Adder Constructor run
Adder(3)
Adder Destructor run
Adder Destructor run
Adder Destructor run
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
设计并实现加法器类Adder 
class Adder
{
private:
    int num;
public:
    Adder(int n=0);//有参构造函数，其中参数默认值为0
    Adder(const Adder &adder);//拷贝构造函数
    ~Adder();//析构函数
    void  setNum(int n);//公有函数，用于设置数值域
    int getNum() const;//公有函数，用于返回数值域
    Adder operator+(Adder &a);//重载+运算符
    Adder& operator++(void);//前置++运算符重载
    const Adder operator++(int);//后置++运算符重载
    void show() const;//显示
};
Adder::Adder(int n)//有参构造函数的实现
{
    num=n;
    cout<<"Adder Constructor run"<<endl;
}
Adder::Adder(const Adder &adder)//拷贝构造函数的实现
{
    num = adder.num;
    cout<<"Adder CopyConstructor run"<<endl;
}
Adder::~Adder()//析构函数的实现
{
    cout<<"Adder Destructor run"<<endl;
}
void Adder::setNum(int n)
{
    num=n;
}
int Adder::getNum()const
{
    return num;
}
Adder Adder::operator+(Adder &a)//重载+运算符
{
    this->num = this->num + a.num;
    return (Adder(getNum()));
}
Adder& Adder::operator++(void)//前置重载++运算符
{
    num++;
    return *this;
}
const Adder Adder::operator++(int)//后置重载++运算符
{
    Adder ad=*this;
    ++(*this);
    return ad;
}
void Adder::show()const
{
    cout<<"Adder("<<num<<")"<<endl;
}
源代码1

 第二题

以点类Point及平面图形类Plane为基类公有派生圆类Circle，main(void)函数完成对其的测试。

Point类结构说明：
Point类的数据成员包括：
①私有数据成员：X坐标x(double型)，Y坐标y(double型)。
Point类成员函数包括：
①有参构造函数Point(double, double)和拷贝构造函数Point(const  Point  &)，其中有参构造函数参数默认值为0，输出信息“Point Constructor run”，拷贝构造函数输出信息“Point CopyConstructor run”
②析构函数，析构函数输出信息“Point Destructor run”
③公有函数成员void  setX(double)和double getX() const分别返回和设置X坐标
④公有函数成员void  setY(double)和double getY() const分别返回和设置Y坐标
⑤公有成员函数void show() const用于显示点的坐标信息，显示格式为：Point(X=<X坐标>,Y=<Y坐标>)
Plane类结构说明：
抽象类Plane类的成员函数包括：
①纯虚函数virtual double length()const用于计算平面图形的周长
②纯虚函数virtual double area()const用于计算平面图形的面积
Circle类结构说明：
公有派生圆类Circle以点类Point、平面图形类Plane为基类，Circle类的结构说明如下：
Circle类的数据成员包括：
①圆心坐标继承自Point类
②保护静态数据常量PI(double型)，其值为3.14159
③私有数据成员：半径radius(double型)。
Circle类成员函数包括：
①有参构造函数Circle(double, double, double)和拷贝构造函数Circle(const Circle &)，其中有参构造函数参数包括圆心坐标和半径，圆心调用Point类构造函数进行构造，各参数默认值为0，输出信息“Circle Constructor run”，拷贝构造函数输出信息“Circle CopyConstructor run”
②析构函数，析构函数输出信息“Circle Destructor run”
③公有函数成员void setR(double)和double getR()const分别返回和设置radius
④重载void show()const用于显示圆的信息，显示格式为：
Circle(Point(<圆心X坐标>,<圆心Y坐标>),Radius=<半径>)
⑤重载double area()const用于计算圆的面积
⑥重载double length()const用于计算圆的周长
裁判测试程序样例：
#include <iostream>
using namespace std;
//点类Point
class Point{
private:
    double x;
    double y;
public:
    Point(double xv=0,double yv=0);/*构造函数*/
    Point(const Point &p);         /*拷贝构造*/
    ~Point();                      /*析构函数*/
    virtual void show()const;      /*显示*/
    void setX(double xv);          /*设置X坐标*/
    void setY(double yv);          /*设置Y坐标*/
    double getX() const;           /*获取X坐标*/
    double getY() const;           /*获取Y坐标*/
};
Point::Point(const double xv,const double yv){/*构造函数*/
    x=xv;
    y=yv;
    cout<<"Point Constructor run"<<endl;
}
Point::Point(const Point &p){/*拷贝构造*/
    x=p.x;
    y=p.y;
    cout<<"Point CopyConstructor run"<<endl;
}
Point::~Point(){/*析构函数*/
    cout<<"Point Destructor run"<<endl;
}
void Point::show() const{/*显示*/
    cout<<"Point(X="<<x<<",Y="<<y<<")";
}
void Point::setX(double xv){/*设置X坐标*/
    x=xv;
}
void Point::setY(double yv){/*设置Y坐标*/
    y=yv;
}
double Point::getX() const{/*获取X坐标*/
    return x;
}
double Point::getY() const{/*获取Y坐标*/
    return y;
}
class Plane{/*平面图形基类*/
public:
    virtual double length()const=0;/*周长*/
    virtual double area()const=0;  /*面积*/
};

/*请在这里填写答案*/

void show(Point *p){/*点基类的显示函数*/
    p->show();
}
void length(Plane *p){/*平面图形的周长函数*/
    cout<<"Length="<<p->length()<<endl;
}
void area(Plane &p){/*平面图形的面积函数*/
    cout<<"Area="<<p.area()<<endl;
}
//主函数
int main(void){
    double x,y,r;
    Circle c1,c2(c1);
    show(&c1);
    cout<<endl;
    area(c1);
    length(&c1);
    cin>>x>>y>>r;
    c2.setX(x);
    c2.setY(y);
    c2.setR(r);
    show(&c2);
    cout<<endl;
    area(c2);
    length(&c2);
}
输入样例：
1.0 2.0 3.0
输出样例：
Point Constructor run
Circle Constructor run
Point CopyConstructor run
Circle CopyConstructor run
Circle(Point(X=0,Y=0),Radius=0)
Area=0
Length=0
Circle(Point(X=1,Y=2),Radius=3)
Area=28.2743
Length=18.8495
Circle Destructor run
Point Destructor run
Circle Destructor run
Point Destructor run
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
以点类Point及平面图形类Plane为基础设计圆类Circle 
class Circle:public Point, public Plane 
{
    private:
    double x;
    double y;
    double radius;
    protected:
    static double PI;
    public:
    Circle(double ,double ,double);
    Circle(const Circle &);
    ~Circle();
    void setX(double xv)         /*设置X坐标*/
    {
        this->x=xv;
    }
    void setY(double yv)         /*设置Y坐标*/
    {
        this->y=yv;
    }
    double getX() const          /*获取X坐标*/
    {
        return this->x;
    }
    double getY() const          /*获取Y坐标*/
    {
        return this->y;
    }
    void setR(double);
    double getR() const;
    void show() const;
    double area() const;
    double length() const;
};
double Circle::PI=3.14159;
Circle::Circle(double a=0,double b=0,double c=0):Point(a,b)
{
    this->x=a;
    this->y=b;
    this->radius=c;
    cout<<"Circle Constructor run"<<endl;
}
Circle::Circle(const Circle &p):Point (p)
{
    this->x=p.x;
    this->y=p.y;
    this->radius=p.radius;
    cout<<"Circle CopyConstructor run"<<endl;
}
Circle::~Circle()
{
    cout<<"Circle Destructor run"<<endl;
}
void Circle::setR(double r=0)
{
    this->radius=r;
}
double Circle::getR() const
{
    return radius;
}
void Circle::show() const
{
    cout<<"Circle(Point(X="<<this->x<<",Y="<<this->y<<"),Radius="<<this->radius<<")";
}
double Circle::area() const{
    return PI*radius*radius;
}
double Circle::length() const{
    return 2.0*PI*radius;
}
源代码2

第三题

定义一个整数型大数类，要求能够完成100位以内的较大整数的加法和减法计算，main(void)函数完成对其的测试。

BigNum类结构说明：
BigNum类的数据成员包括：
①私有数据成员：数值域num(char []型)。
BigNum类成员函数包括：
①有参构造函数BigNum(char c[])和拷贝构造函数BigNum(const  BigNum  &)，其中有参构造函数参数默认值为"+0"，输出信息"BigNum Constructor run"，拷贝构造函数输出信息"BigNum CopyConstructor run"
②析构函数，析构函数输出信息"BigNum Destructor run"
③公有函数成员void  setNum(char c[])和char const *getNum(void) const分别返回和设置数值域。
④重载“+”运算符，实现两个BigNum对象相加的运算
⑤重载“-”运算符，实现两个BigNum对象相减的运算
⑥公有成员函数void show() const用于显示BigNum对象的信息，显示格式为：BigNum(<数值域>)
建议：大数存储时专门存储符号位且低位存储在前，高位存储在后。这样便于运算实现。

裁判测试程序样例：
#include <iostream>
using namespace std;
#define N 100

/*请在这里填写答案*/

//主函数
int main(void){
    char c[100],op;
    cin>>c;
    BigNum b1(c),b2(b1);
    b1.show();
    cin>>c;
    b2.setNum(c);
    b2.show();
    cin>>op;
    if(op=='+') (b1+b2).show();
    if(op=='-') (b1-b2).show();
    return 0;
}
输入样例：
123
234
-
输出样例：
BigNum Constructor run
BigNum CopyConstructor run
BigNum(+123)
BigNum(+234)
BigNum Constructor run
BigNum CopyConstructor run
BigNum Destructor run
BigNum(-111)
BigNum Destructor run
BigNum Destructor run
BigNum Destructor run
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
设计并实现大数类BigNum 
#include<bits/stdc++.h>
class BigNum
{
private:
    char num[N];
public:
    BigNum( char c[N] = "+0" );
    BigNum( const BigNum &p );
    ~BigNum()
    {
        cout<<"BigNum Destructor run"<<endl;
    }
    void setNum( char c[N] );
    char const * getNum(void) const;
    BigNum operator + ( const BigNum &a );
    BigNum operator - (  BigNum &b );
    void show() const;
};
 
 
BigNum::BigNum( char c[N] )
{
    int i,j,a = strlen(c);
    if( c[0] != '-')
    {
        num[0] = '+';
        if( c )
        {
            for( i=strlen(c), j=0; i>=1; i--,j++)
            {
                num[i] = c[j];
            }
        }
        num[a+1] = '\0';
    }
    else
    {
        num[0] = c[0];
        for( i=strlen(c)-1, j=1; i>=1; i--,j++)
        {
            num[i] = c[j];
        }
        num[a] = '\0';
    }
    cout<<"BigNum Constructor run"<<endl;
}
 
BigNum::BigNum( const BigNum &p )
{
    int i=0;
    if(p.num)
    {
        while( p.num[i] != '\0' )
        {
            num[i] = p.num[i];
            i++;
        }
        num[i] = '\0';
    }
    cout<<"BigNum CopyConstructor run"<<endl;
}
 
void BigNum::setNum( char c[N] )
{
    int i,j,a = strlen(c);
    if( c[0] != '-')
    {
        num[0] = '+';
        if( c )
        {
            for( i=strlen(c), j=0; i>=1; i--,j++)
            {
                num[i] = c[j];
            }
        }
        num[a+1] = '\0';
    }
    else
    {
        num[0] = c[0];
        for( i=strlen(c)-1, j=1; i>=1; i--,j++)
        {
            num[i] = c[j];
        }
        num[a] = '\0';
    }
}
 
char const * BigNum::getNum(void) const
{
    return num;
}
 
BigNum BigNum::operator + ( const BigNum &a )
{
    if(num[0]=='+' && a.num[0]=='-')
    {
        BigNum s2(a);
        s2.num[0] = '+';
        return  (*this) - s2;
    }
    if(num[0]=='-' && a.num[0]=='+')
    {
        BigNum s2(a);
        num[0] = '+';
        return s2 - (*this);
    }
    BigNum s;
    int i;
    char s2[N];
    for( i=0; a.num[i]!='\0'; i++)
    {
        s2[i] = a.num[i];
    }
    s2[i] = '\0';
    int len1 = strlen(num);
    int len2 = strlen(s2);
    int Max=0;
    if( len1 > len2)
    {
        Max = len1;
        num[len1] = '0';
        for( i=len2; i<=len1; i++)
        {
            s2[i] = '0';
        }
    }
    else
    {
        if( len1 < len2 )
        {
            Max = len2;
            s2[len2] = '0';
            for( i=len1; i<=len2; i++)
            {
                num[i] = '0';
            }
        }
        else
        {
            Max = len1;
            s2[len2] = '0';
            num[len1] = '0';
        }
    }
    if( (num[0]=='+' && s2[0]=='+') || (num[0]=='-' && s2[0]=='-') )
    {
        for( i=1; i<=Max; i++)
        {
            int c = ( (num[i]-'0') + (s2[i]-'0') );
            if( c>= 10 )
            {
                c -= 10;
                s.num[i] = char( c +'0');
                s2[i+1]++;
            }
            else
            {
                s.num[i] = char( c + '0');
            }
        }
        s.num[i] = '\0';
        if(num[0]=='+' && s2[0]=='+')
        {
            s.num[0] = '+';
        }
        if(num[0]=='-' && s2[0]=='-' )
        {
            s.num[0] = '-';
        }
    }
 
    return s;
}
 
BigNum BigNum::operator - (  BigNum &b )
{
    if(num[0]=='+' && b.num[0]=='-')
    {
        BigNum s2(b);
        s2.num[0] = '+';
        return  (*this) + s2;
    }
    if(num[0]=='-' && b.num[0]=='+')
    {
        BigNum s2(b);
        s2.num[0] = '-';
        return  (*this) + s2;
    }
    BigNum s;
    int i;
    char s2[N];
    for( i=0; b.num[i]!='\0'; i++)
    {
        s2[i] = b.num[i];
    }
    s2[i] = '\0';
    int len1 = strlen(num);
    int len2 = strlen(s2);
    int Max=0;
    if( len1 > len2)
    {
        Max = len1;
        num[len1] = '0';
        for( i=len2; i<=len1; i++)
        {
            s2[i] = '0';
        }
    }
    else
    {
        if( len1 < len2 )
        {
            Max = len2;
            s2[len2] = '0';
            for( i=len1; i<=len2; i++)
            {
                num[i] = '0';
            }
        }
        else
        {
            Max = len1;
            s2[len2] = '0';
            num[len1] = '0';
        }
    }
    if( (num[0]=='+' && s2[0]=='+') || (num[0]=='-' && s2[0]=='-') )
    {
        if(num[0]=='-' && s2[0]=='-')
        {
            s2[0] = '+';
            num[0] = '+';
            for( i=0; num[i]!='\0'; i++ )
            {
                char ch;
                ch = num[i];
                num[i] = s2[i];
                s2[i] = ch;
            }
        }
        char s1[N];
        char s3[N];
        int j;
        for( i=Max,j=0; i>0; j++,i--)
        {
            s1[j] = num[i];
        }
        s1[j] = '\0';
        for( i=Max,j=0; i>0; j++,i--)
        {
            s3[j] = s2[i];
        }
        s3[j] = '\0';
        if( strcmp(s1,s3)>0 )
        {
            s.num[0] = '+';
            for( i=1; i<=Max; i++)
            {
                int c = ( (num[i]-'0') - (s2[i]-'0'));
                if( c<0 )
                {
                    c+=10;
                    s.num[i] = char( c + '0');
                    num[i+1]--;
                }
                else
                {
                    s.num[i] = char( c + '0');
                }
            }
            s.num[i] = '\0';
        }
        else
        {
            if( strcmp(s1,s3)<0 )
            {
                s.num[0] = '-';
                for( i=1; i<=Max; i++)
                {
                    int c = ( (s2[i]-'0') - (num[i]-'0'));
 
                    if( c<0 )
                    {
                        c+=10;
                        s.num[i] = char( c + '0');
 
                        s2[i+1]--;
                    }
                    else
                    {
                        s.num[i] = char( c + '0');
 
                    }
                }
                s.num[i] = '\0';
            }
            else
            {
                s.num[0] = '+';
                s.num[1] = '0';
                s.num[2] = '\0';
            }
        }
    }
    return s;
}
 
void BigNum::show() const
{
    char ch[N] = "+0";
    char c[N] = "+00";
    //cout<<num<<endl;
    if( strcmp(ch,num) == 0 || strcmp(c,num) == 0 )
    {
        cout<<"BigNum("<<ch<<")"<<endl;
    }
    else
    {
        cout<<"BigNum("<<num[0];
        int i;
        int flag;
        for( i=strlen(num)-1; i>=0; i--)
        {
            if(num[i]!='0')
            {
                flag = i;
                break;
            }
        }
        for( i=flag; i>=1; i--)
        {
            cout<<num[i];
        }
        cout<<")"<<endl;
    }
}
源代码3

第四题

以平面图形类Plane为基类公有派生三角形类Triangle，main(void)函数完成对其的测试。

Point类结构说明：
Point类的数据成员包括：
①私有数据成员：X坐标x(double型)，Y坐标y(double型)。
Point类成员函数包括：
①有参构造函数Point(double, double)和拷贝构造函数Point(const  Point  &)，其中有参构造函数参数默认值为0，输出信息“Point Constructor run”，拷贝构造函数输出信息“Point CopyConstructor run”
②析构函数，析构函数输出信息“Point Destructor run”
③公有函数成员void  setX(double)和double getX() const分别返回和设置X坐标
④公有函数成员void  setY(double)和double getY() const分别返回和设置Y坐标
⑤公有成员函数void show() const用于显示点的坐标信息，显示格式为：Point(X=<X坐标>,Y=<Y坐标>)
Plane类结构说明：
抽象类Plane类的成员函数包括：
①纯虚函数virtual double length()const用于计算平面图形的周长
②纯虚函数virtual double area()const用于计算平面图形的面积
Triangle类结构说明：
公有派生三角形类Triangle以平面图形类Plane为基类，Triangle类的结构说明如下：
Triangle类的数据成员包括：
①私有数据成员：A顶点a(Point型)，B顶点b(Point型)，C顶点c(Point型)。
Triangle类成员函数包括：
①有参构造函数Triangle(const Point &, const Point &, const Point &)和拷贝构造函数Triangle(const Triangle &)，其中有参构造函数参数包括3个顶点，默认值为Point(0,0)，输出信息“Triangle Constructor run”，拷贝构造函数输出信息“Triangle CopyConstructor run”
②析构函数，析构函数输出信息“Triangle Destructor run”
③公有函数成员void setA(const Point &)和Point getA()const分别返回和设置A顶点
④公有函数成员void setB(const Point &)和Point getB()const分别返回和设置B顶点
⑤公有函数成员void setC(const Point &)和Point getC()const分别返回和设置C顶点
⑥公有函数成员void show()const用于显示三角形的信息，显示格式为：
Triangle(A=<A顶点>,B=<B顶点>,C=<C顶点>))
⑦重载double area()const用于计算三角形的面积
⑧重载double length()const用于计算三角形的周长
非成员函数说明：
①求两点间距离double pointDis(const Point &p1,const Point &p2)
裁判测试程序样例：
#include <iostream>
#include<cmath>
using namespace std;
//点类Point
class Point{
private:
    double x;
    double y;
public:
    Point(double xv=0,double yv=0);/*构造函数*/
    Point(const Point &p);         /*拷贝构造*/
    ~Point();                      /*析构函数*/
    virtual void show()const;      /*显示*/
    void setX(double xv);          /*设置X坐标*/
    void setY(double yv);          /*设置Y坐标*/
    double getX() const;           /*获取X坐标*/
    double getY() const;           /*获取Y坐标*/
};
Point::Point(const double xv,const double yv){/*构造函数*/
    x=xv;
    y=yv;
    cout<<"Point Constructor run"<<endl;
}
Point::Point(const Point &p){/*拷贝构造*/
    x=p.x;
    y=p.y;
    cout<<"Point CopyConstructor run"<<endl;
}
Point::~Point(){/*析构函数*/
    cout<<"Point Destructor run"<<endl;
}
void Point::show() const{/*显示*/
    cout<<"Point(X="<<x<<",Y="<<y<<")";
}
void Point::setX(double xv){/*设置X坐标*/
    x=xv;
}
void Point::setY(double yv){/*设置Y坐标*/
    y=yv;
}
double Point::getX() const{/*获取X坐标*/
    return x;
}
double Point::getY() const{/*获取Y坐标*/
    return y;
}
class Plane{/*平面图形基类*/
public:
    virtual double length()const=0;/*周长*/
    virtual double area()const=0;  /*面积*/
};

/*请在这里填写答案*/

void length(Plane *p){/*平面图形的周长函数*/
    cout<<"Length="<<p->length()<<endl;
}
void area(Plane &p){/*平面图形的面积函数*/
    cout<<"Area="<<p.area()<<endl;
}
//主函数
int main(void){
    double x,y;
    Point p1,p2(1,1),p3(2,2);
    Triangle t1,t2(t1);
    t1.show();
    cout<<endl;
    area(t1);
    length(&t1);
    cin>>x>>y;
    p1.setX(x);
    p1.setY(y);
    t2.setA(p1);
    t2.setB(p2);
    t2.setC(p3);
    t2.show();
    cout<<endl;
    area(t2);
    length(&t2);
    return 0;
}
输入样例：
3.0  2.0
输出样例：
Point Constructor run
Point Constructor run
Point Constructor run
Point Constructor run
Point Constructor run
Point Constructor run
Point CopyConstructor run
Point CopyConstructor run
Point CopyConstructor run
Triangle Constructor run
Point Destructor run
Point Destructor run
Point Destructor run
Point CopyConstructor run
Point CopyConstructor run
Point CopyConstructor run
Triangle CopyConstructor run
Triangle(A=Point(X=0,Y=0),B=Point(X=0,Y=0),C=Point(X=0,Y=0))
Area=0
Length=0
Triangle(A=Point(X=3,Y=2),B=Point(X=1,Y=1),C=Point(X=2,Y=2))
Area=0.5
Length=4.65028
Triangle Destructor run
Point Destructor run
Point Destructor run
Point Destructor run
Triangle Destructor run
Point Destructor run
Point Destructor run
Point Destructor run
Point Destructor run
Point Destructor run
Point Destructor run

代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
以点类Point及平面图形类Plane为基础设计三角形类Triangle 
double pointDis(const Point &p1,const Point &p2)
{
    return sqrt(pow(p1.getX()-p2.getX(),2)+pow(p1.getY()-p2.getY(),2));

}
class Triangle:public Plane
{
    private:
    Point a;
    Point b;
    Point c;
    public:
    Triangle(const Point &,const Point &,const Point &);
    Triangle(const Triangle &);
    ~Triangle();
    void setA(const Point &);
    Point getA() const;
    void setB(const Point &);
    Point getB() const;
    void setC(const Point &);
    Point getC() const;
    void show() const;
    double area() const;
    double length() const;
};

Triangle::Triangle(const Point &a1=Point(0,0),const Point &b1=Point(0,0),const Point &c1=Point(0,0)):a(a1),b(b1),c(c1)
{
    a=a1;
    b=b1;
    c=c1;
    cout<<"Triangle Constructor run"<<endl;
}
Triangle::Triangle(const Triangle &p):a(p.a),b(p.b),c(p.c)
{
    a=p.a;
    b=p.b;
    c=p.c;
    cout<<"Triangle CopyConstructor run"<<endl;
}
Triangle::~Triangle()
{
    cout<<"Triangle Destructor run"<<endl;
}
void Triangle::setA(const Point &a1)
{
    a=a1;
}
Point Triangle::getA() const
{
    return a;
}
void Triangle::setB(const Point &b1)
{
    b=b1;
}
Point Triangle::getB() const
{
    return b;
}
void Triangle::setC(const Point &c1)
{
    c=c1;
}
Point Triangle::getC() const
{
    return c;
}
void Triangle::show() const
{
    cout<<"Triangle(A=";
    a.show();
    cout<<",B=";
    b.show();
    cout<<",C=";
    c.show();
    cout<<")";
}
double Triangle::area() const
{
    double t=0.5*(pointDis(a,b)+pointDis(a,c)+pointDis(b,c));
    return sqrt(t*(t-pointDis(a,b))*(t-pointDis(a,c))*(t-pointDis(b,c)));
}
double Triangle::length() const
{
    return pointDis(a,b)+pointDis(a,c)+pointDis(b,c);
}
源代码4

第五题

以点类Point及平面图形类Plane为基类公有派生圆类Circle，再以圆类Circle及立体图形类Solid为基类公有派生球类Sphere，main(void)函数完成对球类Sphere的测试。

Point类结构说明：
Point类的数据成员包括：
①私有数据成员：X坐标x(double型)，Y坐标y(double型)。
Point类成员函数包括：
①有参构造函数Point(double, double)和拷贝构造函数Point(const  Point  &)，其中有参构造函数参数默认值为0，输出信息“Point Constructor run”，拷贝构造函数输出信息“Point CopyConstructor run”
②析构函数，析构函数输出信息“Point Destructor run”
③公有函数成员void  setX(double)和double getX() const分别返回和设置X坐标
④公有函数成员void  setY(double)和double getY() const分别返回和设置Y坐标
⑤公有成员函数void show() const用于显示点的坐标信息，显示格式为：Point(X=<X坐标>,Y=<Y坐标>)
Plane类结构说明：
Plane类的成员函数包括：
①纯虚函数virtual double length()const用于计算平面图形的周长
②纯虚函数virtual double area()const用于计算平面图形的面积
Solid类结构说明：
Solid类的成员函数包括：
①纯虚函数virtual double volume()const用于计算立体图形的体积
②纯虚函数virtual double s_Area()const用于计算立体图形的表面积
Circle类结构说明：
在这里描述函数接口。例如：
公有派生圆类Circle以点类Point、平面图形类Plane为基类，Circle类的结构说明如下：
Circle类的数据成员包括：
①圆心坐标继承自Point类
②保护静态数据常量PI(double型)，其值为3.14159
③私有数据成员：半径radius(double型)。
Circle类成员函数包括：
①有参构造函数Circle(double, double, double)和拷贝构造函数Circle(const Circle &)，其中有参构造函数参数包括圆心坐标和半径，圆心调用Point类构造函数进行构造，各参数默认值为0，输出信息“Circle Constructor run”，拷贝构造函数输出信息“Circle CopyConstructor run”
②析构函数，析构函数输出信息“Circle Destructor run”
③公有函数成员void setR(double)和double getR()const分别返回和设置radius
④重载void show()const用于显示圆的信息，显示格式为：
Circle(Point(<圆心X坐标>,<圆心Y坐标>),Radius=<半径>)
⑤重载double area()const用于计算圆的面积
⑥重载double length()const用于计算圆的周长
Sphere类结构说明：
公有派生球类Sphere以圆类Circle、立体图形类Solid为基类，Sphere类的结构说明如下：
Sphere类的数据成员包括：
①基圆继承自Circle类
Sphere类成员函数包括：
①有参构造函数Sphere(double, double, double)和拷贝构造函数Sphere(const Sphere &)，其中有参构造函数参数包括基圆圆心坐标和半径，基圆调用Circle类构造函数进行构造，各参数默认值为0，输出信息“Sphere Constructor run”，拷贝构造函数输出信息“Sphere CopyConstructor run”
②析构函数，析构函数输出信息“Sphere Destructor run”
③重载void show()const用于显示球的信息，显示格式为：
Sphere(Circle(Point(<球心X坐标>,<球心Y坐标>),Radius=<半径>))
④重载double s_Area()const用于计算球的面积
⑤重载double volume()const用于计算球的体积
裁判测试程序样例：
#include <iostream>
using namespace std;
//点类Point
class Point{
private:
    double x;
    double y;
public:
    Point(double xv=0,double yv=0);/*构造函数*/
    Point(const Point &p);         /*拷贝构造*/
    ~Point();                      /*析构函数*/
    void setX(double xv);          /*设置X坐标*/
    void setY(double yv);          /*设置Y坐标*/
    double getX()const;            /*获取X坐标*/
    double getY()const;            /*获取Y坐标*/
    virtual void show()const;      /*显示*/
};
Point::Point(const double xv,const double yv){/*构造函数*/
    x=xv;
    y=yv;
    cout<<"Point Constructor run"<<endl;
}
Point::Point(const Point &p){/*拷贝构造*/
    x=p.x;
    y=p.y;
    cout<<"Point CopyConstructor run"<<endl;
}
Point::~Point(){/*析构函数*/
    cout<<"Point Destructor run"<<endl;
}
void Point::setX(double xv){/*设置X坐标*/
    x=xv;
}
void Point::setY(double yv){/*设置Y坐标*/
    y=yv;
}
double Point::getX()const{/*获取X坐标*/
    return x;
}
double Point::getY()const{/*获取Y坐标*/
    return y;
}
void Point::show()const{/*显示*/
    cout<<"Point(X="<<x<<",Y="<<y<<")";
}
//平面图形类Plane
class Plane{
public:
    virtual double length()const=0;/*周长*/
    virtual double area()const=0;  /*面积*/
};
//立体图形类Solid
class Solid{
public:
    virtual double volume()const=0;/*体积*/
    virtual double s_Area()const=0;/*表面积*/
};

/*请在这里填写答案*/

void show(Point *p){/*点基类的显示函数*/
    p->show();
}
void length(Plane *p){/*平面图形的周长函数*/
    cout<<"Length="<<p->length()<<endl;
}
void area(Plane &p){/*平面图形的面积函数*/
    cout<<"Area="<<p.area()<<endl;
}

void volumn(Solid *s){/*立体图形的体积函数*/
    cout<<"Volumn="<<s->volume()<<endl;
}
void s_Area(Solid &s){/*立体图形的表面积函数*/
    cout<<"S_Area="<<s.s_Area()<<endl;
}
//主函数
int main(void){
    double  r;
    cin>>r;
    Sphere s1(1,2,3),s2(s1);
    show(&s1);
    cout<<endl;
    area(s1);
    length(&s1);
    s_Area(s1);
    volumn(&s1);
    s2.setR(r);
    show(&s2);
    cout<<endl;
    area(s2);
    length(&s2);
    s_Area(s2);
    volumn(&s2);
    return 0;
}
输入样例：
4.0
输出样例：
Point Constructor run
Circle Constructor run
Sphere Constructor run
Point CopyConstructor run
Circle CopyConstructor run
Sphere CopyConstructor run
Sphere(Circle(Point(X=1,Y=2),Radius=3))
Area=28.2743
Length=18.8495
S_Area=113.097
Volumn=113.097
Sphere(Circle(Point(X=1,Y=2),Radius=4))
Area=50.2654
Length=25.1327
S_Area=201.062
Volumn=268.082
Sphere Destructor run
Circle Destructor run
Point Destructor run
Sphere Destructor run
Circle Destructor run
Point Destructor run
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
以圆类Circle及立体图形类Solid为基础设计球类Sphere 
#include <iostream>
using namespace std;
//点类Point
class Point{
private:
    double x;
    double y;
public:
    Point(double xv=0,double yv=0);/*构造函数*/
    Point(const Point &p);         /*拷贝构造*/
    ~Point();                      /*析构函数*/
    void setX(double xv);          /*设置X坐标*/
    void setY(double yv);          /*设置Y坐标*/
    double getX()const;            /*获取X坐标*/
    double getY()const;            /*获取Y坐标*/
    virtual void show()const;      /*显示*/
};
Point::Point(const double xv,const double yv){/*构造函数*/
    x=xv;
    y=yv;
    cout<<"Point Constructor run"<<endl;
}
Point::Point(const Point &p){/*拷贝构造*/
    x=p.x;
    y=p.y;
    cout<<"Point CopyConstructor run"<<endl;
}
Point::~Point(){/*析构函数*/
    cout<<"Point Destructor run"<<endl;
}
void Point::setX(double xv){/*设置X坐标*/
    x=xv;
}
void Point::setY(double yv){/*设置Y坐标*/
    y=yv;
}
double Point::getX()const{/*获取X坐标*/
    return x;
}
double Point::getY()const{/*获取Y坐标*/
    return y;
}
void Point::show()const{/*显示*/
    cout<<"Point(X="<<x<<",Y="<<y<<")";
}
//平面图形类Plane
class Plane{
public:
    virtual double length()const=0;/*周长*/
    virtual double area()const=0;  /*面积*/
};
//立体图形类Solid
class Solid{
public:
    virtual double volume()const=0;/*体积*/
    virtual double s_Area()const=0;/*表面积*/
};

/*请在这里填写答案*/
#define PI 3.14159
class Circle:public Point,public Plane
{
    double x,y;
    protected:
        double radius;
    public:
        Circle(double x1=0,double y1=0,double radius1=0);
        Circle(const Circle &);
        ~Circle();
        void setR(double);
        double getR() const;
        double length() const;
        double area() const;
        void show() const;
};
Circle::Circle(double x1,double y1,double radius1):Point(x1,y1),radius(radius1)
{
    x=x1;
    y=y1;
    cout<<"Circle Constructor run"<<endl;
}
Circle::Circle(const Circle &p):Point(p)
{
    x=p.x;
    y=p.y;
    radius=p.radius;
    cout<<"Circle CopyConstructor run"<<endl;
}
Circle::~Circle()
{
    cout<<"Circle Destructor run"<<endl;
}
void Circle::setR(double radius1)
{
    radius=radius1;
}
double Circle::getR() const
{
    return radius;
}
double Circle::area() const
{
    return PI*radius*radius;
}
double Circle::length() const
{
    return 2*PI*radius;
}
void Circle::show() const
{
    cout << "Sphere(Circle(Point(X=" << x << ",Y=" << y << ")"<<","<<"Radius="<<radius<<"))";
}


class Sphere:public Circle,public Solid
{
    double x,y;
    public:
        Sphere(double x1=0,double y1=0,double r=0);
        Sphere(const Sphere &s);
        ~Sphere();
        double volume() const;
        double s_Area() const;
};

Sphere::Sphere(double x1,double y1,double r):Circle(x1,y1,r)
{
     cout<<"Sphere Constructor run"<<endl;
}
Sphere::Sphere(const Sphere &s):Circle(s)
{
    x=s.x;
    y=s.y;
    radius=s.radius;
    cout<<"Sphere CopyConstructor run"<<endl;
}
Sphere::~Sphere()
{
    cout<<"Sphere Destructor run"<<endl;
}
double Sphere::volume() const
{
    return (4*PI*radius*radius*radius)/3;
}
double Sphere::s_Area() const
{
    return 4*PI*radius*radius;
}


void show(Point *p){/*点基类的显示函数*/
    p->show();
}
void length(Plane *p){/*平面图形的周长函数*/
    cout<<"Length="<<p->length()<<endl;
}
void area(Plane &p){/*平面图形的面积函数*/
    cout<<"Area="<<p.area()<<endl;
}

void volumn(Solid *s){/*立体图形的体积函数*/
    cout<<"Volumn="<<s->volume()<<endl;
}
void s_Area(Solid &s){/*立体图形的表面积函数*/
    cout<<"S_Area="<<s.s_Area()<<endl;
}
//主函数
int main(void){
    double  r;
    cin>>r;
    Sphere s1(1,2,3),s2(s1);
    show(&s1);
    cout<<endl;
    area(s1);
    length(&s1);
    s_Area(s1);
    volumn(&s1);
    s2.setR(r);
    show(&s2);
    cout<<endl;
    area(s2);
    length(&s2);
    s_Area(s2);
    volumn(&s2);
    return 0;
}
源代码5

第六题

以点类Point及平面图形类Plane为基类公有派生圆类Circle，再以圆类Circle及立体图形类Solid为基类公有派生圆柱类Cylinder，main(void)函数完成对圆柱类Cylinder的测试。

Point类结构说明：
Point类的数据成员包括：
①私有数据成员：X坐标x(double型)，Y坐标y(double型)。
Point类成员函数包括：
①有参构造函数Point(double, double)和拷贝构造函数Point(const  Point  &)，其中有参构造函数参数默认值为0，输出信息“Point Constructor run”，拷贝构造函数输出信息“Point CopyConstructor run”
②析构函数，析构函数输出信息“Point Destructor run”
③公有函数成员：void  setX(double)和double getX() const分别返回和设置X坐标
④公有函数成员：void  setY(double)和double getY() const分别返回和设置Y坐标
⑤公有成员函数void show() const用于显示点的坐标信息，显示格式为：Point(X=<X坐标>,Y=<Y坐标>)
Plane类结构说明：
Plane类的成员函数包括：
①纯虚函数virtual double length()const用于计算平面图形的周长
②纯虚函数virtual double area()const用于计算平面图形的面积
Solid类结构说明：
Solid类的成员函数包括：
①纯虚函数virtual double volume()const用于计算立体图形的体积
②纯虚函数virtual double s_Area()const用于计算立体图形的表面积
Circle类结构说明：
公有派生圆类Circle以点类Point、平面图形类Plane为基类，Circle类的结构说明如下：
Circle类的数据成员包括：
①圆心坐标继承自Point类
②保护静态数据常量PI(double型)，其值为3.14159
③私有数据成员：半径radius(double型)。
Circle类成员函数包括：
①有参构造函数Circle(double, double, double)和拷贝构造函数Circle(const Circle &)，其中有参构造函数参数包括圆心坐标和半径，圆心调用Point类构造函数进行构造，各参数默认值为0，输出信息“Circle Constructor run”，拷贝构造函数输出信息“Circle CopyConstructor run”
②析构函数，析构函数输出信息“Circle Destructor run”
③公有函数成员void setR(double)和double getR()const分别返回和设置radius
④重载void show()const用于显示圆的信息，显示格式为：
Circle(Point(<圆心X坐标>,<圆心Y坐标>),Radius=<半径>)
⑤重载double area()const用于计算圆的面积
⑥重载double length()const用于计算圆的周长
Cylinder类结构说明：
公有派生圆柱类Cylinder以圆类Circle、立体图形类Solid为基类，Cylinder类的结构说明如下：
Cylinder类的数据成员包括：
①基圆继承自Circle类
②私有数据成员：高度 height(double型)
Cylinder类成员函数包括：
①有参构造函数Cylinder(double, double, double, double)和拷贝构造函数Cylinder(const Cylinder &)，其中有参构造函数参数包括基圆圆心坐标、半径和高度，基圆调用Circle类构造函数进行构造，各参数默认值为0，输出信息“Cylinder Constructor run”，拷贝构造函数输出信息“Cylinder CopyConstructor run”
②析构函数，析构函数输出信息“Cylinder Destructor run”
③重载void show()const用于显示圆柱的信息，显示格式为：
Cylinder(Circle(Point(<球心X坐标>,<球心Y坐标>),Radius=<半径>),Height=<高度>)
④重载double s_Area()const用于计算圆柱的面积
⑤重载double volume()const用于计算圆柱的体积
裁判测试程序样例：
#include <iostream>
using namespace std;
//点类Point
class Point{
private:
    double x;
    double y;
public:
    Point(double xv=0,double yv=0);/*构造函数*/
    Point(const Point &p);         /*拷贝构造*/
    ~Point();                      /*析构函数*/
    void setX(double xv);          /*设置X坐标*/
    void setY(double yv);          /*设置Y坐标*/
    double getX()const;            /*获取X坐标*/
    double getY()const;            /*获取Y坐标*/
    virtual void show()const;      /*显示*/
};
Point::Point(const double xv,const double yv){/*构造函数*/
    x=xv;
    y=yv;
    cout<<"Point Constructor run"<<endl;
}
Point::Point(const Point &p){/*拷贝构造*/
    x=p.x;
    y=p.y;
    cout<<"Point CopyConstructor run"<<endl;
}
Point::~Point(){/*析构函数*/
    cout<<"Point Destructor run"<<endl;
}
void Point::setX(double xv){/*设置X坐标*/
    x=xv;
}
void Point::setY(double yv){/*设置Y坐标*/
    y=yv;
}
double Point::getX()const{/*获取X坐标*/
    return x;
}
double Point::getY()const{/*获取Y坐标*/
    return y;
}
void Point::show()const{/*显示*/
    cout<<"Point(X="<<x<<",Y="<<y<<")";
}
//平面图形类Plane
class Plane{
public:
    virtual double length()const=0;/*周长*/
    virtual double area()const=0;  /*面积*/
};
//立体图形类Solid
class Solid{
public:
    virtual double volume()const=0;/*体积*/
    virtual double s_Area()const=0;/*表面积*/
};

/*请在这里填写答案*/

void show(Point *p){/*点基类的显示函数*/
    p->show();
}
void length(Plane *p){/*平面图形的周长函数*/
    cout<<"Length="<<p->length()<<endl;
}
void area(Plane &p){/*平面图形的面积函数*/
    cout<<"Area="<<p.area()<<endl;
}

void volumn(Solid *s){/*立体图形的体积函数*/
    cout<<"Volumn="<<s->volume()<<endl;
}
void s_Area(Solid &s){/*立体图形的表面积函数*/
    cout<<"S_Area="<<s.s_Area()<<endl;
}
//主函数
int main(void){
    double  h;
    cin>>h;
    Cylinder cy1(1,2,3,4),cy2(cy1);
    show(&cy1);
    cout<<endl;
    area(cy1);
    length(&cy1);
    s_Area(cy1);
    volumn(&cy1);
    cy2.setH(h);
    show(&cy2);
    cout<<endl;
    area(cy2);
    length(&cy2);
    s_Area(cy2);
    volumn(&cy2);
    return 0;
}
输入样例：
1.0
输出样例：
Point Constructor run
Circle Constructor run
Cylinder Constructor run
Point CopyConstructor run
Circle CopyConstructor run
Cylinder CopyConstructor run
Cylinder(Circle(Point(X=1,Y=2),Radius=3),Height=4)
Area=28.2743
Length=18.8495
S_Area=131.947
Volumn=113.097
Cylinder(Circle(Point(X=1,Y=2),Radius=3),Height=1)
Area=28.2743
Length=18.8495
S_Area=75.3982
Volumn=28.2743
Cylinder Destructor run
Circle Destructor run
Point Destructor run
Cylinder Destructor run
Circle Destructor run
Point Destructor run
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
以圆类Circle及立体图形类Solid为基础设计圆柱类Cylinder 
#include <iostream>
using namespace std;
//点类Point
class Point{
private:
    double x;
    double y;
public:
    Point(double xv=0,double yv=0);/*构造函数*/
    Point(const Point &p);         /*拷贝构造*/
    ~Point();                      /*析构函数*/
    void setX(double xv);          /*设置X坐标*/
    void setY(double yv);          /*设置Y坐标*/
    double getX()const;            /*获取X坐标*/
    double getY()const;            /*获取Y坐标*/
    virtual void show()const;      /*显示*/
};
Point::Point(const double xv,const double yv){/*构造函数*/
    x=xv;
    y=yv;
    cout<<"Point Constructor run"<<endl;
}
Point::Point(const Point &p){/*拷贝构造*/
    x=p.x;
    y=p.y;
    cout<<"Point CopyConstructor run"<<endl;
}
Point::~Point(){/*析构函数*/
    cout<<"Point Destructor run"<<endl;
}
void Point::setX(double xv){/*设置X坐标*/
    x=xv;
}
void Point::setY(double yv){/*设置Y坐标*/
    y=yv;
}
double Point::getX()const{/*获取X坐标*/
    return x;
}
double Point::getY()const{/*获取Y坐标*/
    return y;
}
void Point::show()const{/*显示*/
    cout<<"Point(X="<<x<<",Y="<<y<<")";
}
//平面图形类Plane
class Plane{
public:
    virtual double length()const=0;/*周长*/
    virtual double area()const=0;  /*面积*/
};
//立体图形类Solid
class Solid{
public:
    virtual double volume()const=0;/*体积*/
    virtual double s_Area()const=0;/*表面积*/
};

/*请在这里填写答案*/
#define PI 3.14159
class Circle:public Point,public Plane
{
    double x,y;
    protected:
        double radius;
    public:
        Circle(double x1=0,double y1=0,double radius1=0);
        Circle(const Circle &);
        ~Circle();
        void setR(double);
        double getR() const;
        double length() const;
        double area() const;
        void show() const;
};
Circle::Circle(double x1,double y1,double radius1):Point(x1,y1),radius(radius1)
{
    x=x1;
    y=y1;
    cout<<"Circle Constructor run"<<endl;
}
Circle::Circle(const Circle &p):Point(p)
{
    x=p.x;
    y=p.y;
    radius=p.radius;
    cout<<"Circle CopyConstructor run"<<endl;
}
Circle::~Circle()
{
    cout<<"Circle Destructor run"<<endl;
}
void Circle::setR(double radius1)
{
    radius=radius1;
}
double Circle::getR() const
{
    return radius;
}
double Circle::area() const
{
    return PI*radius*radius;
}
double Circle::length() const
{
    return 2*PI*radius;
}
void Circle::show() const
{
    cout << "Cylinder(Circle(Point(X=" << x << ",Y=" << y << ")"<<","<<"Radius="<<radius<<"))";
}

class Cylinder:public Circle,public Solid
{
    double x,y;
    double height;
    public:
        Cylinder(double x1=0,double y1=0,double r=0,double height1=0);
        Cylinder(const Cylinder &s);
        ~Cylinder();
        double volume()const;
        double s_Area()const;
        void setH(double);
        double getH() const;
        void show() const;
};
Cylinder::Cylinder(double x1,double y1,double r,double height1):Circle(x1,y1,r),height(height)
{
    x=x1;
    y=y1;
    height=height1;
    cout<<"Cylinder Constructor run"<<endl;
}
Cylinder::Cylinder(const Cylinder &s):Circle(s)
{
    x=s.x;
    y=s.y;
    radius=s.radius;
    height=s.height;
    cout<<"Cylinder CopyConstructor run"<<endl;
}
Cylinder::~Cylinder()
{
    cout<<"Cylinder Destructor run"<<endl;
}
double Cylinder::volume() const
{
    return PI*radius*radius*height;
}
double Cylinder::s_Area() const
{
    return 2*PI*radius*radius+2*PI*radius*height;
}
void Cylinder::setH(double height1)
{
    height=height1;
}
double Cylinder::getH() const
{
    return height;
}
void Cylinder::show() const
{
    cout << "Cylinder(Circle(Point(X=" << x << ",Y=" << y << ")"<<","<<"Radius="<<radius<<"),Height="<<height<<")";
}
void show(Point *p){/*点基类的显示函数*/
    p->show();
}
void length(Plane *p){/*平面图形的周长函数*/
    cout<<"Length="<<p->length()<<endl;
}
void area(Plane &p){/*平面图形的面积函数*/
    cout<<"Area="<<p.area()<<endl;
}

void volumn(Solid *s){/*立体图形的体积函数*/
    cout<<"Volumn="<<s->volume()<<endl;
}
void s_Area(Solid &s){/*立体图形的表面积函数*/
    cout<<"S_Area="<<s.s_Area()<<endl;
}
//主函数
int main(void){
    double  h;
    cin>>h;
    Cylinder cy1(1,2,3,4),cy2(cy1);
    show(&cy1);
    cout<<endl;
    area(cy1);
    length(&cy1);
    s_Area(cy1);
    volumn(&cy1);
    cy2.setH(h);
    show(&cy2);
    cout<<endl;
    area(cy2);
    length(&cy2);
    s_Area(cy2);
    volumn(&cy2);
    return 0;
}
源代码6

第七题

以点类Point及平面图形类Plane为基类公有派生圆类Circle，再以圆类Circle及立体图形类Solid为基类公有派生圆锥类Cone，main(void)函数完成对圆锥类Cone的测试。

Point类结构说明：
Point类的数据成员包括：
①私有数据成员：X坐标x(double型)，Y坐标y(double型)。
Point类成员函数包括：
①有参构造函数Point(double, double)和拷贝构造函数Point(const  Point  &)，其中有参构造函数参数默认值为0，输出信息“Point Constructor run”，拷贝构造函数输出信息“Point CopyConstructor run”
②析构函数，析构函数输出信息“Point Destructor run”
③公有函数成员：void  setX(double)和double getX() const分别返回和设置X坐标
④公有函数成员：void  setY(double)和double getY() const分别返回和设置Y坐标
⑤公有成员函数void show() const用于显示点的坐标信息，显示格式为：Point(X=<X坐标>,Y=<Y坐标>)
Plane类结构说明：
Plane类的成员函数包括：
①纯虚函数virtual double length()const用于计算平面图形的周长
②纯虚函数virtual double area()const用于计算平面图形的面积
Solid类结构说明：
Solid类的成员函数包括：
①纯虚函数virtual double volume()const用于计算立体图形的体积
②纯虚函数virtual double s_Area()const用于计算立体图形的表面积
Circle类结构说明：
公有派生圆类Circle以点类Point、平面图形类Plane为基类，Circle类的结构说明如下：
Circle类的数据成员包括：
①圆心坐标继承自Point类
②保护静态数据常量PI(double型)，其值为3.14159
③私有数据成员：半径radius(double型)。
Circle类成员函数包括：
①有参构造函数Circle(double, double, double)和拷贝构造函数Circle(const Circle &)，其中有参构造函数参数包括圆心坐标和半径，圆心调用Point类构造函数进行构造，各参数默认值为0，输出信息“Circle Constructor run”，拷贝构造函数输出信息“Circle CopyConstructor run”
②析构函数，析构函数输出信息“Circle Destructor run”
③公有函数成员void setR(double)和double getR()const分别返回和设置radius
④重载void show()const用于显示圆的信息，显示格式为：
Circle(Point(<圆心X坐标>,<圆心Y坐标>),Radius=<半径>)
⑤重载double area()const用于计算圆的面积
⑥重载double length()const用于计算圆的周长
Cone类结构说明：
公有派生圆锥类Cone以圆类Circle、立体图形类Solid为基类，Cone类的结构说明如下：
Cone类的数据成员包括：
①基圆继承自Circle类
②私有数据成员：高度 height(double型)
Cone类成员函数包括：
①有参构造函数Cone(double, double, double,double)和拷贝构造函数Cone(const Cone &)，其中有参构造函数参数包括基圆圆心坐标、半径和高度，基圆调用Circle类构造函数进行构造，各参数默认值为0，输出信息“Cone Constructor run”，拷贝构造函数输出信息“Cone CopyConstructor run”
②析构函数，析构函数输出信息“Cone Destructor run”
③重载void show()const用于显示圆锥的信息，显示格式为：
Cone(Circle(Point(<球心X坐标>,<球心Y坐标>),Radius=<半径>),Height=<高度>)
④重载double s_Area()const用于计算圆锥的面积
⑤重载double volume()const用于计算圆锥的体积
裁判测试程序样例：
#include <iostream>
#include<cmath>
using namespace std;
//点类Point
class Point{
private:
    double x;
    double y;
public:
    Point(double xv=0,double yv=0);/*构造函数*/
    Point(const Point &p);         /*拷贝构造*/
    ~Point();                      /*析构函数*/
    void setX(double xv);          /*设置X坐标*/
    void setY(double yv);          /*设置Y坐标*/
    double getX()const;            /*获取X坐标*/
    double getY()const;            /*获取Y坐标*/
    virtual void show()const;      /*显示*/
};
Point::Point(const double xv,const double yv){/*构造函数*/
    x=xv;
    y=yv;
    cout<<"Point Constructor run"<<endl;
}
Point::Point(const Point &p){/*拷贝构造*/
    x=p.x;
    y=p.y;
    cout<<"Point CopyConstructor run"<<endl;
}
Point::~Point(){/*析构函数*/
    cout<<"Point Destructor run"<<endl;
}
void Point::setX(double xv){/*设置X坐标*/
    x=xv;
}
void Point::setY(double yv){/*设置Y坐标*/
    y=yv;
}
double Point::getX()const{/*获取X坐标*/
    return x;
}
double Point::getY()const{/*获取Y坐标*/
    return y;
}
void Point::show()const{/*显示*/
    cout<<"Point(X="<<x<<",Y="<<y<<")";
}
//平面图形类Plane
class Plane{
public:
    virtual double length()const=0;/*周长*/
    virtual double area()const=0;  /*面积*/
};
//立体图形类Solid
class Solid{
public:
    virtual double volume()const=0;/*体积*/
    virtual double s_Area()const=0;/*表面积*/
};

/*请在这里填写答案*/

void show(Point *p){/*点基类的显示函数*/
    p->show();
}
void length(Plane *p){/*平面图形的周长函数*/
    cout<<"Length="<<p->length()<<endl;
}
void area(Plane &p){/*平面图形的面积函数*/
    cout<<"Area="<<p.area()<<endl;
}

void volumn(Solid *s){/*立体图形的体积函数*/
    cout<<"Volumn="<<s->volume()<<endl;
}
void s_Area(Solid &s){/*立体图形的表面积函数*/
    cout<<"S_Area="<<s.s_Area()<<endl;
}
//主函数
int main(void){
    double  h;
    cin>>h;
    Cone co1(1,2,3,4),co2(co1);
    show(&co1);
    cout<<endl;
    area(co1);
    length(&co1);
    s_Area(co1);
    volumn(&co1);
    co2.setH(h);
    show(&co2);
    cout<<endl;
    area(co2);
    length(&co2);
    s_Area(co2);
    volumn(&co2);
    return 0;
}
输入样例：
1.0
输出样例：
Point Constructor run
Circle Constructor run
Cone Constructor run
Point CopyConstructor run
Circle CopyConstructor run
Cone CopyConstructor run
Cone(Circle(Point(X=1,Y=2),Radius=3),Height=4)
Area=28.2743
Length=18.8495
S_Area=75.3982
Volumn=37.6991
Cone(Circle(Point(X=1,Y=2),Radius=3),Height=1)
Area=28.2743
Length=18.8495
S_Area=58.078
Volumn=9.42477
Cone Destructor run
Circle Destructor run
Point Destructor run
Cone Destructor run
Circle Destructor run
Point Destructor run
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
以圆类Circle及立体图形类Solid为基础设计圆锥类Cone 
#include <iostream>
#include<cmath>
using namespace std;
//点类Point
class Point{
private:
    double x;
    double y;
public:
    Point(double xv=0,double yv=0);/*构造函数*/
    Point(const Point &p);         /*拷贝构造*/
    ~Point();                      /*析构函数*/
    void setX(double xv);          /*设置X坐标*/
    void setY(double yv);          /*设置Y坐标*/
    double getX()const;            /*获取X坐标*/
    double getY()const;            /*获取Y坐标*/
    virtual void show()const;      /*显示*/
};
Point::Point(const double xv,const double yv){/*构造函数*/
    x=xv;
    y=yv;
    cout<<"Point Constructor run"<<endl;
}
Point::Point(const Point &p){/*拷贝构造*/
    x=p.x;
    y=p.y;
    cout<<"Point CopyConstructor run"<<endl;
}
Point::~Point(){/*析构函数*/
    cout<<"Point Destructor run"<<endl;
}
void Point::setX(double xv){/*设置X坐标*/
    x=xv;
}
void Point::setY(double yv){/*设置Y坐标*/
    y=yv;
}
double Point::getX()const{/*获取X坐标*/
    return x;
}
double Point::getY()const{/*获取Y坐标*/
    return y;
}
void Point::show()const{/*显示*/
    cout<<"Point(X="<<x<<",Y="<<y<<")";
}
//平面图形类Plane
class Plane{
public:
    virtual double length()const=0;/*周长*/
    virtual double area()const=0;  /*面积*/
};
//立体图形类Solid
class Solid{
public:
    virtual double volume()const=0;/*体积*/
    virtual double s_Area()const=0;/*表面积*/
};

/*请在这里填写答案*/
class Circle: public Point, public Plane {
protected:
static const double PI;
double radius;
public:
Circle(double x = 0, double y = 0, double radius = 0)
:Point(x, y), radius(radius) {
cout << "Circle Constructor run" << endl;
}
Circle(const Circle& c) :Point(c), radius(c.radius) {
cout << "Circle CopyConstructor run" << endl;
}
~Circle() {
cout << "Circle Destructor run" << endl;
}
void setR(double radius) {
this->radius = radius;
}
double getR() const {
return radius;
}
void show() const {
cout << "Circle(";
Point::show();
cout << ",Radius=" << radius << ")";
}
double area() const {
return PI * radius * radius;
}
double length() const {
return 2 * PI * radius;
}

};
const double Circle::PI = 3.14159;

class Cone: public Circle, public Solid {
private:
double height;
public:
Cone(double x = 0, double y = 0, double radius = 0, double height = 0)
:Circle(x, y, radius), height(height) {
cout << "Cone Constructor run" << endl;
}
Cone(const Cone& c) :Circle(c), height(c.height) {
cout << "Cone CopyConstructor run" << endl;
}
~Cone() {
cout << "Cone Destructor run" << endl;
}
void setH(double height) {
this->height = height;
}
void show() const {
cout << "Cone(";
Circle::show();
cout << ",Height=" << height << ")";
}
double s_Area() const {
return PI * radius * (radius + sqrt(radius * radius + height * height));
}
double volume() const {
return PI * radius * radius * height / 3;
}
};

void show(Point *p){/*点基类的显示函数*/
    p->show();
}
void length(Plane *p){/*平面图形的周长函数*/
    cout<<"Length="<<p->length()<<endl;
}
void area(Plane &p){/*平面图形的面积函数*/
    cout<<"Area="<<p.area()<<endl;
}

void volumn(Solid *s){/*立体图形的体积函数*/
    cout<<"Volumn="<<s->volume()<<endl;
}
void s_Area(Solid &s){/*立体图形的表面积函数*/
    cout<<"S_Area="<<s.s_Area()<<endl;
}
//主函数
int main(void){
    double  h;
    cin>>h;
    Cone co1(1,2,3,4),co2(co1);
    show(&co1);
    cout<<endl;
    area(co1);
    length(&co1);
    s_Area(co1);
    volumn(&co1);
    co2.setH(h);
    show(&co2);
    cout<<endl;
    area(co2);
    length(&co2);
    s_Area(co2);
    volumn(&co2);
    return 0;
}
源代码7

总结：运算符重载是对已有的运算符赋予多重含义，使用已有运算符对用户自定义类型进行操作，虚函数使得同一个函数在不同的类中具有不同的实现，从而实现多态性和代码重用，代码灵活性更高，程序扩展性更强。

每日一mo：原来“疾风知劲草，智者必怀仁”的“必”是必要条件.....

标签：const,函数,Point,double,void,c++,第十七,坐牢,构造函数
From： https://www.cnblogs.com/R-f-12/p/17444931.html

相关文章

  • C/C++数据结构课程设计[2023-05-31]
    C/C++数据结构课程设计[2023-05-31]数据结构课程设计实验（训）指导书所在学院：计算机科学与工程学院编写说明一．实验总体目标《数据结构》是一门实践性较强的课程，为了学好这门课程，必须在掌握理论知识的同时，加强上机实践。本实验的目标是，学生能正确理解和熟练掌握常用数据结构和算......
  • C++四种强制类型详解
    向上转型（上行转换）派生类对象转换为基类对象（包括指针和对象），直接转换由编译器完成，是绝对安全的内存里面：基类对象相当于只是换了个地址，换成了派生类中存储基类成员的内存地址，但是派生类对象中有的，基类没有的变量仍然存在内存中（保留了再次从基类转换成派生类的可能性）向下转型（下行......
  • C/C++杂记：运行时类型识别（RTTI）与动态类型转换原理
    运行时类型识别（RTTI）的引入有三个作用：配合typeid操作符的实现；实现异常处理中catch的匹配过程；实现动态类型转换dynamic_cast。1.typeid操作符的实现1.1.静态类型的情形C++中支持使用typeid关键字获取对象类型信息，它的返回值类型是conststd::type_info&，例：#include<type......
  • C/C++杂记：虚函数的实现的基本原理
    1.概述简单地说，每一个含有虚函数（无论是其本身的，还是继承而来的）的类都至少有一个与之对应的虚函数表，其中存放着该类所有的虚函数对应的函数指针。例：其中：B的虚函数表中存放着B::foo和B::bar两个函数指针。D的虚函数表中存放的既有继承自B的虚函数B::foo，又有重写（override）了基......
  • C/C++杂记：深入理解数据成员指针、函数成员指针
    1.数据成员指针对于普通指针变量来说，其值是它所指向的地址，0表示空指针。而对于数据成员指针变量来说，其值是数据成员所在地址相对于对象起始地址的偏移值，空指针用-1表示。例：代码示例：structX{inta;intb;};#defineVALUE_OF_PTR(p)(*(long*)&p)int......
  • 【C++】c++单继承、多继承、菱形继承内存布局（虚函数表结构）
    单继承：只有一个基类和一个派生类classBase{public:virtualvoidfun1(){cout<<"Base::func1()"<<endl;}virtualvoidfun2(){cout<<"Base::func2()"<<endl;}private:intb;......
  • C++ 在函数内部输出当前类名方式
    开发环境：QtCreator C++1usingnamespacestd;23/*基类汽车*/4classCar5{6public:7Car(){}8virtual~Car(){}9virtualvoidmove(void);10};1112/*基本属性汽车运动*/13voidCar::move(void)14{15cout<<......
  • C++多态虚函数表详解(多重继承、多继承情况)
    本文关键词：C++多态多继承多重继承虚函数表虚函数指针动态绑定概述：C++相对其他面向对象语言来说，之所以灵活、高效。很大程度的占比在于其多态技术和模板技术。C++虚函数表是支撑C++多态的重要技术，它是C++动态绑定技术的核心。本文章将着重图解虚函数表相关知识，在阅读本文......
  • c++中的析构函数和纯虚函数
    析构函数：c++中当delete一个类对象时，会默认调用其析构函数，析构函数的作用就是释放对象占用的堆空间。一般基类的析构函数需写成虚函数，这是因为在多态下，我们一般用基类的指针来指向一个子类对象，若基类的虚函数未被重写，那么可能会造成内存泄漏。因此需要在子类重写基类的虚函数来......
  • 【c&c++】erase怎么用c语言,C++ erase()函数使用时的注意点
    遇见的场景删除vector容器指定元素时；erase()函数的用法vector::erase()：从指定容器删除指定位置的元素或某段范围内的元素。具体用法如下：iteratorerase(iterator_Where);删除指定位置的元素，返回值是一个迭代器，指向删除元素的下一个元素；iteratorerase(iterator_First,i......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99