C++

最新推荐文章于 2021-05-20 01:33:23 发布

Edward_Wong

最新推荐文章于 2021-05-20 01:33:23 发布

阅读量851

点赞数

文章标签：一问一答 C++

本文链接：https://blog.csdn.net/Edward_Wong/article/details/38962777

版权

1、下列哪个选项能赋值给字符常量（C）

A.a B.A C.68 D.'10'

2、控制格式输出输入的操作中，（B）是设置域宽的

A.oct B.setw()C.setfill()D.ws

3、输出的是什么（A）

#include <iostream>
using namespace std;

class Base
{
public:
    virtual void test(int a = 10)
    {
        cout<<"Base::a="<<a<<endl;
    }
};

class Derived:public Base
{
public:
    void test(int a = 20)
    {
        cout<<"Derived::a="<<a<<endl;
    }
};

int main()
{
    Base *p = new Derived;
    p -> test();
}

A.Derived::a=10 B.Derived::a=20

解释：虚函数在派生类中实现的必须是相同的函数，如果参数不同就变成了函数重载。所以这里，继承的虚函数会覆盖子类中的成员函数。

4、设int a = 0, b = 5;执行表达式++a||++b, a + b后，a,b和表达式的值分别是（B）

A.1,5,7 B.1,5,6C.0,5,7D.1,6,7

解释：因为++a=1之后为true,所以不执行++b。

5、有一个int型变量，在程序中频繁使用，最好定义它为（B）

A.auto B.registerC.externD.static

解释：C语言register--最快的关键字，所声明的变量将放在CPU的寄存器中：register int i;

但是register修饰符有几点限制：

首先，register变量必须是能被CPU所接受的类型。所以其必须是单个的值，并且长度应该小于或等于整型的长度；

其次，register变量可能不存放在内存中，所以不能用“&”来获取register变量的地址。

6、可用作C++语言用户标识符的一组标识符是（C）

A.for -abc Case B.void define +WORDC.a3_b3_123 YND.2a DO sizeof

解释：C++语言用户标识符命名规则：

只能有字母、数值和下划线3中字符组成；

第一个字符必须是字母或下划线；

不能与C++语言的关键字或保留字相同。

7、在C++中，数组类型属于（B）

A.结构体类型 B.自定义数据类型C.基本数据类型D.类类型

解释：自定义数据类型包括枚举类型，结构类型，联合类型，数组类型和类等。

8、如果表达式++a中的“++”是作为成员函数重载的运算符，若采用运算符函数调用格式，则可表示为（B）

A.operator++(a,1) B.a.operator++()C.a.operator++(1)D.operator++(a)

9、假定AB为一个类，则执行“AB a(2)，b[3]，*p[4]；”语句时调用该类构造函数的次数为（C）

A.2 B.1 C.4 D.3

其中，a(2)调用1次，b[3]调用3次，*p[4]无调用

10、不能作为类的成员的是（D）

A.另一个类的对象 B.自身类对象的指针 C.自身类对象的引用 D.自身类对象

11、设x.y.z和k都是int型变量，则执行表达式：x = ( y = 4, z = 16 ), k = 32后，x的值为（C）

A.32 B.4 C.16 D .52

解释：在C语言中，多个表达式可以用逗号隔开，其中用逗号隔开的表达式的值分别结算，但整个表达式的值是最后一个表达式的值。所以( y = 4, z = 16)的最终结果是16,。而逗号运算符优先级低于赋值运算符，古先执行x= ()，即x = 16；x赋值后参与后面逗号表达式的运算，该表达式最终结果为32.

12、下列模板声明：template<typename T1,typename T2>class A;下列声明中，与上述声明不等价的是(D)

A.template<class T1,typename T2>class A;

B.template<class T1,class T2>class A;

C.template<typename T1,class T2>class A;

D.template<typename T1,T2>class A;

13、设已定义k为int整型变量，则有下面while循环执行（C）次

k = 10;

while( k = 0) k = k - 1;

A.执行一次 B.无限循环 C.一次也不执行 D.执行10次

解释：（k = 0）的返回值为0

14、文件包含命令所包含的文件是不受限制的（A）

A.错 B.对

15、以下有关静态成员函数的叙述不正确的是（B）

A.使用类名可以直接调用其静态成员函数；

B.对静态成员函数的引用不允许使用对象名；

C.静态成员函数属于整个类；

D.在静态成员函数中不能直接引用类的非静态成员

16、有如下模板定义：template <class T>T fun(T x,T y){ return x*x + y*y; }在下列对fun的调用中，调用错误的是：(D)

A.fun(2,8) B.fun(2.0,8.2) C.fun<float>(2,8.3) D.fun(2,3.8)

17、下面程序的输出结果是（D）

#include<iostream>
int fun(char *s)
{
	char *p = s;
	while(*p != '') p++;
	return (p - s);
}

int main()
{
	cout<<fun("ABCDEFGHIJKLMNOPQRST")<<endl;
}

A.19 B.6 C.0 D.20

解释：注意最后还有一个‘\0’字符

18、char str[20]; cin>>str; cout<<str;执行时输入的是“this is a test line!”，则输出的内容是（C）

A.this is a test line! B.this is a testC.thisD.this is a test line

分析：cin>>str的结束标志是空格，如果改为gets(str)，则输出全部。如果将cout<<str改为cout<<*str，则输出“t”

19、关于友元函数的描述中，（D）是错的

A.友元函数可直接访问类中的私有成员

B.友元类中的所有成员函数都是友元函数

C.友元函数破坏封装性，使用时尽量少用

D.友元函数是成员函数，它被说明在类体中

20、下列（C）是C++的函数声明

A.int add(int x,int y){....}

B.int add(x,y);

C.int add(int,int);

D.int add(){....}

21、include头文件中尖括号和双引号的区别：

使用双引号：系统首先到当前目录先查找被包含的文件，如果没找到，再到系统指定的“包含文件目录”（由用户在配置环境时设置）去查找。

使用尖括号：直接到系统指定的”包含文件目录“去查找。一般来说，使用双引号比较保险。

22、输出结果为18和30！

#include <iostream>
using namespace std;
#define F1(n) (n-1)*n
#define F2(n) (n-1)*n*(n+1)

int main() {
	int x = 1, y = 2;
	cout<<F1(3+x+y)<<endl;
	cout<<F2(3+x+y)<<endl;
}

宏定义的时候，编译器是直接把变量替换成参数，比如：

(n-1)*n就替换成（n-1）*3+x+y=18

(n-1)*n*(n+1)替换成(n-1)*3+x+y*(n+1)=30

23、输出结果-- 8 3

#include <iostream>
using namespace std;

int main() {
    int n = 9;
    cout<<(n--/3)<<ends<<n;
}

24、输出结果-- 9

#include <iostream>
#include <cstdlib>
using namespace std;

void fun(int **s, int p[2][3]) {
    **s = p[1][1];
}

int main() {
    int a[2][3] = {1,3,5,7,9,11}, *p;
    p = (int*)malloc(sizeof(int));
    fun(&p,a);
    cout<<*p;
}

25、有关多态性说法不正确的是（B）

A C++语言的多态性分为编译时的多态性和运行时的多态性 B 运行时的多态性可通过模板和虚函数实现 C 编译时的多态性可通过函数重载实现 D 实现运行时多态性的机制称为动态多态性

26、如下代码：struct {char a1; int a2; float a3;}A; 这sizeof(A)的结果是（D）

A 9 B 13 C 24 D 12

ans:总共有9个字节，由于要对齐，所以最终占12个字节。为结构体分配内存时，是按顺序分配的且必须对齐，即变量为2字节则其地址最低位必须为0，变量为4字节则其地址最低两位必须为0。

26、fseek函数与ftell函数综合应用:

分析:可以用fseek函数把位置指针移到文件尾,再用ftell函数获得这时位置指针距文件头的字节数,这个字节数就是文件的长度.

27、x > 0 || y == 5的相反表达式为（A）

A x <= 0 && y != 5 B x > 0 && y == 5 C x <= 0 || y != 5 D x > 0 || y != 5

28、有如下程序：

#include <iostream>
using namespace std;

class C1 {
public:
    ~C1() { cout<<1; };
};

class C2: public C1 {
public:
    ~C2() { cout<<2; };
};

int main() {
    C2 cb2;
    C1* cb1;
    return 0;
}

运行时的输出结果是（D）

A 221 B 12 C 121 D 21

29、int w[5] = {1,2,3,4,5,};

当for(int i = 0; i< 5;i++)
cout<<w[i]<<ends;

时输出1,2,3,4,5

当for(int i = 0; i< 6;i++)
cout<<w[i]<<ends;

时输出1,2,3,4,5,5

30、程序段char a[3],b[] = "China";a=b;cout<<a;则（B）

A 运行后将输出China B 编译出错 C 运行后输出Chi D 运行后将输出Ch

31、已知：int a, *pa = &a;输出指针pa十进制的地址值的方法是（C）

A cout<<pa; B cout<<*pa; C cout<<long(&pa) D cout<<&pa;

32、下列关于虚函数的说明中，正确的是（D）

A 从虚基类继承的函数都是虚函数

B 抽象类中的成员函数都是虚函数

C 只能通过指针和引用调用虚函数

D 虚函数不得是静态成员函数

ans:静态函数是全局共享的，而虚函数不是

33、转义字符意义 ASCII码值(十进制)

  \a 响铃(BEL) 007 
  \b 退格(BS) 008 
  \f 换页(FF) 012 
  \n 换行(LF) 010 
  \r 回车(CR) 013 
  \t 水平制表(HT) 009 
  \v 垂直制表(VT) 011 
  \\ 反斜杠 092 
  \? 问号字符 063 
  \' 单引号字符 039 
  \" 双引号字符 034 
  \0 空字符(NULL) 000 
  \ddd 任意字符 三位八进制 
  \xhh 任意字符 二位十六进制

34、子类不能从父类继承的有：
构造函数，拷贝构造函数，析构函数
能从父类继承的有：
静态成员变量，静态成员函数，友元函数，赋值操作符=重载函数

35、在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
1.栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。
2.堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程>序结束后，操作系统会自动回收。
3.自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。
4.全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
5.常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改）

36、线程调度是在进程中进行，在同一存储区内操作，而进程则在不同存储区操作，所以进程调度数度比线程慢

37、由于计算机表示小数（包括float和double型小数）都有误差，我们不能直接用等号（==）判断两个小数是否相等。如果两个小数的差的绝对值很小，比如小于0.00000001，我们就认为它们相等。

Edward_Wong

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++

1、下列哪个选项能赋值给字符常量（）
复制链接

扫一扫

C++

“相关推荐”对你有帮助么？