c++笔试题（自我纠查）

爱编程的小白菜

已于 2023-09-08 21:19:50 修改

阅读量301

点赞数

文章标签： c++ 算法开发语言

于 2023-08-12 08:53:24 首次发布

本文链接：https://blog.csdn.net/m0_65938528/article/details/132091561

版权

1.设“int a=15,b=26;”，则“cout << (a,b); ”的输出结果是( 26 )。

逗号运算符返回最右侧的值！

2、C++是不是类型安全的？不是

3、下面程序的输出结果是（2,5）

#include <stdio.h>

int main() {

int intArray[] = {1, 2, 3, 4, 5};

int *p = (int *)(&intArray+1); //&intArrays+1表示整个数组的地址

printf("%d,%d",*(intArray+1),*(p-1)); //intArray+1表示数组首元素的地址

return 0; //*(p-1)，因为p是int，-1移动4个字节，intArray数组也为int

}

4、设有语句 char a = '\72';，则关于变量a的说法正确的是（）

包含2个字符

说明不合法

包含1个字符

包含3个字符

变量a的值为'\72'，'\72'是八进制表示的字符，对应的ASCII码为50，是字符'2'的ASCII码值。所以变量a的值为字符'2'。

5、通过基类对象名、指针只能使用从基类继承的成员。

6、.常见的不能声明为虚函数的有:普通函数(非成员函数)，静态成员函数，内联成员函数，构造函数，友元函数

7、关于c++的inline关键字,以下说法正确的是()

使用inline关键字的函数会被编译器在调用处展开

头文件中可以包含inline函数的声明

可以在同一个项目的不同源文件内定义函数名相同但实现不同的inline函数

定义在Class声明内的成员函数默认是inline函数

优先使用Class声明内定义的inline函数

优先使用Class实现的内inline函数的实现

解释：

A 项错误，因为使用 inline 关键字的函数只是用户希望它成为内联函数，但编译器有权忽略这个请求，比如：若此函数体太大，则不会把它作为内联函数展开的。

B 项错误，头文件中不仅要包含 inline 函数的声明，而且必须包含定义，且在定义时必须加上 inline 。关键字 inline 必须与函数定义体放在一起才能使函数成为内联，仅将 inline 放在函数声明前面不起任何作用。

C 项错误， inline 函数可以定义在源文件中，但多个源文件中的同名 inline 函数的实现必须相同。一般把 inline 函数的定义放在头文件中更加合适。

D 项正确，类内的成员函数，默认都是 inline 的。定义在类声明之中的成员函数将自动地成为内联函数。

EF 项错误， class 的成员函数都是 inline 的，加了关键字 inline也没有优先问题。

8、有以下表达式：

int a = 248, b = 4;

int const c = 21;

const int *d = &a;

int *const e = &b;

int const * const f = &a;

请问下列表达式哪些会被编译器禁止?

*c=32

*d=43

e=&a

f=0x321f

d=&b

*e=34

9、在下列流类中，可以用于处理文件的是（）

ios

iostream

strstream

fstream

你的答案：B

官方解析：正确答案：D
A 选项 ios 是所有流类的基类，它派生出 istream 和 ostream
B 选项 iostream 继承自 istream 和 ostream 类，因为该类的功能兼两者于一身，既能用于输入，也能用于输出
C 选项 strstream 类同时可以支持 C 风格的串流的输入输出操作

D 选项兼 ifstream 和 ofstream 类功能于一身，既能读取文件中的数据，又能向文件中写入数据

10、定义宏

1	`#define DECLARE(name, type) type name##_##type##_type`

则DECLARE(val, int)替换结果为（）

int val_int_type

int val_int_int

int name_int_int

int name_int_name

预编译时扫描文本, 找到单独的type 和粘贴连接的##type, 对于 _type是一个整体, 不同于 type, 所以最后 _type不会被替换

11、下面哪些函数不能被声明为虚函数（）

构造函数

静态成员函数

内联函数

友元函数

如果一个类的友元函数是另一个类成员函数，那么它在自己的类内可以被声明为虚函数

12、可以用delete释放不是用new运算符分配的内存。

正确

错误

番外内容：

wait(),waitpid()区别：

1、在一个子进程终止前，wait使其调用者阻塞，而waitpid有一个选项，可使调用者不阻塞

2、waitpid()并不等待在其调用之后的第一个终止的子进程，它有若干个选项，可以控制它所等待的进程;

3、

13、

下面程序打印结果在32位系统上输出为（8）

#include<iostream>

using namespace std;

class A {

char a[3];//3个字节

public:

virtual void fun1(){};//类中的虚函数表4个字节，实例化后的对象中存在虚函数指针，指向类中的虚函数表 32位4字节 64 位8字节

};

int main () {

cout << sizeof(A) << endl;//字节对齐总共8字节

return 0;

}

14、

下面程序运行后的结果为：

char str[] = "glad to test something";

char *p = str; //p->g元素

p++;//p->l元素

int *p1 = reinterpret_cast<int *>(p);

p1++; //p1为int，加1 4个字节 p1->t

p = reinterpret_cast<char *>(p1);

printf("result is %s\n", p);

result is glad to test something

result is ad to test something

result is test something

result is to test something

15、阅读C语言代码输出（）

int main()

{

int arr[]={1,2,3,4,5,6,7};

int *p=arr;

*(p++)+=89;

printf("%d,%d\n",*p,*(++p));

return 0;

}

3 3

2 2

2 3

3 2

16、哪个类定义可能需要一个复制构造函数？

包含四个 float 成员的 Point3w 类

Matrix 类，其中，实际矩阵在构造函数中动态分配，在析构函数中删除

Payroll 类，在这个类中为每个对象提供唯一ID

Word 类，包含一个 string 和一个以行列位置对为元素的 vector

解析：

类需要定义一个新的复制构造函数，说明默认的复制构造函数不能满足需求：

A选项可以用默认的复制构造函数

B选项需要动态分配内存，需要

C选项根据存在的Payroll复制一份相同的副本，不能使得对象ID唯一

D选项可以调用string/vector类的复制构造函数

17、在C++中，根据（）识别类层次中不同类定义的虚函数版本。

参数个数

参数类型

函数名

this指针类型

18、（C++部分）若TestClass为一个类，执行“TestClass a[4]，*p[5]；”语句时会自动调用该类构造函数的次数是？

解析：语句“MyClass a[4]”定义了4个MyClass对象，分别为a[0]，a[1]，a[2]，a[3]，调用4次构造函数；语句“MyClass *p[5]”定义了5个指向MyClass对象的指针变量，分别为*p[0]，*p[1]，*p[2]，*p[3]，*p[4]，但定义指针并没有实例化对象，所以不调用构造函数。因此，执行该语句共调用MyClass的构造函数4次

19、

如输入1，最后输出什么（）

void main()

{

char c;

scanf("%c", &c);

switch(c)

{

case '1':

printf("1");

case '2':

printf("2")

case '3':

printf("3")

default:

printf("error");

}

123error

20、下列代码的结果是

#include<stdio.h>

main() {

int a[5] = {1, 2, 3, 4, 5};

int *ptr = (int *)(&a + 1);

printf("%d,%d", *(a + 1), *(ptr - 1));

}

3，5

2，4

2，5

3，4

21、建立类模板对象的实例化过程为（）？

基类→派生类

构造函数→对象

模板类→对象

模板类→模板函数

22、在上下文及头文件均正常的情况下，若有以下定义和语句：

1 2	`char` `s1[] =` `"12345", *s2 =` `"1234";` `printf("%d\n", strlen(strcpy(s1, s2)));`

则输出结果是

解析：

strcpy(s1,s2)这个函数是把s2字符串拷贝到s1这个字符串，分两种情况

1、s1的空间大于等于s2（结果：s2完全覆盖s1）理由：此时把s2中的所有字符连同结尾的‘\0’ 也拷贝到s1中。在读取s1时，读到 ‘\0’ 时便认为字符串结束。

2、s1的空间小于s2（结果：出错

3、strlen从1开始计数

23、以二进制方式打开一个文件的方法是？

FILE *f = fwrite("test.bin", "b");

FILE *f = fopenb("test.bin", "w");

FILE *f = fopen("test.bin", "wb");

FILE *f = fwriteb("test.bin");

解析：以二进制方式打开，在读写方式后加一个b

24、下列代码的运行结果（）

short i = 65537;

int j = i + 1;

printf("i=%d,j=%d\n", i, j);

i=65537,j=65538

i=1,j=2

i=-1,j=0

i=1,j=65538

25、下列关于 C++ 构造函数的说法，错误的是（）

构造函数不可以是私有的（private）

一个类中可以有多个构造函数

无论何时，只要类的对象被创建，就会执行构造函数

构造函数没有返回类型

构造函数可以是私有的，这样能对外界构造类对象进行限制（比如单例模式的一种实现）

26、在x86的机器上执行：

1 2	`int` `a = 0xabcd1234;` `char` `b = ((char*)&a)[0];`

请问b是多少

0xa

0x4

0xab

0x34

x86是小端存储（低---->高）

26、常对象只能调用它的常成员函数, 而不能调用普通的成员函数。

正确

错误

常对象就是创建初始化之后不能改变的对象，常对象只能调用常函数，就是说函数声明是有const关键字的成员函数

27、在32位计算机中，下面输出是多少（）

#include <iostream>

using namespace std;

typedef enum

{

Char ,

Short,

Int,

Double,

Float,

}TEST_TYPE;

int main() {

TEST_TYPE val;

cout<< sizeof(val)<<endl;

return 0;

}

因为，枚举变量的取值为花括号内的任意一个值（有且只能有其中一个值），而这个值是int型的，在X86系统中，int型的数据占内存4个字节。所以sizeof(c) = 4，也就是枚举变量的值为4。

28、下列程序的运行结果是PP 10003，请为横线处选择合适的程序（）

#include <stdio.h>

#include <string.h>

struct STU {

char name[10];

int num;

};

void f(char _____, int num) {

struct STU s[2] = {{"SS", 10001}, {"PP", 10002}};

num = s[1].num;

strcpy(name, s[1].name);

}

main() {

struct STU s[2] = {{"YY", 10003}, {"LL", 10004}}, *p;

p = s;

f(p->name, p->num);

printf("%s %d\n", p->name, p->num);

}

*name

name[]

name

&name

29、C++当中，没有参数的两个函数是不能重载的，上述说法是否正确？

正确

错误

官方解析：

const重载是可以的，如下

class

{

public：

void func();

void func() const;

};

这两个函数构30成重载

30、已知一函数中有下列变量定义，其中属于自动变量的有（）。

double k;

static char c;

auto long m;

自动变量：只在定义它们的时候才创建，在定义它们的函数返回时系统回收变量所占存储空间。对这些变量存储空间的分配和回收，是由系统自动完成的。一般情况下，没有auto说明的局部变量均是自动变量，自动变量也可用关键字auto做出说明、

31、已知: int m=10;，下列表示引用的方法中，正确的是（）

int &Z;

int &t = 10;

int &X = m;

float &f = &m;

32、在一个16位的机器，以下结构由于边界对齐浪费了多少空间（）

struct{

char a;

int b;

char c;

}

16机器按照两字节对齐。所以char型占用一个字节，浪费一个字节。 int型字节占用四个字节，没有浪费字节

1、8位系统（如一些嵌入式系统）：通常采用字节对齐，结构体成员的对齐边界为1字节。

2. 16位系统（如一些早期的微处理器）：通常采用字节对齐，结构体成员的对齐边界为2字节。即结构体中的成员变量的地址必须是2的整数倍。

3. 32位系统（如x86架构的计算机）：通常采用4字节对齐，结构体成员的对齐边界为4字节。即结构体中的成员变量的地址必须是4的整数倍。

4. 64位系统（如现代个人电脑）：通常采用8字节对齐，结构体成员的对齐边界为8字节。即结构体中的成员变量的地址必须是8的整数倍。

33、有如下程序段：

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

void GetMemeory(char *p) {

p = (char *)malloc(100);

}

void Test() {

char *str = NULL;

GetMemeory(str);

strcpy(str, "Thunder");

strcat(str + 2, "Downloader");

printf(str);

}

Thunder Downloader

under Downloader

Thunderownloader

程序崩溃

注意，当是传一个指针的时候，GetMemeory(&str);

void GetMemeory(char **p) { *p = (char *)malloc(100); }

否则GetMemory（）是按照按值传递的，因而局部变量，不会因为函数内部 p = (char*)malloc(100)的实现，而更改。

34、

在上下文及头文件均正常的情况下，以下代码打印的结果是（假设运行在 64 位计算机上）：

struct st_t {

int status;

short *pdata;

char errstr[32];

};

st_t st[16];

char *p = (char *)(st[2].errstr + 32);

printf("%d", (p - (char *)(st)));

120

114

144

根据字节对齐，在64位系统下struct st_t 结构体占用的字节为48个。

struct st_t {

int status; //占用8个（后面的4个为对齐位）

short *pdata;//占用8个

char errstr[32];//占用32个

};

char *p=(char *)(st[2].esstr+32)，p实际指向了st[3]

则p-(char *)(st))，即为&st[3]-&st[0],占用空间为3个结构体的大小，即3*48=144

35.构造异质链表的意义是（）？

用数组组织类对象

用链表组织类对象

用抽象类指针指向派生类对象

用抽象类指针构造派生类对象链表

36、有如下代码:

struct A1{

virtual ~A1(){}

};

struct A2{

virtual ~A2(){}

};

struct B1 : A1, A2{};

int main()

{

B1 d;

A1* pb1 = &d;

A2* pb2 = dynamic_cast<A2*>(pb1); //L1

A2* pb22 = static_cast<A2*>(pb1); //L2

return 0;

}

L1语句编译失败，L2语句编译通过

L1语句编译通过，L2语句编译失败

L1，L2都编译失败

L1，L2都编译通过

解释：

1、静态类型转换

static_cast<目标类型>(原类型) 目标类型和源类型之间必须一个方向可以自动类型转换，否则就会出现错误。

2、动态类型转换

dynamic_cast<目标类型>(原类型) 源类型和目标类型之间必须存在继承关系，否则会出现错误。

3、去常类型转换

const_cast<目标类型>(原类型) 源类型和目标类型必须是指针或引用，且间除了const属性外，其它都相同，否则就会出现错误。

4、reinterpret_cast

reinterpret_cast<目标类型>(原类型) 只能把整数转换成指针或把指针转换成整数，否则就会出现错误

37、对于void类型函数，调用时不可作为（）

自定义函数体中的语句

循环体里的语句

if 语句的成分语句

表达式

38、

下列表达式中，不合法的是（）
已知：double d = 3.2; int n = 3;

d<<2;

d/n

!d && (n-3)

(d-0.2)|n

参考答案：AD 浮点数和位运算：所有的位运算都不能直接操作浮点数，这就是A和D错的原因，但是，我们可以间接对浮点数进行位运算，例如，将float数据，取地址(&)强行转化为整型(int等)指针后，再取值(*)后赋值给整型变量(int等)，然后就能对该变量进行位运算了。【注】对浮点数进行位运算，一般没什么意义，因为浮点数的存储结构分三部分，进行过位运算后，所得结果跟原始浮点数没多大关系。 B.d/n：在运算前，系统会自动把两个操作数转化为精度较高的那个数据类型，这里会自动将n转化为double类型，然后在进行运算； C.!d&&(n-3)：逻辑运算符非(!)、与(&&)、或(||)，操作数可以是任何基本数据类型，因此此表达式合法，可以正常运行

39、char *p ="PCGAME";是定义初始化指针变量,指针变量的值是一个字符串.说法是否正确？

正确

错误

指针变量的值是地址，解引用*才是值

40、C++是否支持嵌套函数定义，如下代码所示？

fun1() {

fun2() {

fun3() {

}

允许

不允许

函数可以嵌套调用，但不可以嵌套定义

40、在32位系统中，下面代码打印结果为（）

class Base {

char data[3];

public:

virtual void f() { cout << "Base::f" << endl; }

virtual void g() { cout << "Base::g" << endl; }

virtual void h() { cout << "Base::h" << endl; }

};

int main() {

cout << sizeof(Base)<< endl;

return 0;

}

解释：无论有多少个虚函数，都只是提供一个虚函数表指针。这是因为虚函数表是存储在只读数据段中的，对于每个类来说，虚函数表的地址是固定的，因此不需要为每个类的对象都创建一个副本。

41、关于static变量，请选择下面所有说法正确的内容。

若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度

若全局变量仅由单个函数访问，则可以将这个变量改为该函数内的静态局部变量，以降低模块间的耦合度

设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题

静态全局变量过大时，可能会导致堆栈溢出

按照存储区分：全局变量、静态全局变量和静态局部变量都存放在内存的全局数据区，局部变量存放在内存的栈区

42、

enum string{

x1,

x2,

x3 = 10,

x4,

x5,

} x;

函数外部访问x等于什么？

随机值

函数外定义==全局变量==系统初始化为0;函数内定义==局部变量==需要人初始化，否则是随机值。

43、cin 是 istream 类的成员函数。

正确

错误

ios类派生istream类和ostream类，istream类和ostream类共同派生出iostream类，cin和cout都是iostream类的对象

44、若有以下定义，说法错误的是（）

1	`int` `a = 100, *p = &a;`

声明变量p，其中*表示p是一个指针变量

变量p经初始化，获得变量a的地址

变量p只可以指向一个整形数据

变量p的值为100

45、下面程序执行后的输出值为（）

#define SUM(x) 3*x*x+1 //3*5+8*5+8+1

int main() {

int i=5, j=8;

printf("%d\n", SUM(i+j));

return 0;

}

508

420

其他几项都不对

46、以下关于类占用内存空间的说法正确的是

类所占内存的大小是由成员变量（静态变量除外）和虚拟函数表指针空间（若有虚函数）所决定

空类的内存大小是１个字节

类中无论有多少个虚函数，只会多占一个虚表指针空间

子类的内存大小等于父类的内存大小加上子类独有成员变量的内存大小

47、下面有关C++中为什么用模板类的原因，描述错误的是？

可用来创建动态增长和减小的数据结构

它是类型无关的，因此具有很高的可复用性

它运行时检查数据类型，保证了类型安全

它是平台无关的，可移植性

参考答案：答：(1)可用来创建动态增长和减小的数据结构（2）它是类型无关的，因此具有很高的可复用性。（3）它在编译时而不是运行时检查数据类型，保证了类型安全（4）它是平台无关的，可移植性（5）可用于基本数据类型

48、有以下类定义

#include <iostream>

using namespace std;

class shape

{public:

virtual int area()=0;

};

class rectangle:public shape

{public:

int a, b;

void setLength (int x, int y) {a=x;b=y;}

int area() {return a*b;}

};

若有语句定义rectangle r; r.setLength(3,5); 则编译时无语法错误的语句是（）

shape *s1=&r;

shape &s2=r;

shape s3=r;

shape s4[3];

D 抽象类不能实例化，但是可以定义成指针或者引用。

49、关于下面代码，哪些描述是错误的（）

std::vector<char> v{'1', '2', '3', '4'};

// A

v.push_back('5');

// B

*v.end() == '4'

A和B位置v.capacity() 一定大于 v.size()

如果A位置v.size()与v.capacity()分别是4,4，那么B位置是5,5

如果A位置v.size()与v.capacity()分别是4,4，A位置&v[0]等于B位置的&v[0]

v.capacity()函数返回容器v的当前容量。

A：end()返回的迭代器一定指向vector中最后一个元素的后面，不管怎样都不会等于最后一个元素

B：v.capacity()可能等于v.size()

C：每次一扩容都是原来容量的两倍，因此B位置应该是5,8（根据编译器的不同可能不一样，反正不会只扩容一个元素的大小，除非capacity从0扩容到1）

D：因为发生了扩容：申请一块更大的连续空间->将原来空间的所有元素复制过去->释放原来的空间，两块连续空间在内存中的不同位置，那么地址当然发生了变化

50、unsigned short 类型的范围是（）

-128~12

-32768~32767

0~65535

0~255

shaort为2字节，16位，11111111 11111111

51、-5%3的运算结果是2。这句话是否正确

正确

错误

-号优先级高，先和5结合得到-5然后再取余，结果为-2。另外，两个数进行取余运算，结果的符号由被取余数决定，即-5%3=-2，5%-3=2，-5%-3=-2.

52、如果c为字符型变量，判断c是否为空格（假设已知空格ASCII码为32）不能使用（）

if(c==32)

if(c=='32')

if(c=='\40')

if(c==' ')

53、请问在 64 位平台机器下 sizeof(string_a)，sizeof(string_b) 大小分别是（）

1 2	`char` `string_a = (char` `)malloc(100*sizeof(char));` `char` `string_b[100];`

8 100

100 8

100 100

8 8

54、有以下定义语句 double a,b; int w; long c;

若各变量已正确赋值，则下列选项中正确的表达式是（）

a=a+b=b++// a+b为右值表达式

w%(int)(a+b)

(c+w)%(int)a

w=a==b;

55、静态存储变量具有局部的生存期.说法是否正确？

正确

错误

局部变量存在栈区

new出的变量存在堆区

static变量和全局变量由操作系统释放

static不在栈区存储，所以不是局部生存期。

在C语言中，局部生存周期（local scope）指的是一个变量的有效性或可见性仅限于在其定义的代码块（例如函数或循环体）内部。当代码块执行结束后，这些局部变量将被销毁。

56、有声明

1 2	`int` `fun6(int);` `int` `(*pf)(int) = fun6;`

在下列选项中，正确的调用是（）。

int a=15; int n=fun6(&a);

int a = 15; cout<<(&pf)(a);

cout<<(pf)( 256 );

cout << pf( 256 );

函数指针 int (*pt)(int) 表示pt指向一个函数类型为int,拥有一个int型参数的函数而int *pt(int)则表示pt为函数名，函数返回的是一个int*类型的指针，有一个int型的参数函数指针的使用方式：（1）pt(int) （2)(＊pt)(int) （3）(pt)(int)

57、设有下面的程序段：char s[]＝"china"；char *p＝s，p 和 s 可以随意替换使用

TRUE

FALSE

数组名作为指针是一个常量，不能和变量指针等同

58、对于下面代码段，正确的赋值语句（）

1	`char` `a[5], *p=a;`

p="abcd";

a="abcd";

*p="abcd";

*a="abcd";

A p=“abcd”; P是字符型指针,将“abcd”的地址给了P,也就是P指向“abcd"的首地址,也就是指向‘a'的地址；
B a=“abcd”；a是字符数组的地址,不可赋值；
C *p=“abcd”; *P是字符,不能将字符串赋给它,若是*p='a',则正确. ...

58、c++的一个类中声明一个static成员变量，下面描述正确的是（）

static是加了访问控制的全局变量，不被继承

类和子类对象，static变量占有一份内存

子类继承父类static变量

static 变量在创建对象时分配内存空间

static变量在子类和父类中是相同的，都存储在全局数据区，如果static在子类构建时没有定义，继承就会报错，可以把继承看作父子都有，static只有一份

60、下列程序的运行结果是 YY,78,96，请为横线处选择合适的程序（）

#include <stdio.h>

#include <string.h>

typedef struct {

char name[9];

float score[2];

} STU;

void f(STU _______) {

STU b = {"YY", 78, 96};

int i;

strcpy(a->name, b.name);//不能用引用，只有地址才能这样写，故c不行

for (i = 0; i < 2; i++)

a->score[i] = b.score[i];

}

main() {

STU c = {"LL", 90, 80};

f(&c);

printf("%s,%.0f,%.0f\n", c.name, c.score[0], c.score[1]);

}

a[]

61、下面关于shared_ptr说法错误的有?

一个 shared_ptr 对象实体可被多个线程同时读取

两个 shared_ptr 对象实体可以被两个线程同时写入

多线程读写同一个 shared_ptr对象不需要加锁,因为shared_ptr 对象本身是线程安全的

使用shared_ptr时候最好使用make_shared来分配内存

（shared_ptr）的引用计数本身是安全且无锁的，但对象的读写则不是，因为 shared_ptr 有两个数据成员，读写操作不能原子化。 shared_ptr 的线程安全级别和内建类型、标准库容器、std::string 一样，即：
• 一个 shared_ptr 对象实体可被多个线程同时读取；
• 两个 shared_ptr 对象实体可以被两个线程同时写入，“析构”算写操作；
• 如果要从多个线程读写同一个 shared_ptr 对象，那么需要加锁。
请注意，以上是 shared_ptr 对象本身的线程安全级别，不是它管理的对象的线程安全级别

62、对于以下C++程序代码输出是____。

#include <iostream>

using namespace std;

int main(void)

{

const int a = 10;

int * p = (int *)(&a);

*p = 20;

cout<<"a = "<<a<<", *p = "<<*p<<endl;

return 0;

}

编译阶段报错运行阶段报错

a = 10, *p = 10

a = 20, *p = 20

a = 10, *p = 20

a = 20, *p = 10

在c语言中const所修饰的变量不是真正的常量，只是标明这个变量是只读的，编译期并不会为其生成常量表，通过指针的修改是直接针对变量修改的，两者是同步的。所以如果是c编译，则都会是20。在c++中const变量在编译期会被编译期编译成一张常量表，所有读取常量的操作都会从这个常量表里直接读取，因此输出c永远都是10。

63、【单选】用Struct代替class的时候以下哪些描述是对的?

成员默认是public的

成员默认是private的

成员默认是protected的

没有区别

64、C++语言中提供了哪些代码重用的方式（）

继承

多态

模板

异常处理

65、下面有关C++的类和C里面的struct的描述，正确的有？

在C++中，来自class的继承默认按照private继承处理，来自struct的继承默认按照public继承处理

class的成员默认是private权限，struct默认是public权限

c里面的struct只是变量的聚合体，struct不能有函数

c++的struct可有构造和析构函数

1.c++中，class和struct的区别:
        a.成员访问权限->class的成员访问权限为private,而struct的成员访问权限为public
        b.默认的继承方式->class的默认继承方式为private,而struct的默认继承方式为public
2.struct在C和C++之间的区别
        a.c中，struct是用户自定义数据类型，而c++中，struct是抽象数据类型，支持成员定义函数；
        b.c中的struct是没有权限设置的，但是在c++中，给strcut添加了权限设置，增加了访问权限；
        c.c中的struct只是变量的聚合体，可以封装数据，但是不可以隐藏，不可以定义函数成员；但是C++中的struct可以定义函数成员

66、以下说法正确的是（）

gcc编译.c文件，__cplusplus没有定义，编译器按照c编译代码

gcc编译.cpp文件，__cplusplus有定义，编译器按照c++编译代码

g++编译.c文件, __cplusplus没有定义，编译器按照c编译代码

g++编译.cpp文件，__cplusplus有定义，编译器按照c++编译代码

gcc和g++的主要区别

1. 对于 *.c和*.cpp文件，gcc分别当做c和cpp文件编译（c和cpp的语法强度是不一样的）

2. 对于 *.c和*.cpp文件，g++则统一当做cpp文件编译

3. 使用g++编译文件时，g++会自动链接标准库STL，而gcc不会自动链接STL

4. gcc在编译C文件时，可使用的预定义宏是比较少的

5. gcc在编译cpp文件时/g++在编译c文件和cpp文件时（这时候gcc和g++调用的都是cpp文件的编译器），会加入一些额外的宏

67、在上下文及头文件均正常的情况下，执行下面语句后的输出为

int I = 1;

if(I <= 0)

printf("****\n");

else

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

****

有语法错，不能正确执行

%%%%

printf("%%%%")输出的为%%，而cout << "%%%%" << endl;输出却为%%%%，在c里面printf的%是转义字符，在C++里面不是

68、c/c++中，有关纯虚函数说法正确的是（）

子类中必须覆盖基类的纯虚函数

含有纯虚函数的类不能被实例化

基类的纯虚函数没有函数体

含有纯虚函数的类一定是抽象类

A：错误，子类中不一定要覆盖基类的纯虚函数。存没有实现的纯虚函数，那这个基类是不能实例化的。继承这个基类的子类可以覆盖也可以不覆盖其虚函数。如果基类中的纯虚函数在子类中没有覆盖，那这个子类还是一个虚类，同样不能实例化。

B：正确，纯虚函数产生的目的本身就是不能实例化对象

C：错误，基类的纯虚函数是可以有函数体的。可以有，但没必要~不知道这个选项存在的意义是什么。

D：正确，纯虚函数产生的定义就是抽象类

我们可以为纯虚函数提供定义，不过函数体必须定义在类的外部。若定义在类的内部，会出现错误：pure-specifier on function-definition。

69、循环语句whlie(int i=0 )i--;的循环次数是（）

无限次

70、对于以下结构定义，(*p)->str++中的++加在（）

1	`struct` `{` `int` `len;` `char` `str; } p;`

指针 str 上

指针 p 上

str 指向的内容上

语法错误

p是指针，可以写p->str,但是（*p）只能写(*p).str;

71、下面四个选项中，均是不合法的转义字符的选项是（）

'\'" '\\' '\xf\

'\1011' '\' '\ab'

'\011' '\f' '\}'

'\abc' '\101' 'xlf'

72、在下列运算符中，优先级最高的是（）

运算符优先级顺口溜：单算一笔，俺裸三服（才单算了一笔账，我就脱了三件衣服）

1单：单目运算符；

2算：算数运算符；加、减、乘、除、取余

3一：移位运算符；左移、右移

4笔：比较运算符；等于【==】、不等于【!=】、关系运算符【< > <= >= 】

5俺：按位运算符；按位与(&)，按位或(|)、按位非(~)、按位异或(^)

6裸：逻辑运算符；与【&&】、或【||】、非【！】

7三：三目运算符；b ? x : y，先计算b，然后进行判断。如果b的值为true，计算x的值，运算结果为x的值

8服：赋值运算符。赋值运算符【= += -= *= /= %= >>= <<= &= |= ^=】

73、关于下列操作哪个复杂度为O(1)?

vector中插入元素的最差情况(动态数组)

set中查找元素

hash_map中查找元素

deque尾部删除元素

deque删除尾部元素hash_map底层是hash_table哈希结构则O(1)

set底层是红黑树，时间复杂度就是树高O(log2N)

vector最差是O(N)

74、下面哪几种是 STL 容器（C++ 11及以上）类型（）

vector

set

multivector //multivector 是不同类型数组的集合

multiset

array

75、下面程序输出结果是什么?

#include<iostream>

using namespace std;

class A{

public:

A(char *s)

{

cout<<s<<endl;

}

~A(){}

};

class B:virtual public A

{

public:

B(char *s1,char*s2):A(s1){

cout<<s2<<endl;

}

};

class C:virtual public A

{

public:

C(char *s1,char*s2):A(s1){

cout<<s2<<endl;

}

};

class D:public B,public C

{

public:

D(char *s1,char *s2,char *s3,char *s4):B(s1,s2),C(s1,s3),A(s1)

{

cout<<s4<<endl;

}

};

int main() {

D *p=new D("class A","class B","class C","class D");

delete p;

return 0;

}

class A class B class C class D

class D class B class C class A

class D class C class B class A

class A class C class B class D

加了virtual后派生类B、C成为虚基类，此时在最派生类D中只有一份基类A的成员，如果不加virtual则在D中会有两份基类A中的成员（因为同过B和C都会继承一份A），对A中的成员进行访问容易出现二义性，这正是引出虚基类概念的根本。

成员初始化列表的初始化顺序，是按照他们在定义中出现的顺序进行依次初始化的，而不是按照他们在初始化列表中出现的顺序来初始化的；
本题中初始化的顺序是先A(s1)，其次B(s1,s2)，最后C(s1,s3)；
又因为B和C使用了虚继承，解决了二义性，因为基类A已经初始化过了，即使在B和C继承了它，但初始化他们时不再改变A的结果

76、（C++部分）下列关于对象初始化的叙述中，正确的是:

定义对象的时候不能对对象进行初始化

定义对象之后可以显式地调用构造函数进行初始化

定义对象时将自动调用构造函数进行初始化

在一个类中必须显式地定义构造函数实现初始化

77、若有以下说明，则对n的正确访问语句是（）。

class Y

{

//… ;

public:

static int n;

};

int Y::n;

Y objY;

n=1;

Y::n=1;

objY::n=1;

Y>n

为避免有些解析没写得很清楚误导大家，专门强调一点：类中的静态变量既可以通过类名访问，也可以通过类的对象访问。所以B和C都有可能是正确的，C不正确的原因仅仅是语法写错了，若写成objY.n=1就是正确的。

77、C++类体系中，不能被派生类继承的有?

构造函数

静态成员函数

非静态成员函数

赋值操作函数

“赋值运算符重载函数”不是不能被派生类继承，而是被派生类的默认“赋值运算符重载函数”给覆盖了

78、

在C++中，定义结构体类型struct时，不能定义成员函数，只有class可以定义成员函数。

正确

错误

虽然在字面上struct与class的含义不一样，但在C++中其功能基本是相同的，C++中的struct不仅可以包含数据成员，而且与class一样支持新增的面向对象特性，仅在以下细节上有略微差别。c语言中struct不允许

79、下·下·STL中的哪种结构在增加成员时可能会引起原有成员的存储位置发生改变

map；

set;

list;

vector;

vector是STL中最常见的容器，它是一种顺序容器，支持随机访问。vector是一块连续分配的内存，从数据安排的角度来讲，和数组极其相似，
不同的地方就是：数组是静态分配空间，一旦分配了空间的大小，就不可再改变了；而vector是动态分配空间，随着元素的不断插入，它会按照自身
的一套机制不断扩充自身的容量。
vector的扩充机制：按照容器现在容量的一倍进行增长。vector容器分配的是一块连续的内存空间，每次容器的增长，并不是在原有连续
的内存空间后再进行简单的叠加，而是重新申请一块更大的新内存，并把现有容器中的元素逐个复制过去，然后销毁旧的内存。这时原有指向旧内存空
间的迭代器已经失效，所以当操作容器时，迭代器要及时更新。

其他三个容器是由链表等实现的，增加元素不会引起其他元素位置变化，只需要改变相应指针就可以

80、关于struct和class，下面的说法不正确的是（）

struct的成员默认是public,class的成员默认是private

struct不能继承，class可以继承

struct的成员变量只能是public

class可以有无参构造函数，而struct不可以

struct 能包含成员函数能继承能实现多态和class的区别在于默认访问控制类型不同 struct是public的，class是private 就算把程序中的class全换成struct，程序依然能正常运行。还有另一个很少涉及的区别是:class 可以用于定义模板参数，但是struct不行

81、要求打开文件 d:file.dat，可写入数据，正确的语句是___________

ifstream infile(“d:file.dat”, ios::in);

ifstream infile(“d:\\file.dat”, ios::in);

ofstream infile(“d:file.dat”, ios::out);

fstream infile(“d:\\file.dat”, ios::in| ios::out);

<p>ofstream 写数据;istream读数据;fstream可读可写。</p>

而ifstream则是负责读和打开文件

82、已知：print( )函数是一个类的常成员函数，它无返回值，下列表示中，（）是正确的

void print( ) const;

const void print( );

void const print( );

void print(const);

const（*号）左边放，我是指针变量指向常量； const（*号）右边放，我是指针常量指向变量； const（*号）两边放，我是指针常量指向常量；const在*的左边，则指针指向的变量的值不可直接通过指针改变（可以通过其他途径改变）；在*的右边，则指针的指向不可变。简记为“左定值，右定向”。

83、在C++语言中, %运算符要求运算数必须是整型。是否正确？ .

正确

错误

84.*p++ 自增 p 还是 p 所指向的变量?

自增 p

自增 p 所指向的变量

和机器相关

后缀 ++ 和 -- 操作符本质上比前缀一目操作的优先级高, 因此 *p++ 和 *(p++) 等价, 它自增 p 并返回 p 自增之前所指向的值。要自增 p 指向的值, 使用 (*p)++, 如果副作用的顺序无关紧要也可以使用 ++*p。

85、以下叙述中正确的是( )

在C++中数据封装是通过各种类型来实现的

在C++中，数据封装可以由struct关键字提供

数据封装就是使用结构类型将数据代码连接在一起

数据封装以后，仍然可以不通过使用函数就能直接存取数据

A C++通过类来实现封装性，把数据和与这些数据有关的操作封装在一个类中，或者说，类的作用是把数据和算法封装在用户声明的抽象数据类型中。

B 正确，C++中虽然struct的默认封装类型为public，但是你也可以设置为private的形式，都可以.

C 所有的 C++ 程序都有以下两个基本要素：

程序语句（代码）：这是程序中执行动作的部分，它们被称为函数。
程序数据：数据是程序的信息，会受到程序函数的影响。

封装是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念(并不是单纯将数据代码连接起来，是数据和操作数据的函数.)，这样能避免受到外界的干扰和误用，从而确保了安全。

D 正确一般情况好像是不允许的. 但是如果你用一些比较骚的方法. 前提要你知道一个类的结构分布，比如让你访问类中虚函数表的内容，你就可以先取到类的首地址，把指针强转成int*，通过你了解到的结构定位到虚函数表的地址，这样你就能访问到虚函数表里面的元素，当然这些的前提都是你对这个类的结构相当了解. 一般不推荐使用，因为做法比较bug.

86、一个最简单的C++程序，可以只有一个（）？

库函数

自定义函数

main函数

空函数

87、在上下文及头文件均正常的情况下，字符串"Hello"会被输出几次?

int main() {

printf("Hello");

fork();

printf("Hello");

}

1.fork()函数会把它所在语句以后的语句复制到一个子进程里，单独执行。
2.如果printf函数最后没有"\n"，则输出缓冲区不会被立即清空，而fork函数会把输出缓冲区里的内容也都复制到子进程里。
所以，父进程和子进程各输出2个Hello，共4个。
如果第一个printf("Hello");写成printf("Hello\n");，则只会输出3个Hello，父进程2个，子进程1个

88、要求用成员函数重载的运算符是（）。

直白的说，重载操作符分为类内重载（声明为类的成员函数）和类外重载（声明为普通的非成员函数）。写法上有什么区别？比如要实现把值赋给对象，类内重载操作符要放在对象的右边。而类外重载操作符要放在对象的左边。我们在赋值的时候都是把右侧的内容赋值给左侧，如果写成类外重载就反过来了不符合逻辑习惯，也会造成定义的二义性。因此=、()、[]、->、new、delete需要类内实现。
89、math.h的abs返回值()

不可能是负数

不可能是正数

都有可能

不可能是0

num为0或正数时，函数返回num值；

当num为负数且不是最小的负数时（不要问我最小的int类型负数是多少，上面那个图里面有真相），函数返回num的对应绝对值数，即将内存中该二进制位的符号位取反，并把后面数值位取反加一；

当num为最小的负数时（即0x80000000），由于正数里int类型32位表示不了这个数的绝对值，所以依然返回该负数。

90、在下列关于类型转换的描述中，错误的是（）

任何形式的构造函数都可以实现数据类型转换。

带非默认参数的构造函数可以把基本类型数据转换成类类型对象。

类型转换函数可以把类类型对象转换为其他指定类型对象。

类型转换函数只能定义为一个类的成员函数，不能定义为类的友元函数。

91、在C++语言中，下列说法正确的是：

编译器会将inline修饰的函数的函数体直接插入到调用此函数的地方，以此加快程序的运行速度

局部变量和全局变量不能重名

静态局部变量内存是在运行期分配的，存储在静态区

C++不是类型安全的语言

92、对于类Value，下面运算符重载的写法错误的是（）

Value operator-(Value, Value)

Value operator+(Value)

Value operator*(int)

Value operator/(Value)

这道题最开始做的时候忽略了“类value”这个条件，当在类中，说明重载为成员函数，成员函数有一个this指针，也就是已经有了一个参数，所以重载单目运算符时，不需要参数，重载双目运算符时，只需要一个参数 ...

93、以下程序运行后的输出结果是（）

int main() {

int a=1,b=2,m=0,n=0,k;

k=(n=b<a)&&(m=a) ;

printf("%d,%d\n",k,m);

return 0;

}

0,0

0,1

1,0

1,1

94、若要重载+、=、<<、==和[]运算符，则必须作为类成员重载的运算符是

+和=

=和<<

＝＝和<<

＝和[]

(1)只能使用成员函数重载的运算符有：=、()、[]、->、new、delete

95、有如下程序，输入数据：12345M678＜CR＞后（<CR>表示回车），x的值是（）

#include<stdio.h>

int main(){

int x;

float y;

scanf("%3d%f", &x, &y);

return 0;

}

12345

123

345

scanf确实可以设置输入整数的宽度，%3d表示取三位整数；

printf也可以设置输出整数的宽度，%3d表示输出至少3位，假如超过3位，有多少输出多少。

96、

关于纯虚函数，下列表述正确的是？（）

派生类必须实现基类的纯虚函数

纯虚函数的声明总是以"=0"结束

纯虚函数是给出实现版本（即无函数体定义）的虚函数

含有纯虚函数的类一定是派生类

(a), 派生类不一定需要实现，只要需要派生类的实现object的时候才需要实现。

(c), 纯虚函数是需要在该类下不实现而在派生类中实现的函数

(d), 含有纯虚函数的类一定是基类，需要派生类来实现其虚函数的功能

97、数组a的定义为：int a[3][4]; 下面哪个不能表示 a[1][1] ?

*(&a[0][0]+5)

*(*(a+1)+1)

*(&a[1]+1)

*(a[1]+1)

选项A，很容易判断选项B，*(a+1) == a[1] == a[1][0]的地址, *(*(a+1)+1) == a[1][0] 选项C，&a[1]+1,因为&a[1]指向第1行这个1*4的一维数组，&a[1]+1则指向第2行这个二维数组，所以*(&a[1]+1) == a[2],为第2行的地址选项D，a[1] == &a[1][0], *(a[1]+1) == a[1][0]

98、

有以下类定义

#include <iostream>

using namespace std;

class shape {

public:

virtual int area()=0;

};

class rectangle:public shape {

public:

int a, b;

void setLength (int x, int y) {a=x;b=y;}

int area() {return a*b;}

};

若有语句定义rectangle r; r.setLength(3,5); 则编译时无语法错误的语句是（）

shape *s1=&r;

shape &s2=r;

shape s3=r;

shape s4[3];

cd错误的原因在于抽象类无法实例化

98、

下面程序运行结果为（）

int main() {

char c = 'a'；

if ('a' < c <= 'z') printf("Low”)；

else printf("UP")；

}

LOW

LOWUP

程序语法错误

【解释】关系运算符具有左结合性，所以表达式（’a'<c<=’z’)将先求’a'<c的值，即为

0（假），再求0<=’z’的值，即为1（真），所以执行if后面的语句printf（"LOW");故正确

答案为A。

99、

下列代码可以通过编译吗？如何修改使其通过编译？

template <class T>

struct sum {

static void foo(T op1 , T op2){

cout << op1 <<op2;

}

};

sum::foo(1,3);

编译通过

应该去掉static关键字

调用应该如下： sum<int>:: foo(1,3)

调用应该如下： sum:: <int>foo(1,3)

这道题的考点是类模板的static成员。首先说说模板实例化，即类模板需要指定确定的类型，例如本题中sum<int> a或者sum<string> a等。 static成员函数可以由类名或者对象直接调用。在本题中，sum<int> a；a.foo(1,3)或者sum<int>::foo(1,3)。两种形式均可。

100、

#include <iostream>

using namespace std;

struct A{

A(){cout<<"A::A"<<endl;}

~A(){cout<<"A::~A"<<endl;}

};

struct B:public A{

B(){cout<<"B::B"<<endl;}

~B(){cout<<"B::~B"<<endl;}

};

int main(){

A* a= new B;

delete a;

}

A::A B::B B::~B A::~A

A::A B::B A::~A B::~B

A::A B::B A::~A

A::A B::B B::~B

由于A的析构函数不是virtual的，并且a是一个类型A的指针，所以只会调用A的析构函数而不是B的析构函数，结果输出A::~A
101、

对于一维整形数组 a ，以下描述正确的是（）

int a(10)

int n=10,a[n]

int n scanf(“%d”, &n) int a[n]

#define SIZE 10 int a[SIZE]

这种数组的大小是需要在编译时确定的，但n的值是运行时才得到的，n是个变量随着程序运行可变，这样只能采用动态分配的方法进行，用new或者malloc。注意不管啥语言，数组定义中等号左边括号内如果有则必须为常数，如果是变量n，那后面对n进行修改导致冲突，变量可改但数组长度不能改
102、

假定CSomething是一个类，执行下面这些语句之后，内存里创建了____个CSomething对象。

CSomething a();

CSomething b(2);

CSomething c[3];

CSomething &ra = b;

CSomething d = b;

CSomething *pA = c;

CSomething *p = new CSomething(4);

CSomething a()；// 没有创建对象，这里不是使用默认构造函数，而是定义了一个函数，在C++ Primer393页中有说明。 CSomething b(2);//使用一个参数的构造函数，创建了一个对象。 CSomething c[3];//使用无参构造函数，创建了3个对象。 CSomething &ra=b;//ra引用b，没有创建新对象。 CSomething d=b;//使用拷贝构造函数，创建了一个新的对象d。 CSomething *pA = c;//创建指针，指向对象c，没有构造新对象。 CSomething *p = new CSomething(4);//新建一个对象。 //综上，一共创建了6个对象。个人理解，如有错误，还请大神指出

103、下面哪种C/C++ 分配内存的方法会将分配的空间初始化为0

malloc()

calloc()

realloc()

new[ ]

calloc申请内存空间后，会自动初始化内存空间为 0，但是malloc不会进行初始化，其内存空间存储的是一些随机数据。

104、

对于C++， struct T {}，sizeof(struct T)的值为（）

编译或运行期错误

C++语言中的确规定了空结构体和空类所占内存大小为1，而C语言中空类和空结构体占用的大小是0。

105、

以下能正确定义一维数组的选项是（）

int a[5]={0,1,2,3,4,5};

char a[]={0,1,2,3,4,5};

char a={'A','B','C'};

int a[5]="0123";

B中的数据其实是ascll码，可以用整型来表示字符

106、

下面说法正确的是（）

在C++语言中new和malloc都是在堆（heap）上进行动态的内存操作，可以互相代替。

C++语言重载（over load）是指子类重新定义父类的虚函数的方法。

C++语言函数既可以嵌套定义又可以递归调用。

在C++语言中调用函数时，只能把实参的值传给形参，形参的值不能传送给实参（不考虑引用、指针等情况）。

参考答案：答案：D A，关键字new和malloc都是在堆（heap）上进行动态的内存申请，但是内存释放不同，new申请的内存用delete释放，malloc申请的内存用free释放，因此不能代替 B，子类重新定义父类的虚函数的方法这种叫覆盖，override C，函数不能嵌套定义，也就是函数内部不能定义函数

107、

在下列表达式选项中，正确的是（）

++(a++)

a++b

a+++b

a++++b

A错误，因为a++操作通过临时量返回其值，该值是一个常量，因此不能被修改（不是左值），而后缀++需要对左值进行操作，所以会引起编译错误。

所谓的左值，说通俗一点就是可以被修改和引用的值，左值可以取地址。与之相对的就是右值。在使用时，左值可以作为右值，但右值不能作为左值。

108、

以下程序打印的两个字符分别是？

#include<stdio.h>

#include<iostream>

using namespace std;

typedef struct object object;

struct object {

char data[3];

};

int main(void) {

object obj_array[3] = {{'a', 'b', 'c'}, {'d', 'e', 'f'}, {'g', 'h', 'i'}};

object *cur = obj_array;

printf("%c %c\n", *(char *)((char *)(cur) + 2), *(char *)(cur + 2));

return 0;

}

c g

b d

g g

g c

*(char*)(cur+2)),cur的类型是object*,那么cur+2就是加两个obect的大小，就是6，因此是g

109、

下面关于类和对象的描述中，错误的是：

类就是C语言中的结构体类型，对象就是C语言中的结构体变量

类和对象之间的关系是抽象和具体的关系

对象是类的实例，一个对象必须属于一个已知的类

类是具有共同行为的若干对象的统一描述体

类是属性与方法的封装体，而结构只有数据没有方法。哪怕是class A{ int a; }这样一个类，看似没有方法，但它却有默认的构造方法public A(){}

结构体是一种特殊的类，但是并不具备类的一些特性，例如继承、重载、多态

110、

构造函数的名字必须与类名相同，其返回类型缺省为void类型。

正确

错误

构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。

111、

下面有关static类变量和实例变量的描述，正确的有？

static类变量又叫静态成员变量，它不需要创建对象就可以已经在内存中存在了

在创建实例对象的时候，内存中会为每一个实例对象的每一个非静态成员变量开辟一段内存空间，用来存储这个对象所有的非静态成员变量值

static类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果

实例变量则属对象私有，某一个对象将其值改变，不影响其他对象

112、下面哪一个不是动态链接库的优点？

共享

装载速度快

开发模式好

减少页面交换

1 静态链接库的优点

(1) 代码装载速度快，执行速度略比动态链接库快；

(2) 只需保证在开发者的计算机中有正确的.LIB文件，在以二进制形式发布程序时不需考虑在用户的计算机上.LIB文件是否存在及版本问题，可避免DLL地狱等问题。

2 动态链接库的优点

(1) 更加节省内存并减少页面交换；

(2) DLL文件与EXE文件独立，只要输出接口不变（即名称、参数、返回值类型和调用约定不变），更换DLL文件不会对EXE文件造成任何影响，因而极大地提高了可维护性和可扩展性；

(3) 不同编程语言编写的程序只要按照函数调用约定就可以调用同一个DLL函数；

(4)适用于大规模的软件开发，使开发过程独立、耦合度小，便于不同开发者和开发组织之间进行开发和测试。

113、

在下列选项中，用于清除基数格式位设置以十六进制数输出的语句是（）

cout << setf(ios::dec, ios::basefield);

cout << setf(ios::hex, ios::basefield);

cout << setf(ios::oct, ios::basefield);

cin >> setf(ios::hex, ios::basefield);

正确答案：B

官方解析：

cout 的 setf 表示设置输出基数格式，D 选项错误。

ios::dec 表示 10 进制，A 选项错误。

ios::oct 表示 8 进制，C 选项错误。

ios::hex 表示 16 进制，B 选项正确。

114、c/c++中，关于类的静态成员的不正确描述是（）

静态成员不属于对象，是类的共享成员

c++11之前，非const的静态数据成员要在类外定义和初始化

静态成员函数不拥有this指针，需要通过类参数访问对象成员

只有静态成员函数可以操作静态数据成员

在C++11之前，非const的静态数据成员必须在类的定义外部进行定义和初始化。

在C++11及之后的标准中，我们可以在类的定义内部进行静态数据成员的初始化

115、

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

a.operator++(1)

operator++(a)

operator++(a，1)

a.operator++()

++a，运用成员函数调用方式为：a.operator++()

重载后缀a++: operator++(int)运用成员函数调用方式为：a.operator++(1)

116、

有以下程序

#include<iostream>

using namespace std;

____________________

int main() {

int a=1,b=2,c=3;

cout<<add(a,b,c);

return 0;

}

int add(int x,int y,int z) { return x+y+z; }

程序运行的结果是6，横线处合适的程序是（）

int add(int x,int y=5,int z=6);

int add(int x=1,int y=5,int z);

int add(int x=1,int y,int z=6);

int add(int x=1,int y=5,int z=6);

默认实参作为形参的初始值出现在形参列表中。我们可以为一个或多个形参定义默认值，不过需要注意一点的是，一旦某个形参被赋予了默认值，它后面的所有形参都必须有默认值；

117、

该函数参数为1时返回值为（）

int GetResult(int a){

int b = 0;

__try{

if ( a != 0 ){

b++;

}

return b;

}

__finally{

--b;

}

return b;

}

-1

finally块中的代码会执行，但是try中已经返回了，所以返回b=1;

返回后，执行finally中的代码--b，b=0;

但是finally后面的代码return b不执行。所以返回还是1;但是此时b=0，如果finally有return b，则放回的是0

118、

对C++中重载（overload）和重写（override）描述正确的有（）

重载是指在同一个类或名字空间中存在多个函数，它们的函数名相同，而函数签名不同

重写是指在子类中实现一个虚函数，该虚函数与其父类中的一个虚函数拥有同样的函数签名

虚函数不可以重载

构造函数可以重载，析构函数可以重写

119、

关于虚函数的说法,哪些是正确的

构造函数中调用该类的虚函数，动态绑定机制会生效

静态函数不可以是虚函数

虚函数可以声明为inline

构造函数和析构函数都可以声明为虚函数

B. 静态函数不能被声明为虚函数。虚函数是通过对象的指针或引用来调用的，静态函数与具体的对象无关，因此不能定义为虚函数。

C. 虚函数不可以是内联函数，因为内联函数要在编译期间展开，那样多态性就无法实现。但是虚函数可以声明为inline，这只是一个建议，编译器不会展开它。

A. 在类的构造函数中，调用虚函数，也是静态绑定(构造函数中调用其它任何函数,都不会发生动态绑定)。也就是说在有对象之前是不能发生动态绑定的，构造函数执行完才能生成对象；

其次，如果不是通过指针或者引用变量来调用虚函数，而是通过对象来调，那就是静态绑定。

D. 构造函数可以被声明为虚函数，但是析构函数通常被定义为虚函数以确保在删除指向派生类对象的基类指针时动态绑定正确的析构函数。

120、

C++中的拷贝构造函数在下面哪些情况下会被调用（）

对象创建的时候

使用一个类的对象去初始化该类的一个新对象

被调用函数的形参是类的对象

当函数的返回值是类的对象时，函数执行完成返回调用者

121、

在32位机器中，如下代码：

void example(char acWelcome[]){

printf("%d", sizeof(acWelcome));

return;

}

void main(){

char acWelcome[] = "Welcome to Huawei Test";

example(acWelcome);

return;

}

的输出是?

数组名作实参，调用函数时把数组的首地址传递给形参。此时，计算sizeof(数组名)，计算的是地址的大小，即4

122、

在C语言中，以下代码执行之后，*p的值为（）

void func(int *p){

static int num = 4;

p = &num;

(*p)--;

}

int main(){

int i = 5;

int *p = &i;

func(p);

printf("%d", *p);

return 0;

}

以上都不是

传入的是形参P,当函数结束后悔自动销毁,所以还是5,当传入的是&p,函数用**p接收,那就不一样了

123、

以下关于抽象类的说法正确的有

抽象类只能用作其他类的基类

不能使用抽象类定义对象

抽象类不能用作参数类型、函数返回类型或显式转换的类型

抽象类不能有构造函数和析构函数

124、

下列哪段代码是实现在一个vector中查找匹配值value并删除：

for (std::vector::iterator iter = numbers.begin(); iter != numbers.end(); ++iter) { if (*iter == value) { numbers.erase(iter); } }

erase：删除当前元素，并自动指向下一个元素 A：erase删除后，指向下一个元素，再进行++it，会漏掉一个元素没有判断

for (std::vector::iterator iter = numbers.begin(); iter != numbers.end(); ++iter) { if (*iter == value) { numbers.erase(iter); iter--; } }

for (std::vector::iterator iter = numbers.begin(); iter != numbers.end();) { if (*iter == value) { iter = numbers.erase(iter); } else { ++iter; } }

以上代码都不对

125、

下面代码段输出为（）

#include <stdio.h>

int i;

int main(){

for(i = 0;i < 3;i++){

switch(i){

case 0: printf("%d", i);

case 2: printf("%d", i);

default: printf("%d", i);

}

000111

000020

000102

000122

case 只起到标号作用，并不能进行判断。因此一旦于 switch 中的匹配，就从对应的标号开始执行，并且再没有 break 的情况下继续执行下一个 case 以及 default 的语句

126、

设fp已定义,执行语句fp=fopen("file","w");后,以下针对文本文件file操作叙述的选项错误的是:

可以随意读和写

只能写不能读

可以在原有内容后追加写

写操作结束后可以从头开始读

open(“file”,”w”)打开文件，并赋值为“w”权限，即写权限，则B正确，A错误，因为这里不具有读权限；对于C的解释：用“w”打开的文件只能向该文件写入。若打开的文件不存在，则以指定的文件名建立该文件，若打开的文件已经存在，则将该文件删去，重建一个新文件。所以C错误；对于D的解释："w+"可以从头开始读。但是"w"却没有此描述

127、

下列语句中错误的是（）

int *p = new int(10);

int *p = new int[10];

int *p = new int;

int *p = new int[40](0);

1给某一个变量赋予初值，则可使用()，如a选项; 2.给某数组赋予初值时，则不能使用()，而应该要用中括号就像 int a[5]={1,3,5,7,9}，即int *p=new int[40]{0}。

爱编程的小白菜

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
c++笔试题（自我纠查）

参考答案：AD 浮点数和位运算：所有的位运算都不能直接操作浮点数，这就是A和D错的原因，但是，我们可以间接对浮点数进行位运算，例如，将float数据，取地址(&)强行转化为整型(int等)指针后，再取值(*)后赋值给整型变量(int等)，然后就能对该变量进行位运算了。语句“MyClass *p[5]”定义了5个指向MyClass对象的指针变量，分别为*p[0]，*p[1]，*p[2]，*p[3]，*p[4]，但定义指针并没有实例化对象，所以不调用构造函数。即结构体中的成员变量的地址必须是4的整数倍。
复制链接

扫一扫