我可以用指针表示多维数组吗?

Question

给出以下代码，我试图理解指针操作是否合法:

struct Foo{
 int *temp1;
}

temp1 => 2d array

struct Foo1{
 int temp1[2][2];
}

temp1 => 3d array

struct Foo2{
 int temp1[3][2][3];
}

我使用静态数据给Foo1和Foo2赋值。例如:

Foo1 f1 =
{
 { 2, 4 },
 { 1, 3 }
};
Foo2 f2 = 
{
   {
       {
           {101, 102, 103},
           {104, 105, 106},
       },
       {
           {107, 108, 109},
           {110, 111, 112},
       },
       {
           {113, 114, 115},
           {116, 117, 118},
       },
   }
};

我可以引用Foo数据从Foo1这样:

Foo f;
f.temp1 = (int*)f1.temp1;
for(int i = 0; i < 2; ++i)
{
 for(int j = 0; j < 2; ++j)
 {
  cout << "i " << i << " j " << j << " value: " << f.temp1[(i * 2) + j] << endl;
 }
}

我可以引用Foo数据从Foo2这样:

Foo f;
f.temp1 = (int*)f2.temp1;
for(int i = 0; i < 3; ++i)
{
 for(int j = 0; j < 2; ++j)
 {
   for(int k = 0; k < 3; ++k)
   {
    cout << "i " << i << " j " << j << " k " << k << " value: " << f.temp1[(i * 3 * 2) + (j * 2) + k] << endl;
   }
 }
}

本质上，我假设数组将被安排在连续内存中，我可以像这样对它进行解引用吗?

Answer 1

这个问题的答案表明答案是是。假设多维数组是用[size1][size2][size3]表示法声明的，那么多维数组确实是在内存中连续布局的。

根据经验，答案也是是。考虑下面的代码，这是我将您在问题中编写的代码片段拼凑在一起编写的。

#include <stdio.h>
#include <iostream>
#include <string>
using namespace std;
struct Foo {
    int *temp1;
};
struct Foo1{
    int temp1[2][2];
};
struct Foo2{
    int temp1[3][2][3];
};

Foo1 f1 =
{
    {
        { 2, 4 },
        { 1, 3 }
    }
};
Foo2 f2 = 
{
    {
        {
            {101, 102, 103},
            {104, 105, 106},
        },
        {
            {107, 108, 109},
            {110, 111, 112},
        },
        {
            {113, 114, 115},
            {116, 117, 118},
        },
    }
};

int main(){

    int* temp1 = (int*) f1.temp1;
    for(int i = 0; i < 2; ++i)
        for(int j = 0; j < 2; ++j)
            cout << "i " << i << " j " << j << " value: " 
                << temp1[(i * 2) + j] << endl;
    temp1 = (int*) f2.temp1;
    cout << endl;
    for(int i = 0; i < 3; ++i)
        for(int j = 0; j < 2; ++j)
            for(int k = 0; k < 3; ++k)
                cout << "i " << i << " j " << j << " k " << k << " value: " 
                    << temp1[(i * 3 * 2) + (j * 3) + k] << endl;
}

输出:

i 0 j 0 value: 2
i 0 j 1 value: 4
i 1 j 0 value: 1
i 1 j 1 value: 3
i 0 j 0 k 0 value: 101
i 0 j 0 k 1 value: 102
i 0 j 0 k 2 value: 103
i 0 j 1 k 0 value: 104
i 0 j 1 k 1 value: 105
i 0 j 1 k 2 value: 106
i 1 j 0 k 0 value: 107
i 1 j 0 k 1 value: 108
i 1 j 0 k 2 value: 109
i 1 j 1 k 0 value: 110
i 1 j 1 k 1 value: 111
i 1 j 1 k 2 value: 112
i 2 j 0 k 0 value: 113
i 2 j 0 k 1 value: 114
i 2 j 0 k 2 value: 115
i 2 j 1 k 0 value: 116
i 2 j 1 k 1 value: 117
i 2 j 1 k 2 value: 118

Answer 2

标准清楚而明确地表明答案是肯定的。参见n3797 s8.3.4。有些语言很难读懂，但最后的注释是:

[注:由此可见，c++中的数组是按行存储的(最后一个下标变化最快)，声明中的第一个下标有助于确定数组所消耗的存储量，但在下标计算中没有其他作用。-end note]

因此，您可以通过使用简单的指针算术计算来引用任何数组中的存储空间，并通过简单地增加指针来遍历任何数组中的所有存储空间。

请注意，数组不需要打包。它们通常是这样的，但是可以在元素之间插入填充(但不能在行或列之间插入额外的填充)。