8.3.5/8州-

函数的返回类型不应该是数组或函数，尽管它们可以有类型指针或引用的返回类型。不应该有函数数组，尽管可以有指向函数的指针数组。”

int (&fn1(int (&arr)[5]))[5]{     // declare fn1 as returning refernce to array
   return arr;
}

int *fn2(int arr[]){              // declare fn2 as returning pointer to array
   return arr;
}


int main(){
   int buf[5];
   fn1(buf);
   fn2(buf);
}

为了从函数返回一个数组，让我们在结构中定义该数组; 它看起来是这样的

struct Marks{
   int list[5];
}

现在让我们创建类型结构的变量。

typedef struct Marks marks;
marks marks_list;

我们可以通过以下方式将array传递给一个函数并为其赋值:

void setMarks(int marks_array[]){
   for(int i=0;i<sizeof(marks_array)/sizeof(int);i++)
       marks_list.list[i]=marks_array[i];
}

我们也可以返回数组。要返回数组，函数的返回类型应该是结构类型即标记。这是因为在现实中，我们传递的是包含数组的结构。最终的代码可能是这样的。

marks getMarks(){
 return marks_list;
}

为什么不把数组作为参数“返回”呢?

fillarr(int source[], size_t dimSource, int dest[], size_t dimDest)
{

    if (dimSource <= dimDest)
    {
        for (size_t i = 0; i < dimSource; i++)
        {   
            //some stuff...
        }
    }
    else 
    {
        //some stuff..
    }
}

或者用更简单的方式(但你必须知道尺寸…):

fillarr(int source[], int dest[])
{
    //...
}

这里有一个完整的例子来解决这类问题

#include <bits/stdc++.h>
using namespace std;
int* solve(int brr[],int n)
{
sort(brr,brr+n);
return brr;
}

int main()
{
int n;
cin>>n;
int arr[n];
for(int i=0;i<n;i++)
{
    cin>>arr[i];
}
int *a=solve(arr,n);
for(int i=0;i<n;i++)
{
    cout<<a[i]<<endl;
}

return 0;
}

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风格数组的结构，因此可以应用面向对象的语义，同时保留数组原始的简单性。

这样的:

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