腾讯云智

一面：

C++怎么处理内存泄漏

C++ 析构函数为虚函数

C++多态

C++构造函数是否可以为虚函数，是否可以调用虚函数(effective C++第二章)

Linux epoll

TCP为什么是安全的

TCP三次握手的作用，两次握手可能会导致历史连接建立、三次握手可以重置序列号、防止冗余连接（网络阻塞，客户端没有收到ACK报文，服务的会建立大量连接，两次握手情况下）

TCP滑动窗口，其弊端

服务端为什么会产生大量Time_wait状态，怎么解决

TCP拆包粘包

TCP快重传

写一个简单的String类，包含构造函数，拷贝构造函数，移动构造函数，拷贝赋值函数，析构函数，通过通过指针初始化

二面：

问项目

算法题目描述：

思路：4->3->2->1 最后一个数是否为24, 方法：递归，没刷到 GG

24点游戏 https://leetcode.cn/problems/24-game/

static constexpr int TARGET = 24;
    static constexpr int ADD = 0, MUTILPLY = 1, SUBTRACT = 2, DIVDE = 3;
    static constexpr double EPSILON = 1E-6;

    bool judgePoint24(vector<int>& nums){
        vector<double> ret;
        for(int x : nums){
            ret.push_back(x);
        }

        return solve(ret);
    }

    bool solve(vector<double>& l){
        if(l.size() == 0){
            return false;
        }

        if(l.size() == 1){
            return fabs(l[0] - TARGET) < EPSILON;
        }
        
        int n = l.size();
        for(int i = 0; i < n; ++i){
            for(int j = 0; j < n; ++j){
                if(i != j){
                    vector<double> temp;
                    for(int k = 0; k < n; ++k){
                        if(k != i && k != j){
                            temp.push_back(l[k]);
                        }
                    }

                    for(int k = 0; k < 4; ++k){
                        if(k < 2 && i > j){
                            continue;
                        }

                        if(k == ADD){
                            temp.push_back(l[i] + l[j]);
                        }
                        else if(k == MUTILPLY){
                            temp.push_back(l[i] * l[j]);
                        }
                        else if(k == SUBTRACT){
                            temp.push_back(l[i] - l[j]);                       
                        }
                        else{
                            if(fabs(l[j]) < EPSILON){
                                    continue;   
                            }

                            temp.push_back(l[i] / l[j]);
                        }

                        if(solve(temp)){
                            return true;
                        }

                        temp.pop_back();
                    }
                }
            }
        }
        return false;
    }