- 以下程序的运行结果是(
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