Question

鉴于以下代码，我试图了解指针操作是否合法：

struct Foo{
 int *temp1;
}

temp1 =＆gt; 2d数组

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

temp1 =＆gt; 3d数组

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},
       },
   }
};

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

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;
 }
}

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

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

this question的答案表明答案是是。多维数组确实在内存中连续排列，假设它们以[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 ++中的数组是按行存储的（最后一个下标变化最快），并且声明中的第一个下标有助于确定数组所消耗的存储量，但不会发挥其他任何作用。下标计算。 - 后注]

因此，您可以通过使用简单指针算法的计算引用任何数组中的存储，并通过递增指针迭代任何数组中的所有存储。

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

我能用指针表示多维数组吗？

2 个答案: