c++知识题

C++语言程序设计    
一、选择题  

1.下面有关重载函数的说法中正确的是（C）  
A重载函数必须具有不同的返回值类型；

B重载函数形参个数必须不同；　　  
C重载函数必须有不同的形参列表　

D重载函数名可以不同；  
2.下列关于构造函数的描述中，错误的是（D）  
A构造函数可以设置默认参数；　

B构造函数在定义类对象时自动执行　　 

C构造函数可以是内联函数；

D构造函数不可以重载 

3下面描述中，表达错误的是（B）  
A公有继承时基类中的public成员在派生类中仍是public的　　  
B公有继承是基类中的private成员在派生类中仍是private的　　  
C公有继承时基类中的protected成员在派生类中仍是protected的　　  
D私有继承时基类中的public成员在派生类中是private的  
4下面关于虚函数和函数重载的叙述中，不正确的是( A )

 A. 虚函数不是类的成员函数

 B. 虚函数实现了C++的多态性

 C. 函数重载允许非成员函数，而虚函数则不行

 D. 函数重载的调用根据参数的个数、序列来确定，而虚函数依据对象确定

 5.关于类和对象不正确的说法是( C )

 A. 类是一种类型，它封装了数据和操作

 B. 对象是类的实例

 C. 一个类的对象只有一个

 D. 一个对象必属于某个类

 6. 在类定义的外部，可以被访问的成员有（ C）

 A. 所有类成员

 B. private或protected的类成员

 C. public的类成员

D. public或private的类成员

 7. 关于this指针的说法错误的是（ A ）

A.this指针必须显示说明

B. 当创建一个对象后，this指针就指向该对象

C. 成员函数拥有this指针

D. 静态成员函数不拥有this指针

 8. 对静态成员的不正确描述是  ( C )

 A. 静态成员不属于对象，是类的共享成员

 B. 静态数据成员要在类外定义和初始化

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

 D. 非静态成员函数也可以操作静态数据成员

9. 在创建派生类对象时，构造函数的执行顺序是（  D）

 A. 对象成员构造函数、基类构造函数、派生类本身的构造函数

 B. 派生类本身的构造函数、基类构造函数、对象成员构造函数

 C. 基类构造函数、派生类本身的构造函数、对象成员构造函数

 D. 基类构造函数、对象成员构造函数、派生类本身的构造函数

10. 下面对析构函数的正确描述是（ C ）

 A. 系统不能提供默认的析构函数

 B. 析构函数必须由用户定义

 C. 析构函数没有参数

 D. 析构函数可以设置默认参数

11. 下面对友元的错误描述是（  D）

 A. 关键字friend用于声明友元

 B. 一个类的成员函数可以是另一个类的友元

 C. 友元函数访问对象的成员不受访问特性影响

 D. 友元函数通过this指针访问对象成员

 12. 下列关于类的继承描述中，错误的是（ A）

 A. 派生类可以访问基类的所有数据成员，也能调用基类的所有成员函数

 B. 派生类也是基类，但基类不一定具有派生类的全部属性和方法

 C. 继承描述类的层次关系，派生类可以具有与基类相同的属性和方法

 D. 一个基类可以有多个派生类，一个派生类可以有多个基类

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

 A. public成员

B. private成员

 C. protected成员

D. 友元

14．如果派生类以proctected方式继承基类，则原基类的protected和public成员在派生类的访问性分别是：（   D   ）

A．public和public

B．public和protected

C．protected和public

D．protected和protected

15．派生类的成员函数不能访问基类的：（   C  ）

A．共有成员和保护成员

B．共有成员

C．私有成员

D．保护成员

16．按照“后进先出”原则组织数据的数据结构是（  B ）

A．队列

B．栈

C．双向链表

D．二叉树

17.下列关于虚函数的说明中，正确的是：（   B  ）

A．从虚基类继承的函数都是虚函数

B．虚函数不得是静态成员函数

C．只能通过指针或者引用调用虚函数

D．抽象类中的中的成员函数都是虚函数。

18．有如下类的定义：

ClassMyClass

{

intvalue;

public:MyClass(int n):value(n){}

intgetValue() const {return value;}

}

则类Myclass的构造函数的个数是：（   B  ）

A．1个

B．2个

C．3个

D．4个

19．有如下类的定义：

classConstants

{ 

public:   static double GetPI(void){return 3.14159;}

}; 

Constantsconstants;

下列各组语句中，能输出3.14159的是： （   D  ）

A．cout<<constants->GetPI();和cout<<Constants::GetPI(); 

B．cout<<constants.GetPI();和cout<<Constants.GetPI(); 

C．cout<<constants->GetPI();和cout<<Constants->GetPI(); 

D．cout<<constants.GetPI();和cout<<Constants::GetPI();

20．有如下程序：

 

} 

运行时的输出结果是：（   A ）

A．5   3  

B．3   5

C．5   5  

D．3   3

21．查看下面两段代码,描述结果正确的是 ( B )

(1)

classclassA {...};

classclassB

{

    public:

        classB(classAa) {mA = a;}

    private:

        classAmA;

};

(2)

classclassA {...};

classclassB

{

    public:

        classB(classAa): mA(a) {}

    private:

        classAmA;

};

A.  两种方法产生的结果和效率完全相同
B.   通常情况下（2）的效率更高
C.   通常情况下（1）的效率更高
D.   两种调用方法会产生不同的结果

22. 以下哪个运算符不允许重载?  ( C  )

A.   ()

B.   ->

C.   .(成员提取符号)

D.  []

23. 以下哪种不属于类成员?  (B  )

A.   类的静态成员

B.   类的友元

C.   类的常量成员

D.   虚函数

24. 以下哪种不属于C++编译器默认提供的类成员?  (B  )

A.   析构函数

B.   赋值函数

C.   拷贝构造

D.   有参构造

25. 关于指针和引用描述不正确的是?  (B  )

A.   引用不能为空,指针可以为空

B.   程序需要给指针和引用分配空间

C.   引用一旦定义后不可变,指针可变

D.   引用比指针更安全

 

二、程序分析题
1． # include <iostream.h>

class  A{

public: int x;

       A(int a=0) { x=a;}

};

class B:public virtualA{

public: int y;

       B(int a=0,int b=0): A(a) {y=b;}

};

class C:publicvirtual A{

public: int z;

       C(int a=0,int c=0):A(a){z=c;  }

};

class D:publicB,public C{

public: int dx;

       D(int a1,int b,int c,int d,inta2):B(a1,b),C(a2,c)

       {      dx=d;}

};

void  main(void)

{      D d1(10,20,30,40,50);   

        cout<<d1.x<<endl; 

}

程序运行后的输出结果   0

2． # include <iostream>

class  A{

public: int x;

       void Setx(x)  {this->x=x;}

};

void main()

{

  A* pa =A[3];

  pa[0].Setx(0);

pa[1].Setx(1);

pa[2].Setx(2);

delete pa;

}

以上程序存在什么问题,: 程序会存在内存泄露,new 出来了3个对象,但delete pa 只会析构一个对象.

3．

class  Str

{

int Length;  

char  *Sp;

public:

Str(char *string)

{

if(string)

{

Length=strlen(string);

       Sp=newchar[Length+1];

      strcpy(Sp,string);   

}

     else

Sp=0;

  }

~Str()

{   

if(Sp)    delete []Sp;      

}

};

void main(void)

{      Strs1("Study C++");

       Str s2(s1);

}

以上程序存在什么问题? 崩溃,默认的拷贝构造函数引起浅拷贝,会造成成员变量Sp所指向的空间被析构两次,

三.简单题

1.什么是“引用”？申明和使用“引用”要注意哪些问题？

   引用就是某个目标变量的“别名”(alias)，对应用的操作与对变量直接操作效果完全相同。申明一个引用的时候，切记要对其进行初始化。引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，不能再把该引用名作为其他变量名的别名。声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。不能建立数组的引用。

2、重载（overload)和覆盖”(overried）的区别？

重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。重写：是指子类重新定义复类虚函数的方法。从实现原理上来说：重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数。重写：当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。

3. C++类中关键字static和Const 的作用

1.      在类的static 成员变量属于整个类所拥有，对类的所以对象只有一份拷贝

2.      类中的 static 成员函数属于整个类所拥有，这个函数不接收 this 指针，因而只能访问类的 static 成员变量

3. const 修饰类的成员变量，表示成员常量，不能被修改。

4. const修饰函数承诺在本函数内部不会修改类内的数据成员，不会调用其它非 const 成员函数。

5. 如果 const 构成函数重载，const 对象只能调用 const 函数，非 const 对象优先调用非 const 函数。

6. const 函数只能调用 const 函数。非 const 函数可以调用 const 函数。

7. 类体外定义的 const 成员函数，在定义和声明处都需要 const 修饰符。。

4. 什么时候要用虚析构函数

 通过基类的指针来删除派生类的对象时，基类的析构函数应该是虚的。否则其删除效果将无法实现。

 一般情况下，这样的删除只能够删除基类对象，而不能删除子类对象，形成了删除一半形象，从而千万内存泄漏。

 原因：

  在公有继承中，基类对派生类及其对象的操作，只能影响到那些从基类继承下来的成员。

如果想要用基类对非继承成员进行操作，则要把基类的这个操作（函数）定义为虚函数。那么，析构函数自然也应该如此：如果它想析构子类中的重新定义或新的成员及对象，当然也应该声明为虚的。

 注意:;  如果不需要基类对派生类及对象进行操作，则不能定义虚函数（包括虚析构函数），因为这样会增加内存开销。

5.构造函数和析构函数的调用顺序? 析构函数为什么要虚拟?

构造函数的调用顺序：基类构造函数—对象成员构造函数—派生类构造函数；析构函数的调用顺序与构造函数相反。析构函数虚拟是为了防止析构不彻底，造成内存的泄漏。  

6.简单叙述实现动态多态性的必要条件?
1.基类中声明虚函数;

2.派生类中覆盖该虚函数;

3.用基类的指针(或引用)来接收派生类对象地址;  

7.  哪几种情况必须用到初始化成员列表?

1：类的成员是常量成员初始化；

2.类的成员是对象成员初始化，而该对象没有无参构造函数。

3.类的成员为引用时。

4.派生类向基类进行参数传递

四、编程题

1.判断数组a[N]是否为一个递增数组。

bool fun( int a[], int n )

{

if( n= =1 )

return true;

if( n= =2 )

return a[n-1] >= a[n-2];

return fun( a,n-1) && ( a[n-1] >= a[n-2] );

｝

2.设计一个栈的数据结构,实现压栈和弹栈的方法;

template <class TYPE>

class CStack

{

       TYPE*m_pData;

       int m_nTop;

       int m_nCount;

public:

       boolisFull();

       boolisEmpty();

       voidpush(const TYPE& data);

       boolpop(TYPE& t);

       CStack(intnCount =8);

       virtual~CStack();

};

 

CStack::CStack(int nCount)

{

       m_nCount=nCount;

    m_nTop=-1;

       m_pData =newTYPE [nCount];

}

virtual CStack::~CStack()

{

       delete[]m_pData;

}

 

bool CStack::isFull()

{

       returnm_nTop+1>m_nCount;

}

bool CStack::isEmpty()

{

       returnm_nTop<0;

}

void CStack::push(const TYPE& data)

{

       if(isFull())

              return;

     m_nTop++;

        m_pData[m_nTop] =data;

 

}

bool CStack::pop(TYPE& t)

{

       if(isEmpty())

       {

              returnfalse;

       }

       t=m_pData[m_nTop];

       m_nTop --;

    return true;

}