前一个是机器视觉组，另外一个组(数据存储)也想面一下，就重新从1面开始了
1.项目的一些实现：
例如：服务器架构、如何实现多个玩家数据同步、很多玩家同时登陆会怎么样
回答了一些游戏服务器架构的知识，合服原理以及玩家排队机制
2.session和token的区别，token是啥
Session和Token机制原理上差不多，都是用户身份验证的一种识别手段，它们都有过期时间的限制，但两者又有一些不同的地方。
1、Session是存放在服务器端的，可以保存在：内存、数据库、NoSQL中。它采用空间换时间的策略来进行身份识别，若Session没有持久化落地存储，一旦服务器重启，Session数据会丢失。
2、Token是放在客户端存储的，采用了时间换空间策略，它也是无状态的，所以在分布式环境中应用广泛。
3.设计模式
1.知道哪些策略模式：
单例模式、抽象工厂方法，策略模式、桥接器模式、装饰器模式、代理模式
2.单例模式如何实现：
我说构造函数使用私有，然后每次创建时，都去检测一下，如果有这个私有变量，就返回私有变量，如果没有，就不返回这个私有变量
其实正确答案应该是静态指针
3.策略模式和装饰器模式区别
策略模式更趋向于多选1
装饰器模式应该是执行某个函数前，要先去执行某个前序函数……
4.多线程的单例会怎么样？
上面这个如果写成静态类就可以了。
4.c++的nullptr和NULL有什么区别？
NULL有二义性，可以是空指针，也可以是int类型的0，
void func()
和 int func()
重载时，NULL会调用int func()
5.你知道多路复用IO吗？
select和epoll
1.select和epoll的区别
2.epoll的底层实现
6.虚函数有什么作用？
可以用基类指针访问基类，实现动态多态，
1.虚指针的实现：
通过一个虚函数表
2.什么时候使用虚函数
我没有答出来。
答案参考
什么要用父类指针指向子类对象呢？这根本不需要声明为虚函数啊，直接定义一个子类对象，或是用子类指针指向子类对象，再来调用Show函数，即使不用声明为虚函数，也能调用我们派生后重写的Show函数啊。
虽然这样说，但是实际开发过程中不是这样的，当我们使用一些类库、框架的时候，这些类库、框架是事先就写好的。我们在使用的时候不能直接修改类库的源码，我们只能派生类库中的类来覆盖一些成员函数以实现我们的功能，但这些成员函数有的是由
框架调用的。这种情况下，用虚函数是很好的办法。
在面向过程的C语言中，在需要框架、类库回调我们自定义的函数的时候，往往是传入一个函数指针，让框架回调。
在面向对象的C++中，为了实现同样的目的，框架往往准备好了什么也不干的虚函数，由我们派生后重写这个虚函数，来实现我们的自定义功能。随后，框会调用这个虚函数。效果如同面向过程语言中的回调。
7.c++的函数调用里面，哪些内存是怎么保存的
1.栈里面的，例如局部变量等等
2.堆里面的，例如新分配的动态分配的内存
3.一些静态变量，会一直全局存在
8.你知道哪些STL
vector，set，map，string，list，stack，queue
9.STL里面String是深拷贝还是浅拷贝？
#include <string>//包含string
#include <iostream>
using namespace std;
int main(int argc, char* argv[]) {
string ss, s;
ss = "1234567";
s = ss;//用=号直接把ss的值1234567赋给s
ss = "1";
cout << s << endl;
return 0;
}
请问s输出什么？这里s输出的还是1234567
是深拷贝
如何实现字符串的深拷贝
1.分配空间
2.给字符串赋值
3.返回新串
10.vector的迭代器
如果在vector迭代过程中，进行了删除操作，会怎么样
迭代器会失效，但是可以获取新的有效的下一个迭代器
11.你用过thread吗？c++里面thread的作用等等
没有 = =
12.函数调用压栈过程
函数怎么知道什么时候返回呢？返回地址是啥
13.多线程操作一个链表的话会出现什么问题
会出现异常结果，操作时需要加锁
如果是2个线程操作2个链表呢？
如果是 各自线程操作各自的链表不会有问题，不然需要同步
14.一个算法题
我没有做出来，贴一下后来的实现。。。。。
一个升序单链表(值不一定连续)，头指针为head, 将其中值在[a,b]之间的数据反转，包含a和b,返回反转后的链表。
eg：
[2 3]
1 2 3 4 6
1 4 3 2 6
若有更清晰思路请不吝赐教。
#include <iostream>
#include<vector>
using namespace std;
struct LinkNode {
LinkNode* pNext;
int val;
};
LinkNode* GetMaxAPre(LinkNode* pHead, int a) {
LinkNode* pre = pHead;
while (pHead && pHead->pNext)
{
if (pHead->pNext->val<a)
{
pre = pHead;
}
else {
return pre;
}
pHead = pHead->pNext;
pre = pre->pNext;
}
return pre;
}
LinkNode* GetMinBPre(LinkNode* pHead, int b) {
LinkNode* pre = pHead;
while (pHead && pHead->pNext)
{
if (pHead->pNext->val <= b)
{
pre = pHead;
}
else {
return pre;
}
pHead = pHead->pNext;
pre = pre->pNext;
}
return pre;
}
LinkNode* ReverseList(LinkNode* pHead,LinkNode* tail) {
LinkNode* pReverseHead = nullptr; //当前需要连接的头
LinkNode* pNode = pHead;
LinkNode* pPrev = nullptr;
while (pNode != tail)
{
LinkNode* pNext = pNode->pNext;
if (pNext == tail)
{
// 是空，到了最后一个节点了
pReverseHead = pNode;
}
pNode->pNext = pPrev;
pPrev = pNode;
pNode = pNext;
}
return pReverseHead;
}
LinkNode* ReverseListA2B(LinkNode* pHead, int a, int b) {
LinkNode* preA = GetMaxAPre(pHead, a);
LinkNode* newTail = preA->pNext;
LinkNode* B = GetMinBPre(preA, b);
LinkNode* BNext;
if (B==nullptr)
{
BNext = nullptr;
}
else {
BNext = B->pNext;
}
if (preA==nullptr )
{
return nullptr;
}
LinkNode* newhead;
if (pHead->val>=a)
{
newhead = ReverseList(pHead, BNext);
preA->pNext = BNext;
return newhead;
}
else {
newhead = ReverseList(preA->pNext, BNext);
}
preA->pNext = newhead;
newTail->pNext = BNext;
return pHead;
}
void testcase(const string caseName, vector<int> data,int a,int b) {
cout << caseName<<" : \n";
LinkNode* pHead = new LinkNode();
pHead->pNext = nullptr;
pHead->val = data[0];
LinkNode* p = pHead;
for (int i = 1; i < data.size(); i++)
{
LinkNode* newNode = new LinkNode();
newNode->pNext = nullptr;
newNode->val = data[i];
p->pNext = newNode;
p = p->pNext;
}
p = pHead;
while (p != nullptr)
{
if (p && p->pNext != nullptr)
{
cout << p->val << " ->";
}
else {
cout << p->val << endl;
}
p = p->pNext;
}
p = ReverseListA2B(pHead, a, b);
while (p != nullptr)
{
if (p && p->pNext != nullptr)
{
cout << p->val << " ->";
}
else {
cout << p->val << endl;
}
p = p->pNext;;
}
cout << endl;
}
int main()
{
vector<int> data{ 0,1,3,4,5,7,9,10 };
testcase("case1", data,1,5); //0 ->5 ->4 ->3 ->1 ->7 ->9 ->10
testcase("case2", data,0,9); //9 ->7 ->5 ->4 ->3 ->1 ->0 ->10
testcase("case3", data,1,10);// 0 ->10 ->9 ->7 ->5 ->4 ->3 ->1
testcase("case4", data,0,10);// 10 ->9 ->7 ->5 ->4 ->3 ->1 ->0
testcase("case5", data, -5, 20);//10 ->9 ->7 ->5 ->4 ->3 ->1 ->0
testcase("case6", data, 1, 20);//0 ->10 ->9 ->7 ->5 ->4 ->3 ->1
testcase("case7", data, 6, 9);//0 ->1 ->3 ->4 ->5 ->9 ->7 ->10
testcase("case8", data, 5, 8);//0 ->1 ->3 ->4 ->7 ->5 ->9 ->10
return 0;
}
用例：
