这是一个相当老的问题，但是我要投入2美分，因为有很多答案，但是没有一个以简洁明了的方式展示所有可能的方法（不确定简明之处，因为这有点位（TL; DR😉）。
我假设OP希望返回不复制而传递的数组，这是将其直接传递给调用方并传递给另一个函数以使代码更漂亮的某种方式。
然而，使用一个数组这样是让它衰变到一个指针和具有编译器把它像一个数组。如果您传入类似的数组，这可能会导致细微的错误，该函数期望它包含5个元素，但是调用者实际上传入了其他一些数字。
有几种方法可以更好地处理此问题。传递一个std::vector或std::array（不确定是否std::array在2010年问这个问题时）。然后，您可以将对象作为参考传递，而无需任何复制/移动对象。
std::array<int, 5>& fillarr(std::array<int, 5>& arr)
{
// (before c++11)
for(auto it = arr.begin(); it != arr.end(); ++it)
{ /* do stuff */ }
// Note the following are for c++11 and higher. They will work for all
// the other examples below except for the stuff after the Edit.
// (c++11 and up)
for(auto it = std::begin(arr); it != std::end(arr); ++it)
{ /* do stuff */ }
// range for loop (c++11 and up)
for(auto& element : arr)
{ /* do stuff */ }
return arr;
}
std::vector<int>& fillarr(std::vector<int>& arr)
{
for(auto it = arr.begin(); it != arr.end(); ++it)
{ /* do stuff */ }
return arr;
}
但是，如果您坚持使用C数组，请使用一个模板，该模板将保留数组中有多少项的信息。
template <size_t N>
int(&fillarr(int(&arr)[N]))[N]
{
// N is easier and cleaner than specifying sizeof(arr)/sizeof(arr[0])
for(int* it = arr; it != arr + N; ++it)
{ /* do stuff */ }
return arr;
}
除了那看起来很难看，而且很难读。我现在使用一些东西来帮助解决2010年没有出现的问题，我也将其用于函数指针：
template <typename T>
using type_t = T;
template <size_t N>
type_t<int(&)[N]> fillarr(type_t<int(&)[N]> arr)
{
// N is easier and cleaner than specifying sizeof(arr)/sizeof(arr[0])
for(int* it = arr; it != arr + N; ++it)
{ /* do stuff */ }
return arr;
}
这使其中一个会希望它是，使得这种类型远远更具可读性。当然，如果您只使用5个元素，那么使用模板是多余的，因此您当然可以对其进行硬编码：
type_t<int(&)[5]> fillarr(type_t<int(&)[5]> arr)
{
// Prefer using the compiler to figure out how many elements there are
// as it reduces the number of locations where you have to change if needed.
for(int* it = arr; it != arr + sizeof(arr)/sizeof(arr[0]); ++it)
{ /* do stuff */ }
return arr;
}
就像我说的那样，type_t<>在提出这个问题时，我的trick俩是行不通的。那时您可能希望的最好的办法是在结构中使用类型：
template<typename T>
struct type
{
typedef T type;
};
typename type<int(&)[5]>::type fillarr(typename type<int(&)[5]>::type arr)
{
// Prefer using the compiler to figure out how many elements there are
// as it reduces the number of locations where you have to change if needed.
for(int* it = arr; it != arr + sizeof(arr)/sizeof(arr[0]); ++it)
{ /* do stuff */ }
return arr;
}
虽然看起来可能很丑陋，但至少仍然更具可读性，尽管typename那时取决于编译器可能是可选的，从而导致：
type<int(&)[5]>::type fillarr(type<int(&)[5]>::type arr)
{
// Prefer using the compiler to figure out how many elements there are
// as it reduces the number of locations where you have to change if needed.
for(int* it = arr; it != arr + sizeof(arr)/sizeof(arr[0]); ++it)
{ /* do stuff */ }
return arr;
}
然后，您当然可以指定一个特定的类型，而不是使用我的帮助器。
typedef int(&array5)[5];
array5 fillarr(array5 arr)
{
// Prefer using the compiler to figure out how many elements there are
// as it reduces the number of locations where you have to change if needed.
for(int* it = arr; it != arr + sizeof(arr)/sizeof(arr[0]); ++it)
{ /* do stuff */ }
return arr;
}
当时，自由的功能std::begin()和std::end()不存在，但可能已经很容易实现。这将允许以一种更安全的方式遍历数组，因为它们在C数组上有意义，但在指针上却没有意义。
至于访问数组，您既可以将其传递给具有相同参数类型的另一个函数，也可以为其别名（这在您已经拥有该范围的原始对象中就没有多大意义了）。访问数组引用就像访问原始数组一样。
void other_function(type_t<int(&)[5]> x) { /* do something else */ }
void fn()
{
int array[5];
other_function(fillarr(array));
}
要么
void fn()
{
int array[5];
auto& array2 = fillarr(array); // alias. But why bother.
int forth_entry = array[4];
int forth_entry2 = array2[4]; // same value as forth_entry
}
总而言之，如果要迭代数组，最好不要让数组衰减为指针。这是一个坏主意，因为它使编译器无法保护您免于脚步，并使您的代码更难阅读。除非您有充分的理由不这样做，否则请始终尝试通过尽可能长时间保持类型来帮助编译器为您提供帮助。
编辑
哦，为了完整起见，您可以允许它降级为一个指针，但这会使数组与其持有的元素数量脱钩。这在C / C ++中已完成很多工作，通常可以通过传递数组中的元素数来缓解。但是，如果您犯了错误并将错误的值传递给元素数量，则编译器将无法为您提供帮助。
// separate size value
int* fillarr(int* arr, size_t size)
{
for(int* it = arr; it != arr + size; ++it)
{ /* do stuff */ }
return arr;
}
您可以传递结束指针，而不是传递大小，该指针将指向数组末尾的1。这很有用，因为它可以使它更接近于std算法，该算法需要使用begin和end指针，但是现在返回的只是您必须记住的内容。
// separate end pointer
int* fillarr(int* arr, int* end)
{
for(int* it = arr; it != end; ++it)
{ /* do stuff */ }
return arr;
}
另外，您可以记录该函数仅包含5个元素，并希望函数的用户不要做任何愚蠢的事情。
// I document that this function will ONLY take 5 elements and
// return the same array of 5 elements. If you pass in anything
// else, may nazal demons exit thine nose!
int* fillarr(int* arr)
{
for(int* it = arr; it != arr + 5; ++it)
{ /* do stuff */ }
return arr;
}
请注意，返回值已丢失其原始类型，并降级为指针。因此，您现在可以自己确保不会超出阵列。
您可以传递一个std::pair<int*, int*>，可以将其用于开始和结束，并将其传递出去，但是随后它实际上不再像数组一样。
std::pair<int*, int*> fillarr(std::pair<int*, int*> arr)
{
for(int* it = arr.first; it != arr.second; ++it)
{ /* do stuff */ }
return arr; // if you change arr, then return the original arr value.
}
void fn()
{
int array[5];
auto array2 = fillarr(std::make_pair(&array[0], &array[5]));
// Can be done, but you have the original array in scope, so why bother.
int fourth_element = array2.first[4];
}
要么
void other_function(std::pair<int*, int*> array)
{
// Can be done, but you have the original array in scope, so why bother.
int fourth_element = array2.first[4];
}
void fn()
{
int array[5];
other_function(fillarr(std::make_pair(&array[0], &array[5])));
}
有趣的是，这与std::initializer_list工作方式（c ++ 11）非常相似，但是它们在这种情况下不起作用。