これはかなり古い質問ですが、答えはたくさんあるので、2セントで説明しますが、すべての可能な方法を明確かつ簡潔な方法で示していません（簡潔なビットについてはわかりません。少し手に負えない。TL; DR😉）。
OPが、コピーせずに渡された配列を、呼び出し元に直接渡して別の関数に渡してコードをきれいに見せるための手段として返したいと思っていると思います。
ただし、このような配列を使用することは、それをポインターに減衰させ、コンパイラーに配列のように処理させることです。これは、5つの要素があることを期待する関数などの配列を渡す場合、微妙なバグを引き起こす可能性がありますが、呼び出し元は実際には他の数値を渡します。
これをよりよく処理できる方法がいくつかあります。std::vectororを渡します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;
}
これは、1つは、この作り、それがために期待するタイプの移動はるかに読みやすくします。もちろん、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<>この質問がなされたとき、私のトリックはうまくいかなかったでしょう。当時あなたが望んでいた最高のものは、構造体で型を使用することでした：
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;
}
サイズを渡す代わりに、配列の終わりを過ぎたところを指す終了ポインターを渡すことができます。これは、開始ポインタと終了ポインタを取るstdアルゴリズムに近いものを作成するのに役立ちますが、返されるのは覚えておかなければならないものだけです。
// 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*>beginとendに使用できるを渡し、それを渡すことができますが、実際には配列のように見えなくなります。
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）と非常によく似ていますが、このコンテキストでは機能しません。