Конечный тип возвращаемого массива
auto function(int i) -> int(*)[10]{
}
Может кто-нибудь помочь мне, как вернуть указатель на массив из 10 целых чисел, используя конечный тип возврата? Любой пример будет полезен.
Решение
#include <iostream>
const size_t sz = 10;
auto func(int i) -> int(*)[sz] /// returns a pointer to an array of ten ints
{
static int arr[sz];
for (size_t i = 0; i != sz; ++i)
arr[i] = i;
return &arr;
}
int main()
{
int i = 2;
int (*p)[sz] = func(i); /// points to an array of ten ints which funct returns which is arr array
for (size_t ind = 0; ind != sz; ++ind) /// displays the values
std::cout << (*p)[ind] << std::endl;
return 0;
}
авто функция (int i) -> int (*) [sz]
- это означает, что функция имени функции имеет параметры типа int, которые принимают
аргумент int и возвращает указатель на массив из 10 int, что означает
что мы указали каждый элемент int в массиве из десяти int. концевые типы возврата используются для легкого чтения
вернуть указатель на массив из десяти int
int i = 2;
int (* p) [sz] = funct (i);
- это означает, что (* p) [sz] будет указывать массив из 10 int, что функция func
возвращает массив arr и отображает значения, используя цикл
Другие решения
Если вас не волнует, является ли возвращаемое значение разыменованным (и вы не указали это), следующее «вернет указатель на массив из 10 целых чисел»:
auto function(int i) -> int(*)[10]
{
return nullptr;
}
Сначала вам нужно решить, где будут храниться целые числа, как они будут «разделены», и отвечает ли вызывающий или вызываемый за их время жизни.
Варианты включают …
1) возврат указателя на вновь динамически распределенную память:
auto function(int i) -> int(*)[10] {
int* p = new int[10];
p[0] = 1;
p[1] = 39;
...
p[9] = -3;
return (int(*)[10])p;
}
// BTW it's usually cleaner (avoiding the ugly cast above) to handle
// arrays via a pointer (but you do lose the compile-time knowledge of
// array extent, which can be used e.g. by templates)
int* function(int i) {
int* p = ...new and assign as above...
return p;
}
// either way - the caller has to do the same thing...
void caller()
{
int (*p)[10] = function();
std::cout << p[0] + p[9] << '\n';
delete[] p;
}
Обратите внимание, что 99% времени возвращаются либо std::vector<int> или std::array<int, 10> это лучшая идея, и что 99% оставшегося времени лучше вернуть std::unique_ptr<int[]> который вызывающий может переместить к своей собственной переменной, которая будет delete[] данные, как они уничтожаются, выходят из области видимости или — для переменных-членов — уничтожают содержащий объект.
2) возвращая указатель на function()-местный static массив (который будет перезаписываться каждый раз function вызывается так, что старые возвращенные указатели будут видеть обновленные значения и могут быть условия гонки в многопоточном коде):
auto function(int i) -> int(*)[10]{
static int a[10] { 1, 39, ..., -3 };
return &a;
}
Звонящий звонит так же, но не должен вызов delete[],