迅雷招聘笔试题总结C++西安

最新推荐文章于 2021-03-12 16:15:29 发布

pa_miao_chi

最新推荐文章于 2021-03-12 16:15:29 发布

阅读量818

点赞数 1

分类专栏：笔试面试

本文链接：https://blog.csdn.net/chenjieyujiayou/article/details/77211684

版权

笔试面试专栏收录该内容

13 篇文章 1 订阅

订阅专栏

1.有变量int i=0; int a = i++; int b = ++a; int c = a+b; 请问表达式a?b:c的值为：(B)

A 0 B.1 C.2 D.3

分析：i=0; a = i++======>a = 0;

b = ++a======>b=1, a = 1;

a?b:c====>a 是1为真，取b的值 b=1;

代码验证：

2.32位环境下，int *p = new int[10]; 求sizeof(p)

sizeof(p) = 4;

解析：不要被这个整型数组迷惑，p 是一个指针，在32位操作系统上是4个字节

3.有语句char str[] = "abcde"; 请问表达式sizeof(str) = 多少？

解析：题目考察的是sizeof 和 strlen 的区别

sizeof(str) 包括\0

strlen(str) 不包括\0

所以sizeof(str) = 6;

4.有函数int func(int i)的实现为：

int func(int i)
{
    if(i > 1)
    return i*func(i-1);
    else
    return 1;
}

求fun(5)的返回值

这种递归的求法，我们可以用下面这种比较容易理解的方法来做：

其实本题就是在求 5！ = 5＊4＊3＊2＊1 = 120

5.请问下列哪个是正确的：

A 每个类都有一个无参数的构造函数

B.每个类都有一个拷贝构造函数

C.每个类都有多个构造函数

D.每个类能有多个析构函数

解析：

A 不一定，如果给一个有参数的构造函数的话，就没有无参数的构造函数，构造对象时调的也是有参数的构造函数

B.B在这里是有争议的，单例模式的拷贝构造函数是私有的，不能用，但是它也是可以存在的

C.构造函数可以重载

D.一个类只能有一个析构函数

6.用class 定义的类，其成员默认的访问属性为私有

7.类的成员有三种访问属性，分别是public, private, protected ,子类能够访问的成员是：protected 和 public

8.对一个排好序的数组进行查找，时间复杂度为（O（logn））

解析：对一个排好序的数组进行查找，用二分查找的方法，时间复杂度为O（logn）

9.二叉树的后序遍历的结果为：

后序遍历的顺序为左，右，根

所以顺序为：丙，丁，乙，己，戊，甲

10.

A ＊pa = new A[10];
delete pa;

类A的构造函数和析构函数分别执行了多少次？

构造函数执行了10次，析构函数执行了1次

代码验证：

11.看以下代码：

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

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

int main()
{
	A *pa = new B();
	delete pa;
}

执行结果：

12.文件长度是一个大于0 的整数，用变量unsigned file length 来表示，把文件分成块，每块的长度也是一个大于0 的整数，用变量unsigned block_length 来表示，则文件被分为的块数为（）

A file_length/block_length

B. file_length/block_length+1

C.(file_length+block_length-1)/block_length

D.(file_length-1)/(block_length+1)

分析：

如果file_length = 101, block_length = 10 则需要分11块

A 选项不符合，A选项就会被分成11块

如果file_length = 100, block_length = 10, 则需要分成10块

B选项不符合， B选项就会分成11块，多分一块

C.如果file_length = 101, block_length = 10,

(101+10-1)/10 = 11块

如果file_length = 100, block_length = 10;

(100+10-1)/10 = 10块

C符合题义

D如果file_length = 101, block_length = 10,

(101-1)/（10+1） = 9块

如果file_length = 100, block_length = 10;

（100-1）／（10+1） = 9块

D不符合

所以遇到这一类题先不要懵，用个实际的数字带入，就会很简单

13.整数int i=0xFE78DA45; int k = 0xAC3189B2, 求i ^ k 的值

首先将i 和 k 转化为二进制

i : 0xFE78DA45

1111 1110 0111 1000 1100 1010 0100 0101

k:0xAC3189B2

1010 1100 0011 0001 1000 1001 1011 0010

求i^k

0101 0010 0100 1001 0101 0011 1111 0111

再转化为十六进制

0x5 2 4 9 5 3 f 7

所以这个题的诀窍就是认真～～～认真～～～认真

14.看以下代码：（这种题型我还没有见过，需要重视）

#include<string.h>
class parent
{
public:
	virtual void output();

};

void parent::output()
{
	cout<<"parent"<<endl;
}
class son:public parent
{
public:
	virtual void output();
};


void son::output()
{
	cout<<"son"<<endl;
}

int main()
{
	son s;
//	memset(&s, 0, sizeof(s));
	parent &p = s;
	p.output();
}

首先看一下没有memset 的执行结果：

加上memset之后的执行结果：

解析：经过memset 初始化之后，就会摧毁虚表指针，所以程序运行错误

15. 函数的局部变量所需空间，是在哪里分配的？

进程的栈上

16.以下STL容器存放数据，哪个肯定是排序好的？(D)

A vector B deque C. list D map

17.int a[][3] = {{1}， {3, 2}, {6, 7, 8}, {9}};

a[2][1] 的值为：7

1 0 0

3 2 0

6 7 8

9 0 0

18.以下关于头文件：B

A.#include<filename.h>,编译器寻找头文件时，会从当前编译的源文件所在的目录下去找

B.#include"filename.h" 编译器寻找头文件时，会从通过编译选项指定的目录中去找

C.多个源文件同时用到的全局变量，它的声明和定义都放在头文件中，是好的编程习惯

D.在大型项目开发中，把所有自定义的数据类型，全局变量，函数声明都放在同一个头文件中，各个源文件就只需要包含这个头文件即可，省去了要写很多#include语句的麻烦，是好的编程习惯

解析：A.<>是编译器从根目录下开始查找库里面的文件

C.全局变量的声明放在头文件中，全局变量的定义放在源文件中，要把声明和定义分开

D.不同源文件的头文件最好分开写

19, 某棵完全二叉树上有699个节点，则该二叉树的叶子节点数为：

解析：

二叉树上有度为0（n0），度为1（n1），度为2(n2) 的节点,总节点个数为N

n0+n1 + n2 = N

n0 = n2 + 1;

在完全二叉树中，n1 = 0, 或者 n1 = 1;

n1 = 1=====>N为偶数

2＊n0-1+n1 = N

n0 = N / 2;

n1 = 0=====>N为奇数

2＊n0 = (N+1)/2

所以该题为：

n0 = 350

20. 有一个指向字符串的指针 char *p_str, 要把字符串中的第4个字符的值改为‘a’, 正确的做法是： C

A. p_str[3] = "a" Bp_str[4] = 'a' C.*(ptr+3) = 'a' D *(ptr+4) = "a"

21.以下排序算法，哪个算法的平均复杂度和最坏情况下的复杂度都为O（nlogn）堆排序

关于各种排序算法的实现以及时间复杂度和空间复杂度的专题帖我会在后面专门总结

22.下面关于单向链表，哪个不正确？B

A.在单向链表中查找某个元素的时间复杂度为O（n）

B.为了减少从单向链表中查找元素的时间复杂度，可以先把链表排序

C把单向链表改造成循环链表并加上头节点后，使用链表的代码会更加整洁

D.如果需要频繁查找，用数组比用单向链表好

解析：

A.因为要从头节点开始一个一个往后查找，所以时间复杂度为O（n）

B.链表排序之后，查找元素的时间复杂度还是为O（n）, 所以B不正确

C.加上头节点之后，链表的操作就会简单，代码也会简洁

D.数组查找的时间复杂度为O（1），所以查找的速度比链表要快的多

23. ipv6 中ip 地址的位数为：128位

24.以下代码，哪个是正确的

A. const char *str = "abc"; (正确)

B.char str[5] = {"a", "b"}; (字符串的话应该改为char *str[5] = {"a", "b"})

C. char str[4] = {"abcd", "efg"}; (错误：“abcd”越界)

D.char str[10]; str = "abc" (错误，不能对数组直接赋值)

25. 有编号为1，2，3，4，5，6 的六辆列车，需按顺序开入栈式结构的站台， 6辆列车中的一部分列车入栈后，就可以让入栈的列车出栈一部分，再让其余未入栈的列车继续入栈，已经出栈的列车不能再入栈，下面哪个是可能的出栈顺序

A 125346

B.435612

C.154623

D.134526

A中3不可能在4的前面出栈

B中1 不可能在2的前面入栈

C中2不可能在3的前面出栈

D.正确

26.要求函数的功能是交换X 和 y 中的值，能完成此功能的函数是：D

A void funa(int *x, int *y)

{int *p; *p = *a, *x = *y; *y = *p;} 交换形参的值，对实际参数无影响

B void funb(int x, int y)(int t; t = x; x = y; y=t):值传递，不会交换两个数的值

C.func(int *x, int *y, ){ *x = *y; *y = *x} 两个都是y 的值

D.fund(int *x, int *y){*x = *x+*y; *y = *x- *y; *x = *x - *y;}可以完成，相当与a = a+b; b = a-b; a = a-b;

27.int (*p)[3]: 这句话的含义是：

首先它是一个指针，其次是一个数组指针， p是一个指向具有三个元素数组的指针

28. 使用操作系统提供的socket API 在一个已经建立好的TCP连接上发送数据，

int send_bytes = send(socket_ptr, buffer_ptr, 1024, 0);

在send 函数返回后，且返回值为1024，以下说法中正确的是(D)

A.buffer_ptr所指向的1024个字节数据，已经成功发送到对端计算机了，且已经收到了对端计算机的tcp ack 包

B.buffer_ptr 所指向的1024个字节数据，已经成功发送给对端计算机了，但是还没有收到对端计算机的tcp ack 包

C.buffer_ptr 所指向的1024个字节数据，已经成功发送给本端计算机所连接的路由器了，但不一定到达了对端计算机

D buffer_ptr 所指向的1024个字节的数据，不一定成功发送给网络了，有可能还在本端计算机系统的协议缓冲区中，没有发送

29. 假设32位操作系统下，有unsigned short *p = 0x10000000; 那么p+1 之后，p 的值为（0x10000002）

解析：移动一位是移动指针所指类型的字节数

30. 函数调用exec((x1, x2, x3), (x3, x4, x5), x6, x7),实参的个数为 4，（x1, x2, x3）为逗号表达式

填空题和编程题我下一篇再写啦～～～

pa_miao_chi

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
迅雷招聘笔试题总结C++西安

1.有变量int i=0; int a = i++; int b = ++a; int c = a+b; 请问表达式a?b:c的值为：(B)A 0 B.1 C.2 D.3分析：i=0; a = i++======>a = 0; b = ++a======>b=1, a =
复制链接

扫一扫