7

我如何遍历一个数字列表，有多少种不同的方法可以做到这一点？

我认为会起作用的：

#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'in 'numbers'，它是非类类型'int[4]'

4

9 回答 9

28

与许多现代语言不同，普通 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 数组，您可以将大小存储在其他地方，或者根据数组类型的大小计算数组的大小。计算数组的大小在 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
}

如果您使用任何提供 a .begin()and.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（新标准）还带来了新的和花哨的范围，因为它应该适用于任何提供 a.begin()和.end(). 但是：此功能的编译器支持可能会有所不同。您也可以使用begin(type)andend(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;
    }
}

这个列表远非全面，但正如您所见，有很多方法可以迭代集合。一般来说，除非您有充分的理由不这样做，否则您更喜欢迭代器。

于 2013-01-16T03:46:11.250 回答
6

将您的 for 循环更改为 

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

简而言之， sizeof(numbers)数组中的平均元素数 * 原始类型 int 的大小，因此除以sizeof(int)得到元素数

于 2013-01-16T03:29:19.003 回答
5

如果你修复它，它是list<int> numbers = {1,2,3,4}：

通过使用迭代器进行迭代：

#include <iterator>

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

通过 using 迭代std::for_each：

#include <algorithm>
#include <iterator>

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

利用 for-each 循环 (C++11)：

for(int i : numbers) { ... }
于 2013-01-16T03:30:46.637 回答
2

“普通” C 样式数组没有size函数。如果要使用std::vector则需要使用size，或者通过计算大小sizeof。

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

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

其他一切都保持不变（请参阅此处的演示）。

于 2013-01-16T03:28:05.880 回答
2

您还可以使用普通的旧 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;
}
于 2016-02-16T13:50:59.897 回答
1

我没有在答案中看到它，但这是 imo 最好的方法：基于范围的 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;
}
于 2018-12-22T16:27:29.967 回答
0

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

于 2013-01-16T03:32:44.833 回答
0

如果您的数字列表是固定的，请注意您可以简单地编写：

#include <iostream>
#include <initializer_list>

int main()
{
    for (int i : {2, 4, 6, 8})
        std::cout << i << std::endl;
    return 0;
}
于 2021-10-29T08:14:59.170 回答
0

在我看来，最简单的方法是使用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 库的一部分。要使用它们，请从此处下载库，并将下载路径添加到编译命令中，例如g++ -o foo foo.cpp -I/path/to/gsl
  • 在 C++20 中，span将成为标准的一部分，因此您只需使用std::spanand #include <span>。
于 2018-12-17T21:53:38.620 回答