C++ 为什么我的数组双精度函数不起作用？

我尝试创建一个函数，将传入的数组加倍，只有一个for loop，并将int 0添加到每个没有先前值的额外索引中

我发现最后3个元素最终被打印为内存地址

为什么这不起作用？我如何修复它

例如：

int array[] = { 3,5,6 };
int size = 3;
arrayDouble(array,size)
int array[] = { 3,5,6,0,0,0 }; //expected output

int* arrayDouble(int array[], int size)
{
    int *new_array = new int[size * 2]();  // <-- Note the () to value-initialize the memory
    std::copy(array, array + size, new_array); // <-- Use copy to copy over the values to new_array

    // print results
    for (int i = 0; i < size * 2; i++)
        std::cout << new_array[i] << " ";

    return new_array;
} 

---

#包括“pch.h”
#包括
#包括
使用名称空间std；
int*arrayDouble（int数组[]，int大小）；
int main（）
{
int数组[]={3,5,6}；
int size=3；
int*ptrarray=arrayDouble（数组，大小）；
}
int*arrayDouble（int数组[]，int大小）
{
int*new_数组=新int[size*2]；
用于（整数i=1；i（大小*2））
{
新的_数组[i-1]=0；
}
新的_数组[i-1]=数组[i-1]；
}
对于（int i=0；i
for (int i = 1; i <= size * 2; i++)
{
    if (i > (size * 2)) // this never evaluates to true?
    {
        new_array[i - 1] = 0;
    }
    new_array[i - 1] = array[i - 1]; // this always happens

}

for（int i=1；i（size*2））//这永远不会计算为true？
{
新的_数组[i-1]=0；
}
new_array[i-1]=array[i-1]；//这种情况经常发生
}

应该是

for (int i = 0; i < size * 2; i++)
{
    if (i > size)
    {
        new_array[i] = 0;
    }else{
        new_array[i] = array[i];
    }

}

for（int i=0；i大小）
{
新的_数组[i]=0；
}否则{
新_数组[i]=数组[i]；
}
}

此外，如果不管理正在创建的所有阵列，您可能会遇到内存泄漏。
您的for循环不稳定

for (int i = 1; i <= size * 2; i++)
{
    if (i > (size * 2))
    {
        new_array[i - 1] = 0;
    }
    new_array[i - 1] = array[i - 1];
}

for（int i=1；i（大小*2））
{
新的_数组[i-1]=0；
}
新的_数组[i-1]=数组[i-1]；
}

应该是这样的

for (int i = 0; i < size * 2; i++) //easier to understand if you just start with 0
{
    if (i > size) //you don't need to multiply by 2!!
    {
        new_array[i] = 0;
    }
    new_array[i] = array[i];
}

（inti=0；ifor//如果从0开始，更容易理解
{
if（i>size）//不需要乘以2！！
{
新的_数组[i]=0；
}
新_数组[i]=数组[i]；
}

---

这应该可以为您解决问题

其他人已经指出了您的循环存在的问题。但是，如果在使用

new[]

时默认初始化条目，则不需要两个循环

此外，如果使用

std:：copy

将数据从一个数组复制到另一个数组，则甚至不需要任何循环

例如：

int array[] = { 3,5,6 };
int size = 3;
arrayDouble(array,size)
int array[] = { 3,5,6,0,0,0 }; //expected output

int* arrayDouble(int array[], int size)
{
    int *new_array = new int[size * 2]();  // <-- Note the () to value-initialize the memory
    std::copy(array, array + size, new_array); // <-- Use copy to copy over the values to new_array

    // print results
    for (int i = 0; i < size * 2; i++)
        std::cout << new_array[i] << " ";

    return new_array;
} 

---

但是，既然有

std:：vector

已经完成了所有这些工作，而且没有潜在的内存泄漏问题，为什么还要这样做呢

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> array = { 3,5,6 };
    array.resize(array.size() * 2);
    for (auto v : array)
        std::cout << v << " ";
}

#包括
#包括
int main（）
{
向量数组={3,5,6}；
array.resize（array.size（）*2）；
用于（自动v:阵列）
std：：cout我搞砸了。我没看到我放了*2号