第1讲 函数的定义和使用

第1讲 掌握函数的定义和函数的调用方式

1、下列特性中,C与C++共有的是:
    A、继承
    B、封装
    C、多态性
    D、函数定义不能嵌套

2、必须用一对大括号括起来的程序段是:
    A、switch语句中的case标号语句
    B、if语句的分支
    C、循环语句的循环体
    D、函数的函数体

3、关于C++主函数特性,下列叙述正确的是:
    A、主函数在同一个C++文件中可以有两个
    B、主函数类型必须是void类型
    C、主函数一定有返回值
    D、每个C++程序都必须有一个main()函数

4、在C++语言中,main函数默认返回一个( )类型的值
    A、int
    B、float
    C、char
    D、void

5、C++语言中规定函数的返回值的类型是由:
    A、return语句中的表达式类型所决定
    B、调用该函数时的主调用函数类型所决定
    C、调用该函数时系统临时决定
    D、在定义该函数时多指定的数据类型所决定

6、若调用一个函数,且此函数中没有return语句,则正确的说法是该函数:
    A、没有返回值
    B、返回若干个系统默认值
    C、有返回值,但返回一个不确定的值
    D、回一个用户所希望的函数值

7、下列叙述中错误的是:
    A、一个函数中可以有多条return语句
    B、调用函数必须在一条独立的语句中完成
    C、函数中通过return语句传递函数值
    D、主函数名main也可以带有形参

8、在C++中把不返回任何类型的函数应该说明为:
    A、int
    B、float
    C、char
    D、void

9、在函数的定义格式中,下面各组成部分中,( )是可以省略的。
    A、函数名
    B、函数数据类型说明
    C、函数体
    D、函数参数

10、函数调用func((exp1,exp2),(exp3,exp4,exp5))中所含实参的个数为:
    A、1
    B、2
    C、3
    D、4

第3讲 函数的设计

第3讲 灵活运用函数重载、默认参数和函数模板

1、指出下列对定义重载函数的要求中,( )是错误的。
    A、要求参数的个数相同
    B、要求参数的类型相同时,参数个数不同
    C、函数的返回值可以不同
    D、要求参数的个数相同时,参数类型不同

2、一个函数为void x(int,char ch=’a’),另一个函数为void x(int),则它们:
    A、不能在同一程序中定义
    B、可以在同一程序中定义并可重载
    C、可以在同一程序中定义,但不可以重载
    D、以上说法均不正确

3、重载函数在调用时选择的依据中,错误的是:
    A、函数的参数
    B、参数的类型
    C、函数的名字
    D、函数返回值类型

4、下列函数原型声明中错误的是:
    A、void fun(int x=0,int y=0);
    B、void fun(int x,int y);
    C、void fun(int x,int y=0);
    D、void fun(int x=0,int y);

5、一个函数带有参数说明时,则参数的默认值应该在( )中给出。
    A、函数定义
    B、函数声明
    C、函数定义或声明
    D、函数调用

6、下列关于函数参数默认值的描述中,正确的是:
    A、函数参数的默认值只能设置一个
    B、若一个函数含有多个参数,其中一个参数设置成默认值后,其后所有参数都必须 设置默认值
    C、若一个函数含有多个参数,则设置默认参数时可以不连续设置默认值
    D、C++语言中函数都必须设有默认值

7、模板函数的真正代码是在( )时候产生。
    A、源程序中声明函数时
    B、源程序中定义函数时
    C、源程序中的调用函数时
    D、运行执行函数时

8、以下关于函数模板叙述正确的是:
    A、函数模板也是一个具体类型的函数
    B、函数模板的类型参数与函数的参数是同一个概念
    C、通过使用不同的类型参数,函数模板可以生成不同类型的函数
    D、用函数模板定义的函数没有类型

9、常情况下,函数模板中的类型参数个数不能是:
    A、0
    B、1
    C、2
    D、3

10、实现两个相同类型数加法的函数模板的声明是:
    A、add(T x,T y)
    B、T add(x,y)
    C、T add(T x,y)
    D、T add(T x,T y)

第2讲 函数的调用

第2讲 掌握函数的嵌套调用和递归调用

1、在参数传递过程中,对形参和实参的要求是:
    A、函数定义时,形参一直占用存储空间
    B、实参可以是常量、变量或表达式
    C、形参可以是常量、变量或表达式
    D、形参和实参类型和个数都可以不同

2、在函数的引用调用时,实参和形参应该是使用:
    A、变量值和变量
    B、地址值和指针
    C、地址值和引用
    D、变量值和引用

3、使用值传递方式将实参传给形参,下列说法正确的是:
    A、形参是实参的备份
    B、实参是形参的备份
    C、形参和实参是同一对象
    D、形参和实参无联系

4、下列函数调用中对调用它的函数没有起到任何作用的是:
    A、void f1(double &x){--x;}
    B、double f2(double x){return x-1.5;}
    C、void f3(double x){--x;}
    D、double f4(double *x){--*x;return *x;}

5、对于某个函数调用,不给出调用函数的声明的情况是:
    A、被调用函数是无参函数
    B、被调用函数是无返回值的函数
    C、函数的定义在调用处之前
    D、函数的定义有别的程序文件中

6、在哪种情况下适宜采用 inline 定义内联函数?
    A、函数体含有循环语句
    B、函数体含有递归语句
    C、函数代码少、频繁调用
    D、函数代码多、不常调用

7、下列哪个类型函数不适合声明为内联函数:
    A、函数体语句较多
    B、函数体语句较少
    C、函数执行时间较短
    D、函数执行时间过长

8、在C++中,编写一个内联函数Fsqu,使用double类型的参数,求其平方并返回,返回值为double类型,下列定义正确的是:
    A、double Fsqu (double x){return x*x;}
    B、inline double Fsqu (double x){return x*x;}
    C、double inline Fsqu (double x){return x*x;}
    D、double Fsqu (double x){inline return x*x;}

9、已知递归函数f的定义如下: int f(int n) { if (n<=1) return 1; else return n*f(n-2); } 则函数调用语句f(5)的返回值是:
    A、14
    B、15
    C、16
    D、17

10、在一个函数体中直接或间接地调用函数本身,这种调用称为()调用。
    A、嵌套
    B、递归
    C、直接
    D、间接

第4讲 作用域、生命期和程序的组织结构

第4讲 理解作用域、生命期和程序的组织结构

1、不能实现函数之间数据传递的是:
    A、全局变量
    B、局部变量
    C、函数接口
    D、函数返回值

2、所有在函数中定义的变量,连同形式参数,都是:
    A、全局变量
    B、局部变量
    C、静态变量
    D、寄存器变量

3、内部静态变量的作用域是:
    A、定义该静态变量的函数外部
    B、定义该静态变量的函数内部
    C、定义该静态变量的文件外部
    D、定义该静态变量的文件内部

4、进行初始化即可自动获取初值为0的变量是:
    A、任何用static修饰的变量
    B、任何在函数外定义的变量
    C、局部变量和用static修饰的全局变量
    D、全局变量和用static修饰的局部变量

5、在函数中,可以用auto,extern,register和static四个关键字中的一个来说明变量的存储类型,如果不说明存储类型,则默认的存储类型是:
    A、auto
    B、extern
    C、register
    D、static

6、在一个C++源程序文件中定义的全局变量的有效范围是:
    A、该C++程序的所有源程序文件
    B、本源程序文件的全部范围
    C、从定义变量的位置开始到本源程序文件结束
    D、函数内部全部范围

7、在C++中有以下4条语句: static int hot=200; int &rad=hot; hot=hot+100; cout<<rad<<endl; 执行这4条语句后输出为:
    A、0
    B、100
    C、200
    D、300

8、下面关于C++语言变量的叙述错误的是:
    A、C++语言中变量为auto,static,extern和register四种存储类型
    B、自动变量和外部变量的作用域为整个程序
    C、内部静态变量的作用域是定义它的函数
    D、外部静态变量的作用域是定义它的文件

9、如果在一个源文件中定义的函数,只能被本文件中的函数调用,而不能被同一程序其它文件中的函数调用,则说明这个函数为:
    A、私有函数
    B、内部函数
    C、外部函数
    D、库函数

10、重新定义标识符的作用域规定是外层变量被隐藏,()变量是可见的。
    A、外层
    B、内层
    C、外层和内层
    D、内部

第5讲 标准库

第5讲 了解标准库的内容、掌握字符串流的使用

1、下列关于C++流的说明中,正确的是:
    A、与键盘、屏幕、打印机和通信端口的交互都可以通过流类来实现
    B、从流中获取数据的操作称为插入操作,向流中添加数据的操作称为提取操作
    C、cin是一个预定义的输入流类
    D、输出流有一个名为open的成员函数,其作用是生成一个新的流对象

2、在C++中使用流进行输入输出,其中用于屏幕输出的对象是:
    A、cerr
    B、cin
    C、cout
    D、cfile

3、out、cerr、clog是( )的对象,cout处理标准输出,cerr和clog都处理标准出错信息
    A、istream
    B、ostream
    C、cerr
    D、clog

4、在下面格式化命令的解释中,错误的是:
    A、ios::skipws 跳过输入中的空白字符
    B、ios::fill() 获得当前的填充字符
    C、ios::hex 转换基数为八进制形式
    D、ios::precision 返回当前的精度

5、在进行完任何C++流的操作后,都可以用C++流的有关成员函数检测流的状态;其中只能用于检测输入流状态的操作函数名称是:
    A、fail
    B、eof
    C、bad
    D、good

第6讲 文件

第6讲 掌握文件的基本操作

1、在C++中,打开一个文件,就是将整个文件与一个( )建立关联,关闭一个文件,就是取消这种关联
    A、类
    B、流
    C、对象
    D、结构

2、下列打开文件的表达式中,错误的是:
    A、ofstream ofile;ofile.open(“C:\\vc\\abc.txt”,ios::binary);
    B、fstream iofile;iofile.open(“abc.txt”,ios::ate);
    C、ifstream ifile (“C:\\vc\\abc.txt”);
    D、cout.open(“C:\\vc\\abc.txt”,ios::binary);

3、以下关于文件操作的叙述中,不正确的是:
    A、打开文件的目的是使文件对象与磁盘文件建立联系
    B、文件读写过程中,程序将直接与磁盘文件进行数据交换
    C、关闭文件的目的之一是保证将输出的数据写入硬盘文件
    D、关闭文件的目的之一是释放内存中的文件对象

4、语句ofstream f("SALARY.DAT",ios::noreplace | ios::binary); 的功能是建立流对象f,并试图打开文件SALARY.DAT并与之连接,而且:
    A、若文件存在,将文件指针定位于文件尾;若文件不存在,建立一个新文件
    B、若文件存在,将其截为空文件;若文件不存在,打开失败
    C、若文件存在,将文件指针定位于文件首;若文件不存在,建立一个新文件
    D、若文件存在,打开失败;若文件不存在,建立一个新文件

5、执行语句序列ofstream outf(“SALARY.DAT”);if(...)cout<<“成功”;else cout<<“失败”;后,如文件打开成功,显示”成功”,否则显示”失败”.由此可知,上面if语句的条件表达式是:
    A、!outf或者outf.fail()
    B、!outf或者outf.good()
    C、outf或者outf.fail()
    D、outf或者outf.good()

第7讲 数组的定义和使用

第7讲 掌握数组的定义和使用

1、下列关于数组的描述正确是:
    A、数组的长度是固定的,而其中元素的数据类型可以不同
    B、数组的长度是固定的,而其中元素的数据类型必须相同
    C、数组的长度是可变的,而其中元素的数据类型可以不同
    D、数组的长度是可变的,而其中元素的数据类型必须相同

2、在C++语言中引用数组元素时,下面关于数组下标数据类型的说法错误的是:
    A、整型常量
    B、整型表达式
    C、整型常量或整型表达式
    D、任何类型的表达式

3、要定义数组A,使得其中每个元素的数据分别依次为:3、9、4、8、0、0、0,错误的定义语句是:
    A、int A[]={3,9,4,8,0,0,0};
    B、int A[9]={3,9,4,8,0,0,0};
    C、int A[]={3,9,4,8};
    D、int A[7]={3,9,4,8};

4、有如下数组声明:int value[30];,下标值引用错误的是:
    A、value[30]
    B、value[0]
    C、value[10]
    D、value[20]

5、以下叙述中错误的是:
    A、对于double类型数组,不可以直接用数组名对数组进行整体输入或输出
    B、数组名代表的是数组所占存储区的首地址,其值不可改变
    C、当程序执行中,数组元素的下标超出所定义的下标范围时,系统将给出“下标越界”的出错信息
    D、可以通过赋初值的方式确定数组元素的个数

6、以下正确的二维数组定义是:
    A、int a[][]={1,2,3,4,5,6};
    B、int a[2][]={1,2,3,4,5,6};
    C、int a[][3]={1,2,3,4,5,6};
    D、int a[2,3]={1,2,3,4,5,6};

7、以下对二维数组a进行初始化正确的是:
    A、int a[2][]={{1,0,1},{5,2,3}} ;
    B、int a[][3]={{1,2,3},{4,5,6}} ;
    C、int a[2][4]={{1,2,3},{4,5},{6}} ;
    D、int a[][3]={{1,0,1},{},{1,1}} ;

8、若有定义:int a[3][4];则正确引用数组a元素的是:
    A、a[2][4]
    B、a[3][3]
    C、a[0][0]
    D、a[3][4]

9、若有定义:int a[][4]={0,0};以下叙述中错误的是:
    A、数组a的每个元素都可得到初值0
    B、二维数组a的第一维大小为1
    C、因为初值个数除以a中第二维大小的值的商为0,故数组a的行数为1
    D、只有元素a[0][0]和a[0][1]可得到初值0,其余元素均得不到初值0

10、下面选项中等价的是:
    A、int a[2][3]={1,0,2,2,4,5}与int a[2][]= {1,0,2,2,4,5};
    B、int a[][3]= {1,0,2,2,4,5}与int a[2][3]= {1,0,2,2,4,5};
    C、int a[2][3]={3,4,5}与int a[][3]={3,4,5};
    D、int a[2][3]={0,1}与int a[2][3]={{0},{1}};

第8讲 数组与函数

第8讲 掌握数组作为函数参数的使用方法

1、若用数组名作为函数调用的实参,传递给形参的是:
    A、数组的首地址
    B、数组中第一个元素的值
    C、数组中的全部元素的值
    D、数组元素的个数

2、对数组名作函数的参数,下面描述正确的是:
    A、数组名作函数的参数,调用时将实参数组复制给形参数组
    B、数组名作函数的参数,主调函数和被调函数共用一段存储单元
    C、数组名作参数时,形参定义的数组长度不能省略
    D、数组名作参数,不能改变主调函数中的数据

3、已知某函数的一个形式参数被说明为MAT[3][10],在下列说明中,与此等效的形参说明是:
    A、int MAT[][10]
    B、int MAT[3][]
    C、int MAT[10][3]
    D、int MAT[][]

4、设主调用函数为如下程序段,则函数f中对形参数组定义错误的是: int a[3][4]; f(a);
    A、f(int array[3][4])
    B、f(int array[][4])
    C、f(int array[3][])
    D、f(int array[4][3])

5、下面程序执行后的输出结果是: #include <iostream> using namespace std; int f(int b[],int m,int n) { int i,s=0; for(i=m;i<n;i++) s=s+b[i-1]; return s; } int main() { int x,a[]={1,2,3,4,5,6,7,8,9}; x=f(a,3,7); cout<<x; return 0; }
    A、10
    B、18
    C、8
    D、15

6、下面程序执行后的输出结果是: #include <iostream> using namespace std; #define N 20 void fun(int a[],int n,int m) { int i; for(i=m;i>=n;i--) a[i+1]=a[i]; } int main() { int i; int a[N]={1,2,3,4,5,6,7,8,9,10}; fun(a,2,9); for(i=0;i<5;i++) cout<<a[i]; return 0; }
    A、10234
    B、12344
    C、12334
    D、12234

7、下面程序执行后的输出结果是: #include <iostream> using namespace std; void swap1(int c[]) { int t; t=c[0];c[0]=c[1];c[1]=t; } void swap2(int c0,int c1) { int t; t=c0;c0=c1;c1=t; } int main( ) { int a[2]={3,5},b[2]={3,5}; swap1(a) ; swap2(b[0],b[1]); cout<<a[0] <<a[1] <<b[0] <<b[1]; return 0; }
    A、5353
    B、5335
    C、3535
    D、3553

8、下面程序执行后的输出结果是: #include <iostream> using namespace std; int fun(int t[],int n) { int m; if(n>=2) { m=fun(t,n-1); return m; } return t[0]; } int main() { int a[]={11,4,6,3,8,2,3,5,9,2}; cout<<fun(a,10); return 0; }
    A、10
    B、11
    C、12
    D、13

第9讲 字符串的处理

第9讲 掌握C和C++的字符串处理方式

1、字符串的长度是:
    A、串中不同字符的个数
    B、串中不同字母的个数
    C、串中所含字符的个数且字符个数大于0
    D、串中所含字符的个数

2、下列说法正确的是:
    A、字符型数组与整型数组可通用
    B、字符型数组与字符串其实没什么区别
    C、当字符串放在字符数组中,这时要求字符数组长度比字符串长1个单元,因为要 放字符串终结符’\0’
    D、字符串的输出可以用它所存储的数组来输出,也可以字符串的形式整体输出,结 果没区别

3、下面有关字符数组的描述中错误的是:
    A、字符数组可以存放字符串
    B、字符串可以整体输入、输出
    C、可以在赋值语句中通过赋值运算对字符数组整体赋值
    D、不可以用关系运算符对字符数组中的字符串进行比较

4、给出下面定义: char a[]=”abcd”; char b[]={‘a’,’b’,’c’,’d’}; 则下列说法正确的是:
    A、数组a与数组b等价
    B、数组a和数组b的长度相同
    C、数组a的长度大于数组b的长度
    D、数组a的长度小于数组b的长度

5、下面程序输出结果为: #include<iostream> using namespace std; #include<string.h> int main( ) { char st[20]="hello\0\t\\"; cout<<strlen(st); cout<<sizeof(st)<<endl; cout<<st; return 0; }
    A、520 hello
    B、1220 hello\0\t
    C、520 hello\t
    D、1120 hello└┘└┘

6、要使字符串变量str具有初值"Lucky",正确的定义语句是:
    A、char str[]={'L','u','c','k','y'};
    B、char str[5]={'L','u','c','k','y'};
    C、char str []="Lucky";
    D、char str [5]="Lucky";

7、下列是为字符数组赋字符串的语句组,其中错误是:
    A、char s[10]; s=”program”;
    B、char s[]=”program”;
    C、char s[10]=”Hello!”;
    D、char s[10];strcpy(s,”hello!”);

8、字符数组s不能作为字符串使用的是:
    A、char s[]="happy";
    B、char s[6]={'h','a','p','p','y',''};
    C、char s[]={"happy"};
    D、char s[5]={'h','a','p','p','y'};

9、下面程序段执行后的输出结果是: char c[5]={'a','b','','c',''}; cout<<c;
    A、'a''b'
    B、ab
    C、ab c
    D、abc

10、下面程序执行后的输出结果是: #include <iostream> using namespace std; #include<string.h> int main() { char str[]=" SSWLIA" , c; int k; for (k=2;(c=str[k])!='\0';k++) { switch (c) { case 'I': ++k; break ; case 'L': continue; default : cout<<c; continue ; } cout<<'*'; } return 0; }
    A、SSW
    B、SW*
    C、SW*A
    D、SW

第11讲 指针的定义与使用

第11讲 理解指针的定义,掌握指针的使用方法

1、下面对于指针的描述不正确的是:
    A、指针是地址变量
    B、指针不能用除0以外的常量赋值
    C、两个指针变量的加法无意义
    D、指针指向不同基类型的变量长度不同

2、在int a=3,int *p=&a;中,*p的值是:
    A、变量a的地址值
    B、无意义
    C、变量p的地址值
    D、3

3、已知int a, *pa=&a;输出指针pa十进制的地址值的方法是:
    A、cout<<pa;
    B、cout<<*pa;
    C、cout<<&pa;
    D、cout<<long(&pa);

4、变量的指针,其含义是指该变量的:
    A、值
    B、地址
    C、名
    D、一个标志

5、已有定义int k=2;int *ptr1,*ptr2;且ptr1和ptr2均已指向变量k,下面不能正确执行的赋值是:
    A、k=*ptr1+*ptr2
    B、ptr2=k
    C、ptr1=ptr2
    D、k=*ptr1*(*ptr2)

6、若有int *p,a=4;和p=&a;下面那个选项均代表地址?
    A、a,p,*&a
    B、&*a,&a,*p
    C、*&p,*p,&a
    D、&a,&*p,p

7、若变量已正确定义并且指针p已经指向变量x,则*&x相当于:
    A、x
    B、p
    C、&x
    D、&*p

8、若定义了int m,n=0,*p1=&m;则下列哪个表达式与m=n等价。
    A、m=*p1
    B、*p1=&*n
    C、*&p1=&*n
    D、*p1=*&n

9、假如指针p已经指向整型变量x,则(*p)++相当于:
    A、x++
    B、p++
    C、*(p++)
    D、&x++

10、对于基类型相同的两个指针变量之间,不合理的运算是:
    A、<
    B、=
    C、+
    D、-

第12讲 指针与数组

第12讲 掌握指针对一维数组的操作

1、以下四种说法中,正确的一项是:
    A、C++允许在字符串上进行整体操作
    B、语句:char vn[]=”Brown”; 将vn定义成一个有5个元素的数组,因为”Brown”中含有5个字符
    C、对指针只要赋给一个地址值就可以了
    D、一维的指针数组实际上是一个二维数组

2、定义如下一维数组:int a[5],*p=a;则下面描述错误的是:
    A、表达式p=p+1是合法的
    B、表达式a=a+1是合法的
    C、表达式p-a是合法的
    D、表达式a+2是合法的

3、若有语句int a[10]={0,1,2,3,4,5,6,7,8,9},*p=a;则哪个不是对a数组元素的正确引用(其中0≤i<10)。
    A、p[i]
    B、*(*(a+i))
    C、a[p-a]
    D、*(&a[i])

4、有如下程序段: int *p,a[6]={-1,0,1,2,3,4}; p=a+3; 执行该程序段后,*p的值为:
    A、4
    B、2
    C、1
    D、NULL

5、若有定义 char s[10];则在下面表达式中不表示s[1]的地址的是:
    A、s+1
    B、s++
    C、&s[0]+1
    D、&s[1]

6、若要对a进行合法的自减运算,则之前应有下面哪个说明?
    A、int p[3]; int *a=p;
    B、int k; int *a=&k;
    C、char *a[3];
    D、int b[10]; int *a=b+1;

7、若有定义int x[10]={0,1,2,3,4,5,6,7,8,9},*p1;则数值不为3的表达式是:
    A、x[3]
    B、p1=x+3,*p1++
    C、p1=x+2,*(p1++)
    D、p1=x+2,*++p1

8、若有定义int x[6]={2,4,6,8,5,7},*p=x,i;要求依次输出x数组6个元素中的值,不能完成此操作的语句是:
    A、for(i=0;i<6;i++) cout<<setw(2)<<*(p++);
    B、for(i=0;i<6;i++) cout<<setw(2)<<*(p+i);
    C、for(i=0;i<6;i++) cout<<setw(2)<<*p++);
    D、for(i=0;i<6;i++) cout<<setw(2)<<(*p)++;

9、下面程序执行后的输出结果是: #include <iostream> using namespace std; void sum(int *a) { a[0]=a[1];} int main() { int aa[10]={1,2,3,4,5,6,7,8,9,10},i; for(i=2;i>=0;i--) sum(&aa[i]); cout<<aa[0]; return 0; }
    A、1
    B、2
    C、3
    D、4

10、下面程序执行后的输出结果是: #include <iostream> using namespace std; int main() { int a[10]={1,2,3,4,5,6,7,8,9,10}, *p=&a[3], *q=p+2; cout<<*p+*q; return 0; }
    A、16
    B、10
    C、8
    D、6

第13讲 指针与函数

第13讲 掌握指针作为函数参数的用法以及指向函数的指针

1、下面程序执行后的输出结果是: #include <iostream> using namespace std; void fun(char *c,char d) { *c=*c+1; d=d+1; cout<<*c<<","<<d<<","; } int main() { char a='A', b='a'; fun(&b,a); cout<<a<<","<<b<<endl; return 0; }
    A、B,a,B,a
    B、a,B,a,B
    C、A,b,A,b
    D、b,B,A,b

2、下面程序执行后的输出结果是: #include <iostream> using namespace std; void ss(char *s,char t) { while(*s) { if(*s==t) *s=t-'a'+'A'; s++; } } int main() { char str1[100]="abcddfefdbd",c='d'; ss(str1,c); cout<<str1; return 0; }
    A、ABCDDEFEDBD
    B、abcDDfefDbD
    C、abcAAfefAbA
    D、Abcddfefdbd

3、以下函数的功能是: fun(char *a,char *b) { while((*a!='\0')&&(*b!='\0')&&(*a==*b)) { a++;b++;} return(*a-*b); }
    A、计算a和b所指字符串的长度之差
    B、将b所指字符串连接到a所指字符串中
    C、将a所指字符串连接到b所指字符串后面
    D、比较a和b所指字符串的大小

4、若有定义char *st="how are you";下列程序段中正确的是:
    A、char a[11],*p; strcpy(p=a+1,&st[4]);
    B、char a[11]; strcpy(++a, st);
    C、char a[11]; strcpy(a, st);
    D、char a[],*p; strcpy(p=&a[1],st+2);

5、以下与库函数strcpy(char *p1,char *p2)功能不相等的程序段是:
    A、strcpy1(char *p1,char *p2) { while ((*p1++=*p2++)!='\0') ; }
    B、strcpy2(char *p1,char *p2) { while ((*p1=*p2)!='\0') { p1++; p2++ } }
    C、strcpy3(char *p1,char *p2) { while (*p1++=*p2++) ; }
    D、strcpy4(char *p1,char *p2) { while (*p2) *p1++=*p2++ ; }

6、函数char* fun(char *p){ return p; }的返回值是:
    A、无确切的值
    B、形参p中存放的地址值
    C、一个临时存储单元的地址
    D、形参p自身的地址值

7、若有定义int *f();中,标识符f代表的是:
    A、一个用于指向整型数据的指针变量
    B、一个用于指向一维数组的行指针
    C、一个用于指向函数的指针变量
    D、一个返回值为指针型的函数名

8、若有定义int(*p)();标识符p可以:
    A、表示函数的返回值
    B、指向函数的入口地址
    C、表示函数的返回类型
    D、表示函数名

9、若有函数max(a,b),为了让函数指针变量p指向函数max,正确的赋值方法是:
    A、p=max;
    B、p=max(a,b);
    C、*p=max;
    D、*p=max(a,b);

10、若有以下说明和定义: int fun(int *c) {……} int main() { int (*a)(int *)=fun,*b,w[10],c; …… } 在必要的赋值之后,对fun函数的正确调用语句是:
    A、a=a(w);
    B、a(&c);
    C、b=*b(w);
    D、fun(*b);

第14讲 自定义数据类型

第14讲 掌握三种自定义数据类型

1、设有结构体说明 struct ex { int x; float y; char z;} example;以下叙述中错误的是:
    A、struct是结构体类型的关键字
    B、example是结构体类型名
    C、x,y,z都是结构体成员名
    D、struct ex是结构体类型

2、以下哪个定义不会分配实际的存储空间?
    A、struct { char name[10] ; int age ; } student ;
    B、struct STUDENT { char name[10] ; int age ; } student ;
    C、struct STUDENT { char name[10] ; int age ; } ; struct STUDENT student;
    D、struct STUDENT { char name[10] ; int age ; } ;

3、在说明一个结构体变量时,系统分配给它的存储空间是:
    A、该结构体中的第一个成员所需的存储空间
    B、该结构体中的最后一个成员所需的存储空间
    C、该结构体中占用最大存储空间的成员所需的存储空间
    D、该结构体中所有成员所需存储空间的总和

4、已知学生记录描述为: struct student { int no ; char name[20]; char sex; struct { int year; int month ; int day ; } birth; } s; 设结构变量s中的“birth”应是“1985年10月1日”,则下面正确的赋值是:
    A、year=1985; month=10; day=1;
    B、birth.year=1985; birth.month=10; birth.day=1;
    C、s.year=1985; s.month=10; s.day=1;
    D、s.birth.year=1985; s.birth.month=10; s.birth.day=1;

5、设有定义struct ru{long x;float y;} time,*timep=&time;则对time中成员x的正确引用是:
    A、ru.time.x
    B、timep.x
    C、(*timep).x
    D、time->x

6、有以下说明和定义: union dt { int a;char b;double c; } data; 以下叙述中错误的是:
    A、data的每个成员起始地址都相同
    B、变量data所占的内存字节数与成员c所占字节数相等
    C、程序段:data.a=5;cout<<data.c;输出结果为5.000000
    D、data可以作为函数的实参

7、若有定义union data {char ch;int x;} a;下列语句中哪个是不正确的?
    A、a={'x',10}
    B、a.x=10;a.x++;
    C、a.ch='x';a.ch++;
    D、a.x=10;a.ch='x';

8、若有定义enum color {red,yellow=2,blue,white,black} r=white;执行cout<<r;后的输出结果是:
    A、1
    B、2
    C、3
    D、4

9、下面对typedef的叙述中错误的是:
    A、用typedef可以定义各种类型名,但不能用来定义变量
    B、用typedef可以增加新类型
    C、用typedef只是将已存在的类型用一个新的标识符来代表
    D、使用typedef有利于程序的通用和移植

10、若有定义typedef struct {int n;char ch[8];} PER;以下叙述中正确的是:
    A、PER是结构体变量名
    B、PER是结构体类型名
    C、typedef struct 是结构体类型
    D、struct 是结构体类型名

第15讲 预处理命令

第15讲 掌握预处理命令的使用

1、以下叙述中错误的是:
    A、预处理命令行都必须以#开始
    B、在程序中凡是以#开始的语句行都是预处理命令行
    C、C++程序在执行过程中对预处理命令行进行处理
    D、预处理命令行可以出现在C++程序中任意一行上

2、设#define P(x) x/x执行语句cout <<P(3*5);后的输出结果是:
    A、1
    B、0
    C、25
    D、15

3、在任何情况下计算平方都不会引起二义性的宏定义是:
    A、#define POWER(x) x*x
    B、#define POWER(x) (x)*(x)
    C、#define POWER(x) (x*x)
    D、#define POWER(x) ((x)*(x))

4、下面程序执行后的输出结果是: #include <iostream> using namespace std; #define A 3 #define B 2*A #define C B+A int main() { int a=B; cout<<C<<"└┘"<<--a<<endl; return 0; }
    A、9└┘5
    B、2└┘3
    C、9└┘3
    D、7└┘5

5、若有宏定义: #define N 3 #define Y(n) ((N+1)*n) 则表达式2*(N+Y(5+1))的值是:
    A、出错
    B、42
    C、48
    D、54

6、已知宏定义#define p(x,y,z) x=y*z;则宏替换p(a,x+5,y-3.1)应为:
    A、a=x+5*y-3.1;
    B、a=(x+5)*(y-3.1);
    C、a=x+5*y-3.1
    D、a=(x+5)*(y-3.1)

7、下面程序执行后的输出结果是: #include <iostream> using namespace std; #define MA(x) x*x-1 int main() { int a=1,b=2; cout<<MA(1+a+b); return 0; }
    A、6
    B、8
    C、10
    D、12

8、下面程序执行后的输出结果是: #include <iostream> using namespace std; #define R 0.5 #define AREA(x) R*x*x int main() { int a=1, b=2; cout<<AREA(a+b); return 0; }
    A、0.0
    B、0.5
    C、3.5
    D、4.5

9、在“文件包含”预处理命令形式中,当#include后面的文件名用" "(双引号)括起时,寻找被包含文件的方式是:
    A、直接按系统设定的标准方式搜索目录
    B、先在源程序所在目录中搜索,再按系统设定的标准方式搜索
    C、仅仅搜索源程序所在目录
    D、仅仅搜索当前目录

10、在“文件包含”预处理命令形式中,当#include后面的文件名用< >(尖括号)括起时,寻找被包含文件的方式是:
    A、直接按系统设定的标准方式搜索目录
    B、先在源程序所在目录中搜索,再按系统设定的标准方式搜索
    C、仅仅搜索源程序所在目录
    D、仅仅搜索当前目录

第16讲 动态分配内存

第16讲 掌握动态分配内存的方法

1、对使用关键字new所开辟的动态存储空间,释放时必须使用:
    A、free
    B、create
    C、delete
    D、realse

2、关于动态存储分配,下列说法正确的是:
    A、new和delete是C++语言中专门用于动态内存分配和释放的函数
    B、动态分配的内存空间也可以被初始化
    C、当系统内存不够时,会自动回收不再使用的内存单元,因此程序中不必使用 delete释放内存空间
    D、当动态分配内存失败时,系统会立刻崩溃,因此一定要慎用new

3、对new运算符的下列描述中,哪个是错误的?
    A、它可以动态创建对象和对象数组
    B、用它创建对象数组时必须指定初始值
    C、用它创建对象时要调用构造函数
    D、用它创建的对象可以使用运算符delete来释放

4、若有以下定义,则释放指针所指内存空间的操作是: float *r=new float[10];
    A、delete r ;
    B、delete *r;
    C、delete []r;
    D、delete r[];

5、已知n是一个int型变量,下列语句中错误的是:
    A、long *p=new long[n];
    B、long p[n];
    C、long *p=new long(n);
    D、long p[10];

第18讲 类的定义

第18讲 掌握类的基本概念

1、下面关于类中概念的描述中错误的是:
    A、类是抽象数据类型的实现
    B、类是具有共同行为的若干对象的统一描述体
    C、类是创建对象的样板
    D、类就是C语言中的结构体类型

2、下列关于C++语言类的描述中错误的是:
    A、类用于描述事物的属性和对事物的操作
    B、类与类之间通过封装而具有明确的独立性
    C、类与类之间必须是平等的关系,而不能组成层次结构
    D、类与类之间可以通过一些方法进行通信和联络

3、在面向对象设计中,对象有很多基本特点,其中“一个系统中通常包含很多类,这些类之间呈树形结构”这一性质指的是对象的:
    A、分类性
    B、标识唯一性
    C、继承性
    D、封装性

4、什么是成员:
    A、类的特征
    B、类的方法
    C、类的事件
    D、以上全是

5、作用域运算符的功能是:
    A、标识作用域的级别
    B、指出的大小
    C、标识某个成员是属于哪一类的
    D、给出的范围

第19讲 对象的定义和使用

第19讲 掌握 对象的定义和使用

1、假定AA为一个类,a()为该类公有的函数成员,x为该类的一个对象,则访问x对象中函数成员a()的格式为:
    A、x.a
    B、x.a()
    C、x->a
    D、x->a()

2、为了使类中的某个成员不能被类的对象通过成员操作符访问,则不能把该成员的访问权限定义为:
    A、public
    B、protected
    C、private
    D、static

3、在用关键字class定义的类中,以下叙述正确的是:
    A、在类中,不作特别说明的数据成员均为私有类型
    B、在类中,不作特别说明的数据成员均为公有类型
    C、类成员的定义必须是成员变量定义在前,成员函数定义在后
    D、类的成员定义必须放在类定义体内部

4、下列关于成员函数特征的描述中,错误的是:
    A、成员函数一定是内联函数
    B、成员函数可以重载
    C、成员函数可以设置参数的默认值
    D、成员函数可以是静态的

5、下列有关类的说法不正确的是:
    A、对象是类的一个实例
    B、任何一个对象只能属于一个具体的类
    C、一个类只能有一个对象
    D、类与对象的关系和数据类型与变量的关系相似

第20讲 构造函数

第20讲 掌握构造函数的功能和使用方法

1、类的构造函数被自动调用执行的情况是在定义该类的:
    A、成员函数时
    B、数据成员时
    C、对象时
    D、友元函数时

2、设类A将其它类对象作为成员,则建立A类对象时,下列描述正确的是:
    A、类构造函数先执行
    B、成员构造函数先执行
    C、两者并行执行
    D、不能确定

3、假定一个类的构造函数为“A(int aa=1, int bb=0) {a=aa; b=bb;}”, 则执行“A x (4);”语句后,x.a和x.b的值分别为:
    A、1和0
    B、1和4
    C、4和0
    D、4和1

4、下列是构造函数的特点,是错误的是:
    A、构造函数是一种成员函数,它具有一般成员函数的特点
    B、构造函数的名称与其类名相同
    C、构造函数必须指明其类型
    D、一个类中可定义一个或多个构造函数

5、构造函数不具备的特征的是:
    A、构造函数的函数名与类名相同
    B、构造函数可以重载
    C、构造函数可以设置默认参数
    D、构造函数必须指定类型说明

第21讲 默认构造函数和复制构造函数

第21讲 掌握默认构造函数和复制构造函数的使用法则

1、假定AB为一个类,则执行AB x(y);语句时将自动调用该类的:
    A、有参构造函数
    B、无参构造函数
    C、复制构造函数
    D、赋值构造函数

2、通常,复制构造函数的参数是:
    A、某个对象名
    B、某个对象的成员名
    C、某个对象的引用名
    D、某个对象的指针名

3、类的默认的复制构造函数:
    A、在任何情况下都存在
    B、仅当未定义复制构造函数时存在
    C、仅当未定义有参构造函数时存在
    D、仅当未定义任何构造函数时存在

4、下列情况中,不会调用复制构造函数的是:
    A、用一个对象去初始化同一类的另一个新对象时
    B、将类的一个对象赋值给该类的另一个对象时
    C、函数的形参是类的对象,调用函数进行形参和实参相结合
    D、函数的返回值是类的对象,函数执行返回调用时

5、假设OneClass为一个类,则该类的复制初始化构造函数的声明语句为:
    A、OneClass(OneClass p);
    B、OneClass& (OneClass p);
    C、OneClass(OneClass & p);
    D、OneClass (OneClass *p);

第22讲 析构函数

第22讲 掌握析构函数的用途和使用方法

1、下面有关类说法不正确的是:
    A、一个类可以有多个构造函数
    B、一个类只有一个析构函数
    C、析构函数需要指定参数
    D、在一个类中可以说明具有类类型的数据成员

2、对类的构造函数和析构函数描述正确的是:
    A、构造函数可以重载,析构函数不能重载
    B、构造函数不能重载,析构函数可以重载
    C、构造函数可以重载,析构函数也可以重载
    D、构造函数不能重载,析构函数也不能重载

3、类的析构函数的作用是:
    A、一般成员函数
    B、类的初始化
    C、对象初始化
    D、撤销对象时要执行的操作

4、下面哪项是对构造函数和析构函数的正确定义?
    A、X::X(参数), X::~X()
    B、X::X(参数), X::~X(参数)
    C、void X::X(参数), void X::~X(参数)
    D、void X::X(), void X::~X()

5、以下有关析构函数的叙述不正确的是:
    A、析构函数没有任何函数类型
    B、析构函数的作用是在对象被撤销时收回先前分配的内存空间
    C、析构函数可以有形参
    D、一个类只有一个析构函数

第23讲 对象数组和对象指针

第23讲 对象数组和对象指针

1、有以下的类定义:class MyClass { public: MyClass(){cout<<'1';} }; 则执行语句MyClass a,b[2],*p[2];后,程序的输出结果是( )。
    A、11
    B、111
    C、1111
    D、11111

2、已知p是一个指向类sample数据成员m的指针,s是类sample的一个对象。如果要给m赋值为5,哪个是正确的?
    A、s.p=5
    B、s->p=5
    C、s.*p=5
    D、*s.p=5

3、假定AA是一个类,“AA* abc()const;”是该类中一个成员函数的原型,若该函数返回this值,当用x.abc()调用该成员函数后,x的值:
    A、已经被改变
    B、可能被改变
    C、不变
    D、受到函数调用的影响

4、下列关于this指针的叙述中,正确的是:
    A、this指针是一个隐含指针,它隐含于类的成员函数中
    B、只有在使用this时,系统才会将对象的地址赋值给this
    C、类的友元函数也有this指针
    D、this指针表示了成员函数当前操作的数据所属的对象

5、this指针存在的目的是:
    A、保证基类公有成员在子类中可以被访问
    B、保证每个对象拥有自己的数据成员,但共享处理这些数据成员的代码
    C、保证基类保护成员在子类中可以被访问
    D、保证基类私有成员在子类中可以被访问

第25讲 静态成员和友元

第25讲 掌握静态成员和友元的使用

1、静态数据成员的初始化必须在:
    A、类内
    B、类外
    C、构造函数内
    D、静态成员函数内

2、静态成员函数没有:
    A、返回值
    B、this指针
    C、指针参数
    D、返回类型

3、下列不是描述类的成员函数的是:
    A、构造函数
    B、析构函数
    C、友元函数
    D、复制构造函数

4、下面关于友元的描述中,错误的是:
    A、友元函数可以访问该类的私有数据成员
    B、一个类的友元类中的成员函数都是这个类的友元函数
    C、友元可以提高程序的运行效率
    D、类与类之间的友元关系可以继承

5、已知类A是类B的友元,类B是类C的友元,则:
    A、类A一定是类C的友元
    B、类C一定是类A的友元
    C、类C的成员函数可以访问类B的对象的任何成员
    D、类A的成员函数可以访问类B的对象的任何成员

第26讲 类模板

第26讲 掌握类模板的定义和使用

1、下列关于模板的叙述中,错误的是:
    A、模板声明中的第一个符号总是关键字template
    B、在模板生命中用<>括起来的部分是模板的形参表
    C、类模板不能有数据成员
    D、在一定条件下函数模板的实参可以省略

2、下列程序段中有错的是:
    A、template <class Type>
    B、Type
    C、func(Type a,b)
    D、{return (a>b)?(a):(b);}

3、如果一个模板声明列出了多个参数,则每个参数之间必须使用逗号隔开,每个参数都必须使用( )关键字来修饰
    A、const
    B、static
    C、void
    D、class

4、类模板的模板参数:
    A、只可作为数据成员的类型
    B、只可作为成员的返回类型
    C、只可作为成员函数的参数类型
    D、以上三者均可

5、模板对类型的参数化提供了很好的支持,因此:
    A、类模板的主要作用是生成抽象类
    B、类模板实例化时,编译器将根据给出的模板实参生成一个类
    C、在类模板中的数据成员都具有同样类型
    D、类模板中的成员函数都没有返回值

第27讲 运算符重载

第27讲 掌握运算符重载的方法

1、下列有关运算符重载的描述中,哪个是正确的?
    A、运算符重载可改变其优先级
    B、运算符重载不改变其语法结构
    C、运算符重载可改变其结合性
    D、运算符重载可改变其操作数的个数

2、在重载一个运算符时,其参数表中没有任何参数,这表明该运算符是:
    A、作为友元函数重载的1元运算符
    B、作为成员函数重载的1元运算符
    C、作为友元函数重载的2元运算符
    D、作为成员函数重载的2元运算符

3、在下面的运算符重载函数的原型中,错误的是:
    A、volume operator-(double,double);
    B、double volume::operator-(double);
    C、volume volume ::operator-(volume);
    D、volume operator-(volume,volume);

4、下列运算符中,哪个运算符在C++中不能重载?
    A、?:
    B、[]
    C、new
    D、&&

5、如果表达式++a中的“++”是作为成员函数重载的运算符,若采用运算符函数调用格式,则可表示为:
    A、a.operator++
    B、operator++(a)
    C、operator++(a,1)
    D、a.operator++()

第29讲 类的继承与派生

第29讲 掌握派生类的定义

1、定义新类是通过什么实现的
    A、信息隐藏
    B、数据封装
    C、继承机制
    D、数据抽象

2、继承具有( ),即当基类本身也是某一个类派生类时,底层的派生类也会自动继承间接基类的成员
    A、规律性
    B、传递性
    C、重复性
    D、多样性

3、C++类体系中,不能被派生类继承的有:
    A、构造函数
    B、虚函数
    C、静态成员函数
    D、赋值操作函数

4、C++的继承性允许派生类继承基类的:
    A、部分特性,并允许增加新的特性或重定义基类的特性
    B、部分特性,但不允许增加新的特性或重定义基类的特性
    C、所有特性,并允许增加新的特性或重定义基类的特性
    D、所有特性,但不允许增加新的特性或重定义基类的特性

5、对基类和派生类的关系描述中,错误的是:
    A、派生类是基类的具体化
    B、基类继承了派生类的属性
    C、派生类是基类定义的延续
    D、派生类是基类的特殊化

第30讲 派生类成员的访问

第30讲 掌握派生类成员的访问方法

1、若要用派生类的对象访问基类的保护成员,以下观点正确的是:
    A、可采用公有继承
    B、可采用私有继承
    C、可采用保护继承
    D、不可能实现

2、派生类的对象对它的基类成员中( )是可以访问的?
    A、公有继承的公有成员
    B、公有继承的私有成员
    C、公有继承的保护成员
    D、私有继承的公有成员

3、下列说法中错误的是:
    A、公有继承时基类中的public成员在派生类中仍是public成员
    B、私有继承时基类中的protected成员在派生类中仍是protected成员
    C、私有继承时基类的public成员在派生类中是private成员
    D、保护继承时基类的public成员在派生类中是protected成员

4、下面叙述不正确的是:
    A、派生类一般都用公有派生
    B、基类成员的访问必须是无二义性的
    C、赋值兼容规则也适用于多重继承的组合
    D、基类的公有成员在派生类中仍然是公有的

5、若派生类的成员函数不能直接访问基类中继承来的某个成员,则该成员一定是基类中的:
    A、私有成员
    B、公有成员
    C、保护成员
    D、保护成员或私有成员

第31讲 派生类的构造和析构函数

第31讲 掌握派生类的构造和析构函数

1、有如下程序: #include <iostream> using namespace std; class Base{ protected: Base(){cout<<'A';} Base(char c){cout<<c;} }; class Derived:public Base{ public: Derived(char c){cout<<c;} }; int main(){ Derived d1('B'); return 0; } 执行这个程序屏幕上将显示输出:
    A、B
    B、BA
    C、AB
    D、BB

2、派生类的构造函数的成员初始化列表中,不能包含:
    A、基类的构造函数
    B、派生类中子对象的初始化
    C、基类中子对象的初始化
    D、派生类中一般数据成员的初始化

3、假设ClassY:publicX,即类Y是类X的派生类,则说明一个Y类的对象时和删除Y类对象时,调用构造函数和析构函数的次序分别为:
    A、X,Y,Y,X
    B、X,Y,X,Y
    C、Y,X,X,Y
    D、Y,X,Y,X

4、以下有关继承的叙述正确的是:
    A、构造函数和析构函数都能被继承
    B、派生类是基类的组合
    C、派生类对象除了能访问自己的成员以外,不能访问基类中的所有成员
    D、基类的公有成员一定能被派生类的对象访问

5、建立包含有类对象成员的派生类对象时,自动调用构造函数的执行顺序依次为:
    A、自己所属类、对象成员所属类、基类的构造函数
    B、对象成员所属类、基类、自己所属类的构造函数
    C、类、对象成员所属类、自己所属类的构造函数
    D、基类、自己所属类、对象成员所属类的构造函数

第32讲 多态性

第32讲 掌握多态性的概念和实现原理

1、下列关于动态联编的描述中,错误的是:
    A、动态联编是以虚函数为基础
    B、动态联编是运行时确定所调用的函数代码的
    C、动态联编调用函数操作是指向对象的指针或对象引用
    D、动态联编是在编译时确定操作函数的

2、要实现动态联编,必须通过( )调用虚函数?
    A、对象指针
    B、成员名限定
    C、对象名
    D、派生类名

3、对虚函数的调用:
    A、一定使用动态联编
    B、必须使用动态联编
    C、一定使用静态联编
    D、不一定使用动态联编

4、以下叙述正确的是:
    A、构造函数调用虚函数采用动态联编
    B、构造函数可以说明为虚函数
    C、当基类的析构函数是虚函数时,它的派生类的析构函数也是虚函数
    D、析构函数必须是虚函数

5、对虚函数使用对象指针或引用,系统使用(),对虚函数使用对象调用时,系统使用()联编。
    A、静态联编、静态联编
    B、动态联编、动态联编
    C、静态联编、动态联编
    D、动态联编、静态联编

第33讲 虚函数

第33讲 掌握虚函数、纯虚函数、抽象类的定义和使用

1、以下成员函数哪个表示纯虚函数?
    A、virtual int vf(int)
    B、void vf(int)=0
    C、virtual void vf()=0
    D、virtual void vf(int){}

2、关于虚函数的描述中,哪个是正确的?
    A、虚函数是一个静态成员函数
    B、虚函数是一个非成员函数
    C、虚函数既可以在函数说明时定义,也可以在函数实现时定义
    D、派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型

3、关于纯虚函数和抽象类的描述中,错误的是:
    A、纯虚函数是一种特殊的虚函数,它没有具体的实现
    B、抽象类是指具有纯虚函数的类
    C、一个基类中说明有纯虚函数,该基类派生类一定不再是抽象类
    D、抽象类只能作为基类来使用,其纯虚函数的实现由派生类给出

4、关于抽象类,下列表述中正确的是:
    A、抽象类的成员函数中至少有一个是没有实现的函数(即无函数体定义的函数)
    B、派生类必须实现作为基类的抽象类中的纯虚函数
    C、派生类不可能成为抽象型
    D、抽象类可以用来定义对象

5、下列关于纯虚函数的描述中,正确的是:
    A、纯虚函数是一种特殊的虚函数,它是个空函数
    B、具有纯虚函数的类称为虚基类
    C、一个基类中说明有纯虚函数,其派生类一定要实现该纯虚函数
    D、具有纯虚函数的类不能创建类对象