如何将数组设置为新数组？

Question

我需要实现一个修改数组的函数。新阵列可能是不同的大小。 cout打印1.我明白这个代码有什么问题，但我无法弄清楚语法是什么。

//tried this.. 
int reduce(int *array[]) 
{ 
    *array = new int[1]; 
    (*array)[0] = 6; 
    return 0; 
} 

//also tried this.. 
int reduce(int array[]) 
{ 
    array = new int [1]; 
    array[0] = 6; 
    return 0; 
}  

int main() 
{ 
    int a[1] = {1}; 
    int *p = a; 

    reduce(&p); 
    cout << a[0]; 

    return 0; 
} 

Answer 1

修改：

你想修改数组，试试这个：

int reduce(int **array) 
{ 
    *array = new int[1]; 
    (*array)[0] = 6; 
    return 0; 
} 


int main() 
{ 
    int *a = new int[1]; 
    reduce(&a); 
    cout << a[0]; 

    return 0; 
} 

Answer 2

不正确地理解你的问题，但是这是你可以做什么：

void reduce(int *a, int size) 
{ 
    for (int i =0; i < size; ++i) { 
     *(a+i) = 6; // or whatever value to want to 
    } 
} 

这样称呼：

int main(){ 
    int a[5] = {1, 1, 1, 1, 1}; 
    int *p = a; 

    reduce(p, 5); 
    for (int i =0; i < 5; ++i) { cout << a[i]<<endl; } 
    return 0; 
} 

编辑

什么你正在尝试做的，可以隐约做到这样：

int * reduce (int **b, int size) { 
    *b = new int[size]; 
    for (int i =0; i < size; ++i) { 
     *(*b + i) = 6; 
    } 
    return *b; 
} 


int main(){ 
    int a[5] = {1, 1, 1, 1, 1}; 
    int *p = a; 

    p = reduce(&p, 5); 
    cout << p[0]; 
    cout << p[1]; 
    cout << p[2]; 
    cout << p[3]; 
    cout << p[4]; 

    delete [] p; 

    return 0; 
} 

但它仍然不会改变其中a指向。

Answer 3

你想要做的是静态定义的数组是不可能的。

当你使用像

int a[1] = {1}; 

一个数组，你不能在运行时更改数组的大小，你不能让它指向动态分配的内存。您只能访问和修改阵列的元素。而已。

功能reduce更改，其中p指向但它不会更改a的元素。

如果您想修改a的内容，您可以简单地使用a作为参数，并设置值。

Answer 4

首先，形式参数int* array[]实际上与int** array（你可以把它想象成一个二维数组）相同。这可能不是你想要的。

@everettjf的答案只有在你做的时候才会起作用不是改变数组的大小。一种可能的解决方案（即完全替换阵列）将是

#include <iostream> 
void print_array(int[],int); 

int* reduce(int array[]) { 
    // get rid of the old array 
    delete[] array; 

    // create a new one 
    array = new int[7]{8,4,6,19,3,56,23}; 

    // need to return the new address, so that 
    // the main function is informed on the new 
    // address 
    return array; 
} 

int main() { 
    // initialize array 
    int *a = new int[1]{4}; 

    print_array(a,1); 

    // "change" array by completely replacing it 
    a=reduce(a); 

    print_array(a,7); 

    return 0; 
} 

// simply prints out the array; no error checking! 
void print_array(int array[], int length) { 
    std::cout << "["; 
    for (int i = 0; i < length ; ++i) { 
     std::cout << array[i] << " "; 
    } 
    std::cout << "]" << std::endl; 
} 

在reduce功能，初始阵列被完全删除。之后，你可以创建一个新的（我选择只使用7个随机数）。将该指针返回给调用方（方法main）非常重要。否则，a指针的主要方法将指向无效

如果不强制（通过某种锻炼; Tibial，例如）使用数组，你应该看看http://en.cppreference.com/w/cpp/container/vector

Answer 5

你的问题的前提是无效。在通过标准C++中的ANY方法定义之后，不可能调整自动存储持续时间的数组大小（a，即main()）。

您的reduce()函数中的动态内存分配不会导致调整main()中的a的大小。

reduce(&p)意愿调用的reduce()的第一个版本，那么这将改变p（所以它指向的动态分配的内存），但不影响a。

如果main()调用reduce(a)或reduce(p)（，二者是等效的给定的初始化int *p = a）将改变既不a也不p，而是会导致内存泄漏。

潜在的问题，我怀疑是，你相信 - 不正确 - 指针和数组是相同的东西。它们实际上是不同的东西，但可以在各种情况下以相同的方式使用。而你的代码是其中不能互换使用的上下文之一。

如果你想要一个可调整大小的数组，可以使用一个静态容器（如std::vector<int>）和 - 如果你想让一个函数调整它的大小，可以通过引用来传递它。它动态管理自己的内存，所以能够动态调整自己的大小。