嵌入式软件工程师/linux c程序员 面试经验总结

最近也没有时间写博客，原因简单，忙着找工作，一天面试2-3家，早出晚归一天累的死去活来，混口饭吃真TM的不容易啊！在上一家公司日子比较清闲也没什么大项目，在空闲和业余时间我先后熟读了《Unix环境高级编程》、《Unix进程间通信》、《大话数据结构》、《Unix网络编程》最后一本还没来得急看完，个人理解做应用开发就这四方面的知识就够了。其次你想练练C语言功底得读读《c陷阱》、《c专家编程》、《c和指针》、还有一本功能书《c primer plus中文版》还有很多好书不一一列举。我换工作的目的很简单，作为北漂一族为别人打工无非两点：第一、为钱，工资待遇好，干什么并不重要。第二、能学到本事。我可能属于第三种，既没有好的待遇，也学不到东西，所以我毅然决然的辞掉了工作，苦逼的屌丝生活不是我想要的。找工作其实挺简单，但是要想找个好工作难，没有学历，没有能力就难上加难了。在北京这PM2.5天天爆表的城市里，牛人太多太多，你不出去走走永远不知道自己有多么的渺小（不是自卑），随处可见拿着5位数工资的人。在北京这种人人都像被打了鸡血一样的城市，你不努力迟早被淘汰，现实就是这样，打住..........有时候你必须得把心态放宽些，走好脚下的路，世界上多数人都是普普通通的，只有极少数人能成功。我们不能人云亦云，大多数人认为是对的不一定对，大多数人认为是错的它不一定错。有句古话叫“机会掌握在少数人手中！”，我们在社会的大潮中做人做事必须时时刻刻过过自己的脑子。

最后说说面试经验：对程序员来说无非两点：第一、笔试，第二、面试。

笔试，笔试这东西就靠硬功夫了，靠自己平时的编程积累，和临场的随机应变（有时候面试官会临时出个题目给你）。可以在网上下载些相关的资料做做，一般公司的笔试题都是十分简单的，对于有工作经验的是人来说就是一个简单的参考。

面试，面试这玩意真不好说，有时候还的看人品。每个面试官都有自己的性格，他们通常会根据自己的性格喜好和公司的团队氛围来估量面试者是否合适，过了初试那关，这面试就显得十分重要。对于程序员面试的时候通常面试官会根据你的简历问一些相关的项目，他会根据公司岗位要求技能对你进行考察，你得事先做好充分的准备：第一、查看HR给的发的岗位要求，因为这些要求是面试的时候肯定会被问到的。第二、了解公司行业所从事的方向，自己估量会用到哪些技术。第三、结合岗位要求重点想想自己有没有做过这方面的项目，到时候任由你发挥。第四、面试的时候一定要从容自信（我做的还不够），最好面带笑容这样不但能缓解气氛，也能给面试官留下好影响。

以上内容纯属个人见解，下面贴上2013年3月13号-2013年3月26号中面试所遇到的题目，很简单这里拿来与大家分享。下周一就要上班了，面试我的是个大美女，心理暗喜，最后希望自己在新公司能尽快的融入团队、能快速的定位自己、不断的成长和提高，好好工作，幸福生活每一天！

一、什么叫可重入？
可重入函数主要用于多任务环境中，一个可重入的函数简单来说就是
可以被中断的函数，也就是说，可以在这个函数执行的任何时刻中断
它，转入OS调度下去执行另外一段代码，而返回控制时不会出现什么
错误；而不可重入的函数由于使用了一些系统资源，比如全局变量区，
中断向量表等，所以它如果被中断的话，可能会出现问题，这类函数是
不能运行在多任务环境下的。

二、tcp/IP三次握手？
1.首先客户端通过向服务器端发送一个SYN来建立一个主动打开，作为三
路握手的一部分。(同步位为1)
2. 然后服务器端应当为一个合法的SYN回送一个SYN/ACK。（同步位和确
认位都为1）
3. 最后，客户端再发送一个ACK。这样就完成了三路握手，并进入了连接
建立状态。（确认位位1）

三、TCP/IP通信阻塞和非阻塞？
阻塞：当socket的接收缓冲区中没有数据时，read调用会一直阻
塞住，直到有数据到来才返回。当socket缓冲区中的数据量小于期望读取
的数据量时，返回实际读取的字节数。当socket的接收缓冲区中的数据大于
期望读取的字节数时，读取期望读取的字节数，返回实际读取的长度。
非阻塞：socket的接收缓冲区中有没有数据，read调用都会立刻返回。接收
缓冲区中有数据时，与阻塞socket有数据的情况是一样的，如果接收缓冲区
中没有数据，则返回错误号为EWOULDBLOCK,表示该操作本来应该阻塞的，但
是由于本socket为非阻塞的socket，因此立刻返回，遇到这样的情况，可
以在下次接着去尝试读取。如果返回值是其它负值，则表明读取错误。
因此，非阻塞的rea调用一般这样写:
if ((nread = read(sock_fd, buffer, len)) < 0)
{
if (errno == EWOULDBLOCK)
{
return 0; //表示没有读到数据
}
else 
return -1; //表示读取失败
}else return nread;  //读到数据长度

四、TCP/UDP区别？
TCP---传输控制协议,提供的是面向连接、可靠的字节流服务。当客户和服务器
彼此交换数据前，必须先在双方之间建立一个TCP连接，之后才能传输数据。TCP
提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端
传到另一端。

UDP---用户数据报协议，是一个简单的面向数据报的运输层协议。UDP不提供可靠
性，它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它们能到达
目的地。由于UDP在传输数据报前不用在客户和服务器之间建立一个连接，且没有
超时重发等机制，故而传输速度很快

五、林锐内存思考？
（1）
void GetMemory(char *p) 
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
答：程序崩溃因为GetMemory并不能
传递动态内存，Test函数中的 str一
直都是NULL
strcpy(str, "hello world");
将使程序崩溃 

（2）
char *GetMemory(void) 
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}
答：可能是乱码 因为GetMemory返回的
是指向栈内存的指针，该指针的地址
不是 NULL，但其原现的内容已经被清
除，新内容不可知

（3）
void GetMemory2(char **p, int num) 
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
答： （1）能够输出hello （2）内存泄漏没有free

（4）
void Test(void) 
{
char *str = (char *) malloc(100);
strcpy(str, hello);
free(str);
if(str != NULL)
{
strcpy(str, world);
printf(str);
}
}
答：篡改动态内存区的内容，后果难以
预料，非常危险 因为free(str);之后
str成为野指针，if(str != NULL)语句
不起作用

六、编写各种str函数？
strcpy函数
char *my_strcpy(char *dest, const char *src)
{
char *temp;

assert(dest!=NULL && str != NULL);
while((*dest++ = *src++) != '\0');

return temp;
}

char *my_strcat(char *dest, const char *stc)
{
char *temp;

assert(dest!=NULL && str != NULL);
while(*dest)
dest++;
while((*dest++ = *stc++) != '\0');

return temp;
}

char my_strstr(const char *str, char c)
{
for(; *str != c; str++)
if(*str == '\0')
return NULL;
else
return str;
}

int my_strlen(const char *str)
{
char *temp = str;
for(; *temp != '\0'; temp++);

return (int)(temp - str);
}

void *my_memcpy(void * dest, const void *src, size_t count)
{
char *temp_dest = (char *)dest;
char *temp_src = (char *)src;

assert(dest != NULL && src != NULL);

while(count--)
*temp_dest++ = *temp_src++;
return dest;
}

int my_strcmp(char *str1, char *str2)
{
int ret = 0;

while((ret = *(unsigned char*)str1 - *(unsigned char*)str2)&&*str1&&*str2)
{
str1++;
str2++;
}
if(ret < 0)
ret = -1;
else if(ret > 0)
ret = 1;
return ret;
}

七、链表操作
（1）逆序？
node *reverse_node(node *head)
{
node *record, *current;

if(head == NULL || head->next == NULL)
return head;

current = head->next;
head->next = NULL;
while(current != NULL)
{
record = current->next;
current->next = head->next;
head->next = current;
current = record;
}
return head;
}
（2）插入
node *add_node(node *head, node *data)
{
node *current = head;
while(current->next != NULL)
current = current->next;
current->next = data;
data->next = NULL;
return head;
}
（3）删除
node *del_node(node *head, node *data)
{
node *pf,*pb;
pf = head->next;

while(pf != NULL && pf->data != data->data)
{
pb = pf;
pf = pf->next;
}
if(pf->data == data->data)
{
pb->next = pf->next;
free(pf);
}
else
printf("NO node!\n");
}
（4）单链表（非循环）倒数第4个元素？
思路：让第一个元素先走四步，然后两个游标指针一起走。
node *Get_Node(node *head)
{
int i;
node *first = head;
node *back  = head;

for(i=0; i<4; i++)
{
if(first->next == NULL)
printf("Node less than four!\n");
first = first->next;
}
while(first != NULL)
{
first = first->next;
back = back->next;
}
return back;
}
（5）如何找出链表中间元素？
思路：让前一个指针每次走两步，后一个指针每次走一步。
node *Get_middle_node(node *head)
{
node *first = head;
node *back = head;

while(first != NULL)
{
first = first->next->next;
back = back->next;
}
return back;
}
（6）删除一个无头单链表的一个节点（链表很长10万以上）？
思路：把当前节点的下个节点数据拷贝到当前节点，然后删除下一个节点。
void del_node(node *del_node)
{
node *record = del_node->next;
node *current = del_node;

current->data = record->data;  //数据拷贝，假设结构体数据为data
current->next = record->next;  //指针跳转
free(record);
}
（7）如何判断一个单链表是否有环？
思路：我们用一个步长1和一个步长2的游标指针遍历链表，观察是否有两个游标相遇的时刻。
int judge_list_circle(node *head)
{
node *first = head;
node *back = head;

while(first->next != NULL && back->next->next != NULL)
{
first = first->next;
back = back->next->next;
if(first == back)
return true;
}
return false;
}

八、两种排序法(冒泡排序、选择排序)
void bubble(int a[], int n)
{
int i,j,temp;

for(i=0; ifor(j=i+1; j{
if(a[i] > a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
return 0;
}

void choise(int a[], int n)
{
int i, j, temp, min;

for(i=0; i{
min=i;
if(j=i+1; j{
if(a[i] > a[j])
min = j;
}
if(min != i)
{
temp = a[i];
a[i] = a[min];
a[min] = temp;
}
}
return 0;
}

九、字符串反转？
char str_rev(char *str, size_t len)
{
char *start = str;
char *end = str+len-1;
char ch;

if(str != NULL)
{
while(start < end)
{
ch = *start;
*start++ = *end;
*end-- = ch;
}
}
return str;
}

十、关键字volatile有什么含意 并给出三个不同的例子。
一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会
去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重
新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：
1) 并行设备的硬件寄存器（如：状态寄存器）；
2) 一个中断服务子程序中会访问到的非自动变量；
3) 多线程应用中被几个任务共享的变量；

1) 一个参数既可以是const还可以是volatile吗？解释为什么。
2) 一个指针可以是volatile 吗？解释为什么。
3) 下面的函数有什么错误：
int square(volatile int *ptr)
{
  return *ptr  *  *ptr;
}
答案：
1) 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想
不到地改变。它是const因为程序不应该试图去修改它。
2) 是的。尽管这并不很常见。一个例子是当一个中断服务子程序修该一个指向一个buffer的指针时。
3)这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向
一个volatile型参数，编译器将产生类似下面的代码：
int square(volatile int *ptr)
{
int a,b;
a = *ptr;
b = *ptr;
return a * b;
}
由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：
long square(volatile int *ptr)
{
int a;
a = *ptr;
return a * a;
}

十一、内存分配应该注意什么问题？
1、检查内存分配是否成功。
2、内存生命周期，程序结束时记得free，避免内存泄露。
3、使用过程中避免指针越界访问，会导致不必要的错误。

十二、字符串回文判断？
int str_is_resv(char *str)
{
int i;
int  len = strlen(str);
char *start = str;
char *end   = str+len-1;

for(i=0; i{
if(*(start+i) != *(end-i))
return -1;
}
return 0;
}

十三、字符串循环左移？
//循环左移，库函数实现 
char *str_rev1(char *str, int bit)
{
int len = strlen(str);
int n = bit%len;
char temp[128] = "";

strcpy(temp, str);
strncpy(str, str+n, len-n);
str[len-n] = '\0';
strncat(str, temp, n);

return str;
}

//循环左移，不用库函数
char *str_rev2(char *str, int bit)
{
char temp_str[128];
int i,j;
int str_len = strlen(str);
bit = bit%str_len;

for(i=0; i{
*(temp_str+i) = *(str+i);
}

for(i=0; i{
*(str+i) = *(str+bit+i);
}

for(j=0; j{
*(str+i+j) = *(temp_str+j);
}
return str;
}

十四、如何编程判断大小端？
/*返回1表示小端，返回0表示大端*/
int check_cpu_endian()
{
union 
{
unsigned int a;
unsigned char b;
}s;
s.a = 1;      //0x01 
return (s.b == 1);
}

十五、如何判断一个字节(char)里面多少bit被置1？
int count_bit(int value)
{
int i, count=0;

for(i=0; i<8; i++)
{
if(value&0x01 == 0x01)
count++;
value  = value >> 0x01;
}
return count;
}

十六、判断一个整数里面有多少个1？
int count_bit(int value)
{
int count=0; 

while(value)
{
count++;
value &= value-1;
}
return count;
}

十七、二分法查找？
int mid_serach(int arry[], int key, int size)
{
int low, high, mid;

low = 0;
high = size-1;

while(low < high)
{
mid = (low+high)/2;
if(key == arry[mid])
return mid;
else if(key < arry[mid])
high = mid-1;
else if(key > arry[mid])
low = mid+1;
}
return -1;
}

十八、字符串转成十进制数？
int str_to_int(char *str)
{
int temp = 0;

while(*str != '\0')
{
temp = temp*10 + *str - '0';
str++;
}
//temp = atol(str);    //库函数一步完成
return temp;
}

十九、OSI模型分哪几层？
物理层、数据链路层、网络层、传输层、应用层、表示层、会话层
集线器hub工作在OSI参考模型的（物理）层；
网卡工作在OSI参考模型的（物理）层；
路由器router工作在OSI参考模型的（网络）层；
交换机Switch工作在OSI参考模型的（数据链路）层。

二十、给定某个整数n(0-10000),求小于等于n的整数中与7有关的整数
（被7整除或者数字中含有7，只要求求出个数，不用列觉出每一个数字）
int fun(int data)
{
int count=0;
int i;
int first,second,third,four;

for(i=1; i<=data; i++)
{
first  = i%10;
second = i/10%10;
third  = i/100%10;
four   = i/1000;
if ((i%7 == 0) || (first == 7) || (second == 7) || (third == 7) || (four == 7)) 
{
//printf("qian bai shi ge is:%d %d %d %d\n", four, third, second, first);
count++;
}
}
return count;
}

二十一、将字符串中每个单词的第一个字符变为大写？
char *fun(char *str)
{
int i;
int flag = -1;
int len = strlen(str);

if(islower(str[0]))
{
str[0] = toupper(str[0]);
}

for(i=1; i{
if(str[i]==' ' && islower(str[i+1]))
{
str[i+1] = toupper(str[i+1]);
}

}
return str;
}

二十二、统计出具有n个元素的一维整数数组中大于等于
所有元素平均值的元素个数。验证该函数？
int fun(int a[], int size)
{
int i=0;
float sum=0, aver=0;
int count=0; 

for(i=0; isum +=a[i];
aver = sum/size;

for(i=0; i{
if(a[i] > aver)
count++;
}
printf("The aver is %f\n", aver);

return count;
}