C++：传递一个数组和一个指向数组的指针一样吗？ [复制]

Question

起初我猜 k1 的值不会在主空间中。但是后来我意识到一个数组是一个指针，那么有什么区别吗？我认为这是相同的，但也许任何人都可以找到其他一些技术差异。也许更快地传递指针？

#include <iostream>

using namespace std;

void g(double [],int );
void f(double* [],int );

int main()
{

    int n = 10;
    double *k1, *k2;

    k1 = new double[n];
    k2 = new double[n];

    g(k1,n);
    f(&k2,n);

    for(int i = 0;i <n;i++)
    {
        cout << k1[i]<< " ";
        cout << k2[i] << endl;
    }

    delete [] k1;
    delete [] k2;

    return 0;
}


void g(double h[],int n)
{
     for(int i = 0;i <n;i++)
        h[i]=i;
}

void f(double* h[],int n)
{
     for(int i = 0;i <n;i++)
        (*h)[i]=i;
}

Answer 1

首先，数组不是指针。这是一个包含 10 个双精度数的数组：

double a[10];

这是一个指向双精度的指针：

double *p;

这是一个指向 10 个双精度数组的指针：

double (*pa)[10];

这是一个指向双精度的指针数组：

double *pa[10];

数组和指针只有在声明为函数参数时才相同。但是数组可以转换（衰减）为指向数组第一个元素的指针：

double a[10];
double *p = a;
double *q = &a[0]; //same as p

在您的示例代码中：

double *x = new double[10];

您正在创建一个包含 10 个双精度数的动态数组，并获取指向该数组第一个元素的指针。您还可以创建一个新数组并获得一个指向数组的指针：

double (*x)[10] = new double (*)[10];

但是这种奇怪的语法很少有用。

关于函数，这是一个采用双精度数组的函数：

void g1(double h[], int n);

这是一个函数，它带有一个指向 10 个双精度数组的指针：

void g2(double (*h)[10]);

在指向数组的情况下，您需要指定数组的大小，因为您无法创建指向未知大小数组的指针。

这就是为什么数组实际上是作为指针传递给函数的。但是指向数组的第一个成员的指针，而不是指向数组本身的指针。所以第一个函数实际上和这个函数是一样的：

void g1(double *h, int n);

由于您只将指针传递给数组的第一个成员（指向 double 的指针），因此您还需要在附加参数中指定数组的大小。优点是您可以传递任意大小的数组。甚至是数组的拼接：

double x[20];
g1(x + 10, 5); //pass x[10..15]

关于哪个更快，它们都是一样的，它们实际上是指向同一个内存地址的指针。请注意，数组仅在它们是结构的一部分时才通过副本传递，并且结构是按值传递的。

我的建议是：如果您使用 C 坚持惯用的 C，则在必要时使用指向数组第一个成员的指针，并尽可能避免使用指向数组的语法。如果您使用 C++，请使用容器、迭代器和范围。

Answer 2

void f(double* h[],int n)

不接受指向数组的指针。你已经声明它接受一个指针数组。

它起作用的唯一原因是声明为数组的函数参数被默默地转换为指针，因此它相当于：

void f(double** h,int n)

这毕竟是你想要的。

这个（被 g++ 拒绝）代码将使用指向数组的指针：

void f(double (*h)[],int n)

Answer 3

有了这个声明：

void f(double* [],int );

您是说，作为第一个参数，您正在获取指向double 的指针数组。

当您使用(*h) 取消引用该参数（被视为指向指针的指针）时，您实际上获得了数组第一个位置的地址。

Answer 4

即使你按值传递指针，它指向的内存仍然可以被函数更改。

Answer 5

void g(double h[],int n);

从技术上讲，您在该函数中传递了一个指针。

void f(double* h[],int n);

然而，在这一个中，你传递了一个指向数组的指针，它解析为一个指向指针的指针，因为它是一个函数参数*。

*感谢本·沃伊特

Answer 6

许多程序员都有一个关于编译器如何工作的心智模型，其中包括“数组只是一个指针”。这个模型不正确。

 typedef int[10] Array;
 typedef Array * PointerToArray;
 typedef int * Pointer;

 Array a = {0,1,2,3,4,5,6,7,8,9};
 PointerToArray pa;
 Pointer pint = a;   // the compiler casts this automatically to a different type.

此时 pint 和 pa 具有相同的二进制值，但 pa[1] 和 a[1] 不引用内存中的相同位置。了解原因很重要。