c++ 使用动态分配运算符反转数组元素

Question

您好，我是 C++ 的初学者。 这一次，我尝试使用动态分配运算符来反转 Array 的元素顺序。 例如数组{1,2,3,4}将通过调用函数'reverseArray'重新排列{4,3,2,1}。 一切正常，但不知何故我得到了不需要的整数“-1”以及重新排列的数组。 例如 {-1,4,3,2,1}。 这意味着我做错了，我真的想知道我的错。 这是我的代码，请帮我弄清楚。

#include<iostream>
#include<new>

using namespace std;

void reverseArray(int [] , int);

int main(){

    int num=0;

    cout << "enter size of pointer : " ;
    cin >> num ;

    int *pointerArray = new int [num];

    cout << "enter integer numbers in pointer" << endl;

    for(int index = 0 ; index < num ; index++){
        cin >> pointerArray[index];     
    }

    reverseArray(pointerArray, num);

delete[] pointerArray;
    return 0 ; 
}

void reverseArray(int reverse[], int Size){
    int*ptArray[Size]; 

    cout << "the reverse order of entered numbers is : " << endl;
    for(int index = 0 ; Size >= 0 ; index++) {
        ptArray[index] = &reverse[Size];
        cout << *ptArray[index] << " " ;
        --Size; 
    }

    return ; 
}

Answer 1

这个函数

void reverseArray(int reverse[], int Size){
    int*ptArray[Size]; 

    cout << "the reverse order of entered numbers is : " << endl;
    for(int index = 0 ; Size >= 0 ; index++) {
        ptArray[index] = &reverse[Size];
        cout << *ptArray[index] << " " ;
        --Size; 
    }

    return ; 
}

没有意义。

对于初学者可变长度数组

    int*ptArray[Size]; 

不是标准的 C++ 功能。

第二次在这个循环中

    for(int index = 0 ; Size >= 0 ; index++) {
        ptArray[index] = &reverse[Size];
        cout << *ptArray[index] << " " ;
        --Size; 
    }

数组之外还有访问权限。

例如，假设Size 等于1。 在这种情况下，在 , 循环中我们有

ptArray[0] = &reverse[1];

然后

ptArray[1] = &reverse[0];

但是，此类数组的唯一有效索引是 0。

不清楚你要做什么。

如果你想反转一个数组，那么函数看起来像

void reverseArray( int a[], size_t Size )
{
    for ( size_t i = 0; i < Size / 2; i++ )
    {
        // you can use the standard function std::swap here
        int tmp = a[i];
        a[i] = a[Size - i - 1];
        a[Size - i - 1] = tmp;
    }
}

在main中调用函数后可以输出反转数组。

注意有标准算法 std::reverse 可以做 rask。

你可以写

std::reverse( reverse, reverse + num );

这是一个演示程序。

#include <iostream>
#include <algorithm>

void reverseArray( int a[], size_t Size )
{
    for ( size_t i = 0; i < Size / 2; i++ )
    {
        // you can use the standard function std::swap here
        int tmp = a[i];
        a[i] = a[Size - i - 1];
        a[Size - i - 1] = tmp;
    }
}

int main() 
{
    const size_t N = 5;
    int *a = new int[5] { 1, 2, 3, 4, 5 };

    for ( size_t i = 0; i < N; i++ ) std::cout << a[i] << ' ';
    std::cout << '\n';

    reverseArray( a, N );

    for ( size_t i = 0; i < N; i++ ) std::cout << a[i] << ' ';
    std::cout << '\n';

    std::reverse( a, a + N );

    for ( size_t i = 0; i < N; i++ ) std::cout << a[i] << ' ';
    std::cout << '\n';

    delete [] a;

    return 0;
}

它的输出是

1 2 3 4 5 
5 4 3 2 1 
1 2 3 4 5 

Answer 2

在您的代码中，您会在第一次迭代时越界访问数组，因为对于大小为 Size 的数组，有效索引为 0 到 Size-1

不清楚为什么要创建一个指针数组，而int*ptArray[Size]; 是一个非标准 C++ 的可变长度数组 (VLA)。此外，您不需要包含<new>。

要打印动态大小（即大小取自输入）数组，您可以使用std::vector 和循环：

#include <vector>
#include <iostream>

int main(){   
    size_t size;
    std::cout << "enter size: ";
    std::cin >> size;
    std::vector<int> data(size);
    for (auto& element : data) std::cin >> element;
    for (size_t i = 0; i < data.size(); ++i) {
        std::cout << data[ data.size()-1-i ]; // first element printed is data[data.size()-1]
    }    
}

如果要反转数组，而不仅仅是以相反的顺序打印，<algorithm> 中有std::reverse。该算法也适用于动态分配的数组：

#include <iostream>
#include <algorithm>

int main(){   
    size_t size;
    std::cout << "enter size: ";
    std::cin >> size;

    int* data = new int[size];
    for (size_t i=0; i<size; ++i) std::cin >> data[i];

    std::reverse(data,data+size);
    for (size_t i=0; i<size; ++i) std::cout << data[i];

    delete [] data;
}

Answer 3

#包括 使用命名空间标准；

int main() {

int n;
cin>>n;
int temp=n;

int rem=0;
int i=0;


while (n>0) {



    n= n/10;
    i++;

}

int *arr = new int(i);

i=0;

while (temp>0) {

    rem=temp%10;
    arr[i]=rem;


    i++;

    temp= temp/10;



}
int t=0;

while(t<i) {
    cout<<arr[t]<<" ";
    t++;
}


return 0;

}