Comprobación para ver si se puede liberar un puntero

Question

He buscado una respuesta a esto pero no puedo encontrar una. (Tengo una experiencia bastante limitada con C++)

En mi biblioteca, libero una cadena. (Increíble, ¿eh?)

Aquí es donde surge el problema. Tengo una estructura que contiene un char * que puede asignarse en el montón o no. Si bien es un puntero válido, no se puede liberar.

IE

char* s1 = "A String"; 
char* s2 = (char*)memcpy(malloc(9), s1, 9); 

free(s2); 
free(s1); 

causará un error en el "libre (S1);" (Como debería) Dado que s1 en realidad no necesita para liberarse, (No está en el montón) ¿cómo puedo manejar esto de una manera "aceptable"? (En temas similares, la respuesta de "déjalo colapsar" no parecía razonable IMO)

Dado que la estructura no es únicamente creada por la biblioteca, no es posible garantizar que una cadena se copiará correctamente utilizando algo como memcpy.

Como esta es una biblioteca de Windows, no tengo que preocuparme por usar material ISO C o funciones C estándar.

Answer 1

Al tratarse de una biblioteca de Windows, establezca el argumento en BSTR. Luego necesita que el usuario lo asigne correctamente (con SysAllocString) y tiene la garantía de usar a matching deallocator.

Otros métodos son simplemente ... malos. Si su usuario tiene un compilador diferente, entonces no puede free() la cadena incluso si utilizaron malloc.

[Nota: Construcción de un comentario a petición de James, esto realmente es sólo un caso específico para Windows de la última de his suggestions]

nota además: BSTR es Unicode. De alguna manera recuerdo haber visto una forma de usar el asignador BSTR para almacenar cadenas ANSI, parece que SysAllocStringByteLen hace eso, pero ten en cuenta que poner datos ANSI en un BSTR será altamente contrario a cualquiera que esté familiarizado con BSTR.

Answer 2

En C++, no debe preocuparse por esto en absoluto. Use std::string y haga que administre la memoria automáticamente. Don't manage memory manually.

Si tuviera que hacerlo de forma manual, que tendría que manejar el recurso a sí mismo, por

• hacer que el usuario de la biblioteca de gestionar la memoria a sí mismo, o
• que el usuario tenga que decirte cómo administrar la memoria, o
• indicando al usuario cómo va a administrar la memoria y luego esperar que el usuario cumpla.

Answer 3

Puede malloc char *s1 y colocar "A String" como valor. Después de eso, puede liberar s1.

Answer 4

Este es el tipo de cosa que se conoce en tiempo de compilación. Miras el código y sabes qué liberar y qué no. Así que no piense en una forma de diferirlo al tiempo de ejecución, porque aparte del hecho de que no encontrará una forma en este caso, es la forma incorrecta de hacer las cosas en C++. Cuando puedes hacerlo estáticamente, hazlo estáticamente.

Utilice el sistema de tipos. Usa RAII

Answer 5

Almacena todas las cadenas en el montón, entonces sabrás que todas necesitan ser liberadas. Si la cadena existe como en la memoria global, cópiela en un buffer de pila.

Answer 6

He hecho algo similar en el pasado, donde usaría una cadena asignada por la pila en algunos casos, y una cadena asignada en el montón en otros, pero en última instancia pasarían a algún otro código común.

Lo que he hecho en ese caso, es tener dos punteros. Uno es NULL o una cadena asignada en el montón. El otro puntero apunta a la memoria asignada o a la misma memoria asignada en el montón como la primera. Cuando vaya a hacer su free(), solo verifica el puntero anterior.

Por supuesto, eso se verá desagradable en una API expuesta. En mi caso, era solo código interno.

Answer 7

Para cosas que involucran asignación de memoria en C++, los punteros inteligentes son increíbles. Sólo digo'.

http://www.cplusplus.com/reference/std/memory/auto_ptr/

http://www.boost.org/doc/libs/1_45_0/libs/smart_ptr/smart_ptr.htm