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

说明：

• 面试群，群号： 228447240

• 面试题来源于网络书籍，公司题目以及博主原创或修改（题目大部分来源于各种公司）；

• 文中很多题目，或许大家直接编译器写完，1分钟就出结果了。但在这里博主希望每一个题目，大家都要经过认真思考，答案不重要，重要的是通过题目理解所考知识点，好应对题目更多的变化；

• 博主与大家一起学习，一起刷题，共同进步；

• 写文不易，麻烦给个三连！！！

1.指针和引用的差别？

答案：

• 定义和声明：指针是一个变量，它存储了一个内存地址。可以通过使用星号（*）来声明一个指针变量。引用是一个别名，它是已存在的变量的别名，通过使用和定义原始变量相同的类型来声明引用。
• 内存操作：指针可以通过解引用操作符（*）来访问和修改指向的内存地址中的值。可以对指针进行算术运算，如指针加法和指针减法。引用本身并不直接操作内存地址，它只是原始变量的别名，对引用的操作实际上是对原始变量的操作。
• 空值：指针可以具有空值（NULL或nullptr），表示指针没有指向任何有效的内存地址。引用必须始终引用一个有效的对象，不能为引用赋予空值。
• 重新赋值：指针可以被重新赋值，可以指向不同的内存地址。引用在声明后不能被重新赋值，它始终引用同一个对象。
• 初始化：指针可以在声明时不进行初始化，也可以在稍后的时间点进行初始化。引用在声明时必须进行初始化，并且一旦初始化后，就不能再引用其他对象。
• 对象类型：指针可以指向任何类型的对象，包括基本类型、自定义类型和指针类型。引用只能引用与其声明时相同或兼容的类型的对象。
• 应用区别。总的来说，在以下情况下应该使用指针：一是考虑到存在不指向任何
  对象的可能（在这种情况下，能够设置指针为空），二是需要能够在不同的时刻指向不同的
  对象（在这种情况下，你能改变指针的指向）。如果总是指向一个对象并且一旦指向一个对
  象后就不会改变指向，那么应该使用引用。

2.下面5个函数哪个能够成功进行两个数的交换？

#include 
using namespace std;

void swap1(int p, int q)
{
    int temp;
    temp = p;
    p = q;
    q = temp;
}

void swap2(int *p, int *q)
{
    int *temp;
    *temp = *p;
    *p = *q;
    *q = *temp;
}

void swap3(int *p, int *q)
{
    int *temp;
    temp = p;
    p = q;
    q = temp;
}

void swap4(int *p, int *q)
{
    int temp;
    temp = *p;
    *p = *q;
    *q = temp;
}

void swap5(int &p, int &q)
{
    int temp;
    temp = p;
    p = q;
    q = temp;
}

int main()
{
    int a=1, b=2;
    // swap1(a,b); 
    // swap2(&a, &b); 
    // swap3(&a, &b); 
    // swap4(&a, &b);  
    // swap5(a,b); 

    cout << a << " " << b << 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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

解析：
这道题考察函数参数传递、值传递、指针传递（地址传递）、引用传递。

• swap1传的是值的副本，在函数体内被修改了形参p、q（实际参数a、b的一个拷贝），p、q的值确实交换了，但是它们是局部变量，不会影响到主函数中的a和b。当函数swap1生命周期结束时，p、q所在栈也就被删除了。
• swap2传的是一个地址进去，在函数体内的形参*p、*q是指向实际参数a、b地址的两个
  指针。int *temp; *temp = *p;是不符合逻辑的一段代码，int *temp新建了一个指针（但没有分配内存）。 * temp= * p不是指向而是拷贝。把 * p所指向的内存里的值（也就是实参a的值）拷贝到 * temp所指向内存里了。但是int *temp不是不分配内存吗？的确不分配，于是系统在拷贝时临时给了一个随机地址，让它存值。分配的随机地址是个“意外”，且函数结束后不收回，造成内存泄露。那么swap2到底能否实现两数交换吗？这要视编译器而定，在vscode可以通过测试，但是在更加“严格”的编译器如vs2023，这段代码会报错。
• swap3传的是一个地址进去，在函数体内的形参*p、*q是指向实际参数a、b地址的两个指针.int *temp; temp = p;int * temp新建了一个指针（但没有分配内存）。temp=p是指向而不是拷贝。temp指向了 * p所指向的地址（也就是a）。函数swap3不能实现两数的交换，这是因为函数体内只是指针的变化，而对地址中的值却没有改变。
• 函数swap4可以实现两数的交换，因为它修改的是指针所指向地址中的值.
• swap5函数与swap4类似，是一个引用传递，修改的结果直接影响实参。

答案：swap4函数和swap5函数

3.写出下面程序的运行结果

#include 
using namespace std;


int main()
{
    int a[3];
    a[0] = 0;
    a[1] = 1;
    a[2] = 2;

    int *p, *q;
    p = a;
    q = &a[2];

    cout << a[q - p] << '\n';

    return 0;
}

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

解析：
首先，定义了一个整型数组a，它有3个元素。然后，将数组a的第一个元素赋值为0，第二个元素赋值为1，第三个元素赋值为2。

接下来，定义了两个整型指针变量p和q。将指针变量p指向数组a的首地址，即a[0]的位置。将指针变量q指向数组a的第三个元素的地址，即a[2]的位置。

然后，使用cout语句输出a[q - p]的值。这里的[q - p]表示指针q和指针p之间的偏移量，即q指向的元素在数组a中的位置与p指向的元素在数组a中的位置之间的差值。由于q指向a[2]，p指向a[0]，所以[q - p]的值为2-0=2。因此，输出a[2]的值，即2
答案：2

4.下列程序的输出结果是什么？

#include 
using namespace std;


class A {
public:
    int _a;
    A()
    {
        _a = 1;
    }
    void print()
    {
        printf("%d", _a);
    }
};

class B :public A {
public:
    int _a;
    B()
    {
        _a = 2;
    }
};

int main()
{
    B b;
    b.print();

    printf("%d", b._a);

    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
34
35
36

A．22
B．11
C．12
D．21

解析：
B类中的_a把A类中_a的覆盖掉了。在构造B类时，先调用A类的构造函数。所以A类的_a是1，而B类的_a是2。
答案：C

5.以下描述正确的是（ ）

A．函数的形参在函数未调用时预分配存储空间
B．若函数的定义出现在主函数之前，则可以不必再说明
C．若一个函数没有return语句，则什么值都不返回
D．一般来说，函数的形参和实参的类型应该一致

解析：
A：错误的，调用到实参才会分配空间。
B：函数需要在它被调用之前被声明，这个跟main()函数无关。
C：错误的，在主函数main中可以不写return语句，因为编译器会隐式返回0；但是在一
般函数中没return语句是不行的。
D：正确的。

答案：D

6.写出函数指针、函数返回指针、const指针、指向const的指针、指向const的const指针

答案：

void (*f)()         // 函数指针
void * f()          // 函数返回指针
const int *         // const指针
int * const         // 指向const的指针
const int * const   // 指向const的const指针
1
2
3
4
5

7.下面的数据声明都代表什么？

（1）float(**def)［10］;
（2）double * ( * gh)［10］;
（3）double( * f［10］)();
（4）int * (( * b)［10］);
（5）Long ( * fun)(int)
（6）Int (*(*F)(int,int))(int)

答案：
（1）float(* * def)［10］;
def是一个二级指针，它指向的是一个一维数组的指针，数组的元素都是float。
（2）double*(*gh)［10］;
gh是一个指针，它指向一个一维数组，数组元素都是double *。
（3）double(*f［10］)();
f是一个数组，f有10个元素，元素都是函数的指针，指向的函数类型是没有参数且返回double的函数。
（4）int * (( * b)［10］);
就跟“int * (b)［10］”是一样的，是一维数组的指针。
（5）Long ( fun)(int)
函数指针。
（6）Int ( * (*F)(int,int))(int)
F是一个函数的指针，指向的函数的类型是有两个int参数并且返回一个函数指针的函
数，返回的函数指针指向有一个int参数且返回int的函数。

8.以下程序的输出是（ ）

#include 
#include 
using namespace std;


int main()
{
   
    int v[2][10] = {
        {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
        {11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
    };

    int (*a)[10] = v; // 数组指针
    
    cout << **a << endl;
    cout << **(a+1) << endl;
    cout << *(*a+1) << endl;
    cout << *(a[0]+1) << endl;
    cout << *(a[1]) << 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

解析：
本题定义一个指针指向一个10个int元素的数组。a+1表明a指针向后移动
1*sizeof(数组大小)；a+1后共向后移动40个字节。*a+1仅针对这一行向后移动4个字节，如下
图所示。

答案：1 11 2 2 11

9.什么是数组指针？指针数组呢？

答案：
数组指针和指针数组都涉及到指向数组的指针，但它们的概念和用法略有不同。
1.数组指针
数组指针是指向数组的指针，它可以看作是一个一维数组，每个元素是指向数组中元素的指针。例如，int (*p)[3]就是一个指向包含3个整数的数组的指针。使用数组指针时，可以通过解引用指针来访问数组元素，也可以使用指针算术运算来访问数组元素。

示例代码：

int arr[2][3] = {{1,2,3},{4,5,6}};
int (*p)[3] = arr; // p指向arr数组
cout << **p << endl; // 输出1
cout << *(*p + 1) << endl; // 输出
1
2
3
4

2.指针数组
指针数组是一个数组，其中每个元素都是一个指针。例如，int *arr[3]就是一个包含3个指向整数的指针的数组。使用指针数组时，可以通过下标访问数组元素，也可以使用指针解引用来访问指针指向的值。

示例代码：

int a = 1, b = 2, c = 3;
int *arr[3] = {&a, &b, &c}; // arr数组包含3个指向整数的指针
cout << *arr[0] << endl; // 输出1
cout << *(arr[1] + 1) << endl; // 错误，arr[1]是一个指针，不能进行指针算术运算

**总结：**一句话（不够准确）来说就是，数组指针是指针指向了数组，指针数组是数组里面存指针
1
2
3
4
5
6

10.写出如下程序片段的输出

#include 
using namespace std;


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


    printf("%d %d", *(a+1), *(ptr - 1));

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

解析：
第一个结果好理解，是正常的指针运算。
第二个的确是5。首先a表示一个1行5列数组，在内存中表示为一个5个元素的序列。int* ptr=(int*)(&a＋1)的意思是，指向a数组的第6个元素（尽管这个元素不存在）。那么显然，(ptr-1)所指向的数据就是a数组的第5个元素——5。

答案：2 5

11.空指针和迷途指针的区别是什么？

答案：

• 当delete一个指针的时候，实际上仅是让编译器释放内存，但指针本身依然存在。这时它就是一个迷途指针。
• 空指针（Null Pointer）： 空指针是指没有指向任何有效对象或函数的指针。在C和C++中，可以使用特殊的宏常量NULL或者nullptr来表示空指针。空指针是一个有效的指针值，但它并不指向任何有效的内存地址。当我们声明一个指针变量但没有给它赋初值时，默认情况下它的值是空指针。

通常，如果在删除一个指针后又把它删除了一次，程序就会变得非常不稳定，任何情况都有可能发生。但是如果你只是删除了一个空指针，则什么事都不会发生，这样做非常安全。
使用迷途指针或空指针（如MyPtr=0）是非法的，而且有可能造成程序崩溃。如果指针是空指针，尽管同样是崩溃，但它同迷途指针造成的崩溃相比是一种可预料的崩溃。这样调试起来会方便得多。

12.C++中有了malloc/free，为什么还需要new/delete？

答案：
malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。然而，new和delete提供了更多的功能和便利性，优势如下：

• 类型安全性：new和delete是类型安全的，它们会自动根据指定的类型进行内存分配和释放。在使用new时，不需要显式地指定分配的内存大小，编译器会根据类型自动计算所需的内存大小。而malloc()需要手动计算所需的内存大小，并进行强制类型转换。
• 构造和析构函数的调用：new运算符在分配内存后，会自动调用对象的构造函数进行初始化。而malloc()只是简单地分配内存空间，不会调用构造函数。同样，delete运算符在释放内存前，会自动调用对象的析构函数进行清理工作。而free()只是简单地释放内存空间，不会调用析构函数。
• 重载支持：new和delete运算符可以被重载，允许用户自定义内存分配和释放的行为。这对于实现自定义的内存管理策略、跟踪内存分配情况等非常有用。
• 对象数组的处理：new运算符可以方便地分配对象数组，并在释放时自动调用每个对象的析构函数。而malloc()和free()无法正确处理对象数组的构造和析构。

13.说一下C++的this指针？

答案：
（1）This指针本质是一个函数参数，只是编译器隐藏起形式的，语法层面上的参数。this只能在成员函数中使用，全局函数、静态函数都不能使用this。实际上，成员函数默认第一个参数为T* const this。如：

class A {
public:
    int func(int p) { }
};
1
2
3
4

其中，func的原型在编译器看来应该是：

int func(A* const this, int p);
1

（2）this在成员函数的开始前构造，在成员的结束后清除。这个生命周期同任何一个函数的参数是一样的，没有任何区别。当调用一个类的成员函数时，编译器将类的指针作为函数的this参数传递进去。如：

A a;
a.func(10);
1
2

此处，编译器将会编译成：

A::func(&a, 10);
1

看起来和静态函数没差别，不过，区别还是有的。编译器通常会对this指针做一些优化，因此，this指针的传递效率比较高，如VC通常是通过ecx寄存器传递this参数的。
（3）this指针并不占用对象的空间。
this相当于非静态成员函数的一个隐函的参数，不占对象的空间。它跟对象之间没有包含关系，只是当前调用函数的对象被它指向而已。
所有成员函数的参数，不管是不是隐含的，都不会占用对象的空间，只会占用参数传递时的栈空间，或者直接占用一个寄存器。
（4）this指针是什么时候创建的？
this在成员函数的开始执行前构造，在成员的执行结束后清除。
但是如果class或者struct里面没有方法的话，它们是没有构造函数的，只能当做C的struct使用。采用TYPE xx的方式定义的话，在栈里分配内存，这时候this指针的值就是这块内存的地址。采用new方式创建对象的话，在堆里分配内存，new操作符通过eax返回分配的地址，然后设置给指针变量。之后去调用构造函数（如果有构造函数的话），这时将这个内存块的地址传给ecx。
（5）this指针存放在何处？堆、栈、还是其他？
this指针会因编译器不同而有不同的放置位置。可能是堆、栈，也可能是寄存器。
（6）this指针是如何传递给类中的函数的？绑定？还是在函数参数的首参数就是this指针？那么，this指针又是如何找到“类实例后函数”的？
大多数编译器通过ecx寄存器传递this指针。事实上，这也是一个潜规则。一般来说，不
同编译器都会遵从一致的传参规则，否则不同编译器产生的obj就无法匹配了。