嵌入式软件工程师——2025校招专题（一）

说明：

• 面试群，群号： 228447240
• 前面5篇以实际笔试题为主，如果背概念八股，从第5篇以后开始看;
• 面试题来源于网络书籍，公司题目以及博主原创或修改（题目大部分来源于各种公司）；
• 前面几篇以做笔试程序题为主，后面以简答题为主
• 文中很多题目，或许大家直接编译器写完，1分钟就出结果了。但在这里博主希望每一个题目，大家都要经过认真思考，答案不重要，重要的是通过题目理解所考知识点，好应对题目更多的变化（第一篇开始，可能有点啰嗦，请大家勿烦）；
• 博主与大家一起学习，一起刷题，共同进步；
• 写文不易，麻烦给个三连！！！

1. 下列C++代码的输出结果是什么？

#include 
using namespace std;

int i = 1;

int main()
{
    int i = i;
    printf("%d\n", i);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

A. main()里的i是一个未定义值
B. main()里的i值为1
C. 编译器不允许这种写法
D. main()里的i值为0

解析：当面试者看到int i=i;时，也许第一反应就是怎么有这么诡异的代码？但是在
C++中这样做是完全合法的（但显然不合理）。int i=i，i变量从声明的那一刻开始就是可见
的了，main()里的i不是1，因为它和main()外的i无关，而是一个未定义值。

博主第一次看到此解析，没有看明白它的意思。再这里用博主自己的话重新做一下说明，main函数外的i为全局变量，在全区域内都可以使用。而在’main’函数内，因为重新使用了int，所以是重新定义的i，与外面的i将没有任何关系。使用int i = i; 声明了一个局部变量i，并将其赋值为它自己。这是一个有问题的语句，因为它试图将未初始化的局部变量赋值给自己，导致结果是不确定的。

答案：A

2.下列C++代码的输出结果是什么？

#include 
using namespace std;


int main()
{
    int x = 2, y, z;
    x *= (y=z=5);
    cout << x << endl;

    z = 3;
    x == (y=z);
    cout << x << endl;

    x = (y==z);
    cout << x << endl;

    x = (y&z);
    cout << x << endl;

    x = (y&&z);
    cout << x << endl;

    y = 4;
    x = (y|z);
    cout << x << endl;

    x = (y||z);
    cout << x << endl;


    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

解析：

• x*=(y=z=5)的意思是说5赋值给z，z再赋值给y，x=x * y，所以x为2 * 5=10。
• x==(y=z)的意思是说z赋值给y，然后看x和y相等否？不管相等不相等，x并未发生变化，
  仍然是10。
• x=(y==z)的意思是说首先看y和z相等否，相等则返回一个布尔值1，不等则返回一个布尔
  值0。现在y和z是相等的，都是3，所以返回的布尔值是1，再把1赋值给x，所以x是1。
• x=(y&z)的意思是说首先使y和z按位与。y是3，z也是3。y的二进制数位是0011，z的二进
  制数位也是0011。所以y&z的二进制数位仍然是0011，也就是还是3。再赋值给x，所以x为3。
• x=(y&&z)的意思是说首先使y和z进行与运算。与运算是指如果y为真，z为真，则(y&&z)
  为真，返回一个布尔值1。这时y、z都是3，所以为真，返回1，所以x为1。
• x=(y|z)的意思是说首先使y和z按位或。y是4，z是3。y的二进制数位是0100，z的二进制
  数位是0011。所以y&z的二进制数位是0111，也就是7。再赋值给x，所以x为7。
• x=(y||z)的意思是说首先使y和z进行或运算。或运算是指如果y和z中有一个为真，则(y||z)
  为真，返回一个布尔值1。这时y、z都是真，所以为真，返回1。所以x为1。

答案：10，10，1，3，1，7，1

3. 下列C++代码的输出结果是什么？

#include 
using namespace std;

int func(int x)
{
    int count = 0;
    while(x)
    {
        count++;
        x = x&(x-1);
    }
    return count;
}

int main()
{   
    cout << func(9999) << endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

解析：本题重点是x = x&(x-1);这一行代码通过位运算将x的二进制表示中最右边的1变为0。这个操作会在每次循环中去掉x的二进制表示中的一个1。
本题func函数返回值是形参x转化成二进制后包含1的数量。理解这一点就很容易
答出来了。9999转化为二进制是10 0111 0000 1111。

答案：8

4. 下面两段代码的输出结果有什么不同？

// 第一段代码
using namespace std;

int main()
{
    int a, x;
    for(a=0, x=0; a<=1 && !x++; a++)
    {
        a++;
    }

    cout << a << x << endl;

    return 0;
}

// 第二段代码
#include 
using namespace std;

int main()
{
    int a, x;
    for(a=0, x=0; a<=1 && !x++;)
    {
        a++;
    }

    cout << a << x << endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

解析
先说第1段代码。
第1步：初始化定义a=0，x=0。
第2步：a小于等于1，x的非为1，符合循环条件。
第3步：x++后x自增为1。
第4步：进入循环体，a++，a自增为1。
第5步：执行for(a=0,x=0;a<=1 &&!x++;a++)中的a++，a自增为2。
第6步：a现在是2，已经不符合小于等于1的条件了，所以“&&”后面的“!x++”不执行，x
还是1，不执行循环体。
第7步：打印a和b，分别是2和1。

再说第2段代码。
第1步：初始化定义a=0，x=0。
第2步：a小于等于1，x的非为1，符合循环条件。
第3步：x++后x自增为1。
第4步：进入循环体，a++，a自增为1。
第5步：a现在是1，符合小于等于1的条件，所以“&&”后面的“!x++”被执行，x现在是
1，x的非为0，不符合循环条件，不执行循环体，但x++依然执行，自增为2。
第6步：打印a和b，分别是1和2。
答案：21 12

5. 以下代码的输出结果是什么？

#include 

int main()
{
    int b = 3;
    int arr[] = {6, 7, 8, 9, 10};
    int *ptr = arr;

    *(ptr++) += 123;

    printf("%d, %d\n", *ptr, *(++ptr));


    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

解析：
C中printf计算参数时是从右到左压栈的
printf("%d\n ",*ptr)；此时ptr应指向第一个元素6。
(ptr++)+=123应为ptr=ptr+123;ptr++，此时ptr应指向第二个元素7。
printf("%d,%d\n ", ptr, * (++ptr))；从右到左运算，第一个是(++ptr)，ptr++了，所以此时ptr指向第三个元素8， 第二个是ptr他也指向第三个元素8。
注意：此题目中b没有用，博主也不知道该公司怎么想的，一点干扰都没有。另外可能大家好奇加的123去哪里，这里笔者直接告诉大家，129变成了 *(ptr-2)的结果。可以试试下面的变形
答案：8，8

6.下面两段程序有两种写法，你青睐哪种，为什么？

// 第一段
// 1.
 if('A' == a)
 {
     a++;
 }
// 2.
 if(a == 'A')
 {
      a++;
 }
// 第二段
// 1.
for(i=0; i<8; i++){
    X = i+Y+J*7;
    printf("%d", X);
}
// 2.
S = Y+J*7;
for(i=0; i<8; i++){
   printf("%d", i+S);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

解析：
A．第一种写法'A' == a比较好一些。这时如果把 ==误写做=的话，因为编译器不允许
对常量赋值，就可以检查到错误。
B．第二种写法好一些，将部分加法运算放到了循环体外，提高了效率。缺点是程序不
够简洁。

7.下面程序的结果是多少？

int main()
{
    float a = 1.0f;
    cout << (int)a << endl;
    cout << &a << endl;
    cout << (int&)a << endl;
    cout << boolalpha << ((int)a == (int&)a) << endl; // 输出什么？

    float b = 0.0f;
    cout << (int)b << endl;
    cout << &b << endl;
    cout << (int&)b << endl;
    cout << boolalpha << ((int)b == (int&)b) << endl; // 输出什么

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

解析：
在机器上运行一下，可以得到结果，“cout << (int&)a << endl;”输出的是
1065353216，而不是1。这是因为浮点数在内存里和整数的存储方式不同，(int&)a相当于将该浮点数地址开始的sizeof(int)个字节当成int型的数据输出，因此这取决于float型数据在内存中的存储方式，而不是经过(int&)a显示转换的结果（1）。
因为float a=1.0f在内存中的表示都是3f800000，而浮点数和一般整型不一样，所以当(int&)a强制转换时，会把内存值3f8000000当做int型输出，所以结果自然变为了1065353216（0x3f800000的十进制表示）。
而b为0.0f,所以输出的均为0。结果就为true了
答案：false true

8.下面程序的结果是多少？

int main()
{
    unsigned int a = 0xFFFFFFF7;
    unsigned char i = (unsigned char)a;
    char *b = (char*)&a;

    printf("%08x, %08x", i, *b);

    return 0;
}
1
2
3
4
5
6
7
8
9
10

解析：
unsigned int变量赋值给unsigned char变量时会发生字节截断（3位和高于3位的将被程序自动丢弃）。
那么第二个数，也就是char* b=(char*)&a中a本身为一个uint类型的值，把它的地址赋给一个执行char类型数据的指针。char类型的长度只有一个字节，打印char类型的指针指向的值会是多少？
&a的结果是一个指针，它的类型取决于a的类型，此处&a的类型应该是：

unsigned int *;
char *b = (char*)&a;
1
2

上面等价于：

unsigned int *p = &a;
char *b = (char*)&p;
1
2

上面的步骤就是将一个unsigned int型的指针强制转换成一个char型的指针。
所以请注意：这里是char类型的指针转换，而不是char类型的转换。

答案：000000f7，fffffff7

9.下面程序的结果是多少？

int main()
{
    unsigned char a = 0xA5;
    unsigned char b = ~a>>4+1;

    printf("b=%d\n", b);


    return 0;
}
1
2
3
4
5
6
7
8
9
10

解析：
这道题目考查两个知识点：一是类型转换问题；二是算符的优先级问题。
对于第一个问题：unsigned char b=~a>>4，在计算这个表达式的时候，编译器会先把a和
4的值转换为int类型（即所谓整数提升）后再进行计算，当计算结果出来后，再把结果转换
成unsigned char赋值给b。
对于第二个问题：因为“~”的优先级高于“>>”和“+”，本题的过程是这样的：先对于1010
0101取反0101 1010；再右移，这里有一个问题，是先右移4位再加1呢，还是直接右移
5（4+1）位。因为“+”的优先级高于“>>”，所以直接右移5位。结果是0000 0010。
最后的结果应该是2才对，但把如上的指令放到vs code中运行，答案居然是250。

那么到底是什么地方出了问题？在调试的过程中进入汇编指令。可以看到高级语句转换
为汇编语言以后，是先执行取反再位移的。我们看到eax是16位的寄存器，于是在机器中
0xA5的寄存中表达是0000 0000 1010 0101 ，取反是1111 1111 0101 1010，那么右移5位是
0000 0111 1111 1010，由于是unsigned char型的只能表示低8位的数值，即250。
答案：250

10.用一个表达式，判断一个数X是否是2的N次方(2,4,8,16,…)，不可用循环语句

解析：
2、4、8、16这样的数转化成二进制是10、100、1000、10000。如果X减1后与X
做与运算，答案若是0，则X是2的N次方。
答案：!(X&(X-1))

11.给三个整数a、b、c，函数实现取三个数的中间数，不可以使用sort，整数操作尽可能少

答案：

inline int max(int a, int b) { return a>=b ? a : b; }
inline int min(int a, int b) { return a<=b ? a : b; }
inline int medium(int a, int b, int c)
{
    int t1 = max(a, b);
    int t2 = max(b, c);
    int t3 = max(a, c);

    return min(t1, min(t2, t3));
}

int main()
{

    int mid = medium(1, 3, 5);
    printf("mid: %d\n", mid);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

12.在C++程序中调用被C编译器编译后的函数，为什么要加extern “C”？

答案：C++语言支持函数重载，C语言不支持函数重载。函数被C++编译后在库中的名
字与C语言的不同。假设某个函数的原型为void foo(int x, int y)。该函数被C编译器编译后在
库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。
C++提供了C连接交换指定符号extern "C"解决名字匹配问题。

13.头文件中的ifndef/define/endif是干什么用的？

答案：防止该头文件被重复引用。

14.下面的switch语句输出什么。

int main()
{
    int n = 'c';
    switch(n++)
    {
        default: printf("error"); break;
        case 'a': case 'A': case 'b': case 'B': printf("ab"); break;
        case 'c': case 'C': printf("c");
        case 'd': case 'D': printf("d");
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

解析：
本题考的是switch中的“fall through”：如果case语句后面不加break，就依次执行下去。
int n = 'c';这一行定义了一个整数变量n，并将其初始化为字符 ‘c’ 对应的ASCII码值，也就是99。
switch(n++)：这是一个switch语句，它会根据n的值来选择不同的分支进行执行。n++表示先使用n的值，然后再将n自增1。
case 'a': case 'A': case 'b': case 'B': printf("ab"); break;这是一个合并的case分支。如果n的值等于小写 ‘a’、大写 ‘A’、小写 ‘b’ 或大写 ‘B’，就会执行这个分支，打印 “ab” 并结束switch语句的执行。
case 'c': case 'C': printf("c");这是另一个合并的case分支。如果n的值等于小写 ‘c’ 或大写 ‘C’，就会执行这个分支，打印 “c”。
case 'd': case 'D': printf("d");这是又一个合并的case分支。如果n的值等于小写 ‘d’ 或大写 ‘D’，就会执行这个分支，打印 “d”。
答案：cd