则正确的说法是（）。
(2分)
A.x数组和y数组的长度相同
B.x数组的长度大于y数组的长度
C.x数组的长度小于y数组的长度
D.x数组与y数组等价
(2分)
A.一个用于指向函数的指针变量
B.一个返回值为指针型的函数名
C.一个用于指向一维数组的行指针
D.一个用于指向int型数据的指针变量
(2分)
A.可以用一个空指针赋值给某个指针
B.一个指针可以加上一个整数
C.两个指针可以进行加法运算
D.两个指针在一定条件下，可以进行相等或不相等的运算
B）当指针指向数组时，指针加上一个整数表明基于当前位置向后移动的元素个数
D）两个指针指向同一个数组，就可以进行相等运算，还可以比较大小
(2分)
A.定义line是一个数组，每个数组元素是一个基类型为char为指针变量
B.定义line是一个指针变量，该变量可以指向一个长度为6的字符型数组
C.定义line是一个指针数组，语句中的*号称为间址运算符
D.定义line是一个指向字符型函数的指针
(2分)
A.一个用于指向函数的指针变量
B.一个返回值为指针型的函数名
C.一个用于指向float型数据的指针数组
D.一个用于指向float型数据的指针变量
(2分)
A.类是一种类型，它封装了数据和操作
B.对象是类的实例
C.一个类的对象只有一个
D.一个对象比属于某个类
(2分)
A.构造函数
B.析构函数
C.友元函数
D.拷贝构造函数
(2分)
A.枚举
B.类
C.数组
D.函数
(2分)
A.一致性
B.分类性
C.多态性
D.标识唯一性
(2分)
A.构造函数可以重载，析构函数不能重载
B.构造函数不能重载，析构函数可以重载
C.构造函数可以重载，析构函数也可以重载
D.构造函数不能重载，析构函数也不能重裁
(2分)
A.结构
B.枚举
C.指针
D.引用
答案：D
(2分)
A.内联函数
B.重载函数
C.递归调用
D.嵌套调用
(2分)
A.p=x
B.p=q
C.p=&x
D.p=&y
(2分)
A.Microsoft Visual Studio 6.0!
B.Microsoft
C.Microsoft Visual
D.Microsoft Visual Studio 6.0
(2分)
A.x.a
B.x.a()
C.x->a
D.(*x).a()
(2分)
A.对象介绍c语言中的结构变量
B.对象代表着正在创建的系统中的一个实体
C.对象是类的一个变量
D.对象之间的信息传递是通过消息进行的
(2分)
A.fun();
B.fun(2,3);
C.fun(2, ,'c', 3.14)
D.fun(int a=1);
class MyClass {
public:
MyClass(int x): val(x) {}
void Print() const {cout << "const:val=" << val << ' ';}
void Print() {cout << "val=" << val << ' ';}
private:
int val;
};
在main函数中定义该类的l两个对象：const MyClass obj1(10); MyClass obj2(20); 依次执行obj1.Print(); obj2.Print();的输出结果是（）。
(2分)
A.val=10 const:val=20
B.const:val=10 const:val=20
C.const:val=10 val=20
D.val=10 val=20
(2分)
A.this指针是指向对象的指针
B.this指针是在使用对象引用成员函数时，系统自动生成的
C.this指针可以在程序中显示使用
D.this指针是指向成员函数的指针
(2分)
A.在建立对象前，就可以为静态数据成员赋值
B.静态成员函数在类外定义时要用static前缀
C.静态成员函数只能在类外定义
D.在静态成员函数中可以使用this指针
(2分)
A.如果函数fun被声明为类A的友元函数，则该函数成为A的成员函数
B.如果函数fun被声明为类A的友元函数，则该函数能访问A的保护成员，但不能访问私有成员
C.如果函数fun被声明为类A的友元函数，则fun的形参类型不能是A。
D.以上答案都不对
A.友元函数是指某些虽然不是类成员函数却能够访问类的所有成员的函数。
B.类授予它的友元特别的访问权，这样该友元函数就能访问到类中的所有成员。
C.如果函数fun被声明为类A的友元函数，则fun的形参类型可以是A。
2-22下面关于友元的描述中，错误的是：
(2分)
A.友元函数可以访问该类的私有数据成员
B.一个类的友元类中的成员函数都是这个类的友元函数
C.友元可以提高程序的运行效率
D.类与类之间的友元关系可以继承
答案：D 友元关系不能被继承
2-23已知类A是类B的友元，类B是类C的友元，则：
(2分)
A.类A一定是类C的友元
B.类C一定是类A的友元
C.类C的成员函数可以访问类B的对象的任何成员
D.类A的成员函数可以访问类B的对象的任何成员
答案：D
A.B友元关系不具有传递性。若类A是类B的友元，类B是C的友元，类A不一定是类C的友元，同样要看类中是否有相应的申明。
C.D友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
2-25若类A被说明成类B的友元，则（ ） 。
(2分)
A.类A的成员即类B的成员
B.类B的成员即类A的成员
C.类A的成员函数不能访问类B的成员
D.类B不一定是类A的友元
答案：D
2-26下列的模板说明中，正确的是。
(2分)
A.template < typename T1, T2 >
B.template < class T1, T2 >
C.template < typename T1, typename T2 >
D.template ( typedef T1, typedef T2 )
答案：C
2-27假设有函数模板定义如下： template Max( T a, T b ,T &c) { c = a + b ; } 下列选项正确的是( )。
(2分)
A.int x, y; char z ;Max( x, y, z ) ;
B.double x, y, z ;Max( x, y, z ) ;
C.int x, y; float z ;Max( x, y, z );
D.float x; double y, z;Max( x, y, z ) ;
答案：B
2-28关于类模板，描述错误的是。
(2分)
A.一个普通基类不能派生类模板
B.类模板可以从普通类派生，也可以从类模板派生
C.根据建立对象时的实际数据类型，编译器把类模板实例化为模板类
D.函数的类模板参数需生成模板类并通过构造函数实例化
答案：A
A
#include<bits/stdc++.h> using namespace std; class student { protected: string name; int sco; public: student(string na,int sc){ name=na; sco=sc; } }; template<class T> class stu1:public student{ protected: T num; public: stu1(string na, int sc, T nu):student(na,sc){ num=nu; } void display(){ cout<<name<<" "<<sco<<" "<<num; } }; int main() { string na="lihua"; int sc=1; int a=2; stu1 <int>st(na,sc,a); st.display(); return 0; }
B
#include<bits/stdc++.h> using namespace std; template<class T> class Animal { public: void Jiao() { cout << mAge << "岁的动物在叫!" << endl; } public: T mAge; }; template<class T> class Cat :public Animal<T> { }; int main() { int age=1; Cat <int>c; c.mAge=age; c.Jiao(); return 0; }
C D
"一般来讲，类模版是结构相似但不同的类的抽象，是描述性的；形式：template<typename T> class 类版名；模版类是 类模版铸造出来的类，是具体的类，是如结构等相似的类型；"
类模板只是一个抽象的描述,在应用时在内存中是不占空间的,
而模板类是一个具体的东西!
2-30下列关于模板的说法中，错误的是____。
(2分)
A.用模板定义一个对象时，不能省略参数
B.类模板只能有虚拟参数类型
C.类模板的成员函数都是模板函数
D.类模板在编绎中不会生成任何代码
答案：C
2-31(2018final) 下面对模板的声明，正确的是（ ）。
(2分)
A.template<T>
B.template<class T1, T2>
C.template<class T1, class T2>
D.template<class T1; class T2>
答案：C
2-32在c++中，类之间的继承关系具有( )。
(2分)
A.自反性
B.对称性
C.传递性
D.反对称性
答案：C
2-33下列关于类的继承描述中，( )是正确的。
(2分)
A.派生类公有继承基类时，可以访问基类的所有数据成员，调用所有成员函数。
B.派生类也是基类，所以它们是等价的。
C.派生类对象不会建立基类的私有数据成员，所以不能访问基类的私有数据成员。
D.一个基类可以有多个派生类，一个派生类可以有多个基类。
答案：D
2-34下列关于运算符重载的描述中，（ ）是正确的。
(2分)
A.运算符重载可以改变操作数的个数
B.运算符重载可以改变优先级
C.运算符重载可以改变结合性
D.运算符重载不可以改变语法结构
答案：D
2-35为了能出现在赋值表达式的左右两边，重载的"[]"运算符应定义为：
(2分)
A.A operator [ ] (int);
B.A& operator [ ] (int);
C.const A operator [ ] (int);
D.以上答案都不对
答案：B
2-36关于类的静态数据成员和静态函数成员，说法错误的是（ ）
(2分)
A.类的静态数据成员，解决的是同类不同对象之间的数据共享问题。
B.类的静态数据成员，具有静态声明周期，必须在命名空间作用域的某个地方对其进行初始化。
C.静态成员函数可以直接访问该类的静态数据成员和函数成员；而访问类的非静态成员，必须通过对象名。
D.静态数据成员，属于对象的属性。若要对静态数据成员进行访问，必须通过对象名。
答案：D
静态数据成员是类的所有对象共享的成员，即可以通过类名访问，也可以通过对象访问。但通过类名访问更方便、更高效。
#include<bits/stdc++.h> using namespace std; class A { public: static int x; }; int A::x=3; int main() { A a; cout << a.x << endl; cout << A::x << endl; return 0; }
2-37下列关于运算符重载的表述中，正确的是（）。
(2分)
A.C++已有的任何运算符都可以重载
B.运算符函数的返回类型不能声明为基本数据类型
C.在类型转换符函数的定义中不需要声明返回类型
D.可以通过运算符重载来创建C++中原来没有的运算符
答案：C
重载运算符的规则如下：①C++不允许用户自己定义新的运算符，只能对已有的C++运算符进行重载；②C++不能重戟的运算符只有5个；③重载不能改变运算符运算对象的个数；④重载不能改变运算符的优先级和结合性；⑤重载运算符的函数不能有默认的参数；⑥重载的运算符必须和用户定义的自定义类型的对象一起使用，至少应有一个是类对象，即不允许参数全部是C++的标准类型。故本题答案为C。
2-38下列关于运算符重载的描述中，（ ）是正确的。
(2分)
A.针对<<、>>运算符不可以采用友元函数进行重载
B.针对<<、>>运算符既可以采用成员函数也可以采用友元函数进行重载
C.AB说法均正确
D.ABC均不正确
答案：D
只能将重载<<、>>的函数作为友元函数，而不能将它们定义为成员函数
2-39如何区分自增运算符重载的前置形式和后置形式？
(2分)
A.重载时，前置形式的函数名是++operator，后置形式的函数名是operator ++
B.后置形式比前置形式多一个 int 类型的参数
C.无法区分，使用时不管前置形式还是后置形式，都调用相同的重载函数
D.前置形式比后置形式多一个 int 类型的参数
答案：B
2-40系统在调用重载函数时往往根据一些条件确定哪个重载函数被调用，在下列选项中，不能作为依据的是（ ）。
(2分)
A.函数的返回值类型
B.参数的类型
C.函数名称
D.参数个数
答案：A
2-41在派生类对基类继承的传递性中，__是错误的。
(2分)
A.在公有继承方式下，直接派生类对象可以直接调用基类中的公有成员函数，去访问基类的私有数据成员
B.在公有继承方式下，间接派生类对象可以直接调用基类中的公有成员函数，去访问基类的私有数据成员
C.在私有继承方式下，间接派生类对象可以直接调用基类中的公有成员函数，去访问基类的私有数据成员
D.不管是私有继承还是公有继承，基类中的私有成员在派生类的作用域内都是不可能见的。
答案：C
应该是这个意思吧
#include<bits/stdc++.h> using namespace std; class A { private: int a; public: void set_a(int aa){ a=aa; } int get_a(){ return a; } }; // A选项 //class B:public A{ // public: // void zz(){ // get_a(); // } //}; // B选项 //class B:public A{ // public: // void zz(){ // get_a(); // } //}; //class C:public B{ // public: // void zz(){ // get_a(); // } //}; // C选项 class B:private A{ public: void zz(){ get_a(); } }; class C:private B{ public: void zz(){ get_a(); } }; int main() { return 0; }
2-42在C++语言中设置虚基类的目的是（ ） 。
(2分)
A.简化程序代码
B.提高程序的运行效率
C.解决多继承造成的二义性问题
D.缩短程序的目标代码
答案：C
虚基类的目标就是要消除二义性。尽管：C++或其他OO语言支持多重继承，但在实际软件开发中多重继承用的并不多，原因在于多重继承过手复杂。因此，在C#中已经不再支持多重继承了。
2-43继承机制的作用是
(2分)
A.信息隐藏
B.数据封装
C.定义新类
D.数据抽象
答案：C
2-44C++语言类体系中, 不能被派生类继承的有
(2分)
A.转换函数
B.构造函数
C.虚函数
D.静态成员函数
答案：B
派生类对象的数据结构是由基类中说明的数据成员和派生类中说明的数据成员共同构成，所以不能继承基类的构造函数，必须重新定义。
2-45在公有继承的情况下，在派生类中能够访问的基类成员包括
(2分)
A.公有成员
B.保护成员
C.公有成员、保护成员和私有成员
D.公有成员和保护成员
答案：D
2-46可以用p.a的形式访问派生类对象p的基类成员a, 其中a是
(2分)
A.私有继承的公有成员
B.公有继承的私有成员
C.公有继承的保护成员
D.公有继承的公有成员
答案：D
2-47下面关于继承和派生的构造函数和析构函数的程序，输出结果是
#include<iostream>
using namespace std;
class AA {
public:
AA() { cout << "A"; }
~AA() { cout << "a"; }
};
class BB: public AA {
AA aa;
public:
BB() { cout << "B"; }
~BB() { cout << "b"; }
};
int main() {
BB bb;
return 0;
}
(2分)
A.AABaab
B.AABbaa
C.BAAaab
D.BAAbaa
答案：B
2-48一个类的私有成员
(2分)
A.只能被该类的成员函数访问
B.只能被该类的成员函数和友元函数访问
C.只能被该类的成员函数、友元函数和派生类访问
D.以上答案都不对
答案：B
派生类中父类的私有成员为不可访问。
2-49建立派生类对象时, 3种构造函数分别是a(基类的构造函数)、b(成员对象的构造函数)、c(派生类的构造函数)，这3种构造函数的调用顺序为
(2分)
A.abc
B.acb
C.cab
D.cba
答案：A
基类的构造函数------>成员对象的构造函数------>派生类的构造函数
派生类的析构函数------>成员对象的析构函数------>基类的析构函数
2-50下面叙述不正确的是
(2分)
A.基类的保护成员在派生类中仍然是保护的成员
B.基类的保护成员在公有派生类中仍然是保护的
C.基类的保护成员在私有派生类中仍然是私有的
D.对基类成员的访问必须是无二义性
答案：A
2-51下面关于类的继承与派生的程序，其输出结果是
#include<iostream>
using namespace std;
class A
{
public:
A(){cout<<"A";}
};
class B
{
public:
B(){cout<<"B";}
};
class C:public A
{
B b;
public:
C(){cout<<"C";}
};
int main(){
C obj;
return 0;
}
(2分)
A.CBA
B.BAC
C.ACB
D.ABC
答案：D
基类的构造函数------>成员对象的构造函数------>派生类的构造函数
2-52假设在公有派生情况下，以下说法不正确的是
(2分)
A.可以将基类对象复制给派生类对象
B.可以将派生类对象的地址复制给基类指针
C.可以将派生类对象赋值给基类的引用
D.可以将派生类对象赋值给基类对象
答案：A
2-53下列关于派生类构造函数和析构函数的说法中，错误的是
(2分)
A.派生类的构造函数会隐含调用基类的构造函数
B.如果基类声明了带有形参表的构造函数，则派生类就应当声明构造函数
C.在建立派生类对象时，先调用基类的构造函数，再调用派生类的构造函数
D.在销毁派生类对象时，先调用基类的析构函数，再调用派生类的析构函数
答案：D
2-54以下关于C++语言中继承的叙述中，错误的是（ ）。
(2分)
A.继承是父类和子类之间共享数据和方法的机制
B.继承定义了一种类与类之间的关系
C.继承关系中的子类将拥有父类的全部属性和方法
D.继承仅仅允许单继承，即不允许一个子类有多个父类
答案：D
此题考查的是派生类的构造函数和析构函数。在撤销派生类对象时，析构函数的执行过程和构造函数严格相反，即：对派生类新增普通成员进行清理；调用成员对象析构函数，调用基类析构函数对基类进行清理。
2-55派生类继承基类的方式有
(2分)
A.public
B.private
C.protected
D.以上都对
答案：D
2-56下面关于类的继承与派生的程序，其输出结果是
```C++ #include using namespace std; class A { public: A(int i) { x = i; } void dispa() { cout << x << ','; } private: int x; }; class B: public A { public: B(int i) : A(i + 10) { x = i; } void dispb() { dispa(); cout << x << endl; } private: int x; }; int main() { B b(2);
(2分)
A.dispb(); return 0; } ```
B.10,2
C.12,10
D.12,2
E.2,2
答案：D
#include<bits/stdc++.h> using namespace std; class A { public: A(int i) { x = i; } void dispa() { cout << x << ','; } private: int x; }; class B: public A { public: B(int i) : A(i + 10) { x = i; } void dispb() { dispa(); cout << x << endl; } private: int x; }; int main() { B b(2);//A的x为12，B的x为2 b.dispb(); return 0; }
2-57若obj是类D的对象，则下列语句中正确的是
class B{
private: void fun1(){ }
protected: void fun2(){ }
public: void fun3(){ }
};
class D : public B {
protected: void fun4(){ }
};
(2分)
A.obj.fun1();
B.obj.fun2();
C.obj.fun4();
D.obj.fun3();
答案：D
本题考查公用继承对基类成员的访问属性。在公用继承中，基类的公用成员和保护成员在派生类中保持原有的访问属性，其私有成员仍为基类私有。所以在本题中，在类外引用成员函数时，派生对象只能引用基类的公用成员函数fun1，故本题答案为A。
2-58以下说法不正确的是（假设在公有派生情况）？
(2分)
A.可以将基类对象赋值给派生类对象
B.可以将派生类对象的地址赋值给基类指针
C.可以将派生类对象赋值给基类的引用
D.可以将派生类对象赋值给基类对象
答案：A
2-59以下说法正确的是？
(2分)
A.派生类可以和基类有同名成员函数，但是不能有同名成员变量
B.派生类的成员函数中，可以调用基类的同名同参数表的成员函数
C.派生类和基类的同名成员函数必须参数表不同，否则就是重复定义
D.派生类和基类的同名成员变量存放在相同存储空间
答案：B
2-60下列程序的执行结果为
#include <iostream>
using namespace std;
class A {
public:
A() { cout << "1"; }
~A() { cout << "2"; }
};
class B: public A {
public:
B() { cout << "3"; }
~B() { cout << "4"; }
};
int main() {
B b;
return 0;
}
(2分)
A.1234
B.1324
C.1342
D.3142
答案：C
2-61下面的概念，哪个不是关于对象的多态性的体现。
(2分)
A.方法的重载
B.方法的继承
C.方法的覆盖
D.对象的上、下转型
答案：B
2-62关于面向对象的特征
▁▁▁▁▁ 不是面向对象的特征。
(2分)
A.多态性
B.继承性
C.封装性
D.过程调试
答案：D
2-63在C++中用类将数据和对数据操作的代码连接在一起称为（ ）
(2分)
A.软件重用
B.封装
C.集合
D.多态
答案：B
2-64在派生类中，重载一个虚函数时，要求函数名、参数的个数、参数的类型、参数的顺序和函数的返回值。
(2分)
A.相同
B.不同
C.相容
D.部分相同
答案：A
2-65虚析构函数的作用是。
(2分)
A.虚基类必须定义虚析构函数
B.类对象作用域结束时释放资源
C.delete动态对象时释放资源
D.无意义
答案：C
2-66下面函数原型中，( )声明了fun为纯虚函数。
(2分)
A.void fun()=0
B.virtual void fun()=0
C.virtual void fun()
D.virtual void fun(){ }
答案：B
2-67若一个类中含有纯虚函数，则该类称为。
(2分)
A.基类
B.纯基类
C.抽象类
D.派生类
答案：C
纯虚函数一般提供派生类进行继承的参考，是多态性的重要保证，一个具有纯虚函数的类称为抽象类，抽象类可以具有其他类的特点，但它不能定义对象，不能声明为内联函数。
2-68下面描述中，正确的是( )。
(2分)
A.虚函数是没有实现的函数
B.纯虚函数是返回值等于0的函数
C.抽象类是只有纯虚函数的类
D.抽象类指针可以指向不同的派生类
答案：D
2-69下面是关于ios 类的叙述，正确的是（ ）。
(2分)
A.它是istream 类和ostream 类的虚基类
B.它只是istream 类的虚基类
C.它只是ostream 类的虚基类
D.它是iostrearm 类的虚基类
答案：A
2-70当使用ifstream 流类定义一个流对象并打开一个磁盘文件时，文件的隐含打开方式为（ ）。
(2分)
A.ios::in
B.ios::out
C.ios::in|ios::out
D.ios::binary
答案：A
当使用ifstream 流类定义一个流对象并打开一个磁盘文件时，文件的隐含打开方式为ios::in。
而对类ostream文件打开的方式默认为ios::out
C++中文件的打开与关闭
2-71下列函数中，（ ）是对文件进行写操作的。
(2分)
A.get
B.read
C.seekg
D.put
答案：D
C 此函数一般用于二进制模式打开的文件中，功能是定位到流中指定的位置
C++文件操作大全
2-72下列打开文件的表达式中，错误的是：
(2分)
A.ofstream ofile; ofile.open(“C:vcabc.txt”,ios::binary);
B.fstream iofile;iofile.open(“abc.txt”,ios::ate);
C.ifstream ifile (“C:vcabc.txt”);
D.cout.open(“C:vcabc.txt”,ios::binary);
答案：D
本题考核文件的I/O操作。流可以分为3类：输入流、输出流以及输入/输出流，相应地必须将流说明为ifstream、ofstream以及fstream类的对象。如，说明一个输入流对象：ifstream ifile；。说明了流对象后，可使用函数open()打开文件。文件的打开即是在流与文件之间建立一个连接。open()的函数原型为：void open(const char *filename,int mode,int port=filebuf::openprot)；其中，filename是文件名字，它可包含路径说明。mode说明文件的打开模式。除了open()成员函数外，ifstream、ofstream以及fstream 三类流的构造函数也可以打开文件，其参数同open()函数。例如：ifstream ifile('c:\vc\abc．txt")；C选项。打开的文件使用完毕后，必须使用close()函数将其关闭。close()函数也是流类的成员函数，它没有参数与返回值，其作用是将缓冲区的内容刷新并撤销流与文件之间的连接。当流对象的生存周期后，相应的析构函数也会将文件关闭。由此可知，A、B和C选项的表达式都是正确的。对于D选项，由于open函数并不是tout对象中的成员函数，所以对open的调用是非法的。
2-73对磁盘文件进行操作时，以____模式打开的文件，可实现创建一个可以写入的、新的空文件；如果该文件已经存在，则先删除以前的内容，再写入新数据。
(2分)
A.ios::in
B.ios::app
C.ios::out
D.ios::binary
答案：C ios::out 以输出方式打开文件（这是ostream的默认方式）
2-74下列关于文件的打开与关闭的描述中，错误的是____。
(2分)
A.ifstream类. ostream类和fstream类都提供了成员函数open()用于打开文件
B.对于ifstream类对象其打开文件的默认方式是ios::in，ostream类对象打开文件的默认方式是ios::out
C.对于ofstream类来说，析构函数会自动完成关闭，然后可以在这个流上打开另外一个文件
D.文件的打开方式可以组合使用
答案：C
虽然ofstream析构函数会自动完成关闭，但如果在同一流对象上打开另外的文件，就需要使用close函数。
2-75关于动态绑定的下列描述中，（ ）是错误的。
(2分)
A.动态绑定是以虚函数为基础的
B.动态绑定在运行时确定所调用的函数代码
C.动态绑定调用函数操作是通过指向对象的指针或对象引用来实现的
D.动态绑定是在编译时确定操作函数的
答案：D
动态联编一直到程序运行时才能确定调用哪个函数。没有虚函数不能够实现动态联编，调用虚函数操作的是指向对象的指针或者对象的引用。
2-76关于虚函数的描述中，（ ）是正确的。
(2分)
A.虚函数是一个static 类型的成员函数
B.虚函数是一个非成员函数
C.基类中说明了虚函数后，派生类中与其对应的函数可不必说明为虚函数
D.派生类的虚函数与基类的虚函数具有不同的参数个数和类型
答案：C
虚函数是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。在基类中用virtual声明成员函数为虚函数，在派生类中重新定义此函数，要求函数名、函数类型、函数参数个数和类型全部与基类的虚函数相同。
2-77以下说法中正确的是（）
(2分)
A.在虚函数中不能使用this指针
B.在构造函数中调用虚函数不是动态联编
C.抽象类的成员函数都是纯虚函数
D.构造函数和析构函数都不能是虚函数
答案：B 构造函数和析构函数调用虚函数时都不使用动态联编，如果在构造函数或析构函数中调用虚函数，则运行的是为构造函数或析构函数自身类型定义的版本。
D 构造函数不能为虚函数，析构函数可以是虚函数
2-78虚函数必须是类的____
(2分)
A.成员函数
B.友元函数
C.构造函数
D.析构函数
答案：A 虚函数只能是类的成员函数，不能是构造函数或析构函数。
2-79派生类中虚函数原型的（）。
(2分)
A.函数类型可以与基类中虚函数的原型不同
B.参数个数可以与基类中虚函数的原型不同
C.参数类型可以与基类中虚函数的原型不同
D.以上都不对
答案：D
2-80下列描述中，（ ）是抽象类的特性。
(2分)
A.可以说明虚函数
B.可以进行构造函数重载
C.可以定义友元函数
D.不能定义该类对象
答案：D
①抽象类是指至少有一个纯虚函数的类。它往往表示一些抽象的概念，它的成员函数没有什么意义。
②抽象类是一种特殊的类，它是为了抽象和设计的目的而建立的，它处于继承层次结构的上层。抽象类的主要作用是将有关的类组织在一个继承层次结构中，由它来为它们提供一个公共的根，相关的子类是从这个根派生出来的。
③对于抽象类的使用有几点规定：抽象类只能用作其他类的基类，不能建立抽象类对象；抽象类不能用作参数类型、函数返回类型或显式转换的类型；可以说明指向抽象类的指针和引用，此指针可以指向它的派生类，进而实现多态性。