37、设有以下类和对象的定义:class A {public: int k; }; A x1,x2,*p1,*p2; 则下面针对成员变量k的引用，正确的是（）。A．x1-＞k=1;B．x2.k=2;C．p1.k=3;D．(*p2)-＞k=4;

题目

37、设有以下类和对象的定义:class A {public: int k; }; A x1,x2,*p1,*p2; 则下面针对成员变量k的引用，正确的是（）。

A．x1-＞k=1;

B．x2.k=2;

C．p1.k=3;

D．(*p2)-＞k=4;

相似考题

1.有如下类定义：class MyBase{int k;public;MyBase（int n=0）:k（n）{}int value（）const{return k;}};class MyDerived; MyBase{int j;public;MyDerived（int i）: j（i）{}int getK（）const {return k;}int gutj（）const{return j;}};编译时发现有一处语法错误，对这个错误最佳准确的描述是____A．函数getK 试图访问基类的私有成员变量KB．在类MyDerived 的定义中，基类名MyBase 前缺少关键字public、protected 或privateC．类MyDerived 缺少一个无参的构造函数D．类MyDerived 的构造的数没有对基数数据成员K 进行初始化

2.（ 31 ） 有如下类定义 ：class MyBase{int k;public:MyBase(int n=0):k(n){ }int value( )const{ return k;}};class MyDerived: MyBase{int j;public:MyDerived(int i): j(i) {}int getK( )const{ return k; }int getJ( )const{ return j; }};编译时发现有一处语法错误 ， 对这个错误最准确的描述是A ）函数 getK 试图访问基类的私有成员变量 kB ） 在类 MyDerived 的定义中，基类名 MyBase 前缺少关键字 public ,protected 或 privateC ）类 MyDerived 缺少一个无参的构造函数D ）类 MyDerived 的构造函数没有对基类数据成员 k 进行初始化

3.有如下类定义： class MyBase { int k; public: MyBase(int n=0):k(n) { } int value( )const{ return k;} }; class MyDerived: MyBase { intj; public: MyDerived(int i): j(i) {} int getK( )const{ return k; } int getJ( )const{ return j; } }; 编译时发现有一处语法错误，对这个错误最准确的描述是A．函数getK试图访问基类的私有成员变量kB．在类MyDerived的定义中，基类名MyBase前缺少关键字public、protected或privateC．类MyDerived缺少一个无参的构造函数D．类MyDerived的构造函数没有对基类数据成员k进行初始化

4.设p1和p2是指向同一个int型一维数组的指针变量，k为int型变量，则下列不能正确执行的语句是（ ）。A．k=*p1+*p2 B．p2=kC．p1=p2 D．k=*p1*(*p2)

更多“37、设有以下类和对象的定义:class A {public: int k; }; A x1,x2,*p1,*p2; 则下面针对成员变量k的引用，正确的是（）。”相关问题

  • 第1题：

    设有以下类和对象的定义： class A {public： int m； }； A k1，k2，*p1，*p2； 则下面针对成员变量m的引用，错误的是( )。

    A．k1.m＝1

    B．k2-＞m＝2

    C．p1-＞m＝3

    D．(*p2).m＝4


    正确答案：B
    解析： A*pl，A*p2为指向A类对象的指针，故p1→m＝3，(*p2).m=4是正确的。但k2不是指针，k2→m的表示是错误的。

  • 第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*j

    B．int k;

    C．return i;

    D．void make();


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

  • 第3题：

    若类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的私有变量，它们是隐蔽的，在派生类中不能直接访问。

  • 第4题：

    设有以下程序: include using namespace std; int main() {inta,b,k:4,m=6,*p1=&k

    设有以下程序：

    include＜iostream＞

    using namespace std；

    int main()

    {

    int a，b，k：4，m=6，*p1=&k，*p2=&m；

    a=p1==&m；

    b=(*p1)／(*p2)+7；

    cout＜＜a＜＜b＜＜end1；

    return 0；

    }

    执行该程序后，a的值为【 】，b的值为【 】。


    正确答案：0 7
    0 7 解析：本题考核的知识点是有关指针的运算。程序中定义了两个指针变量p1和p2，并通过赋初值让它们分别指向了变量k和m。语句“a=p1==&m；”中先执行关系运算符“p1==&m”，显然是0(假)，然后把0赋值给a。接着执行语句“b=(*p1)／(*p2)+7”，此处*p1的值就是k的值4，*p2的值就是m的值6，即把“4／6+7”的结果赋给b，b的值为7。

  • 第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题：

    有如下类声明： class MyBASE{ int k； public： void set(int n){k=n；} int get( )const{return k；} }； class MyDERIVED：protected MyBASE{ protected： intj； public： void set(int m，int n){MyBASE::set(m)；j=n；} int get( )const{return MyBASE::get( )+j；} }； 则类MyDERIVED中保护的数据成员和成员函数的个数是

    A．4

    B．3

    C．2

    D．1


    正确答案：B
    解析：在保护派生的单继承中，基类的公有数据成员和成员函数在派生类中成为保护成员。

  • 第7题：

    设p1和p2是指向一个int型一维数组的指针变量,k为int型变量,则不能正确执行的语句是

    A．k=*p1+*p2

    B．p2=k;

    C．p1=p2;

    D．k=*p1*(*p2);


    正确答案：B
    解析：本题主要考查了一维数组指针的赋值和用指针引用数组元素进行运算。选项B)中p2为指向int型变量的指针,而k为int型变量,不能将int型变量直接赋值给指向int型变量的指针,所以选项B)错误。

  • 第8题：

    下面是类MyClass的定义，对定义中各语句描述正确的是( )。 class MyClass { private: int x,y, z; public: void MyClass(int A) { x=a; } //① int f(int a, int B) //② { x=a; y=b; } int f(int a,

    A．语句①是类MyClass 的构造函数的定义

    B．语句②和③实现类成员函数的重载

    C．语句④实现对类成员变量x的更新操作

    D．语句①、②、③和④都不正确


    正确答案：D
    解析：在C++中构造函数没有返回类型，所以语句①是错误的。语句②和语句③在进行f(x,y)调用时会产生二义性。静态成员函数不能直接访问类中说明的非静态成员。所以语句④也是错误的。

  • 第9题：

    若类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

  • 第10题：

    已知类X的定义如下，为了实现将对象成员k的值修改为678，下面的哪条语句是正确的 ______。 class X{ private： int k； public： K(int n){k=n；} set(int n){k=m;} }； void fun(){ X a(10)，*p=&a; ______ }

    A．p-＞set(678)；

    B．X(678)：

    C．p-＞k=678；

    D．p.set(678)；


    正确答案：A

  • 第11题：

    若有以下程序:includeusing namespaces std;class A{public:A(){}A(int i){x1=i; } v

    若有以下程序： #include＜iOStream＞ using namespaces std； class A { public： A(){} A(int i) { x1=i； } void dispa() { cout＜＜"X1="＜＜x1＜＜","： } private； int x1； }； class B：public A { public： B(){} B(int i)：A(i+10) { x2=i； } void dispb() { dispa()； cout＜＜"x2="＜＜x2＜＜end1； } private： int x2； }； ． int main() { B b(2)； b．dispb() return 0； } 程序运行后的输出结果是( )。

    A．x1=10,x2=2

    B．x1=12,x2=10

    C．x1=12,x2=2

    D．x1=2,x2=2


    正确答案：C
    解析：本题考核派生类的构造函数。在C++中，构造函数不能被继承，因此，派生类的构造函数必须通过调用基类的构造函数来初始化基类子对象。所以，在定义派生类的构造函数时，除了对自己的数据成员进行初始化外，还必须负责调用基类构造函数使基类的数据成员得以初始化。如果派生类中还有子对象，还应包含对于对象初始化的构造函数。

  • 第12题：

    以下程序的运行结果为:public class A {static int k=3;public static void main(String[] args) {int k=4;A x1=new A();x1.k＋＋;A x2=new A();x2.k＋＋;k＋＋;System.out.println(x1.k);}}

    A. 3

    B. 4

    C.5

    D.6

    E.7


    正确答案：C

  • 第13题：

    （ 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

  • 第14题：

    有如下类声明： class MyBASE { int k： public; void set(int n){k=n;} int get() const{return k;} }; class MyDERIVED: protected MyBASE { protected: int j; public: void set(int m, int n){MyBASE::set(m);j=n;} int get() const{return MyBASE::get()+j;} }; 则类MyDERIVED中保护的数据成员和成员函数的个数是( )。

    A．4

    B．3

    C．2

    D．1


    正确答案：B

  • 第15题：

    对下面程序描述正确的是()。 include < iostream > using namespace std; class A { private:int

    对下面程序描述正确的是( )。 #include ＜ iostream ＞ using namespace std; class A { private: int i; public: class B { private: int j; protected: int k; int fun1 ( ); } MyB; int fun2 ( ); }

    A．定义类B的对象的语句是： A：：B b；

    B．类A的成员函数fun2()可以用MyB．j的方式访问类B的私有成员j。

    C．类A的成员函数fun2()可以用MyB．k的方式访问类B的保护成员k。

    D．类B的成员函数fun1()可以直接访问类A的私有成员i。


    正确答案：A
    解析：内嵌类的成员函数对包容类的成员没有访问特权，反之亦然。

  • 第16题：

    有如下类声明： class MyBASE{ int k; public: void set(iht n){k=n;} int get()coast{return k;} }; class MyDERIVED:pnoted My BASE { protected: int j; public: void set(int m，int n){MyBASE::set(m);j=n;} int get()const{return MyBASE::get()+j;} }; 则类MyDERIVED中保护的数据成员和成员函数的个数是

    A．4

    B．3

    C．2

    D．1


    正确答案：B
    解析：protected派生：pnvate-＞不可见；protected-＞private;public-＞protected。

  • 第17题：

    若类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是非法的。其余的访问权限都是许可的。

  • 第18题：

    若类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的私有变量，它们是隐蔽的，在派生类中不能直接访问。

  • 第19题：

    设p1和p2是指向一个血型一维数组的指针变量，k为int型变量，则不能正确执行的语句是

    A．k=*p1+*p2

    B．p2=k；

    C．p1=p2；

    D．k=*p1*(*p2)；


    正确答案：B
    解析： 本题主要考查了一维数组指针的赋值和用指针引用数组元素进行运算。选项B)中p2为指向int型变量的指针，而k为int型变量，不能将int型变量直接赋值给指向int型变量的指针，所以选项B)错误。

  • 第20题：

    设有以下类和对象的定义： ClaSSA {public： intm； }； Ak1，k2，*p1，*p2； 则下面针对成员变量m的引用，错误的是（ ）。

    A.k1．m=1

    B.k2→m=2

    C.p1→m=3

    D.(*p2)．m=4


    正确答案：B
    B。【解析】A*p1，A*p2为指向A类对象的指针，故“p1→m=3，(*p2)．m=4”是正确的。但k2不是指针，k2→m的表示是错误的。

  • 第21题：

    若类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

  • 第22题：

    设有以下定义：class person{int num；char name[10]；public：void init (int n, char *m)；┇}；person std [30]；则下面叙述中，不正确的是( )。

    A．std是一个含有30个元素的对象数组

    B．std数组中的每个元素都是person类的对象

    C．std数组中的每个元素都有自己的私有变量num和name

    D．std数组中的每个元素都有各自的成员函数init


    正确答案：D

  • 第23题：

    设p1和p2均为指向int型的指针变量,k为int型变量,下列不正确的赋值语句是(C)。

    A.k=*p1+*p2

    B.k=*p1*(*p2)

    C.p2=k

    D.p1=p2


    正确答案：C

  • 第24题：

    若有类W说明class W{int a；public：voidfConst（int&）const；}；，则函数fConst的正确定义是（）

    • A、void W：：fConst（int&k）const{k=a；}
    • B、void W：：fConst（int&k）const{k=a++；}
    • C、void W：：fConst（int&k）const{cin>>a；}
    • D、void W：：fConst（int&k）const{a=k；}

    正确答案:A

相关内容