C++ 交换数组指针 #包括 #包括 使用名称空间std； 无效交换（int*q，int*p） { 内部温度； 温度=*q； *q=*p； *p=温度； } 无效反向（整数*ip，整数常量大小） { 对于（int k=0；k

当您执行以下操作时，您正在

reverse（）

中访问数组边界之外的内容：

    #include <iostream>
    #include <cstdlib>

    using namespace std;

    void swapNum(int *q, int *p)
    {
        int temp;
        temp = *q;
        *q = *p;
        *p = temp;
    }

    void reverse(int *ip, int const size)
    {
        for (int k = 0; k < size; k++)
        {
            if (k == (size/2))
            {
                int *q = &ip[k];
                int *p = &ip[k+1];
                swapNum(q,p);
                break;
            }
            else
                swap(ip[k], ip[size-k]);
        }
    }

    int main()
    {
        const int size = 20;
        int arr[size];
        int *ip;
        ip = arr;

        cout << "Please enter 20 different numbers." << endl;

        for (int i = 0; i < size; i++)
        {
            cout << "\nNumber " << i+1 << " = ";
            cin >> ip[i];
        }

        reverse(ip, size);

        cout << "I will now print out the numbers in reverse order." << endl;

        for (int j = 0; j < size; j++)
        {
            cout << ip[j] << " ";
        }

        return 0;
    }

在

for

循环的第一次迭代中，

k

是

0

，

size-k

是

size

。但是数组索引从

0

运行到

size-1

。因此它应该是：

swap(ip[k], ip[size-k]);

但我在您的程序中没有看到

交换的定义。我认为它实际上应该是：

swap(ip[k], ip[size-k-1]);

另一个改进：不需要专门处理
size==k/2
和使用
break
，只需在
for
循环中使用
size
作为绑定测试。
在
reverse（）
中访问数组边界之外的内容时：

    #include <iostream>
    #include <cstdlib>

    using namespace std;

    void swapNum(int *q, int *p)
    {
        int temp;
        temp = *q;
        *q = *p;
        *p = temp;
    }

    void reverse(int *ip, int const size)
    {
        for (int k = 0; k < size; k++)
        {
            if (k == (size/2))
            {
                int *q = &ip[k];
                int *p = &ip[k+1];
                swapNum(q,p);
                break;
            }
            else
                swap(ip[k], ip[size-k]);
        }
    }

    int main()
    {
        const int size = 20;
        int arr[size];
        int *ip;
        ip = arr;

        cout << "Please enter 20 different numbers." << endl;

        for (int i = 0; i < size; i++)
        {
            cout << "\nNumber " << i+1 << " = ";
            cin >> ip[i];
        }

        reverse(ip, size);

        cout << "I will now print out the numbers in reverse order." << endl;

        for (int j = 0; j < size; j++)
        {
            cout << ip[j] << " ";
        }

        return 0;
    }

swapNum(&ip[k], &ip[size-k-1]);

在
for
循环的第一次迭代中，
k
是
0
，
size-k
是
size
。但是数组索引从
0
运行到
size-1
。因此它应该是：

swap(ip[k], ip[size-k]);

但我在您的程序中没有看到
交换的定义。我认为它实际上应该是：

swap(ip[k], ip[size-k-1]);

另一个改进：不需要专门处理
size==k/2
和使用
break
，只需在
for
循环中使用
size
作为绑定测试。
在
reverse（）
中访问数组边界之外的内容时：

    #include <iostream>
    #include <cstdlib>

    using namespace std;

    void swapNum(int *q, int *p)
    {
        int temp;
        temp = *q;
        *q = *p;
        *p = temp;
    }

    void reverse(int *ip, int const size)
    {
        for (int k = 0; k < size; k++)
        {
            if (k == (size/2))
            {
                int *q = &ip[k];
                int *p = &ip[k+1];
                swapNum(q,p);
                break;
            }
            else
                swap(ip[k], ip[size-k]);
        }
    }

    int main()
    {
        const int size = 20;
        int arr[size];
        int *ip;
        ip = arr;

        cout << "Please enter 20 different numbers." << endl;

        for (int i = 0; i < size; i++)
        {
            cout << "\nNumber " << i+1 << " = ";
            cin >> ip[i];
        }

        reverse(ip, size);

        cout << "I will now print out the numbers in reverse order." << endl;

        for (int j = 0; j < size; j++)
        {
            cout << ip[j] << " ";
        }

        return 0;
    }

swapNum(&ip[k], &ip[size-k-1]);

在
for
循环的第一次迭代中，
k
是
0
，
size-k
是
size
。但是数组索引从
0
运行到
size-1
。因此它应该是：

swap(ip[k], ip[size-k]);

但我在您的程序中没有看到
交换的定义。我认为它实际上应该是：

swap(ip[k], ip[size-k-1]);

另一个改进：不需要专门处理
size==k/2
和使用
break
，只需在
for
循环中使用
size
作为绑定测试。
在
reverse（）
中访问数组边界之外的内容时：

    #include <iostream>
    #include <cstdlib>

    using namespace std;

    void swapNum(int *q, int *p)
    {
        int temp;
        temp = *q;
        *q = *p;
        *p = temp;
    }

    void reverse(int *ip, int const size)
    {
        for (int k = 0; k < size; k++)
        {
            if (k == (size/2))
            {
                int *q = &ip[k];
                int *p = &ip[k+1];
                swapNum(q,p);
                break;
            }
            else
                swap(ip[k], ip[size-k]);
        }
    }

    int main()
    {
        const int size = 20;
        int arr[size];
        int *ip;
        ip = arr;

        cout << "Please enter 20 different numbers." << endl;

        for (int i = 0; i < size; i++)
        {
            cout << "\nNumber " << i+1 << " = ";
            cin >> ip[i];
        }

        reverse(ip, size);

        cout << "I will now print out the numbers in reverse order." << endl;

        for (int j = 0; j < size; j++)
        {
            cout << ip[j] << " ";
        }

        return 0;
    }

swapNum(&ip[k], &ip[size-k-1]);

在
for
循环的第一次迭代中，
k
是
0
，
size-k
是
size
。但是数组索引从
0
运行到
size-1
。因此它应该是：

swap(ip[k], ip[size-k]);

但我在您的程序中没有看到
交换的定义。我认为它实际上应该是：

swap(ip[k], ip[size-k-1]);

另一个改进：不需要专门处理
size==k/2
和使用
break
，只需使用
size
作为
for
循环的绑定测试

swapNum(&ip[k], &ip[size-k-1]);

您的问题就在这里。
size-k
当
k
为0时，将导致未定义的行为（访问数组超出范围）。可以简化
反向中的循环结构：

swap(ip[k], ip[size-k]);

for（int k=0；k

您的问题就在这里。
size-k
当
k
为0时，将导致未定义的行为（访问数组超出范围）。可以简化
反向中的循环结构：

swap(ip[k], ip[size-k]);

for（int k=0；k

您的问题就在这里。
size-k
当
k
为0时，将导致未定义的行为（访问数组超出范围）。可以简化
反向中的循环结构：

swap(ip[k], ip[size-k]);

for（int k=0；k

您的问题就在这里。
size-k
当
k
为0时，将导致未定义的行为（访问数组超出范围）。可以简化
反向中的循环结构：

swap(ip[k], ip[size-k]);

for（int k=0；k
功能反转无效

for (int k = 0; k < size / 2; k++)
    swapNum(&ip[k], &ip[size - k - 1]); // updated to use the address since your swap function takes pointers.

            swap(ip[0], ip[size]);

但是，该数组没有索引大小的元素

您还可以使用两个函数
std:：swap
和
swapNum

此代码段也无效

for (int k = 0; k < size / 2; k++)
    swapNum(&ip[k], &ip[size - k - 1]); // updated to use the address since your swap function takes pointers.

            swap(ip[0], ip[size]);

当代码中的大小为偶数（或奇数）时，则进行不正确的交换。例如，如果大小等于20，则应将ip[9]与ip[10]交换。但是，根据上面的代码片段，将ip[10]与ip[11]交换

您可以使用标准算法
std:：reverse

比如说

        if (k == (size/2))
        {
            int *q = &ip[k];
            int *p = &ip[k+1];
            swapNum(q,p);
            break;
        }

#包括
#包括
//...
标准：：反向（标准：：开始（arr），标准：：结束（arr））；

或

#包括
//...
标准：：反向（arr，arr+大小）；

如果您想自己编写函数，那么它可以如下所示

#include <algorithm>

//...

std::reverse( arr, arr + size );

void reverse（int a[]，int size）
{
对于（int k=0；k

或者如果您想使用swapNum函数

void reverse( int a[], int size )
{
    for (int k = 0; k < size / 2; k++)
    {
        int tmp = a[k];
        a[k] = a[size-k-1];
        a[size-k-1] = tmp; 
    }
}

void reverse（int a[]，int size）
{
对于（int k=0；k

编辑：我从第一个输入错误的参数中删除了限定符const。
函数反转无效

for (int k = 0; k < size / 2; k++)
    swapNum(&ip[k], &ip[size - k - 1]); // updated to use the address since your swap function takes pointers.

            swap(ip[0], ip[size]);

但是，该数组没有索引大小的元素

您还可以使用两个函数
std:：swap
和
swapNu