Hay una función que devuelve un puntero (cualquier tipo), si no almaceno el puntero cuando llamo a la función, ¿qué sucede? ¿La función todavía devolverá un puntero en este caso? En caso afirmativo, ¿habrá una pérdida de memoria porque no estoy liberando la memoria asignada?

Considere el siguiente código como ejemplo:

int * testfunc()
{
int * a=new int();
return(a);
}

int main()
{
testfunc();
return(0);
}
c++
4
Vishal Sharma 23 feb. 2018 a las 13:57

4 respuestas

La mejor respuesta

Absolutamente habrá una pérdida de memoria. Debe equilibrar todas las llamadas a new con un delete en el puntero devuelto.

C ++ te da alguna clase para ayudarte a administrar eso delete: ver std::unique_ptr. Esencialmente, el destructor de std::unique_ptr llama delete que, en la mayoría de los casos, es extremadamente útil.

7
Bathsheba 23 feb. 2018 a las 11:35

Sí, debe liberar manualmente cada bloque de memoria asignado con new, new[], malloc() y calloc(). El método aún devolverá un puntero y apunta a una memoria válida, pero no puede usarlo ni liberarlo. En C ++ casi siempre debe regresar por valor y move semantics se encargará de la memoria dinámica.

3
Loris156 23 feb. 2018 a las 12:28

Sí, pierde memoria.

La variable de puntero en el alcance de la función se destruirá cuando la función salga, pero los datos que el puntero ha asignado permanecerán en la memoria. La función devuelve la dirección de donde se encuentran los datos.

Si esto es realmente lo que pretende hacer su función, aún puede eliminar los datos con la dirección devuelta

int *pi = testfunc();
delete pi;

Entonces no habrá una pérdida de memoria cuando su programa salga, pero sí, hay una pérdida de memoria en la función, como ha pedido.

1
Neil Steyn 23 feb. 2018 a las 17:45

Ejecuté valgrind en el código dado en la pregunta (después de compilarlo con la opción '-g') usando la instrucción (valgrind --leak-check=full --show-reachable=yes --track-origins=yes ./test) Debajo está la salida

==59142== Memcheck, a memory error detector
==59142== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.
==59142== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info
==59142== Command: ./test
==59142==
==59142==
==59142== HEAP SUMMARY:
==59142==     in use at exit: 4 bytes in 1 blocks
==59142==   total heap usage: 1 allocs, 0 frees, 4 bytes allocated
==59142==
==59142== 4 bytes in 1 blocks are definitely lost in loss record 1 of 1
==59142==    at 0x4A075BC: operator new(unsigned long) (vg_replace_malloc.c:298)
==59142==    by 0x4006D3: testfunc() (test.cpp:7)
==59142==    by 0x4006EF: main (test.cpp:13)
==59142==
==59142== LEAK SUMMARY:
==59142==    definitely lost: 4 bytes in 1 blocks
==59142==    indirectly lost: 0 bytes in 0 blocks
==59142==      possibly lost: 0 bytes in 0 blocks
==59142==    still reachable: 0 bytes in 0 blocks
==59142==         suppressed: 0 bytes in 0 blocks
==59142==
==59142== For counts of detected and suppressed errors, rerun with: -v
==59142== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 6 from 6)

Esto demuestra claramente que hay una pérdida de memoria.

-3
Bathsheba 23 feb. 2018 a las 13:34