Question

我正在尝试创建一个嵌套的for循环，用于填充数组中从1到20的值。

IE）array = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20}

int array [20];

for(int i = 0; i<21; i++)
{
    for(int j =1; j<21; j++)
    {
         array[i] = j;
        cout<< array[i];
    }

}

据说，数组索引应该用“i”计数，并且应该等于“j”，它也在计数。数组元素在填充时会打印到控制台。

我预计会打印一次1到20，但是当我运行代码时，1-20会多次打印出来。有人能告诉我这个问题吗？谢谢！

Answer 1

你的外部for循环运行21次，你的内部for循环运行20次外部for循环迭代，所以你总共有21 * 20 = 420个打印语句。

你可以简单地做

for(int i = 0 ; i < array.length ; i++)
{
    array[i] = i + 1;
    cout << array[i] << endl;
}

Answer 2

如果你在完成后查看你的数组，它也只是一系列20秒。第一个循环是“执行20次”，然后第二个循环说“设置并打印该数组元素的值20次”。您需要做的是检查是否将正确的j值分配给正确的array [i]值，并仅在该情况下设置值。类似的东西：

if (j == i + 1) array[i] = j;

Answer 3

为什么需要嵌套循环？

for(int i = 0; i<20; i++)
{
    array[i] = i + 1;
    cout<< array[i];
}

Answer 4

是的，当你只需要一个循环时，你有两个循环：

for(int i = 0; i<21; i++)
{
  array[i] = i + 1;
  cout<< array[i];
}

Answer 5

为了填充数组并打印结果，您只需要两个简单的for循环

for(int i = 0; i<20; i++)
{
    array[i] = j;
}

for(int j =0; j<20; j++)
{
    cout<< array[i];
}

您在上面创建的嵌套循环将完全按照您的描述执行。对于外部for循环的每个循环，它将执行内部循环的完整20个循环。所以总共会执行21 * 20次。

还要小心索引。您希望从int i = 0开始到< 20，它会完全循环20次。

Answer 6

我不知道你为什么要在你的数组中打印单个元素，但是没有必要在这里使用嵌套循环;事实上，根本不需要循环：

// vector version
std::vector<int> vec(20);
std::iota(vec.begin(), vec.end(), 1);

// array version
int arr[20];
std::iota(std::begin(arr), std::end(arr), 1);

如果要在初始化后打印出整个数组：

std::copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, "\n"));

Answer 7

我看到很多人回答了这个问题，所以我不再重复了，我只是提到你是在数组大小之外写的。如果你有int array[20]，你应该循环

for（int i = 0; i＆lt; 20 ; i ++）最后一个指数是19

Answer 8

外环21次重复内环

for(int i = 0; i<21; i++)
{
    for(int j =1; j<21; j++)
    {
         array[i] = j;
        cout<< array[i];
    }

}

内部循环执行与分配数组sequantial数字元素相同的操作。此外，您的代码有一个错误，因为外部循环您试图访问不存在的元素数组[20]，因为如果数组被定义为

int arrat[20];

然后有效的指标是0 - 19。

无需编写正确的所需循环或循环，您可以使用标准算法std::iota

例如

#include <iostream>
#include <numeric>
#include <iterator>
#include <algorithm>

int main()
{
   const size_t N = 20;
   int array[N];

   std::iota( std::begin( array ), std::end( array ), 1 );
   std::copy( std::begin( array ), std::end( array ), std::ostream_iterator<int>( std::cout, " " ) );
}

或者代替算法，您可以使用基于范围的语句。例如

#include <iostream>

int main()
{
   const size_t N = 20;
   int array[N];
   int i = 1;

   for ( int &x : array )
   {
       x = i++;
       std::cout << x << ' ';
   }
}

Answer 9

如果您真的想使用嵌套解决方案（例如游戏板坐标），那么这就是我的解决方案。

// nesting arrays for example game board coordinates                                                                                                                                       

#include <iostream>

  int main(){
  int x = 20;
  int y = 40;

  int array[x][y];

  // initialize array of variable-sized.                                                                                                                                
  for(int i = 0; i < x; ++i){
    for(int j = 0; j < y; ++j){
      array[i][j] = 0; // or something like i + j + (i * (y-1)) if you wish                                                                                             
      // and send it to cout                                                                                                                                            
      std::cout << array[i][j] << " ";
    }
    std::cout << std::endl;
  }
  //notice, that when sent to cout like this, x and y flips on screen, but                                                                                              
  //logics of coordinates is ok                                                                                                                                         

  // and then do something usefull with it                                                                                                                              

  return EXIT_SUCCESS;
}

Answer 10

int size = 20;

for (int i = 0; i < size; i++)
   {    int array[i];
        array[i] = i + 1;
        cout << array[i]<< " ";
   }

您可以使用1 for循环填充数组，并像上面所述测量数组的大小。

嵌套for循环填充数组

10 个答案: