2023年c++题库.doc

假定 AB 引用是某个变量的别名，对引用的操作就是对被引用变量的操作。
 A. 对
 B. 错

假定 AB 为一个类，则执行 AB x; 语句时将自动调用该类的无参构造函数。
 A. 对
 B. 错

构造函数用来初始化类的新对象，构造函数与类同名，返回类型只能为void。
 A. 对
 B. 错

用new动态分派的内存是在堆中分派的，而不是在栈中分派的。
 A. 对
 B. 错

使用关键字class定义的类中缺省的访问权限是私有（private）的。
 A. 对
 B. 错
在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。
 A. 对
 B. 错
C++语言的标记符是不区分大小写的。
 A. 对
 B. 错
作用域运算符（::）只能用来限定成员函数所属的类。
 A. 对
 B. 错
声明对象时，类名前面不需要加class关键字。
 A. 对
 B. 错

C++程序一般应当具有main函数，它是C++程序执行的入口。
 A. 对
 B. 错
可以在类的构造函数中对静态数据成员进行初始化。
 A. 对
 B. 错
C++语言中，既允许单继承，又允许多继承。
 A. 对
 B. 错
派生类的继承方式有两种：公有继承和私有继承。
 A. 对
 B. 错
多继承情况下，派生类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序。
 A. 对
 B. 错

类的私有成员只能被类中的成员函数访问，任何类以外的函数对它们的访问都是非法的。
 A. 对
 B. 错

构造函数和析构函数都不能重载。
 A. 对
 B. 错
在基类中被声明为虚函数的类的成员函数必须在每个派生类中显式声明为虚函数，才干具有多态的特性。
 A. 对
 B. 错
关于运算符重载，运算符函数的返回类型不能声明为基本数据类型。
 A. 对
 B. 错
将类的一个对象赋值给该类的另一个对象时，调用拷贝构造函数。
 A. 对
 B. 错
模板可以使程序对任何数据类型进行同样方式的解决。
 A. 对
 B. 错

1. 编译源文献后产生的文献是（    ）。
 A. 目的文献
 B. 可执行文献
 C. 源文献
 D. 头文献

2. 每个C++程序只能有一个（   ）。
 A. 全局变量
 B. 函数
 C. 头文献
 D. 主函数

3. 使用内联函数的好处是（   ）。
 A. 增长函数调用次数
 B. 提高代码执行效率
 C. 减少代码量，增强代码可读性
 D. 隐藏内部实现
4.下列不是函数重载所规定的条件是（   ）。
 A. 函数名相同
 B. 函数返回值类型不同
 C. 参数类型不同
 D. 参数个数不同
5. 下列哪两个函数为重载函数（   ）。
 A. void a1(), void a2()
 B. intb(int x), float b(int x)
 C. char c(double y), char c(int y, double z)
 D. bool d(double y), bool d(double y, int x = 0)
6. 在面对对象方法中，实现信息隐蔽依靠的是（   ）。
 A. 对象的封装
 B. 对象的继承
 C. 对象的多态
 D. 对象的分类
7. 所谓数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是（   ）。
 A. 类
 B. 对象
 C. 函数体
 D. 数据块
8. 下列关于类定义的说法中，对的的是（   ）。
 A. 在类里定义的函数为内联函数
 B. 类成员的默认访问权限是保护的
 C. 数据成员必须被声明为私有的
 D. 成员函数只能在类体外进行定义
9. 关于类和对象不对的的说法是（   ）。
 A. 类是一种类型，它封装了数据和操作
 B. 对象是类的实例
 C. 一个类的对象只有一个
 D. 一个对象必属于某个类
10. 结构体中定义的成员默认的访问属性为（   ）。
 A. public
 B. private
 C. friend
 D. protected
11.类中定义的成员默认的访问属性为（   ）。
 A. public
 B. private
 C. friend
 D. protected

12. 有关构造函数的叙述不对的的是（   ）。
 A. 构造函数名必须和类名一致
 B. 构造函数在定义对象时自动执行
 C. 构造函数无任何函数类型
 D. 在一个类中构造函数有且仅有一个
13. 下列关于析构函数的描述中，错误的是（   ）。
 A. 析构函数可以重载
 B. 析构函数由系统自动调用
 C. 每个对象的析构函数只被调用一次
 D. 每个类都有析构函数
14. 通常拷贝构造函数的参数是（   ）。
 A. 对象名
 B.  对象的成员名
 C. 对象的引用名
 D. 对象的指针名
15. 在类外定义成员函数时，需要在函数名前加上（   ）。
 A. 类名
 B. 对象名
 C. 作用域运算符
 D. 类名和作用域运算符
16. 在类定义中，为说明成员的访问权限，private， protected，public可以出现次数（   ）。
 A. 次数没有具体限制
 B. 每种至多一次
 C. public 至少一次
 D. 每种至少一次
17. 关于静态数据成员的描述中错误的是（   ）。
 A. 类的静态数据成员是该类所有对象所共享的
 B. 类的静态数据成员在在该类每个对象中都保存一个备份
 C. 类的静态数据成员必须进行初始化
 D. 类的静态数据成员可以不通过对象来访问
18. 若一个类的数据成员用 const 关键字修饰，则该数据成员（   ）。
 A. 静态函数中可以对该成员赋值
 B. 构造函数只能通过初始化列表对该成员初始化
 C. 任何函数都不能使用该成员
 D. 外部函数可以对该成员赋值
19. 有两个类 X和Y，且 Y 有一个构造函数 Y::Y(X x); 那么以下语句：
X a;
Yb(a);
不会调用下面的哪个函数（    ）。
 A. Y 的构造函数 Y(X x)
 B. Y 的拷贝（复制）构造函数
 C.  X 的默认构造函数
 D. X 的拷贝（复制）构造函数
20. 已知类 A 的定义。假设 x 为 A 的对象，则在类外访问 x 对象中数据成员a和b分别应采用（   ）。
class A {
private:
    int a;
public:
    int getValue() {
        return a;
    }
    int b;
};
 A. x::getValue(), x::b
 B. x.a, x.b
 C. x.a(), x.b()
 D. x.getValue(), x.b
21. 假设程序中先前已经定义了 A、B、C 三个类，他们的构造函数分别会输出A constructed、B constructed 和C constructed，那么又定义了类 D，并在 main 函数中定义了一个D 类的对象，部分代码如下：
class D{
public:
    D():a(), b(), c() { }
private:
    A a;
    B b;
    C c;
};
intmain() {
    D d;
    return 0;
}
程序的输出结果为（    ）。
 A. A constructed B constructed C constructed
 B. C constructed B constructed A constructed
 C. 编译错误
 D. 编译器决定
22. 已知类 CA 中的某个成员是类 CB 的对象，若要把这两个类定义在同一个文献中，则（   ）。
 A. CA 必须定义在 CB 之前
 B. CB 必须定义在 CA 之前
 C. 若 CA 定义在 CB 之后，则 CA 的声明必须出现在 CB 的定义之前
 D. 若 CB 定义在 CA 之后，则 CB 的声明必须出现在 CA 的定义之前
23. 在设计一个类的时候，假如希望允许一个不属于该类的函数访问该类的私有成员，应当使用哪个关键字（   ）。
 A. public
 B. private
 C. friend
 D. protected
24. 关于友元函数的描述中,错误的是（   ）。
 A. 友元函数是成员函数
 B. 友元函数能访问类中私有成员
 C. 友元函数破坏封装性
 D. 友元函数声明在类体内
25. 假如类 A 是类 B 的友元，则（   ）。
 A. 类 A 的成员是类 B 的成员
 B. 类 B 的成员是类 A 的成员
 C. 类 A 的成员函数可以访问类 B 的私有成员
 D. 类 B 是类 A 的友元
26. 已知类 A 是类 B 的友元类，类 B 是类 C 的友元类，则（   ）。
 A. 类 A 一定是类 C 的友元
 B. 类 C 一定是类 A 的友元
 C. 类 C 的成员函数可以访问类 B 的对象的任何成员
 D. 类 A 的成员函数可以访问类 B 的对象的任何成员
27. 已知Point类具有无参（默认）构造函数和有参构造函数，使用Point a[3] = { Point(1, 2), Point(3,4), Point() }; 时，调用了（   ）次Point类的无参（默认）构造函数。
 A. 1
 B. 2
 C. 3
 D. 4
28. 要定义一个引用变量p使之引用类MyClass的一个对象,对的的定义语句是（   ）。
 A. MyClass p = MyClass;
 B. MyClass p = new MyClass;
 C. MyClass &p = new MyClass;
 D. MyClass a, &p = a;
29. 关于this指针的说法不对的的是（   ）。
 A. 不能在程序中修改this指针
 B. this指针可以给其他指针赋值，但不能修改this指针
 C. 静态成员函数中没有this指针
 D. this指针可以被赋值
30. 关于C++的动态存储分派，下列说法对的的是（   ）。
 A. new和delete是C++语言中专门用于动态内存分派和释放的函数
 B. 动态分派的内存空间也可以被初始化
 C. 当系统内存不够时，会自动回收不再使用的内存单元，因此程序中不必用delete释放内存空间
 D. 当动态分派内存失败时，系统会立刻崩溃，因此一定要慎用new 
31. 观测程序
#include 
using namespace std; 
int main() {
    int *first, *second;
    first = new int[5];
    second = first;    
    delete[] second;    
    delete[] first;
    return 0;
} 
该程序是否对的，因素是什么 ？
 A. 对的，由于first和second都是独立的指针变量
 B. 不对的，由于first和second是相关而非独立的指针变量
 C. 对的，second会拷贝first的内容
 D. 不对的，second和first指向相同的内容
32. C++中，不能被派生类继承的有（   ）。
 A. 析构函数
 B. 虚函数
 C. 静态成员函数
 D. 友元函数
33. 下列关于派生类的叙述中，错误的是（   ）。
 A.  派生类至少要有一个基类
 B. 派生类中涉及了从基类继承的成员
 C. 一个派生类可以作为另一个派生类的基类
 D. 基类成员被派生类继承以后访问权限保持不变
34. 下列关于类型转换对的的是（   ）。
 A. 基类的对象可以被当作公有派生类对象使用
 B. 派生类对象必须显式的转换为基类对象
 C. 派生类对象可以初始化基类的引用
 D. 基类的指针可以隐含转换为派生类的指针
35. 下列关于虚基类的描述中，错误的是（   ）。
 A. 使用虚基类可以消除由多继承产生的二义性
 B. 构造派生类对象时，虚基类的构造函数只被调用一次
 C. 声明“classB:virtual public A”说明类B为虚基类
 D. 建立派生类对象时，一方面调用虚基类的构造函数
36. 以下说法对的的是（   ）。
 A. 同一个运算符可以被重载多次
 B. 可以通过运算符重载来创建C++中本来没有的运算符
 C. 自增运算符重载时，重载函数不允许有输入参数
 D. 运算符函数的返回类型不能声明为基本数据类型
37. 若A是一个类名，则如下语句将会产生的A对象个数为（   ）。
A a1,*a2;
A *a3= new A();
A& a4 = a1;
 A. 1
 B. 2
 C. 3
 D. 4
38. 类C2是类C1的派生类，下列说法中错误的是（   ）。
 A. C1的成员都是C2的成员
 B. C2的对象可以赋值给C1的变量
 C. C1的友元函数都是C2的友元函数
 D. 创建C2的对象时，要执行C1的构造函数
39. 若类A和类B都是类模板T的模板类，则以下说法对的的是（   ）。
 A. A的友元函数中，可以访问B的私有成员
 B. A的对象可以赋值给B类型的变量
 C. A和B共享T的静态成员变量
 D. A的成员函数中，不能访问B的私有成员
40.若类B是从类A派生而来，而语句 p.Do(); 在被多次执行时，有的时候调用的是类A的Do成员函数，有的时候调用的是类B的Do成员函数，那么 p 的类型可以是（   ）。
 A. A &
 B. A *
 C. B
 D. A
41. 将一个对象放入STL中的容器里时，（   ）。
 A. 事实上被放入的是该对象的一个拷贝（副本）
 B. 事实上被放入的是该对象的指针
 C. 事实上被放入的是该对象的引用
 D. 事实上被放入的就是该对象自身
42. 以下说法对的的是（   ）。
 A. 在multiset容器中，可以同时存储多个相同的元素
 B. 在set容器中，各元素的存储位置取决于它们的插入顺序
 C. 向deque容器添加新对象时，需要比较对象的大小
 D. 在list容器中，各元素的存储位置取决于它们的值
43. 若有如下定义：
set::iterator it1, it2, it3;
set s;
则以下语句不符合语法的是（    ）。
 A. it1++;
 B. --it2;
 C. it3 = it1 + 1;
 D. boolisEnd = (it1 == s.end());
44. 关于函数对象，如下说法中对的的是（   ）。
 A. 假如一个类重载了“()”运算符，该类的对象是函数对象
 B. 假如一个类定义了函数指针成员变量，则该类的对象是函数对象
 C. 函数对象类中只能定义成员函数，不能定义成员变量
 D. 函数对象类只能定义一个函数对象
45. 有如下两个类定义：
class AA { };
class BB {
    AA v1, *v2;
    BB v3;
    int v4;
}
其中有一个成员变量的定义是错误的，这个变量是（    ）。
 A. v1
 B. v2
 C. v3
 D. v4
46. 对于如下代码，请指犯错误的代码行号是（    ）。
1   class A {
2   public:
3       A(int a = 0) {
4           x = a;
5       }
6       static void f1() {
7           x++;
8       };
9   private:
10      int x;
11      static int y;
12  };
 A. 3
 B. 4
 C. 7
 D. 11

47. 对于如下代码
1   class B {
2   public:
3       void f() { }
4       void g() { f(); }
5   }
6   class D : public B {
7   public:
8       void f() { }
9       void g() { B::f() }
10  }
11  int main() {
12      B b, pb = &b;
13      D d, pd = &d;
14      b.f();
15      pd->f();
16      return 0;
17  }
其中第14行代码和第15行代码分别调用的是（    ）。
 A. B::f() 与 D::f()
 B. B::f() 与 B::f()
 C. D::f() 与 D::f()
 D. D::f() 与 B::f()
48. 以下程序的输出结果是（   ）。
#include
using namespace std;
class A {
public:
    A(int a1, int a2):a1(a1), a2(a2) { }
    void print();
    void print() const;
private:
    int a1, a2;
};
void A::print() {
    cout << a1 << " ";
}
void A::print()const {
    cout << a2 << " ";
}
int main() {
    A a(1, 2);
    const A b(1, 2);
    a.print();
    b.print();
    return 0;
}
 A. 1 1
 B. 1 2
 C. 2 1
 D. 2 2
49. 有如下程序：
#include
using namespace std;
class A {
private:
    int a;
public:
    A(int a = 0):a(a) {
        cout << "1";
    }
    A(A &x) {
        a = x.a;
        cout << "2";
    }
    ~A() {
        cout << a;
    }
    int get_a() {
        return a;
    }
};
int main() {
    A d1(5), d2(d1);
    A *pd = new A(8);
    cout << pd->get_a();
    delete pd;
    return 0;
}
程序运营时的输出结果是（    ）。
 A. 12185
 B. 1215588
 C. 128512
 D. 1218855
50. 有如下程序：
#includeeam>
using namespace std;
class A {
public:
    void setA(int);
private:
    int a;
};
class B {
public:
    void setB(int);
private:
    int b;
};
class C:public A,private B {
public:
    void setC(int, int, int);
private:
    int c;
};
void A::setA(intx){
    a = x;
}
void BsetB(intx){
    b = x;
}
void C::setC(int x, int y, int z) {
    setA(x);
    setB(y);
    c = z;
}
int main() {
    C obj;
    obj.setA(5);       // A
    obj.setB(6);       // B
    obj.setC(6, 7, 9); // C
    return 0;
}
main函数中（    ）是错误的。
 A.  A语句
 B. B语句
 C. C语句
51. 设立虚基类的目的是（   ）。
 A. 区分类是否有虚函数
 B. 使类成为抽象类
 C. 提高程序运营效率
 D. 消除二义性
52. 运营时多态是基于（   ）。
 A. 友元函数
 B. 虚函数
 C. 函数重载
 D. 运算符重载
53. C++泛型编程通过（    ）实现。
 A. class
 B. template
 C. virtual
 D. typedef
54. 关于函数声明 float fun(int a, int b) throw，下列叙述对的的是（   ）。
 A. 表白函数抛出 float 类型异常
 B. 表白函数抛出任何类型异常
 C. 表白函数不抛出任何类型异常
 D. 语法错误
55. 有如下两个程序片段：
#include
//程序片段一
std::vectorvec;
for(auto itr =vec.begin(); itr != vec.end(); itr++)
itr->print();
//程序片段二
std::vectorvec;
for(autoitr = vec.begin(); itr != vec.end(); ++itr)
itr->print();
则下列说法中，对的的有（    ）。
(a)itr的类型为auto
(b)程序二性能上要比程序一更好
(c)程序一和程序二性能上没有区别
 A. ab
 B. b
 C. ac
 D. c
56. 假如 X 是整型变量，则合法的形式是（   ）。
 A. &(X+1)
 B. *X
 C. *&X
 D. &*X
57. 判断以下程序的对的性，并说明因素。
#include
using namespace std;
int main() {
int *first, *second;
first = new int[5];
second = first;
delete[] second;
delete[] first
return 0;
}
 A. 对的，由于 first 和 second都指向动态内存，需要手动释放
 B. 不对的，应当先释放 first 指向的内存空间
 C. 对的，second 会拷贝 first 的内容
 D. 不对的，second 和 first 指向相同的动态内存，反复释放会也许导致未定义行为
58. C++中既可以用于文献输入又可以用于文献输出的流类是（    ）。
 A. fstream
 B. ifstream
 C. ofstream
 D. iostream
59. 下列是关于函数模板的程序，则下列说法中对的的有（   ）。
#include
using namespace std;
template void f(T &i) { cout << "1"; }
template <> void f(const int &i) { cout << "2"; }
int main() {
int i = 42;
f(i);
return 0;
}
(a)程序输出1
(b)程序输出2
(c)template <>void f(const int &i) 显式实例化void f(const int &)
(d)f(i)隐式实例化函数void f(int &)
 A ad
 B. bc
 C.  acd
 D. bcd
60. 下列程序的输出为（   ）。
#include
using namespace std;
class Shape {
public:
virtual void print() {
cout << "SHAPE" << endl;
}
virtual ~Shape() { }
};
classBox : public Shape {
public:
virtual void print(int i) {
cout << "BOX" << endl;
}
};
int main() {
Shape *s = new Box();
s->print();
delete s;
return 0;
}
 A. SHAPE
 B. BOX
 C. 未定义行为
1、从完毕C++源文献编辑，到生成执行文献，C++编译器必须执行的环节依次为编译、链接。
 A. 对
 B. 错
C++是强类型语言。
 A. 对
 B. 错
3、假如a为int型变量，b为int型变量，则a/static_cast(b)的值为int型。
 A. 对
 B. 错
4、数组可以通过值参数和引用参数两种方式传递给函数。
 A. 对
 B. 错
5、当一个函数在运营过程中产生一个异常，则这个函数会终止，但是整个程序不一定终止运营。
 A. 对
 B. 错
6、构造函数和析构函数都不能重载。
 A. 对
 B. 错
7、构造函数可以声明为虚函数。
 A. 对
 B. 错
8、已知类X成功地重载了--、=、+和[]这几个运算符，其中肯定属于成员函数的运算符是=和[]。
 A. 对
 B. 错
9、在声明一个对象时假如使用同一类类型的另一个对象来初始化，这时调用的是该类的拷贝构造函数。
 A. 对
 B. 错
10、C++语言中，既允许单继承，又允许多继承。
 A. 对
 B. 错
11、派生类的继承方式有两种：公有继承和私有继承。
 A. 对
 B. 错
12、派生类是从基类派生出来的，它不能再生成新的派生类。
 A. 对
 B. 错
13、构造函数可以被继承，析构函数不能被继承。
 A. 对
 B. 错
14、在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。
 A. 对
 B. 错
15、在公有继承中，基类中只有公有成员对派生类对象是可见的。
 A. 对
 B. 错
16、某类的友元类中的所有成员函数可以存取或修改该类的私有成员。
 A. 对
 B. 错
17、多继承情况下，派生类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序。
 A. 对
 B. 错
18、虚函数和普通函数的区别在于函数名字与函数体之间的绑定方式不同，普通函数使用的是静态绑定，而虚函数使用的是动态绑定。
 A. 对
 B. 错
19、在抽象类中定义的函数只能是纯虚函数。
 A. 对
 B. 错
20、模板对类型参数化提供了很好的支持，类模板实例化时，编译器将根据给出的模板实参生成一个类。
 A. 对
 B. 错
1. 算法是一个计算过程，是程序设计的基础和精髓。一个有效的算法应当具有如下特点，其中错误的是（   ）。
 A. 零个或多个输入及一个或多个输出
 B. 有效性
 C. 无穷性
 D. 拟定性
2. #include与 #include"file.h"的区别是（   ）。
 A. 前者一方面从当前工作途径搜寻并引用file.h，而后者一方面从标准库的途径寻找和引用file.h
 B. 前者一方面从标准库的途径寻找和引用file.h，而后者一方面从当前工作途径搜寻并引用file.h
 C. 两者都是一方面从标准库的途径寻找和引用file.h
 D. 两者都是一方面从当前工作途径搜寻并引用file.h
3. 头文献中的ifndef/define/endif的作用是（   ）。
 A. 定义常量
 B. 标记为特殊的头文献
 C. 防止头文献被反复引用
 D. 注释头文献
4. 在一个程序中，假如函数fA调用了函数fB，函数fB又调用了函数fA，那么（    ）。
 A. 称为函数的循环调用
 B. 这样调用方式是不允许的
 C. 称为函数的直接递归调用
 D. 称为函数的间接递归调用
5. 引入内联函数的目的是为了（    ）。
 A. 方便变量的使用
 B. 提高函数调用的效率
 C. 扩大局部变量的使用范围
 D. 节省内存空间
6. 当给函数的参数设立默认值时，对的的说法是（   ）。
 A. 若给某一参数设立了默认值，那么在参数表中其前所有的参数都必须也设立默认值
 B. 若给某一参数设立了默认值，那么在参数表中其后所有的参数都必须也设立默认值
 C. 给函数的参数设立默认值可以提高程序运营效率
 D. 任何情况下，函数调用时均可不列出已设立默认值的参数
7.下列说法对的的是（   ）。
int *p1 =new int[10];   
int *p2 =new int[10]();
 A. p1和p2申请的空间里面的值都是随机值
 B. p1和p2申请的空间里的值都已经初始化
 C. p1申请的空间里的值是随机值，p2申请的空间里的值已经初始化
 D. p1申请的空间里的值已经初始化，p2申请的空间里的值是随机值
8. 按照常理，下列概念可以理解为对象而不是类的是（   ）。
 A. 国际知名学府
 B. 国家重点建设大学
 C. 诺贝尔奖获得者
 D. 杭州师范大学
9. 在面向对象程序设计中，实现信息隐蔽是靠（    ）。
 A. 对象的封装
 B. 对象的继承
 C. 对象的间接访问
 D. 对象的分类
10. 下列有关类的说法，错误的是（    ）。
 A. 在类中，假如不作特别说明，所有的数据成员均为私有数据成员
 B. 类是一种用户自定义的数据类型
 C. 在类中，假如不作特别说明，所有的成员均为公有成员
 D. 只有类中的成员函数或类的友元函数才干存取类中的私有数据
11. 下面有关类与对象的说法中，错误的是（    ）。
 A 对象是类的实例
 B. 类和对象的关系与数据类型和变量的关系相似
 C. 一个对象不能同时属于多个没有关系的独立的类
 D. 一个类只能有一个对象
12. 下列关于构造函数说法，错误的是（    ）。
 A. 构造函数必须与类同名
 B. 构造函数必须有返回值
 C. 构造函数可以省略不写
 D. 在构造函数中可以对类中的成员进行初始化
13. 以下有关析构函数的叙述，错误的是（   ）。
 A. 析构函数名前必须冠有符号“~”
 B. 在一个类只能定义一个析构函数
 C. 析构函数不允许用返回值
 D. 析构函数和构造函数同样可以有形参
14. 关于类的对象，说法错误的是（   ）。
 A. 释放对象时，相应类的析构函数被自动执行
 B. 在成员函数中，只能访问成员函数所作用的对象的private成员
 C. 对象的成员变量可以是其他类的对象
 D. 同类的对象间，可以互相赋值
15. 设已有A、B、C、D4个类的定义，程序中A、B、C、D析构函数调用顺序是（   ）。
C c;    
int main() {    
A *pa = new A();
B b;    
static D d;
delete pa;    
}
 A. A B C D
 B. A B D C
 C. A C D B
 D. A C B D
16. 以下说法中对的的是（   ）。
 A. 构造函数中可以调用本类的静态成员函数
 B. 构造函数和析构函数都可以是虚函数
 C. 通过赋值号“=”用一个对象对另一个对象进行赋值，就会引发复制构造函数的调用
 D. 用new运算符动态创建对象时，用于初始化该对象的一定是无参数的构造函数
17. 下列情况中，不会调用对象析构函数的是（   ）。
 A. 将对象指针强行赋值为NULL时
 B. 函数中定义的动态对象变量当函数执行结束时
 C. 用delete删除对象指针时
 D. 当对象变量脱离其作用域时
18. 关于类的静态成员，说法错误的是（   ）。
 A 在类的静态成员函数中，可以访问该类的静态成员变量
 B. 在类的非静态成员函数中，不可以访问该类的静态成员变量
 C. 不需要创建类的对象，就可以访问类的静态成员
 D. 类的静态成员变量由该类的所有对象共有
19. 假设Complex是一个复数类，下面（   ）将不会引起拷贝构造函数的调用。
 A. Complexc1(5); Complex c2(c1);
 B. Complexc1(5); Complex c2 = c1;
 C. Complexc1(5); Complex c2[2] ={ c1, 2};
 D. Complexc1(5), c2; c2 = c1;
20. 关于常量成员和静态成员，下面说法对的的是（   ）。
 A. 从同一个类模板得到的两个模板类可以共享同一个静态成员
 B. 公有的静态成员在没有对象生成的时候也能被直接访问
 C. 常量成员函数只有常量对象可以调用
 D. 在静态成员函数中不能访问非静态成员，但可以访问常量成员
21. 下列关于运算符重载的说法中，错误的是（    ）。
 A. new和delete运算符可以重载
 B. 重载运算符不能改变其原有的操作数个数
 C. 三元运算符“?:”不能重载
 D. 所有运算符既可以作为类的成员函数重载,又可以作为非成员函数重载
22. 若需要为xv类重载乘法运算符，运算结果为xv类型，在将其声明为类的成员函数时，下列原型声明对的的是（   ）。
 A. xv operator*(xv,xv);
 B. xv*(xv);
 C. operator*(xv);
 D. xv operator*(xv);
23. 已知表达式++a中的“++”是作为成员函数重载的运算符，则与++a等效的运算符函数调用形式为（   ）。
 A. a.operator++(1)
 B. operator++(a)
 C. operator++ (a,1)
 D. a.operator++()
24. 将运算符重载为类成员函数时，其参数表中没有参数，说明该