linux c嵌入式工程师笔试题,嵌入式软件工程师/linux c程序员 笔试题
赞
踩
一、什么叫可重入？
可重入函数主要用于多任务环境中，一个可重入的函数简单来说就是
可以被中断的函数，也就是说，可以在这个函数执行的任何时刻中断
它，转入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; i
