前言
秋招一般从9月份开始启动，10月份进入校园招聘的旺季，高潮会一直持续到11月底。秋招招聘企业一般以互联网、房地产、银行企业居多，时长不定，但一般而言，银行秋招结束了就意味着整个秋招的完结。秋招以规模大、专业广、选择多著称。校招通常分为内推渠道和正常校招渠道。
很多人觉得参不参加秋招都无所谓，因为后面还有一个春招，但是个人建议最好去参加，因为秋招的公司一般都是大公司，门槛相对来说要高，即使没有拿到offer也可以感受一下求职的氛围，知道求职过程需要注意什么，以免未来的求职发生不应该出现的插曲，同时也可以学习一下面试技巧，锻炼一下内心的承受能力，以及面试过程中的口头表达能力。
当然，有些人觉得秋招使人迷茫绝望、自卑崩溃、自我怀疑，这坑定会出现的，因为在面试过程中，你可能会被面试官问的哑口无言，甚至怼到你怀疑人生，并自我否认自己所学。如果想要进大厂，甚至是BAT（百度、腾讯、阿里）、美团。字节等公司，就必然会受到打击，随之出现的就是自我否认。因此要相信人上有人，并不是每个人都是面霸，比你优秀的人比比皆是，找工作需要就是做好心理准备，放平心态，此地不留爷，自有留爷处。
感谢道友的鼓励与支持 ，往期文章都在最后梳理出来了(●'◡'●)
内推码
海康威视内推码：G0M3R4
登录海康威视校招官网campushr.hikvision.com 进行网申
内推码
秋招经历
2022届秋招基本告一段落，经历了三个月左右的时间，有很多的感想和苦涩。经历秋招收获很多，没经历过秋招错过很多。秋招机会多、公司多、岗位也多，从中你可以自己针对自己的能力进行指定挑选。
正常秋招的流程：网申→宣讲会（一般现场投递会增加入选概率、但如果只是企业吹牛逼而没有现场投递简历和面试环节的就可以不用去）→网测（谷歌浏览器）、线上笔试→一面→二面→终面→发放offer→试岗、企业文化体验之旅、体检→培训、实习
（今年因为疫情原因参加都是线上空中宣讲会，面试和笔试也都是参加线上面试）
接下来总结一下自己投递过的公司以及拿到的offer
- 人人网（一面挂）
- 基恩士（一面挂）
- 腾讯云智研发中心（二面挂）
- 福建中科光芯光电科技有限公司（没消息）
- 北京天融信科技有限公司（没消息）
- 杰瑞股份集团（offer-拒）
- 北京七星华创微电子（offer-拒）
- 鼎桥通信（offer-拒）
- 深圳创维（offer-拒）
- 中科曙光（offer-拒）
- 海康威视（offer-签约）
- 京东方（笔试完）
- 招商银行（一面结束，等消息）
- 民生银行（二面结束，等消息）
- 工商银行（一面结束，等消息）\
（凭借记忆把目前的公司汇总，可能还有一些投了的不记得了，也没有消息）
最开始让我进入秋招的公司就是北京人人网和基恩士，最开始什么都不知道，收到面试通知后也没有做什么准备，一头蒙的状态进行了面试，加之这两家公司的面试时间就是一前一后，结果可想而知，被面试官一顿顿的摩擦，最可恶就是人人网面试期间居然在线考查代码能力，这又让自己对自己的严重怀疑是不是干这行的料。。。。
有了前车之鉴，自己开始认认真真的准备，首先就是对自己的简历进行一轮全面更新，然后就是有针对性的收集笔试和面试资料。
简历特色
工作经历用STAR法则
STAR法则是情境(situation)、任务(task)、行动(action)、结果(result) 四项的缩写而成。
Situation：事情是在什么情况下发生。Task：你是如何明确你的任务的。Action：针对这样的情况分析，你采用了什么行动方式。Result：结果怎样，在这样的情况下你学习到了什么。
主要就是需要体现你做了什么，做成了什么。强调使用star法则的好处就是：HR能够清楚的知道，你做了些什么，做成了什么。\
工作经历要与岗位匹配，匹配更多的岗位要求，获得面试的机会的可能性更大。并不是一味把所有经历都写上，只需要调最重要的写。
好的简历需要具备以下八大要素：
-
内容框架清晰，形式简洁明了，包含如下框架：
基本信息、教育背景、实习经历、项目经验、校园实践、获奖情况、个人技能、自我评价
（技巧：可适当标出重点）\ -
基本信息只写必须项
姓名、出生日期、联系方式、邮箱、籍贯、政治面貌 -
教育信息只写亮点
-
实习经历有条理描述（多用数字化）
-
项目经验体现专业能力
-
校园实践要与岗位能力模型沾边
-
获奖情况挑有分量的写
-
个人技能要切合岗位描述
面经分享
面试（重点内容，成功关键，要点：真诚，真实，有礼貌谦逊，精气神，有血有肉有趣）
◆ 个人形象：衣着，发型，领带，正装，淡妆，精气神等，我们都知道一个清新精干给人亲和力的人永远是让人喜欢的人，毕竟是个看脸的社会
◆ 自我介绍：中英文1分钟3分钟5分钟各准备一套，这是为什么呢？因为每个企业要求不同呀，有的需要你英文介绍有的需要你中文，有的要你用一分钟自我介绍有的三分钟，所以都备全了以防万一。
切记不要吹牛逼，简历上有的面试官都知道心里都有数，你一上来就说自己多厉害多厉害拿过多少多少奖只会降低你的印象分，如果想展示自己的优点可以用委婉的方式，装逼于无形之中。\
个人意见是个人基本信息+简历上没有的有趣的亮点、经历。
C/C++常问问题
- C和C++的区别
C语言是面向过程的语言，而C++是面向对象的过程。
C++比C语言的增强点：
1、命名空间；
2、实用性加强；
3、register关键字；
4、变量检测加强；
5、struct 加强。
- 面向对象和面向过程
面向过程就是分析解决问题的步骤，然后用函数把这些步骤一步一步的进行实现，在使用的时候进行一一调用就行了，注重的是对于过程的分析。
面向对象则是把构成问题的事进行分成各个对象，建立对象的目的也不仅仅是完成这一个个步骤，而是描述各个问题在解决的过程中所发生的行为。
- 面向对象的三大特征\
（1）封装：将一类事物的属性和行为抽象为一个类，使属性私有化，行为公开化，提高数据隐蔽性，复用性高
对于封装来说就是数据与具体操作实现的代码都放在某个对象的内部，使这些代码的具体细节不被外界发现，只留下一些接口供外部来使用，而不能一任何的形式来对象内部的实现。使用封装能够隐藏具体的实现的细节，使代码更加易于维护并且保证了系统的安全性。
（2）继承：进一步将属性和行为抽象为一个父类，每一个子类拥有父类的行为和属性，也有自己的行为和属性
继承机制是面向对象程序设计使代码进行复用的最重要的手段，允许在保证类原有类特性的基础上进行扩展来增加功能。这样新产生的类就被称为派生类，继承就可以表现面向对象机制的的层次结构。
（3）多态：接口复用
多态简单点说就是“一个接口，多种实现”，就是同一种事物表现出的多种形态。多态在面向对象语言中是指：接口多种的不同实现方式。也就是复用相同接口，实现不同操作。
- static与const的区别
（1）const定义的常量在超出其作用域之后其空间会被释放，而static定义的静态常量在函数执行后不会释放其存储空间
（2）在C++中，static静态成员变量不能在类的内部初始化。在类的内部只是声明，定义必须在类定义体的外部，通常在类的实现文件中初始化，如：double Account::Rate = 2.25;static关键字只能用于类定义体内部的声明中，定义时不能标示为static
（3）在C++中，const成员变量也不能在类定义处初始化，只能通过构造函数初始化列表进行，并且必须有构造函数
（4）const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的；const数据成员的初始化只能在类的构造函数的初始化列表中进行
（5）const成员函数主要目的是防止成员函数修改对象的内容。即const成员函数不能修改成员变量的值，但可以访问成员变量。
static成员函数主要目的是作为类作用域的全局函数。不能访问类的非静态数据成员。
- 指针和引用的区别
相同点：
1). 都是地址的概念；
2). 都是“指向”一块内存。指针指向一块内存，它的内容是所指内存的地址；而引用是某块内存的别名；
3). 引用在内部实现其实是借助指针来实现的，一些场合下引用可以替代指针，比如作为函数形参。
不同点：
（1）指针：一个变量，存储的内容为一个地址；引用：给一个已有对象起的别名
（2）指针是一个实体，需要分配内存空间；引用知识变量别名，不需要分配内存空间
（3）可以有多级指针，不能有多级引用
（4）自增（++）运算结果不一样
（5）指针是间接访问，引用是直接访问
（6）“sizeof 引用" = 指向变量的大小 ， "sizeof 指针"= 指针本身的大小
（7）引用不能为空，指针可以为空
- 指针与数组的区别\
（1）数组对应着一块内存，而指针是指向一块内存。数组的地址和空间大小在生命周期不会发生改变，内容可能会发生改变，而指针指向的内存大小可以随时发生改变。当指针指向常量字符串时，它的内容不可以改。
（2）计算容量的区别：用sizeof计算出数组的元素个数，无法计算指针所指向内存的大小
（3）数组名是常量指针，指针是变量指针
（4）对数组用&和对指针&的意义不同，此时数组名不在当成指向一个元素的常量指针来使用
- C/C++内存有几种类型
1、栈（如局部变量、函数参数）― 由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆（malloc）― 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收 。
3、全局区（静态区）（static）― 全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。- 程序结束后有系统释放
4、常量存储区 ― 常量字符串就是放在这里的。程序结束后由系统释放
5、程序代码区 ― 存放函数体的二进制代码。
- 线程与进程
1、 线程是进程的一部分，所以线程有的时候被称为是轻权进程或者轻量级进程。
2、 一个没有线程的进程是可以被看作单线程的，如果一个进程内拥有多个进程，进程的执行过程不是一条线（线程）的，而是多条线（线程）共同完成的。
3、 系统在运行的时候会为每个进程分配不同的内存区域，但是不会为线程分配内存（线程所使用的资源是它所属的进程的资源），线程组只能共享资源。那就是说，出了CPU之外（线程在运行的时候要占用CPU资源），计算机内部的软硬件资源的分配与线程无关，线程只能共享它所属进程的资源。
4、 与进程的控制表PCB相似，线程也有自己的控制表TCB，但是TCB中所保存的线程状态比PCB表中少多了。
5、 进程是系统所有资源分配时候的一个基本单位，拥有一个完整的虚拟空间地址，并不依赖线程而独立存在。
- 多线程同步与互斥
线程同步是指线程之间所具有的一种制约关系，一个线程的执行依赖另一个线程的消息，当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒。
线程互斥是指对于共享的进程系统资源，在各单个线程访问时的排它性。当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源。线程互斥可以看成是一种特殊的线程同步
- 静态链表和动态链表
静态链表和动态链表是线性表链式存储结构的两种不同的表示方式。
1、静态链表是用类似于数组方法实现的，是顺序的存储结构，在物理地址上是连续的，而且需要预先分配地址空间大小。所以静态链表的初始长度一般是固定的，在做插入和删除操作时不需要移动元素，仅需修改指针。
2、动态链表是用内存申请函数（malloc/new）动态申请内存的，所以在链表的长度上没有限制。动态链表因为是动态申请内存的，所以每个节点的物理地址不连续，要通过指针来顺序访问。
- 链表与数组的关系
数组存放数据时，必须事先定义数组长度，如果不知道具体长度，只能定义一个足够大的长度
链表则没有这种缺点，他能根据需要开辟内存单元
- 指针数组和数组指针
指针数组：指针数组可以说成是”指针的数组”，首先这个变量是一个数组，其次，”指针”修饰这个数组，意思是说这个数组的所有元素都是指针类型，在32位系统中，指针占四个字节。int *p[n]
数组指针：数组指针可以说成是”数组的指针”，首先这个变量是一个指针，其次，”数组”修饰这个指针，意思是说这个指针存放着一个数组的首地址，或者说这个指针指向一个数组的首地址。int (*p)[n]
- 函数指针与指针函数
函数指针：与整型指针类似，整型指针为指向整型的指针，函数指针为指向函数的指针，是指针变量，他与函数名无关，只与参数列表和返回类型有关；
指针函数：本质是函数，返回值为一个指针。
- 内存泄漏和内存溢出
内存溢出是指程序在申请内存时，没有足够的内存空间供其使用。原因可能如下：
（1）内存中加载的数据量过于庞大，如一次从数据库取出过多数据
（2）代码中存在死循环或循环产生过多重复的对象实体
（3）递归调用太深，导致堆栈溢出等
（4）内存泄漏最终导致内存溢出
内存泄漏是指向系统申请分配内存进行使用（new），但是用完后不归还（delete），导致占用有效内存。常见的几种情况：
（1）在类的构造函数和析构函数中没有匹配的调用new和delete函数
两种情况下会出现这种内存泄露：一是在堆里创建了对象占用了内存，但是没有显示地释放对象占用的内存；二是在类的构造函数中动态的分配了内存，但是在析构函数中没有释放内存或者没有正确的释放内存
（2）在释放对象数组时在delete中没有使用方括号
方括号是告诉编译器这个指针指向的是一个对象数组，同时也告诉编译器正确的对象地址值病调用对象的析构函数，如果没有方括号，那么这个指针就被默认为只指向一个对象，对象数组中的其他对象的析构函数就不会被调用，结果造成了内存泄露。
（3）没有将基类的析构函数定义为虚函数
- new与malloc以及delete与free
都可以用于申请动态内存和释放内存
1.malloc与free是C++/C的标准库函数，可以覆盖。
2.new/delete是C++的运算符,可以重载。
3.new调用构造函数，delete会调用对象的析构函数,对非内部数据类型的对象来说，malloc/free无法满足动态对象的要求。
4.new/delete返回的是某种类型的指针，malloc/free返回的是void指针
5.new建立的是一个对象，malloc分配的是一块内存
- delete与delete[]
1.delete只调用一次析构函数，delete[]会调用每个成员的析构函数。
2.new与delete、new []与delete[]配套使用
3.对于内置数据类型，2者无区别。对于复杂的数据类型，delete和delete[]不能互用。
- 变量的声明和定义
为变量分配地址和存储空间的称为定义，不分配地址的称为声明。
一个变量可以在多个地方声明，但是只在一个地方定义。
加入 extern 修饰的是变量的声明，说明此变量将在文件以外或在文件后面部分定义。
说明：很多时候一个变量，只是声明不分配内存空间，直到具体使用时才初始化，分配内存空间，如外部变量。
- 简述strcpy/sprintf/memcpy的区别
操作对象不同，strcpy 的两个操作对象均为字符串，sprintf 的操作源对象可以是多种数据类型，目的操作对象是字符串，memcpy 的两个对象就是两个任意可操作的内存地址，并不限于何种数据类型。
执行效率不同，memcpy 最高，strcpy 次之，sprintf 的效率最低。
实现功能不同，strcpy 主要实现字符串变量间的拷贝，sprintf 主要实现其他数据类型格式到字符串的转化，memcpy 主要是内存块间的拷贝。
- 深拷贝与浅拷贝
浅拷贝：只是拷贝了基本类型的数据，而引类型数据，复制后也是会发生引用，浅拷贝只是指向被复制的内存地址，如果原来对象呗修改，那么浅拷贝出来的对象也会被修改。
深拷贝：在计算机中开辟一块新内存用于存放复制的对象。因此要用new或者malloc等。
- 程序崩溃的原因
（1）读取未赋值的变量
（2）函数栈溢出
（3）数组越界访问
（4）指针的目标对象不可用
#include <stdio.h>
#define LEN 10 //数组长度
void main( void )
{
int ARRAY[10] = { 0, 6, 3, 2, 7, 5, 4, 9, 1, 8 }; //待排序数组
printf( "\n" );
for( int a = 0; a < LEN; a++ ) //打印数组内容
{
printf( "%d ", ARRAY[a] );
}
int i = 0; int j = 0;
bool isChange; //设定交换标志
for( i = 1; i < LEN; i++ )
{ //最多做 LEN-1 趟排序
isChange = 0; //本趟排序开始前,交换标志应为假
for( j = LEN-1; j >= i; j-- ) //对当前无序区 ARRAY[i..LEN]自下向上扫描
{
if( ARRAY[j+1] < ARRAY[j] )
{ //交换记录
ARRAY[0] = ARRAY[j+1]; //ARRAY[0]不是哨兵,仅做暂存单元
ARRAY[j+1] = ARRAY[j];
ARRAY[j] = ARRAY[0];
isChange = 1; //发生了交换,故将交换标志置为真
}
}
}
printf( "\n" );
for( a = 0; a < LEN; a++) //打印本次排序后数组内容
{
printf( "%d ", ARRAY[a] );
}
if( !isChange )
{
break;
} //本趟排序未发生交换,提前终止算法
printf( "\n" ); return;
}
- 堆排序
void createHeep(int ARRAY[], int sPoint, int Len) //生成大根堆
{
while ((2 * sPoint + 1) < Len){
int mPoint = 2 * sPoint + 1;
if ((2 * sPoint + 2) < Len){
if (ARRAY[2 * sPoint + 1] < ARRAY[2 * sPoint + 2]){
mPoint = 2 * sPoint + 2;
}
}
if (ARRAY[sPoint] < ARRAY[mPoint]) //堆被破坏，需要重新调整
{
int tmpData = ARRAY[sPoint]; //交换 sPoint 与 mPoint 的数据
ARRAY[sPoint] = ARRAY[mPoint];
ARRAY[mPoint] = tmpData;
sPoint = mPoint;
}
else{
break; //堆未破坏，不再需要调整
}
}
return;
}
void heepSort(int ARRAY[], int Len) //堆排序
{
int i = 0;
for (i = (Len / 2 - 1); i >= 0; i--) //将 Hr[0，Lenght-1]建成大根堆
{
createHeep(ARRAY, i, Len);
}
for (i = Len - 1; i > 0; i--){
int tmpData = ARRAY[0]; //与最后一个记录交换
ARRAY[0] = ARRAY[i];
ARRAY[i] = tmpData;
createHeep(ARRAY, 0, i); //将 H.r[0..i]重新调整为大根堆
}
return;
}
int main(void)
{
int ARRAY[] = { 5, 4, 7, 3, 9, 1, 6, 8, 2 };
printf("Before sorted:\n"); //打印排序前数组内容
for (int i = 0; i < 9; i++)
{
printf("%d ", ARRAY[i]);
}
printf("\n");
heepSort(ARRAY, 9); //堆排序
printf("After sorted:\n"); //打印排序后数组内容
for (i = 0; i < 9; i++)
{
printf("%d ", ARRAY[i]);
}
printf("\n");
}
- 基数排序
#include <stdio.h>
#include <malloc.h>
#define LEN 8
typedef struct node //队列结点
{
int data;
struct node * next;
}node, *QueueNode;
typedef struct Queue //队列
{
QueueNode front;
QueueNode rear;
}Queue, *QueueLink;
QueueLink CreateNullQueue(QueueLink &Q) //创建空队列
{
Q = NULL;
Q = (QueueLink)malloc(sizeof(Queue));
if (NULL == Q)
{
printf("Fail to malloc null queue!\n");
return NULL;
}
Q->front = (QueueNode)malloc(sizeof(node));
Q->rear = (QueueNode)malloc(sizeof(node));
if (NULL == Q->front || NULL == Q->rear)
{
printf("Fail to malloc a new queue's fornt or rear!\n");
return NULL;
}
Q->rear = NULL;
Q->front->next = Q->rear;
return Q;
}
int lenData(node data[], int len) //计算队列中各结点的数据的最大位数
{
int m = 0;
int temp = 0;
int d;
for (int i = 0; i < len; i++)
{
d = data[i].data;
while (d > 0)
{
d /= 10;
temp++;
}
if (temp > m)
{
m = temp;
}
temp = 0;
}
return m;
}
QueueLink Push(QueueLink &Q, node node) //将数据压入队列
{
QueueNode p1, p;
p = (QueueNode)malloc(sizeof(node));
if (NULL == p)
{
printf("Fail to malloc a new node!\n");
return NULL;
}
p1 = Q->front;
while (p1->next != NULL)
{
p1 = p1->next;
}
p->data = node.data;
p1->next = p;
p->next = Q->rear;
return NULL;
}
node Pop(QueueLink &Q) //数据出队列
{
node temp;
temp.data = 0;
temp.next = NULL;
QueueNode p;
p = Q->front->next;
if (p != Q->rear)
{
temp = *p;
Q->front->next = p->next;
free(p);
p = NULL;
}
return temp;
}
int IsEmpty(QueueLink Q)
{
if (Q->front->next == Q->rear)
{
return 0;
}
return 1;
}
int main(void)
{
int i = 0;
int Max = 0; //记录结点中数据的最大位数
int d = 10;
int power = 1;
int k = 0;
node Array[LEN] = { { 450, NULL }, { 32, NULL }, { 781, NULL }, { 57, NULL }, 组
{ 145, NULL }, { 613, NULL }, { 401, NULL }, { 594, NULL } };
//队列结点数
QueueLink Queue[10];
for (i = 0; i < 10; i++)
{
CreateNullQueue(Queue[i]); //初始化队列数组
}
for (i = 0; i < LEN; i++)
{
printf("%d ", Array[i].data);
}
printf("\n");
Max = lenData(Array, LEN); //计算数组中关键字的最大位数
printf("%d\n", Max);
for (int j = 0; j < Max; j++) //按位排序
{
if (j == 0) power = 1;
else power = power *d;
for (i = 0; i < LEN; i++)
{
k = Array[i].data / power - (Array[i].data / (power * d)) * d;
Push(Queue[k], Array[i]);
}
for (int l = 0, k = 0; l < d; l++) //排序后出队列重入数组
{
while (IsEmpty(Queue[l]))
{
Array[k++] = Pop(Queue[l]);
}
}
for (int t = 0; t < LEN; t++)
{
printf("%d ", Array[t].data);
}
printf("\n");
}
return 0;
}
拖offer
拿到offer后，公司都会催你签三方协议，如果目前为止还不是你心仪的或者还没做好决定，此时你该怎么办？
以下是几个拖offer的“借口”，仅供参考
a,我现在的实习还没结束还要写毕业实习手册等实习单位盖章，盖章的hr admin休假了没法敲章
b,三方协议学校还没发，下个学期才会发
c,最近回学校答辩了比较忙，等忙完这件事就回来签协议
d,有事去了外地我下个星期回来再签
