#include <iostream>
using namespace std;

int* flipArray(int input[], int n)
{
    int output[n];
    int pos = 0;
    for (int i = n-1; i >= 0; i--)
    {
        output[pos++] = input[i];
    }
    int* p = output;
    for (int k = 0; k < n; k++)
        cout << *p-k << endl << endl;
    return p;
}

int main()
{
    const int SIZE = 5;
    int firstArray[SIZE];
    for (int n = 0; n < SIZE; n++)
    {
        firstArray[n] = n+1;
    }
    int* a;
    a = flipArray(firstArray, SIZE);
    for (int j = 0; j < SIZE; j++)
        cout << *a-j << endl;

    cout << endl;
    cout << *a << '\t' << *a+1 << '\t' << *a+2;
    return 0;
}

我正在尝试使用返回指针的函数翻转 firstArray，但我很难理解如何使用指针访问索引。

这就是我困惑的原因: 在函数 flipArray 中，以下 for 循环:

for (int k = 0; k < n; k++)
    cout << *p-k << ' ';

向控制台打印“5 4 3 2 1”。据我了解，我应该使用 *(p+k) 而不是 *(p-k) 来访问 vector 的元素。如果我打印 *(p+k)，“5 6 7 8 9”会打印到控制台。如果我打印没有指针的数组并使用 k 作为索引位置，“5 4 3 2 1”将打印到控制台。

然而，在我的主函数中，从 flipArray 函数分配指针 p 的 *a 的值，我没有得到相同的结果:

for (int j = 0; j < SIZE; j++)
    cout << *a-j << endl;

打印 5 0 -1 -2 -3 到控制台，和

    for (int j = 0; j < SIZE; j++)
    cout << *a+j << endl;

打印 5 2个 3个 4个 5 到控制台。

另外，我认为*p的指针location和*a的location指针应该是一样的!但是当我在函数中打印地址&p时，我得到了0x28fde0的位置，而当我在main中打印&a的地址时，我得到了0x28fedc的位置。当然，这些都是在同一次运行中完成的。

有人能告诉我我哪里误入歧途了吗？谢谢!

感谢大家提供的信息丰富的答案。

我已经更新了我的解决方案，现在它返回了我期望的结果。我有一个关于内存泄漏以及何时需要删除指针的新问题。

int* flipArray(int input[], int n)
{
    int* output = new int[n];
    int pos = 0;
    for (int i = n-1; i >= 0; i--)
        output[pos++] = input[i];
    return output;
}

int main()
{
    const int SIZE = 5;
    int firstArray[SIZE];
    for (int n = 0; n < SIZE; n++)
    {
        firstArray[n] = n+1;
    }
    int* a;
    a = flipArray(firstArray, SIZE);
    for (int j = 0; j < SIZE; j++)
        cout << a[j] << " "; // can also be written as *(a+j), which is more prone to bugs
    delete [] a;
    return 0;
}

函数flipArray返回时指针输出会被删除吗？如果不是，我应该如何在返回输出的同时删除输出？在我的 main 函数中删除指针 a 是否与删除输出相同，因为它们指向相同的位置？

最佳答案

有人指出您的主要问题来自 operator precedence . *p - k 中的 * 运算符在 - 之前求值。这意味着 k 将从 p 指向的 int 值中减去。

这是一个巨大的痛苦，这就是为什么通常使用大括号 pointer[k] 的原因。在某些情况下，使用指针运算 *(pointer + k) 更有意义，但它可能是错误的来源。

这里要注意一点:最好使用括号，即使您不确定是否需要它们。

你还有第二个问题:

在这里，您将堆栈上的 output 声明为局部变量，然后返回 output。当您返回到前一个堆栈帧时，此指针将指向一个已取消分配的缓冲区:

int* flipArray(int input[], int n)
{
    int output[n]; // allocated on the stack
    int pos = 0;
    for (int i = n-1; i >= 0; i--)
    {
        output[pos++] = input[i];
    }
    int* p = output;
    for (int k = 0; k < n; k++)
        cout << *p-k << endl << endl;
    return p; // this stack frame ends.
}

这意味着如果缓冲区正在使用的空间被重新分配，缓冲区的内容可以被覆盖。使用 new 在堆上分配:

int* output = new int[n];

确保在使用完指针后调用delete。

此错误甚至会在您的应用程序中出现安全漏洞，因此请确保您知道 when to allocate on the heap in C++ .

更新:

问题:当这个函数返回时，数组仍然存在于内存中，它的位置保存在指针a中。返回值输出是否删除它？如果不是，当我在 main 函数中使用完指针 a 时删除它是否会达到同样的目的？

当您删除 指针时，指向该指针的内存将被释放，指针将悬空。对已删除指针的引用指向技术上免费的内存，这是不好的。如果分配器库决定要重用该空间，则现在处于空闲空间的缓冲区将被重新分配。这意味着您的缓冲区将失去所有数据完整性，并且其中的数据不可信任。

一种常见的做法是在使用完后将指针分配给 NULL。这样你的程序就会崩溃，你就会知道你的错误在哪里:

int* p = new int[10];
...
delete p;
p = NULL;
...
p[0] = 0; // this will now crash because you are accessing NULL.

关于c++ - 使用指针翻转数组，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29754480/