c++ - make_shared - shared_ptr con malloc y libre

malloc sizeof c++

Question

Tengo trabajando en aplicaciones grandes que contienen c y cpp. Todos los archivos guardados como extensión cpp pero el código está escrito en estilo c. Quiero decir que es definir la estructura en lugar de asignar la memoria de clase a través de malloc y realloc y calloc.In recent Han instalado la biblioteca de impulso Así que estoy planeando usar en mi base de código existente Así que tengo alguna pregunta siguiente.

1. ¿Puedo usar std :: shared_ptr con malloc y gratis?
2. En caso afirmativo, ¿alguien me puede indicar una base de código de muestra?
3. ¿Afectará cualquier funcionalidad si creo std :: shared_ptr en mi aplicación y paso este puntero a otra función, que usa malloc o calloc?

O en otras palabras:

¿Cómo logro la funcionalidad similar con std :: shared_ptr, para el siguiente código?

void allocateBlocks(int **ptr, int *cnt)
{
    *ptr = (int*)malloc(sizeof(int) * 10);
    *cnt = 10;
    /*do something*/ 
}

int main()
{
    int *p = NULL;
    int count = 0;
    allocateBlocks(&p, &count);
    /*do something*/

    free(p);
}

Llamamos algunas funciones, que aceptan doble puntero y llenan la estructura dentro de su aplicación y usan malloc. ¿Podemos asignar esos punteros a std :: shared_ptr? Por ejemplo:

typedef struct txn_s
{
    int s;
    int d;
    int *e;
} txn_t;

typedef boost::shared_ptr<txn_t> tpointer;

tpointer((txn_t*)::malloc(sizeof(txn_t),::free));

Answer 1

¿Puedo usar shared_ptr con malloc y gratis? en caso afirmativo, ¿alguien puede señalarme la base de código de muestra?

Sí. shared_ptr no asigna memoria en sí. Sin embargo, elimina su objeto una vez que el recuento de referencias cae a cero. Como usa delete de forma predeterminada y no puede usarlo con objetos asignados por malloc (o de cualquier otro modo), debe usar un eliminador personalizado .

si creo shared_ptr en mi aplicación y paso este puntero a otra función si están usando malloc o calloc. ¿Impactará cualquier funcionalidad?

No está claro qué preguntas aquí. Si esa función no espera que se pase un puntero compartido, se debe tener especial cuidado. Pero depende de lo que esa función realmente haga.

Hemos llamado a alguna función que acepte el puntero doble y complete la estructura dentro de su aplicación y use malloc. ¿Podemos asignar esos punteros a shared_ptr?

Sí, puedes usar cualquier puntero con shared_ptr .

Answer 2

¿Puedo usar shared_ptr con malloc y gratis?

Sí.

¿Alguien puede señalarme la base de código de muestra?

Debe proporcionar un eliminador personalizado, de modo que la memoria se libere mediante la delete free lugar de la predeterminada. Esto puede ser un puntero a la función free sí misma:

shared_ptr<void> memory(malloc(1024), free);

Recuerde que malloc y free solo tratan con la memoria bruta, y usted es responsable de crear y destruir correctamente cualquier objeto no trivial que desee conservar en esa memoria.

si creo shared_ptr en mi aplicación y paso este puntero a otra función si están usando malloc o calloc. ¿Impactará cualquier funcionalidad?

No acabo de seguir la pregunta. Puede usar este shared_ptr intercambiable con punteros compartidos "normales", si eso es lo que está preguntando. La eliminación de tipo garantiza que los usuarios de los punteros no se vean afectados por los diferentes tipos de eliminador. Al igual que con cualquier puntero compartido, debe ser un poco cuidadoso si extrae el puntero sin formato con get() ; específicamente, no haga nada que pueda free , ya que ha asignado irrevocablemente la propiedad al puntero compartido.

Hemos llamado a alguna función que acepte el puntero doble y complete la estructura dentro de su aplicación y use malloc. ¿Podemos asignar esos punteros a shared_ptr?

Supongo que quieres decir algo como:

double * make_stuff() {
   double * stuff = static_cast<double*>(malloc(whatever));
   put_stuff_in(stuff);
   return stuff;
}

shared_ptr<double> shared_stuff(make_stuff(), free);

ACTUALIZACIÓN: No detecté la frase "doble puntero", por lo que supongo que te refieres al uso del estilo C de un puntero para emular una referencia para emular un valor de retorno; Tu también puedes hacer eso:

void make_stuff(double ** stuff);

double * stuff = 0;
make_stuff(&stuff);
shared_ptr<double> shared_stuff(stuff, free);

Cómo se manejará con realloc y calloc

Está bien inicializar el puntero compartido con el resultado de calloc , o cualquier otra cosa que devuelva la memoria para ser liberada usando free . No puede usar realloc , ya que shared_ptr ha shared_ptr del puntero original y no lo lanzará sin llamar free .

Answer 3

Para usar std::shared_pointer con malloc() y free() , debe especificar un eliminador personalizado. Esto debería hacerlo

std::shared_ptr<T> ptr(static_cast<T*>(malloc(sizeof(T))), free);

Siempre que no pase el resultado de std::shared_ptr<T>::get() , su puntero está a salvo.

Editar: se agregó fundir el resultado de malloc() a T* .