考试题改错

6、有以下程序

int i = 0;

void fun()

{   { static int i = 1;

     cout<<i++<<',';}

cout<<i<<',';

}

int main()

{  fun();  fun();

   return 0;

}；程序执行后的输出结果是(D)

A)1,2,1,2,   B)1,2,2,3,   C)2,0,3,0,  D)1,0,2,0,

在变量前加上static，这个变量就会变成静态变量。由于存入静态取的变量只会初始化一次，且在程序结束之前都不会被删除，于是第二次呼叫fun函数时，静态区的i会累加得到2。于是这程序输出结果是1，0，2，0

1. C++的程序中，对变量一定要先说明再使用，说明只要在使用之前就可以。√

42. 在公有继承中，基类中只有公有成员对派生类对象是可见的。√

50. 函数的定义不可以嵌套，类的定义可以。√

51. 派生类是从基类派生出来，它不能再派生出其他类。

52. 派生类的继承方式中有两种:公有继承和私有继承。×

58. 对象数组的既可以赋初值又可以赋值。√

1. 运算符重载的形式有两种:成员函数和普通函数。√

以上这句些显然是对的，本想在C++标准里找到原文的，可惜我眼瞎没找到＝ ＝

1. .在一个类中可以定义 多个构造函数， 1个析构函数。

好吧，无数个的话，内存会不够的。题应该改成“最多”＝ ＝

88. 类A有如下成员函数：

int A::fun(double x){return (int) x／2；}

int A::fun(int x){return x*2；}，设a为类A的对象，在主函数中执行语句int s=a.fun(6)+a.fun(2.0)后的s值为__13__。

gcc处理函数重载的方法是在编译时重写函数名什么的。像这样：（无关部分退散）

0x0000000100000dc8 <main+24>:callq  0x100000e92 <dyld_stub__ZN1A3funEi>

0x0000000100000dcd <main+29>:lea    -0x8(%rbp),%rdi

0x0000000100000dd1 <main+33>:movsd  0xef(%rip),%xmm0        # 0x100000ec8

0x0000000100000dd9 <main+41>:mov    %eax,-0xc(%rbp)

0x0000000100000ddc <main+44>:callq  0x100000e8c <dyld_stub__ZN1A3funEd>

结果当然就是13了。还是不会的话把答案背下来（够

91. 在下划线处填上缺少的部分。

class complex{

public：

int real；

int imag；

complex(int r=0，int i=0){

real=r；

imag=i；}

}；

complex operator+(__complex &a___，  complex& b  ){

int r=a.real+b.real；

int i=a.imag+b.imag；

return__complex(r,i)；  //将结果以对象方式返回}

void main(){

complex x(1，2)，y(3，4)，z；

z=x+y；

cout<<z.real<<″+″<<z.imag<<″i″<<endl；}

98. 对静态成员的不正确描述是（ c  ） 

A) 静态成员不属于对象，是类的共享成员    B) 静态数据成员要在类外定义和初始化

1. 调用静态成员函数时要通过类或对象激活，所以静态成员函数拥有this指针 

同一个类的所有对象公用同一个静态成员，

99. 下面选项中，不是类的成员函数为（  C ）

A) 构造函数          B) 析构函数              C）友元函数           D) 缺省参数的构造函数方言

102. 当一个派生类私有继承一个基类时，基类中的所有仅有成员和保护成员成为派生类的（  B ） 

A) public成员    B) private成员       C) protected成员              D) 友元 

113. 关于面向对象的程序设计方法，下列说法正确的是(D)

A)“封装性”指的是将不同类型的相关数据组合在一起，作为一个整体进行处理

B)“多态性”指的是对象的状态会根据运行时要求自动变化

C)基类的私有成员在派生类的对象中不可访问，也不占内存空间

D)在面向对象的程序设计中，结构化程序设计方法仍有着重要作用

124. 请将如下程序补充完整，使得输出结果为bbaa

class A {

public:

~A()  {cout<<"aa";}

};

class B :public A{

public:

~B(){cout<<"bb";}

};

int main (){

B*p=new B;

delete p;

return 0;}

125. Sample是一个类，执行下面语句后，调用Sample类的构造函数的次数是(D)

Sample a[2], *p = new Sample;
A）0　　B）1　　C）2　　D）3

126. 有以下程序

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类的拷贝构造函数被调用的次数是(B)

A)5    B)4    C)3    D)2

186. 下列程序的输出结果是  0 4 2 。

class Test {

public:

     Test() { cnt++; }

     ~Test() {cnt--; }

     static int Count() { return cnt;}

private:

     static int cnt;

};

int Test::cnt = 0;

int main()

{    cout << Test::Count() <<' ';

     Test tl, t2;

     Test * pT3 = new Test;

     Test* pT4 = new Test;

     cout << Test::Count() <<' ';

     delete pT4;

     delete pT3;

     cout << Test::Count() << endl;

return 0;}

188. 有如下程序

  class myclass{

     public:

         myclass(){++count;}

         ~myclass(){--count;}

     static int getcount(){return count;}

private:

static int count;};

int myclass::count=0;

int main(){

   myclass obj;

   cout<<obj.getcount();

   myclass *ptr=new myclass;

   cout<<myclass::getcount();

   delete ptr;

   cout<<myclass::getcount();

   return 0;

}，程序的输出结果是（A）

A 121      B 232     C 221    D 122

189. 有如下程序：

class Toy{
　　public:
　　    Toy(char* _n) { strcpy (name,_n); count++;}
　　    ~Toy(){ count--; }
　　    char *GetName(){ return name; }
　　    static int getCount(){ return count; }
　　private:
　　    char name[10];
　　    static int count;
　　};
　　int Toy::count=0;
　　int main(){
　　    Toy t1(“Snoopy”),t2(“Mickey”),t3(“Barbie”);
　　    cout<<t1.getCount()<<endl;
　　return 0;
　　}，运行时的输出结果是(C)
A）1　　B）2　　C）3　　D）运行时出错

191. 有如下程序：

class point {

public:

static int number;

public:

point(){number++;}

~point(){number--;}

};

int point::number=0;

void main(){

point *ptr;

point A,B;

{point *ptr_point=new point[3];

ptr=ptr_point;}

point C;

cout<<point::number<<endl;

delete [] ptr;

}，运行时输出的结果是(C)

A）3    B）4    C）6    D）7

194. 下列程序的输出结果是  2 5 。

class base {

  public:

     int n;

     base(int x) { n = x;}

     virtual void set(int m) { n = m; cout << n <<' ';}

};

class deriveA:public base {

  public:

     deriveA(int x):base(x) { }

     void set(int m) { n += m; cout << n <<' ';}

};

class deriveB:public base {

  public:

    deriveB(int x):base(x) { }

     void set(int m) { n +=m; cout <<n << ' ';}

};

int main()

{    deriveA dl(1);

     deriveB d2(3);

     base *pbase;

     pbase = &dl;

     pbase->set(1);

     pbase = &d2;

     pbase->set(2);

     return 0;}

195. 有如下程序

class Base{

int a,b;

public:

Base(int x ,int y) { a=x; b=y;}

void show(){ cout<<a<<','<<b<<endl;}

};

class Derived:public Base {

int c ,d;

public:

Derived(int x,int y,int z,int m):Base(x,y){c=z; d=m;}

void show(){ cout<<c<<','<<d<<endl;}

};

int main()

{Base B1(50,50),*pb;

Derived D1(10,20,30,40);

pb=&D1;

pb->show();

return 0;}，运行时输出的结果是(A)

A）10，20 B）30，40 C）20，30 D）50，50

196. 有如下程序：

   class base{

     public:

         void output(){cout<<1;}

         void print() {cout<<'B';}

        };

       class derived:public base{

        public:

            void output(){cout<<2;}

            void print(){cout<<'D';}

        };

  int main(){

derived *ptr=new derived;

base * passnew=ptr;

             ptr->output();

             ptr->print();

             delete ptr;

             return 0;}，程序的输出结果是(D)

    A 1B        B 1D     C 2B     D 2D

197、有如下程序： 

     class B{

     public:

       virtual void show(){cout<<'B';}

     };

     class D:public B {

     public:

       void show(){cout<<'D';}

     };

       void fun1(B *ptr){ptr->show();}

       void fun2(B &ref){ref.show();}

       void fun3(B b){b.show();}

       int main(){

          B b,*p=new D;

          D d;

          fun1(p);

          fun2(b);

          fun3(d);

          return 0;

        };，程序的输出结果是(C)

  A DBD       B BBD      C DBB      D DBD

198、下列选项中，与实现运行时多态性无关的是（A）。

A）重载函数    B）虚函数      C）指针 D）引用

205. 下面程序的输出结果是（  C     ）

class Base

{  public:

  virtual void f() { cout << “f0+”; }

  void g() { cout << “g0+”; }

};

class Derived : public Base

{

  public:

  void f() { cout << “f+”; }

  void g() { cout << “g+”; }

};

void main() { Derived d;  Base *p = &d;  p->f();  p->g(); }

A）f+g+ B）f0+g+C）f+g0+ D）f0+g0+

208. 已知程序中已经定义了函数test，其原型是int test(int, int, int);，则下列重载形式中正确的是(B)

A ) char test(int,int,int);  B ) double test(int,int,double);

C ) int test(int,int,int=0);  D ) float test(int,int,float=3.5F);

210. 以下哪一关键字可用于重载函数的区分（  C     ）

A）extern B）static C）constD）virtual

214、下列关于运算符重载的描述中，正确的是（A）

A 运算符重载为成员函数时，若参数表中无参数，重载的是一元运算符

B 一元运算符只能作为成员函数重载

C 二元运算符重载为非成员函数时，参数表中有一个参数

D C++中可以重载所有的运算符

215、若将一个双目运算符重载为类的成员函数，其形参个数应该是  1 个。

224、利用表达式a[i]可以访问int型数组a中下标为i的元素。在执行了语句int *p=a;后，利用指针p也可访问该元素，相应的表达式是   *(p+i)  。

228、有如下程序：

class pumpkin{ 

public:

pumpkin(){++count;}

~pumpkin(){--count;}

static void total_count(){

cout<<count<<"pumpkin(s)"<<endl;

} 

private: 

static int count; 

};

int pumpkin::count=0;

int main(){

pumpkin pl[10];

pumpkin::total_count();

return 0; 

}，这个程序的输出结果是__10pumpkin(s)__。

230、关于动态存储分配，下列说法正确的是(B)

A)new和delete是C++语言中专门用于动态内存分配和释放的函数

B)动态分配的内存空间也可以被初始化

C)当系统内存不够时，会自动回收不再使用的内存单元，因此程序中不必用delete释放内存空间

D)当动态分配内存失败时，系统会立刻崩溃，因此一定要慎用new

233、如果派生类以public方式继承基类，则原基类的protected成员和public成员在派生类中的访问类型分别是(D)

  A public和 public     B public和protected      C.protected 和 public        D protected 和 protected

239、下列有关继承和派生的叙述中，正确的是( C  )

A）派生类不能访问通过私有继承的基类的保护成员

B）多继承的虚基类不能够实例化

C）如果基类没有默认构造函数，派生类就应当声明带形参的构造函数

D）基类的析构函数和虚函数都不能够被继承，需要在派生类中重新实现

242、下面程序的输出结果是（    C   ）

class Base 

{ public:

  Base(int i) { cout << i; }

  ~Base () { }

};

class Base1: virtual public Base 

{  public:

  Base1(int i, int j=0) : Base(j) { cout << i; }

  ~Base1() {}

};

class Base2: virtual public Base 

{  public:

  Base2(int i, int j=0) : Base(j) { cout << i; }

  ~Base2() {}

};

class Derived : public Base2, public Base1 

{  public:

  Derived(int a, int b, int c, int d) : mem1(a), mem2(b), Base1(c), Base2(d), Base(a)                                     

    { cout << b; }

  private:

  Base2 mem2;

  Base1 mem1;

};

void main() { Derived objD (1, 2, 3, 4); }

A）134122 B）123412 C）14302012D）143212

246、建立一个有成员对象的派生类对象时，各构造函数体的执行次序为（C）。

A）派生类、成员对象类、基类    B）成员对象类、基类、派生类

C）基类、成员对象类、派生类     D）基类、派生类、成员对象类