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

答案可能取决于您计划如何使用该函数。对于最简单的答案，让我们确定您真正需要的不是数组，而是一个向量。向量很好，因为它看起来很无聊，普通的值可以存储在常规指针中。之后我们将看看其他选择以及为什么你需要它们:

std::vector<int> fillarr( std::vector<int> arr ) {
    // do something
    return arr;
}

This will do exactly what you expect it to do. The upside is that std::vector takes care of making sure everything is handled cleanly. the downside is that this copies a very large amount of data, if your array is large. In fact it copies every element of the array twice. first it copies the vector so that the function can use it as a parameter. then it copies it again to return it to the caller. If you can handle managing the vector yourself, you can do things quite a bit more easily. (it may copy it a third time if the caller needs to store it in a variable of some sort to do more calculation)

看起来您真正要做的只是填充一个集合。如果没有特定的理由返回一个集合的新实例，那么就不要这样做。我们可以这样做

void fillarr(std::vector<int> &  arr) {
    // modify arr
    // don't return anything
}

通过这种方式，您可以获得传递给函数的数组的引用，而不是它的私有副本。调用者可以看到您对参数所做的任何更改。如果你愿意，你可以返回对它的引用，但这并不是一个好主意，因为这意味着你得到的东西与你传递的东西不同。

如果您确实需要一个集合的新实例，但希望避免将它放在堆栈上(以及所有需要的复制)，则需要为如何处理该实例创建某种契约。最简单的方法是使用智能指针，只要有人使用它，它就会保持被引用的实例。如果超出范围，它就会干净利落地消失。就像这样。

std::auto_ptr<std::vector<int> > fillarr( const std::vector<int> & arr) {
    std::auto_ptr<std::vector<int> > myArr(new std::vector<int>);
    // do stuff with arr and *myArr
    return myArr;
}

在大多数情况下，使用*myArr与使用普通向量的工作原理相同。本例还通过添加const关键字来修改参数列表。现在你得到了一个引用而不需要复制它，但是你不能修改它，所以调用者知道它和函数得到它之前是一样的。

所有这些都很棒，但惯用的c++很少将集合作为一个整体使用。更正常的情况下，您将在这些集合上使用迭代器。它看起来更像这样

template <class Iterator>
Iterator fillarr(Iterator arrStart, Iterator arrEnd) {
    Iterator arrIter = arrStart;
    for(;arrIter <= arrEnd; arrIter++)
       ;// do something
    return arrStart;
}

如果您不习惯使用这种样式，那么使用它看起来有点奇怪。

vector<int> arr;
vector<int>::iterator foo = fillarr(arr.begin(), arr.end());

Foo现在“指向”修改后的arr的开头。

这样做的真正好处是，它在vector和普通C数组以及许多其他类型的集合上工作得同样好

int arr[100];
int *foo = fillarr(arr, arr+100);

现在看起来很像这个问题中其他地方给出的普通指针的例子。

int *fillarr(int arr[])

你仍然可以使用结果like

int *returned_array = fillarr(some_other_array);
if(returned_array[0] == 3)
    do_important_cool_stuff();

来源:https://www.tutorialspoint.com/cplusplus/cpp_return_arrays_from_functions.htm

c++不允许将整个数组作为函数的参数返回。但是，您可以通过指定数组的名称而不指定索引来返回指向数组的指针。

如果你想从一个函数返回一个一维数组，你必须声明一个函数返回一个指针，如下面的例子所示:

int * myFunction（） { . . . }

c++不提倡将局部变量的地址返回给函数外部，因此必须将局部变量定义为静态变量。

将这些规则应用于当前问题，我们可以编写如下程序:

# include <iostream> 使用命名空间std; Int * fillarr(); Int main () ｛ int * p; P = fillarr(); For (int I = 0;I < 5;我+ +) Cout << "p[" << I << "]: "<< *(p + I) << endl; 返回0; ｝ Int * fillarr() ｛ 静态int arr[5]; For (int I = 0;I < 5;+ + i) Arr [i] = i; 返回arr; ｝

输出将是:

p[0]=0
p[1]=1
p[2]=2
p[3]=3
p[4]=4

template<typename T, size_t N>
using ARR_REF = T (&)[N];

template <typename T, size_t N>
ARR_REF<T,N> ArraySizeHelper(ARR_REF<T,N> arr);

#define arraysize(arr) sizeof(ArraySizeHelper(arr))

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

        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)