C++ 是否可以使用负索引访问二维数组？

我试图访问程序中的二维数组，并且尝试使用负索引（这有助于我的思维步骤）。我想对access数组元素使用最简洁的语法，即

a[I][j]

然而，当我运行程序时，我得到了分段错误

#include <iostream>

int main (void)
{
    int i,j;
    int arr[3][3];
    int ** p;

    for( i=0; i<3; i++)
    {
        for(j=0; j<3; j++)
        {
            arr[i][j] = i+j;
        }
    }

    p = (int **)&(arr[1][1]);

    for( i=-1; i<2; i++)
        {
            for(j=-1; j<2; j++)
            {
                std::cout << p[i][j] << std::endl;
            }
        }
    return 0;
}

#包括
内部主（空）
{
int i，j；
int arr[3][3]；
int**p；
对于（i=0；iC++标准定义：

5.2.1/1（…）非范围枚举或整数类型。（…）表达式E1[E2]与*（（E1）+（E2）的定义相同

因此它不需要正积分（不同于数组的大小，根据8.3.4，数组的大小必须是正的）。当E1是指针，E2是正积分或负积分时，5.7定义了E1+E2

因此，是的，原则上它应该是有效的。例如：

 int a[4][5] = { { 11, 12, 13, 14,15 }, { 21, 22, 23, 24,25 }, { 31, 32, 33, 34,35 }, { 41, 42, 43, 44,45 } };
 typedef int (*myarr)[5];
 myarr p  = (myarr) &a[2][2];
 cout << p[0][0] << endl << p[-2][-2]<<endl; 

inta[4][5]={{11,12,13,14,15}，{21,22,23,24,25}，{31,32,33,34,35}，{41,42,43,44,45}；
typedef int（*myarr）[5]；
myarr p=（myarr）&a[2][2]；
C++标准定义了：

5.2.1/1（…）非范围枚举或整数类型。（…）表达式E1[E2]与*（（E1）+（E2）的定义相同

因此它不需要正积分（不同于数组的大小，根据8.3.4，数组的大小必须是正的）。当E1是指针，E2是正积分或负积分时，5.7定义了E1+E2

因此，是的，原则上它应该是有效的。例如：

 int a[4][5] = { { 11, 12, 13, 14,15 }, { 21, 22, 23, 24,25 }, { 31, 32, 33, 34,35 }, { 41, 42, 43, 44,45 } };
 typedef int (*myarr)[5];
 myarr p  = (myarr) &a[2][2];
 cout << p[0][0] << endl << p[-2][-2]<<endl; 

inta[4][5]={{11,12,13,14,15}，{21,22,23,24,25}，{31,32,33,34,35}，{41,42,43,44,45}；
typedef int（*myarr）[5]；
myarr p=（myarr）&a[2][2]；
C++标准定义了：

5.2.1/1（…）非范围枚举或整数类型。（…）表达式E1[E2]与*（（E1）+（E2）的定义相同

因此它不需要正积分（不同于数组的大小，根据8.3.4，数组的大小必须是正的）。当E1是指针，E2是正积分或负积分时，5.7定义了E1+E2

因此，是的，原则上它应该是有效的。例如：

 int a[4][5] = { { 11, 12, 13, 14,15 }, { 21, 22, 23, 24,25 }, { 31, 32, 33, 34,35 }, { 41, 42, 43, 44,45 } };
 typedef int (*myarr)[5];
 myarr p  = (myarr) &a[2][2];
 cout << p[0][0] << endl << p[-2][-2]<<endl; 

inta[4][5]={{11,12,13,14,15}，{21,22,23,24,25}，{31,32,33,34,35}，{41,42,43,44,45}；
typedef int（*myarr）[5]；
myarr p=（myarr）&a[2][2]；
C++标准定义了：

5.2.1/1（…）非范围枚举或整数类型。（…）表达式E1[E2]与*（（E1）+（E2）的定义相同

因此它不需要正积分（不同于数组的大小，根据8.3.4，数组的大小必须是正的）。当E1是指针，E2是正积分或负积分时，5.7定义了E1+E2

因此，是的，原则上它应该是有效的。例如：

 int a[4][5] = { { 11, 12, 13, 14,15 }, { 21, 22, 23, 24,25 }, { 31, 32, 33, 34,35 }, { 41, 42, 43, 44,45 } };
 typedef int (*myarr)[5];
 myarr p  = (myarr) &a[2][2];
 cout << p[0][0] << endl << p[-2][-2]<<endl; 

inta[4][5]={{11,12,13,14,15}，{21,22,23,24,25}，{31,32,33,34,35}，{41,42,43,44,45}；
typedef int（*myarr）[5]；
myarr p=（myarr）&a[2][2]；
cout可以在数组下标中使用负索引，
[]
中的索引基本上是指针的偏移量，因此如果您写入：

 int array[5]={1,2,3,4,5};
 int *arr=&array[2];
 int val=arr[-2];

得到1。
负索引可以在数组下标中使用，
[]
中的索引基本上是指针的偏移量，因此如果写入：

 int array[5]={1,2,3,4,5};
 int *arr=&array[2];
 int val=arr[-2];

得到1。
负索引可以在数组下标中使用，
[]
中的索引基本上是指针的偏移量，因此如果写入：

 int array[5]={1,2,3,4,5};
 int *arr=&array[2];
 int val=arr[-2];

得到1。
负索引可以在数组下标中使用，
[]
中的索引基本上是指针的偏移量，因此如果写入：

 int array[5]={1,2,3,4,5};
 int *arr=&array[2];
 int val=arr[-2];

您得到1。
据我所知，您试图实现的是，给定2D数组中的一个位置（
[1][1]
），您希望对该位置的邻近区域执行一些操作。下面是一种可读的方法，我强烈建议：

int row = 1;
int col = 1;
for (int i = -1; i < 2; i++) {
    for (int j = -1; j < 2; j++) {
        std::cout << arr[row + i][col + j] << std::endl;
    }
}

工作原理：
p[i]
与
*（p+i）
相同，将
i
添加到
p
意味着添加
i*ROW\u LEN*sizeof（int）
，即通过
i
行（向前或向后）移动位置，保留列。
*（p+i）
的类型是
int[ROW\LEN
，为实现指向
int*
的指针运算而衰减，这意味着
p[i][j]
将
j*sizeof（int）
添加到
p[i]
，也就是说通过
j
更改列，正如我所理解的，您试图实现的是在二维数组中给定一个位置（
[1][1]
），您希望在该位置附近执行一些操作。以下是一种可读的方法，我强烈建议：

int row = 1;
int col = 1;
for (int i = -1; i < 2; i++) {
    for (int j = -1; j < 2; j++) {
        std::cout << arr[row + i][col + j] << std::endl;
    }
}

工作原理：
p[i]
与
*（p+i）
相同，将
i
添加到
p
意味着添加
i*ROW\u LEN*sizeof（int）
，即通过
i
行（向前或向后）移动位置，保留列。
*（p+i）
的类型是
int[ROW\LEN
，为实现指向
int*
的指针运算而衰减，这意味着
p[i][j]
将
j*sizeof（int）
添加到
p[i]
，也就是说通过
j
更改列，正如我所理解的，您试图实现的是在二维数组中给定一个位置（
[1][1]
），您希望在该位置附近执行一些操作。以下是一种可读的方法，我强烈建议：

int row = 1;
int col = 1;
for (int i = -1; i < 2; i++) {
    for (int j = -1; j < 2; j++) {
        std::cout << arr[row + i][col + j] << std::endl;
    }
}

工作原理：
p[i]
与
*（p+i）
相同，将
i
添加到
p
意味着添加
i*ROW\u LEN*sizeof（int）
，即通过
i
行（向前或向后）移动位置，保留列。
*（p+i）
的类型是
int[ROW\LEN
，为实现指向
int*
的指针算术而衰减，其中