我使用静态数组，当返回数组时，它不应该抛出错误，因为你正在返回本地变量的地址… 所以现在你可以通过将函数中的任何局部创建的变量设置为静态来发送…因为它作为全局变量....工作

#include<iostream>
using namespace std;

char *func(int n)
{
   // char a[26]; /*if we use this then an error will occur because you are 
                        //  returning address of a local variable*/
    static char a[26];
    char temp='A'; 
    for(int i=0;i<n;i++)
    {
     a[i]=temp;temp++;
    }
    return a;
}
int main()
{
    int n=26;
    char *p=func(n);
    for(int i=0;i<n;i++)
     cout<<*(p+i)<<" ";

   //or you can also print like this
  
    for(int i=0;i<n;i++)
     cout<<p[i]<<" ";    

}

在这种情况下，数组变量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;
}

如上所述的路径是正确的。但我认为如果我们只是返回一个函数的局部数组变量，有时它会返回垃圾值作为它的元素。

为了避免这种情况，我必须动态地创建数组并继续。大概是这样的。

int* func()
{
  int* Arr = new int[100];
  return Arr;
}

int main()
{
  int* ArrResult = func();
  cout << ArrResult[0] << " " << ArrResult[1] << endl;
  return 0;
} 

还有:

int (*func())
{
    int *f = new int[10] {1,2,3};

    return f;
}

int fa[10] = { 0 };
auto func2() -> int (*) [10]
{
    return &fa;
}

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

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