面试中||HWIT

一面：技术面
1、自我介绍，了解

2、计算机安全有哪些方面？
（从密码学课程方向回答的话）
(1)设备安全
(2)数据安全
(3)内容安全
(4)行为安全

3、协议框架怎么看？
（感觉更加想要往安全的方向回答）
我从OSI七层回答：
（1）数据链路层：SDLC、HDLC、PPP、STP
（2）网络层：IP,、ICMP、IGMP、ARP、RARP和OSPF
（3）传输层：TCP，UCP
（4）应用层： FTP、SMTP、HTTP

4、顺着上面协议题，问我22端口是哪个协议？还有其他的协议是哪个端口的？
（查了个表，还真没发现22端口时干啥的，然后其他的协议端口也有点乱。。。）

查阅百度：22端口是ssh端口（安全终端）

5、Web安全有哪些方面？
（1）SSL/TLS

（2）安全电子协议（SET）

6、SQL注入：
SQL注入是比较常见的网络攻击方式之一，它不是利用操作系统的BUG来实现攻击，而是针对程序员编写时的疏忽，通过SQL语句，实现无账号登录，甚至篡改数据库。

7、内存泄露
动态分配内存所开辟的空间，在使用完毕后未手动释放，导致一直占据该内存，即为内存泄漏。
（1）造成内存泄漏的几种原因：
1）类的构造函数和析构函数中new和delete没有配套
2）在释放对象数组时没有使用delete[]，使用了delete
3）没有将基类的析构函数定义为虚函数，当基类指针指向子类对象时，如果基类的析构函数不是virtual，那么子类的析构函数将不会被调用，子类的资源没有正确释放，因此造成内存泄露
4）没有正确的清楚嵌套的对象指针
（2）避免方法：
malloc/free要配套
使用智能指针；
将基类的析构函数设为虚函数；

8、顺着内存泄露，问内存泄露与缓冲区溢出的关系？
（乍一看还以为是内存溢出，审准了才发现啥也不知道）
（以下来自百度）
缓冲区溢出：向缓冲区填充的数据位数超过了缓冲区自身的容量限制时，发生的缓冲区溢出覆盖在合法的数据。
（猜测是：内存泄漏的堆积，会最终消耗尽系统所有的内存，然后就导致缓冲区变小，然后缓冲区溢出？）

9、手撕代码：
给出字符序列和单词表，尝试用字符序列中的字母表示单词表中的每个单词，统计可表示的单词的总长度：
例如单词表s=[“bat”,“cat”]，字符序列p=“atbd”，那么可以表示的单词有“bat”，即总长度为3；
我的方法：暴力解答！

int fun(string s, vector<int> f) {
	int len = s.length();
	for (int i = 0; i < len; i++) {
		f[s[i] - 'a']--;
		if (f[s[i] - 'a'] < 0) return 0;//缺少字符
	}
	return len;//成功匹配则返回长度
}
int main()
{
	//输入
	/*string s[3] = { "hello","world","leetcode" };
	int n = 3;
	string p="welldonehoneyr";*/
	string s[4]={"cat","bt","hat","tree"};
	int n=4;
	string p="atacht";

	vector<int> f(26,0);//（小写字母的）字符数数组
	int count = 0;
	for (int i = 0; i < p.length(); i++) {//统计字符
		f[p[i] - 'a']++;
	}
	for (int i = 0; i < n; i++) {//遍历单词表
		count+=fun(s[i], f);
	}
	cout << count << endl;
}

二面：技术面
1、介绍下项目（重点，问了好多）
（1）流水车间调度问题（失败项目），描述这个问题，说一下怎么做，参考了一些论文，说了自己的论文看法（遗传+蒙特卡罗算法，遗传+聚类），因为没有成功也说了下自己预想的改进方向（遗传+粒子群+决策树）
（2）人工智能算法比赛（组队获奖），自己的工作，身份，大概运用了图像处理的方法，用均值滤波、中值滤波和拉普拉斯锐化算法等去噪、锐化验证码边缘。

这里因为我写了使用DOCKER封装代码程序，有问docker是啥，有无使用过：
（以下来自百度）
Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中,然后发布到任何流行的Linux机器或Windows 机器上,也可以实现虚拟化,容器是完全使用沙箱机制,相互之间不会有任何接口。
一个完整的Docker有以下几个部分组成：
1)DockerClient客户端
2)Docker Daemon守护进程
3)Docker Image镜像
4)DockerContainer容器

2、指针与引用
（1）指针是一个新的变量，指向另一个变量的地址，我们可以通过访问这个地址来修改另一个变量；而引用是一个别名，对引用的操作就是对变量的本身进行操作
（2）指针可以有多级，引用只有一级
（3）传参的时候，使用指针的话需要解引用才能对参数进行修改，而使用引用可以直接对参数进行修改
（4）指针的大小一般是4个字节，引用的大小取决于被引用对象的大小（指的是使用sizeof运算符得到的结果，引用本质上还是使用指针，因此所占内存和指针是一样的）
（5）指针可以为空，引用不可以。

在函数参数传递的时候，什么时候使用指针，什么时候使用引用？
需要返回函数内局部变量的内存的时候用指针。使用指针传参需要开辟内存，用完要记得释放指针，不然会内存泄漏。而返回局部变量的引用是没有意义的
对栈空间大小比较敏感（比如递归）的时候使用引用。使用引用传递不需要创建临时变量，开销要更小
类对象作为参数传递的时候使用引用，这是C++类对象传递的标准方式。

3、对于main函数，有什么办法可以在main之前运行
（我的回答）
（1）考虑栈运行，可以独立设计函数，栈后进先出就可以仙女运行其他函数；
（2）全局变量，常量等，在编译的时候就确定，不必等到运行时。

（来自百度）如何在main函数之前和之后运行
总体想法是构造函数：
（1）全局变量
（2）静态变量
（3）include文件中的全局或静态变量
（4）namespace中

4、多态，虚函数（重点在虚函数）
（1）多态则是“一个接口，多个实现”，通过子类重写父类的虚函数，实现了接口重用
（2）C++的虚函数是实现多态的机制。它是通过虚函数表实现的，虚函数表是每个类中存放虚函数地址的指针数组，类的实例在调用函数时会在虚函数表中寻找函数地址进行调用，如果子类覆盖了父类的函数，则子类的虚函数表会指向子类实现的函数地址，否则指向父类的函数地址。一个类的所有实例都共享同一张虚函数表
C++虚函数剖析

5、今后会怎么提高自己？
（1）意识
（2）计划；
（3）整体性把握，目标
（4）向周围的人学习

6、问我有什么问题？
询问安全的学习方向：
回：
（1）基础原理
（2）技术栈
（3）设计模式

7、手撕代码：
给定一系列物品大小，给出当前背包最大容量，求最大的容纳量：
我的解答：贪心算法

int fun(vector<int> a, int n, int start, int num,int res) {
	if (start == n) {
		return 0;
	}
	int r = res;
	for (int i = start; i < n; i++) {
		if (a[i] > num) return res;
		res = max(res, r+a[i] + fun(a, n, i+1, num - a[i],r));
	}
	return res;
}

int main()
{
	int n;
	int num;
	while (cin >> n) {
		//输入
		vector<int> a(n, 0);
		for (int i = 0; i < n; i++) {
			cin >> a[i];
		}
		cin >> num;
		sort(a.begin(), a.end());//排序
		//贪心算法
		cout << fun(a, n, 0, num,0) << endl;
	}
}

三面：主管面
1、最大优点

2、做过的项目，针对我提到的一些算法问为什么？

3、有没有安全相关的项目？
课设。。。

4、在项目中遇到的最难的问题，怎么解决？
界面设计，界面接口，多参考工业设计

5、成绩如何？有无参加过安全竞赛，为什么？
自身把握不准
（1）没意识；
（2）没计划，没目标
（3）缺少途径

6、虚函数的原理？
参考上面二面内容

7、进程的通信方式：
（1）消息队列
（2）信号量
（3）信号
（4）共享内存
（5）套接字
（6）管道

8、互斥？
指在某一时刻指允许一个进程运行其中的程序片

9、并发？线程如何实现并发？
并发指的是两个或多个独立的活动在同一时段内发生
线程就像轻量级的进程，每个线程相互独立运行，但它们共享地址空间，所有线程访问到的大部分数据如指针、对象引用或其他数据可以在线程之间进行传递，它们都可以访问全局变量

10、死锁是什么？死锁怎么解决？举个例子？
（1） 互斥：一个资源每次只能被一个进程使用。
（2） 占有并请求：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3） 不可剥夺:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4） 循环等待:若干进程之间形成一种头尾相接的循环等待资源关系。
产生死锁的原因主要是：
（1） 因为系统资源不足。
（2） 进程运行推进的顺序不合适。
（3） 资源分配不当等。
死锁的恢复：
（1）重新启动：是最简单、最常用的死锁消除方法，但代价很大，因为在此之前所有进程已经完成的计算工作都将付之东流，不仅包括死锁的全部进程，也包括未参与死锁的全部进程。
（2）终止进程(process termination)：终止参与死锁的进程并回收它们所占资源。

1. 一次性全部终止；2) 逐步终止(优先级，代价函数)
   （3）剥夺资源(resource preemption):剥夺死锁进程所占有的全部或者部分资源。
2. 逐步剥夺：一次剥夺死锁进程所占有的一个或一组资源，如果死锁尚未解除再继续剥夺，直至死锁解除为止。
3. 一次剥夺：一次性地剥夺死锁进程所占有的全部资源。
   （4）进程回退(rollback):让参与死锁的进程回退到以前没有发生死锁的某个点处，并由此点开始继续执行，希望进程交叉执行时不再发生死锁。但是系统开销很大：
4. 要实现“回退”，必须“记住”以前某一点处的现场，而现场随着进程推进而动态变化，需要花费大量时间和空间。
5. 一个回退的进程应当“挽回”它在回退点之间所造成的影响，如修改某一文件，给其它进程发送消息等，这些在实现时是难以做到的

10、学习过哪些关于安全的课程，有什么收获，对安全有什么认识？

11、有什么要问的吗？
（1）技术倾向
（2）有没有基于身份的框架能够解决所有的安全问题？（这个问题是尝试根据上面技术倾向的回答问的，为了没显得那么单一）

------------------------------补充---------------------------------------
12、有没有在课程之后使用计算机知识？
在数学建模时。。。。