Question

如何遍历数字列表，以及有多少种不同的方法可以做到？

我认为会起作用：

#include <cstdlib>
#include <iostream>
#include <list>


using namespace std;


int main()

{
    int numbers[] = {2, 4, 6, 8};
    int i = 0;
    for(i=0; i< numbers.size();i++)
            cout << "the current number is " << numbers[i];


    system("pause");

    return 0;

}

我在for循环行上遇到错误：

请求'size'中的成员'numbers'，该成员属于非类型'int[4]'

Answer 1

与许多现代语言不同，普通C ++数组没有.size()函数。根据存储类型，您可以通过多种方式迭代列表。

一些常见的存储选项包括：

// used for fixed size storage. Requires #include <array>
std::array<type, size> collection;

// used for dynamic sized storage. Requires #include <vector>
std::vector<type> collection;

// Dynamic storage. In general: slower iteration, faster insert
// Requires #include <list>     
std::list<type> collection;  

// Old style C arrays
int myarray[size];

您的迭代选项取决于您使用的类型。如果您使用的是普通的旧C数组，则可以将其大小存储在其他位置，或者根据数组的大小来计算数组的大小。 Calculating the size of an array has a number of drawbacks outlined in this answer by DevSolar

// Store the value as a constant
int oldschool[10];
for(int i = 0; i < 10; ++i) {
    oldschool[i]; // Get
    oldschool[i] = 5; // Set
} 

// Calculate the size of the array
int size = sizeof(oldschool)/sizeof(int);
for(int i = 0; i < size; ++i) {
    oldschool[i]; // Get
    oldschool[i] = 5; // Set
}

如果您正在使用提供.begin()和.end()函数的任何类型，您可以使用它们来获取迭代器，与基于索引的迭代相比，它在C ++中被认为是好的样式：

// Could also be an array, list, or anything with begin()/end()
std::vector<int> newschool;     

// Regular iterator, non-C++11
for(std::vector<int>::iterator num = newschool.begin(); num != newschool.end(); ++num) {
    int current = *num; // * gets the number out of the iterator
    *num = 5; // Sets the number.
}

// Better syntax, use auto! automatically gets the right iterator type (C++11)
for(auto num = newschool.begin(); num != newschool.end(); ++num) {
    int current = *num; // As above
    *num = 5;
}

// std::for_each also available
std::for_each(newschool.begin(), newschool.end(), function_taking_int);

// std::for_each with lambdas (C++11)
std::for_each(newschool.begin(), newschool.end(), [](int i) {
    // Just use i, can't modify though.
});

向量也很特殊，因为它们被设计为数组的直接替换。您可以使用.size()函数完全迭代向量。但是，这在C ++中被认为是不好的做法，你应该尽可能使用迭代器：

std::vector<int> badpractice;
for(int i = 0; i < badpractice.size(); ++i) {
    badpractice[i]; // Get
    badpractice[i] = 5; // Set
}

C ++ 11（新标准）还带来了新的和奇特的范围，适用于任何提供.begin()和.end()的类型。但是：编译器支持可能因此功能而异。您也可以使用begin(type)和end(type)替代。

std::array<int, 10> fancy;
for(int i : fancy) {
    // Just use i, can't modify though.
}

// begin/end requires #include <iterator> also included in most container headers.
for(auto num = std::begin(fancy); num != std::end(fancy); ++num) {
    int current = *num; // Get
    *num = 131; // Set
}

std::begin还有另一个有趣的属性：它适用于原始数组。这意味着您可以在数组和非数组之间使用相同的迭代语义（您仍然应该比原始数组更喜欢标准类型）：

int raw[10];
for(auto num = std::begin(raw); num != std::end(raw); ++num) {
    int current = *num; // Get
    *num = 131; // Set
}

如果要在循环中删除集合中的项目，还需要小心，因为调用container.erase()会使所有现有迭代器无效：

std::vector<int> numbers;
for(auto num = numbers.begin(); num != numbers.end(); /* Intentionally empty */) {
    ...

    if(someDeleteCondition) {
        num = numbers.erase(num);
    } else {
        // No deletition, no problem
        ++num;
    }
}

这个列表远非全面，但正如您所看到的，有很多方法可以迭代集合。通常更喜欢迭代器，除非你有充分的理由不这样做。

Answer 2

将你的循环改为

 for(i=0; i< sizeof(numbers)/sizeof(int);i++){

简单来说， sizeof(numbers)表示数组中元素的数量*基本类型int的大小，因此除以sizeof(int)以获取元素数

Answer 3

如果您将其修改为list<int> numbers = {1,2,3,4}：

使用迭代器迭代：

#include <iterator>

for(auto it = std::begin(numbers); it != std::end(numbers); ++it) { ... }

使用std::for_each：

进行迭代

#include <algorithm>
#include <iterator>

std::for_each(numbers.begin(), numbers.end(), some_func);

利用for-each循环（C ++ 11）：

for(int i : numbers) { ... }

Answer 4

“普通”C风格数组上没有size函数。如果您想使用std::vector，或者通过size计算尺寸，则需要使用sizeof。

在C ++ 11中，您可以使用数组初始化语法来初始化向量，如下所示：

vector<int> numbers = {2, 4, 6, 8};

其他所有内容保持不变（请参阅演示here）。

Answer 5

您还可以使用普通的旧C容器和使用循环的迭代器语法：

#include <iostream>

int main()
{
    int numbers[] = {2, 4, 6, 8};
    int *numbers_end = numbers + sizeof(numbers)/sizeof(numbers[0]);
    for (int *it = numbers; it != numbers_end; ++it)
        std::cout << "the current number is " << *it << std::endl;

    return 0;
}

Answer 6

没有成员函数“size”，因为“numbers”不是类。你无法以这种方式获得数组的大小，你必须知道（或计算它）或使用某个类来存储你的数字。

Answer 7

我认为，最简单的方法是使用span。

#include <cstdlib>
#include <iostream>
#include <gsl/span>

int main() {
    int numbers[] = {2, 4, 6, 8};
    for(auto& num : gsl::span(numbers)) {
            cout << "the current number is " << num;
    }

    system("pause");
}

注意：

跨度是GSL库的一部分。要使用它们，请从here下载库，然后将下载路径添加到编译命令中，例如g++ -o foo foo.cpp -I/path/to/gsl
在C ++ 20中，span将成为标准的一部分，因此您只需使用std::span和#include <span>。

Answer 8

我没有在答案中看到它，但这是imo做到这一点的最佳方法：Range-based for loop

使用演绎法转发参考文献是安全的，实际上，在通用代码中更可取：
for（auto && var：sequence）。

极简主义和实际示例：

#include <list>
#include <iostream>

int main()
{
    std::list<int> numbers = {2, 4, 6, 8};
    for (const int & num : numbers)
        std::cout << num << "  ";
    std::cout << '\n';
    return 0;
}

如何迭代c ++中的数字列表

8 个答案: