重庆大学2023级期末模拟测试题选择题题库（一）

  本文仅提供部分选择题，个人原因收集不完全。

基类成员在派生类中的访问属性

基类中的保护成员在公有派生类中的访问属性为 ▁▁▁▁▁。

A.

无法访问

B.

公有

C.

私有

D.

保护

下列程序段的输出结果是（A）

#include <stdio.h>
int main(void)
{
    int m, k = 0, s = 0;
    for (m = 1; m <= 4; m++) {
        switch (m % 4) {
        case 0:
        case 1: s += m; break;
        case 2:
        case 3: s -= m; break;
        }
        k += s;
    }
    printf("%d\n", k);
    return 0;
}

A.
-4

B.
10

C.
-2

D.
-12

若有int *p, a=4; 和 p=&a; 下面（ ）均代表地址。

A.
*&p, *p, &a

B.
a, p, *&a

C.
&a, &*p, p

D.
&*a, &a, *p

若想将一个字符数组a的内容存入另一个字符数组b中,下列正确D).

A.
b=a;

B.
trcat(b,a);

C.
strcpy(a,b);

D.
strcpy(b,a);

关于new 和 delete 关键字功能的叙述，不正确的是（B）

A.
delete用于删除new建立的对象，并释放指针所指向的内存空间，同时，也会自动调用对象的析构函数。

B.
B * ptr=new B(5)；delete ptr; 假设上述语句中，new申请的内存空间首地址为Addr,存放ptr指针变量值的内存空间首地址为 PAddr，则执行delete ptr 语句后，Addr、PAddr指向的内存区域均会被系统收回。

C.
new动态申请内存空间成功后，返回该内存区域的首地址；同时，也会自动调用相关类的构造函数。

D.
C++程序的内存空间，可以分为代码区(text segment）、静态存储区(Data Segment)、栈区(Stack)、堆区(Heap)。new关键字用于从堆区中动态申请创建对象所需的内存空间。

关于析构函数

下列关于构造函数的说法中，▁▁▁▁▁ 是正确的。

A.
析构函数不能重载

B.
析构函数可以有函数值

C.
析构函数必须有参数

D.
析构函数不可缺省

下列哪个循环不是死循环（A）。

A.
int i=100;
 while(1)
 { i=i%100+1;
   if(i>=100)
       break;    
}

B.
int k=0;
 do{
     ++k;
 }while(k=1);

C.
int i=100;
 while(1)
 { 
   if(i>=100)
       continue;    
   i=i%100+1;
}

D.
int i;
for( i=1 ;   ;   )
{
     i=i%100+1;
}

表达式 “new int”的返回值类型是?（B）

A.
无法确定

B.
int *

C.
int

D.
int &

下列说法中正确的是（ C）

A.
在函数参数定义中不可以使用const说明符

B.
在函数参数定义中可以使用const说明符，但只能有一个参数使用const

C.
在函数参数定义中可以使用const说明符，其值在函数体内不可改变

D.
在函数参数定义中可以使用const说明符，但必须指定缺省值

下列程序的输出结D）。

int main(void)
{ 
  int n[3],i,j,k;
  for(i=0;i<3;i++)
        n[i]=0;
  k=2;
  for (i=0;i<k;i++)
    for (j=0;j<k;j++)
       n[j]=n[i]+1;
  printf("%d\n",n[1]);
  return 0;
}

A.
1

B.
2

C.
0

D.
3

对于常数据成员，下面描述正确B）

A.
常数据成员可以不初始化，并且不能更新

B.
常数据成员必须被初始化，并且不能更新

C.
常数据成员可以不初始化，并且可以被更新

D.
常数据成员必须被初始化，并且可以更新

基于以下代码，不能正确输出字符A )。

string s;
char ts[10];
cin>>ts;
s=ts;

A.

printf("%s\n", s);

B.

printf("%s\n", ts);

C.

cout<<s<<endl;

D.

printf("%s\n", s.c_str());

有以下程序

#include <stdio.h>
main(){  
   char  s[]="abcde";
   s+=2;
   printf("%d\n",s[0]);
}
执行后的D）

A.
输出字符c

B.
输出字符c的ASCII码

C.
输出字符a的ASCII码

D.
程序出错

下列程序段的输出结果是（D）

#include <stdio.h>
int main(void)
{
    int m, k = 0, s = 0;
    for (m = 1; m <= 4; m++) {
        switch (m % 4) {
        case 0:
        case 1: s += m; break;
        case 2:
        case 3: s -= m; break;
        }
        k += s;
    }
    printf("%d\n", k);
    return 0;
}

A.
-2

B.
-12

C.
10

D.
-4

下列关于常指针的定义，错误的是：（B）

A.
const int * p;

B.
int * p const;

C.
const int * const p;

D.
int * const p;

下列选项哪一个是正D）

A.
char *p=new int; p='a'; delete p;

B.
char *p=new char; p[0]='k'; delete p;

C.
int *p=new int[25]; p[10]=100; delete p;

D.
char *p=new char[10]; p[0]='k'; delete [ ] p;

假设在公有派生情况下，以下说法不正确的是（B）

A.
可以将派生类对象赋值给基类的引用

B.
可以将基类对象复制给派生类对象

C.
可以将派生类对象赋值给基类对象

D.
可以将派生类对象的地址复制给基类指针

下面程序段的循环次数是（ B）。
for ( i = 2; i == 0; )
printf( "%d", i-- );

A.
无限次

B.
0次

C.
1次

D.
2次

执行以下程序后，y的值是：D

int main ( )
 {
    int a[]={2,4,6,8,10};
    int y=1,x,*p;
    p=&a[1];
    for(x=0;x<3;x++)
      y + = * (p + x);
    printf("%d\n",y);
    return 0;
 }

A.
18

B.
20

C.
17

D.
19

下列关于构造函数的描述中，错误的是（D）

A.
每个类都有构造函数

B.
构造函数名与类名相同

C.
构造函数可以重载

D.
构造函数可以有返回值

执行下面程序段后，变量a的值为（C ）。

int a=10,b=1;
int *p=&a;
a=*p+b;

A.
12

B.
编译错误

C.
11

D.
10

分析以下程序：程序的输出结果是（C）

#include <iostream>
using namespace std;
void fun(int num)
{
    cout << num << endl;
}
void fun(char ch)
{
    cout << (ch + 1) << endl;
}
int main()
{
    fun('A');
    return 0;
}

A.
A

B.
65

C.
66

D.
B

派生类中的私有成员

若采用私有继承方式，则派生类对象中的私有成员不可能为 ▁▁C▁▁▁。

A.
派生类中新增的私有成员

B.
基类中定义的公有成员

C.
基类中定义的私有成员

D.
基类中定义的保护成员

如果多种事物，有一些共同的特点又各自不同的特点，如何编写类来代表这些事物比较合适？

(A)

A.
概括所有事物的共同特点，写一个基类。然后为每种事物写一个类，都从基派生而来

B.
一共就写一个类，包含所有事物的所有特点，然后用一个成员变量作为标记，来区分不同种类的事物

C.
为每种事物独立编写一个类，各之间互相无关

D.
写一个类代表其中一种事物，代表其他事物的类都从这个类派生出来

有语句“int a;”，则以下语句正确的是( C)。

A.
cout< <a;

B.
cin>>a>>endl;    

C.
printf("%d\n",a);    

D.
scanf("%d",a);

若有int *p, a=4; 和 p=&a; 下面（C ）均代表地址。

A.
a, p, *&a

B.
*&p, *p, &a

C.
&a, &*p, p

D.
&*a, &a, *p

以下程序存在的问题是：(C)

void fun()
{
 int *num1, *num2;
 num1 = new int[10];
 num2 = new int[20];
 num1[0] = 100;
 num2[0] = 300;
 num1 = num2;
 delete [] num1;
}

A.
num2最初指向的空间没有释放

B.
num2不能给num1赋值

C.
num1最初指向的空间没有释放

D.
程序没有问题

下列数据中属于C语言的“字符串常量”的是（ A ）。

A.
“a”

B.
‘a’

C.
‘abc\0’

D.
{ABC}

若变量已正确定义，对以下while循环结束条件的准确描述是（ C）。

flag = 1;
denominator = 1;
item = 1.0;
pi = 0;
while(fabs(item) > 0.0001){
   item = flag * 1.0 / denominator;
   pi = pi + item;
   flag = -flag;
   denominator = denominator + 2;
}

A.
item的绝对值不小于0.0001

B.
item的绝对值不等于0.0001

C.
item的绝对值不大于0.0001

D.
item的绝对值等于0.0001

下列不正确的定义是（　 D ）。

A.
int i,*p;

B.
int i,*p=&i;

C.
int *p,i;

D.
int *p=&i,i;

关于类的析构函数描述正确的是(D)

A.
析构函数可以重载

B.
析构函数可以有参数

C.
析构函数有返回值类型

D.
析构函数可以省略

以下程序段的输出结果是(A)。
int i, j;
for(i =1; i<4; i++)
{ for(j=i; j<4;j++) printf("%d*%d=%d ", i, j, i*j);
printf("\n "); }

A.
1*1=1 1*2=2 1*3=3
2*2=4 2*3=6
3*3=9

B.
1*1=1 1*2=2 1*3=3
2*1=2 2*2=4
3*1=3

C.
1*1= 1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9

D.
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9

定AA是一个类，“AA* abc()const;”是该类中一个成员函数的原型，若该函数返回this值，当用x.abc()调用该成员函数后，x的值：（B）

A.
受到函数调用的影响

B.
不变

C.
已经被改变

D.
可能被改变

有下列程序, 则下列叙述中正C)。
int main(void)
{ static char p[ ]={'a', 'b' , 'e'}, q[10] ={'a', 'b', 'e'};
printf("%d%d\n", strlen(p), strlen(q));
return 0; }

A.
在给p和q数组赋初值时, 系统会自动添加字符串结束符, 故输出的长度都为3

B.
由于q数组中没有字符串结束符, 长度不能确定, 但p数组中字符串长度为3

C.
由于p数组中没有字符串结束符, 长度不能确定, 但q数组中字符串长度为3

D.
由于p和q数组中都没有字符串结束符, 故长度都不能确定

先输入一个字符c，再输入一个包含空格的字符串s时，需要吸收c之后的换行符，则以下达不到目的的是(D )。

A.
cin.get();

B.
scanf("%*c");

C.
getchar();

D.
scanf("%c");
 

现有程序用于计算一个数学函数f(n):

fun(int n)
{    switch(n)
     {
            case 0:return 0;
            case 1:return 1;
            default:
            {       int i,a=0,b=1,result;
                     for(i=2;i<=n;i++)
                     {     result=a+b;
                           a=b;
                           b=result;
                     }
                     return result;
             }
      }
}

该数学函数的表达式是___C_____。

A.

           0 (n=1)
f(n)={     1 (n=1)
           f(n-1)+f(n-2) (n>0)

B.

            0 (n=0)
f(n)={      1 (n=0)
            f(n-1)+f(n-2) (n>1)

C.

           0 (n=0)
f(n)={     1 (n=1)
           f(n-1)+f(n-2) (n>1)

D.

          0 (n<0)
f(n)={    1 (n>0)
          f(n-1)+f(n-2) (n>1)