C++ 带指针的数组分区

我有一个20x20数组，需要通过读取一个4x4数组来迭代它。我原以为我可以用有针对性的任务来完成这项任务，但除了强制关闭外，它没有什么作用

const char SOURCE[20][20];
const char **pointer;

for(int x = 0; x < 20; x+=4)
{
    for(int y = 0; y < 20; y+=4)
    {
        pointer = (const char **)&SOURCE[x][y];
        printGrid(pointer);
    }
}

void printGrid(const char **grid)
{
    // do something usefull
}

const char SOURCE[20][20]；
常量字符**指针；
对于（int x=0；x<20；x+=4）
{
对于（int y=0；y<20；y+=4）
{
指针=（常量字符**）和源[x][y]；
打印网格（指针）；
}
}
无效打印网格（常量字符**网格）
{
//做一些有用的事
}

指向指针的指针与数组的数组不同

但是，您可以使用指向数组的指针：

const char (*pointer)[20];

当然，您需要更新

printGrid

函数以匹配类型

---

---

关于指向指针的指针和数组的数组（通常也称为矩阵）的原因，请参见显示这两个数组的内存布局的示例。

您的2D数组类型为

char

：

const char SOURCE[20][20];

当您对其进行迭代时，您可以查看

char

或使用

char*

引用地址：

for(int x = 0; x < 20; x+=4)
{
    for(int y = 0; y < 20; y+=4)
    {
        printGrid(SOURCE[x][y]); // do this unless you need to do something with pointer
    }
}

或

---

扩展James的答案，您可以如下更改代码，因为它会将指针传递到一个4

char

数组，而不仅仅是

char

数组

for(int x = 0; x < 20; x+=4)
{
    for(int y = 0; y < 20; y+=4)
    {
        char const (*p4[4])[4] =
        {
            (const char(*)[4])(SOURCE[x] + y),
            (const char(*)[4])(SOURCE[x + 1] + y),
            (const char(*)[4])(SOURCE[x + 2] + y),
            (const char(*)[4])(SOURCE[x + 3] + y)
        };
    }
}

for（int x=0；x<20；x+=4）
{
对于（int y=0；y<20；y+=4）
{
字符常量（*p4[4]）[4]=
{
（常量字符（*）[4]）（源[x]+y），
（常量字符（*）[4]）（源[x+1]+y），
（常量字符（*）[4]）（源[x+2]+y），
（常量字符（*）[4]）（源[x+3]+y）
};
}
}

仅将指针强制转换为其他类型不会改变 它指向的类型（通常会导致未定义 行为，除非你真的知道自己在做什么）。如果你 无法更改打印网格，您必须创建一个 动态指针：

for ( int x = 0; x < 20; x += 4 ) {
    for ( int y = 0; y < 20; y += 4 ) {
        char const* p4[4] =
        {
            source[x] + y,
            source[x + 1] + y,
            source[x + 2] + y,
            source[x + 3] + y
        };
        printGrid( p4 );
    }
}

for（int x=0；x<20；x+=4）{
对于（int y=0；y<20；y+=4）{
字符常量*p4[4]=
{
源[x]+y，
源[x+1]+y，
源[x+2]+y，
源[x+3]+y
};
打印网格（p4）；
}
}

这仍然不行。根据他的说法，

printGrid

需要一个指向4个

char const*

数组的指针，每个数组都指向4个

char

。您给它一个指向单个

char const*

的指针，该指针指向

20-y

char

数组。一点也不一样。@JamesKanze虽然你的解决方案似乎是最好的，但对我更新的解决方案有什么建议吗？似乎有太多的间接性

printGrid

需要一个指向指针数组[4]的指针，因此在某个点上，您需要一个

char const*tmp[4]（我在您的代码中没有看到）。没有别的办法。然后将该数组中第一个元素的地址传递给它（几乎可以肯定是通过隐式数组到指针的转换获得的）。@JamesKanze现在应该很好了，他的函数
printGrid
（因为
p4
隐式转换为
字符常量（**）[4]
，而不是
字符常量**
）。您需要显式转换这一事实应该是某种不正确的迹象。它会确保p4的元素是指向4个整数数组的指针吗？？我认为它只是一个指向常量char的4指针数组。不应该是
char const（*p4[4]）[4]
？？@Saksham通常，“指向数组的指针”是指向数组的第一个元素的指针；这是将数组转换为指针时得到的结果。指针的用户需要知道它是指向单个对象的指针，还是指向数组的第一个元素的指针，以及数组中有多少个元素
char-const（*p4[4））[4]
将是指向数组的指针数组；如果没有显式强制转换，我无法初始化它，因为我没有任何
char-const[4]
的地址可以初始化它。而且它没有传递到
printGrid
的正确类型。
for(int x = 0; x < 20; x+=4)
{
    for(int y = 0; y < 20; y+=4)
    {
        char const (*p4[4])[4] =
        {
            (const char(*)[4])(SOURCE[x] + y),
            (const char(*)[4])(SOURCE[x + 1] + y),
            (const char(*)[4])(SOURCE[x + 2] + y),
            (const char(*)[4])(SOURCE[x + 3] + y)
        };
    }
}

for ( int x = 0; x < 20; x += 4 ) {
    for ( int y = 0; y < 20; y += 4 ) {
        char const* p4[4] =
        {
            source[x] + y,
            source[x + 1] + y,
            source[x + 2] + y,
            source[x + 3] + y
        };
        printGrid( p4 );
    }
}