C++ 如何理解复杂的数组声明指针，以及&；

以下是两行代码：

int (*parry)[10]   = &arr   // Line # 1
int *(&arrRef)[10] = ptrs   // Line # 2

第1行：

parry

是指向大小为10的

int

数组的指针。
那么这是否意味着：

• parray[1]

  指向

  arr

  的地址

• parray[2]

  指向

  arr的地址

• parray[10]

  指向地址或

  arr

我什么时候使用

行#1

解决方案：

#include <iostream>
int main(
{
 int arr[10] = { 3, 54  };
 int (*parry)[10] = &arr;
 std::cout << (*parry)[0] << " " << (*parry)[1] << " "  << (*parry)[3] << "  " << parry[4] << std::endl;
 return 0;
}

#包括
int main(
{
int-arr[10]={3,54}；
int（*parry）[10]=&arr；
std:：cout如有疑问，请参阅

parry
是指向10
int
s数组的指针

int *(&arrRef)[10] = ptrs;

arrRef
是对指向int的10个指针数组的引用

例如：

int main()
{
   int arr[10];
   int* ptrs[10];

   int (*parry)[10] = &arr;
   int *(&arrRef)[10] = ptrs;
}

如有疑问，请参阅

parry
是指向10
int
s数组的指针

int *(&arrRef)[10] = ptrs;

arrRef
是对指向int的10个指针数组的引用

例如：

int main()
{
   int arr[10];
   int* ptrs[10];

   int (*parry)[10] = &arr;
   int *(&arrRef)[10] = ptrs;
}

我认为在这份声明中

//line1// int (*parry)[10] = $arr
                            ^^^  ^^

有一个打字错误

一定有

//line1// int (*parry)[10] = &arr;
                            ^^^  ^^

假设
arr
是
int[10]
类型的数组

int arr[10];

decltype( auto )arrRef = ( ptrs );

还有这个宣言

int (*parry)[10] = &arr;

int * (&arrRef)[10] = ptrs;

声明指向整个数组的指针

至于这个声明,

//line2// int *(&arrRef)[10] = ptrs;
                                  ^^^

然后假设
ptrs
是
int*[10]
类型的数组，即数组的元素具有
int*
类型。它们是指针

还有这个宣言

int (*parry)[10] = &arr;

int * (&arrRef)[10] = ptrs;

声明对此数组的引用。引用实际上是数组的别名

<>在C++ 2014中，可以定义对数组的引用更简单。
比如说

int arr[10];

decltype( auto )arrRef = ( ptrs );

这是一个演示程序

#include <iostream>


int main()
{
    int a[10];

    decltype( auto )ra = ( a );

    std::cout << sizeof( a ) << std::endl;
    std::cout << sizeof( ra ) << std::endl;

    ra[0] = 10;

    std::cout << a[0] << std::endl;
    std::cout << ra[0] << std::endl;
}    

我认为在这份声明中

//line1// int (*parry)[10] = $arr
                            ^^^  ^^

有一个打字错误

一定有

//line1// int (*parry)[10] = &arr;
                            ^^^  ^^

假设
arr
是
int[10]
类型的数组

int arr[10];

decltype( auto )arrRef = ( ptrs );

还有这个宣言

int (*parry)[10] = &arr;

int * (&arrRef)[10] = ptrs;

声明指向整个数组的指针

至于这个声明,

//line2// int *(&arrRef)[10] = ptrs;
                                  ^^^

然后假设
ptrs
是
int*[10]
类型的数组，即数组的元素具有
int*
类型。它们是指针

还有这个宣言

int (*parry)[10] = &arr;

int * (&arrRef)[10] = ptrs;

声明对此数组的引用。引用实际上是数组的别名

<>在C++ 2014中，可以定义对数组的引用更简单。
比如说

int arr[10];

decltype( auto )arrRef = ( ptrs );

这是一个演示程序

#include <iostream>


int main()
{
    int a[10];

    decltype( auto )ra = ( a );

    std::cout << sizeof( a ) << std::endl;
    std::cout << sizeof( ra ) << std::endl;

    ra[0] = 10;

    std::cout << a[0] << std::endl;
    std::cout << ra[0] << std::endl;
}    

现在我已经澄清了你的问题，我可以看出这不是我最初的想法。你说：

parray是指向大小为10的整数数组的指针

很明显，你已经知道了顺时针/螺旋线/cdecl

那么这是否意味着：…帕雷[10]点到arr的地址

首先，C++中的数组从零开始索引，因此可以访问<代码> ARR [0 ]…ARR（9）< /C>如果有10个元素；<代码> ARR（10）< /C> >将是第十一，所以超出界限。< /P>
现在，让我们把你的句子拆开：
parray
是一个指针

右，它不是一个数组，它是一个指针。现在，让我们考虑它是指向：
的指针。
大小为10的整数数组

好的，如果它指向那个，那么
*parray
必须是（对）原始数组的引用

因此，
（*parray）[0]
是数组的第一个元素，以此类推

请注意，您可以通过打印出来并查看得到的结果来轻松测试您的直觉。您可以看到指针，并能够比较地址，或者看到整数值，或者得到（希望信息丰富的）编译错误。请尝试

哦，还有：

我什么时候使用第一行

通常，仅当您需要重新安装时才可以。例如，如果您希望根据某些逻辑从两个不同的阵列中选择一个，然后…对所选的阵列执行进一步的逻辑


接下来，你说

arrRef是对大小为10个指针的int数组的引用

对

arrRef由ptrs参考

不，
arrRef
引用数组，数组大小为10，其10个元素为指向int的指针。注意这与第一个数组的类型不同

由于引用可以与它们引用的东西使用相同的语法，因此我们可以使用
arrRef
作为数组

因此，
arrRef[0]
是数组的第一个元素，它是指向int的指针

这可以用在什么例子中

使用数组引用的唯一常见原因是避免指针衰减，允许模板推断元素的数量。
现在我已经澄清了你的问题，我可以看出这不是我最初的想法。你说：

parray是指向大小为10的整数数组的指针

很明显，你已经知道了顺时针/螺旋线/cdecl

那么这是否意味着：…帕雷[10]点到arr的地址

首先，C++中的数组从零开始索引，因此可以访问<代码> ARR [0 ]…ARR（9）< /C>如果有10个元素；<代码> ARR（10）< /C> >将是第十一，所以超出界限。< /P>
现在，让我们把你的句子拆开：
parray
是一个指针

右，它不是一个数组，它是一个指针。现在，让我们考虑它是指向：
的指针。
大小为10的整数数组

好的，如果它指向那个，那么
*parray
必须是（对）原始数组的引用

因此，
（*parray）[0]
是数组的第一个元素，以此类推

请注意，您可以通过打印出来并查看得到的结果来轻松测试您的直觉。您可以看到指针，并能够比较地址，或者看到整数值，或者得到（希望信息丰富的）编译错误。请尝试

哦，还有：

我什么时候使用第一行

通常，仅当您需要重新设置它的位置时。例如，如果您希望根据某些逻辑从两个不同的阵列中选择一个