类MyClas的定义如下： class MyClas{ public: MyClas(){} MyClas(int a){ value=new.int(i); } int *value; }; 若要对类中的value赋值，则下面的语句中正确的是( )A．MyClas x;x.value=10;B．MyClas x; *x.value=10;C．MyClas x;x. *value=10;D．MyClas x(10);

题目

类MyClas的定义如下： class MyClas{ public: MyClas(){} MyClas(int a){ value=new.int(i); } int *value; }; 若要对类中的value赋值，则下面的语句中正确的是( )

A．MyClas x;x.value=10;

B．MyClas x; *x.value=10;

C．MyClas x;x. *value=10;

D．MyClas x(10);

相似考题

1.有如下类定义：class Foo{public:Foo(int v):value(v){} // ①~Foo(){} // ②private:Foo(){} // ③int value = 0; // ④};其中存在语法错误的行是A ． ①B ． ②C ． ③D ． ④

2.若类A和类B的定义如下:includeclass A{int i,j;public:int geti(){return i;}};class若类A和类B的定义如下： #include＜malloc.h＞ class A { int i,j; public: int geti() { return i; } }; class B:public A { int k; public: void make() { k=i*j; } }; 则上述定义中非法的表达式是( )。A．k=i*jB．int k;C．return i;D．void make();

3.类MyClass的定义如下，若要对value赋值，则下面语句正确的是( )。 class MyClass { public: MyClass(){} MyClass(int i){value=new int(i);} int*value; };A．MyClass my;my.value=10;B．MyClass my;*my.value=10;C．MyClass my;my.*value=10;D．MyClass my(10);

4.类MyClass的定如下，若要对value赋值，则下面语句正确的是( )。 class MyClass { public： MyClass(){} MyClass(int i){value＝new int(i)；} int*value； }；A．MyClass my；my.value=10；B．MyClass my；*my.value=10；C．MyClass my；my.*value=10；D．MyClass my(10)；

更多“类MyClas的定义如下:class MyClas{public:MyClas(){}MyClas(int a){value=new.int(i);}int *valu ”相关问题

  • 第1题：

    有如下类定义： ClaSS MyClass{ int value； public： MyClass(int n)：value(n){ } int getValue( )const{return value；} l； 则类MyClass的构造函数的个数是

    A．1个

    B．2个

    C．3个

    D．4个


    正确答案：A
    解析：对于类的构造函数，如果有显式定义，那么在构造该类对象时就自动调用显式定义的构造函数，否则系统将给类一个默认的空构造函数。

  • 第2题：

    类MyClas定义如下： Class MyClas{ public: MyClas(){value=0;} setVariable(int i){value=I;} private: int value; }则以下对语句序列 MyClas *p,my;p=&my; 的描述正确的是( )。

    A．语句 p-＞setVariable(5) 与语句 my.setVariable(5) 等价

    B．对语句 *p.setVariable(5)的调用是正确的

    C．语句 MyClas *p,my; 会调用两次类MyClas的构造函数

    D．语句 p=&my; 是把对象my赋值给指针变量p


    正确答案：A
    解析：选项A中，p是对象指针，所以调用p的成员要用符号“-＞”，而my是一般的类对象，所以调用my的成员用“.”；选项B中正确的调用方式应该是(*p).setVariable；选项C中仅调用一次类对象的构造函数；选项D是把对象my的地址赋值给指针变量p，而不是对象本身。

  • 第3题：

    已知类MyClass的定义如下：

    classMyClass{

    public：

    voidfunctionl(MyClass＆c){out<<c．data；}

    statievoidfunction2(MyClas＆c){cout<<c．data；}

    voidfunction3（）{out<<data；}

    statiCvoidfunction4（）{COut<<data；}

    private：

    intdata；

    }：

    其中有编译错误的函数是（ ）。

    A.function1

    B.function2

    C.function3

    D.function4


    正确答案：D
    D。【解析】静态函数调用非静态变量错误。必须通过对象实例来访问非静态变量。

  • 第4题：

    有如下类定义： class MyClass{ int value； public： MyClass(int n)：value(n){} int getValueconst{retum value；} }； 则类MyClass的构造函数的个数是( )。

    A.1个

    B.2个

    C.3个

    D.4个


    正确答案：B
    本题考查类的默认构造函数和自定义的构造函数、本题中MyClass(intn)：value(n){}为自定义的构造函数，加上默认构造函数，一共有2个构造函数。

  • 第5题：

    若类A和类B的定义如下： class A { int i,j; public: int geti () { return i; } }; class B : public A { int k; public: void make () { k=i*j; } }; 则上述定义中非法的语句是

    A．k=i*j;

    B．int k;

    C．return i;

    D．void make()


    正确答案：A
    解析：本题考核派生类的定义和访问权限。变量i和j都是基类A的私有变量，它们是隐蔽的，在派生类中不能直接访问。

  • 第6题：

    若类A和类B的定义如下:includeclass A{int i*j;public:int geti(){return i;}};class

    若类A和类B的定义如下： #include＜malloc.h＞ class A { int i*j; public: int geti() { return i; } }; class B: public A { int k; public: void make() { k=i*j; } ); 则上述定义中非法的表达式是( )。

    A．k=i*j；

    B．int k；

    C．return i；

    D．void make()；


    正确答案：A
    解析：因为派生类不能访问基类的私有成员i和j(默认情况下，成员的属性为私有)，所以表达式k=i*j是非法的。其余的访问权限都是许可的。

  • 第7题：

    若类A和类B的定义如下： class A { int i,j; public: int geti() { return i; } }; class B: public A { int k; public: void make() { k=i*j } }; 则上述定义中

    A．k=i*j;

    B．int k;

    C．return i;

    D．void make()


    正确答案：A
    解析：本题考核派生类的定义和访问权限。变量i和j都是基类A的私有变量，它们是隐蔽的，在派生类中不能直接访问。

  • 第8题：

    假定用户没有给一个名为MyClas的类定义析构函数，则系统为其定义的默认析构函数形式为【 】。


    正确答案：～MyClas()
    ～MyClas() 解析：析构函数名是在类名前加符号“～”，它既没有返回值，也没有参数。

  • 第9题：

    设有如下程序: include using namespace std; class A { public:int i;display(){co

    设有如下程序： #include ＜iostream＞ using namespace std; class A { public: int i; display() { cout＜＜"class A\n"; } }; class B { public: int i; display() { cout＜＜"class B\n"; } }; class C : public A, public B { int j; public: int i; show ( ) { j = i * i; display(); } }; int main() { C demo; demo.show(); return O; } 则主程序运行时将( )。

    A．因为变量i的重复定义而报错

    B．因为对象demo间接调用display()函数时产生二义性而报错

    C．因为类定义的语法错误而不能运行

    D．没有语法错误，能够正常输出结果


    正确答案：B
    解析：本题主要考察C++中多继承的工作方式和二义性的解决办法。在C++中，允许一个派生类从多个基类派生，这种继承方式称为多继承。多继承的定义格式如下：class派生类名＞：继承方式＞基类名1＞，继承方式2＞基类名2＞，…{派生类类体＞}；但是，如果一个派生类的两个或多个基类中有某个同名成员，在派生类中对这个成员的访问就可能出现二义性；同时，如果一个派生类是由两个或多个基类派生出来的，而这几个基类又有一个共同的基类，对该基类进行访问时，也可能会出现二义性。本题程序中，类C是由类A和类B多继承得到的派生类，但其自身函数show()中调用了display()函数，而这个函数是同时出现在类C的两个基类中的，因此程序会出现二义性，编译器将无法确定调用哪一个display()函数来执行操作，因此报错。解决二义性的通常办法是通过作用域运算符“::”进行限定。

  • 第10题：

    已知类MyClas有一个只需要一个double型参数的构造函数，其将运算符“+”重载为友元函数。要使语句序列 MyClas x(1.2),y(2.3),z(0);z=x+y; 能够正常运行，运算符函数 operator+应在类中声明为( )。

    A．friend MyClas operator+(int,MyClas&);

    B．friend MyClas operator+(MyClas,MyClas);

    C．friend MyClas operator+(MyClas,MyClas&);

    D．friend MyClas operator+(MyClas&,MyClas);


    正确答案：B
    解析：由重载的定义格式可知运算符函数应在类中声明为：friendMyClasoperator+(MyClas,MyClas);

  • 第11题：

    类MyClass的定义如下： class MyClass { public： MyClass(){} MyClass(int i) { value=new int(i)； } int *value； }； 若要对类中的value赋值，则下面的语句中，正确的是( )。

    A．MyClass my;my.value=10；

    B．MyClass my;*my,value=10；

    C．MyClass my;my.*value=10；

    D．MyClass my(10)；


    正确答案：D

  • 第12题：

    若类A和类B的定义如下： class A { int i，j; public： void get()； //… } ； class B:A//默认为私有派生 { int k； public： void make(); //… }; void B::make() { k=i*j； } 则上述定义中， ( )是非法的表达式。

    A．void get()；

    B．int k；

    C．void make()；

    D．k=i*j；


    正确答案：D

  • 第13题：

    若类A和类B的定义如下

    class A

    {

    int i,j;

    public:

    int geti( )

    {

    return i;

    }

    };

    class B:public A

    {

    int k:

    public:

    void make( )

    {

    k=i*j;

    }

    };

    则上述定义中非法的语句是

    A．k=i*j

    B．int k;

    C．return i;

    D．void make()


    正确答案：A
    解析：本题考核派生类的定义和访问权限。变量i和j都是基类A的私有变量，它们是隐蔽的，在派生类中不能直接访问。

  • 第14题：

    有如下程序 include using namespace std;int i=1;class Fun {public:static int i;i

    有如下程序 #include ＜iostream＞using namespace std;int i=1;class Fun {public:static int i;int value(){ return i-1;}int value()const{ return i+1;}};int Fun:: i=2;int main() {int i=3;Fun fun1;const Fun fun2;______________________return ();}若程序的输出结果是:123

    A．cout＜＜fun1.value()＜＜Fun:: i＜＜fun2.value();

    B．cout＜＜Fun::i＜＜fun1.value()＜＜fun2.value();

    C．cout＜＜fun1. value()＜＜fun2.value()＜＜Fun:: i;

    D．cout＜＜fun2.value()＜＜Fun:: i＜＜fun 1.value();


    正确答案：A

  • 第15题：

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

    A．MyClas&(MyClas x);

    B．const MyClas&(MyClas x);

    C．MyClas(const MyClas& x);

    D．MyClas(MyClas& x);


    正确答案：C
    解析：只有选项C符合拷贝构造函数的声明语法。

  • 第16题：

    若有一个MyClas类，则执行语句MyClas a，b(2)，*p；后，自动调用该类的构造函数 ( )次。

    A．2

    B．3

    C．4

    D．不确定


    正确答案：A
    解析：C++在创建一个对象时，会自动调用类的构造函数，在构造函数中可以执行初始化成员变量的操作。题目中语句创建了两个对象a、b和一个对象指针。在创建a和b时，系统会调用类的构造函数。而在创建指针p时，不调用类的构造函数，因为指针p本身不定义类对象，而是定义一个可以指向MyClas对象的指针。

  • 第17题：

    假定MyClas为一个类，那么该类的析构函数是( )。

    A．void～MyClas()；

    B．～MyClas(int n)；

    C．MyClas()；

    D．～MyClas()；


    正确答案：D
    解析：析构函数名为符号“～”加类名，析构函数没有参数和返回值。

  • 第18题：

    有如下程序:includeusing namespace std;int i=1;class Fun{public:static int i;int

    有如下程序： #include＜iostream＞ using namespace std; int i=1; class Fun { public: static int i; int value(){return i-1;} int value()const{return i+1;} }; int Fun::i=2; int main() { int i=3; Fun fun 1; const Fun fun2; ______ return 0; } 若程序的输出结果是： 123 则程序中横线处的语句是( )。

    A．cout＜＜fun1.value()＜＜Fun::i＜＜fun2.value();

    B．cout＜＜Fun::i＜＜fun1.value()＜＜fun2.value();

    C．count＜＜fun.value()＜＜fun2.value()＜＜Fun::i;

    D．cout＜＜fun2.value()＜＜Fun::i＜＜fun1.value();


    正确答案：A
    解析：此题因为定义的变量i是static类型的(main()函数内部的i只是一个局部变量)，所以，选项A)中fun1.value()的返回值是1，Fun::i引用的是外部变量会输出2；fun2.value()；会调用常成员函数int valueoconstfrerun i+1；}使得外部静态变量i的值增加为3，故输出3。

  • 第19题：

    有如下类定义： class Foo { public: Foo(int v) : value(v) { } // ① ～Foo() { } // ② private: Foo() { } // ③ int value = 0; // ④ }; 其中存在语法错误的行是( )。

    A．①

    B．②

    C．⑧

    D．④


    正确答案：D
    解析：此题考查的是类的定义。C++语言规定，在类体内不允许对所定义的数据成员进行初始化。

  • 第20题：

    下面类的定义，有( )处错误。 class MyClass { public: void MyClass(); ～MyClass(int Value); private: int i=0; };

    A．1

    B．2

    C．3

    D．4


    正确答案：C
    解析：上述类的定义共有3处错误。第一处：类的成员变量不能在定义时进行初始化：第二处：类的构造函数不能有返回值(包括void类型)；第三处：类的析构函数不能有参数。

  • 第21题：

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

    class Myclas{

    int *x；

    public：

    MyClas(int n)；

    ～MyClas()；

    }；

    MyClas：：MyClas(intn){

    【 】；

    }

    MyClas：：～MyClas(){

    【 】；

    }


    正确答案：x=new int(n)delete x
    x=new int(n)，delete x 解析：在类的构造函数中，是申请内存空间，并使指针x指向构造函数的形参n，所以构造函数的函数体应为：x=newint(n)；。在析构函数中，是释放类的私有成员，即指针变量x，所以析构函数的函数体应该为deletex；。

  • 第22题：

    若类A和类B的定义如下： class A { public: int i，j; void get(); }； class B：A{ int i, j; protected; int k; public： void make(); }； void B: :make()(k=i*j；} 则其中 ______ 是非法的表达式。

    A．void get();

    B．int k;

    C．void make();

    D．k=i*j;


    正确答案：D

  • 第23题：

    设有如下程序:include class A{public:int i;display(){ cout<<"class A\n"; }};c

    设有如下程序：#include ＜iostream. h＞class A{public:int i;display(){ cout＜＜"class A\n"; }};class B{public:int i;display(){ cout＜＜"class B\n"; }};class C: public: A, public: B{int j;public:int i;show(){ j=i*i; display(); }};void main(){C demo;demo. show();}则主程序运行时，将( )。

    A．因为变量i的重复定义而报错

    B．因为对象demo间接调用display函数时产生歧义性而报错

    C．因为类定义的语法错误而不能运行

    D．没有语法错误，能够正常输出结果


    正确答案：B

相关内容