腾讯面经汇总--C++后端

栈空间 实际上堆空间也有可能占用

立即学习“C++免费学习笔记（深入）”；

基础类型(不会) 感觉从内存上讲没好处，看需求把，是否需要改那个数。

1，引用实际是通过指针实现的。 2，引用是一个常量指针。 3，引用在内存中占4个字节。 4，在对引用定义时，需要对这个常量指针初始化。 5，因为在在表达式中，使用引用实际上就像使用变量本身一样，所以直接用sizeof是得不到引用本身的大小的。

简单介绍，协议细节和包含了什么

vector内存结构，扩容缩容 string扩容缩容，连续的 string是连续的 优先级队列，以vector为存储结构的堆

int成员+普通函数+虚函数 类大小是多少 sizeof 为 8

为什么要字节对齐 怎么字节对齐 不对齐会怎么样 对齐与不对齐的访问内存区别

大端小端的区别

string有字节序的说法吗

2msl 半连接状态

内碎片外碎片

静态变量共享吗 虚拟内存地址的组织

慢启动和快重传的触发条件 怎么区分是网络的原因(连发3次ack说明丢包)

对着tcp的可靠传输方法改 加ack 加序号 拥塞控制

vector内存 map的实现方式

进程重启如何读到之前的东西(比如本来有个map，重启后继续读到) 共享内存可以实现的

红包算法，3个人抢5块的红包，每个人不能超过2块

进程调度：记录系统中的所有进程的状态、优先级数和资源的需求情况确定调度算法，决定将 CPU 分配给哪个进程多少时间分配处理机给进程，进行 CPU 现场的保护和移交

进程调度算法：先来先服务调度算法、短作业优先调度算法、非抢占式优先级调度算法、抢占式优先级调度算法、高响应比优先调度算法、时间片轮转法调度算法

详细

同进程调度

TCP/IP协议并不完全符合OSI 标准定制的七层参考模型，它采取了四层的层级结构

Ping 是一个应用程序，是基于 ICMP 协议实现的。ICMP 协议是位于 IP 层的一个协议。它是 TCP/IP 协议族的一个子协议，用于在 IP 主机、路由器之间传递控制消息。 Ping 命令的基本原理？答：ICMP，发送主机发送 echo 请求，接受主机回复 echo 报文 Ping 的如果是域名，还要先经过 DNS 解析

详细

因为要考虑到一个服务器通常会连接多个客户端，因此由用户在应用层自己实现心跳包，代码较多 且稍显复杂，而利用TCP／IP协议层为内置的KeepAlive功能来实现心跳功能则简单得多。 不论是服务端还是客户端，一方开启KeepAlive功能后，就会自动在规定时间内向对方发送心跳包， 而另一方在收到心跳包后就会自动回复，以告诉对方我仍然在线。 因为开启KeepAlive功能需要消耗额外的宽带和流量，所以TCP协议层默认并不开启KeepAlive功 能，尽管这微不足道，但在按流量计费的环境下增加了费用，另一方面，KeepAlive设置不合理时可能会 因为短暂的网络波动而断开健康的TCP连接。并且，默认的KeepAlive超时需要7,200，000 MilliSeconds， 即2小时，探测次数为5次。对于很多服务端应用程序来说，2小时的空闲时间太长。因此，我们需要手工开启KeepAlive功能并设置合理的 KeepAlive参数

心跳包一般来说都是在逻辑层发送空的echo包来实现的。下一个定时器，在一定时间间隔下发送一个空包给客户端，然后客户端反馈一个同样的空包回来，服务器如果在一定时间内收不到客户端发送过来的反馈包，那就只有认定说掉线了

这两种方式分配的都是虚拟内存，没有分配物理内存。在第一次访问已分配的虚拟地址空间的时候，发生缺页中断，操作系统负责分配物理内存，然后建立虚拟内存和物理内存之间的映射关系

在应用程序启动之后，就马上创建一定数量的线程，放入空闲的队列中。这些线程都是处于阻塞状态，这些线程只占一点内存，不占用 CPU。当任务到来后，线程池将选择一个空闲的线程，将任务传入此线程中运行。当所有的线程都处在处理任务的时候，线程池将自动创建一定的数量的新线程，用于处理更多的任务。执行任务完成之后线程并不退出，而是继续在线程池中等待下一次任务。当大部分线程处于阻塞状态时，线程池将自动销毁一部分的线程，回收系统资源。

使用一个全局变量进行标志

取地址的、有名字的就是左值。左值的生存期长，可以作为赋值的对象。 右值指临时对象，只在当前语句有效，右值又可以细分为纯右值、将亡值。纯右值指的是临时变量和不跟对象关联的字面量值；将亡值则是 C++11 新增的跟右值引用相关的表达式，这样表达式通常是将要被移动的对象（移为他用）。如std::move 的返回值。将亡值可以理解为通过“盗取”其他变量内存空间的方式获取到的值

std::move()将左值强制转换为右值。

shared_ptr、unique_ptr、weak_ptr。shared_ptr多个指针指向相同的对象。shared_ptr 使用引用计数，每一个 shared_ptr 的拷贝都指向相同的内存。每使用他一次，内部的引用计数加 1，每析构一次，内部的引用计数减 1，减为 0 时，自动删除所指向的堆内存。shared_ptr 内部的引用计数是线程安全的，但是对象的读取需要加锁。 unique_ptr“唯一”拥有其所指对象，同一时刻只能有一个 unique_ptr 指向给定对象（通过禁用拷贝构造函数和赋值运算符、只有移动语义来实现）。 对象互相引用 当父类对象包含子类对象且子类对象包含父类对象，然二者又互相赋值的时候，将会发生互相引用的情况，资源将得不到释放。 弱指针 weak_ptr 不控制对象的生命期，指向一个shared_ptr 管理的对象，但是引用计数不在进行加 1。 它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造。,然后赋值给它的构造和析构不会引起引用记数的增加或减少.防止两个 shares_ptr 互相引用使得释放时引用计数为 1，无法得到释放。不能通过 weak_ptr 直接访问对象的方法，需要先将 weak_ptr 转为shared_ptr，才可以。某个 weak_ptr 调用 lock()转变为 shared_ptr。也可以 weak..直接赋值给 shared…

详细

双端队列（deque）是一种支持向两端高效地插入数据、支持随机访问的容器。和 vector 容器采用连续的线性空间不同，deque 容器存储数据的空间是由一段一段等长的连续空间构成，各段空间之间并不一定是连续的，可以位于在内存的不同区域。为了管理这些连续空间，deque 容器用数组（数组名假设为 map）存储着各个连续空间的首地址。也就是说，map 数组中存储的都是指针，指向那些真正用来存储数据的各个连续空间

当 deque 容器需要在头部或尾部增加存储空间时，它会申请一段新的连续空间，同时在 map 数组的开头或结尾添加指向该空间的指针，由此该空间就串接到了 deque 容器的头部或尾部。如果 map 数组满了怎么办？很简单，再申请一块更大的连续空间供 map 数组使用，将原有数据（很多指针）拷贝到新的 map 数组中，然后释放旧的空间。

Linux 内核中引入了伙伴系统算法(buddy system)。把所有的空闲页框分组为 11 个块链表，每个块链表分别包含大小为 1，2，4，8，16，32，64，128，256，512 和 1024 个连续页框的页框块。最大可以申请 1024 个连续页框，对应 4MB 大小的连续内存。每个页框块的第一个页框的物理地址是该块大小的整数倍。

假设要申请一个 256 个页框的块，先从 256 个页框的链表中查找空闲块，如果没有，就去 512 个页框的链表中找，找到了则将页框块分为 2 个 256 个页框的块，一个分配给应用，另外一个移到 256 个页框的链表中。如果 512 个页框的链表中仍没有空闲块，继续向 1024 个页框的链表查找，如果仍然没有，则返回错误。页框块在释放时，会主动将两个连续的页框块合并为一个较大的页框块。

top, ps, lsof, netstat, df -h

IO 准备好 / Sleep 时间到 前不会调度该线程

中断是指计算机运行过程中，出现某些意外情况需主机干预时，机器能自动停止正在运行的程序并转入处理新情况的程序，处理完毕后又返回原被暂停的程序继续运行.

检查方法：在 main 函数最后面一行，加上一句_CrtDumpMemoryLeaks()。调试程序，自然关闭程序让其退出，查看输出： 输出这样的格式{453}normal block at 0x02432CA8,868 bytes long 被{}包围的 453 就是我们需要的内存泄漏定位值，868 bytes long 就是说这个地方有 868 比特内存没有释放。 定位代码位置 在 main 函数第一行加上_CrtSetBreakAlloc(453);意思就是在申请 453这块内存的位置中断。然后调试程序，程序中断了，查看调用堆栈。加上头文件#include

1.什么是消息队列 2.如何保证消息不丢失 3.如何保证消息不重复

详细

SYN表示建立连接， FIN表示关闭连接， ACK表示响应， PSH表示有 DATA数据传输， RST表示连接重置

大端模式：是指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址端。 小端模式，是指数据的高字节保存在内存的高地址中，低位字节保存在在内存的低地址端

网络字节序类似于大端模式，因为UDP/TCP/IP协议规定:把接收到的第一个字节当作高位字节看待，类似于大端模式低地址存放高字节的存储方式，实际上也确实像，因为无论是收还是发，都是从低字节开始的，那么收到的第一个字节理应放到低地址。

class Solution {public:    // 翻转一个子链表，并且返回新的头与尾    pair<ListNode*, ListNode*> myReverse(ListNode* head, ListNode* tail) {        ListNode* prev = tail->next;        ListNode* p = head;        while (prev != tail) {            ListNode* nex = p->next;            p->next = prev;            prev = p;            p = nex;        }        return {tail, head};    }    ListNode* reverseKGroup(ListNode* head, int k) {        ListNode* hair = new ListNode(0);        hair->next = head;        ListNode* pre = hair;        while (head) {            ListNode* tail = pre;            // 查看剩余部分长度是否大于等于 k            for (int i = 0; i < k; ++i) {                tail = tail->next;                if (!tail) {                    return hair->next;                }            }            ListNode* nex = tail->next;            pair<ListNode*, ListNode*> result = myReverse(head, tail);            head = result.first;            tail = result.second;            // 把子链表重新接回原链表            pre->next = head;            tail->next = nex;            pre = tail;            head = tail->next;        }        return hair->next;    }};

class Solution {public:    ListNode* reverseKGroup(ListNode* head, int k) {        if (k <= 1) return head;        vector<ListNode* > vec;        while (head) {            vec.emplace_back(head);            head = head->next;        }        if (vec.size() < k) return head;        ListNode* newHead = vec[k - 1];        for (int i = 1; i < k; ++i) {            vec[i]->next = vec[i - 1];        }        int last_index = 0;        if (vec.size() == k) {            vec[0]->next = nullptr;            return vec[k - 1];        }        int j = k, tmp;        while (j < vec.size()) {            tmp = last_index + k - 1;            if (tmp + 1 < vec.size()) vec[tmp + 1]->next = nullptr;            if (tmp + k >= vec.size()) {                if(tmp+2 < vec.size()) vec[tmp+1]->next = vec[tmp+2];                vec[last_index]->next = vec[tmp + 1];                return newHead;            }            j = tmp + 2;            for (; j < vec.size() && j - tmp <= k; ++j) {                vec[j]->next = vec[j - 1];            }            vec[last_index]->next = vec[j - 1];            last_index = tmp + 1;        }        return newHead;    }};

找出规律不能为7的倍数，每次取到只剩7的倍数个糖果即可

https://leetcode-cn.com/problems/unique-paths-ii/

class Solution {public:    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {        vector<vector<int>> vvi(obstacleGrid.size(), vector<int>(obstacleGrid[0].size(), 0));        if(obstacleGrid[0][0]) return 0;        vvi[0][0] = 1;        for(int j =1;j < obstacleGrid[0].size();j++){            if(obstacleGrid[0][j]) break;            vvi[0][j] = 1;        }        for(int i = 1;i < obstacleGrid.size();i++){            if(obstacleGrid[i][0]) break;            vvi[i][0] = 1;        }                for(int i = 1;i < obstacleGrid.size();i++){            for(int j = 1;j < obstacleGrid[0].size();j++){                if(obstacleGrid[i][j]) continue;                vvi[i][j] = vvi[i-1][j]+vvi[i][j-1];            }        }        return vvi[obstacleGrid.size()-1][obstacleGrid[0].size()-1];    }};

class Solution {public:    ListNode* reverseList(ListNode* head) {        if(!head || !head->next) return head;        ListNode *t1 = head, *t2 = head->next, *t3;        head->next = nullptr;        while(t2){            t3 = t2->next;            t2->next = t1;            t1 = t2;            t2 = t3;        }        return t1;    }};