使用指针翻转数组

Question

#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).如果我打印*(p+k),"5 6 7 8 9"将打印到控制台.如果我在没有指针的情况下打印数组并使用k作为索引位置,则会在控制台上打印"5 4 3 2 1".

然而,在我的main函数中,从flipArray函数赋值指针的*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和位置的指针*a应该是一样的!但是当我&p在函数中打印地址时,我得到0x28fde0的位置,当我打印主要的地址时&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与删除输出相同,因为它们指向同一位置？

Answer 1

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

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在使用完指针后调用它。

此错误甚至可能会在您的应用程序中带来安全漏洞，因此请确保您知道何时在 C++ 堆上进行分配。

更新：

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

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

NULL常见的做法是在使用完毕后分配指针。这样你的程序就会崩溃，你就会知道你的bug在哪里：

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