C++错题集

• 以下程序的运行结果是（B）
  A computer , puter
  B computer , com
  C computer , computer
  D computer , compu.ter

int main(void)
{
	printf("%s , %5.3s\n","computer","computer");
	return 0;
}

• int *p[4] 与选择项中的 说明 （C） 等价
  A int p[4]
  B int *p
  C int *(p[4])
  D int (*p)[4]

• 若有定义语句： int a=10 ; double b=3.14 ; 则表达式 ‘A’+a+b 值的类型是（C）
  A char
  B int
  C double
  D float

• 数组a的定义语句为“float a[3][4];”,下列（D）是对数组元素不正确的引用方法。
  A a[i][j]
  B *(a[i]+j)
  C *( *(a+i)+j)
  D *(a+i * 4+j)

• 下面叙述错误的是（D）
  A acX与acY的内容可以修改
  B szX与szY指向同一个地址
  C acX占用的内存空间比acY占用的大
  D szX的内容修改后，szY的内容也会被更改

char acX[]=”abc”;
char acY[]={‘a’,’b’,’c’};
char *szX=”abc”;
char *szY=”abc”;

• 下列代码的运行结果是（）
  A 1,3
  B 1,2
  C 2,4
  D 3,2

int a[]={1,2,3,4};
int *b=a;
*b+=2;
*(b+2)=2;
b++;
printf(“%d,%d\n”,*b,*(b+2));

• 在32位cpu上选择缺省对齐的情况下，有如下结构体定义：则sizeof（struct A）的值为（C）
  A 9
  B 12
  C 16
  D 20

struct A{
		unsigned a : 19;
		unsigned b : 11;
		unsigned c : 4;
		unsigned d : 29;
		char index;
};

• 关于虚函数的描述正确的是(B)
  A 派生类的虚函数与基类的虚函数具有不同的参数个数和类型
  B 内联函数不能是虚函数
  C 派生类必须重新定义基类的虚函数
  D 虚函数可以是一个static型的函数

• 以下程序的输出结果是?(B)
  A 6
  B 6789
  C ‘6’
  D 789

#include <stdio.h> 
main()
{
	char a[10]={ '1','2','3','4','5','6','7','8','9',0},*p; int i;
	i=8;
	p=a+i;
	printf("%s\n",p-3);
}

• 以下能对二维数组a进行正确初始化的语句是（B）
  A int ta[2][]={{0,1,2},{3,4,5}};
  B int ta[][3]={{0,1,2},{3,4,5}};
  C int ta[2][4]={{0,1,2},{3,4},{5}};
  D int ta[][3]={{0,2},{},{3,4,5}};

• 由多个源文件组成的C程序，经过编辑、预处理、编译、链接等阶段会生成最终的可执行程序。下面哪个阶段可以发现被调用的函数未定义？(C)
  A 预处理
  B 编译
  C 链接
  D 执行

• 以下哪种STL容器中的对象是连续存储的:(B)
  A list
  B vector
  C map
  D set

• 当一个类对象的生命周期结束后，关于调用析构函数的描述正确的是:（C）
  A 如果派生类没有定义析构函数，则只调用基类的析构函数
  B 如果基类没有定义析构函数，则只调用派生类的析构函数
  C 先调用派生类的析构函数，后调用基类的析构函数
  D 先调用基类的析构函数，后调用派生类的析构函数

• 以下C语言指令：运行结果是什么？(C)
  A 2,1
  B 3,1
  C 3,9
  D 运行时崩溃

int a[5] = {1,3,5,7,9};
int *p = (int *)(&a+1);
printf(“%d,%d”,*(a+1)，*(p-1));

• print()函数是一个类的常成员函数，它无返回值，下列表示中正确的是(C)
  A const void print();
  B void const print();
  C void print() const;
  D void print(const);

• 以下关于纯虚函数的说法,正确的是(A)
  A 声明纯虚函数的类不能实例化
  B 声明纯虚函数的类成虚基类
  C 子类必须实现基类的
  D 纯虚函数必须是空函数

• 下列情况中，不会调用拷贝构造函数的是（B）
  A 用一个对象去初始化同一个类的另一个新对象时
  B 将类的一个对象赋值给该类的另一个对象时
  C 函数的形参对象，调用函数进行形参和实参结合时
  D 函数的返回值是类的对象，函数执行返回调用时

• 下面两个结构体在#pragma pack(4)和#pragma pack(8)的情况下，结构体的大小分别是(C)
  A 16 24,16 24
  B 16 20,16 20
  C 16 16,16 24
  D 16 16,24 24

struct One{
	double d;
	char c;
	int i;
}
struct Two{
	char c;
	double d;
	int i;
}

• 下面程序的输出结果是(B)
  A 10,30,50
  B 10,20,30
  C 20,40,60
  D 10,30,60

#include<iosteam.h>
void main(){
	int n[][3] = {10,20,30,40,50,60};
	int (*p)[3];
	p=n;
	cout<<p[0][0]<<","<<*(p[0]+1)<<","<<(*p)[2]<<endl;
}

• 若运行时从键盘上输入9876543210l,则上面程序在gcc编译器下的输出结果是(B)
  A a=98,b=765,c=4321.000000
  B a=98,b=0,c=0.000000
  C a=98,b=765.000000,c=4321.000000
  D a=98,b=765.0,c=4321.0

int main(){
	int a;float b,c;
	scanf("%2d%3f%4f",&a,&b,&c);
	printf("\na=%d,b=%d,c=%f\n",a,b,c);
}

• 下面说法正确的是(C)
  A 一个空类默认一定生成构造函数,拷贝构造函数,赋值操作符,引用操作符,析构函数
  B 可以有多个析构函数
  C 析构函数可以为virtual,可以被重载
  D 类的构造函数如果都不是public访问属性,则类的实例无法创建
• c++语言中，类ClassA的构造函数和析构函数的执行次数分别为(A)
  A 5,1
  B 1,1
  C 5,5
  D 1,5

ClassA *pclassa=new ClassA[5];
delete pclassa;

• 关于重载和多态正确的是
  A 如果父类和子类都有相同的方法,参数个数不同,将子类对象赋给父类后,由于子类继承于父类,所以使用父类指针 调用父类方法时,实际调用的是子类的方法
  B 选项全部都不正确
  C 重载和多态在C++面向对象编程中经常用到的方法,都只在实现子类的方法时才会使用
  D 结果是1

class A{
	void test(float a){cout<<"1";}
};
class B:public A{
void test(int b){cout<<"2";}
};
A *a=new A;
B *b=new B;
a=b;
a.test(1.1);

• 请选择下列程序的运行结果（A）
  A B0::display0 B0::display0 B0::display0
  B B0::display0 B0::display0 D1::display0
  C B0::display0 B1::display0 D1::display0
  D B0::display0 B1::display0 B1::display0

#include<iostream>
using namespace std;
class B0//基类BO声明
{
public://外部接口
	virtual void display(){cout<<"B0::display0"<<endl;}//虚成员函数
};
class B1:public B0//公有派生
{
public:
	void display() { cout<<"B1::display0"<<endl; }
};
class D1: public B1//公有派生
{
public:
	void display(){ cout<<"D1::display0"<<endl; }
};
void fun(B0 ptr)//普通函数
{
	ptr.display();
}
int main()//主函数
{
	B0 b0;//声明基类对象和指针
	B1 b1;//声明派生类对象
	D1 d1;//声明派生类对象
	fun(b0);//调用基类B0函数成员
	fun(b1);//调用派生类B1函数成员
	fun(d1);//调用派生类D1函数成员
}

• 有以下程序(C)
  程序运行后的输出结果是()
  A 0123 0173
  B 0123 173
  C 123 173
  D 173 173

#include<iostream>
#include<stdio.h>
using namespace std;
int main(){
	int m=0123, n = 123;
	printf("%o %o\n", m, n);
	return 0;
}

• 关于"深拷贝"，下列说法正确的是(A)
  A 会拷贝成员数据的值和会拷贝静态分配的成员对象
  B 只会拷贝成员数据的值
  C 只会拷贝静态分配的成员对象
  D 只会拷贝动态分配的成员对象

• 设变量已正确定义，以下不能统计出一行中输入字符个数（不包含回车符）的程序段是(D)
  A n=0;while(ch=getchar()!=’\n’)n++;
  B n=0;while(getchar()!=’\n’)n++;
  C for(n=0;getchar()!=’\n’;n++);
  D n=0;for(ch=getchar();ch!=’\n’;n++);

• 下面程序输出是什么？(D)
  A 1，2，3
  B 1，3，2
  C 3，2，1
  D 1，3，3

#include <stdio.h>
int main()
{
int a=1,b=2,c=3,d=0;
if(a == 1 && b++==2)
	if(b!=2||c--!=3)
		printf("%d,%d,%d\n" ,a,b,c);
	else
		printf("%d,%d,%d\n" ,a,b,c);
else
	printf("%d,%d,%d\n" ,a,b,c);
return 0;
}

• 假定一个类的构造函数为A(int aa,int bb){a=aa–;b=a*bb;}，则执行A x(4,5);语句后，x.a和x.b的值分别为（D）
  A 20和5
  B 3和15
  C 5和4
  D 4和20