C ++ forma correcta de devolver el puntero a array de la función

Presta atención porque en esta reseña vas a hallar el hallazgo que buscas.

Solución:

Su código, tal como está, es correcto, pero tengo dificultades para descubrir cómo podría usarse en un escenario del mundo real. Dicho esto, tenga en cuenta algunas advertencias al devolver punteros de funciones:

• Cuando creas un array con sintaxis int arr[5];se asigna en la pila y es local para la función.
• C++ le permite devolver un puntero a este arraypero es comportamiento indefinido para usar la memoria a la que apunta este puntero fuera de su ámbito local. Lea esta gran respuesta usando una analogía del mundo real para obtener una comprensión mucho más clara de lo que podría explicar.
• Todavía puedes usar el array fuera del alcance si puede garantizar que la memoria de la array no ha sido purgado. en tu caso esto es true cuando pasas arr para test().
• Si desea pasar punteros a un asignado dinámicamente array sin preocuparse por las fugas de memoria, debe leer un poco sobre std::unique_ptr/std::shared_ptr<>.

Editar: para responder al caso de uso de la multiplicación de matrices

Tienes dos opciones. La forma ingenua es usar std::unique_ptr/std::shared_ptr<>. La forma moderna de C++ es tener un Matrix clase donde te sobrecargas operator * y usted absolutamente debe usar el nuevo rvalue references si quieres evitar copiar el resultado de la multiplicación para sacarlo de la función. Además de tener su copy constructor, operator = y destructortambién necesitas tener move constructor y move assignment operator. Revise las preguntas y respuestas de esta búsqueda para obtener más información sobre cómo lograrlo.

Edición 2: respuesta a la pregunta adjunta

int* test (int a[5], int b[5]) 
    int *c = new int[5];
    for (int i = 0; i < 5; i++) c[i] = a[i]+b[i];
    return c;

Si está usando esto como int *res = test(a,b);luego, en algún momento posterior en su código, debe llamar delete []res para liberar la memoria asignada en el test() función. Ahora ve que el problema es que es extremadamente difícil hacer un seguimiento manual de cuándo hacer la llamada a delete. Por lo tanto, los enfoques sobre cómo lidiar con eso se describen en la respuesta.

Tu código está bien. Sin embargo, tenga en cuenta que si devuelve un puntero a un arrayy eso array sale del alcance, ya no debe usar ese puntero. Ejemplo:

int* test (void)

    int out[5];
    return out;

Lo anterior nunca funcionará, porque out ya no existe cuando test() devoluciones. El puntero devuelto ya no debe usarse. Si usted hacer úselo, estará leyendo/escribiendo en la memoria que no debería.

En su código original, el arr array queda fuera de alcance cuando main() devoluciones. Obviamente eso no es problema, ya que regresando de main() también significa que su programa está terminando.

Si desea algo que se mantenga y no pueda quedar fuera del alcance, debe asignarlo con new:

int* test (void)

    int* out = new int[5];
    return out;

El puntero devuelto siempre será válido. Sin embargo, recuerda borrarlo de nuevo cuando hayas terminado con él, usando delete[]:

int* array = test();
// ...
// Done with the array.
delete[] array;

Eliminarlo es la única forma de recuperar la memoria que usa.

Nueva respuesta a nueva pregunta:

No puede devolver el puntero a la variable automática (int c[5]) de la función. La variable automática finaliza su vida útil con el bloque envolvente de retorno (función en este caso), por lo que está devolviendo el puntero a no existente array.

O haz que tu variable sea dinámica:

int* test (int a[5], int b[5]) 
    int* c = new int[5];
    for (int i = 0; i < 5; i++) c[i] = a[i]+b[i];
    return c;

O cambie su implementación para usar std::array:

std::array test (const std::array& a, const std::array& b) 

   std::array c;
   for (int i = 0; i < 5; i++) c[i] = a[i]+b[i];
   return c;

En caso de que su compilador no proporcione std::array puede reemplazarlo con una estructura simple que contiene un array:

struct array_int_5  
   int data[5];
   int& operator [](int i)  return data[i];  
   int operator const [](int i)  return data[i];  
;

---

Respuesta antigua a pregunta antigua:

Tu código es correcto y... hmm, bueno... inútil. Dado que las matrices se pueden asignar a punteros sin una función adicional (tenga en cuenta que ya está usando esto en su función):

int arr[5] = 1, 2, 3, 4, 5;
//int* pArr = test(arr);
int* pArr = arr;

Además firma de su función:

int* test (int in[5])

Es equivalente a:

int* test (int* in)

Así que ya ves que no tiene sentido.

Sin embargo, esta firma toma un arrayno puntero:

int* test (int (&in)[5])

Te mostramos comentarios y calificaciones

Si sostienes alguna suspicacia o capacidad de modernizar nuestro reseña te proponemos dejar una glosa y con deseo lo ojearemos.

---

---

Utiliza Nuestro Buscador