突破编程_C++_面试（数组（1））

面试题1：详细说明一下数组名是什么？

在 C++ 中，数组名代表数组首元素的地址。更具体地说，数组名是一个指向数组第一个元素的常量指针。这意味着，当使用数组名时，实际上是在使用指向数组第一个元素的指针。
例如，如果你有一个整数数组 int vals[5]; ，那么 vals 就是一个指向 int 类型的指针，它指向 vals[0] 的地址。因此， vals 和 &vals[0] 是等价的。
虽然数组名可以像指针一样使用，但它并不是真正的指针。它不能被重新赋值指向数组的其他位置，也不能被递增或递减。尝试这样做会导致编译错误。
这里有一些重要的点需要注意：
（1）数组名不是指针：尽管数组名可以像指针一样使用，但它本身不是一个指针变量。数组名是一个常量表达式，它不能被修改。
（2）数组名转换为指针：当数组名作为函数参数传递时，或者当它被用在需要指针的上下文中时，它会被隐式地转换为指向数组第一个元素的指针。
（3）数组名和指针的不同：可以改变一个指针变量的值让它指向不同的内存位置，但不能改变数组名让它指向数组中的其他元素或不同的数组。
下面是一个简单的示例，展示了数组名如何被用作指针：

#include <iostream>int main()
{int vals[5] = { 1, 2, 3, 4, 5 };// 使用数组名作为指针int* ptr = vals; // ptr 指向 vals[0] 的地址// 输出数组的第一个元素std::cout << "vals[0] = " << *vals << std::endl; // 输出 1std::cout << "ptr[0] = " << *ptr << std::endl; // 输出 1std::cout << "vals == &vals[0] = " << (vals == &vals[0]) << std::endl; // 输出 1（true）// 数组名不能被修改// vals = &vals[1]; // 这是非法的，会导致编译错误return 0;
}

在上面代码中，vals、 &vals[0] 和 ptr 都指向相同的内存地址，即数组的第一个元素的地址。然而，只有 ptr 可以被重新赋值指向其他位置，而 vals 则始终保持不变，指向数组的第一个元素。

面试题2：数组是一块连续的内存么？

是的， C++ 中的数组是一块连续的内存区域。当声明一个数组时， C++ 会在内存中为数组分配一块连续的空间，这块空间的大小是数组元素类型的大小乘以数组的大小（元素个数）。
数组元素在内存中是紧密排列的，这意味着每个元素都紧挨着前一个元素存储。这种连续的内存布局有几个重要的特点：
高效访问
由于数组元素是连续存储的，所以可以通过简单的偏移量快速访问任何元素。例如，如果有一个整数数组 int vals[10]; ，那么 vals[2] 就是 vals[0] 之后的第 2 个整数，可以直接通过 vals + 2 或者 &vals[0] + 2 * sizeof(int) 来访问。
快速遍历
连续的内存布局使得遍历数组变得非常高效。可以使用指针或迭代器轻松地遍历数组的所有元素。
空间局部性
由于数组元素是连续存储的，它们通常会被加载到缓存中，这有助于减少 CPU 访问内存的次数，从而提高程序的性能。
限制
数组的大小在编译时确定，并且一旦分配了内存，就不能改变数组的大小。这种连续内存分配方式要求数组的大小是固定的。
自动管理
在 C++ 中，当你声明一个局部变量数组时，数组的内存会在进入作用域时自动分配，并在离开作用域时自动释放。这种自动内存管理可以避免内存泄漏和其他与手动内存管理相关的问题。
需要注意的是，如果动态地分配数组（例如使用 new 关键字），那么你需要自己负责在不再需要数组时释放内存（使用 delete[] ）。否则，可能会导致内存泄漏。

面试题3：多维数组如何声明和初始化？

在 C++ 中，多维数组可以通过在数组类型后面跟随多个方括号和大小来声明。多维数组的初始化可以通过在声明时提供初始化列表来完成，其中每个内部列表对应数组的一个维度。
下面是一个二维数组（也称为矩阵）的声明和初始化的例子：

// 声明一个3x3的二维数组
int matrix[3][3];// 初始化一个3x3的二维数组
int matrix[3][3] = 
{{1, 2, 3},{4, 5, 6},{7, 8, 9}
};

在这个例子中， matrix 是一个 3x3 的整数数组，每个元素都被初始化为 0 （如果没有显式初始化）。初始化列表为数组的每个元素提供了具体的值。
对于更高维度的数组，可以继续添加更多的方括号和大小。例如，一个三维数组可以这样声明和初始化：

// 声明一个2x3x4的三维数组
int cube[2][3][4];// 初始化一个2x3x4的三维数组
int cube[2][3][4] = 
{{{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12}},{{13, 14, 15, 16},{17, 18, 19, 20},{21, 22, 23, 24}}
};

在多维数组的初始化中，可以省略内部维度的大小，让编译器自动计算它们。但是，第一个维度的大小必须明确指定。例如：

// 声明并初始化一个3x自动计算大小的二维数组
int arr[3][] = 
{{1, 2, 3},{4, 5, 6},{7, 8, 9}
};// 编译器会自动计算内部维度的大小，这里是3

面试题4：如何比较两个数组是否相等？

在C++中，比较两个数组是否相等通常涉及检查两个数组的每个元素是否都相同。这可以通过编写一个函数或使用标准库算法来完成。以下是几种比较两个数组是否相等的方法：
方法1：使用循环遍历数组
可以通过编写一个函数来遍历两个数组，并逐个比较它们的元素。

#include <iostream>bool isArraysEqual(const int* arr1, const int* arr2, size_t size) 
{for (size_t i = 0; i < size; ++i) {if (arr1[i] != arr2[i]) {return false;}}return true;
}int main() 
{int arr1[3] = {1, 2, 3};int arr2[3] = {1, 2, 3};bool equalFlag = isArraysEqual(arr1, arr2, 3);return 0;
}

方法2：使用 std::equal 算法

C++标准库提供了 std::equal 算法，它可以比较两个范围是否相等。要使用它，需要包含 <algorithm> 头文件，并确保数组是 C 风格的数组或者是可以通过迭代器访问的容器（如 std::vector ）。

#include <iostream>
#include <algorithm>int main() 
{int arr1[3] = {1, 2, 3};int arr2[3] = {1, 2, 3};bool equalFlag = std::equal(std::begin(arr1), std::end(arr1), std::begin(arr2));return 0;
}

在这个例子中， std::begin 和 std::end 分别用于获取数组的开始和结束迭代器。如果两个数组相等， std::equal 将返回 true ；否则返回 false 。
注意事项
（1）当使用 std::equal 时，确保两个数组的大小相同，否则比较可能会产生未定义的行为。
（2）如果数组中的元素是对象而不是基本类型，可能需要自定义比较函数或操作符来比较对象。
（3）上述示例中的数组大小是硬编码的。在实际应用中，你可能需要传递数组的大小作为参数，或者使用容器（如 std::vector ）来动态管理数组的大小。
（4）如果数组元素是基本类型，且数组大小已知，可以直接使用 memcmp 函数进行比较，但这通常只适用于 C 风格的数组。

面试题5：数组和指针有什么区别？

数组和指针的区别如下：
定义和存储
数组是一个用于存储多个相同类型数据的有序集合，它在内存中占据一块连续的空间。数组的大小在编译时确定，并且在整个生命周期内保持不变。而指针是一个变量，它存储的是另一个变量在内存中的地址。指针可以随时指向任意内存地址，因此它的特征是可变。
赋值和访问
数组的元素赋值或拷贝需要逐个进行。例如， arr[0] = value; 将会把 value 赋值给数组 arr 的第一个元素。而指针变量可以相互赋值，如 ptr1 = ptr2; 。在访问数据时，数组名使用下标来引用元素，如 arr[i] 。指针则需要通过解引用操作符 * 来访问它所指向的值，如 *ptr 。
表示范围
数组的有效范围就是其空间的范围，数组名使用下标引用元素，不能指向别的数组。指针可以指向任何地址，但是不能随意访问，必须依附在变量的有效范围之内。
内存大小
数组所占的存储空间大小可以通过 sizeof(数组名) 得到，而数组的大小（即元素个数）可以通过 sizeof(数组名) / sizeof(数据类型) 计算。指针的大小则是由指针类型决定的，例如，在 32 位系统中，指针的大小通常为 4 字节；在 64 位系统中，指针的大小通常为8字节。
函数参数传递
当数组作为函数的参数进行传递时，数组将自动退化为同类型的指针。因此，传入数组做参数时一般需要将其长度也作为参数传入，因为函数内部无法直接获取数组的长度。