C++ 返回带有指针C++；

我试着做一个函数，把一个数组作为一个参数，使一个新数组变大一个元素，使新数组的下一个元素成为第一个数组的当前元素（数组1{1,2,3,4,5}array to然后变成{0,1,2,3,4,5}），这部分工作得很好，但是函数必须返回指向新数组的指针并显示该数组。我一直在玩指针，我可以让它使用普通的int变量，但不能使用这个数组，它一直显示垃圾。有人知道我做错了什么吗

#include "stdafx.h"
#include <iostream>

using namespace std;

int *newaray(int[], int);

int main()
{
    int *numbers;
    int i;
    int ar1[] = {1,2,3,4,5};

    numbers = newaray(ar1, 5);

    for (i = 0; i <= 5; i++)
    {
        cout << numbers[i] << endl;
    }
    //cout << numbers << endl;

    system("pause");
    return 0;
}

int *newaray ( int array[],int size)
{
    int ar2[] = {0,0,0,0,0,0};
    int i;
    int *ptr;

    ptr = ar2;

    for ( i = 0; i <= size; i ++) 
    {
        ar2[i + 1] = array[i];
    }

    //for (i = 0; i <= size; i++)
    //{
    //  cout << ar2[i] << endl;
    //}
    return ptr;

}

#包括“stdafx.h”
#包括
使用名称空间std；
int*newaray（int[]，int）；
int main（）
{
整数*数字；
int i；
int ar1[]={1,2,3,4,5}；
数字=newaray（ar1，5）；
对于（i=0；i，数组位于堆栈上，一旦函数返回，数组就超出范围。返回的指针无效

在您的上下文（尝试创建新数组）中，您可能需要动态分配数组（并记住在处理完数组后删除它们）
数组位于堆栈上，一旦函数返回，数组将超出范围。您返回的指针无效

在您的上下文中（尝试创建新的数组），您可能需要动态分配数组（并记住在使用完数组后删除它们）
您需要使用动态内存分配，否则，当函数堆栈弹出时，您的数组将消失。当然，请记住在使用完后删除它，这样您就不会泄漏内存

#include <iostream>
#include <string.h>

using namespace std;

int *newaray(int[], int);

int main()
{
    int *numbers;
    int i;
    int ar1[] = {1,2,3,4,5};

    numbers = newaray(ar1, 5);

    for (i = 0; i < 6; i++)
        cout << numbers[i] << endl;

    // Clean up after ourselves.
    delete[] numbers;

    return 0;
}

int *newaray ( int array[],int size)
{
    // Allocate new memory on the heap to store the return value.
    int *ar2 = new int[size + 1];
    memset(ar2, 0, (size +1)*sizeof(int));

    for (int i = 0; i < size; i++) 
        ar2[i + 1] = array[i];

    return ar2;
}

#包括
#包括
使用名称空间std；
int*newaray（int[]，int）；
int main（）
{
整数*数字；
int i；
int ar1[]={1,2,3,4,5}；
数字=newaray（ar1，5）；
对于（i=0；i<6；i++）
cout您需要使用动态内存分配，否则，当函数堆栈弹出时，您的数组将消失。当然，请记住在使用完后删除它，这样您就不会泄漏内存

#include <iostream>
#include <string.h>

using namespace std;

int *newaray(int[], int);

int main()
{
    int *numbers;
    int i;
    int ar1[] = {1,2,3,4,5};

    numbers = newaray(ar1, 5);

    for (i = 0; i < 6; i++)
        cout << numbers[i] << endl;

    // Clean up after ourselves.
    delete[] numbers;

    return 0;
}

int *newaray ( int array[],int size)
{
    // Allocate new memory on the heap to store the return value.
    int *ar2 = new int[size + 1];
    memset(ar2, 0, (size +1)*sizeof(int));

    for (int i = 0; i < size; i++) 
        ar2[i + 1] = array[i];

    return ar2;
}

#包括
#包括
使用名称空间std；
int*newaray（int[]，int）；
int main（）
{
整数*数字；
int i；
int ar1[]={1,2,3,4,5}；
数字=newaray（ar1，5）；
对于（i=0；i<6；i++）
cout您必须使用new操作符动态分配数组

请参阅下面的代码

int *newaray ( int array[], int size)
{
    int i;
    int *ar2=new int[size+1]; // note size+1
    ar2[0]=0;

    for ( i = 0; i < size; i ++) // no equal to operator
    {
        ar2[i + 1] = array[i];
    }

    return ar2;

}

您必须使用new操作符动态分配数组

请参阅下面的代码

int *newaray ( int array[], int size)
{
    int i;
    int *ar2=new int[size+1]; // note size+1
    ar2[0]=0;

    for ( i = 0; i < size; i ++) // no equal to operator
    {
        ar2[i + 1] = array[i];
    }

    return ar2;

}

从函数返回时，返回一个指向被删除数组的指针。
main
中的指针指向已删除的内存，因此您会看到垃圾。您需要从堆中分配内存，并返回一个从堆中分配内存的指针

int *newaray ( int array[],int size)
{
   int* ptr = new int[size+1];
   for ( int i = 0; i <= size; i ++) 
   {
       ptr[i + 1] = array[i];
   }
   return ptr;
}

从函数返回时，返回一个指向被删除数组的指针。
main
中的指针指向已删除的内存，因此您会看到垃圾。您需要从堆中分配内存，并返回一个从堆中分配内存的指针

int *newaray ( int array[],int size)
{
   int* ptr = new int[size+1];
   for ( int i = 0; i <= size; i ++) 
   {
       ptr[i + 1] = array[i];
   }
   return ptr;
}

函数返回
int*
是不好的风格。这是因为它让调用方有责任担心内存管理

最好把数组放在一个管理自己内存的容器中。幸运的是，在标准C++中有很多这样的容器，最简单的是 STD:：vector < /Cord>。它可以保存一个可变大小的数组。（还有代码> STD:：数组< /COD>，但是只有在编译时知道大小）才行。
此代码几乎等同于其他海报所建议的“隐藏”代码，只是在此版本中，您不必担心内存管理及其相关问题。
函数返回
int*
是一种不好的风格。这是因为它让调用者有责任担心内存管理

最好把数组放在一个管理自己内存的容器中。幸运的是，在标准C++中有很多这样的容器，最简单的是 STD:：vector < /Cord>。它可以保存一个可变大小的数组。（还有代码> STD:：数组< /COD>，但是只有在编译时知道大小）才行。
这个代码几乎等同于“引擎盖下”，而不是其他海报所建议的，只是在这个版本中，你不必担心内存管理和它的相关问题。
 < P>这是一个使用更多C++概念的奖励版本（需要C++ 11）在我看来，这种任务比复杂的输入解析更适合学习语言

#include <vector>
#include <iostream>

template<typename T, size_t size> 
std::vector<T> new_array(T (&array)[size] )
{
    std::vector<T> vec( array, array + size );
    vec.insert( vec.begin(), T() );
    return vec;
}

int main()
{
    int ar1[] = { 1, 2, 3, 4, 5 };

    auto numbers = new_array(ar1);

    for ( auto num : numbers )
        std::cout << num << std::endl;
}

#包括
#包括
样板
std:：vector新数组（T（&array）[size]）
{
std：：向量向量向量（数组，数组+大小）；
向量插入（向量开始（），T（））；
返回向量；
}
int main（）
{
int ar1[]={1,2,3,4,5}；
自动编号=新的_数组（ar1）；
用于（自动编号：数字）
STD：：CUT< P>这里是一个使用更多C++概念（需要C++ 11）的奖励版本。IMO这种任务比学习棘手的输入分析更好地学习语言。
#include <vector>
#include <iostream>

template<typename T, size_t size> 
std::vector<T> new_array(T (&array)[size] )
{
    std::vector<T> vec( array, array + size );
    vec.insert( vec.begin(), T() );
    return vec;
}

int main()
{
    int ar1[] = { 1, 2, 3, 4, 5 };

    auto numbers = new_array(ar1);

    for ( auto num : numbers )
        std::cout << num << std::endl;
}

#包括
#包括
样板
std:：vector新数组（T（&array）[size]）
{
std：：向量向量向量（数组，数组+大小）；
向量插入（向量开始（），T（））；
返回向量；
}
int main（）
{
int ar1[]={1,2,3,4,5}；
自动编号=新的_数组（ar1）；
用于（自动编号：数字）
std:：难道这只会为分配的第一个整数释放空间，而不是整个数组。@RikayanBandyopadhyay，谢谢。修复了。我太习惯了
malloc
，以至于我总是忘记这个差异（已删除下一票。由于这是公认的答案，您应该修复
数组
越界。在现有版本中，
i这只为分配的第一个整数释放空间，而不是整个数组。@RikayanBandyopadhyay，谢谢。已修复。我太习惯
malloc
了，以至于我总是忘记这一差异。：（已删除下一票。由于这是公认的答案，您应该修复
数组
越界问题。在现有版本中，
可能重复