精华内容
下载资源
问答
  • 面向对象相关描述

    2017-07-08 20:20:15
    以下关于面向对象的描述错误的是正确答案: C 面向对象的基本特性是封装,继承和多态 构造函数不可以是虚函数,析构函数可以是虚函数 子类重新定义父类虚函数的方法叫做重载 多态是...
    以下关于面向对象的描述错误的是:

    正确答案: C   

    面向对象的基本特性是封装,继承和多态
    构造函数不可以是虚函数,析构函数可以是虚函数
    子类重新定义父类虚函数的方法叫做重载
    多态是为了接口重用,封装和继承是为了代码重用
    解析:

    对于C++中经常出现的函数名称相同但是参数列表或者返回值不同的函数,主要存在三种情况:

    1.函数重写(override)

    函数重载主要实现了父类与子类之间的多态性,子类中定义与父类中名称和参数以及返回值都相同的虚函数。

    1)重写的函数不能是static函数,必须是virtual函数,即函数在原始的基类中被声明为虚函数;

    2)重写函数与基类函数分在两个类的声明和定义中,这也就导致二者的作用域不同;

    3)重写函数的名称、参数列表以及返回值(即函数原型)都要与基类的函数相同;

    4)重写函数的访问修饰符可以不同,尽管virtual函数是private的,在派生类中重写的函数可以是public或protect的

    2.函数重载(overload)

    指函数名称相同但是参数类型或者参数顺序不同的相同作用域中的函数,函数重载不能靠返回值来进行区分;

    3.重定义(redefine)

    指子类重新定义父类中的非虚函数(参数列表可以不同),这样父类中的对应函数将被隐藏。

    二、重写(override)与重载(overload)的区别

    1、函数重写是子类和父类之间的继承关系,是垂直关系;方法的重载是同一个类中方法之间的关系,是水平关系;

    2、重写需要子类和父类中的两个函数的函数原型完全相同;重载要求两个函数参数列表不同;

    3、在重写关系中,调用具体调用哪一个函数是根据(对象对应存储空间的实际类型)为准的,这涉及到动态绑定和静态绑定的问题,也就是虚函数的调用机制,而函数重载主要是靠形参列表的不同来区分具体调用哪个函数的。


    展开全文
  • 对象声明描述的是存 储在对象的信息以及可对对象执行的操作(类方法)。对象的某些组成部分对于外界来说是可见的(公有部 分),而某些部分却是隐藏的(私有部分)。特殊的类方法(构造函数和析构函数)在对象创建和释放...
  • 对象声明描述的是存 储在对象的信息以及可对对象执行的操作(类方法)。对象的某些组成部分对于外界来说是可见的(公有部 分),而某些部分却是隐藏的(私有部分)。特殊的类方法(构造函数和析构函数)在对象创建和释放...
  • 对象声明描述的是存 储在对象的信息以及可对对象执行的操作(类方法)。对象的某些组成部分对于外界来说是可见的(公有部 分),而某些部分却是隐藏的(私有部分)。特殊的类方法(构造函数和析构函数)在对象创建和释放...
  • 对象声明描述的是存 储在对象的信息以及可对对象执行的操作(类方法)。对象的某些组成部分对于外界来说是可见的(公有部 分),而某些部分却是隐藏的(私有部分)。特殊的类方法(构造函数和析构函数)在对象创建和释放...
  • c++选择题(选择题)

    千次阅读 2020-07-07 08:37:21
    关于纯虚函数和抽象类的描述中,(C )是错误的。 A.纯虚函数是一种特殊的虚函数,它没有具体的实现 B.抽象类是指具有纯虚函数的类 C.一个基类中说明有纯虚函数,该基类的派生类一定不再是抽象类 D.抽象类只能...

    2-1

    关于纯虚函数和抽象类的描述中,(C )是错误的。

    A.纯虚函数是一种特殊的虚函数,它没有具体的实现

    B.抽象类是指具有纯虚函数的类

    C.一个基类中说明有纯虚函数,该基类的派生类一定不再是抽象类

    D.抽象类只能作为基类来使用,其纯虚函数的实现由派生类给出


    2-2

    下列描述中,( D)是抽象类的特性。

    A可以说明虚函数

    B可以进行构造函数重载

    C.可以定义友元函数

    D.不能定义该类对象


    2-3

    在下面类声明中,关于生成对象不正确的是( )。 class point { public: int x; int y; point(int a,int b) {x=a;y=b;}

    };

    A.point p(10,2);

    B.point *p=new point(1,2);

    C.point *p=new point[2];

    D.point *p[2]={new point(1,2), new point(3,4)};


    2-4

    下列运算符中,( )运算符不能重载。

    A.&&

    B.[ ]

    C.::

    D.<<

     


    2-5

    在下列关键字中,用以说明类中公有成员的是(A )。

    A.public

    B.private

    C.protected

    D.friend

     


    2-6

    下列叙述中,不正确的是( C)。

    A.构造函数必须和类同名

    B.构造函数和析构函数都没有返回值

    C.析构函数中不能加代码

    D.析构函数不能带参数

     


    2-7

    在公有继承的情况下,在派生类中能够访问的基类成员包括(C)

    A.公有成员

    B.保护成员

    C.公有成员、保护成员和私有成员

    D.公有成员和保护成员


    2-8

    以下关于异常处理的描述错误的是()。

    A.C++程序中出现异常时,编译器不会进行提示

    B.将可能产生异常的代码放在try语句块内

    C.使用catch关键字接收并处理异常

    D.重抛异常可以在try语句块或者catch语句块中调用throw实现

     


    2-9

    假设声明了一下的函数模板:

    template<class T>
    T max(T x, T y)
    {
        return  (x>y)?x:y;
    }

    并定义了int i; char c;

    错误的调用语句是(C)。

    A.max(i,i);

    B.max(c,c);

    C.max((int)c,i);

    D.max(i,c);

     


    2-10

    下面是关于ios 类的叙述,正确的是(A )。

    A.它是istream 类和ostream 类的虚基类

    B.它只是istream 类的虚基类

    C.它只是ostream 类的虚基类

    D.它是iostrearm 类的虚基类

    1-1

    多数运算符可以重载,个别运算符不能重载,运算符重载是通过函数定义实现的(T)


    1-2

    this 指针是一个系统预定义的特殊指针,指向当前正在操作的对象(T)


    1-3

    在多继承中,派生类的构造函数需要依次调用其基类的构造函数,调用顺序取决于定义派生类时所指定的各基类的顺序。(T)


    1-4

    虚函数是用virtual 关键字说明的成员函数。(T)


    1-5

    一个类的友元函数可以访问该类的私有成员。(T)


    1-6

    静态数据成员不属于某个对象,在给对象分配存储空间时,不包括静态数据成员所占的空间。(T)

     


    1-7

    模板函数可以用同名的另一模板函数重载。(T)

    2-1

    能用友元函数重载的运算符是(A)

    A.+

    B.=

    C.[]

    D.->


    2-2

    如何区分自增运算符重载的前置形式和后置形式?(B)

    A.重载时,前置形式的函数名是++operator,后置形式的函数名是operator ++

    B.后置形式比前置形式多一个 int 类型的参数

    C.无法区分,使用时不管前置形式还是后置形式,都调用相同的重载函数

    D.前置形式比后置形式多一个 int 类型的参数

    2-1

    关于纯虚函数和抽象类的描述中,(C )是错误的。

    A.纯虚函数是一种特殊的虚函数,它没有具体的实现

    B.抽象类是指具有纯虚函数的类

    C.一个基类中说明有纯虚函数,该基类的派生类一定不再是抽象类

    D.抽象类只能作为基类来使用,其纯虚函数的实现由派生类给出


    2-2

    建立派生类对象时, 3种构造函数分别是a(基类的构造函数)、b(成员对象的构造函数)、c(派生类的构造函数),这3种构造函数的调用顺序为(A)

    A.abc

    B.acb

    C.cab

    D.cba


    2-3下面关于继承和派生的构造函数和析构函数的程序,输出结果是(A)

    ```C++ #include using namespace std;

    class AA { public: AA() { cout << "A"; } ~AA() { cout << "a"; } };

    class BB: public AA { AA aa; public: BB() { cout << "B"; } ~BB() { cout << "b"; } };

    int main() { BB bb; return 0; }

    ```

    A.AABaab/这里有两个A的原因是一个是基类的,一个 是派生类的

    B.AABbaa

    C.BAAaab

    D.BAAbaa


    2-4

    在公有派生的前提下,下列说法错误的是(D)。

    A.在一个赋值语句中,等号的左边是一个基类对象时,右边可以是一个派生类对象

    B.若B是A的派生类,且有默认的构造函数,则语句A &a = new B是正确的

    C.在一个返回值为基类指针的函数中,可以返回一个派生类对象的地址

    D.在调用一个形参类型为派生类引用的函数时,可以将一个基类对象作为实参


    2-5

    多继承是指(A)。

    A.一个派生类同时继承多个基类

    B.多个派生类同时继承一个基类

    C.基类本身又是一个更高一级基类的派生类

    D.派生类本身又是更低一级派生类的基类


    2-6

    设有如下代码段:

    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();
    }

    则输出结果为:(B)

    A.A1 A2

    B.A1 B2

    C.B1 A2

    D.B1 B2


    2-7

    如果在基类中将show声明为不带返回值的纯虚函数,正确的写法是(C)。

    A.virtual show()=0;

    B.virtual void show();

    C.virtual void show()=0;

    D.void show()=0 virtual;


    2-8

    class X{ int a; public: X(int x=0) {a=x;} }; class Y:public X { int b; public: Y(int x=0,int y=0):X(y)) { b=x;} };

     下述语句存在错误的是( D )<div class="pc-text ml-2 pc-color-light inline select-none" data-reactroot=""><div class="pc-text-raw">(2分)</div></div>

    A.X *pa=new Y(1,2);

    B.X a1=Y(1,3);

    C.Y b1(2,3); X & a3=b1;

    D.X a4(10); Y b2=a4;


    2-9

    如果多种事物,有一些共同的特点又各自不同的特点,如何编写类来代表这些事物比较合适?(C)

    A.为每种事物独立编写一个类,各之间互相无关

    B.写一个类代表其中一种事物,代表其他事物的类都从这个类派生出来

    C.概括所有事物的共同特点,写一个基类。然后为每种事物写一个类,都从基派生而来

    D.一共就写一个类,包含所有事物的所有特点,然后用一个成员变量作为标记,来区分不同种类的事物


    2-10

    若派生类的成员函数不能直接访问基类中的某个成员,则该成员一定是基类中的(A)。

    A.私有成员

    B.公有成员

    C.保护成员

    D.私有成员或保护成员

     

    1-1

    函数的参数个数和类型都相同,只是返回值不同,这不是重载函数。(F)


    1-2

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


    1-3

    预定义的提取符和插入符是可以重载的。(T)


    1-4

    动态联编调用函数操作是指向对象的指针或对象引用。(T)


    1-5

    不考虑成员变量对齐问题,对象所占用的存储空间的大小等于各成员变量所占用的存储空间大小之和。(T)

     


    1-6

    复制构造函数只有一个参数,类型是同类的引用。(T)


    1-7

    在构造函数和析构函数中调用虚函数是多态。(F)


    1-8

    类模板中的成员函数不可以是函数模板。(F)


    1-9

    "catch(...)"能匹配任何类型的异常。(T)


    1-10

    string是C++的基本数据类型。(F)


     


     


     

    2-1

    关于纯虚函数和抽象类的描述中,(C )是错误的。

    A.纯虚函数是一种特殊的虚函数,它没有具体的实现

    B.抽象类是指具有纯虚函数的类

    C.一个基类中说明有纯虚函数,该基类的派生类一定不再是抽象类

    D.抽象类只能作为基类来使用,其纯虚函数的实现由派生类给出


    2-2

    在下面有关静态成员函数的描述中,正确的是(A)。

    A.在建立对象前,就可以为静态数据成员赋值

    B.静态成员函数在类外定义时要用static前缀

    C.静态成员函数只能在类外定义

    D.在静态成员函数中可以使用this指针


    2-3

    设有基类定义: class Cbase { private: int a; protected: int b; public: int c;

    };派生类采用何种继承方式可以使成员变量b成为自己的私有成员( C)

    A.保护继承

    B.公有继承

    C.私有继承

    D.私有、保护、公有均可


    2-4

    关于函数模板,描述错误的是( B)。

    A.函数模板的实例化由编译器实现

    B.函数模板必须由程序员实例化为可执行的函数模板

    C.类模板的成员函数都是函数模板,类模板实例化后,成员函数也随之实例化

    D.一个类定义中,只要有一个函数模板,这个类就是类模板


    2-5

    const int *p说明不能修改(B)。

    A.p指针;

    B.p指针指向的变量;

    C.p指针指向的数据类型;

    D.上述A、B、C三者;


    2-6

    下列关于继承的描述中,错误的是( D)。

    A.析构函数不能被继承

    B.派生类是基类的组合

    C.派生类的成员除了它自己的成员外,还包含了它的基类的成员

    D.派生类中继承的基类成员的访问权限到派生类保持不变


    2-7

    设类AA已定义,假设以下语句全部合法,哪些语句会触发调用拷贝构造函数( D)。

    ``` AA a, b; //1 AA c(10, 20); //2 AA d(c); //3 AA e = d; //4

    ```

    A.2

    B.3

    C.4

    D.3 和 4


    2-8

    创建一个类A;然后通过继承的方式由类A派生出类B,则下列关于派生中构造函数和析构函数的描述中正确的是:(C)

    A.类B继承了类A的构造函数

    B.类B继承了类A的析构函数

    C.创建类B的对象时,先执行类A的构造函数,然后执行类B的构造函数

    D.撤销类B的对象时,先执行类A的析构函数,然后执行类B的析构函数


    2-9

    以下关于友元的说法哪个是不正确的?(B)

    A.一个类的友元函数可以访问类对象的私有成员

    B.友元类关系是相互的,即若类A是类B 的友元,类B也是类A的友元

    C.在一个类中可以将另一个类的成员函数声明为友元

    D.类之间的友元关系不能传递


    2-10

    如何区分自增运算符重载的前置形式和后置形式?(B)

    A.重载时,前置形式的函数名是++operator,后置形式的函数名是operator ++

    B.后置形式比前置形式多一个 int 类型的参数

    C.无法区分,使用时不管前置形式还是后置形式,都调用相同的重载函数

    D.前置形式比后置形式多一个 int 类型的参数


    2-11

    有如下的类定义:

    class Sample
    {
    public:
        Sample( );
        Sample(int x );
        ......    
    };
    

    动态申请对象存储单元,调用无参构造函数的语句是(C)。

    A.Sample *a=new Sample(2);

    B.Sample a=new Sample( );

    C.Sample *a=new Sample;

    D.Sample a=new Sample;


    2-12

    下列关于异常类的说法中,错误的是。(A)

    A.异常类由标准库提供,不可以自定义

    B.C++的异常处理机制具有为抛出异常前构造的所有局部对象自动调用析构函数的能力

    C.若catch块采用异常类对象接收异常信息,则在抛出异常时将通过拷贝构造函数进行对象复制,异常处理完后才将两个异常对象进行析构,释放资源

    D.异常类对象抛出后,catch块会用类对象引用接收它以便执行相应的处理动作


    2-13

    下面是关于ios 类的叙述,正确的是( A)。

    A.它是istream 类和ostream 类的虚基类

    B.它只是istream 类的虚基类

    C.它只是ostream 类的虚基类

    D.它是iostrearm 类的虚基类


     


     


    2-14

    当使用ifstream 流类定义一个流对象并打开一个磁盘文件时,文件的隐含打开方式为( A)。

    A.ios::in

    B.ios::out

    C.ios::in|ios::out

    D.ios::binary


    2-15

    下面小段程序和各项说法中,哪个是正确的(B)

    A.char * p = new char[ ]; p[0] = 'K'; delete p;

    B.int n = 8; int & r1 = n; const int & r2 = r1;

    C.在派生类的各个成员函数中,可以访问基类中的private成员;

    D一个类只能包含一个构造函数;

    1-1

    函数的参数个数和类型都相同,只是返回值不同,这不是重载函数。(T)


    1-2

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


    1-3

    预定义的提取符和插入符是可以重载的。(T)


    1-4

    动态联编调用函数操作是指向对象的指针或对象引用。(T)


    1-5

    不考虑成员变量对齐问题,对象所占用的存储空间的大小等于各成员变量所占用的存储空间大小之和。(T)


    1-6

    复制构造函数只有一个参数,类型是同类的引用。(T)


    1-7

    在构造函数和析构函数中调用虚函数是多态。(F)


    1-8

    类模板中的成员函数不可以是函数模板。(F)


    1-9

    "catch(...)"能匹配任何类型的异常。(T)


    1-10

    string是C++的基本数据类型。(F)

     

     

     

     

     

     

     

     

    展开全文
  • 18.关于虚函数的描述,抽象类论述 7 20. 关于read( ) , write( )函数的描述 7 二、程序错误 7 三、阅读程序写运行结果、程序填空 10 6. 12 Time(int s=0, int m=0, int h=0) { 12 Time operator +(Time t1, Time t2...
  • 真正侯捷《深入浅出mfc》chm版

    热门讨论 2010-05-05 22:08:42
    改写OnDismiss 虚函数,在其中定义macros /389 修改text template/389 Top Studio AppWizard执行结果/390 更多信息/390 第16章 站上众人肩膀—使用Components和ActiveX Controls/391 什么是Component ...
  • 8.8 SQL中的视图(表) 187 8.8.1 SQL视图概念 187 8.8.2 SQL中的视图规范 188 8.8.3 视图实现和更新 188 8.9 SQL其他特性 190 8.10 小结 190 复习题 192 练习题 192 实验题 194...
  • 翻译过程,译者感到此言不:作者从数据库基本概念到数据库建模,从如何运用规范化原则到如何做成实际数据库表,从如何保护数据库完整性到如何提高数据库性能,从数据库安全机制到并发事务控制,从...
  • 翻译过程,译者感到此言不:作者从数据库基本概念到数据库建模,从如何运用规范化原则到如何做成实际数据库表,从如何保护数据库完整性到如何提高数据库性能,从数据库安全机制到并发事务控制,从...
  • 2 (3分)关于基类成员在派生类的访问权限,下列描述正确的是 ‍ 在保护继承方式下,基类私有成员在派生类中转为保护成员 ‍ 在私有继承方式下,基类的私有成员在派生类不能直接访问。 ‍ 在公有继承方式下...

    1 (3分)下列无法实现类的多态性的是
    友元类
    ‍ 虚函数
    ‍ 运算符重载
    ‍ 函数重载

    2 (3分)关于基类成员在派生类中的访问权限,下列描述不正确的是
    在保护继承方式下,基类中私有成员在派生类中转为保护成员
    ‍ 在私有继承方式下,基类中的私有成员在派生类中不能直接访问。
    ‍ 在公有继承方式下,基类中的私有成员在派生类中不能直接访问。
    ‍ 在保护继承方式下,基类中保护成员在派生类中仍为保护成员。

    3 (3分)下列描述错误的是
    ‍ 虚基类只能被继承一次
    ‍ 基类和派生类之间是继承关系
    基类中包含派生类的成员
    ‍ 派生类对基类的继承有多种不同的方式

    4 (3分)关于对象指针与对象引用做参数,描述正确的是
    ‍ 对象指针做参数效率更高
    ‍ 对象引用做参数效率更高
    对象指针做参数代码更加直观
    ‍ 对象引用和对象指针都能够实现传址

    5 (3分)下列运算符中,只能通过成员函数进行重载的是:
    赋值运算符
    ‍ 关系运算符
    ‍ 自增运算符
    ‍ 输入输出运算符

    6 (3分)关于返回值优化描述不正确的是:
    ‍ 通过传值方式返回创建的新对象时,编译器会采用返回值优化策略
    ‍ 在返回值优化策略中,编译器直接把这个对象创建在外部返回值的存储单元中
    执行语句{Integer temp(left.i + right.i);return temp;}采用的是返回值优化策略
    ‍ 返回值优化策略能提高运行效率

    7 (3分)关于类类的数据成员描述错误的是:
    ‍ 常数据成员的初始化必须在构造函数中
    ‍ 常数据成员的值不能被改变
    静态数据成员的初始化必须在构造函数中
    ‍ 静态数据成员的作用域与类的对象生命周期无关

    8 (3分)关于设置参数的默认值,描述错误的是:
    ‍ 成员函数的参数可以设置为默认值。
    ‍ 可以给一个或多个参数设置默认值;
    ‍ 指定了默认值的参数的右边,不能出现没有指定默认值的参数
    一定定义了设置了默认值的构造函数,还需提供默认构造函数的定义

    9 (5分)以下描述正确的是
    模板是一种代码重用的方法
    ‍ 模板可以编译执行
    函数模板与其他函数模板之间可以重载
    函数模板与其他非模板函数之间可以重载

    10 (5分)以下关于抽象的描述,正确的是
    函数是对一系列操作的抽象
    ‍ 函数模板是对近似功能的函数的抽象
    ‍ 类是对具有相同属性和行为的对象的抽象
    ‍ 类模板是对近似功能的多个类的进一步抽象

    运算符重载之复数类填空

    试题描述

    定义复数Complex类,并重载单目减号运算符、双目+、-、*运算符函数为Complex类的成员函数。请仔细阅读代码,填写下面空白。

    ①    //必要的头文件等,可能为多条语句
    ②    //复数Complex类
    {
       ③    //保护数据成员:int类型的real、image,分别代表实部、虚部
    
       ④    //带有两个参数的构造函数,参数默认值均为0;在初始化列表中将形参赋给对应的数据成员
    
       ⑤    //输出Show()常成员函数,注意保持合理的复数输出格式
    
       ⑥    //双目+运算符重载常成员函数,有一个参数(Complex类型对象z2的常引用)
    
       ⑦    //双目-运算符重载常成员函数,有一个参数(Complex类型对象z2的常引用)
    
       ⑧    //双目*运算符重载常成员函数,有一个参数(Complex类型对象z2的常引用)
    
       ⑨    //单目-运算符重载常成员函数,无参数
    };
    int main()
    {
    int a, b, c, d;
    cin >> a >> b >> c >> d;
    Complex z1(a, b), z2(c, d), z3; //定义复数对象
    z1.Show(); //输出z1
    z2.Show(); //输出z2
    
    z3 = z1 + z2 - (-z1); //进行复数运算
    z3.Show(); //输出z3
    
    z3 = z3 * z1; //进行复数运算
    z3.Show(); //输出z3
    return 0;
    }
    

    注意:1.请务必提交完整的程序代码,不要修改代码框架。2.请不要修改试题描述中的所有标识符,注意大小写敏感。

    输入

    输入四个整数,用一个空格隔开。

    输出

    依据题意输出四行。

    输入示例1

    2 5 6 -5

    输出示例1

    2+5i
    6-5i
    10+5i
    -5+60i

    输入示例2

    2 0 -7 5

    输出示例2

    2
    -7+5i
    -3+5i
    -6+10i

    数据范围

    输入为int范围的整数

    答案

    #include<iostream>
    using namespace std;
    class Complex    //复数Complex类
    {
      protected:
          int real,image;
    
        //保护数据成员:int类型的real、image,分别代表实部、虚部
    
      public:
          Complex(int r = 0,int i = 0):real(r),image(i){}
    
        //带有两个参数的构造函数,参数默认值均为0;在初始化列表中将形参赋给对应的数据成员
    
          void Show()
          {
              cout<<real;
              if(image > 0)
                cout<<"+";
              if(image != 0)
                cout<<image<<"i"<<endl;
          }    //输出Show()常成员函数,注意保持合理的复数输出格式
    
          Complex operator+(const Complex& z2) const
          {
              return Complex(real+z2.real,image+z2.image);
          }    //双目+运算符重载常成员函数,有一个参数(Complex类型对象z2的常引用)
    
          Complex operator-(const Complex& z2) const
          {
              return Complex(real-z2.real,image-z2.image);
          }    //双目-运算符重载常成员函数,有一个参数(Complex类型对象z2的常引用)
    
          Complex operator*(Complex& z2) const
          {
              return Complex(real*z2.real-image*z2.image,real*z2.image+image*z2.real);
          }    //双目*运算符重载常成员函数,有一个参数(Complex类型对象z2的常引用)
    
          Complex operator-() const
          {
              return Complex(-real,-image);
          }    //单目-运算符重载常成员函数,无参数
    };
    int main()
    {
       int a, b, c, d;
       cin >> a >> b >> c >> d;
       Complex z1(a, b), z2(c, d), z3; //定义复数对象
       z1.Show(); //输出z1
       z2.Show(); //输出z2
    
       z3 = z1 + z2 - (-z1); //进行复数运算
       z3.Show(); //输出z3
    
       z3 = z3 * z1; //进行复数运算
       z3.Show(); //输出z3
       return 0;
    }
    
    

    析构函数填空

    试题描述

    请仔细阅读代码,并填写下面空白。

    //必要的头文件等,可能为多条语句//Test类
    {//定义保护的int类型的数据成员x和y//带有两个int类型参数a和b,且参数默认值均为0的构造函数,在初始化列表中,将形参a赋给数据成员x,b赋给y//析构函数,在函数体中输出x、y的值到屏幕,共占一行,两个值之间用一个空格隔开
    };
    int main()
    {//创建Test对象t1//定义Test指针t2
    int a, b;
    
    for(int i = 0; i < 2; i++)
    {
       cin >> a >> b;= new(a, b); //创建Test堆对象,并将地址赋给指针t2
          ⑩    t2; //释放堆对象
    }
    return 0;
    }
    

    注意:1.请务必提交完整的程序代码,不要修改代码框架。2.请不要修改试题描述中的所有标识符,注意大小写敏感。

    输入

    输入四个整数,以空格隔开。

    输出

    依据题意输出若干行。

    输入示例

    10 20 30 40

    输出示例

    10 20
    30 40
    0 0

    数据范围

    输入int范围的整数

    答案

    #include<iostream>
    using namespace std;
    class Test    //Test类
    {
      protected:
        int x,y;//定义保护的int类型的数据成员x和y
    
      public:
        Test(int a = 0,int b = 0):x(a),y(b){}
        //带有两个int类型参数a和b,且参数默认值均为0的构造函数,在初始化列表中,将形参a赋给数据成员x,b赋给y
    
        ~Test()
        {
            cout<<x<<" "<<y<<endl;
        }    //析构函数,在函数体中输出x、y的值到屏幕,共占一行,两个值之间用一个空格隔开
    };
    int main()
    {
       Test t1;    //创建Test对象t1
       Test* t2;    //定义Test指针t2
       int a, b;
    
       for(int i = 0; i < 2; i++)
       {
          cin >> a >> b;
             t2    = new    Test   (a, b); //创建Test堆对象,并将地址赋给指针t2
             delete    t2; //释放堆对象
       }
       return 0;
    }
    
    

    构造函数之矩形类

    试题描述

    创建矩形Rectangle类,有保护的int类型的成员变量r_long长和r_width宽;无参数的构造函数和有参数(参数没有默认值)的构造函数;其他成员函数comp_area()计算并返回矩形的面积,成员函数comp_perimeter()计算并返回矩形的周长,成员函数get_long()返回矩形的长;成员函数get_width()返回矩形的宽。

    int main()
    {
       int a, b;
       cin >> a >> b;
       Rectangle rect1, rect2(a, b); //分别调用不同的构造函数,创建两个对象
       cout << "(" << rect1.get_long() << "," << rect1.get_width() << ")" << endl;
       cout << "(" << rect2.get_long() << "," << rect2.get_width() << ")" << endl;
       cout << rect2.comp_area() << endl;
       cout << rect2.comp_perimeter() << endl;
       return 0;
    }
    

    注意:1.请务必提交完整的程序代码,不要修改代码框架。2.请不要修改试题描述中的所有标识符,注意大小写敏感。

    输入

    输入两个非负整数,两数之间用一个空格隔开。

    输出

    依据题意输出四行。

    输入示例

    100 1

    输出示例

    (10,10)
    (100,1)
    100
    202

    数据范围

    输入为int范围的非负整数

    答案

    #include<iostream>
    using namespace std;
    class Rectangle
    {
    protected:
        int r_long,r_width;
    public:
        Rectangle():r_long(10),r_width(10){}
        Rectangle(int a,int b):r_long (a),r_width(b){}
        int comp_area(){return r_long*r_width;}
        int get_long(){return r_long;}
        int get_width(){return r_width;}
        int comp_perimeter(){return 2*(r_long+r_width);}
    };
    int main()
    {
       int a, b;
       cin >> a >> b;
       Rectangle rect1, rect2(a, b); //分别调用不同的构造函数,创建两个对象
       cout << "(" << rect1.get_long() << "," << rect1.get_width() << ")" << endl;
       cout << "(" << rect2.get_long() << "," << rect2.get_width() << ")" << endl;
       cout << rect2.comp_area() << endl;
       cout << rect2.comp_perimeter() << endl;
       return 0;
    }
    
    

    继承机制下构造函数之窗口类

    试题描述

    以下面类CWnd为父类。
    从CWnd类公有派生出子类CEdit文本框类,具体要求如下:
    1)为子类CEdit新增保护数据成员string text。
    2)为子类CEdit设计无参默认构造函数,在该函数中初始化text的值为""。
    3)为子类CEdit设计三个参数的构造函数(int a, int b, string c) ,参数没有默认值。并在初始化表中调用父类有参构造函数(将参数a,b传给父类构造函数),将c的值赋给数据成员text。
    4)为子类CEdit新增成员函数void setText(string) 设置text数据成员的值。
    5)为子类CEdit新增常成员函数string getText() 返回数据成员text的值。

    class CWnd
    {
       protected:
          int width;
          int height;
       public:
          CWnd()
          {
             width = height = 0;
          }
          CWnd(int a, int b)
          {
             width = a;
             height = b;
          }
          void setHeight(int s)
          {
             height = s;
          }
          void setWidth(int s)
          {
             width = s;
          }
          int getHeight()
          {
             return height;
          }
          int getWidth()
          {
             return width;
          }
    };
    int main()
    {
       int a, b;
       string c;
       cin >> a >> b >> c;
       CEdit d(a, b, c);
       cout << d.getWidth() << endl;
       cout << d.getHeight() << endl;
       cout << d.getText() << endl;
       return 0;
    }
    

    注意:1.请务必提交完整的程序代码,不要修改代码框架。2.请不要修改试题描述中的所有标识符,注意大小写敏感。

    输入

    输入两个整数和一个字符串,相邻项之间以空格隔开。

    输出

    依据题意输出三行。

    输入示例

    50 20 欢迎

    输出示例

    50
    20
    欢迎

    数据范围

    输入整数和字符串

    答案

    #include<iostream>
    #include<string>
    using namespace std;
    class CWnd
    {
       protected:
          int width;
          int height;
       public:
          CWnd()
          {
             width = height = 0;
          }
          CWnd(int a, int b)
          {
             width = a;
             height = b;
          }
          void setHeight(int s)
          {
             height = s;
          }
          void setWidth(int s)
          {
             width = s;
          }
          int getHeight()
          {
             return height;
          }
          int getWidth()
          {
             return width;
          }
    };
    class CEdit:public CWnd
    {
    protected:
        string text;
    public:
        CEdit():text(""){}
        CEdit(int a , int b , string c):CWnd(a,b),text(c){}
        void setText(string a){text = a;}
        string getText(){return text;}
    };
    int main()
    {
       int a, b;
       string c;
       cin >> a >> b >> c;
       CEdit d(a, b, c);
       cout << d.getWidth() << endl;
       cout << d.getHeight() << endl;
       cout << d.getText() << endl;
       return 0;
    }
    
    

    多态性之猫狗大战

    试题描述

    宝宝家里养了100只动物(咪咪,阿黄…还有一头黔之驴),宝宝很喜欢它们。每天宝宝都要给它们洗澡,还要挨个抚摸一遍。因为有些动物长得很相似,宝宝也会弄混它们,闹出很多笑话来。比如刚刚给咪咪洗过澡,很快又会把它抱来再洗一遍(把它当雪团了…)。为了便于管理动物们,宝宝请你帮他写个程序,每天给动物们洗一遍澡。尽管小动物们都不喜欢洗澡,洗澡时都要哭个不停。
    具体要求如下:
    1)请设计父类Animal(string类型的保护数据成员nickname), 以及从Animal公有派生出的三个子类Cat、Dog、Donkey。要求所有类都要有一个参数的构造函数,用于初始化数据成员nickname。要求子类的构造函数明确调用父类的构造函数。
    2)三个子类中都有成员函数void Cry(),该函数的功能是描述该种动物的哭声(“喵喵喵”,“汪汪汪”,“嗯昂嗯昂”)。请仔细思考该函数是否有必要在父类Animal中定义为虚函数?
    3)设计Person类,有成员函数void DoCry(Animal &p),该函数描述宝宝的工作,给动物小p洗澡(其实就是p对象调用Cry()函数哭一场啦!)。
    请思考Person类是否有必要从Animal类中派生?
    宝宝不明白面向对象程序设计的思想,所以请你来设计五个类(Animal,Cat,Dog,Donkey,Person)。

    int main()
    {
       #define N 4
       Animal *p[N] = {new Dog("阿黄"), new Cat("咪咪"), new Donkey("黔之驴"), new Cat("雪团")};
       Person baobao("宝宝");
    
       for(int i = 0; i < N; i++)
          baobao.DoCry(*p[i]);
       return 0;
    }
    

    注意:1.请务必提交完整的程序代码,不要修改代码框架。2.请不要修改试题描述中的所有标识符,注意大小写敏感。

    输入

    无输入。

    输出

    依据题意输出若干行。

    输出示例

    汪汪汪
    喵喵喵
    嗯昂嗯昂
    喵喵喵

    答案

    #include<iostream>
    #include<string>
    using namespace std;
    class Animal
    {
    protected:
        string nickname;
    public:
        Animal(string a):nickname(a){}
        virtual void Cry() = 0;
    };
    class Cat:public Animal
    {
    public:
        Cat(string a):Animal(a){}
        void Cry()
        {
            cout<<"喵喵喵"<<endl;
        }
    };
    class Dog:public Animal
    {
    public:
        Dog(string a):Animal(a){}
        void Cry()
        {
            cout<<"汪汪汪"<<endl;
        }
    };
    class Donkey:public Animal
    {
    public:
        Donkey(string a):Animal(a){}
        void Cry()
        {
            cout<<"嗯昂嗯昂"<<endl;
        }
    };
    class Person
    {
    public:
        string name;
        Person(string a):name(a){}
        void DoCry(Animal &P)
        {
            P.Cry();
        }
    };
    int main()
    {
       #define N 4
       Animal *p[N] = {new Dog("阿黄"), new Cat("咪咪"), new Donkey("黔之驴"), new Cat("雪团")};
       Person baobao("宝宝");
    
       for(int i = 0; i < N; i++)
          baobao.DoCry(*p[i]);
       return 0;
    }
    
    
    展开全文
  • 2. (3分)关于基类成员在派生类的访问权限,下列描述正确的是 ‍ 在保护继承方式下,基类私有成员在派生类中转为保护成员 ‍ 在私有继承方式下,基类的私有成员在派生类不能直接访问。 ‍ 在公有继承方式下...
    1.(3分)下列无法实现类的多态性的是

    ‍ 友元类 √
    ‍ 虚函数
    ‍ 运算符重载
    ‍ 函数重载

    2. (3分)关于基类成员在派生类中的访问权限,下列描述不正确的是

    ‍ 在保护继承方式下,基类中私有成员在派生类中转为保护成员。 √
    ‍ 在私有继承方式下,基类中的私有成员在派生类中不能直接访问。
    ‍ 在公有继承方式下,基类中的私有成员在派生类中不能直接访问。
    ‍ 在保护继承方式下,基类中保护成员在派生类中仍为保护成员。

    3. (3分)下列描述错误的是

    ‍ 虚基类只能被继承一次
    ‍ 基类和派生类之间是继承关系
    ‍ 基类中包含派生类的成员 √
    ‍ 派生类对基类的继承有多种不同的方式

    4. (3分)关于对象指针与对象引用做参数,描述正确的是

    ‍ 对象指针做参数效率更高
    ‍ 对象引用做参数效率更高
    ‍ 对象指针做参数代码更加直观
    ‍ 对象引用和对象指针都能够实现传址 √

    5. (3分)下列运算符中,只能通过成员函数进行重载的是:

    ‍ 赋值运算符 √
    ‍ 关系运算符
    ‍ 自增运算符
    ‍ 输入输出运算符

    6. (3分)关于返回值优化描述不正确的是:

    ‍ 通过传值方式返回创建的新对象时,编译器会采用返回值优化策略
    ‍ 在返回值优化策略中,编译器直接把这个对象创建在外部返回值的存储单元中
    ‍ 执行语句{Integer temp(left.i + right.i);return temp;}采用的是返回值优化策略 √
    ‍ 返回值优化策略能提高运行效率

    7. (3分)关于类的数据成员描述错误的是:

    ‍ 常数据成员的初始化必须在构造函数中
    ‍ 常数据成员的值不能被改变
    ‍ 静态数据成员的初始化必须在构造函数中√
    ‍ 静态数据成员的作用域与类的对象生命周期无关

    8. (3分)关于设置参数的默认值,描述错误的是:

    ‍ 成员函数的参数可以设置为默认值。
    ‍ 可以给一个或多个参数设置默认值;
    ‍ 指定了默认值的参数的右边,不能出现没有指定默认值的参数
    ‍ 一定定义了设置了默认值的构造函数,还需提供默认构造函数的定义√

    9. (5分)以下描述正确的是

    ‍ 模板是一种代码重用的方法 √
    ‍ 模板可以编译执行
    ‍ 函数模板与其他函数模板之间可以重载 √
    ‍ 函数模板与其他非模板函数之间可以重载 √

    10. (5分)以下关于抽象的描述,正确的是

    ‍ 函数是对一系列操作的抽象 √
    ‍ 函数模板是对近似功能的函数的抽象 √
    ‍ 类是对具有相同属性和行为的对象的抽象 √
    ‍ 类模板是对近似功能的多个类的进一步抽象 √

    11. (12分)  运算符重载之复数类填空

    试题描述

    定义复数Complex类,并重载单目减号运算符、双目+、-、运算符函数为Complex类的成员函数。请仔细阅读代码,填写下面空白。
    ① //必要的头文件等,可能为多条语句
    ② //复数Complex类
    {
    ③ //保护数据成员:int类型的real、image,分别代表实部、虚部
    ④ //带有两个参数的构造函数,参数默认值均为0;在初始化列表中将形参赋给对应的数据成员
    ⑤ //输出Show()常成员函数,注意保持合理的复数输出格式
    ⑥ //双目+运算符重载常成员函数,有一个参数(Complex类型对象z2的常引用)
    ⑦ //双目-运算符重载常成员函数,有一个参数(Complex类型对象z2的常引用)
    ⑧ //双目
    运算符重载常成员函数,有一个参数(Complex类型对象z2的常引用)
    ⑨ //单目-运算符重载常成员函数,无参数};
    int main()
    {
    int a, b, c, d;
    cin >> a >> b >> c >> d;
    Complex z1(a, b), z2(c, d), z3; //定义复数对象
    z1.Show(); //输出z1
    z2.Show(); //输出z2

    z3 = z1 + z2 - (-z1); //进行复数运算
    z3.Show(); //输出z3

    z3 = z3 * z1; //进行复数运算
    z3.Show(); //输出z3
    return 0;
    }
    注意:1.请务必提交完整的程序代码,不要修改代码框架。2.请不要修改试题描述中的所有标识符,注意大小写敏感。

    输入:

    输入四个整数,用一个空格隔开。

    输出:

    依据题意输出四行。

    输入示例1:

    2 5 6 -5

    输出示例1:

    2+5i
    6-5i
    10+5i
    -5+60i

    输入示例2:

    2 0 -7 5

    输出示例2:

    2
    -7+5i
    -3+5i
    -6+10i

    数据范围:

    输入为int范围的整数

    代码:

    #include<iostream>  //必要的头文件等,可能为多条语句
    using namespace std;
    
    class Complex    //复数Complex类
    {
          protected:
    		  int real;
    		  int image;    //保护数据成员:int类型的real、image,分别代表实部、虚部
    	 public:
    			
          Complex(int x = 0,int y =0):real(x),image(y){}    //带有两个参数的构造函数,参数默认值均为0;在初始化列表中将形参赋给对应的数据成员
    		
          void Show ( ) const{
          	if(real == 0 && image == 0) cout<<0<<endl;
    	  	else if(image == 0) cout<<real <<endl;
    	  	else if(image > 0) cout<<real<<"+"<<image<<"i"<<endl;
    	  	else if(image <0 ) cout<<real<<image<<"i"<<endl;
    	  	else cout<<real<<"+"<<image<<"i"<<endl; 
    	  }    //输出Show()常成员函数,注意保持合理的复数输出格式 
    	  
            Complex operator + ( const Complex & z2 ) const { 
            	return Complex(real + z2.real , image + z2.image); 
    
    	  }    //双目+运算符重载常成员函数,有一个参数(Complex类型对象z2的常引用)
    
          Complex operator - ( const Complex & z2 ) const{
    	  return Complex(real - z2.real , image - z2.image);}     //双目-运算符重载常成员函数,有一个参数(Complex类型对象z2的常引用)
    
            Complex operator * ( const Complex & z2 ) const{
    		return Complex(real * z2.real -image * z2.image , real * z2.image +image *z2.real );
    		}     //双目*运算符重载常成员函数,有一个参数(Complex类型对象z2的常引用)
    //		ac-bd ad+bc
           Complex operator - ( ) const{
    	   return Complex(-real,-image); 
    	   }    //单目-运算符重载常成员函数,无参数
    };
    int main()
    {
       int a, b, c, d;
       cin >> a >> b >> c >> d;
       Complex z1(a, b), z2(c, d), z3; //定义复数对象
       z1.Show(); //输出z1
       z2.Show(); //输出z2
    
       z3 = z1 + z2 - (-z1); //进行复数运算
       z3.Show(); //输出z3
    
       z3 = z3 * z1; //进行复数运算
       z3.Show(); //输出z3
       return 0;
    }   
    
    12. (12分) 析构函数填空

    试题描述

    请仔细阅读代码,并填写下面空白。
    ① //必要的头文件等,可能为多条语句
    ② //Test类
    {
    ③ //定义保护的int类型的数据成员x和y
    ④ //带有两个int类型参数a和b,且参数默认值均为0的构造函数,在初始化列表中,将形参a赋给数据成员x,b赋给y
    ⑤ //析构函数,在函数体中输出x、y的值到屏幕,共占一行,两个值之间用一个空格隔开
    };
    int main()
    {
    ⑥ //创建Test对象t1
    ⑦ //定义Test指针t2
    int a, b;

    for(int i = 0; i < 2; i++)
    {
    cin >> a >> b;
    ⑧ = new ⑨ (a, b); //创建Test堆对象,并将地址赋给指针t2
    ⑩ t2; //释放堆对象
    }
    return 0;
    }
    注意:1.请务必提交完整的程序代码,不要修改代码框架。2.请不要修改试题描述中的所有标识符,注意大小写敏感。

    输入

    输入四个整数,以空格隔开。

    输出

    依据题意输出若干行。

    输入示例

    10 20 30 40

    输出示例

    10 20
    30 40
    0 0

    数据范围

    输入int范围的整数

    代码:

    #include<iostream>
    using namespace std;   //必要的头文件等,可能为多条语句
       class Test    //Test类
    {
        protected:
    	int x;int y;//定义保护的int类型的数据成员x和y
        public:
          Test(int a=0,int b=0):x(a),y(b){} //带有两个int类型参数a和b,且参数默认值均为0的构造函数,在初始化列表中,将形参a赋给数据成员x,b赋给y
    
          ~Test(){
    	  cout<<x<<" "<<y<<endl; }    //析构函数,在函数体中输出x、y的值到屏幕,共占一行,两个值之间用一个空格隔开
    };
    int main()
    {
        Test  t1;    //创建Test对象t1
          Test *t2;  //定义Test指针t2
       int a, b;
    
       for(int i = 0; i < 2; i++)
       {
          cin >> a >> b;
             t2    = new   Test   (a, b); //创建Test堆对象,并将地址赋给指针t2
               delete   t2; //释放堆对象
       }
       return 0;
    }
    
    13 (12分)  构造函数之矩形类

    试题描述

    创建矩形Rectangle类,有保护的int类型的成员变量r_long长和r_width宽;无参数的构造函数和有参数(参数没有默认值)的构造函数;其他成员函数comp_area()计算并返回矩形的面积,成员函数comp_perimeter()计算并返回矩形的周长,成员函数get_long()返回矩形的长;成员函数get_width()返回矩形的宽。
    int main()
    {
    int a, b;
    cin >> a >> b;
    Rectangle rect1, rect2(a, b); //分别调用不同的构造函数,创建两个对象
    cout << “(” << rect1.get_long() << “,” << rect1.get_width() << “)” << endl;
    cout << “(” << rect2.get_long() << “,” << rect2.get_width() << “)” << endl;
    cout << rect2.comp_area() << endl;
    cout << rect2.comp_perimeter() << endl;
    return 0;
    }
    注意:1.请务必提交完整的程序代码,不要修改代码框架。2.请不要修改试题描述中的所有标识符,注意大小写敏感。

    输入

    输入两个非负整数,两数之间用一个空格隔开。

    输出

    依据题意输出四行。

    输入示例

    100 1

    输出示例

    (10,10)
    (100,1)
    100
    202

    数据范围

    输入为int范围的非负整数

    代码:

    #include<iostream>
    using namespace std;
    //创建矩形Rectangle类,有保护的int类型的成员变量r_long长和r_width宽;
    //无参数的构造函数和有参数(参数没有默认值)的构造函数;
    //其他成员函数comp_area()计算并返回矩形的面积,成员函数comp_perimeter()计算并返回矩形的周长,
    //成员函数get_long()返回矩形的长;成员函数get_width()返回矩形的宽。
    class Rectangle{
    	protected:
    		int r_long; int r_width;
    	public:
    		Rectangle(){r_long=10;r_width=10;}
    		Rectangle(int a,int b){r_long=a;r_width=b;}
    		int comp_area(){
    			return r_long*r_width;
    		}
    		int comp_perimeter(){
    			return 2*(r_long + r_width);
    		}
    		int get_long(){return r_long;}
    		int get_width(){return r_width;}
    			
    };
    int main()
    {
       int a, b;
       cin >> a >> b;
       Rectangle rect1, rect2(a, b); //分别调用不同的构造函数,创建两个对象
       cout << "(" << rect1.get_long() << "," << rect1.get_width() << ")" << endl;
       cout << "(" << rect2.get_long() << "," << rect2.get_width() << ")" << endl;
       cout << rect2.comp_area() << endl;
       cout << rect2.comp_perimeter() << endl;
       return 0;
    }
    
    
    14 (15分)  继承机制下构造函数之窗口类

    试题描述

    以下面类CWnd为父类。
    从CWnd类公有派生出子类CEdit文本框类,具体要求如下:
    1)为子类CEdit新增保护数据成员string text。
    2)为子类CEdit设计无参默认构造函数,在该函数中初始化text的值为""。
    3)为子类CEdit设计三个参数的构造函数(int a, int b, string c) ,参数没有默认值。并在初始化表中调用父类有参构造函数(将参数a,b传给父类构造函数),将c的值赋给数据成员text。
    4)为子类CEdit新增成员函数void setText(string) 设置text数据成员的值。
    5)为子类CEdit新增常成员函数string getText() 返回数据成员text的值。
    class CWnd
    {
    protected:
    int width;
    int height;
    public:
    CWnd()
    {
    width = height = 0;
    }
    CWnd(int a, int b)
    {
    width = a;
    height = b;
    }
    void setHeight(int s)
    {
    height = s;
    }
    void setWidth(int s)
    {
    width = s;
    }
    int getHeight()
    {
    return height;
    }
    int getWidth()
    {
    return width;
    }
    };
    int main()
    {
    int a, b;
    string c;
    cin >> a >> b >> c;
    CEdit d(a, b, c);
    cout << d.getWidth() << endl;
    cout << d.getHeight() << endl;
    cout << d.getText() << endl;
    return 0;
    }
    注意:1.请务必提交完整的程序代码,不要修改代码框架。2.请不要修改试题描述中的所有标识符,注意大小写敏感。

    输入

    输入两个整数和一个字符串,相邻项之间以空格隔开。

    输出

    依据题意输出三行。

    输入示例

    50 20 欢迎

    输出示例

    50
    20
    欢迎

    数据范围

    输入整数和字符串

    代码:

    #include<iostream>
    #include<string>
    using namespace std;
    
    class CWnd
    {
       protected:
          int width;
          int height;
       public:
          CWnd()
          {
             width = height = 0;
          }
          CWnd(int a, int b)
          {
             width = a;
             height = b;
          }
          void setHeight(int s)
          {
             height = s;
          }
          void setWidth(int s)
          {
             width = s;
          }
          int getHeight()
          {
             return height;
          }
          int getWidth()
          {
             return width;
          }
    };
    class CEdit:public CWnd
    {
    	protected:
    		string text;
    	public:
    		CEdit(){text = "";}
    		CEdit(int a,int b,string c):CWnd(a,b)
    		{text = c;}
    		void setText(string c){text = c;}
    		string getText() const{
    		 return text;
    		}
    };
    int main()
    {
       int a, b;
       string c;
       cin >> a >> b >> c;
       CEdit d(a, b, c);
       cout << d.getWidth() << endl;
       cout << d.getHeight() << endl;
       cout << d.getText() << endl;
       return 0;
    }
    
    15 (15分)  多态性之猫狗大战

    试题描述

    宝宝家里养了100只动物(咪咪,阿黄…还有一头黔之驴),宝宝很喜欢它们。每天宝宝都要给它们洗澡,还要挨个抚摸一遍。因为有些动物长得很相似,宝宝也会弄混它们,闹出很多笑话来。比如刚刚给咪咪洗过澡,很快又会把它抱来再洗一遍(把它当雪团了…)。为了便于管理动物们,宝宝请你帮他写个程序,每天给动物们洗一遍澡。尽管小动物们都不喜欢洗澡,洗澡时都要哭个不停。
    具体要求如下:
    1)请设计父类Animal(string类型的保护数据成员nickname), 以及从Animal公有派生出的三个子类Cat、Dog、Donkey。要求所有类都要有一个参数的构造函数,用于初始化数据成员nickname。要求子类的构造函数明确调用父类的构造函数。
    2)三个子类中都有成员函数void Cry(),该函数的功能是描述该种动物的哭声(“喵喵喵”,“汪汪汪”,“嗯昂嗯昂”)。请仔细思考该函数是否有必要在父类Animal中定义为虚函数?
    3)设计Person类,有成员函数void DoCry(Animal &p),该函数描述宝宝的工作,给动物小p洗澡(其实就是p对象调用Cry()函数哭一场啦!)。
    请思考Person类是否有必要从Animal类中派生?
    宝宝不明白面向对象程序设计的思想,所以请你来设计五个类(Animal,Cat,Dog,Donkey,Person)。
    int main()
    {
    #define N 4
    Animal *p[N] = {new Dog(“阿黄”), new Cat(“咪咪”), new Donkey(“黔之驴”), new Cat(“雪团”)};
    Person baobao(“宝宝”);

    for(int i = 0; i < N; i++)
    baobao.DoCry(*p[i]);
    return 0;
    }
    注意:1.请务必提交完整的程序代码,不要修改代码框架。2.请不要修改试题描述中的所有标识符,注意大小写敏感。

    输入

    无输入。

    输出

    依据题意输出若干行。

    输出示例

    汪汪汪
    喵喵喵
    嗯昂嗯昂
    喵喵喵

    代码:

    #include<iostream>
    using namespace std;
    class Animal{
    	protected:
    		string nickname; 
    	public:
    		Animal(string c){ nickname = c;}
    		virtual void Cry ( ){} ;
    };
    
    class Cat : public Animal{
    	public:
    		Cat(string c):Animal(c){  }
    		void Cry(){ cout<<"喵喵喵" <<endl;}
    } ;
    class Dog: public Animal{
    	public:
    	Dog(string c):Animal(c){  }
    	void Cry(){ cout<< "汪汪汪"<<endl;}
    } ;
    class Donkey: public Animal{
    	public:
    	Donkey(string c):Animal(c){  }
    	void Cry(){ cout<< "嗯昂嗯昂"<<endl;}
    	} ; 
    class Person{
    	public:
    		string name;
    		Person(string c){name = c;
    		}
    		void DoCry(Animal &p)
    		{
    			p.Cry();
    		 } 
    };
    int main()
    {
       #define N 4
       Animal *p[N] = {new Dog("阿黄"), new Cat("咪咪"), new Donkey("黔之驴"), new Cat("雪团")};
       Person baobao("宝宝");
    
       for(int i = 0; i < N; i++)
          baobao.DoCry(*p[i]);
       return 0;
    } 
    
    展开全文
  • C++复习资料之系列

    2008-12-30 21:35:45
    在一个C++程序,main函数的位置( c )。 (a) 必须在程序的开头 (b) 必须在程序的后面 ( c ) 可以在程序的任何地方 (d) 必须在其它函数中间 2.用C++语言编制的源程序要变为目标程序必须要经过( d )。 (a) ...
  • 面向对象c#试题参考

    2010-04-21 12:32:31
    3.关于ASP.NET的代码隐藏文件的描述正确的是(a) a)Web窗体页的程序的逻辑由代码组成,这些代码的创建用于与窗体交互。编程逻辑唯一与用户界面不同的文件。该文件称作为“代码隐藏”文件,如果用C#创建,该...
  • 面向对象与C++试题.doc

    2013-12-16 20:49:17
    1、关于C++与C语言关系的描述中,( )是错误的。 A.C语言是C++语言的一个子集 B.C语言与C++语言是兼容的 C.C++语言对C语言进行了一些改进 D.C++语言和C语言都是面向对象的 2、已知:int m=10; 下列表示引用的...
  • 面试题81 虚函数与纯虚函数的区别 面试题82 如何使用纯虚函数 第8章 指针( 教学视频:60分钟) 8.1 指针概述 面试题83 什么是指针 面试题84 如何初始化指针并对其赋值 面试题85 是否可以确定指针指向一个对象 面试...
  • C++程序员面试宝典

    热门讨论 2013-04-01 13:36:19
    面试题81 虚函数与纯虚函数的区别 85 面试题82 如何使用纯虚函数 86 第8章 指针(教学视频:60分钟) 88 8.1 指针概述 88 面试题83 什么是指针 88 面试题84 如何初始化指针并对其赋值 89 面试题85 是否可以确定指针...
  • 2.5.9 对于INVERSE ARP的描述正确的是? 百度篇 3.1.0 在函数内定义一个字符数组,用gets函数输入字符串的时候,如果输入越界,为什么程序会崩溃? 3.1.1 C++引用与指针的区别 3.1.2 C/C++程序的内存分区 ...
  • 13.3.4套接字在电路服务中的应用 281 13.3.5套接字在数据报服务中的应用 281 13.3.6套接字协议族 282 13.3.7套接字类型 282 13.3.8套接字函数 282 13.4用UNIX平台构建Internet网络环境 284 13.4.1用户域名和...
  • 一个函数调用,如果函数是重载过的,并且重载函数的参数匹配分不出好坏的话 (都经行同样次数的隐式类型转换),那么将产生一个二义性错误.这将生成一个运行时 错误,程序挂起在产生二义性调用的地方.一个简单的例子是,...
  • 2.5.5 虚函数 33 2.6 面向对象程序设计 33 2.6.1 具体类型问题 33 2.6.2 类层次结构 34 2.7 通用型程序设计 36 2.7.1 容器 36 2.7.2 通用型算法 37 2.8 附言 38 2.9 忠告 39 第3章 标准库概览 40 3.1 ...
  • 2.5.5 虚函数 33 2.6 面向对象程序设计 33 2.6.1 具体类型问题 33 2.6.2 类层次结构 34 2.7 通用型程序设计 36 2.7.1 容器 36 2.7.2 通用型算法 37 2.8 附言 38 2.9 忠告 39 第3章 标准库概览 40 3.1 ...
  • 1.写出判断ABCD四个表达式是否正确, 若正确, 写出经过表达式 a值(3分) int a = 4; (A)a += (a++); (B) a += (++a) ;(C) (a++) += a;(D) (++a) += (a++); a = ? 答:C错误,左侧不是一个有效变量,不能赋值,可...
  • C++程序设计语言(特别版)--源代码

    热门讨论 2012-04-23 07:33:51
    提供的是的源代码,非课后练习源代码。 本版本是高清版,是第1版第18次印刷,是书签最全最好的版本。 基本信息 原书名: The C++ Programming Language, Special Edition 原出版社: Addison Wesley 作者: ...
  • java面试宝典

    2013-02-28 16:04:01
    234、存储过程和函数的区别 55 235、事务是什么? 55 236、游标的作用?如何知道游标已经到了最后? 55 237、触发器分为事前触发和事后触发,这两种触发有和区别。语句级触发和行级触发有何区别。 56 238、EJB容器...

空空如也

空空如也

1 2 3
收藏数 41
精华内容 16
关键字:

关于虚函数的描述中正确的是