数组可以在 c++ 中用作迭代器吗？

Question

我只是浏览 std::vector 构造函数，看到有些人使用带有 2 个迭代器的构造函数，并将其与数组一起使用，例如：

int arr[5] = [1,2,3,4,5]
std::vector<int> v(arr, arr + arr.size()/arr[0])

为什么这有效？那么数组也只是一个迭代器吗？ 这里还有一个问题：

 int a[5] = {0, 1, 2, 3, 4};
    vector<int> v4(a, *(&a + 1));

这到底是做什么的以及为什么它与上面的另一件事不同？

Answer 1

int arr[5] = [1,2,3,4,5]
std::vector v(arr, arr + arr.size()/arr[0])

为什么会这样？

这是行不通的。

那么数组也是一个迭代器吗？

数组不是迭代器。但是数组可以隐式转换为指向第一个元素的指针，该元素是数组的迭代器。

---

int a[5] = {0, 1, 2, 3, 4};
矢量 v4(a, *(&a + 1));

这到底是做什么的

是一种不必要的复杂书写方式：

std::vector<int> v4(std::begin(a), std::end(a));

Answer 2

int arr[5];

int *begin=arr;
int *end=arr+sizeof(arr)/sizeof(*arr);

std::vector<int> v(begin, end);

这里的arr（如begin=arr）是一个“指针”，可以像迭代器一样使用。所以 begin=arr 是一个指向数组开头的“迭代器”，而 end 是一个指向“beginning + 5”的“迭代器”。

更精确一点：这里数组的名称“衰减”为指针。在许多情况下，名称可以用作指针，类似于 &arr[0]，即指向第一个元素的指针。

构造 sizeof(array )/sizeof(*array) 回到旧的 C 时代，返回数组中的元素数量。 sizeof 本身仅返回以字节为单位的大小，但如果将其除以单个元素的大小，则可以获得元素的数量。

现在您有了正确的“开始”和“结束”迭代器，您可以从中构造一个 std::vector 。它只是向量的构造函数之一，它需要两个迭代器。

---

你的其他问题与第一个问题完全不同。

向量v4(a, *(&a + 1));

现在我不确定这是否完全有意义。也许你这里有错字。这将尝试调用一个向量构造函数，将 int[] 或 int* 作为第一个参数，将 int 作为第二个参数。

签名将是 std::vector::vector(int*, int)，但我在 cppreference。

Answer 3

对于初学者来说，有一个拼写错误，

int arr[5] = [1,2,3,4,5]
std::vector<int> v(arr, arr + arr.size()/arr[0])

您的意思似乎是

int arr[5] = {1,2,3,4,5};
std::vector<int> v(arr, arr + sizeof( arr ) / sizeof( arr[0] ));

虽然如果您的编译器支持 C++ 17，您可以编写

#include <iterator>

int arr[5] = {1,2,3,4,5};
std::vector<int> v(arr, arr + std::size( arr ));

在具有罕见异常的表达式中使用的数组将转换为指向其第一个元素的指针。

来自 C++ 17 标准（7.2 数组到指针的转换）

1 “NT 数组”或“未知数组”类型的左值或右值
T 的界限”可以转换为“指向 T 的指针”类型的纯右值。这
应用临时物化转换（7.4）。结果是
指向数组第一个元素的指针。

考虑以下演示程序。

#include <iostream>

int main()
{
    int arr[5] = { 1, 2, 3, 4, 5 };

    std::cout << "sizeof( arr ) = " << sizeof( arr ) << '\n';
    std::cout << "sizeof( arr + 0 ) = " << sizeof( arr + 0 ) << '\n';
}

循环

sizeof( arr ) = 20
sizeof( arr + 0 ) = 4

它的输出可能会像从输出中看到的那样

，数组指示符arr被转换为表达式arr + 0中的指针。如果将数组用作参数表达式，并且当数组转换为指向其第一个元素的指针时，相应的参数类型不是引用类型，则同样的方式。

类模板 std::vector 中没有第一个参数具有数组引用类型的构造函数。

但是有一个模板构造函数接受相同类型的两个第一个参数，

template <class InputIterator>
vector(InputIterator first, InputIterator last, const Allocator& = Allocator());

因此在此声明中

std::vector<int> v(arr, arr + sizeof( arr ) / sizeof( arr[0] ));

使用了两个上述构造函数，其中两个第一个参数转换为 int * 类型的指针。

指针与随机访问迭代器具有相同的操作。因此，向量是使用整数值范围 [arr, arr + sizeof( arr ) / sizeof( arr[0] ) 创建的

对于此表达式

*(&a + 1)

，则表达式 &a 的类型为 int ( * )[5] 指向数组 a.. 表达式&a + 1 指向数组最后一个元素的地址。解除引用的表达式 *(&a + 1) 的类型为 int[5]，表示再次用作表达式的数组，该数组将转换为 int * 类型的指针。

因此，实际上在此声明中有两个 int * 类型的表达式。

vector<int> v4(a, *(&a + 1));

但是，这种方法并不正确，因为您可能无法取消引用指向有效对象的指针。

Answer 4

第一部分有几个错误：

int arr[5] = [1,2,3,4,5]
std::vector<int> v(arr, arr + arr.size()/arr[0])

正确的版本是：

int arr[5] = {1,2,3,4,5};
std::vector<int> v(arr, arr + sizeof(arr)/sizeof(arr[0]));

其中 arr 加上“arr 中的元素数量”是刚刚经过 arr 末尾的指针。

在第二部分中，*(&a + 1) 是一个指针。 &a 是一个指向 a 的指针，它是一个由 5 个整数组成的数组。因此，加 1 会使指针 sizeof(a) 字节增加（整数大小的 5 倍）。因此，结果再次是一个刚刚经过 a 末尾的指针，因此向量是用 a 的元素初始化的。