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

Posted 2023-02-21

【中文标题】c++ 使用动态分配运算符反转数组元素

【英文标题】：c++ reverse Array elements using dynamic Allocation Operators

【发布时间】：2019-12-13 21:33:51

【问题描述】：

您好，我是 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 ; 

【问题讨论】：

int*ptArray[Size]; 使用 VLA 扩展，因此不是有效的 C++。

您以Size = size of the array 开始循环并循环到Size == 0（包括），这使得size of array +1 总迭代次数。

使用 0 索引，您必须从 0 迭代到 n-1（包括），而对于反向遍历，从 n-1 到 0

不要误以为 c-arrays 是为初学者准备的，std::vector 是高级的，恰恰相反。也使用new 对初学者不太友好

@parktomatomi 可能是这样，但这不会阻止我建议std::vector，因为人们经常被“记忆是如何工作的”而没有被告知在任何其他情况下你会选择不同的解决方案

【参考方案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 

【参考方案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;

【讨论】：

谢谢你，我会尝试使用矢量 :)) 不知道有这么多方法可以解决这个问题 :))

我知道现在问你问题已经很晚了。但是，如果您仍然对我的问题感兴趣，请问您能回答吗？在这个语句中 ->std::reverse(data,data+size);我可以理解为 data ==data[0]，因为指针变量“数据”分配了动态数组吗？对不起，如果这是一个愚蠢的问题。

@HyeJinJang c 数组可以衰减为指向其第一个元素的指针

【参考方案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;

【讨论】：

正如目前所写，您的答案尚不清楚。请edit 添加其他详细信息，以帮助其他人了解这如何解决所提出的问题。你可以找到更多关于如何写好答案的信息in the help center。