c:
d 的值为D
A. 4
B. 2
C. 3
D. 1
4为表示关系x大于等于y,y大于等于z，正确的C++语言表达式A
A. x>=y&&y>=z
B. （x>=y）AND（y>=z） C. x>=y>=z
D. （x>=y）&（y>=z）
5下列ASCII码值最小的字符是A
A. ‘\n’
B. ‘b’
C. ‘A’
D. ‘6’
6若执行语句：
intb,a=12,n=5;表达式a%=（b=2,n%=b）+4结果是A
A. 2
B. 4
C. 1
D. 16
7设m,n,a,b,c,d均为0，执行（m=a==b）||（n=c==d）后，m、n的值是 B
A. 0，0
B. 1，0
C. 0，1
D. 1，1
8设有语句inta=3;则执行了语句a+=a-=a*a;后，变量a 的值是 C
A. 0
B. 9
C. -12
D. 3
9下列变量定义及初始化中，错误D
A. inta=0xFF
B. longa=2L
C. chara=’\72’
D. doublea=1.2e0.5
10逗号表达式（a=4*5，a*2），a+15的值C
A. 20
B. 40
C. 35
D. 55
11哪一个不是面向对象方法特征B
A. 封装性
B. 开放性
C. 继承性
D. 多态性
12设 charch; 错误的赋值语句C
A. ch=68;
B. ch='\xef';
C. ch="\\";
D. ch='\123';
13设intx=-1；执行表达式++x||++x||++x后，x的值是D
A. 2
B. 0
C. 3
D. 1
14C++源程序文件扩展名的 B
A. obj
B. cpp
C. exe
D. c
15假设下面所有的变量均已定义为double型，下列赋值表达式不正确的是 C
A. z*=2.8/4
B. x=y=z
C. x=3.5%2
D. x=--x
A是复合赋值运算符，先计算右边的除法，当两个数据的类型不同的时候，先将4转化为4.0再进行运算得结果0.7，再执行z=z*0.7的赋值运算，正确；B先对右边的部分进行运算，变量x先执行自减，将表达式的结果赋值给x，实际上直接写成--x能达到同样的效果，这种用法不常见，但是语法上是正确的；C是连续赋值，按从右到左的顺序执行，最终效果是x、y和z三个变量的值相等，也是正确的；D的错误在赋值号右边，运算符“%”要求两个运算对象都必须为整数，3.5不是整数。
16在 C++语言中int,long,unsigned 和 char这四种类型数据的转换规律是C
a. char->int->long->unsigned
b. char->unsigned->long->int
c. char->int->unsigned->long
d. int->unsigned->long->char
17以下选项中可作为C++语言合法整数A
A. 0Xafb
B. 11010B
C. x2b2
D. 0583
18在C++语言中，设shortint型占两个字节，下列不正确的shortint型常数A
A. 32768
B. 0xfa
C. 032770
D. -32768
19关系运算符对两侧的运算对象的要求B
A. 只能是0或1
B. 可以是任意合法的表达式，两者类型不一定相同
C. 两个运算对象必须属于同一种数据类型
D. 只能是0或非0值
20下列哪一个是合法的实型字面常量 C
A. 8E3.1
B. E5
C. 234
D. 234.
复杂数据及运算
1下列程序段运行后，i的正确结果为C
inti=0;char*s=“a\041#041\\b”;while（*s++）i++;
A. 12
B. 5
C. 8
D. 11
2以下一维数组 a 的正确定义是 D
A. intn;cin>>n;inta[n];
B. intn=10,a[n];
C. inta（10）;
D. #defineSIZE10inta[SIZE];
3下面判断字符串str1是否大于str2，正确的表达式是 C
A. if（str1>str2）
B. if（strcmp（str1,str2）） C. if（strcmp（str1,str2）>0）
D. if（strcmp（str2,str1）>0）
4设变量定义为“intx,*p=&x;”，则&*p相当于__。
D
A. x
B. *p
C. *&x
D. &x
5设int*ptr,x,array[5]={5，2，4，3，1}; ptr=array; 能使x的值为2的语句A
A. x=*（array+1）;
B. array++；x=*array;
C. x=*（ptr+2）;
D. x=array[2]；
6下列正确的一维数组初始化是 C
A. inta[2]={1,2,3,4,5};
B. inta[5]={,,1,2};
C. inta[5]={1,2};
D. int*a={1,2,3,4,5};
7以下程序给数组所有元素输入数据，填入__能完成该功能。
C
#include
usingnamespacestd;
intmain（ ）
{
intarray[5],i=0;
while（i<5）
cin>>__;
return0;
}
A. &array[i+1]
B. &array[++i]
C. array+（i++）
D. array+i
8strlen（”a\012b\xab\\bcd\n”）的值A
A. 9
B. 10
C. 11
D. 13
9设charstr[100]；inti=5；则下列哪一个能正确表示数组的某一个元素 C
A. *（（str++）+i）
B. （str+i）
C. *（str+i-1）
D. str[i+95]
10设 int*p,i; 以下正确的语句B
A. i=p;
B. p=&i;
C. i=*p;
D. *p=10;
11设intx[]={1,2,3,4,5,6},*p=x; 则值为3的表达式是 B
A. p+=2;*++p;
B. p+=2;*p++
C. p+=2;++*p;
D. p+=3;*p;
12若有语句 int*point,i=4;和 point=&i; 下面均代表地址的一组选项是 B
A. &*i,&i,*point
B. &a,&*point,point
C. *&point,*point,&i
D. i，point,*&i
13若有说明：
inta[]={15,12,-9,28,5,3},*p=a,则下列哪一种表达错误A
A. *（a=a+3）
B. *（p=p+3）
C. *（a+*（a+5））
D. p[p[4]]
14若定义intm[10]={9,4,12,8,2,10,7,5,1,3};则m[m[4]+m[8]]的值是D
A. 7
B. 12
C. 10
D. 8
15以下二维数组a的正确说明是 A
A. doublea[2][4]
B. floata（3）（4）
C. inta[3][]
D. floata（3,4）
16假设已定义chara[10]; char*p;下面的赋值语句中，正确的是 A
A. p=a;
B. *p=”abcdef”;
C. a=”abcdef”;
D. p=*a;
17下列对指针p的操作，正确的B
A. inta[5]={1,2,3,4,5},*p=&a;*p=5;
B. inta,*p=&a; C. int*p;*p=2;
D. floata[5];int*p=a; 18若有以下定义和语句，错误C
inta=4,b=3,*p,*q,*w;
p=&a;q=&b;w=q;q=NULL;
A. *p=b;
B. *p=*w;
C. *q=0;
D. w=p;
19设int *p,x,a[5]={1，2，3，4，5}; p=a;能使x的值为2的语句是 B
A. x=a[2]；
B. x=*（a+1）;
C. x=*（p+2）;
D. a++；x=*a;
20若有说明：
int*p1,*p2,m=5,n; 以下均是正确赋值语句的选项是 A
A. p1=&m;p2=p1;
B. p1=&m;p2=&p1;
C. p1=&m;*p1=*p2;
D. p1=&m;*p2=*p1;
21设 int s[10];*p=s; 错误A
A. s=p+s;
B. p=s+5;
C. s[2]=p[4];
D. *p=s[0];
22执行下面的程序段后，ab的值B
int*var,ab;
ab=100; var=&ab; *var+=10;ab+=10;
A. 0
B. 120
C. 110
D. 100
23以下对二维数组a进行正确初始化 A
A. intarray[][3]={1*6}; B. intarray[2][3]={{1,2},{3,4},{5,6}};
C. intarray[2][3]={{},{1}};
D. intarray[2][]={1,2,3,4,5,6}; 24不能正确进行字符串初始化的语句A
A. charstr[5]="good!
"; B. charstr[6]={'g','o','o','d',’!
’,’\0’}; C. charstr[]={"good!
"}; D. char*str="good!
"; 25已有定义intk=2;int*ptr1=&k,*ptr2=&k;，下面不能正确执行的赋值语句是 B
A. k=*ptr1+*ptr2;
B. ptr2=k;
C. k=*ptr1*（*ptr2）; D. ptr1=ptr2;
抽象与分类
1C++语言中class和struct的区别仅在于缺省 不同。
C
A. 数据成员
B. 私有部分
C. 访问权限
D. 函数成员
2对于C++语言的函数，错误C
A. 函数的定义可以嵌套，但函数调用不能嵌套
B. 函数的定义和调用都可以嵌套
C. 函数的定义不能嵌套，但函数调用可以嵌套
D. 函数的定义和调用都不能嵌套
3下面正确的引用定义是 。
C
A. int&a[4];
B. int&*p;
C. inti,&p=i;
D. int&&q
4设A为test类的对象且赋有初值，则语句test B＝A；表示 D
A. 为对象A定义一个别名 B. 语法错
C. 仅说明B和A属于同一个类 D. 调用拷贝构造函数，将对象A复制给对象B
5下列有关类和对象的说法错误D
A. 对象是类的一个实例 B. 类与对象的关系类似于数据类型与变量的关系
C. 任何一个对象只能属于一个具体的类
D. 一个类只能有一个对象 6下列特点 不是类与结构共有的。
B
A. 是封装的一种形式
B. 在缺省情况下，所有成员都是私有的
C. 不能在说明中对数据成员使用表达式初始化
D. ．关键字private和public的顺序和次数可以是任意的 7以下关于构造函数的叙述错误 B
A. 构造函数在定义对象时自动执行
B. 在一个类中构造函数有且仅有一个
C. 构造函数无任何函数类型 D. 构造函数名必须和类名一致 8下面函数 的表示方法说明它使用对象的引用作为参数。
A
A. test（pt&p）;
B. test（constp）;
C. test（ptp）;
D. ．test（pt*p）;
9类的拷贝构造函数的参数是B
a. 某个对象名
b. 某个对象的引用名
c. ．某个对象的指针名 d. 某个对象的成员名
10在调用函数时，如果实参是简单变量，它与对应形参之间的数据传递方式是C
A. 地址传递
B. 传递方式由用户指定 C. 单向值传递
D. 由实参传给形参，再由形参传回实参
11对于任意一个类，析构函数的个数为 C
A0
B3
C1
D2
12已知类A是类B的友元，类B是类C的友元，则 。
B
A. 类C一定是类A的友元 B. 类A的成员函数可以访问类B的任何成员
C. A一定是类C的友元
D. 类C一定是类A的友元 13已知函数原型声明为：
float*pp（chara，doubleb）;该函数的返回值类型为D
A. 整型
B. 指向整型的指针
C. 字符型
D. 指向浮点型的指针
14以下不属于类的访问权限的是 B
A. protected
B. static
C. public
D. private
15若有声明“longfun（int*x,intn,long*s）;inta[4]={1,2,3,4};longb,c;”，则以下函数调用形式中正确的是D
A. c=fun（a,4,b）;
B. c=fun（a[],4,&b）;
C. c=fun（a[4],4,b）;
D. c=fun（a,4,&b）;
16有以下函数定义：
voidfun（intn，doublex）{……}，若以下选项中的变量都已正确定义并赋值，则对函数fun的正确调用语句是C
A. fun（intx,doubley）
B. k=fun（10,12.5）
C. fun（x,n）
D. voidfun（n,x）
17对应main函数中的fun函数调用语句，则下列fun函数定义首部中，错误的C
main（）
{inta[50],n;
fun（n,&a[9]）;
}
A. voidfun（ints,inth[41]）
B. voidfun（intm,intx[]）
C. voidfun（intn,inta）
D. voidfun（intp,int*s）18下列关于引用的说法错误的是 D
A. 引用是变量的别名，所以不另外为引用分配内存空间
B. 引用作为形式参数要求对应的实际参数只能是变量
C. 引用作为返回值的函数可以作为左值调用
D. 在同一个函数中，不作为形式参数的引用也可
以作为不同变量的别名
19表达式中类的使用方法错误B
class Location
{
private:
int X,Y;
public:
void init（int initX，int initY）
{
X=initX; Y=initY;
}
int Get_X（）
{ return X;
}
int Get_Y（）
{ return Y;
}
} A1;
A. A1.Get_X（）;
B. X=A1.X;
C. Location*pA1;pA1=&A1;
intX=pA1->Get_x（）; D. A1.init（5,3）;
20 D 是析构函数的特征。
A. 析构函数的定义只能在类体内 B. 析构函数名与类名完全相同
C. 析构函数可以有一个或多个参数D. 一个类中只能定义一个析构函数 21函数调用语句中含有A个实参。
func（（exp1,exp2）,（exp3,exp4,exp5））;
A. 2
B. 4
C. 5
D. 1
22下列各类函数中，不是类的成员函数A
A. 友元函数
B. 拷贝构造函数
C. 构造函数
D. 析构函数
23设有函数f的定义如下，若在main函数中调用f函数，则正确的调用语句A
voidf（intx,int*y）
{*y=x*x*x;}
intmain（ ）
{inti,c[4]={1,2,3,4},s[4]={0};
for（i=0;i<4;i++）
{ ______ /*调用f函数*/
cout<< s[i]<<" ";}
return0;
}
A. f（*（c+i）,&s[i]）;
B. f（c,s）;
C. f（c[i],s[i]）;
D. f（c+i,s+i）;
24下面是关于一个类的友元的说法，其中不正确的是 。
D
A. 友元函数可以是另一个类的成员函数
B. 友元函数可以访问该类的私有数据成员
C. 友元的声明必须放在类的内部
D. 若X类是Y类的友元，Y类就是X类的友元
25若有以下程序：
#include
voidf（intn）;
intmain（）
{
voidf（intn）;
f（5）;
return0;
}
voidf（intn）
{cout<则以下叙述中不正确的是A。
A. 对于以上程序，编译时系统会提示出错信息：
提示对f函数重复说明
B. 若在主函数前对函数f进行说明，则在主函数和其后的其它函数中都可以正确调用函数f
C. 若只在主函数中对函数f进行说明，则只能在主函数中正确调用函数f
D. 函数f无返回值，所以可用void将其类型定义为无类型 多文件工程及编译预处理
1以下不正确的叙述是。
D
A. #defineABCD是正确的宏定义
B. 预处理命令行都必须以"#"开始
C. 在程序中凡是以"#"开始的语句行都是预处理命令行 D. C++程序在执行过程中对预处理命令进行处理
2下列哪一个不是模块化程序设计应具有的特点B
A. 具有可修改性。
对系统的一次修改只涉
及少数几个模块
B. 鼓励多使用外部变量，以减少模块之间的相互参数传递 C. 开发一个模块不需要知道系统其他模块的内部结构和编程细节 D. 模块之间的接口尽可能简明 3如果一个函数定义后不希望别的文件使用,则在该函数首部前增加一个关键字B
a. extern
b. static
c. const
d. auto
4．在文件包含预处理语句（#include）的使用形式中，当之后的文件名用<>（尖括号）括起时，寻找被包含文件的方式是。
B
A. 先在源程序所在目录搜索，再按系统设定的标准方式搜索 B. 直接按系统设定的标准方式搜索目录
C. 仅仅搜索当前目录
D. 仅仅搜索源程序所在目录 5对于以下宏定义：
#define M（x） x*x#define N（x，y） M（x）+M（y）宏调用N（2，2+5）执行后，值为D。
A. 53
B. 51
C. 19
D. 21
6关于外部变量的下列说法错误的是A
a. 只要在主函数外面定义的变量就一定是外部变量
b. 外部变量只需要在一个文件中定义一次,但可以其他文件中多次声明
c. 函数外定义的变量,其前若用static修饰则不能作为外部变量
d. 外部变量在其他文件中被使用时需要用extern进行事先声明 7以下不正确的叙述是D。
A. 宏名无类型
B. 宏替换不占用运行时间 C. 宏替换只是字符替换 D. 宏名必须用大写字母表示 8以下for语句构成的循环执行了次B。
#include
usingnamespacestd;
#defineN2
#defineMN+1
#defineNUM（M+1）*M/2
intmain（）
{
inti,n=0;
for（i=1;i<=NUM;i++）
{n++;
cout<}
cout<return0;
}
A. 5
B. 8
C. 9
D. 6
9关
升级会员 