C++语言对C语言做了很多改进，C++语言相对于C语言的最根本变化是：
A.增加一些新的运算符。
B.允许函数重载，并语序设置缺省参数。
C.规定函数说明符必须用原型。
选中D.引进了类和对象的概念。
Windows环境下，由 C++ 源程序文件编译而成的目标文件的扩展名是：
选中A.obj
B.exe
C.cpp
D.h
下列关于 return 语句的叙述中，正确的是：
A.任何函数的函数体中至少有一个 return 语句
B.任何函数的函数体中最后一条语句必须是 return 语句
选中C.如果函数的返回类型为 void，则其函数体中可以没有 return 语句
D.如果函数的返回类型为 int，则其函数体中可以没有 return 语句
下列关于C++函数的说明中，正确的是：
A.内联函数就是定义在另一个函数体内部的函数
B.函数体的最后一条语句必须是return语句
选中C.标准C++要求在调用一个函数之前，必须先声明其原型
D.编译器会根据函数的返回值类型和参数表来区分函数的不同重载形式
下列关于内联函数的叙述中，正确的是：
A.内联函数就是在一个函数体内定义的函数
B.内联函数必须通过关键字 inline 来定义
选中C.在类体中定义的函数，默认是内联函数
D.内联函数不需要 return 语句
下列关于函数参数的叙述中，正确的是:
A.在函数原型中不必声明形参类型
B.在调用一个函数时，若函数中修改了形参变量的值，则对应的实参变量的值也被修改
C.函数形参的生存期与整个程序的运行期相同
选中D.函数的形参在函数被调用时获得初始值
下列关于函数模板的表述中，正确的是：
A.函数模板是一个实例函数
B.使用函数模板定义的函数没有返回类型
C.函数模板的虚拟类型参数就是函数参数
选中D.通过使用不同的类型参数，可以从函数模板得到不同的实例函数
下列关于函数的描述中，错误的是：
A.函数可以没有返回值
B.函数可以没有参数
C.函数可以是一个类的成员
选中D.函数不能被定义为模板
下列关于运算符new的描述中，错误的是：
A.new运算符可以用来创建动态对象
B.new运算符用来创建堆对象时可进行初始化
C.用new运算符创建的对象可用delete运算符释放
选中D.创建对象时必须指定初始值
下列函数原型声明中，错误的是：
A.int function( int , int);
B.int function( int = 3, int = 0);
选中C.int function( int m = 3, int n);
D.int function( int &m, int &n);
下列有关内联函数的叙述中，正确的是：
A.内联函数在调用时发生控制转移
B.内联函数必须通过关键字inline来定义
选中C.内联函数是通过编译器来实现的
D.内联函数函数体的最后一条语句必须是return语句
下列语句中错误的是：
选中A.const int a;
B.const int a = 10;
C.const int *point = 0;
D.const int *point = new int(10);
下面哪个语言不是面向对象的语言？
A.C#
B.JAVA
C.C++
选中D.C
下面有关重载函数的说法中正确的是：
A.重载函数必须具有不同的返回值类型
B.重载函数形参个数必须不同
选中C.重载函数必须有不同的形参列表
D.重载函数名可以不同
下面正确的函数原型为：
A.f1( int x; int y );
B.void f1( x, y );
C.void f1( int x, y );
选中D.void f1( int, int );
为了提高函数调用的实际运行速度，可以将较简单的函数定义为：
A.重载函数
选中B.内联函数
C.递归函数
D.函数模板
使用重载函数编程序的目的是：
A.共享程序代码
选中B.使用相同的函数名调用功能相似的函数
C.提高程序的运行速度
D.节省存储空间
在下列原型所示的C++函数中，按"传值"方式传递参数的是：
选中A.void f1(int x);
B.void f2(int *x);
C.void f3(const int *x);
D.void f4(int &x);
在语句"cin>>data;"中，cin 是：
A.C++ 的关键字
B.类名
选中C.对象名
D.函数名
在面向对象方法中，不属于面向对象程序特征的是：
选中A.一致性
B.封装性
C.继承性
D.多态性
已知int型变量 y 的初值是 5，但在执行语句"f(y);"后，y 的值被改变，因此该语句所调用函数的原型是：
A.void f(int x);
B.void f(int *x);
C.void f(const int *x);
选中D.void f(int &x);
已知函数 func 的原型为int func(int,int);下列重载函数原型中错误的是：
选中A.char func(int,int);
B.bool func(int,int,bool);
C.int func(int,char*);
D.float func(int,int,int);
已知函数f的原型是void f(int *a, long &b);，变量v1、v2的定义是：int v1; long v2; 下列调用语句中正确的是：
A.f(v1, &v2);
B.f(v1, v2);
C.f(&v1, &v2);
选中D.f(&v1, v2);
有函数原型 void fun4( int & );，在下列选项中，正确的调用是：
A.int a = 2.17; fun4( &a );
B.int a = 15; fun4( a*3.14 );
选中C.int b = 100; fun4( b );
D.fun4( 256 );
有如下函数定义：
void func(int a, int& b) { a++; b++; }
若执行代码段：
int x = 0, y = 1; func(x, y);
则变量x和y的值分别是：
A.0和1
B.1和1
选中C.0和2
D.1和2
有如下定义：
class Inner{
public:
void f1(){ cout<<"f1"; }
friend void f2(){ cout<<"f2"; }
};
void f3(){ cout<<"f3"; }
inline void f4(){ cout<<"f4"; }
其中的内联函数包括：
A.f1 和 f2
B.f3和 f4
C.f2 和 f3
选中D.f1 和 f4
有如下程序段： int i=1;int j=4; int main() { int i=8, j=i; cout <
A.1，4
B.8，1
C.8，8
选中D.8，4
若有下面的函数调用： fun(a+b, 3, max(n-1, b)) 则fun的实参个数是：
A.2
选中B.3
C.4
D.5
有如下类定义：
class Cup{
public:
void SetPrice(double val) { price=val; }
private:
double price;
};
若有定义语句"Cup myCup;"，为了调用SetPrice成员函数，下列选项中正确的是：
A.Cup::SetPrice(5.8);
B.Cup.SetPrice(5.8);
C.myCup::SetPrice(5.8);
选中D.myCup.SetPrice(5.8);
有如下类声明：
class SAMPLE
{
int n;
public:
SAMPLE(int i=0):n(i) { }
void setValue(int n0);
};
下列关于setValue成员函数的定义中，正确的是：
A.SAMPLE::setValue(int n0) { n=n0; }
选中B.void SAMPLE::setValue(int n0) { n=n0; }
C.void setValue(int n0) { n=n0; }
D.setValue(int n0) { n=n0; }
以下关键字不能用来声明类的访问权限的是：
A.public
选中B.static
C.protected
D.private
下列关于类定义的说法中，正确的是：
选中A.类定义中包括数据成员和函数成员的声明
B.类成员的缺省访问权限是保护的
C.数据成员必须被声明为私有的
D.成员函数只能在类体外进行定义
有如下类定义：
class Cup{
public:
void SetPrice(double val);
private:
double price;
};
下列选项中正确的是，的定义SetPrice若要在类体外给出对成员函数SetPrice的定义，下列选项中正确的是：
选中A.void Cup::SetPrice(double val) { price=val; }
B.void Cup.SetPrice(double val) { price=val; }
C.void SetPrice(double val) { Cup::price=val; }
D.void SetPrice(double val) { Cup.price=val; }
若 MyClass 是一个类名，且若 MyClass 是一个类名，且有如下语句序列
MyClass c1,*c2;
MyClass *c3=new MyClass;
MyClass &c4=c1;
上面的语句序列所定义的类对象的个数是：
A.1
选中B.2
C.3
D.4
有如下类定义：
class Cup{
public:
void SetPrice(double val=5.8);
double GetPrice() { return price; }
double GetPrice() const { return price; }
private:
double price;
};
void Cup::SetPrice(double val) { price=val; }
下列关于类中成员函数的叙述中，错误的是：
A.成员函数SetPrice不是内联函数
B.成员函数SetPrice的形参val具有默认值
C.成员函数GetPrice可以重载
选中D.类中没有对成员函数GetPrice进行重载
有如下类定义：
class Pet{
char name[30];
public:
Pet(char * n){ strcpy(name, n); }
void bark(){ cout<<"Woof!"; }
};
且有如下变量定义：
Pet my_dog("Weiwei"), &p=my_dog;
则下列访问成员函数bark的表达式中，错误的是：
选中A.p.bark()
B.my_dog.bark()
C.p->bark()
D.(&p)->bark()
由于常对象不能被更新，因此：
选中A.通过常对象只能调用它的常成员函数
B.通过常对象只能调用静态成员函数
C.常对象的成员都是常成员
D.通过常对象可以调用任何不改变对象值的成员函数
有如下类定义：
class Point
{
int xx, yy;
public:
Point() : xx(0), yy(0) { }
Point(int x, int y =0) : xx(x), yy(y) { }
};
若执行语句：
Point a(2), b［3］, *c［4］;
则Point类的构造函数被调用的次数是：
A.2次
B.3次
选中C.4次
D.5次
模板对类型的参数化提供了很好的支持，因此：
A.类模板的主要作用是生成抽象类
选中B.类模板实例化时，编译器将根据给出的模板实参生成一个类
C.在类模板中的数据成员都具有同样类型
D.类模板中的成员函数都没有返回值
下列情况中，不会调用拷贝构造函数的是：
A.用一个对象去初始化同一类的另一个新对象时
选中B.将类的一个对象赋值给该类的另一个对象时
C.函数的形参是类的对象，调用函数进行形参和实参结合时
D.函数的返回值是类的对象，函数执行返回调用时
有如下程序：
#include
using namespace std;
class MyClass {
public:
MyClass() { cout<<′A′; }
MyClass(char c) { cout<
~MyClass() { cout<<′B′; }
};
int main() {
MyClass p1,*p2;
p2=new MyClass(′X′);
delete p2 ;
return 0;
}
执行这个程序的输出结果是：
A.ABX
B.ABXB
C.AXB
选中D.AXBB
下列符号中不属于C++关键字的是：
A.friend
B.namespace
C.continue
选中D.byte
有如下程序：
#include
#include
using namespace std;
class MyBag{
public:
MyBag(string br,string cr):brand(br),color(cr) { ++count; }
~MyBag() { --count; }
static int GetCount() { return count; }
private:
string brand,color;
static int count;
};
_____________________
int main(){
MyBag one("CityLife","Gray"),two("Micky","Red");
cout<
return 0;
}
若程序运行时的输出结果为 2，则横线处缺失的语句是：
A.int count=0;
B. static int count=0;
选中C.int MyBag::count=0;
D.static int MyBag::count=0;
对于一个类定义，下列叙述中错误的是：
A.如果没有定义拷贝构造函数，编译器将生成一个拷贝构造函数
选中B.如果没有定义缺省的构造函数，编译器一定将生成一个缺省的构造函数
C.如果没有定义构造函数，编译器将生成一个缺省的构造函数和一个拷贝构造函数
D.如果已经定义了构造函数和拷贝构造函数，编译器不会生成任何构造函数
有如下头文件：
int f1();
static int f2();
class MA {
public:
int f3();
static int f4();
};
在所描述的函数中，具有隐含的this指针的是：
A.f1
B.f2
选中C.f3
D.f4
下列关于类模板的模板参数的叙述中，错误的是：
A.模板参数可以作为数据成员的类型
B.模板参数可以作为成员函数的返回类型
C.模板参数可以作为成员函数的参数类型
选中D.模板参数不能作为成员函数的局部变量的类型
下列语句中错误的是：
选中A.const int a;
B.const int a = 10;
C.const int *point = 0;
D.const int *point = new int(10);
下列有关类成员的叙述中，正确的是：
A.友元函数是类的成员函数
选中B.类成员的默认访问权限是私有的
C.类成员函数必须声明为公有的
D.类的静态数据成员不能是常成员
有如下类定义：
class Point {
private:
static int how_many;
};
__________how_many=0;
要初始化Point类的静态成员how_many，下画线处应填入的内容是：
A. int
B.static int
选中C.int Point::
D.static int Point::
有如下类定义：
class MyClass {
int value;
public:
MyClass(int n): value (n) {}
int getValue()const { return value; }
};
则类MyClass的构造函数的个数是：
A.1个
选中B.2个
C.3个
D.4个
有如下类和对象的定义：
class Constants {
public:
static double getPI() { return 3.1416; }
};
Constants constants;
下列各组语句中，能输出3.1416的是：
A.cout<
B.cout<
C.cout<
选中D.cout<
在 C++ 中，编译系统自动为一个类生成默认构造函数的条件是：
A.该类没有定义任何有参构造函数
B.该类没有定义任何无参构造函数
选中C.该类没有定义任何构造函数
D.该类没有定义任何成员函数
建立一个类对象时，系统自动调用：
A.析构函数
选中B.构造函数
C.静态函数
D.友元函数
有如下类定义：
class Box{
public:
Box(int h,int w,int l):width(w),length(l),height(h) { }
private:
int length,width,height;
};
Box 类中3个数据成员的初始化顺序为：
A.length,height,width
选中B.length,width,height
C.height,width,lenth
D.width,length,height
当一个类对象行将消亡时，系统自动调用：
选中A.析构函数
B.构造函数
C.静态函数
D.友元函数
下列关于对象初始化的叙述中，正确的是：
选中A.定义对象的时候不能对对象进行初始化
B.定义对象之后可以显式地调用构造函数进行初始化
C.定义对象时将自动调用构造函数进行初始化
D.在一个类中必须显式地定义构造函数实现初始化
有如下类定义和变量定义：
class A{
public:
A() { data = 0; }
~A() {}
int GetData() const { return data; }
void SetData(int n) { data = n; }
private:
int data;
};
const A a;
A b;
下列函数调用中错误的是：
A.a.GetData();
选中B.a.SetData(10);
C.b.GetData();
D.b.SetData(10);
下列关于类的析构函数的叙述中，错误的是：
A.定义析构函数时不能指定返回值
B.析构函数的函数名就是类名前加上字符
选中C.析构函数可以重载
D.在一个类中如果没有定义析构函数，系统将自动生成一个析构函数
有如下类定义：
class Cup{
public:
_______________ //构造函数声明
private:
double price;
};
其中下划线处缺失的构造函数声明是：
A.void Cup(double price);
选中B.Cup(double Price);
C.myCup(double price);
D.static Cup(double price);
有如下类定义：
class Bag{
public:
Bag(); //①
void SetSize(string s); //②
string GetSize() const; //③
friend void Display(Bag& b); //④
private:
string size;
};
在标注号码的 4 个函数中，不具有隐含this指针的是：
A.①
B.②
C.③
选中D.④
有如下函数原型：
int func(int **a, int *b, int &c int d);
其中可称为引用参数的参数变量是：
A.a
B.b
选中C.c
D.d
下列关于 this 指针的叙述中，正确的是：
A.类的成员函数都有 this 指针
B.类的友元函数都有 this 指针
C.任何与类相关的函数都有 this 指针
选中D.类的非静态成员函数都有 this 指针
有如下类定义：
class Cup{
public:
void SetPrice(double val) { price=val; }
_______________ //常成员函数 GetPrice 的声明
private:
double price;
};
下列函数声明中，能够作为横线处缺失的常成员函数 GetPrice 的声明的是：
A.const double GetPrice();
B.double const GetPrice();
选中C.double GetPrice() const;
D.double GetPrice(const);
p是指向ClassA类型对象的指针。执行delete p;时，系统自动调用：
选中A.析构函数
B.构造函数
C.静态函数
D.友元函数
有如下程序：
#include
using namespace std;
void fun(int a,______________) { int c; c=a; a=*b; *b=c; }
int main(){
int x,y;
x=1; y=2; fun(x,&y); cout<
return 0;
}
运行后的输出结果是11，则横线处的语句应为：
A.int b
选中B.int *b
C.int &b
D.b
对于一个类定义，编译器可能会自动生成的函数不包括：
选中A.复制构造函数
B.缺省的构造函数
C.析构函数
D.友元函数
运算符重载是对已有的运算符赋予多重含义，因此：
A.可以对基本类型（如int类型）的数据，重新定义"+"运算符的含义
B.可以改变一个已有运算符的优先级和操作数个数
选中C.只能重载C++中已经有的运算符，不能定义新运算符
D.C++中已经有的所有运算符都可以重载
下面是重载为非成员函数的运算符的函数原型，其中错误的是：
A.Fraction operator+(Fraction, Fraction);
B.Fraction operator-(Fraction);
选中C.Fraction& operator= (Fraction&, Fraction);
D.Fraction& operator+= (Fraction&, Fraction);
有如下类定义：
class MyClass {
public:
private:
int data;
};
若要为MyClass类重载流输入运算符">>"，使得程序中可以"cin >> obj;"的形式改变MyClass类的对象obj中数据成员data的值，则横线处的声明语句应为：
选中A.friend istream& operator >> (istream& is, MyClass& a);
B.friend istream& operator >> (istream& is, MyClass a);
C.istream& operator >> (istream& is, MyClass& a);
D.istream& operator >> (istream& is, MyClass a);
已知表达式 --a 中的"--"是作为成员函数重载的运算符，则与 --a 等效的运算符函数调用形式为：
A.a.operator--(1)
B.operator--(a)
C.operator--(a,1)
选中D.a.operator--()
通过运算符重载，可以改变运算符原有的：
选中A.操作数类型
B.操作数个数
C.优先级
D.结合性
关于运算符重载，下列表述中正确的是：
A.C++已有的任何运算符都可以重载
B.运算符函数的返回类型不能声明为基本数据类型
选中C.在类型转换符函数的定义中不需要声明返回类型
D.可以通过运算符重载来创建C++中原来没有的运算符
下列有关运算符重载的叙述中，正确的是：
选中A.运算符重载是多态性的一种表现
B.C++中可以通过运算符重载创造新的运算符
C.C++中所有运算符都可以作为非成员函数重载
D.重载运算符时可以改变其结合性
将前缀运算符"--"重载为非成员函数，下列原型中能正确用于类中说明的是：
A.Decr& operator --(int);
B.Decr operator --(Decr&,int);
选中 C.friend Decr& operator --(Decr&);
D.friend Decr operator --(Decr&,int);
下列关于运算符重载的叙述中，错误的是：
A.有的运算符可以作为非成员函数重载
选中B.所有的运算符都可以通过重载而被赋予新的含义
C.不得为重载的运算符函数的参数设置默认值
D.有的运算符只能作为成员函数重载
下列关于运算符重载的描述中，正确的是：
选中A.运算符重载为成员函数时，若参数表中无参数，重载的是一元运算符
B.一元运算符只能作为成员函数重载
C.二元运算符重载为非成员函数时，参数表中有一个参数
D.C++中可以重载所有的运算符
已知Value是一个类，value是Value的一个对象。下列以非成员函数形式重载的运算符函数原型中，正确的是：
选中A.Value operator +(Value v, int i);
B.Value operator +(Value v=value, int i);
C.Value operator +(Value v, int i=0);
D.Value operator +(Value v =value, int i=0);
下列运算符函数中，肯定不属于类 Number 的成员函数的是：
A.Number operator+(Number);
B.Number operator-(Number);
C.Number operator*(int);
选中D.Number operator/(Number,Number);
下列因素中，对 C++ 编译器区分重载函数无任何意义的是：
选中A.返回值类型
B.常成员函数关键字 const
C.参数类型
D.参数个数
将运算符*重载为类成员函数时，其参数表中有且仅有一个参数，说明该运算符是：
A.无操作数的运算符
B.一元运算符
选中C.二元运算符
D.三元运算符
下列关于运算符函数的表述中，错误的是：
A.运算符函数的参数表可以是空的
B.运算符函数的参数可以是对象
C.运算符函数的名称总是以operator为前缀
选中D.运算符函数只能定义为类的成员函数
若要在 Number 类的声明中将减法运算符重载为成员函数，下列重载函数声明中正确的是：
A.Number -(Number);
选中B.Number operator-(Number);
C.Number -operator(Number);
D.Number operator -(Number,Number);
若要对类 Value 中重载的类型转换运算符 long 进行声明，下列选项中正确的是：
选中A.operator long() const;
B.operator long(Value) const;
C.long operator long();
D.long operator long(Value);
若要在Viz类中将*重载为一元运算符，下列重载函数声明中肯定有错的是：
A.Viz operator *();
B.Viz operator *(Viz);
C.int operator *(Viz);
选中D.Viz operator *(Viz, Viz);
有如下类定义：
class MyClass {
public:
MyClass(double d=0.0):val(d) { }
______________ //类型转换运算符double的定义
private:
double val;
};
若要使语句序列
MyClass x(2.1);
cout<
能够正常运行，横线处的语句应为：
选中A.operator double() const { return val; }
B.friend operator double() const { return val; }
C.double operator() const { return val; }
D.friend double operator() const { return val; }
设c1和c2是类MyClass的对象，若将前缀运算符"--"和运算符"/"作为类MyClass的友元函数重载，则表达式--c1/c2等价于：
A.operator/(c1.operator--(),c2)
选中B.operator/(operator--(c1),c2)
C.c1.operator--().operator/(c2)
D.c2.operator/(operator--(c1))
有如下类定义：
class MyClass {
public:
MyClass(double d=0.0):val(d) { }
______________ //后缀自增运算符++的声明
private:
double val;
};
若要使语句序列
MyClass x(2.1),y;
y=x++;
能够正常运行，横线处的语句应为：
A.MyClass& operator++();
B.MyClass& operator++(MyClass&,int);
选中C.MyClass operator++(int);
D.MyClass operator++();
下列关于基类和派生类关系的叙述中，正确的是：
A.每个类最多只能有一个直接基类
B.派生类中的成员可以访问基类中的任何成员
C.基类的构造函数必须在派生类的构造函数体中调用
选中D.派生类除了继承基类的成员，还可以定义新的成员
有如下类定义：
class B{
public: void fun1() { }
private: void fun2() { }
protected: void fun3() { }
};
class D: public B {
protected: void fun4() { }
};
若obj是类D的对象，则下列语句中不违反访问控制权限的是：
选中A.obj.fun1();
B.obj.fun2();
C.obj.fun3();
D.obj.fun4();
有如下程序：
#include
using namespace std;
class A {
public:
A() { cout<<"A"; }
~A() { cout<<"~A"; }
};
class B : public A {
A* p;
public:
B() { cout<<"B"; p = new A(); }
~B() { cout<<"~B"; delete p; }
};
int main() {
B obj;
return 0;
}
执行这个程序的输出结果是：
A.BAA~A~B~A
选中B.ABA~B~A~A
C.BAA~B~A~A
D.ABA ~A~B~A
下列有关继承和派生的叙述中，正确的是：
A.如果一个派生类私有继承其基类，则该派生类对象不能访问基类的保护成员
B.派生类的成员函数可以访问基类的所有成员
C.基类对象可以赋值给派生类对象
选中D.如果派生类没有实现基类的一个纯虚函数，则该派生类是一个抽象类
在公有继承的情况下，允许派生类直接访问的基类成员包括：
A.公有成员
选中B.公有成员和保护成员
C.公有成员、保护成员和私有成员
D.保护成员
有如下类定义：
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试图访问基类的私有成员变量k
B.在类MyDerived的定义中，基类名MyBase前缺少关键字public、protected或private
C.类MyDerived 缺少一个无参的构造函数
D.类MyDerived的构造函数没有对基类数据成员k进行初始化
下列关于派生类构造函数和析构函数的说法中，错误的是：
A.派生类的构造函数会隐含调用基类的构造函数
B.如果基类中没有缺省构造函数，那么派生类必须定义构造函数
C.在建立派生类对象时，先调用基类的构造函数，再调用派生类的构造函数
选中D.在销毁派生类对象时，先调用基类的析构函数，再调用派生类的析构函数
派生类的成员函数不能访问基类的：
A.公有成员和保护成员
B.公有成员
选中C.私有成员
D.保护成员
有如下类定义：
class AA {
int a;
Public:
AA(int n=0):a(n) {}
};
class BB :public AA {
public:
BB(int n)________________
};
其中横线处的缺失部分是：
A.a(n) {}
选中B.AA(n) {}
C.{ a(n); }
D.{ a=n; }
如果派生类以protected方式继承基类，则原基类的protected成员和public成员在派生类中的访问属性分别是：
A.public和public
B.public和protected
C.protected和public
选中D.protected和protected
下列有关继承和派生的叙述中，正确的是：
A.派生类不能访问基类的保护成员
B.作为虚基类的类不能被实例化
选中C.派生类应当向基类的构造函数传递参数
D.虚函数必须在派生类中重新实现
下列代码段中声明了3个类：
class Person {};
class Student : public Person {};
class Undergraduate : Student {};
错误的是，下列关于这些类之间关系的描述中：
A.类Person是类Undergraduate的基类
选中B.类Undergraduate从类Student公有继承
C.类Student是类Person的派生类
D.类Undergraduate是类Person的派生类
下列有关类继承的叙述中，错误的是：
A.继承可以实现软件复用
B.虚基类可以解决由多继承产生的二义性
C.派生类构造函数要负责调用基类的构造函数
选中D.派生类没有继承基类的私有成员
在下列关键字中，不能用来表示继承方式的是：
A.private
选中B.static
C.public
D.protected
有如下两个类定义：
class XX {
private:
double x1;
protected:
double x2;
public:
double x3;
};
class YY: protected XX {
private:
double y1;
protected:
double y2;
public:
double y3;
};
在类YY中保护成员变量的个数是：
A.1
B.2
选中C.3
D.4
有如下类声明：
class Base1{ };
class Base2{ };
class Derived: public Base2,public Base1{ };
在一个 Derived 对象消亡时，析构函数被调用的顺序是：
选中A.~Derived、~Base1、~Base2
B.~Derived、~Base1、~Base2
C.~Base1、~Base2、~Derived
D.~Base2、~Base1、~Derived
在公有继承的情况下，允许派生类中新定义的成员函数直接访问的基类成员只包括：
选中A.公有成员和保护成员
B.公有成员
C.公有成员、保护成员和私有成员
D.保护成员
有如下类定义：
class Point{
public:
Point(int xx=0,int yy=0):x(xx),y(yy) { }
private:
int x,y;
};
class Circle:public Point{
public:
Circle(int r):radius(r) { }
private:
int radius;
};
派生类Circle中数据成员的个数为：
A.1
B.2
选中C.3
D.5
有如下两个类定义：
class AA{};
class BB{
AA v1,*v2;
BB v3;
int *v4;
};
其中有一个成员变量的定义是错误的，这个变量是：
A.v1
B.v2
选中C.v3
D.v4
有如下类定义：
class Person{
public:
Person(string s):name(s) { }
protected:
string name;
};
class Father:virtual public Person{
public:
Father(string s):Person(s) { }
};
class Mother:virtual public Person{
public:
Mother(string s):Person(s) { }
};
class Child:public Father,public Mother,virtual public Person{
public:
Child(string s1,string s2,string s3):Mother(s1),Father(s2),Person(s3) { }
};
在建立派生类Child的对象时，其基类Father、Mother和Person的构造函数的调用顺序为：
A.Father,Mother,Person
B.Mother,Father,Person
选中C.Person,Father,Mother
D.Father,Person,Mother,Person,Person
有如下类定义：
class Point{
public:
void SetX(int xx) { x=xx; }
protected:
void SetY(int yy) { y=yy; }
private:
int x,y;
};
class Circle:Point{
public:
int GetRadius() { return radius; }
private:
void SetRadius(int r) { radius=r; }
int radius;
};
派生类Circle中不可访问成员的个数为：
选中A.2
B.3
C.4
D.6
有如下类定义：
class Base{
public: int a;
protected: int b;
private: int c;
};
class Derived: public Base {
protected: int d;
friend void show();
};
在类 Derived 中，函数 show() 不能直接访问的数据成员是：
A.a
B.b
选中C.c
D.d
通过派生类的对象可直接访问的是：
选中A.公有继承基类的公有成员
B.私有继承基类的公有成员
C.公有继承基类的私有成员
D.私有继承基类的私有成员
有如下类声明：
class Wd{
int a;
public:
int b;
int c;
private:
int d;
protected:
int e;
};
其中访问权限为私有的成员变量有：
A.a 和 b
B.b 和 c
选中C.a 和 d
D.d 和 e
当一个派生类对象结束其生命周期时，自动做的事情是：
选中A.先调用派生类的析构函数后调用基类的析构函数
B.先调用基类的析构函数后调用派生类的析构函数
C.如果派生类没有定义析构函数，则只调用基类的析构函数
D.如果基类没有定义析构函数，则只调用派生类的析构函数
有如下类定义：
class Base{
int m;
int n;
public:
Base(int m1, int n1): n(n1),m(m1){}
};
class Derived: public Base{
int q;
public:
Derived(int m1, int n1, int q1): q(q1),Base(m1,n1){};
};
在创建一个 Derived 对象时，数据成员 m、n 和 q 被初始化的顺序是：
选中A.m、n、q
B.n、m、q
C.q、m、n
D.q、n、m
有如下类定义：
class Base {
public:
void fun() { cout<<"Base::fun"<
};
class Derived : public Base {
public:
void fun() {
____________;
cout<<"Derived::fun"<
}
};
若需要在划线处调用基类中的fun()函数，则填写的语句是：
A.Base.fun();
B.Base->fun();
选中C.Base::fun();
D. fun();
有如下类定义：
class Base{
public: int a;
protected: int b;
private: int c;
};
class Derived: public Base {
protected: int d;
};
若 obj 是类 Derived 的对象，以下语句编译正确的是：
选中A.obj.a;
B.obj.b;
C.obj.c;
D.obj.d;
下列关于虚函数的叙述中，正确的是：
选中A.虚函数不能是静态成员函数
B.从虚基类继承的函数都是虚函数
C.只能通过指针或引用调用虚函数
D.抽象类中的成员函数都是虚函数
下列选项中，与实现运行时多态性无关的是：
选中A.重载函数
B.虚函数
C.引用
D.指针
有如下类定义：
class Shape{
public:
___________________ //虚函数 Draw 的声明
};
横线处缺失的虚函数Draw的声明是：
选中A.virtual void Draw();
B.void virtual Draw();
C.void Draw() virtual;
D.void Draw(virtual);
有如下程序：
#include
using namespace std;
class Shape{ //图形类
public:
//图形绘制函数（用显示字母模拟）
virtual void draw()const{ cout<<'S'; }
};
class Circle: public Shape{ //圆形类
public:
void draw()const{ cout<<'C'; }
};
void plot(Shape &s){ s.draw(); }
int main(){
Shape *ps=new Circle;
Circle t;
ps->draw();
t.draw();
plot(t);
delete ps;
return 0;
}
运行这个程序的输出是：
A.SCC
B.SCS
C.CSS
选中D.CCC
下列有关虚函数的表述中正确的是：
选中A.对于派生类中定义的成员函数，即使没有加 virtual 修饰，也有可能是虚函数
B.只有虚函数才允许在派生类进行重定义
C.对虚函数的任何调用都称为多态调用
D.构造函数和析构函数也可以声明为虚函数
下列有关虚函数的表述中，错误的是：
A.在 C++ 中，运行时的多态性是通过虚函数体现的
选中B.在类声明中只有加了保留字 virtual 的成员函数才是虚函数
C.通过指针或引用对虚函数的调用称为多态调用
D.非多态调用总是通过成员访问运算符“.” 进行的
下列有关类的表述中，正确的是：
A.含有虚函数的类不能被实例化
B.派生类不能访问基类的保护成员
C.派生类只能隐含调用基类的构造函数
选中D.纯虚函数没有函数体
下列关键字中，用来说明虚函数的关键字是：
A.inline
B.operator
选中C.virtual
D. public
下列的成员函数中，纯虚函数是：
A.virtual void f1()=0
B.void f1()=0;
C.virtual void f1(){}
选中D. virtual void f1()=0;
含有一个或多个纯虚函数的类称为：
选中A.抽象类
B.具体类
C.虚基类
D.派生类
下列关于虚函数的描述中，错误的是：
A.虚函数是一个成员函数
B.虚函数具有继承性
选中C.静态成员函数可以声明为虚函数
D.在类的继承层次结构中，虚函数是声明部分相同的函数
下列各种类中，不能定义对象的类是：
A.嵌套类
选中B.抽象类
C.虚基类
D.派生类
下列关于抽象类的描述中，错误的是：
A.抽象类中至少应该有一个纯虚函数
B.抽象类可以定义对象指针和对象引用
C.抽象类通常用作类族中最顶层的类
选中D.抽象类的派生类必定是具体类
一个类的层次结构中，定义有虚函数，并且都是公有继承，在下列情况下，实现动态联编的是：
A.使用类的对象调用虚函数
B.使用类名限定调用虚函数，其格式为：<类名>::<虚函数名>
C.使用构造函数调用虚函数
选中D.使用成员函数调用虚函数
下列关于动态联编的描述中，错误的是：
A.动态联编是函数联编的一种方式，它是在运行时来选择联编函数的
B.动态联编又可称为动态多态性，它是C++语言中多态性的一种重要形式
C.函数重载和运算符重载都属于动态联编
选中D.动态联编只是用来选择虚函数的
在C++中，cin 是一个：
A.类
选中B.对象
C.模板
D.函数
下列关于C++预定义流对象的叙述中，正确的是：
选中A.cin是C++预定义的标准输入流对象
B.cin是C++预定义的标准输入流类
C.cout是C++预定义的标准输入流对象
D.cout是C++预定义的标准输入流类
下列语句都是程序运行时的第1条输出语句，其中一条语句的输出效果与其他三条语句不同，该语句是：
A.cout<
B.cout<
C.cout<
选中D.cout<
本文来源：https://www.2haoxitong.net/k/doc/1f5d6a1ceffdc8d376eeaeaad1f34693daef10f0.html
文档为doc格式