haikang.md · lamdota/summaryc++

嵌入式开发笔试题
(答题时间60分钟)
一、选择题(每题2分，共7题,总计14分):    
1.链表不具有的特点是(**B** )   
A.不必事先估计存储空间    
B.可随机访问任一元素     
C.插入删除不需要移动元素   
D.所需空间与线性表长度成正比

2.在一个单链表中，若p所指结点不是最后结点，在p之后插入s所指结点，则执行( **B** )。  
A.s->next=p;p->next=s;  
B.s->next=p->next;p->next=s;    
C.s->next=p->next;p=s;  
D.p->next=s;s->next=p;  
    
3.如果进栈序列为el、e2、e3、e4，进栈过程中可以出栈，则不可能的一个出栈序列是( **D** ) 
A、e2、e3、e4、e1   
B、e4、e3、e2、el   
C、e1、e2、e3、e4   
D、e3、e1、e4、e2

4. 以下程序打印结果是( **D** )  
#include <stdio.h>] 
#define N 3 
#define M N+1   
(N+1+1)*(N+1)/2 
#define NUM(M+1)*M/2    
main(   
{   
pritf("%d\n",NUM);  
}   
A、7 B、10 C、12 D、15

5.数组定义为int a[10]，表达式( **D** )是错误的。
A.*a
B.a[0]
C.a
D.a++  _数组名是指针常量_

6.多线程中栈与堆是公有的还是私有的(D)
A:栈公有，堆私有
B:栈私有，堆私有
C:栈公有，堆公有
D:栈私有，堆公有

7以下多线程对int型变量x的操作，哪一个不需要进行同步(D)
A.x=y; B x++; C ++x; D x=1

```C
二、填空题(每个空格2分，共7个，总计14分):
1.连个线程并发执行函数calc,问两个线程都结束后，sum的值范围位10~20
int sum=0;
void calc()
{
    for(i=1;i<=10;i++)
    {
        sum +=1;
    }
}
2.请填写以下代码的打印结果 2,5
```c++
int main(int argc, char** argv)
{
    int a[5]={1,2,3,4,5};
    int* ptr = (int *)(&a+1);
    printf(“%d,%d\n”,*(a+1),*(ptr-1));
    return 0;
}
//&a+1 表示数组 a 的地址往后移动一个数组的大小。由于 a 是一个含有5个整型元素的数组，
因此地址实际上会向前移动 5*sizeof(int) 字节（假设 sizeof(int) 为4，则移动20字节）。
//*(a+1) 等同于 a[1]，访问数组 a 的第二个元素，输出值为2。
//*(ptr-1) 这里试图访问 ptr 指针减去1的位置，即尝试访问 a 数组的最后一个元素 a[4]，
因为在前面的步骤中 ptr 实际上指向了 a 数组末尾之外的位置，ptr-1 刚好指向 a 的最后一个元素，输出值为5。
```
3.在32位系统下，C程序，请计算sizeof的值
char str[]= "www.ezviz7.com"
char *p = str;
Int n=10;
请计算：
sizeof(str) = 15;
Sizeof(p)= 4
Sizeof(n)=4
void Foo ( char str[100])
{
}
sizeof(str)= 4;
void *p= malloc(100);
sizeof(p)=4
三、简答题(每题5分，共8题，总计40分):
1.请指出下面程序的错误
unsigned int i=100;
int b=100;
int *p;

void f(void)
{
    while(i>=0)
    {
        *(p++)=b;
        i--;
    }
    return;
}

1.未初始化,p++操作非法
    2.由于是unsigned int，所以会死循环
2.下面求平方函数实现是否有误，如有请写出修改后的函数?
int square(volatile int *ptr)
{
    return *ptr * *ptr;
}
答：
由于*ptr的值可能在两次取值语句之间发生改变，因此a和b可能是不同的。结果，这段代码可能返回的不是你所期望的平方值！
正确的代码如下：
long square(volatile int*ptr)
{
    int a;
    a = *ptr;
    return a*a;
}

3.C语言中 static关键字有哪几种用法及各自表示的作用。
修饰员部变盘,下次调用的值为上一次的值    
修饰全局变量和函费:作用域为当前文件

4. if (a == 3) 与 if (3==a) 两个中写法哪种更好，为什么?
if(3==a)更好,防止写错进行赋值
    
5.请描述malloc/free和new/delete的区别：    
  1.malloc指定申请的字节大小，并返回void*，需要类型转换， new直接分配并初始化对象，返回指定类型的指针    
  2.malloc和free仅分配和释放内存空间，不会调用构造函数和析构函数    
  3.失败时malloc返回NULL，需要显示检查，而new会抛出std::bad_alloc异常。

6.在什么情况使用inline关键定义函数，有什么好处和弊端

使用情况：      
 1.频繁调用的小函数，减少函数调用的开销，提高性能    
   2.代替宏定义    
   3.类成员函数

好处：减少调用开销， 提高代码可读性，类型安全(支持类型检查)，支持调试    
弊端：代码膨胀（函数体直接被嵌入到每个调用点），优化过度风险，编译时间增加

7.进程间/线程通信

进程间： 管道，共享内存，信号量，消息队列，sockets  
线程间通信：共享变量（volatile），锁（互斥锁，条件变量，自旋锁，读写锁），信号量，内存屏障，原子操作，sockets

8.什么情况使用进程/线程
 使用进程的情况：
    资源隔离：当需要在不同任务间保持严格的资源隔离时，使用进程更为合适。每个进程拥有独立的内存空间，不会因一个进程崩溃而影响其他进程。
    稳定性与安全性：进程间的这种隔离特性还提高了系统的稳定性和安全性，因为一个进程的错误不会直接损害其他进程。
    长时间运行的任务：对于需要长时间运行、独立存在的任务，使用进程较为合适，因为它们可以在后台独立运行，不影响主程序。
    不同权限和用户：当任务需要以不同的权限级别或不同用户身份运行时，进程提供了更好的支持。
    重量级任务：对于占用大量资源或需要大量计算的任务，使用进程可能更合适，因为它们不会因为线程间共享资源而产生过多的管理和协调开销。
 使用线程的情况：
    轻量级并发：线程是轻量级的执行单元，创建和切换线程比进程更快，消耗资源少，适合需要快速响应和大量并发处理的场景。
    共享数据和资源：线程间可以直接访问同一进程内的数据和资源，无需复杂的通信机制，适合需要高效数据共享的应用。
    性能要求高的应用：对于需要高性能计算和实时响应的应用，如图形界面、服务器应用、游戏等，线程能够提供更好的并发处理能力。
    简单协作：当任务间需要紧密协作，频繁交互时，线程间的直接内存访问可以简化编程模型。
    动态负载均衡：线程可以更容易地实现动态分配和调整，以适应不断变化的计算需求和负载。

9. define list_entry(ptr, type, member)
*)0)->member)))
以上宏定义摘自Linux内核的list.h，请你谈谈对这个宏定义的理解!(E:member为络
((type *)((char *)(ptn) - (unsigned longit&lyse
构体 type 中的成员，ptr为结构体type 成员 member定义的变量)

这个宏定义 list_entry(ptr, type, member) 是 Linux 内核中用于从链表节点指针获取其所属结构体指针的一个技巧。  
它的核心作用是反向解析，即从一个结构体的成员指针找到整个结构体的指针。下面是对这个宏定义的逐行解释：
#define list_entry(ptr, type, member)：这是宏的开始，它接受三个参数：ptr 是成员的指针，type 是包含该成员的结构体类型，member 是结构体中作为链表节点的成员名。
((type *) ((char *)(ptr)) - (unsigned long)(&((type *)0)->member)))：这是宏的主体，执行了以下操作：
(char *)(ptr)：首先将 ptr 转换为 char 类型的指针，这样做的目的是为了进行指针算术操作，因为直接对非 char 类型的指针进行减法在 C 语言中是不合法的。
((type *)0)：这是一个技巧，它创建了一个类型为 type 的零地址的指针。由于是零地址，访问它的成员是安全的，因为实际上并不会导致内存访问错误。
&((type *)0)->member：获取 type 类型结构体中 member 成员的地址。由于 (type *)0 是零地址，所以这个操作是安全的，只是用于获取成员 member 在其结构体中的偏移量。
(unsigned long)：将上述地址转换为 unsigned long 类型，这样做是为了进行安全的整数减法。((char *)(ptr)) - (unsigned long)...：从 ptr 的地址中减去 member 成员的偏移量，得到结构体的基地址。(type *)：最后，将计算得到的基地址强制转换为 type 类型的指针。

应用场景
这个宏通常用在遍历链表时，当你有一个指向链表节点（即结构体中的 member）的指针，并且你需要获取该节点所属的整个结构体的指针时，使用 list_entry 宏可以方便地完成这一任务。

四、编程题(每题8分，共4题，总计32分):
1.如何实现C代码调用C++的函数，编写一段代码实现这个过程。
CPP使用extern"c" {fun( )}
C:extern fun()
2.写一个函数判断当前的运行环境大小端模式。

int is_littler()
{
    union
    {
        int i;
        char [4];
    }end_test ={0x01020304};
return end_test.c[0]=0x04;
}
```
3.写一个函数，将“l am studem反转成"student a am l"，并且不借助任何库函数。

//反转函数
void inversion(char str[],int len){
	int left = 0;
	int right = len - 1;
	while (left <= right){
		char tmp = str[left];
		str[left] = str[right];
		str[right] = tmp;
		left++;
		right--;
	}
}
//把字符串分批之后,通过inversion()函数进行反转
void change(char str[], int len){
	int count = 0;//为inversion()函数提供需要反转的字符个数
	int i = 0;
	int left = 0, right = 0;
	while (i <= len){
		left = i;//记录每部分开始的下标
		while (str[i] != ' ' && i < len){
			count++;//记录' '之间有几个字符
			i++;
		}
		right = count;
		inversion(str + left,right);//倒置每一部分,str + left 代表从对应的字符开始反转
		i++;//从上面的while函数跳出后,如果不进行自增,则无法再次进入上面的while循环.
		count = 0;//反转过前一部分字符的时候,需要重置count为下一次的反转重新计数
	}
}

//主函数
int main() {
	char str[] = "student a am i";
	int len = strlen(str);
	inversion(str, len);//反转整个字符串,
	change(str, len);//把字符串通过空格分隔,分别通过inversion()函数进行反转
	int i = 0;
	for (i = 0; i < len; i++){
		printf("%c", str[i]);//打印反转后的字符串
	}
	return 0;
}

```
4.已知两个单链表pHead1和pHead2各自有序，请实现函数把它们合并成一个
有序。
链表节点声明如下
struct ListNode
{
    int m_iData;
    ListNode * m_pNext;
};

```c++
递归：
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    if (l1 == NULL) return l2;
    if (l2 == NULL) return l1;
    if (l1->val <= l2->val) {
        l1->next = mergeTwoLists(l1->next, l2);
        return l1;
    } else {
        l2->next = mergeTwoLists(l1, l2->next);
        return l2;
    }
}

或者迭代：
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    ListNode dummy(-1); // 创建一个哑结点作为新链表的起点
    ListNode* tail = &dummy; // tail指针用于连接新链表的最后一个节点

while (l1 != nullptr && l2 != nullptr) {
        if (l1->val < l2->val) {
            tail->next = l1;
            l1 = l1->next;
        } else {
            tail->next = l2;
            l2 = l2->next;
        }
        tail = tail->next;
    }

// 处理剩余部分
    if (l1 != nullptr) tail->next = l1;
    if (l2 != nullptr) tail->next = l2;

return dummy.next; // 返回新链表的头结点
}

```

lamdota/summaryc++

简介

发行版

贡献者

近期动态

lamdota/summaryc++ .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

lamdota/summaryc++