这样的:

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

int *fillarr(int arr[])

你仍然可以使用结果like

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

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

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

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

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

        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* func()
{
  int* Arr = new int[100];
  return Arr;
}

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

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

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

运行它，您将看到更改