听说是华为嵌入式软件工程师面试题（1）

内容来自互联网，2020整理

（1）什么是预编译，何时需要预编译：

答案：

１、总是使用不经常改动的大型代码体。

２、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，可以将所有包含文件预编译为一个预编译头。

（2）char * const p      char const * p     const char *p 上述三个有什么区别？

答案：

char * const p； //常量指针，p的值不可以修改；（内容可以改变，必须初始化，地址跟随一生）

char const * p；//指向常量的指针，指向的常量值不可以改 ； //等同const char *p ；（地址可以变，但内容不可以重新赋值）

（3）下面输出什么结果，为什么？

char str1[] = "abc";
    char str2[] = "abc";
    const char str3[] = "abc";
    const char str4[] = "abc";
    const char* str5 = "abc";
    const char* str6 = "abc";
    char* str7 =  "abc";
    char* str8 =  "abc";
    cout << (str1 == str2) << endl;
    cout << (str3 == str4) << endl;
    cout << (str5 == str6) << endl;
    cout << (str7 == str8) << endl;

答案：0 0 1 1

str1,str2,str3,str4是数组变量，它们有各自的内存空间；而str5,str6,str7,str8是指针，它们指向相同的常量区域。

（4）以下代码中的两个sizeof用法有问题吗？

void UpperCase(char str[]) // 将 str 中的小写字母转换成大写字母
{    
    for( size_t i=0; i <sizeof(str)/sizeof(str[0]); ++i) 
        if( ‘a‘ <=str[i] && str[i] <=‘z‘)         
            str[i] -=(‘a‘-‘A‘ ); }

int main()
{ 
    char str[] = "aBcDe";
    cout << "str字符长度为: " << sizeof(str) / sizeof(str[0]) << endl;
    UpperCase(str);
    cout << str << endl;
}

答案：

UpperCase函数内的sizeof有问题。根据语法，sizeof如用于数组，只能测出静态数组的大小，无法检测动态分配的或外部数组大小。函数外的str是一个静态定义的数组，因此其大小为6，因为还有‘\0‘，函数内的str实际只是一个指向字符串的指针，没有任何额外的与数组相关的信息，因此sizeof作用于上只将其当指针看，一个指针为4个字节，因此返回4。

（5）一个32位的机器,该机器的指针是多少位？

答案：

指针是多少位只要看地址总线的位数就行了。80386以后的机子都是32的数据总线。所以指针的位数就是4个字节了。

 （6）下面输出结果是，为什么？

int main()
{ 
    int a[5] = { 1,2,3,4,5 };
    int* ptr = (int*)(&a + 1);
    printf("%d,%d", *(a + 1), *(ptr - 1));
}

答案：2；5

*(a+1）就是a[1]，*(ptr-1)就是a[4],执行结果是2，5

&a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个数组的大小（本例是5个int） int *ptr=(int *)(&a+1); 则ptr实际是&(a[5]),也就是a+5 原因如下： &a是数组指针，其类型为 int (*)[5]; 而指针加1要根据指针类型加上一定的值，不同类型的指针+1之后增加的大小不同 a是长度为5的int数组指针，所以要加5*sizeof(int) 所以ptr实际是a[5] 但是prt与(&a+1)类型是不一样的(这点很重要) 所以prt-1只会减去sizeof(int*) a,&a的地址是一样的，但意思不一样，a是数组首地址，也就是a[0]的地址，&a是对象（数组）首地址，a+1是数组下一元素的地址，即a[1],&a+1是下一个对象的地址，即a[5].

（7）请问以下代码有什么问题？

int main()
{ 
    char a; 
    char* str = &a; 
    strcpy(str, "hello"); 
    printf(str); 
    return 0;
}

答案：没有为str分配内存空间，将会发生异常，问题出在将一个字符串复制进一个字符变量指针所指地址。

虽然可以正确输出结果，但因为越界进行内在读写而导致程序崩溃。

（8）下面有什么错误？

int main()
{ 
    char* s = "AAA";
    printf("%s", s); 
    s[0] = ‘B‘; 
    printf("%s", s);
    return 0;
}

答案："AAA"是字符串常量。s是指针，指向这个字符串常量，所以声明s的时候就有问题。应该是 const char*s="AAA";

然后又因为是常量，所以对是s[0]的赋值操作是不合法的。

(9)写一个“标准”宏，这个宏输入两个参数并返回较小的一个。

答案：

#define Min(X, Y) ((X) > (Y) ? (Y) : (X))

//注意结尾没有‘；’

（10）嵌入式系统中经常要用到无限循环，你怎么用C编写死循环。

答案：while(1){}或者for(;;)

（11）关键字static的作用是什么？

答案：

1). 在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。 延长了局部变量的生命周期，直到程序运行结束以后才释放。
Static修饰的局部变量存放在全局数据区的静态变量区，初始化的时候自动初始化为0；2). 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。即便是extern外部声明也不可以。3). 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。 大多数应试者能正确回答一二部分，很少的人能懂得第三部分。这是一个应试者的严重的缺点，因为他显然不懂得本地化数据和代码范围的好处和重要性。

（12）关键字const有什么含意？
答案：表示常量，不可以修改的变量。
  1：可以用来定义常量，修饰函数参数，修饰函数返回值，且被const修饰的东西，都受到强制保护，可以预防其它代码无意识的进行修改，从而提高了程序的健壮性
（是指系统对于规范要求以外的输入能够判断这个输入不符合规范要求，并能有合理的处理方式。ps：即所谓高手写的程序不容易死）；
  2：使编译器保护那些不希望被修改的参数，防止无意代码的修改，减少bug；
  3：给读代码的人传递有用的信息，声明一个参数，是为了告诉用户这个参数的应用目的；

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

（14）int (*s[10])(int) 表示的是什么？

答案：int(*s[10])(int) 函数指针数组，每个指针指向一个int func(int param)的函数。

（15）请问下列表达式哪些会被编译器禁止？为什么？

int main()
{ 
    int a = 248; //不会
    b = 4; //会，没数据类型
    int const c = 21; //不会
    const int* d = &a; //不会
    int* const e = &b; //会，b未定义
    int const* f const = &a;//会，const右边不能为空
    return 0;
}

答案：看注释

（16）交换两个变量的值，不使用第三个变量。即a=3,b=5,交换之后a=5,b=3;

　   a = a + b; 
    b = a - b; 
    a = a - b; 
    cout << a << ";" << b << endl;
    a = 3;
    b = 5;
    a = a ^ b;// 只能对int,char..  
    b = a^b; 
    a = a^b; 
    cout << a << ";" << b << endl;

（17）c和c++中的struct有什么不同？

答案：c和c++中struct的主要区别是c中的struct不可以含有成员函数，而c++中的struct可以。

c++中struct和class的主要区别在于默认的存取权限不同，struct默认为public，而class默认为private

（18）下面程序输出什么，有什么问题？

void getmemory(char* p)
{
    p = (char*)malloc(100);
    strcpy(p, "helloworld");
}
int main()
{ 
    char* str = NULL;
    getmemory(str);
    printf("%s\n", str);
    free(str);
    return 0;
}

答案：程序崩溃（VS输出（null）），getmemory中的malloc 不能返回动态内存， free（）对str操作很危险

(19)下面产生什么结果？为什么？

int main()
{ 
    char szstr[10];  
    strcpy(szstr, "0123456789");
    return 0;
}

答案：  编译不过，字符串长度大于数组长度，会造成非法的错误

（20）列举几种进程的同步机制，并比较其优缺点。

1）信号量机制

一个信号量只能置一次初值，以后只能对之进行p操作或v操作。 由此也可以看到，信号量机制必须有公共内存，不能用于分布式操作系统，这是它最大的弱点。 

优：PV操作能够实现对临界区的管理要求；实现简单；允许使用它的代码休眠，持有锁的时间可相对较长。 
缺：信号量机制必须有公共内存，不能用于分布式操作系统，这是它最大的弱点。信号量机制功能强大，但使用时对信号量的操作分散，而且难以控制，读写和维护都很困难。加重了程序员的编码负担；核心操作P-V分散在各用户程序的代码中，不易控制和管理；一旦错误，后果严重，且不易发现和纠正。 

2）自旋锁

优：旋锁是为了保护共享资源提出的一种锁机制； 调用者申请的资源如果被占用，即自旋锁已经被别的执行单元保持，则调用者一直循环在那里看是否该自旋锁的保持者已经释放了锁；

低开销；安全和高效； 
缺：自旋锁是一种比较低级的保护数据结构和代码片段的原始方式，可能会引起以下两个问题; 
（1）死锁 
（2）过多地占用CPU资源 
传统自旋锁由于无序竞争会导致“公平性”问题 

3）管程

信号量机制功能强大，但使用时对信号量的操作分散，而且难以控制，读写和维护都很困难。因此后来又提出了一种集中式同步进程——管程。

其基本思想是将共享变量和对它们的操作集中在一个模块中，操作系统或并发程序就由这样的模块构成。这样模块之间联系清晰，便于维护和修改，易于保证正确性。 

优： 集中式同步进程——管程。其基本思想是将共享变量和对它们的操作集中在一个模块中，操作系统或并发程序就由这样的模块构成。这样模块之间联系清晰，便于维护和修改，易于保证正确性。 
缺：如果一个分布式系统具有多个CPU，并且每个CPU拥有自己的私有内存，它们通过一个局域网相连，那么这些原语将失效。而管程在少数几种编程语言之外又无法使用，并且，这些原语均未提供机器间的信息交换方法。 

4）会合

?进程直接进行相互作用 

5）分布式系统

消息和rpc ，由于在分布式操作系统中没有公共内存，因此参数全为值参， 而且不可为指针.

?（21）进程之间通信的途径

管道pipe：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。
命名管道FIFO：有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。
消息队列MessageQueue：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
共享存储SharedMemory：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量，配合使用，来实现进程间的同步和通信。
信号量Semaphore：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
套接字Socket：套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。
信号 ( sinal ) ： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。
（22）进程死锁的原因

答案：资源竞争及进程推进顺序非法

（23）死锁的4个必要条件

答案：互斥、请求保持、不可剥夺、环路

（24）死锁的处理

答案：鸵鸟策略、预防策略、避免策略、检测与解除死锁

 （25）操作系统中进程调度策略有哪几种？

答案：FCFS(先来先服务)，优先级，时间片轮转，多级反馈

（26）类的静态成员和非静态成员有何区别？

答案：类的静态成员每个类只有一个，非静态成员每个对象一个

（27）纯虚函数如何定义？使用时应注意什么？

答案：virtual void f()=0; 是接口，子类必须要实现

（28）数组和链表的区别

答案：数组：数据顺序存储，固定大小

链表：数据可以随机存储，大小可动态改变

（29）ISO的七层模型是什么？tcp/udp是属于哪一层？tcp/udp有何优缺点？

答案：应用层、表示层、会话层、传输层、网络层、物理链路层、物理层

tcp /udp属于传输层

TCP 服务提供了数据流传输、可靠性、有效流控制、全双工操作和多路复用技术等。

与 TCP 不同， UDP 并不提供对 IP 协议的可靠机制、流控制以及错误恢复功能等。由于 UDP 比较简单， UDP 头包含很少的字节，比 TCP 负载消耗少。

tcp: 提供稳定的传输服务，有流量控制，缺点是包头大，冗余性不好

udp: 不提供稳定的服务，包头小，开销小 

（30）(void *)ptr 和 (*(void**))ptr的结果是否相同？其中ptr为同一个指针

答案：.(void*)ptr 和(*(void**))ptr值是相同的

（31）问函数既然不会被其它函数调用，为什么要返回1？

int main()
{ 
    int x = 3;   
    printf("%d", x);
    return 1;
}

答案：main中，c标准认为0表示成功，非0表示错误。具体的值对应具体出错信息

（32）要对绝对地址0x100000赋值，我们可以用 (unsigned int*)0x100000 =1234; 那么要是想让程序跳转到绝对地址是0x100000去执行，应该怎么做？

答案：

*((void(*)( ))0x100000 ) ( );

首先要将0x100000强制转换成函数指针,即: (void(*)())0x100000

然后再调用它:*((void (*)())0x100000)();

用typedef可以看得更直观些:

typedef void(*)() voidFuncPtr;
 *((voidFuncPtr)0x100000)();

（33）已知一个数组table，用一个宏定义，求出数据的元素个数

#define NTBL (sizeof(table) / sizeof(table[0]))

（34）线程与进程的区别和联系? 线程是否具有相同的堆栈? dll是否有独立的堆栈?

答案：进程是死的，只是一些资源的集合，真正的程序执行都是线程来完成的，程序启动的时候操作系统就帮你创建了一个主线程。每个线程有自己的堆栈。

DLL中有没有独立的堆栈，这个问题不好回答，或者说这个问题本身是否有问题。因为DLL中的代码是被某些线程所执行，只有线程拥有堆栈，如果DLL中的代码是EXE中的线程所调用，那么这个时候是不是说这个DLL没有自己独立的堆栈？如果DLL中的代码是由DLL自己创建的线程所执行，那么是不是说DLL有独立的堆栈？以上讲的是堆栈，如果对于堆来说，每个DLL有自己的堆，所以如果是从DLL中动态分配的内存，最好是从DLL中删除，如果你从DLL中分配内存，然后在EXE中，或者另外一个DLL中删除，很有可能导致程序崩溃

进程与线程的区别

1. 线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位；

2. 一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线

3. 进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段，数据集，堆等)及一些进程级的资源(如打开文件和信

号等)，某进程内的线程在其他进程不可见；

4. 调度和切换：线程上下文切换比进程上下文切换要快得多

(35)下面输出多少？并分析过程

unsigned short A = 10; 
    printf("~A = %u\n", ~A); 
    char c = 128; 
    printf("c=%d\n", c);

第一题，～A ＝0xfffffff5,int值 为－11，但输出的是uint。所以输出4294967285

第二题，c＝0x10,输出的是int，最高位为1，是负数，所以它的值就是0x00的补码就是128，所以输出－128。这两道题都是在考察二进制向int或uint转换时的最高位处理。

10 的二进制码是 00001010
按位取反,得 11110101
此为补码
换算成原码,为 10001011
也就是 -11