使用指针翻转数组

时间:2015-04-20 17:29:05

标签: c++ c arrays pointers

#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 << ' ';

打印&#34; 5 4 3 2 1&#34;到控制台。我的理解是,我应该使用*(p+k)访问向量的元素,而不是*(p-k)。如果我打印*(p+k),&#34; 5 6 7 8 9&#34;打印到控制台。如果我打印没有指针的数组并使用k作为索引位置,&#34; 5 4 3 2 1&#34;打印到控制台。

在我的main函数中,* a的值是从flipArray函数赋值指针p,我得不到相同的结果:

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的位置,当我在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与删除输出相同,因为它们指向同一位置?

3 个答案:

答案 0 :(得分:4)

有人指出,你的主要问题来自operator precedence*中的*p - k运算符在-之前进行评估。这意味着将从p所指向的int的值中减去k。

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

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


你确实有第二个问题:

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

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会起到同样的作用吗?

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

通常的做法是在完成使用后指定NULL指针。这样你的程序就会崩溃,你就会知道你的bug在哪里:

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

答案 1 :(得分:3)

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

我的理解是我应该使用*(p + k)访问向量的元素,而不是*(p-k)。

您的理解是正确的。您不会在此处访问数组。p指向第一个元素5,每次从中减去k,这会为您提供5-0 {{ 1}} 5-1等等等于filpped array.So如果你想使用指针访问数组

5-2

答案 2 :(得分:2)

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

这段代码的作用与你的想法完全不同。

*p - k将像

一样处理
*p = 5 - 0 = 5
*p = 5 - 1 = 4

等不是*(p+k)*(p-k)

为了您的理解:

int a[5] = { 1,2,6,4,5};

为了访问数组中的第3个元素,你可以

a[2] = *(a+2)

而不是

*a + 2

*(a + 2) = 6*a + 2 = 1 + 2 = 3

注意不要将指针返回到将导致未定义行为的局部变量