互联网公司笔试常见陷阱

最新推荐文章于 2022-12-13 17:59:52 发布
最新推荐文章于 2022-12-13 17:59:52 发布
阅读量2.3k 收藏 2
点赞数
分类专栏： C++


陷阱分类：

（1）指针与字符串

7.   阅读下面代码，程序会打印出来的值是（D）------------------------------(腾讯2014实习生笔试)

[cpp] view plain copy
  1. void f(char **p)  
  2. {  
  3.     *p += 2;  
  4. }  
  5. void main()  
  6. {  
  7.     char *a[] = { “123”,”abc”,”456”};  
  8.     f(a);  
  9.     printf(“%s\r\n”,*a);  
  10. }  

A.123   B.   abc  C.  456  D.  3

 

[cpp] view plain copy
  1. void fun1(char **p)  
  2. {  
  3.     *p+=2;  
  4.     cout<<(int)(*p)<<endl;//输出*p保存的地址  
  5. }  
  6.   
  7. void fun2(char *p)  
  8. {  
  9.     p+=2;  
  10. }  
  11.   
  12. int main()  
  13. {     
  14.     char *r[]={"123","234","456"};  
  15.     fun1(r);  
  16.     cout<<int(*r)<<endl; //输出*r保存的地址  
  17.      char *r1="1234";  
  18.     fun2(r1);  
  19.     cout<<*r<<endl<<r1;   
  20.     return 0;  
  21. }  

      图1
从上图1的红框中可看出，*p和*r保存的地址相同，也就*p和*r指向同一地址,如图2所示，*p和*r也就是p1

图2

 

[cpp] view plain copy
  1. void fun1(char **p)  
  2. {  
  3.     p++;  
  4.     *p+=2;  
  5. }     
  6. int main()  
  7. {     
  8.     char *r[]={"123","234","456"};  
  9.     fun11(r);  
  10.     cout<<*r<<endl<<*(r+1);  
  11.     system("pause");  
  12.     return 0;  
  13. }  

       运行结果为图3， 结合上面的程序和图2所示，P++后，p指向p2,*p+=2后，p2指向4，在主函数中，r就是p1，p1未变所以第一行输出123，（r+1）指向p2,p2已被更新，指向4，所以第二行输出4。


图3

8 下面C++程序的输出是（B）//---------------------------------------阿里2014实习生笔试

[cpp] view plain copy
  1. void f1(char *p)  
  2. {  
  3.     p++;  
  4.     *p='a';  
  5. }  
  6. int main()  
  7. {  
  8.     char a[sizeof("hello")];  
  9.     strcpy(a,"hello");  
  10.     char *a1=a;  
  11.     f1(a);  
  12.     cout<<a<<endl;  
  13.     return 0;  
  14. }  

A hello   B hallo  C allo   D以上都不是

         如图4所示程序中的a用图4中的r表示，p其实只是a的一个副本，p++后，p指向e，将e用a覆盖。但r任然指向H。所以cout<<a,结果是hallo。

 

图4

       若将p改成指针的引用，程序如下所示，则p和r是同一变量，p只不过是r的别名，对p操作即是对r操作。所以有图5的结果。

[cpp] view plain copy
  1. void f1(char *p)  
  2. {  
  3.     p++;  
  4.     *p='a';  
  5. }  
  6. void f2(char *&p)  
  7. {  
  8.     p++;  
  9.     *p='a';  
  10. }  
  11. int main()  
  12. {  
  13.     char a[sizeof("hello")];  
  14.     strcpy(a,"hello");  
  15.     char *a1=a;  
  16.     f1(a);  
  17.     cout<<a<<endl;  
  18.     strcpy(a,"hello");  
  19.     a1=a;  
  20.     f2(a1);  
  21.     cout<<a1<<endl;  
  22.     system("pause");  
  23.     return 0;  
  24. }  

图5

     另外，若主函数改成如下形式，则，运行出错，无输出，因为指针指向的字符串是常量，不可更改。

[cpp] view plain copy
  1. int main()  
  2. {  
  3.     char *a="hello";  
  4.     f1(a);  
  5.     cout<<a<<endl;  
  6.     return 0;  
  7. }<span style="font-size:18px;"></span>  

无输出错误为图6：

图6

 

9.   现在有以下两个函数，调用test的结果是（B）  //-----------------------腾讯2014实习生笔试

[cpp] view plain copy
  1. char* getMem(void)  
  2. {        
  3.     Char * p = “hello world ”;  
  4.     P[5] = 0x0;  
  5.     Return p;  
  6. }  
  7. void test(void)   
  8. {        
  9.     char *s = 0x0;  
  10.     s = getMem();  
  11.     Printf(s);  
  12. }  

A.  hello   B. 无输出  C.  Hello0world   D.  不确定

 此题也将出现图6的结果，因为指针指向的字符串，是常量。只读不可写。

（2）虚函数与多态性、构造函数与析构函数

9 在32位环境下，以上程序的输出结果是（2014）//-----------------------腾讯2014实习生笔试

[cpp] view plain copy
  1. class Base  
  2. {  
  3. public:  
  4.     virtual int foo(int x){return x*10;}  
  5.     int foo(char x[14]){return sizeof(x)+10;}  
  6. };  
  7. class Derived:public Base  
  8. {  
  9.     int foo(int x){return x*20;}  
  10.     virtual int foo(char x[10]){return sizeof (x)+20;}  
  11. };  
  12. int main(void)  
  13. {  
  14.     Derived  stDerived;  
  15.     Base * pstBase=& stDerived;  
  16.     char x[10];  
  17.     printf(“%d\n”,pstBase->foo(100)+pstBase->foo(x));  
  18.     return 0;  
  19. }  

 

--------------------------------------------2014腾讯实习生笔试题

[cpp] view plain copy
  1. class Base  
  2. {  
  3. public:  
  4.     Base(){cout << "Base Construction"<<endl;}  
  5.     ~Base(){cout << "Base Destruction"<<endl;}//(2)  
  6. };  
  7. class Derived:public Base  
  8. {  
  9. public:  
  10.     Derived(){ cout << "Derived Construction"<<endl;}  
  11.     ~Derived(){cout << "Derived Destruction"<<endl;}(1)  
  12. };  
  13. int main()  
  14. {     
  15.     Base *base = new Derived();  
  16.     delete base;  
  17.     return 0;  
  18. }  

A先调用（1）再调用（2）  B先调用（2）再调用（1    ） C只调用（2）   D只调用（1）

程序运行结果为图7，因此只调用了基类析构函数。如果析构函数不被声明成虚函数,则编译器实施静态绑定,在删除基类指针时,只会调用基类的析构函数而不调用派生类析构函数,这样就会造成派生类对象析构不完全。

图7

若主函数改成如下程序，则运行结果为图8，派生类的指针，delete时，先调用派生类析构函数，再调用基类析构函数。

[cpp] view plain copy
  1. int main()  
  2. {     
  3.     Base *base = new Derived();  
  4.     delete base;  
  5.     Derived *base1 = new Derived();  
  6.     delete base1;  
  7.     return 0;  
  8. }  

 

图8

若将派生类析构函数改为虚函数，则结果为图9，此时，delete基类指针时，先调用派生类析构函数，再调用基类析构函数。

[cpp] view plain copy
  1. class Base  
  2. {  
  3. public:  
  4.     Base(){cout << "Base Construction"<<endl;}  
  5.     virtual ~Base(){cout << "Base Destruction"<<endl;}//(2)  
  6. };  

图9

           若将派生类的析构函数改为虚函数，基类的函数为一般析构函数，运行时卡在一个地方。说是内存泄露，不是很明白原因。结果为图10.

[cpp] view plain copy
  1. class Derived:public Base  
  2. {  
  3. public:  
  4.     Derived(){ cout << "Derived Construction"<<endl;}  
  5.     virtual ~Derived()  
  6.     {cout << "Derived Destruction"<<endl;}  
  7. };  

图10 

         但若再基类加一个虚函数。运行又不卡住，不知是何原因，望求高人指点。结果为图11

[cpp] view plain copy
  1. class Base  
  2. {  
  3. public:  
  4.     Base(){cout << "Base Construction"<<endl;}  
  5.     ~Base(){cout << "Base Destruction"<<endl;}  
  6.     virtual void foo(){cout<<"Base foo"<<endl;}  
  7. };  
  8. class Derived:public Base  
  9. {  
  10. public:  
  11.     Derived(){ cout << "Derived Construction"<<endl;}  
  12.     virtual ~Derived(){cout << "Derived Destruction"<<endl;}  
  13. };  

图11


-------------------------------------阿里笔试题

[cpp] view plain copy
  1. class Base  
  2. {  
  3. public:  
  4.     int bar(char x)  
  5.     {  
  6.         return (int)(x);  
  7.     }  
  8.     virtual int bar(int x)  
  9.     {  
  10.         return 2*x;  
  11.     }  
  12. };  
  13. class Derive:public Base  
  14. {   
  15. public:  
  16.     virtual int bar(char x)  
  17.     {  
  18.         return (int)(-x);  
  19.     }  
  20.     int bar(int x)  
  21.     {  
  22.         return x/2;  
  23.     }  
  24. };  
  25. class Derive2:public Derive  
  26. {   
  27. public:  
  28.     int bar(char x)  
  29.     {  
  30.         return (int)(-2*x);  
  31.     }  
  32.     int bar(int x)  
  33.     {  
  34.         return x/4;  
  35.     }  
  36. };  

运行结果为图12，是不是有些出乎意料啊，哈哈

图12

（3）变量所占字节数及存储位置

13.请看一下这一段C++代码，如果编译后程序在windows下运行，则一下说话正确的是（AC）-------------腾讯2014实习生笔试

Char*p1 = “123456”;

Char*p2 = (char*)malloc(10);

A.  P1 和 p2都存在栈中

B.   P2指向的10个字节内存在栈中

C.  堆和栈在内存中的生长方向是相反的

D.  “123456”这6个字符存储在栈中

 看了图12，你就懂了。。。。

图13

8.   Char p1[] = “Tencent”, void *p2 = malloc((10)在32位机器上sizeof(p1)和sizeof(p2)对应的值是（C）  //--------腾讯2014实习生笔试

A.  8：0   B.   4：10   C.  8：4  D.  4：4

 

2 . 64位系统上，定义的变量int *a[2][3]占据（D）字节  //-------------------阿里2014实习生笔试

A 4    B 12    C 24   D 48

 

（4）时间复杂度

2.   假设函数f1的时间复杂度O(n)，那么f1*f1的时间复杂度为（A）

//----------------------------腾讯2014实习生笔试

A.  O(n)   B. O(n*n)   C. O(n*log(n))   D.  以上都不对

这个题真的比较坑爹啊，这里的*是f1的结果相称，不是复杂度相乘，f1就调用了2次，哎。。。。>....<

 

11. 在一台主流配置的PC机上，调用f(35)所需要的时间大概是（C）

//---------------------------------------阿里2014实习生笔试

[cpp] view plain copy
  1. unsigned long long  cnt=0;  
  2. int f(int x)  
  3. {  
  4.     int s=0;  
  5.     cnt++;  
  6.     while(x--)  
  7.         s+=f(x);  
  8.     return max(s,1);  
  9. }  


A 几毫秒   B几秒  C几分钟   D几小时

分析如下：

f(0)=1,f(1)=1+f(0)=2f(0),f(2)=1+f(1)+f(0)=4f(0),f(3)=1+f(2)+f(1)+f(0)=8f(0),f(n)=2^nf(0),f函数执行2^n次，分析结果正如图14所示。图14所示为：cout<<n<<":   "<<cnt<<"  "<<sum<<"  time:  "<<GetTickCount()-start<<endl;

输出依次为：n的取值、f（）的执行次数cnt、sum的值、程序运行时间（单位ms）

图14

图15

实际n=35是，执行次数2^35=34359738368，运行时间为1368031ms约22.8分钟，PC配置为CPU 2G 22核

目前主流PC配置为主频3.5G 4核。设指令周期2-5，f（）执行一次，要执行10条指令左右。因为是4核的，1s钟估测运算3.5G条指令。3.5*10^9/10=100s。这样算，大概只需要2分钟，当然，计算机不可能不做其他事。CPU也不可能100%使用，时间肯定大于2分钟。

（5）输出流执行顺序

图16的结果是不是让你震惊啊，输出流是从右向左运算的。和函数调用参数的运算顺序相同也是从右向左运算的。

 

图16

下面代码的输出，也让人奇怪，后加很好理解，输出流从右向左运算。前加就有点莫名其妙了。结果为图17，反汇编，有点长，不分析了哈。

[cpp] view plain copy
  1. int n=10;  
  2. cout<<n<<" "<<n++<<" "<<n++<<endl;  
  3. cout<<n<<" "<<n++<<" "<<n++<<" "<<++n<<" "<<++n<<endl;  

图17


（6）函数参数执行顺序

[cpp] view plain copy
  1. void canshutest(int a,int b)  
  2. {  
  3.     cout<<a<<endl<<b<<endl;  
  4. }  
  5.   
  6. int f1(int a)  
  7. {  
  8.   cout<<"a="<<a<<endl;  
  9.   return a;  
  10. }  
  11.   
  12. int f2(int b)  
  13. {  
  14.     cout<<"b="<<b<<endl;  
  15.     return b;  
  16. }  
  17. int main()  
  18. {     
  19.     int n=10;  
  20.     canshutest(f1(++n),f2(++n));      
  21.     canshutest(n++,n++);  
  22.     canshutest(++n,++n);  
  23.     return 0;  
  24. }  


图18

图19说明如下：

将变量n放入寄存器eax

然后eax+1

再将eax放入变量n

变量n再赋给ecx

ecx+1

ecx再赋给变量n

然后变量n赋给寄存器edx

edx压栈

调用f2

图19

 

图20

 

图21

 

看完以上３张图片，自然就明白了

（7）函数返回值

9  有以下程序，其执行结果是（B）

[cpp] view plain copy
  1. int test(char a,char b)  
  2. {  
  3.     if (a)  
  4.         return b;  
  5. }  
  6. int main()  
  7. {  
  8.     int a='0',b='1',c='2';  
  9.     printf("%c\n",test(test(a,b),test(b,c)));  
  10.     system("pause");  
  11. }  

A 函数调用出错   B 2   C 0   D 1

 

[cpp] view plain copy
  1. int test(char a,char b)  
  2. {  
  3.     if (a)  
  4.         return b;  
  5. }  

虽然编译是给出警告，若a为0时，函数返回0；并非出错

longlovefilm
关注
专栏目录
360笔试——校招试题2
FPGA/MATLAB学习教程/源码/项目合作开发
09-24 990
360笔试——校招试题2
python笔试陷阱1
caesarean6688的博客
07-03 114
test_list = [ {'data': 1, 'no': 301}, {'data': 2, 'no': 401}, {'data': 4, 'no': 201}, {'data': 6, 'no': 101}, {'data': 5, 'no': 303} ] new_list = list(test_list) # print(new_list)...
小心笔试中的小陷阱（五）
moubao的专栏
10-01 716
1.多态： 编译时多态是静态多态，运行时多态是动态多态 C++中，实现多态有以下方法：虚函数，抽象类，重载，覆盖，模版。
华为笔试题陷阱:大数据量的子串全查询
老紫竹的专栏
12-31 2370
题目来自于：http://topic.csdn.net/u/20081230/16/8d5d0a3e-61e3-4121-805c-efe0be2b878a.html 表有一千万条数据以上,有字段eno,ename,sal,未建立索引,现在要执行select substr(ename,2,2) from emp ,请问怎样修改可以优化查询速度？（可以包括修改查询语句和修改表结构等）陷阱：全表查询是
2022/12/10、C语言。字符函数和字符串函数
最新发布
初学者的知识储存库
12-13 105
笔记
baidu.rar_C 笔试 答案_C++笔试编程题_c 笔试题_百度笔试_笔试题
09-21
在编程领域，尤其是对于互联网巨头百度这样的公司，技术面试和笔试是筛选优秀人才的重要环节。这份“baidu.rar”压缩包文件包含了百度公司过去笔试中出现的一些C、C++编程题目及答案，对于准备面试或提升编程技能的...
C语言面试笔试易错题.docx
06-23
根据给定文件的信息，我们可以总结出一系列关于C语言的基础知识点，包括关键字、整型常量、转义符、字符串...通过以上分析，我们可以更深入地理解C语言的基础概念和常见陷阱，这对于准备面试或参加笔试都非常有帮助。
腾讯QQ求职指南：笔试面试经验分享
1. **笔试准备**：可能包含腾讯的笔试题型、常见问题和解题策略，有助于应聘者了解和练习相关技能。 2. **面试技巧**：可能会涵盖面试流程、面试官常问问题、如何展示自我、面试礼仪等内容。 3. **公司信息**：...
嵌入式C语言笔试题集与解答解析
嵌入式C语言笔试题及答案包含了针对该领域的核心知识点，涵盖了预处理器、宏定义、条件运算符以及常见的编程陷阱。以下是详细解析： 1. 预处理器（Preprocessor）：预处理器是C语言的重要组成部分，它在编译器处理...
c语言---字符串为什么不能修改内容？？？字符串常量存放在常量区吗？？？
silently_frog的博客
07-21 5236
疑惑： 1.const修饰的变量都存放在常量区吗？？？ 2.字符串常量存放在那？？？为什么字符型指针（char*）指向字符串不能修改其内容？？？ 字符串的演变： char* p="123456"; “123456”（常量字符串）----》char []------》static const char[]----->char*p 如果不懂，请往下看： 先看导火索： ...
积累(二)
yichudu
03-31 2309
阿里2014实习生招聘 问：某国家非常重男轻女，若一户人家生了一个女孩，便要继续生，直到得到男孩为止。假设生男生女概率相等，请问平均每户人家有（1）个女孩。 答：此题即高数中的级数。         引申：   int f(int x){ int s=0; while(x--) s+=f(x); return max(x,1); } //若调用f(35),此程序
in0t在C语言中是标识符,计算机笔试题内容
weixin_36203080的博客
05-18 202
基础题01关于二叉树，下面说法正确的是()A、对于N个节点的二叉树，其高度为nlog2n;B、一个具有1025个节点的二叉树，其高度范围在11~1025之间C、二叉树的先序遍历是EFHIGJK，中序遍历为HFIEJKG，该二叉树的右子树的根为GD、二叉树中至少有一个节点的度为202假设函数f1的时间复杂度O(n)，那么f1*f1的时间复杂度为()A、O(n)B、O(n*n)C、O(n*log(n)...
阿里实习题
TopicDev的专栏
04-03 1038
1 假设一个主机的IP地址为192.168.5.121,而子网掩码为255.255.255.248,那么该主机的网络号部分（包括子网号部分）为_____________. A   192.168.5.12        B  192.168.5.121    C 192.168.5.120  D 192.168.5.32   2 64系统上，定义的变量int * a[2][3]占据_____
Jeff的错题集（十）：最后一个暑假快结束了！
Jeff.Ye的博客
08-20 1093
题一： char a[]={‘a’,‘b’,‘c’};char b[]={“abc”};数组a和数组 b 占用的内存空间大小不一样。请问这句话的说法是正确的吗？ 正确答案: A 你的答案: B (错误) 正确 错误 解答： char b[]={“abc”}; 其实就是 char b[]=“abc”; 所以b占用的空间需要加上末尾的’\0’，长度为4. 题二： 若有以下程序 struct st{ int n; struct st * nest; }; struct st a[3]={ 5,&a[1
指针与字符串操作-一道腾讯笔试题
ndzj981479673的专栏
09-12 1018
#include void f(char **p){ *p += 2;} int main(int argc, const char * argv[]) {     // insert code here...     std::cout << "Hello, World!\n";          char *a[]={"123","abc","4
操作系统-遍历矩阵时间比较（先行后列或先列后行）及调用f(35)时间
糖醋万象的博客
05-01 1599
一、遍历矩阵时间比较 用c语言写一个大规模矩阵遍历的程序，在不同规模的数据下运行，比较按行遍历快还是按列遍历快。 （一） 程序 // // main.c // bianli // // Created by mac on 2021/4/30. // #include <stdio.h> #include <stdlib.h> #include<time.h> int main() { for(int n = 8; n < 40960; n = n*
2014年4月12号腾讯笔试题
hxysea的专栏
04-16 2441
有问题请讨论 1. 关于二叉树，下面说法正确的是（BC） A. 对于N个节点的二叉树，其高度为nlog2n; B. 一个具有1025个节点的二叉树，其高度范围在11~1025之间 C. 二叉树的先序遍历是EFHIGJK，中序遍历为HFIEJKG，该二叉树的右子树的根为G D. 二叉树中至少有一个节点的度为2 2. 假设函数f1的时间复杂度O(n)，那么f1*f1的时间
阿里巴巴2014研发实习生笔试解析
热门推荐
DianaCody's Blog
03-31 1万+
转载请注明出处：http://blog.csdn.net/dianacody/ 阿里巴巴2014实习生笔试题-研发工程师-北京站 一、单选题（前10题，每题2分；后10题，每题3分；共50分。选对得满分，选错倒扣1分，不选得0分）   1.假设一个主机的IP地址为192.168.5.121，而子网掩码为255.255.255.248。那么该主机的网络号部分（包括子网号部分）
互联网公司Java笔试题解析
"这份文档包含了互联网公司校招的Java笔试题目，主要测试应聘者的编程基础、算法理解以及Java语言的掌握情况。" 在给定的Java笔试题中，我们可以分析以下几个重要的知识点： 1. **递归算法与时间复杂度**： 题目1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值