实际上，当你在函数中传递一个数组时，指向原始数组的指针被传递到函数形参中，因此对该函数中数组所做的更改实际上是在原始数组上进行的。

#include <iostream>

using namespace std;

int* func(int ar[])
{
    for(int i=0;i<100;i++) 
        ar[i]=i;
    int *ptr=ar;
    return ptr;
}


int main() {
    int *p;
    int y[100]={0};    
    p=func(y);

    for(int i=0;i<100;i++) 
        cout<<i<<" : "<<y[i]<<'\n';
}

运行它，您将看到更改

在c++ 11中，可以返回std::array。

#include <array>
using namespace std;

array<int, 5> fillarr(int arr[])
{
    array<int, 5> arr2;
    for(int i=0; i<5; ++i) {
        arr2[i]=arr[i]*2;
    }
    return arr2;
}

c++函数不能按值返回C风格的数组。最接近的方法是返回一个指针。此外，参数列表中的数组类型被简单地转换为指针。

int *fillarr( int arr[] ) { // arr "decays" to type int *
    return arr;
}

你可以通过对参数和返回使用数组引用来改进它，这可以防止衰减:

int ( &fillarr( int (&arr)[5] ) )[5] { // no decay; argument must be size 5
    return arr;
}

在Boost或c++ 11中，引用传递只是可选的，语法也不那么令人费解:

array< int, 5 > &fillarr( array< int, 5 > &arr ) {
    return arr; // "array" being boost::array or std::array
}

数组模板只是生成一个包含c风格数组的结构，因此可以应用面向对象的语义，同时保留数组原始的简单性。

在这种情况下，数组变量arr实际上也可以通过隐式转换被视为指向内存中数组块开头的指针。你正在使用的语法:

int fillarr(int arr[])

有点像语法糖。你真的可以用这个替换它，它仍然可以工作:

int fillarr(int* arr)

所以在同样的意义上，你想从你的函数返回的实际上是一个指向数组中第一个元素的指针:

int* fillarr(int arr[])

你仍然可以像使用普通数组一样使用它:

int main()
{
  int y[10];
  int *a = fillarr(y);
  cout << a[0] << endl;
}

只需要定义一个类型[]作为返回值，就像:

        private string[] functionReturnValueArray(string one, string two)
    {

        string[] x = {one, two};


        x[0] = "a";
        x[1] = "b";

        return x;
    }

． ． ． 函数调用:

string[] y;
y = functionReturnValueArray(stringOne, stringTwo)

这样的:

int fillarr(int arr[])

实际上与:

int fillarr(int *arr)

如果你真的想返回一个数组你可以把这行改为

int * fillarr(int arr[]){
    // do something to arr
    return arr;
}

它并不是真正返回一个数组。方法的开头返回一个指针 数组的地址。

但是记住，当你传递数组时，你只是传递了一个指针。 当你修改数组数据时，你实际上是在修改数据 指针指向。因此，在传入数组之前，必须意识到 你在外面已经有了修改后的结果。

e.g.

int fillarr(int arr[]){
   array[0] = 10;
   array[1] = 5;
}

int main(int argc, char* argv[]){
   int arr[] = { 1,2,3,4,5 };

   // arr[0] == 1
   // arr[1] == 2 etc
   int result = fillarr(arr);
   // arr[0] == 10
   // arr[1] == 5    
   return 0;
}

我建议你可以考虑在fillarr函数中加入一个长度 这一点。

int * fillarr(int arr[], int length)

这样你就可以使用length来填充数组的长度，不管它是什么。

正确地使用它。你可以这样做:

int * fillarr(int arr[], int length){
   for (int i = 0; i < length; ++i){
      // arr[i] = ? // do what you want to do here
   }
   return arr;
}

// then where you want to use it.
int arr[5];
int *arr2;

arr2 = fillarr(arr, 5);

// at this point, arr & arr2 are basically the same, just slightly
// different types.  You can cast arr to a (char*) and it'll be the same.

如果您只想将数组设置为一些默认值，请考虑使用 内置memset功能。

喜欢的东西: Memset ((int*)&arr, 5, sizeof(int));

当我谈到这个话题的时候。你说你在用c++。看一下如何使用stl向量。您的代码可能会更加健壮。

有很多教程。这里有一个可以告诉你如何使用它们。 http://www.yolinux.com/TUTORIALS/LinuxTutorialC++STL.html