C++ C++；迭代结构

是否可以遍历结构

比如说

struct team{
   int player1;
   int player2;
   int player3;
   int player4;
   ...
   int player99; 
   int size = 99;
}

然后运行for循环来设置或访问foo 1-4

我猜伪代码看起来像

for(int i = 0; i < size; i++){
    player i = (i+1); 
 }

for（int i=0；i

---

如果没有意义的话，一个更简单的解释是我只想能够遍历每个变量，而不必硬编码player1=1；player2=2。

我建议使用容器而不是许多变量，例如您可以使用

std:：array

或

std:：vector

。通过这种方式，迭代将变得非常简单，创建副本将更加容易。但从设计的角度来看，这也更好：如果您决定更改播放器的数量，那么更改容器比添加/删除许多字段要容易得多

一种方法是将播放器/元素放入一个数组中：

struct Team {
    static int const size = 99;
    int players[size];
};

然后：

for(int i = 0; i < size; ++i)
    int player = players[i];

for（int i=0；i

要回答您提出的问题，我相信您可以使用预编译器宏包（确切的短语取决于您的编译器）来保证用于创建结构实例的内存结构。然后你可以增加一个指针来移动它。。。如果你疯了。这将是一种非常糟糕的方法，而且根本不能保证在不同的编译器上工作，甚至不能保证在一周中的不同日子工作。不，你想要的是一个数据结构来为你做这项工作；他们有100%的现金返还保证

最基本的结构是固定大小的数组，例如：

struct team
{
    int players[99]; //an array
    int manager;
    int coach;
    string teamName;
    //etc etc
}

然后访问您的播放器

team myTeam;
for(int i(0); i < 99; ++i)
{
    myTeam.players[i]; //do whatever
}

更高级

---

如果您需要一个在创建后可以改变大小的数据结构，例如，您可能希望在将来的某个时候为您的团队添加更多的参与者。然后，您可以使用动态数据结构，例如或。您可以定义指向成员的指针，如指向成员的指针函数：

  typedef int team::*member_t;

您可以拥有指向所有成员的指针数组：

  static member_t member[size];

使用这种方法，定义成员函数以迭代所有成员很容易：

  template <class F>
  void for_each(F f)
  {
     for (int i = 0; i < size; ++i)
       f(this->*member[i]);
  }

模板
每个（F）的无效值
{
对于（int i=0；i*成员[i]）；
}

通过使用预处理器宏，您可以在一个位置定义所有成员，在另一个位置定义指向成员的指针，这样您就不会在更改其顺序时出错。请参阅完整代码：

struct team {
#define TEAM_MEMBERS(prefix,suffix) \
  prefix player1 suffix, \
  prefix player2 suffix, \
  prefix player3 suffix

  int TEAM_MEMBERS(,);
  static const int size = 3;
  typedef int team::*member_t;
  static member_t member[size];
  template <class F>
  void for_each(F f)
  {
     for (int i = 0; i < size; ++i)
       f(this->*member[i]);
  }
};
team::member_t team::member[team::size] = {
  TEAM_MEMBERS(&team::,)
};

struct团队{
#定义团队成员（前缀、后缀）\
前缀player1后缀\
前缀player2后缀\
前缀player3后缀
国际团队成员（，）；
静态常数int size=3；
typedef int团队：：*成员；
静态成员_t成员[大小]；
模板
每个（F）的无效值
{
对于（int i=0；i*成员[i]）；
}
};
团队：：成员团队：：成员[团队：：规模]={
团队成员（&团队：，）
};

还有一些测试：

#include <iostream>

int main() {
  team t = { 0 };
  t.for_each([](int m) { std::cout << m << "\n"; }); // prints 0,0,0
  int n = 0;
  t.for_each([&n](int& m) { m = n++; });
  t.for_each([](int m) { std::cout << m << "\n"; }); // prints 0,1,2
  t.player2 = 7;
  t.for_each([](int m) { std::cout << m << "\n"; }); // prints 0,7,2
}

#包括
int main（）{
团队t={0}；
t、 对于每个单元（[]（整数m）{std:：难道你没有理由不使用数组/向量而不是结构吗？在某种程度上，你可以作弊。在这种情况下，对于完全由相同大小的项组成的结构，你可以得到一个指向该结构实例的指针，并将其视为数组。如果该结构更异构，则无法工作。如果它是同质的，如第一，为什么不使用向量或数组呢？我有很多互不相关的变量，它们将被硬编码到一个结构中。我只想遍历它们，将另一组数据设置为存在于我的结构中的变量。如果你有这样一组其他数据，为什么不让它使用同一个结构，这样你就可以用1=分配整个结构，就像在普通C中一样？所以你实际上需要一个键值对的映射…？
//引发异常-数组值为0-98
。什么。这不是Java。当你访问数组超出其边界时，不会引发异常。这是UB。@Cicada羞愧的脸我是双语好奇，不要评判我！（（已修复）
#include <iostream>

int main() {
  team t = { 0 };
  t.for_each([](int m) { std::cout << m << "\n"; }); // prints 0,0,0
  int n = 0;
  t.for_each([&n](int& m) { m = n++; });
  t.for_each([](int m) { std::cout << m << "\n"; }); // prints 0,1,2
  t.player2 = 7;
  t.for_each([](int m) { std::cout << m << "\n"; }); // prints 0,7,2
}