2021腾讯实习一面复盘-小丑竟是我自己

墨蓝 2022-10-22 04:10 367阅读 0赞

### 文章目录 ###

*  开场
 *   *  自我介绍
     *  比赛用C++，为何走Java?
     *  C/C++和Java有什么区别
 *  手撕算法
 *   *  连续子数组最大和
     *  合并两个排序链表
 *  C/C++
 *   *  sizeof
     *  union和struct的区别
     *  指针和数组的区别
     *  多态
     *  虚函数
     *  static关键字
 *  计网
 *   *  网络体系结构
     *  TCP和UDP的区别
     *  TCP为何三次握手
     *  TCP滑动窗口
     *  TCP和UDP包头大小
     *  网络编程
 *  数据库
 *   *  描述MySQL索引
 *  Linux
 *   *  进程间通信方式
     *  物理地址和虚拟地址的区别
     *  Linux命令
 *  Java
 *   *  Java的GC机制
 *  总结

![在这里插入图片描述][20210406215325866.gif_pic_center]  
每个岗位和事业群要求肯定不同，题目和答案仅供参考。

# 开场 #

## 自我介绍 ##

--------------------

主观题

## 比赛用C++，为何走Java? ##

--------------------

主观题

## C/C++和Java有什么区别 ##

--------------------

*  都是面向对象的语言，都支持继承、封装和多态。
 *  Java不提供指针来直接访问内存，程序内存更安全。
 *  Java的类是单继承的，C++支持多重继承；虽然Java的类不可以多继承，但是可以实现多个接口。
 *  Java有自动内存管理机制，不需要程序员手动释放无用内存。
 *  C语言中，字符串或字符数组最后有一个额外的字符’\\0’表示结束，Java中无结束符这一概念。

# 手撕算法 #

## 连续子数组最大和 ##

--------------------

可参考：[数组面试题-大力出奇迹？][-]

## 合并两个排序链表 ##

--------------------

可参考：[链表面试题(动图详解)-明明做出来了却为什么没有Offer?][-_Offer]

# C/C++ #

## sizeof ##

--------------------

double* (*a)[3][6];
        cout << sizeof(a) << endl; // 4 a为指针（64位是8）
        cout << sizeof(*a) << endl; // 72 *a为一个有3*6个指针元素的数组（64位是144）
        cout << sizeof(**a) << endl; // 24 **a为数组一维的6个指针（64位是48）
        cout << sizeof(***a) << endl; // 4 ***a为一维的第一个指针（64位是8）
        cout << sizeof(****a) << endl; // 8 ****a为一个double变量

## union和struct的区别 ##

--------------------

*  Union  
    整体空间是 占用空间最大的成员（的类型）所占字节数的整倍数。  
    union的成员共享内存空间，修改某成员值会影响其他成员。
 *  Struct  
    数据对齐原则：内存按结构成员的先后顺序排列，当排到该成员变量时，其前面已摆放的空间大小必须是该成员类型大小的整倍数，如果不够则补齐，以此向后类推。  
    各成员间互不影响。

#include<bits/stdc++.h>
    using namespace std;
    struct a { 
        char x;//sizeof(char)=1
        int y;//sizeof(int)=4
        double z;//sizeof(double)=8
    };
    union b { 
        char x;//sizeof(char)=1
        int y;//sizeof(int)=4
        double z;//sizeof(double)=8
    };
    int main() { 
        struct a t1;
        union b t2;
        cout << sizeof(t1) << endl;//1+4+8+补齐3
        cout << sizeof(t2) << endl;//max(1,4,8)
        t1.x = 'a';
        t2.x = 'a';
        cout << t1.x << " " << t2.x << endl;//a a
        t1.y = 1;
        t2.y = 1;
        cout << t1.x << " " << t2.x << endl;//a 乱码
        cout << t1.y << " " << t2.y << endl;//1 1
        return 0;
    }

## 指针和数组的区别 ##

--------------------

<table> 
 <thead> 
  <tr> 
   <th>指针</th> 
   <th>数组</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>相当于一个变量，存放的是其它变量在内存中的地址</td> 
   <td>储存多个相同类型数据的集合</td> 
  </tr> 
  <tr> 
   <td>同类型指针可相互赋值</td> 
   <td>数组只能一个个拷贝元素</td> 
  </tr> 
  <tr> 
   <td>存储很灵活，可指向任意类型的数据</td> 
   <td>存在一块连续的物理空间上，逻辑上的多维数组其实存的是一维</td> 
  </tr> 
  <tr> 
   <td>sizeof在32位下是4，64位下是8</td> 
   <td>sizeof是数组所占存储空间大小，但是<strong>传参时会退化为指针</strong>，此时sizeof即指针大小</td> 
  </tr> 
 </tbody> 
</table>

#include<bits/stdc++.h>
    using namespace std;
    void test1(double* c) { 
        cout << sizeof(c) << endl;//4
        c[0] = 1.0;
    }
    void test2(double c[]) { 
        cout << sizeof(c) << endl;//4
        c[0] = 2.0;
    }
    int main() { 
        int* a[10];//指针数组：存着10个int*类型指针的数组
        int(*b)[10];//数组指针：即一个指针，指向了一个int[10]的数组
        //换言之 []优先级大于*
        cout << sizeof(a) << endl;//40，10×4(32位指针大小)
        cout << sizeof(b) << endl;//4，即一个指针大小(64位是8)
        cout << sizeof(*a) << endl;//4，数组首指针
        cout << sizeof(*b) << endl;//40，所指数组大小10×4(32位int大小)
        //传参时退化成了指针，是引用传递
        double c[10] = {  0 };
        cout << sizeof(c) << endl;
        cout << c[0] << endl;//0
        test1(c);
        cout << c[0] << endl;//1
        test2(c);
        cout << c[0] << endl;//2
        return 0;
    }

## 多态 ##

--------------------

多态是同一个行为具有多个不同表现形式或形态的能力。比如重写父类方法、重载同一方法等。

C/C++构成多态条件：

*  调用函数的对象必须是指针或者引用。
 *  被调用的函数必须是虚函数，且完成了虚函数的重写。

#include<bits/stdc++.h>
    using namespace std;
    class A{  //父类
    public:
        virtual void test(){ 
            cout << "A" << endl;
        }
    };
    class B : public A{   //子类
    public:
        virtual void test(){ 
            cout << "B" << endl;
        }
    };
    void fun(A& obj){ 
        obj.test();
    }
    int main(){ 
        A a;
        B b;
        fun(a);//A
        fun(b);//B
        return 0;
    }

被调用的函数必须是虚函数，也就是说必须要在两个产生多态的函数前面加`virtual`关键字。

调用函数的形参对象必须是基类对象，因为派生类能给基类赋值，基类不能给派生类赋值。

调用函数的参数必须是指针或引用，因为派生类改变了虚表，那么这个虚表就属于派生类对象，赋值时只会把基类的成员给过去，虚表指针不会给。

即在调用函数的时候检查，如果满足多态的条件，则触发寻找虚表中虚函数地址。否则会直接用基类对象调用基类函数。

> （插播反爬信息 ）博主CSDN地址：[https://wzlodq.blog.csdn.net/][https_wzlodq.blog.csdn.net]

## 虚函数 ##

--------------------

虚函数即在类的成员函数前面加`virtual`关键字。若派生类中有一个跟基类的完全相同虚函数（函数名、参数、返回值相同），我们就称子类的虚函数重写了基类的虚函数。

**协变**：重写虚函数的返回值可以不同，但是必须分别是基类指针或引用和派生类指针或引用。（VS会报错，linux的G++不会）

class A{  
    public:                                                                  
        virtual A* fun(){ 
            return new A;                                                    
        }
    };
    class B : public A{ 
    public:
        virtual B* fun(){ 
            return new B;
        }
    };

**纯虚函数**：在虚函数的后面写加上’=0’，则这个函数就变成纯虚函数，包含纯虚函数的类叫做抽象类（或接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。

class A{ 
    public:
        virtual void test() = 0;
    };
    class B : public A{ 
    public:
        virtual void Strength(){ 
            cout << "一键三连" << endl;
        }
    };

## static关键字 ##

--------------------

`static`静态变量作用范围在一个文件内，程序开始时分配空间，结束时释放空间，默认初始化为0，使用时可以改变其值。

1.  修饰局部变量：  
    变量在程序初始化时被分配，直到程序退出前才被释放，也就是`static`是按照程序的生命周期来分配释放变量的，而不是变量自己的生命周期。多次调用也只需一次初始化。
2.  修饰全局变量：  
    可在不同的cpp文件中定义同名变量，避免命名冲突（隐藏)，保持变量内容的持久。
3.  类的数据成员：  
    必须在class的外部初始化。
4.  类的函数：  
    不需要类的实例即可调用（注意public和private权限）。属于整个类而非类的对象实例，所以没有this指针。静态成员之间可以相互访问。
5.  单例模式中使用，保证一个类在内存中仅有一个实例，并提供一个访问它的全局访问点。

# 计网 #

## 网络体系结构 ##

--------------------

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70]

## TCP和UDP的区别 ##

--------------------

*  TCP连接可靠安全有序一对一较慢
 *  UDP无连接不可靠不安全无序一对多较快

## TCP为何三次握手 ##

--------------------

A=>B：A不知道自己发送是否成功，B收到后知道A发送正常、B接收正常。  
B=>A：B不知道自己发送是否成功，A收到后知道A收发正常，B收发正常。  
A=>B：B收到后知道B收发正常、A收发正常。

## TCP滑动窗口 ##

--------------------

发送窗口不断向前滑动，是一种连续的AQR协议。允许发送方已发送但还没有收到确认的分组序号的范围，窗口大小是发送方已发送未确认的最大分组数。避免单窗口的一直等待一个ack而延迟阻塞。

1.  接收方按序接收分组。当收到失序的分组，它会丢弃，并对按序的分组进行确认。
2.  接收方采用**累计确认**的方式。在收到n个分组之后，对按序到达的最后一个分组进行确认。
3.  发送方采用超时重传机制来重传差错或丢失的分组。一旦分组出错，在该分组之后发送的所有分组都需要重传，退回去重传已发送的N个分组，故称为回退N帧协议（GBN）。

## TCP和UDP包头大小 ##

--------------------

TCP：20  
UDP：8

## 网络编程 ##

--------------------

可参考：[Python网络编程-一文厘清socket、TCP和UDP那点事][Python_-_socket_TCP_UDP]

# 数据库 #

## 描述MySQL索引 ##

--------------------

可参考：[不懂就问，MySQL索引是啥？][MySQL]

# Linux #

## 进程间通信方式 ##

--------------------

*  管道  
    父子进程间使用，无格式字节流，慢
 *  信号量  
    计数器、锁机制、控制多个进程对共享资源的访问，承载信号量小，同步问题
 *  消息队列  
    消息的链接表，注意读写队列中消息的权限，容量限制，注意上次是否读完
 *  共享内存  
    银蛇一块可被其他进程所访问的内存，快，同步问题
 *  信号  
    通知接收进程某个事件已经发送
 *  套接字  
    可用于不同机器间进程通信

## 物理地址和虚拟地址的区别 ##

--------------------

*  物理地址：CPU地址总线传来的地址，由硬件电路控制其具体含义。一部分给物理RAM（内存）用，一部分给总线用。
 *  虚拟地址：现代操作系统普遍采用虚拟内存管理机制， 需要MMU（Memory Management Unit）的支持，也就是将虚拟地址映射成物理地址。

## Linux命令 ##

--------------------

可参考：[Linux-基础实用指令（不会还有人不知道吧）][Linux-]

# Java #

## Java的GC机制 ##

--------------------

可参考：[还不会JVM，是准备家里蹲吗？][JVM]

# 总结 #

--------------------

约75分钟，中间几次声音听不清（不知道是网络还是火狐的锅，推荐Chrome）。几度怀疑走错C/C++片场，Java的问题只有一个GC，准备的好多东西都没有问到，像hashmap、设计模式、redis、JVM还有项目啥的。好吧，还是我太菜了。渡人易渡己难，如果能帮到正努力进鹅厂的你也好，冲！

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70_pic_center]

> **原创不易，请勿转载**（本不富裕的访问量雪上加霜 ）  
> 博主首页：[https://wzlodq.blog.csdn.net/][https_wzlodq.blog.csdn.net]  
> 微信公众号：[`吾仄lo咚锵`][lo]  
> *如果文章对你有帮助，记得一键三连❤*

[20210406215325866.gif_pic_center]: /images/20221022/188e407c174541c484d25e5fc425380f.png
[-]: https://blog.csdn.net/qq_45034708/article/details/115447938
[-_Offer]: https://blog.csdn.net/qq_45034708/article/details/115213208
[https_wzlodq.blog.csdn.net]: https://wzlodq.blog.csdn.net/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70]: /images/20221022/1129a7e7949a47b8a6086ea9d61922fb.png
[Python_-_socket_TCP_UDP]: https://blog.csdn.net/qq_45034708/article/details/114341701
[MySQL]: https://blog.csdn.net/qq_45034708/article/details/115409492
[Linux-]: https://wzlodq.blog.csdn.net/article/details/109451439
[JVM]: https://blog.csdn.net/qq_45034708/article/details/115257271
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70_pic_center]: /images/20221022/2d9e5136db9847468aeab77f6e3869b2.png
[lo]: https://mp.weixin.qq.com/mp/profile_ext?action=home&__biz=MzkwMzE2Nzg4MQ==#wechat_redirect