我编写了一个程序来显示数组的内容，但它显示的是它的地址

在您的响应中，计数器和计数器 2 数组的前两行输出是正确的。

第三个输出是基于这样一个事实，即初始化时的数组充满了垃圾值，没有别的。

让我们离开"counter2"数组一次，看看你的代码"Counter"。

我想就是这样了。

int main ()
{
int i,counter[25];
int j,counter2[25];
for(i=0;i<=20;i++){
if(i%2==1)
continue;
counter[i]=i;
cout<<counter[i]<<"  ";
}
cout<<"n";
for(i=0;i<=20;i++){
cout<<counter[i]<<"  ";
}
return 0;
}

如果您仔细查看循环代码

for(i=0;i<=20;i++){
if(i%2==1)
continue;
counter[i]=i;
cout<<counter[i]<<"  ";
}

您正在做的是检查此条件是否为"true"

if(i%2==1)
continue;

那么在"假"上你做的是

counter[i]=i;
cout<<counter[i]<<"  ";

在这里，这些值入到您在 if 条件中与之进行比较的相应值"i"。

换句话说，在

如果您正在比较

i=2
in
if(i%2==1)
this will go "false" and to next statement 
counter[i]=i;
i.e. counter[2]=2;

你基本上是在数组中插入值，如下所示：

_ 2 _ 4 _ 6 _ 8 _ 10 ...etc

它只修改数组中的特定值，而其他值保持不变。

第二个数组"Counter2"也是如此。

标准输出上打印的值不是地址。它们是存储的值。

您需要知道的第一件事是，除非未初始化，否则每个变量在声明期间都会获得垃圾值。如果初始化一个变量，则该变量将携带该值，直到它被其他语句更改。

• 您可以看到偶数索引 0、2、4、...、20 的值与您在第一个for循环中设置的值相同。
• 但是奇数指数的值并不像您期望的那样。因为在第二个for循环中，您已经遍历了from 101 to 115并且没有在正确的索引处设置值。此外，在第二个循环中，您将值存储在数组counter2中，但最后，您正在打印数组counter的值。

最后，当您打印数组counter中的值时，程序会输出当时存储的值。如果未初始化或分配其他值，它将是垃圾值。

您没有打印地址。您正在打印未初始化的整数值。问题出在数组的初始化中。原因是这条线counter2[j] = j;正在尝试索引数组的第 j 个元素，但 j 从 101 递增到 115。如果您只是想获取从 101 到 115 的偶数，请执行如下操作：

for (int j = 0; j <= 7; j++)
{
counter2[j] = (100 + 2*(j + 1) - 1);
}

当您要编写 for 循环以将元素插入数组时，通常希望递增的变量表示要编辑的元素的索引。

在 C/C++ 中，当您使用整数文本声明具有自动存储持续时间的数组时，例如：

int i,counter[25];
int j,counter2[25];

counter和counter2的有效索引0 <= index < 25。在您的代码中，尽管您if语句，但当您这样做时：

for(j=0;j<=115;j++){
if(j%2==0)
continue;
if(j<101 && j>0)
continue;
counter2[j]=j;
cout<<counter2[j]<<"  ";
}

将101传递到115作为索引：

counter2[j]=j;
cout<<counter2[j]<<"  ";

这超出了数组边界，并在代码中调用未定义的行为。

此外，对于由于检查以下各项而未通过为其赋值来初始化的所有索引：

if(i%2==1)
continue;

和

if(j%2==0)
continue;

导致这些元素处于counter状态，并且counter2未分配包含不确定值的值。任何尝试在变量值不确定的情况下访问具有自动存储持续时间的变量的值都会导致未定义的行为。为了避免跳过索引时出现问题，请在声明数组时初始化数组零的所有元素，例如

int i,counter[25] = {0};
int j,counter2[25] = {0};

总而言之，您可以执行以下操作：

#include <iostream>
#include <iomanip>
#include <string>
int main (void) {
int i,counter[25] = {0};
int j,counter2[25] = {0};
for (i = 0; i <= 20; i++){
if (i % 2 == 1)
continue;
counter[i]=i;
std::cout << counter[i] << "  ";
}
std::cout << "n";
for (j = 0; j <= 15; j++){
int v = j + 101;
if (v % 2 == 0)
continue;
counter2[j] = v;
std::cout << counter2[j] << "  ";
}
std::cout<<"nn";
for(i = 0; i <= 20; i++) {
std::cout << counter[i] << "  ";
}
std::cout << 'n';
}

(注意：包括整个namespace std不被认为是好的做法。 年长的眼睛欣赏间隔合理的代码......

示例使用/输出

$ ./bin/array_shift_idx
0  2  4  6  8  10  12  14  16  18  20
101  103  105  107  109  111  113  115
0  0  2  0  4  0  6  0  8  0  10  0  12  0  14  0  16  0  18  0  20

仔细查看，如果您有其他问题，请告诉我。

使用单独的索引变量

当您有一个固定数组并且您要在该数组中读取一定数量的值时，这些值可能/可能不少于数组中的元素总数，您将需要保留一个单独的变量(或计数器)来保存填充的元素数。然后，在遍历数组时，您可以从0 <= i < filled迭代。

在这里，您使用 for 循环变量作为值，并使用循环变量作为索引。当您测试该值，然后continue;它是否不是您想要的时，您将跳过填充关联的索引。要解决此问题，您只需保留单独的值，以保存数组中最后一个填充的索引。例如：

#define NELEM 25    /* if you need a constant, #define one (or more) */
int main (void) {
int counter[NELEM]  = {0},  /* initialize array elements zero */
counter2[NELEM] = {0},
ndx1 = 0, ndx2 = 0;     /* separate indexes for counter/counter2 */

变量ndx1和ndx2是最后填充在counter和counter2中的索引。现在，当您循环时，只有在为数组赋值时才会递增索引，例如

for (int i = 0; ndx1 < NELEM; i++) {    /* fill counter w/even values */
if (i % 2 == 1)
continue;
counter[ndx1++] = i;                /* assign value/advance index */
}

(注意：这里所有元素都被填充了，但你明白了。您使用自变量。一个用于您生成的值，一个用于数组的索引)

同样，对于counter2数组，您可以执行以下操作：

for (int i = 0; ndx2 < NELEM; i++) {    /* fill counter2 w/odd values */
int v = i + 101;                    /* add 101 to each value */
if (v % 2 == 0)
continue;
counter2[ndx2++] = v;               /* assign value/advance index */
}

使用上述内容的简短示例，用从0开始的偶数值填充counter元素，用从101开始的奇数值填充counter2，并确保每个数组中的所有值都是连续的，可能类似于：

#include <iostream>
#include <iomanip>
#define NELEM 25    /* if you need a constant, #define one (or more) */
int main (void) {
int counter[NELEM]  = {0},  /* initialize array elements zero */
counter2[NELEM] = {0},
ndx1 = 0, ndx2 = 0;     /* separate indexes for counter/counter2 */
for (int i = 0; ndx1 < NELEM; i++) {    /* fill counter w/even values */
if (i % 2 == 1)
continue;
counter[ndx1++] = i;                /* assign value/advance index */
}
for (int i = 0; ndx2 < NELEM; i++) {    /* fill counter2 w/odd values */
int v = i + 101;                    /* add 101 to each value */
if (v % 2 == 0)
continue;
counter2[ndx2++] = v;               /* assign value/advance index */
}
std::cout<<"counter:n";                /* output counter values */
for (int i = 0; i < ndx1; i++) {
if (i && i % 10 == 0)               /* 10 values per-row */
std::cout << 'n';
std::cout << std::setw(4) << counter[i];
}
std::cout<<"nncounter2:n";           /* output counter2 values */
for (int i = 0; i < ndx2; i++) {
if (i && i % 10 == 0)               /* 10 values per-row */
std::cout << 'n';
std::cout << std::setw(4) << counter2[i];
}
std::cout << 'n';
}

示例使用/输出

$ ./bin/array_shift_idx2
counter:
0   2   4   6   8  10  12  14  16  18
20  22  24  26  28  30  32  34  36  38
40  42  44  46  48
counter2:
101 103 105 107 109 111 113 115 117 119
121 123 125 127 129 131 133 135 137 139
141 143 145 147 149

您可以根据需要调整循环限制以仅填充0 - 20或101 - 115，也可以简单地迭代少于NELEM次以生成所需的输出。完全取决于你。关键是，由于您保留了捕获每个数组中填充的元素数量的单独索引，因此您可以采用任何一种方式执行此操作，并且永远不会迭代任一数组中的最后一个填充元素。

在counter2中仅填充第 1 个 8 个奇数值

例如，如果您只想向counter2添加101 - 115而将其他元素保留为未填充状态，则只需更改：

for (int i = 0; i <= 15; i++) {         /* fill counter2 w/odd values */
int v = i + 101;                    /* add 101 to each value */
if (v % 2 == 0)
continue;
counter2[ndx2++] = v;               /* assign value/advance index */
}

现在，counter2的输出将是：

counter2:
101 103 105 107 109 111 113 115