이것은 상당히 오래된 질문이지만 많은 답변이 있기 때문에 2 센트를 넣을 것입니다. 그러나 가능한 모든 방법을 명확하고 간결한 방식으로 표시하지는 않습니다 (간결한 비트에 대해서는 확실하지 않습니다. TL; DR 😉).
OP가 코드를 더 예쁘게 보이도록 다른 함수로 전달하기 위해 호출자에게 직접 전달하는 수단으로 복사하지 않고 전달 된 배열을 반환하기를 원한다고 가정합니다.
그러나 이와 같은 배열을 사용하려면 포인터로 붕괴하여 컴파일러 가 배열 처럼 취급하도록하십시오 . 이렇게하면 배열에 5 개의 요소가있을 것으로 예상하지만 호출자는 실제로 다른 번호로 전달하는 등의 배열을 전달하면 미묘한 버그가 발생할 수 있습니다.
더 잘 처리 할 수있는 몇 가지 방법이 있습니다. A의 패스 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<>이 질문을 할 때 내 트릭은 효과가 없었습니다. 그때 당신이 기대했을 수있는 가장 좋은 것은 구조체에 유형을 사용하는 것이 었습니다.
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*>시작과 끝을 위해 그것을 사용할 수있는를 전달할 수 있습니다. 그러나 그 배열은 실제로 배열처럼 보이지 않습니다.
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) 과 매우 유사 하지만이 맥락에서는 작동하지 않습니다.