niusouti.com

单选题下列是重载乘法运算符的函数原型声明，其中错误的是（　　）。A MyClass operator*（double，double）；B MyClass operator*（double，MyClass）；C MyClass operator*（MyClass，double）；D MyClass operator*（MyClass，MyClass）；

题目
单选题
下列是重载乘法运算符的函数原型声明，其中错误的是（　　）。
A

MyClass operator*（double，double）；

B

MyClass operator*（double，MyClass）；

C

MyClass operator*（MyClass，double）；

D

MyClass operator*（MyClass，MyClass）；

相似考题

1.在MyClass 类的定义中，对赋值运算符=进行重载。请将画线处缺失的部分补充完整。（ ） MyClass::operator=（const MyClass rhs）{if（this=&rhs）return*this;value=rhs. value;return*this;}

2.假定MyClass为一个类，那么下列的函数说明中，（ ）为该类的析构函数。B．C．D．A.void～MyClass()；B.～MyClass(int n)；C.MyClass()；D.～MyClass()；?

3.（ 33 ）下列是重载乘法运算符的函数原型声明，其中错误的是A ） MyClass operator*(double,double);B ） MyClass operator*(double,MyClass);C ） MyClass operator*(MyClass,double);D ） MyClass operator*(MyClass,MyClass);

4.有以下程序 include using namespace std; class MyClass { public:有以下程序 #include＜iostream＞ using namespace std； class MyClass { public： MyClass(intn) {number＝n；} //拷贝构造函数 MyClass (MyClass& other) {number＝other.number；} ～MyClass(){} private： int number； }； MyClass fun (MyClass p) { MyClass temp(p)； return temp； } intmain() { MyClass obj1(10)，obj2(0)； MyClass obj3(obj1)； obj2=fun(obj3)； return0； } 程序执行时，MyClass类的拷贝构造函数被调用的次数是A．5B．4C．3D．2

更多“单选题下列是重载乘法运算符的函数原型声明，其中错误的是（　　）。A MyClass operator*（double，double）；B MyClass operator*（double，MyClass）；C MyClass operator*（MyClass，double）；D MyClass operator*（MyClass，MyClass）；”相关问题

  • 第1题：

    （ 29 ）已知类 MyClass 声明如下：

    class MyClass{

    int n;

    public;

    MyClass （ int k ） ： n （ k ） {}

    int getValue （） const{return n;}

    };

    在下列数组定义中正确的是

    A ） MyClass x1[2];

    B ） MyClass x2[2]={new MyClass （ 1 ） ， new MyClass （ 2 ） };

    C ） MyClass *x3[2];

    D ） MyClass *x4[2]={MyClass （ 1 ） ， MyClass （ 2 ） };


    正确答案：C

  • 第2题：

    下列是重载乘法运算符的函数原型声明，其中错误的是

    A．MyClass operator * (double, double);

    B．MyClass operator * (double, MyClass);

    C．MyClass operator * (MyClass, double);

    D．MyClass operator * (MyClass, MyClass);


    正确答案：A
    解析：本题考查的知识点是：运算符重载。C++把重载的运算符视为特殊的函数，称为运算符函数。运算符重载就是函数重载的一种特殊情况。像对待一般重载函数一样，编译系统能够依据使用运算符的不同环境，即参数(操作数)的数量或类型的差异，区分同一运算符的不同含义。本题中的选项A重载运算符“*”使用的形参是两个double，而系统中的“*”运算原本就能计算两个double，所以这违反了重载函数的原则，当执行a*b(a、b的类型均为double)这样的表达式时，系统不知道该执行默认的“乘法”还是用户自定义的运算符重载函数。故答案为选项A。

  • 第3题：

    假定MyClass 为一个类，则该类的拷贝构造函数的声明语句为 ( )。

    A．MyClass& (MyClass x);

    B．MyClass (MyClass x);

    C．MyClass(MyClass &x);

    D．MyClass (MyClass *x);


    正确答案：C
    解析：声明拷贝构造函数的格式为：类名＞：：拷贝构造函数＞(const类名＞&引用名＞)；其中const是修饰符可以省略。

  • 第4题：

    假定MyClass为一个类，那么下列的函数说明中，( )为该类的析构函数。

    A．void～MyClass()；

    B．～MyClass(int n)

    C．MyClass();

    D．～MyClass()；


    正确答案：D
    解析： C++语言中析构函数为符号“～”加类名，且析构函数没有返回值和参数，故前不加void关键宇。所以正确的形式应该是～MyClass()。

  • 第5题：

    假定MyClass为一个类，则该类的拷贝初始化构造函数的声明语句为( )

    A．MyClass&(MyClass x);

    B．MyClass(MyClass x)

    C．MyClass(MyClass &x);

    D．MyClass(MyClass *x)


    正确答案：C
    解析：拷贝构造函数是一个特殊的构造函数，它用一个已知的对象初始化一个正在创建的同类对象，它的一般格式是：类名::类名(const类名&引用对象名)。

  • 第6题：

    下面重载乘法运算符的函数原型声明中错误的是( )

    A．TestClass operator *(MyClass,double);

    B．TestClass operator *(double,MyClass);

    C．TestClass operator *(double,double);

    D．TestClass operator *(MyClass,MyClass);


    正确答案：C

  • 第7题：

    有以下程序include using namespace std;class MyClass{public:MyClass(int n) { num

    有以下程序#include ＜iostream＞using namespace std;class MyClass{public: MyClass(int n) { number=n; } //拷贝的构造函数 MyClass(MyClass& other) {number=other. number; } ～MyClass() { }private: int number;};MyClass fun(MyClass p){ MyClass temp(p); return temp;}int main() MyClass obj 1 (10), obj 2(0); MyClass obi 3 (obj 1); obj2=fun(obj3); return 0;}程序执行时，MyClass 类的拷贝构造函数被调用的次数是( )。

    A．5

    B．4

    C．3

    D．2


    正确答案：B

  • 第8题：

    假定MyClass 为一个类，则该类的拷贝构造函数的声明语句为( )。

    A．MyClass& (MyClass x)；

    B．MyClass (MyClass.x)；

    C．MyClass (MyClass &x)；

    D．MyClass (MyClass *x)；


    正确答案：C

  • 第9题：

    有以下程序includeusing namespace std;class MyClass{public:MyClass(int n){number

    有以下程序 #include＜iostream＞ using namespace std； class MyClass { public： MyClass(int n){number =n； } //拷贝构造函数 MyClass(MyClass& other) {number=other．number；} ～MyClass() {} private： int number； }； MyClass fun(MyClass p) { MyClass temp(p)； return temp； } int main() { MyClass Obj1(10)，obj2(0)； MyClass obj3(obj1)； obj2=fun(obj3)； return 0； } 程序执行时，MyClass类的拷贝构造函数被调用的次数是

    A．5

    B．4

    C．3

    D．2


    正确答案：B
    解析：本题考核C++的拷贝构造函数。调用拷贝构造函数的情况为：一个新对象被另一个已存在的同类型对象初始化；当一个对象作为实参传递给函数时为初始化形参，要调用拷贝构造函数。在函数值返回时形参的生命期结束时它的析构函数被调用；在函数返回一个对象时调用拷贝构造函数。符合以上条件的有：用对象obj1来初始化obj3；obj3作为实参被传入；函数fun返回一个对象时；系统用返回值初始化一个匿名对象时调用了拷贝构造函数。总共调用4次。

  • 第10题：

    在MyClass类的定义中，对赋值运算符＝进行重载。请将横线处缺失的部分补充完整。

    ______MyClass：：operator＝(const MyClass&rhs)

    {

    if(this＝＝&rhs)return*this；

    value＝rhs.value；

    return*this；

    }


    正确答案：MyClass&。
    MyClass&。 解析： 本题考查“=”运算符的重载。运算符“=”的重载需要注意：返回值应声明为引用，函数体中总是用语句return*this;返回；如果参数被声明为指向同类对象的引用妨指针，应判别所指向的对象是否与被赋值对象为同一对象，如果是则不做任何处理；如果被赋值对象占用了动态空间，应选释放这些资源，以便接收新的资源，如果参数被声明为指针成引用，通常应加上const修饰；一个类如果需要重载运算符=，通常也就需要定义自身特有的复制构造函数，反之亦然。

  • 第11题：

    如果类名为Myclass，那么（）可以作为它的构造函数。

    • A、~Myclass（）
    • B、Myclass（doublea）
    • C、~Myclass（doublea）
    • D、voidMyclass（）

    正确答案:B

  • 第12题：

    单选题
    假定MyClass为一个类，则该类的拷贝初始化构造函数的声明语句为（　　）。
    A

    MyClass&(MyClass x)；

    B

    MyClass(MyClass x)；

    C

    MyClass(MyClass&x)；

    D

    MyClass(MyClass*x)；


    正确答案： C
    解析：
    拷贝构造函数是用一个已知的对象初始化一个正在创建的同类对象，拷贝初始化构造函数的声明语句一般格式是：类名::类名（const类名 &引用对象名）。

  • 第13题：

    （ 22 ）要定义一个引用变量 p ，使之引用类 MyClass 的一个对象，正确的定义语句是

    A ） MyClass p=MyClass;

    B ） MyClass p=new MyClass;

    C ） MyClass &p=new MyClass;

    D) MyClass a ， &p=a;


    正确答案：D

  • 第14题：

    假定MyClass为一个类，则该类的拷贝构造函数的声明语句为

    A．MyClass&(MyClassx)；

    B．MyClass(MyClassx)；

    C．MyClass(MyClass &x)；

    D．MvClass(MyClass *x)；


    正确答案：C
    解析：本题考核拷贝构造函数的概念。声明拷贝构造函数的格式为：类名＞::拷贝构造函数＞(const类名＞&引用名＞)；，其中const是修饰符可以省略。

  • 第15题：

    有如下类定义： class MyClass { public： private： ______________________________________ int data； }； 若要为MyClass类重载流输入运算符“>>”，使得程序中可以“cin>>obj；”的形式改变MyClass类的对象0bj中数据成员data的值，则横线处的声明语句应为( )。

    A.friend istream& operator>>(istream&is，MyClass&A．；

    B.friend istream&operator>>(istream&is，MyClass A．；

    C.istream&operator>>(istream&is，MyClass&A．；

    D.istream&operator>>(istream&is，MyClass A．；


    正确答案：A
    本题考查重载流运算符“>>”，根据重载规则，本题答案为A。

  • 第16题：

    下列是重载乘法运算的函数原型声明，其中错误的是

    A．MyClass operator*(double，double)；

    B．MyClass operator*(double，MyClass)；

    C．MyClass operator*(MyClass，double)；

    D．MyClass operator*(MyClass，MyClass)；


    正确答案：A

  • 第17题：

    假定MyClass为一个类，则该类的拷贝构造函数的声明语句为( )

    A．MyClass(MyClass x)；

    B．MyClass(MyClass&x)；

    C．MyClass(&x)；

    D．MvClass(x)；


    正确答案：B
    解析：拷贝构造函数也是构造函数，所以函数名字为MyClass，但它只有一个参数，这个参数是本类的对象，即x；而且采用对象的引用的形式，也就是&x。所以本题答案是B)

  • 第18题：

    有如下类定义： classMyClass( public： ____ private： intdata； }； 若要为Myclass类重载流输入运算符>>，使得程序中可以“cin>>obj；”形式输入MyClasS类的对象obj，则横线处的声明语句应为（ ）。

    A.friendistream＆operator>>(istream＆is，MyClass＆a)；

    B.friendistream＆operator>>(istream＆is，MyClassa)；

    C.istream＆operalor>>(istream＆is，MyClass＆a)；

    D.istream＆operator>>(istream＆is，Myclassa)；


    正确答案：A
    A。【解析】重载输入、输出的声明必须是友元，传入的对象必须是地址，否则操作对象的值是没有意义的。下面是重载输入运算符示例：(Dev-C＋＋)#include<cstdlib>#include<iostream>usingnamespacestd；classMyClass{public：intdata；public：MyClass(intdata)；friendistream＆operator>>(1stream＆is，MyCla-ss＆obj)；}；MyClass：：MyClass(iutdata){data=data；}istream＆operator>>(istream＆is，MyClass＆obj){is>>obj．data；returnis；}intmain(void){MyClassobj(12)；cin>>obj；eout<<endl；cout<<obj．data；system(”PAUSE”)：returnEXIT—SUCCESS；}

  • 第19题：

    下列程序在构造函数和析构函数中申请和释放类的私有成员，请完成该类的实现。

    class Myclass {

    public:

    Myclass(int num);

    ～ Myclass( );

    public:

    int *p;

    };

    Myclass: :Myclass( int hum) {

    【 】

    Myclass:: ～ Myelass( ) {

    【 】;

    }。


    正确答案：P=new int(a)、delete P
    P=new int(a)、delete P 解析：new和delete的用法。

  • 第20题：

    下列是重载乘法运算符的函数原型声明，其中错误的是( )。

    A．MyClass operator*(double,double);

    B．MyClass operator*(double,MyClass);

    C．MyClass operator*(MyClass,double);

    D．MyClassoperator*(MyClass,MyClass);


    正确答案：A
    解析： 此题考查的是乘法运算符的重载函数原型声明。因为操作的对象是类对象，所以重载函数的参数至少有一个是类对象。故选项A)中两个参数都为double型是错误的。

  • 第21题：

    以下程序的执行结果为()。includeclass myClass{Dublic:myClass(intdata) ;myClass(

    以下程序的执行结果为( )。 #include＜iostream．h＞ class myClass { Dublic： myClass(int data) ； myClass(){value=0； }； myClass(myClass &obj)； void print(){ cout＜＜value＜＜end1； } ～myClass(){} private： int value； }； myClass：：myClass(int data) {value=data； } myClass：：myClass(myClass &Obj) { value=obj．value； } void main() { myClass a(100)； myClass b(a) ； b．print()； }

    A．0

    B．100

    C．10

    D．程序编译时出错


    正确答案：B
    解析：题中类myClass定义了一个拷贝初始化构造函数myClass(myClass&obj)。在主函数中，系统首先自动调用相应的构造函数建立对象，然后调用拷贝构造函数对对象b进行初始化。所以程序最后的输出为100。

  • 第22题：

    在MyClass类的定义中，对赋值运算符二进行重载。请将画线处缺失的部分补充完整。【 】MyClass::operator＝(const MyClass& rhs)

    {

    if(this==&rhs)return *this；

    value＝rhs.value；

    return *this；

    }


    正确答案：MyClass&
    MyClass& 解析：本题考查“＝”运算符的重载。赋值运算符＝的重载应注意以下几点：
    ①返回值应声明为引用，而函数体中总是用语句return *this；返回；
    ②如果参数被声明为指向同类对象的引用或指针，应判别所指向的对象是否与被赋值对象为同一对象，如果是，立即返回，不做任何赋值处理：
    ③如果被赋值对象占用了动态空间或其他资源，应首先释放这些资源，以便接收新的资源；
    ④如果参数被声明为指针或引用，通常应加上const修饰；
    ⑤如果参数被声明为指针，应判别是否为空，以便做出特殊处理：
    ⑥一个类如果需要重载运算符＝，通常也就需要定义自身特有的拷贝构造函数，反之亦然。
    由此可见，本题应填入MyClass&。

  • 第23题：

    MyClass类的默认构造方法是哪一个？（）

    • A、new MyClass（）
    • B、MyClass（）{}
    • C、MyClass{}
    • D、public class MyClass

    正确答案:B

  • 第24题：

    单选题
    下列是重载乘法运算符的函数原型声明，其中错误的是（　　）。
    A

    MyClass operator*（double，double）；

    B

    MyClass operator*（double，MyClass）；

    C

    MyClass operator*（MyClass，double）；

    D

    MyClass operator*（MyClass，MyClass）；


    正确答案： A
    解析：
    C++已经提供了求两个double型数据乘法的运算符*，不能再定义同样的运算符，编译器不能识别是否执行运算符重载函数。

相关内容