Preoccupato per la perdita di memoria nella DLL che crea una matrice di dimensioni dinamiche

Question

Preoccupato per la perdita di memoria nella DLL che crea una matrice di dimensioni dinamiche

#1 da (4 voti)
#2 da (0 voti)

3

Ho una DLL wrapper che si interfaccia con un'altra DLL che contiene la seguente funzione:

char * Foobar(void)
{

    // BLAH is the function from the DLL this wrapper interfaces too
    char *array = 0; // Set up an array pointer for dynamic memory allocation.
    int NumOfChar = 0;

    // Build array
    for (int n=0; (*(BLAH+n) != 'char * Foobar(void)
{

    // BLAH is the function from the DLL this wrapper interfaces too
    char *array = 0; // Set up an array pointer for dynamic memory allocation.
    int NumOfChar = 0;

    // Build array
    for (int n=0; (*(BLAH+n) != '%pre%'); n++)
    {
            NumOfChar++; // keep track of how big BLAH is.
    }

    NumOfChar++;    // +1 so I can re-add the NULL

    // Try to allocate an array based on the size of BLAH This is dynamic...
    if (!(array = new char[NumOfChar]))
    {   
        // If there's a problem allocating the memory, pop up a message.
        MessageBox (0, "Error: out of memory.", "Crap", MB_OK); 
    }
    else
    {
        memcpy(array, BLAH,(NumOfChar)); // copy the contents of BLAH to array.
    }

    array[NumOfChar+1]='%pre%'; // ensure the last character is a NULL

    FreeLibrary(hGetProcIDDLL); // release the DLL

    return array;   
}
'); n++)
    {
            NumOfChar++; // keep track of how big BLAH is.
    }

    NumOfChar++;    // +1 so I can re-add the NULL

    // Try to allocate an array based on the size of BLAH This is dynamic...
    if (!(array = new char[NumOfChar]))
    {   
        // If there's a problem allocating the memory, pop up a message.
        MessageBox (0, "Error: out of memory.", "Crap", MB_OK); 
    }
    else
    {
        memcpy(array, BLAH,(NumOfChar)); // copy the contents of BLAH to array.
    }

    array[NumOfChar+1]='%pre%'; // ensure the last character is a NULL

    FreeLibrary(hGetProcIDDLL); // release the DLL

    return array;   
}

Sto chiamando questa DLL da LabVIEW che non credo sia specifica per questa domanda, dato che la DLL può essere chiamata da qualsiasi programma. La mia domanda è una volta che Foobar restituisce il puntatore all'array, come posso assicurarmi che l'array sia deallocato in seguito? Questa sembra essere una perdita di memoria, perché la prossima volta che viene chiamata questa routine, l'array successivo non necessariamente sovrascriverà il vecchio array. Userà sempre più memoria, sono corretto in questa logica?

Grazie

memory dll

posta zacharoni16 17.04.2014 - 15:33

fonte

2 risposte

0

Un altro approccio consiste nel restituire il char * racchiuso in un puntatore intelligente, come

// If you want several scopes keeping references to the same memory
std::shared_ptr<char> Foobar(void)

//or (if you only want a single reference to be available)

std::unique_ptr<char> Foobar(void)

Notifiche, che i due tipi precedenti ( std::shared_ptr & std::unique_ptr ) sono stati introdotti di recente nell'STL. In questo caso, puoi utilizzare boost, quindi puoi

boost::shared_ptr<char> Foobar(void) // for example.

Nota per VC ++: sia il codice client che la DLL (con Foobar) devono essere compilati con la stessa versione del runtime MSVC, come MSVC2013 o entrambi MSVC2015 (che non è un problema nel VC ++ moderno, poiché viene applicato da linker penso). Anche il client deve essere compilato con runtime MD. Per maggiori dettagli su questo, vedi link

risposta data 05.10.2016 - 20:22

fonte

Leggi altre domande sui tag memory dll

API migliore e più sicura per una funzione che riempie un buffer con dati a lunghezza variabile Per i metodi di esempio, restituire sempre sé o questo, invece di usare un tipo di reso vuoto, essere uno stile di codifica pulito? [chiuso]

score 4 · Accepted Answer

Sì, stai allocando memoria ma non la libera, quindi c'è una perdita di memoria.

Un buon approccio è quello di allocare e deallocare la memoria nello stesso posto, cioè ovunque venga chiamata la DLL - nel tuo caso, LabVIEW. Cioè, rendi la tua funzione void Foobar(char *array) (o int Foobar(char *array) e restituisci la lunghezza dell'array). Quindi devi solo assicurarti di chiamare la funzione con un array abbastanza grande. Forse aggiungi un altro parametro indica la lunghezza massima consentita, int Foobar(char *array, int maxLen) per reagire invece di arrestarsi in caso di lunghezza insufficiente.