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

#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';
}

运行它，您将看到更改

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

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;
}

在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;
}

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

#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;
}

一个简单而详细的例子，如果我忘记了概念，需要帮助，我可以参考这里。

#include <iostream>
using namespace std;
int *ReturnArray(int arr[], int size)
{
    static int MinMax[2] = {0, 0}; // must use static, else address would be deleted after the return is reached
    MinMax[0] = arr[0];
    MinMax[1] = arr[size - 1];
    return MinMax;
}
int main()

{
    int arr[] = {1, 2, 3};
    int size = sizeof(arr) / sizeof(*arr);
    int *ans;                     // pointer to hold returned array
    ans = ReturnArray(arr, size); // only pointer can receive the return, not an array
    cout << "Min: " << ans[0] << " Max: " << ans[1];
    return 0;
}

最简单的方法是通过引用返回，即使你不写 符号“&”，它通过引用自动返回

     void fillarr(int arr[5])
  {
       for(...);

  }