Question

我正在自学C ++并且对数组和指针有一些疑问。我的理解是数组实际上只是指针，但是，数组是地址常量，无法更改。

如果是这种情况，我想知道为什么在我的函数show2()中我能够更改指针list的地址。与变量不同，我认为数组是通过引用传递的，所以我在调用函数show2()时期望编译器错误，因为我增加了list的地址。但代码工作得很好。有人可以解释一下吗？

谢谢！

#include<iostream>
#include<iomanip>

using namespace std;

void show1(double *list, int SIZE)
{
    for(int i=0; i < SIZE; i++)
    {
        cout << setw(5) << *(list+i);
    }
    cout << endl;
    return;
}

void show2(double *list, int SIZE)
{
    double *ptr = list;

    for(int i=0; i < SIZE; i++)
        cout << setw(5) << *list++;
    cout << endl;
    return;
}

int main()
{
    double rates[] = {6.5, 7.2, 7.5,  8.3, 8.6, 
                      9.4, 9.6, 9.8, 10.0};
    const int SIZE = sizeof(rates) / sizeof(double);

    show1(rates, SIZE);
    show2(rates, SIZE);    
    return 0;
}

Answer 1

我的理解是数组实际上只是指针

让我们解决这个问题。不，数组不是指针。数组是一系列对象，都是相同的类型，在内存中是连续的。

数组可以通过引用传递，但这不是通常所做的。通常做的是你正在做的事情，就是将指针传递给数组的第一个元素。根据需要，数组可以并且将“衰减”到指向其第一个元素的指针。当您将rates传递给show1和show2时，就会发生这种情况。

在show1和show2内，list开头是指向rates[0]的指针。您可以自由修改此指针以指向任何其他double。

如果您想通过引用传递数组，它将如下所示：

void show3(double (&list)[9]) { ... }

或更多才多艺：

template<size_t SIZE>
void show3(double (&list)[SIZE]) { ... }

请注意，无法执行的操作是按值传递数组（除非它包含在另一个对象中）。如果您编写的函数看起来像是按值获取数组，例如

void show4(double list[9]) { ... }

它实际上是一个指针，而数字9是没有意义的。本机阵列很糟糕。

Answer 2

首先，当作为函数参数传递时，数组被转换为指向第一个元素的指针。顺便说一句，数组不是指针，例如，代码中的sizeof(rates)不是指针的大小。

其次，数组是按值传递的，因为你没有使用引用。

所以在函数show2中，你正在修改一个指针，这很好。

Answer 3

数组不是指针。 C ++从C继承了“Array-Pointer Equivalence”，这意味着一个众所周知的数组变量可以衰减到指针，主要用于偏移数学和避免按值传递数组： / p>

int array[64];
int* a = array; // equivalent to a = &array[0];

数组不是指针。如果在指针上下文中使用数组变量名，它将“衰减”到指针 - 也就是说，丢失了数组对象可用的扩展属性。

int array[64];
int* a = array;
std::cout << "array size = " << sizeof(array) << "\n";
std::cout <<  "a size = " << sizeof(a) << "\n";
std::cout << "(int*)(array) size = " << sizeof((int*)array)) << "\n";

“数组大小”将为256（int为4个字节，其中64个= 256个字节），“大小”将为4或8个字节，具体取决于32/64位，以及“（int *）（array） “大小与指针的大小相同。

人们通常认为数组是按值传递的。事实并非如此：http://ideone.com/hAeH18

#include <iostream>

void bump(int arr[3]) {
    for (size_t i = 0; i < 3; ++i)
        arr[i]++;
}

int main() {
    int array[] = { 1, 2, 3 };
    bump(array);
    for (size_t i = 0; i < 3; ++i)
        std::cout << array[i] << "\n";

    return 0;
}

这输出“2,3,4”而不是“1,2,3”。

这是因为当作为函数参数传递时，数组会衰减为指针。但是为了支持接收数组作为数组的语法，C必须能够在某些上下文中处理像数组这样的指针：

void f1(int* a) { a[0]++; }

void f2(int* a) { (*a)++; }

void f3(int a[]) { a[0]++; }

void f4(int a[]) { (*a)++; }

void f5(int a[1]) { a[0]++; }

void f6(int a[1]) { (*a)++; }

所有这些函数都生成相同的代码。

在C中，这源于数组信息在编译时丢失的事实。所以这个功能：

void f(int array[])

无法判断它接收的数组有多大。他们希望程序员能够意识到这一点，并注意他们如何/如果他们传递大小信息 - 例如在char数组的情况下，我们有nul终结符字节而不是size。

不幸的是，他们没有选择通过使表示看起来像是在接收一个大小信息完整的数组而使其变得明显：（

数组作为函数中的地址常量

3 个答案: