2024-10-19 23:47 华为_系统工程师

发布于四川

关注

面试真题 | 华为[20241019]

int32占字节数

问题回答：

在嵌入式系统开发中，数据类型的大小是至关重要的，因为它们直接影响到内存的使用、存储效率以及数据处理的性能。对于int32这一数据类型，它表示一个32位的整数。在大多数现代编程环境中，包括嵌入式系统开发中常用的C和C++语言，int32（或int32_t，后者是C99标准中定义的确切宽度整数类型）占用的字节数是固定的，即4个字节（byte）。

每个字节包含8位（bit），因此int32总共有32位，可以表示的整数范围是-2,147,483,648到2,147,483,647（对于有符号整数）或者0到4,294,967,295（对于无符号整数，通常表示为uint32_t）。

面试官追问及回答：

追问1：如果在一个特定的嵌入式平台上，我们使用了int类型而不是int32_t，那么int的大小是否一定是4个字节？

回答：不一定。虽然在现代的许多平台上，int通常是32位宽（即4个字节），但这并不是由C或C++标准强制规定的。C标准只要求int至少要有16位宽，并且其大小要足以存储-32,767到32,767之间的值。因此，在不同的编译器或平台上，int的大小可能会有所不同，比如16位（2个字节）或64位（8个字节），特别是在某些特定的嵌入式系统或旧的硬件平台上。为了确保跨平台的一致性，使用固定宽度的整数类型（如int32_t和uint32_t）是更好的选择。

追问2：在嵌入式系统中，使用固定宽度的整数类型（如int32_t）相比于使用可变宽度的整数类型（如int）有哪些优势？

回答：使用固定宽度的整数类型在嵌入式系统中有几个明显的优势：

可移植性：如前所述，固定宽度的整数类型确保了在不同平台和编译器上数据大小的一致性，从而提高了代码的可移植性。
内存管理：在资源受限的嵌入式系统中，精确地知道每个数据类型的大小对于内存管理至关重要。固定宽度的整数类型使得内存预算和分配更加容易预测和控制。
性能优化：在某些情况下，了解数据的确切大小可以帮助开发者进行更有效的性能优化，比如通过减少内存访问次数或利用特定的硬件特性。
避免溢出问题：使用固定宽度的整数类型可以减少因数据类型大小不一致而导致的溢出问题，特别是在进行整数运算时。
代码可读性：在代码中明确使用固定宽度的整数类型可以提高代码的可读性，使得其他开发者更容易理解数据的预期大小和范围。

追问3：在嵌入式系统中，除了int32_t之外，还有哪些常用的固定宽度整数类型？

回答：在C99标准中定义了一系列固定宽度的整数类型，这些类型在嵌入式系统中非常有用。除了int32_t之外，还包括：

int8_t：8位有符号整数
uint8_t：8位无符号整数
int16_t：16位有符号整数
uint16_t：16位无符号整数
int64_t：64位有符号整数
uint64_t：64位无符号整数

这些类型提供了对整数大小和符号性的精确控制，有助于开发者在嵌入式系统中编写更加健壮和可移植的代码。

float字节数

在嵌入式系统面试中，面试官可能会提问关于数据类型及其存储表示的问题，例如“float 类型在大多数编译器和平台上占用的字节数是多少？”

回答

在大多数现代编译器和平台上，例如基于 ARM、x86 架构的系统，以及常见的编译器如 GCC 和 Clang，float 类型通常占用 4 个字节（32 位）。这符合 IEEE 754 标准中单精度浮点数（Single-precision floating-point format）的定义。

具体来说，这 32 位被分为三部分：

符号位（1 位）：表示浮点数的正负。0 表示正数，1 表示负数。
指数位（8 位）：采用偏移量表示法（excess-127 表示法），用于表示浮点数的指数部分。实际指数值等于存储的指数值减去 127。
尾数位（23 位）：表示浮点数的有效数字部分（也称为尾数或小数部分），且隐含了一个隐含的 1 位（对于规格化数）。

这种表示法允许 float 类型在大约 -3.4E+38 到 +3.4E+38 的范围内表示数值，并且可以提供大约 7 位十进制的有效数字精度。

追问及其答案

追问 1：

面试官：在嵌入式系统中，为什么有时候需要关心数据类型的字节数？

回答：在嵌入式系统中，资源通常是受限的，包括内存和处理器能力。了解数据类型的字节数有助于：

优化内存使用：确保程序在有限的内存空间中运行，避免内存溢出。
性能优化：了解数据大小可以帮助优化数据访问模式，提高缓存利用率和总线效率。
通信协议设计：在与其他设备通信时，需要精确控制发送和接收的数据大小。

追问 2：

面试官：有没有遇到过 float 类型在不同平台或编译器上占用不同字节数的情况？

回答：虽然在现代主流平台和编译器上，float 类型通常占用 4 个字节，但在某些特殊情况下，比如使用特定的编译器选项或针对非常古老的硬件平台，可能会遇到不同的情况。例如，某些旧的 DSP（数字信号处理器）或微控制器可能使用 16 位或 32 位浮点数表示，或者没有硬件浮点支持而完全依赖软件模拟。

此外，某些编译器可能提供特定的数据类型（如 __float16 或 __float128）来表示不同精度的浮点数，但这些并非标准 C/C++ 类型。

追问 3：

面试官：能否解释一下 IEEE 754 标准中 float 类型的表示方式如何影响浮点数的精度和范围？

回答： IEEE 754 标准中的 float 类型表示方式通过以下方式影响浮点数的精度和范围：

精度：23 位的尾数位加上隐含的 1 位，总共 24 位有效数字，可以表示大约 7 位十进制的有效数字。这意味着在接近 0 的范围内，float 类型可以表示非常小的增量，但随着数值的增大，能够表示的增量也会增大，导致精度下降。
范围：8 位的指数位允许表示从 -126 到 +127 的指数值（考虑到偏移量 127），加上符号位，可以表示非常大的正数和非常小的负数。然而，随着指数的增加，尾数部分的精度会进一步减少，因为尾数位需要用来表示更大的数值范围。

这种设计在精度和范围之间取得了平衡，使得 float 类型在大多数科学计算和工程应用中都非常有用。

sizeof指针和数组的区别

回答

在C或C++等嵌入式编程常用的语言中，sizeof运算符用于获取数据类型或对象在内存中占用的字节数。对于指针和数组，sizeof的行为有显著的区别：

指针：
- sizeof作用于指针时，返回的是指针类型本身所占用的字节数，而不是指针所指向的数据所占用的字节数。
- 在大多数现代架构上（如32位和64位系统），一个指针通常占用4个字节（32位）或8个字节（64位）。
- 例如，int *ptr; 在32位系统上，sizeof(ptr) 将返回4；在64位系统上，将返回8。
数组：
- sizeof作用于数组时，返回的是整个数组所占用的字节数，即数组元素个数乘以每个元素所占用的字节数。
- 例如，int arr[10]; 在大多数系统上，sizeof(arr) 将返回40（因为每个int通常占用4个字节，所以10个int占用40个字节）。
- 值得注意的是，当数组名作为函数参数传递时，它会被退化为指向数组首元素的指针，此时sizeof将不再返回整个数组的大小，而是指针的大小。

追问及其答案

追问 1：

面试官：能否给出一个具体的例子，展示当数组名作为函数参数时，sizeof的行为变化？

回答：当然可以。以下是一个简单的C代码示例：

#include <stdio.h>

void printSize(int arr[]) {
    printf("Size of array inside function: %zu bytes\n", sizeof(arr));
}

int main() {
    int arr[10];
    printf("Size of array in main: %zu bytes\n", sizeof(arr)); // 输出40（假设int为4字节）
    printSize(arr); // 输出可能是4或8（取决于系统是指针32位还是64位）
    return 0;
}

在这个例子中，main函数中的sizeof(arr)返回整个数组的大小（40字节）。然而，当数组名arr作为参数传递给printSize函数时，它退化为指向数组首元素的指针，因此sizeof(arr)在函数内部返回的是指针的大小（在32位系统上通常是4字节，在64位系统上通常是8字节）。

追问 2：

面试官：在嵌入式编程中，了解sizeof指针和数组的区别对性能或内存管理有何影响？

回答：在嵌入式编程中，了解sizeof指针和数组的区别对性能或内存管理有重要影响：

内存管理：正确地使用sizeof可以帮助程序员准确地分配和释放内存。例如，当动态分配数组时，需要知道数组元素的大小和数量来计算总内存需求。如果错误地使用指针的sizeof，可能会导致内存分配不足。
性能优化：了解数据结构的大小有助于优化数据结构在内存中的布局和访问模式。例如，通过紧密地打包数据结构来减少内存碎片和提高缓存命中率。
避免缓冲区溢出：在处理数组时，使用sizeof来确保不会超出数组的边界，从而避免缓冲区溢出等安全漏洞。

追问 3：

面试官：有没有遇到过需要手动计算数组大小的情况？在这种情况下，你是如何处理的？

回答：在某些情况下，例如当数组的大小在编译时不是固定的（例如，依赖于宏定义或条件编译），或者当使用动态内存分配时，可能需要手动计算数组的大小。

在这种情况下，我通常会：

使用宏定义或常量来表示数组元素的数量和类型大小，并通过乘法运算来计算总大小。
对于动态分配的数组，我会使用sizeof来获取单个元素的大小，并将其乘以所需的元素数量来计算总大小。然而，需要注意的是，在分配动态数组时，应使用元素的sizeof而不是数组名的sizeof，以避免潜在的错误。

例如：

#define NUM_ELEMENTS 10
int *dynamicArray = (int *)malloc(NUM_ELEMENTS * sizeof(int));

在这个例子中，我使用了NUM_ELEMENTS来表示元素数量，并使用sizeof(int)来获取单个元素的大小。这样，我就能够正确地计算出所需的总内存大小并分配它。

sizeof指针的大小

面试问题回答

问题：sizeof指针的大小

在C和C++等编程语言中，指针是一个存储内存地址的变量。sizeof操作符用于确定一个变量或数据类型在内存中占用的字节数。对于指针来说，sizeof返回的是指针本身在内存中占用的字节数，而不是它所指向的数据的内存大小。

在大多数现代操作系统和编译器中，无论是32位系统还是64位系统，指针的大小通常与系统的地址空间大小相对应：

32位系统：指针的大小通常是4字节（32位）。
64位系统：指针的大小通常是8字节（64位）。

这意味着，在32位系统上，一个指针变量可以存储一个32位的内存地址，而在64位系统上，一个指针变量可以存储一个64位的内存地址。

示例代码

#include <stdio.h>

int main() {
    int *ptr;
    printf("Size of pointer: %zu bytes\n", sizeof(ptr));
    return 0;
}

在32位系统上，上述代码将输出Size of pointer: 4 bytes，而在64位系统上，将输出Size of pointer: 8 bytes。

面试官追问及回答

追问1：为什么指针的大小与系统的地址空间大小相对应？

回答：指针的本质是存储内存地址的变量。系统的地址空间大小决定了能够表示的最大内存地址范围。因此，指针的大小需要与系统的地址空间大小相匹配，以确保能够存储任何有效的内存地址。在32位系统中，地址空间是2^32（即4GB），因此指针需要32位（4字节）来存储地址。在64位系统中，地址空间是2^64（远大于当前物理内存的容量，但由于地址空间扩展，允许更复杂的内存管理和虚拟化技术），因此指针需要64位（8字节）来存储地址。

追问2：如果我在32位系统上编译了一个程序，然后在64位系统上运行它，指针的大小会改变吗？

回答：不会。指针的大小是由编译时目标系统的架构决定的，而不是运行时系统的架构。如果你在32位系统上编译了一个程序，该程序的目标架构就是32位，因此指针的大小会被编译为4字节。即使你在64位系统上运行这个32位程序（通常通过32位兼容性模式），指针的大小仍然是4字节。然而，如果你在64位系统上编译同一个程序，那么指针的大小就会是8字节。

追问3：有没有可能在同一个程序中同时有32位和64位的指针？

回答：在大多数情况下，不可能在同一个程序中同时有32位和64位的指针，因为程序的编译目标（32位或64位）决定了指针的大小。然而，有一些特殊情况，比如在使用特定的编译器选项或工具链时，可能会创建能够在两种架构之间切换的代码（例如，通过条件编译或动态链接库）。此外，在64位系统上运行的32位进程（通过32位兼容性模式）会有自己的32位地址空间，因此它们的指针是32位的，而同时运行的64位进程则会有64位的指针。但这并不是在同一个程序中同时存在的。

指针和引用的区别

指针和引用在C++等编程语言中都是非常重要的概念，它们有着显著的区别。

定义与性质

指针：指针是一个变量，其存储的值是另一个变量的内存地址。通过指针，可以直接访问和操作内存中的数据对象。指针可以有多级，例如int**p是合法的，表示p是一个指向指针的指针。
引用：引用是一个已存在变量的别名，它与原始变量实质上是同一个对象，不是原始对象的拷贝。引用在定义时必须初始化，且一旦初始化后，就不能再改变其引用的对象。引用只能是一级的，例如int&&a是不合法的。

使用与特性

指针：
- 可以在定义时不初始化。
- 可以指向空地址（nullptr或NULL）。
- 初始化之后可以改变指向，即可以重新赋值指向不同的内存地址。
- 指针运算，如指针加减、指针解引用等是合法的。
- 指针通常占用一定的内存空间，具体大小取决于系统架构。
引用：
- 必须在定义时初始化，且引用不可为空。
- 一旦初始化后，就不能再改变其引用的对象。
- 引用操作实际上是直接对被引用变量的操作，不需要解引用。
- 引用不占用额外的内存空间，因为在编译时引用会被转换为对应的指针（但这一转换对程序员是透明的）。

应用场景

指针：常用于动态内存分配、数组、函数指针等复杂场景。在嵌入式系统中，指针也常用于操作硬件寄存器、管理内存等。
引用：主要用于作为函数参数传递、函数返回值以及简单的别名使用。引用可以提高代码的可读性和简洁性，特别是在函数参数传递时，可以避免拷贝，提高效率。

面试官可能的追问及回答

追问1：在函数参数传递时，使用指针和引用有什么区别？

回答：在函数参数传递时，使用指针和引用都可以改变实参的值。但指针需要判断是否为空，而引用则不需要。此外，使用引用可以使代码更加简洁和易读，因为不需要解引用操作。同时，引用还提供了类型安全检查，这有助于减少类型错误。

追问2：指针和引用在内存中的表现有什么不同？

回答：指针是一个独立的变量，它存储了另一个变量的内存地址。因此，指针需要占用一定的内存空间。而引用则是原始变量的别名，它与原始变量共享同一块内存空间。在内存中，引用并不占用额外的空间（尽管在编译时可能会转换为指针来处理）。这也意味着，对引用的操作实际上是对原始变量的直接操作。

追问3：在嵌入式系统中，什么时候更适合使用指针而不是引用？

回答：在嵌入式系统中，当需要动态分配内存、操作硬件寄存器或管理复杂的内存结构时，指针通常更加适合。因为指针提供了更灵活的内存访问方式，可以指向任何有效的内存地址。此外，在需要多级指针或指针运算的场景中，也更适合使用指针。然而，在需要提高代码可读性、简洁性或进行类型安全检查时，引用则是一个更好的选择。

这样的回答既全面又深入，能够充分展示对指针和引用区别的理解，同时也能应对面试官的进一步追问。

深拷贝和浅拷贝

回答：

在嵌入式系统开发中，内存管理是一个至关重要的方面。当我们涉及到对象或数据结构的复制时，了解深拷贝和浅拷贝的区别尤为关键。

浅拷贝（Shallow Copy）：浅拷贝是指创建一个新的对象，但这个新对象中的元素仅仅是对原对象中元素的引用，而不是这些元素本身的一个新副本。也就是说，如果原对象中的元素是对象类型（如类实例、结构体等），浅拷贝后的新对象与原对象将共享这些内部对象的引用。因此，如果修改新对象中的这些内部对象，原对象中的相应对象也会受到影响。

深拷贝（Deep Copy）：深拷贝则是指创建一个新的对象，并且递归地复制原对象中的所有元素，包括所有嵌套的元素，以确保新对象与原对象完全独立。深拷贝后的新对象与原对象没有任何共享的内存区域。因此，对新对象的修改不会影响到原对象。

应用场景：

在需要保持数据独立性的场景中，深拷贝是更好的选择。例如，在多线程环境中，避免共享数据导致的并发问题。
在嵌入式系统中，内存资源有限，如果对象结构简单且不会引发数据一致性问题，浅拷贝可能是一个更高效的选择。

实现方式：

对于简单数据类型（如int、float等），直接赋值即可实现拷贝，不存在深拷贝和浅拷贝的区分。
对于复杂数据结构（如数组、链表、树等），通常需要手动实现深拷贝逻辑，包括递归地复制所有元素。
某些编程语言提供了内置的方法或库来支持深拷贝和浅拷贝，如C++中的std::copy（需要手动实现深拷贝逻辑）和Python中的copy模块。

示例代码（C++）：

#include <iostream>
#include <vector>
#include <cstring>

class Node {
public:
    int data;
    Node* next;

    Node(int val) : data(val), next(nullptr) {}
};

// 浅拷贝
Node* shallowCopy(Node* head) {
    if (!head) return nullptr;
    Node* newHead = new Node(head->data);
    newHead->next = head->next; // 只是复制了指针，没有复制链表节点
    return newHead;
}

// 深拷贝
Node* deepCopy(Node* head) {
    if (!head) return nullptr;
    Node* newHead = new Node(head->data);
    if (head->next) {
        newHead->next = deepCopy(head->next); // 递归复制链表节点
    }
    return newHead;
}

int main() {
    // 创建一个链表 1 -> 2 -> 3
    Node* head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(3);

    // 浅拷贝
    Node* shallowHead = shallowCopy(head);
    // 修改浅拷贝链表中的节点数据
    shallowHead->next->data = 99;
    std::cout << "Shallow Copy: " << head->next->data << std::endl; // 输出99，原链表也被修改

    // 深拷贝
    Node* deepHead = deepCopy(head);
    // 修改深拷贝链表中的节点数据
    deepHead->next->data = 999;
    std:

剩余60%内容，订阅专栏后可继续查看/也可单篇购买

ARM/Linux嵌入式真题文章被收录于专栏

让实战与真题助你offer满天飞！！！每周更新！！！励志做最全ARM/Linux嵌入式面试必考必会的题库。励志讲清每一个知识点，找到每个问题最好的答案。让你学懂，掌握，融会贯通。因为技术知识工作中也会用到，所以踏实学习哦！！！