有以下程序
#define f (x) x*x
main( )
{ int i;
i=f(4+4)/f(2+2); //4*4+4+4/2*2+2+2
printf("%d\n",i);
} 执行后输出结果是___
A. 28;
B. 22;
C. 16;
D. 4
下面程序的功能是输出以下形式的金字塔图案是：
| *
| ***
| *****
|*******
main( )
{ int i, j;
for(i = 1; i <= 4; i++)
{ for(j = 1; j <= 4 - i ; j ++) printf(" ");
for(j = 1 ; j <=____; j ++) printf("*");
printf("\n");
}
}
在下划线处应填入的是___
A. i;
B. 2*i-1;
C. 2*i+1;
D. i+2
有以下程序
void sort(int a[ ],int n)
{ int i,j,t;
for(i=0;i<n-1;i+=2)
for(j=i+2;j<n;j+=2)
if(a[i]<a[j]) { t=a[i];a[i]=a[j];a[j]=t; }
}
main()
{ int aa[10]={1,2,3,4,5,6,7,8,9,10},i;
sort(aa,10);
for(i=0;i<10;i++) printf("%d,",aa[i]);
printf("\n");
} 其输出结果是___
A. 1,2,3,4,5,6,7,8,9,10,;
B. 10,9,8,7,6,5,4,3,2,1,;
C. 9,2,7,4,5,6,3,8,1,10,;
D. 1,10,3,8,5,6,7,4,9,2,
有以下程序
struct STU
{ char name[10];
int num;
int Score;
};
main( )
{
struct STU s[5] = { {"YangSan",20041,703},
{"LiSiGuo",20042,580},
{"wangYin",20043,680},
{"SunDan",20044,550},
{"Penghua",20045,537}};
struct STU *p[5], *t;
int i, j;
for(i = 0; i < 5; i ++) p[i] = &s[i];
for(i = 0; i < 4; i ++)
for(j = i + 1; j < 5 ; j ++)
if(p[i]->Score>p[j]->Score)
{ t=p[i];p[i]=p[j];p[j]=t;}
printf("%d %d\n",s[1].Score,p[1]->Score);
//s[1].Score[1]为LiSiGuo的分数580，比其小的是SunDan 550/
}
执行后输出结果是___
A. 550 550;
B. 680 680;
C. 580 550;
D. 580 680
若执行以下程序时从键盘上输入9，
Main()
{
int n;
scanf("%d",&n);
if(n++<10) printf("%d\n",n);//先比较9小于10，而后9自加1输出10
else printf("%d\n",n--);
}
则输出结果是：___
A. 11;
B. 10;
C. 9;
D. 8
以下程序段的输出结果是___
int x=3;
do
{
printf("%3d",x-=2);
}
while(!(--x));
A. 1;
B. 3 0;
C. 1 -2;
D. 死循环
根据下面的定义,能打印出字母m的语句是___
struct person{ char name[9]; int age; };
struct person class[10]=
{"john",17, //class[0]
"paul",19, //class[1]
"mary",18, //class[2].name[0]-->m
"adam",16 //class[3].name[3] -->m }
A. printf(＂%c\n＂,class[3].name)；;
B. printf(＂%c\n＂,class[3].name[1])；;
C. printf(＂%c\n＂,class[2].name[1])；;
D. printf(＂%c\n＂,clsaa[2].name[0])；
有以下程序
#include <stdlib.h>
struct NODE
{
int num;
struct NODE *next;
};
main( )
{ struct NODE *p,*q,*r;
int sum=0;
p=(struct NODE *)malloc(sizeof(struct NODE));
q=(struct NODE *)malloc(sizeof(struct NODE));
r=(struct NODE *)malloc(sizeof(struct NODE));
p->num=1;q->num=2;r->num=3;
p->next=q;q->next=r;r->next=NULL;
sum+=q->next->num;sum+=p->num;//头加尾
printf(“%d\n”,sum);
} 执行后的输出结果是___
A. 3;
B. 4;
C. 5;
D. 6
有以下程序
void fun(char *a, char *b)
{
a=b; (*a)++;
}
void main()
{
char c1='A',c2='a',*p1,*p2;
p1=&c1; p2=&c2;
fun( p1,p2);
printf("%c%c\n",c1,c2);
}
程序运行后的输出结果是_________。
A. Ab;
B. aa;
C. Aa;
D. Bb
有以下程序
void main( )
{
int k=4,n=0;
for(; n; n++)
{
if(n%3!=0)
continue;
k--;
}
printf("%d,%d\n",k,n);
}
程序运行后的输出结果是_______。
A. 4,0;
B. 2,2;
C. 3,3;
D. 4,4
假定A为一个类，
class A
{
public:
int number;
A():number(0){}
A(int a)
{
number = a;
}
~A(){}
}；
int func(A&);
则执行了
“ A a(4);
A b[4];
A *p[5];
func(a);”
语句后，调用该类构造函数的次数为（ ）
A. 5;
B. 6;
C. 11;
D. 14
分析下面的程序，正确的输出结果是（ ）。
#include ＜iostream.h＞
#include ＜string.h＞
class base{
public：
virtual char * fun(void)const＝0；
}；
char * base：：fun(void)const
{return ＂base＂；}
class derived1：virtual public base{
public：
char * fun(void)const{
return ＂derived1＂；
}
}；
class derived2：virtual public base{
public：
char * fun(void)const{
return ＂derived2＂；
}
}；
class subderived：public derived1,public derived2{
public：
char * fun(void)const{
char * pch；
pch＝new char[strlen(derived1：：fun())+strlen(derived2：：fun())+1]；
strcpy(pch,derived1：：fun())；
strcat(pch,derived2：：fun())；
return pch；
}
}；
void main(void){
base * pb；
pb＝new derived1；
cout＜＜pb-＞fun()＜＜endl；
pb＝new derived2；
cout＜＜pb-＞fun()＜＜endl；
pb＝new subderived；
cout＜＜pb-＞fun()＜＜endl；
}
A. Base base base;
B. derived1 derived2 derived1derived2;
C. derived1 derived1 derived1derived2;
D. derived2 derived2 derived1derived2
下面程序的输出结果应为（ ）。
#include <iostream.h＞
#include <iomanip.h＞
void print(float a[],int count,int width);
void main(void){
float f[2]={1.0f,10.0f};
cout<<"Default numeric format:"<<endl;
print(f,2,10);
cout<<"Setting ios::showpoint:"<<endl;
cout.setf(ios::showpoint);
print(f,2,10);
cout.unsetf(ios::showpoint);
cout<<"Setting ios::scientific:"<<endl;
cout.setf(ios::scientific);
print(f,2,10);
cout.unsetf(ios::scientific);
}
void print(float a[],int count,int width){
for(int i=0;i<count;i++){
cout.width(width);
cout<<a[i]<<endl;
}
}
输出结果的选项如下:
A. Default numeric format:
1
10
Setting ios::showpoint:
1.00000
10.0000
Setting ios::scientific:
1.000000e+000
1.000000e+001;
B. Default numeric format:
1
10
Setting ios::showpoint:
1.00000
10.0000
Setting ios::scientific:
1.000000e+000
1.000000e+001;
C. Default numeric format:
1
10
Setting ios::showpoint:
1.00000
10.0000
Setting ios::scientific:
1.000000e+000
1.000000e+001;
D. Default numeric format:
1
10
Setting ios::showpoint:
1.00000
10.0000
Setting ios::scientific:
1.000000e
1.000000e+001
设有如下 class 定义:
class CA
{
public:
CA(void) { std::cout << ＇a＇; }
~CA(void) { std::cout << ＇b＇; }
};
class CB : private CA
{
public:
CB(void) { std::cout << ＇c＇; }
~CB(void) { std::cout << ＇d＇; }
};
则，
{
CB obj;
}
以上代码的执行结果是( )
A. abcd;
B. acbd;
C. cadb;
D. acdb;
以下代码
class Base
{
public:
void h(float x){ cout << ＂Base::h(float)＂ << x << endl; }
};
class Derived : public Base
{
public:
void h(float x){ cout << ＂Derived::h(float) ＂ << x << endl; }
};
void main(void)
{
Derived d;
Base *pb = ＆d;
pb->h(3.14f);
}
上述代码执行后正确的输出是:（ ）
A. Derived::h(float)3.14;
B. Base::h(float)3.14;
C. Derived::f(float)3.14 Base::h(float)3.14;
D. Base::h(float) 3.14 Derived::f(float) 3.14;
有如下程序
#include<iostream>
#include<iomanip>
using namespace std;
class MyClass{
public:
MyClass(){cout<<’A”;}
MyClass(char c ){cout<<c;}
~MyClass(){out<<’B”;}
};
void main(){
MyClass p1,*p2
p2=new MyClass(‘X’);
delete p2;}
执行这个程序幕上将显示输出______。
A）ABX B）ABXB C）AXB D）AXBB
//======================================================
所有在函数中定义的变量，都是( )
A. 全局变量;
B. 局部变量;
C. 静态变量;
D. 寄存器变量
下列关于成员函数的述描述中，错误的是（ ）。
A. 成员函数一定是内联函数;
B. 成员函数可以重载;
C. 成员函数可以设置参数的缺省值;
D. 成员函数可以是静态的
在C++中实现封装是借助于( )
A. 枚举;
B. 类;
C. 数组;
D. 函数
不能作为重载函数的调用的依据是（ ）
A. 参数个数;
B. 参数类型;
C. 函数返回类型;
D. 参数顺序
抽象类指的是（）。
A. 没有任何成员的类;
B. 只有成员函数没有数据成员的类;
C. 有虚函数的类;
D. 有纯虚函数的类
当一个类的某个函数被说明为virtual时，该函数在该类的所有派生类中( )
A. 都是虚函数;
B. 只有被重新说明时才是虚函数;
C. 只有被重新说明为virtual时才是虚函数;
D. 都不是虚函数
宏定义的宏展开是在_________阶段完成的。
A. 预处理;
B. 编译;
C. 预处理前;
D. 运行
宏定义由（ ）结束
A. 分号;
B. 句号;
C. 新行;
D. 冒号
在C语言中,以下正确的说法是___
A. 实参和与其对应的形参各占独立的存储单元X;
B. 实参和与其对应的形参占用同一个存储单元X;
C. 只有当实参和与其对应的形参同名时才占用同一个存储单元X;
D. 形参是虚拟的,不占用存储单元
数组名作为实参传递给形参时,数组名被处理为：___。
A. 该数组的长度;
B. 该数组的元素个数;
C. 该数组中第一个元素的值;
D. 该数组的地址
下面是关于构造函数的说法，不正确的是（ ）。
A. C++规定，每一个类必须有一个构造函数，没有构造函数就不能创建对象;
B. 如果没有提供一个类的构造函数（一个都未提供），则C++编译器提供一个默认的构造函数，该默认构造函数无参，仅仅负责创建对象;
C. 虽然一个类定义了一个构造函数（不一定是无参构造函数），C++仍然提供默认的构造函数;
D. 与变量定义类似，在用默认构造函数创建对象时，如果创建的是全局对象或静态对象，则对象的位模式全为0，否则，对象值是随机的
在下列说法中，不正确的是（ ）。
A. 静态成员函数不能利用this指针;
B. 只有非静态成员才可以使用this关键字，因为静态成员没有this指针;
C. 析构函数不接受任何参数，也不带有任何类型的返回值;
D. 虚机制在构造函数和析构函数中仍然可以很好地工作，以实现多态性
多重继承的构造顺序一般可分为4步，下面给出这4个步骤：
step1： 任何非虚拟基类的构造函数按照它们被继承的顺序构造。
step2： 任何虚拟基类的构造函数按照它们被继承的顺序构造。
step3： 任何成员对象的构造函数按照它们声明的顺序构造。
step4： 类自己的构造函数。
这4个步骤的正确顺序是（ ）。
A. step4、step3、step1、step2;
B. step2、step4、step3、step1;
C. step2、step1、step3、step4;
D. step3、step4、step1、step2
下面表述中不正确的是（ ）。
A. C++中动态内存分配用new建立动态对象，用delete删除动态对象;
B. 类群是由一些彼此互不相关的类组成;
C. 构造函数是和类同名的成员函数;
D. 如果#if后的常量表达值为真，则不编译这部分，否则就编译该部分
下面（ ）的叙述不符合赋值兼容规则。
A. 派生的对象可以赋给基类的对象;
B. 基类的对象可以赋给派生类的对象;
C. 派生类的对象可以初始化基类的引用;
D. 派生类的对象的地址可以赋给指向基类的指针
对虚函数的调用（ ）。
A. 一定使用动态联编;
B. 必须使用动态联编;
C. 一定使用静态联编;
D. 不一定使用动态联编
函数模板和类模板的本质是:
A. 代码可重用;
B. 类型的参数化;
C. 代码的函数化;
D. 面向对象的扩展
下面是关于ios类的叙述，正确的是（ ）。
A. 它是istream类和ostream 类的虚基类;
B. 它是istream类的虚基类;
C. 它是ostream 类的虚基类;
D. 它是iostream 类的虚基类
下面对静态数据成员的描述中，正确的是 ( )
A. 静态非const数据成员也可在类体内进行初始化;
B. 静态数据成员只可以被该类以外的对象引用;
C. 静态数据成员不能受private控制符的作用;
D. 静态数据成员可以直接用类名调用;
2. 对栈内存、堆内存、静态内存的正确描述是（ B ）
A, 全局变量的存储是在静态内存中，局部变量的存储是在堆栈内存，调用中函数参数的存储是在栈内存中；
B, 使用栈内存是不需要程序员申请和释放的，使用堆内存需要程序员申请和释放的，使用静态内存不需要程序员申请和释放的；
C, new和malloc分配的内存是从栈堆内存分配的，static类型变量的存储是在静态存储区中；
D, 指针只能指向栈内存、堆内存，不能指向静态内存；
25. 快速排序的时间复杂度（A）
A, O(n*log(n)); B, O(n*n); C,O(n*n/2); D,O(log(n));
26. 若某链表最常用的操作时在最后一个元素之后插入一个节点和删除最后一个节点，则采用（D）存储方式节省时间。
A,单链表 B,双链表 C,单循环链表 D,带头节点的双循环链表
27. 用数组表示链表的优点是（C）
A,节省内存 B,便于随机存取 C,减少内存碎片 D,插入和删除速度快
28. 对线性表进行二分法查找，其前提条件是（A）
A,线性表以顺序方式存储，并且按关键码值排好序
B,线性表以顺序方式存储，并且按关键码值的检索频率排好序
C,线性表以链接方式存储，并且按关键码值排好序
D,线性表以链接方式存储，并且按关键码值的检索频率排好序
29. 以下哪种数据结构适合查找操作（D）
A,单向链表 B, 双向链表 C,二叉树 D,平衡二叉树
30. 当一个需要排序的数列基本有序的时候,最好选择那种排序方式（D）
A,选择排序 B,插入排序 C,快速排序 D,冒泡排序
关于运算符重载，下列表述中正确的是______。
A）C++已有的任何运算符都可以重载
B）运算符函数的返回类型不能声明为基本数据类型
C）在类型转换符函数的定义中不需要声明返回类型
D）可以通过运算符重载来创建C++中原来没有的运算符
在一个派生类对象结束其生命周期时
A）先调用派生类的析构函数后调用基类的析构函数
B）先调用基类的析构函数后调用派生类的析构函数
C）如果基数没有定义析构函数，则只调用派生类的析构函数
D）如果派生类没有定义析构函数，则只调用基类的析构函数
下列关于C++函数的叙述中，正确的是（ ）。
A）每个函数至少要具有一个参数
B）每个函数都必须返回一个值
C）函数在被调用之前必须先声明
D）函数不能自己调用自己
在C++中，用于实现运行时多态性的是（ ）。
A）内联函数
B）重载函数
C）模板函数
D）虚函数
下列关于运算符重载的叙述中，正确的是（ ）。
A）通过运算符重载，可以定义新的运算符
B）有的运算符只能作为成员函数重载
C）若重载运算符+，则相应的运算符函数名是+
D）重载一个二元运算符时，必须声明两个形参
1361
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
