[C] problema allocazione puntatore a puntatore

[marilynm69]

Ciao a tutti, ho un problema con una funzione che deve prendere in ingresso un numero variable di stringhe e creare un puntatore ad array di puntatore a char (le stringhe caricate).
codice:

void addit( char *title, char *elems,...)

{
	va_list argP;
	va_start(argP, elems);

    char **mitems; 
    mitems=(char **)xMalloc(sizeof(char*));
    
	char *p;
    int i; 
    for (i=0; ((p=va_arg(argP,char*)) !=NULL) ; i++ )
    {
     mitems=xRealloc(mitems,sizeof(mitems)+sizeof(*mitems));
        mitems[i]=(char *)xCalloc(1, sizeof(char*));
        mitems[i]=p;

		printf("\n\t%d: %s",i+1, p);
        	printf("\n\t\t+++ %s",mitems[i]);


    }
    printf("\n\n%d arguments\n", i);
    va_end(argP);
}


int main()
{

    addit("FILE","new","open","save","backup","print","setup","exit",NULL);

    return 0;
}

valgrind:

==13035== Memcheck, a memory error detector
==13035== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==13035== Using Valgrind-3.11.0 and LibVEX; rerun with -h for copyright info
==13035== Command: ./serate\ project
==13035== 

	1: open
		+++ open
	2: save
==13035== Invalid write of size 8
==13035==    at 0x4077CD: addit (Menu.c:440)
==13035==    by 0x40791C: temp (Menu.c:456)
==13035==    by 0x406A93: main (main.c:32)
==13035==  Address 0x6dbd620 is 0 bytes after a block of size 16 alloc'd
==13035==    at 0x4C2FD5F: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==13035==    by 0x406B60: xRealloc (Menu.c:32)
==13035==    by 0x40779B: addit (Menu.c:439)
==13035==    by 0x40791C: temp (Menu.c:456)
==13035==    by 0x406A93: main (main.c:32)
==13035== 
==13035== Invalid write of size 8
==13035==    at 0x4077F1: addit (Menu.c:441)
==13035==    by 0x40791C: temp (Menu.c:456)
==13035==    by 0x406A93: main (main.c:32)
==13035==  Address 0x6dbd620 is 0 bytes after a block of size 16 alloc'd
==13035==    at 0x4C2FD5F: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==13035==    by 0x406B60: xRealloc (Menu.c:32)
==13035==    by 0x40779B: addit (Menu.c:439)
==13035==    by 0x40791C: temp (Menu.c:456)
==13035==    by 0x406A93: main (main.c:32)
==13035== 
		+++ save
==13035== Invalid read of size 8
==13035==    at 0x407832: addit (Menu.c:444)
==13035==    by 0x40791C: temp (Menu.c:456)
==13035==    by 0x406A93: main (main.c:32)
==13035==  Address 0x6dbd620 is 0 bytes after a block of size 16 alloc'd
==13035==    at 0x4C2FD5F: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==13035==    by 0x406B60: xRealloc (Menu.c:32)
==13035==    by 0x40779B: addit (Menu.c:439)
==13035==    by 0x40791C: temp (Menu.c:456)
==13035==    by 0x406A93: main (main.c:32)
==13035== 
	3: backup
		+++ backup
	4: print
		+++ print
	5: setup
		+++ setup
	6: exit
		+++ exit

6 arguments
==13035== 
==13035== HEAP SUMMARY:
==13035==     in use at exit: 64 bytes in 7 blocks
==13035==   total heap usage: 14 allocs, 7 frees, 1,176 bytes allocated
==13035== 
==13035== 16 bytes in 1 blocks are definitely lost in loss record 1 of 2
==13035==    at 0x4C2FD5F: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==13035==    by 0x406B60: xRealloc (Menu.c:32)
==13035==    by 0x40779B: addit (Menu.c:439)
==13035==    by 0x40791C: temp (Menu.c:456)
==13035==    by 0x406A93: main (main.c:32)
==13035== 
==13035== 48 bytes in 6 blocks are definitely lost in loss record 2 of 2
==13035==    at 0x4C2FB55: calloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==13035==    by 0x406B14: xCalloc (Menu.c:22)
==13035==    by 0x4077CC: addit (Menu.c:440)
==13035==    by 0x40791C: temp (Menu.c:456)
==13035==    by 0x406A93: main (main.c:32)
==13035== 
==13035== LEAK SUMMARY:
==13035==    definitely lost: 64 bytes in 7 blocks
==13035==    indirectly lost: 0 bytes in 0 blocks
==13035==      possibly lost: 0 bytes in 0 blocks
==13035==    still reachable: 0 bytes in 0 blocks
==13035==         suppressed: 0 bytes in 0 blocks
==13035== 
==13035== For counts of detected and suppressed errors, rerun with: -v
==13035== ERROR SUMMARY: 14 errors from 5 contexts (suppressed: 0 from 0)

a me servirebbe una cosa così:



il problema più grosso è ovviamente quello della memoria, poi non capisco perchè inizia a prendermi il secondo dei parametri variabili("open"), invece che dal prino ("new").
grazie anticipatamente...

P.S. le funzioni xMalloc, xCalloc, xRealloc sono remplicemente malloc, calloc e realloc con il controllo sulla memoria allocata, e restituiscono il puntatore o chiudono il programma

[grigor91]

Originariamente inviato da marilynm69

Ciao a tutti, ho un problema con una funzione che deve prendere in ingresso un numero variable di stringhe e creare un puntatore ad array di puntatore a char (le stringhe caricate).
codice:

void addit( char *title, char *elems,...)

{
	va_list argP;
	va_start(argP, elems);

  ...

}


int main()
{

    addit("FILE","new","open","save","backup","print","setup","exit",NULL);

    return 0;
}

il problema più grosso è ovviamente quello della memoria, poi non capisco perchè inizia a prendermi il secondo dei parametri variabili("open"), invece che dal prino ("new").
grazie anticipatamente...

P.S. le funzioni xMalloc, xCalloc, xRealloc sono remplicemente malloc, calloc e realloc con il controllo sulla memoria allocata, e restituiscono il puntatore o chiudono il programma

title punta al primo carattere di "FILE", elems al primo carattere di "new", quindi il primo argomento variabile è "open".

Inoltre quando effettui la reallocazione la nuova dimensione è formata dalla somma della dimensione dei due puntatori, che quindi sarà sempre costante (8 o 16 byte in base all'architettura).

[misterx]

se non ho capito male

main (int argc, char *argv[] )
{

}

e fa già quello che chiedi

[marilynm69]

in va_start(argP, elems);
elemsnon deve essere l'ultimo degli argomenti fissi? quindi new,...

char * title è un'altra cosa a parte da quella lista...inizia da open anche se sostituisco char *title con int title e ci passo un numero, come potrebbe pure tranquillamente essere...

per riallocare non ho capito come allora dovrei fare...

[marilynm69]

Originariamente inviato da misterx

se non ho capito male

main (int argc, char *argv[] )
{

}

e fa già quello che chiedi

non mi serve,nell'esempio c'è main ma la funzione è interna ad un altra, a sua volta interna al main...

[marilynm69]

per l'allocazione ho risolto, grazie grigor91 per avermi fatto notare...
ho fatto così:

…..
   char **mitems;
    mitems=(char **)xMalloc(sizeof(char*));
    int i; 
    for (i=0; ((p=va_arg(argP,char*)) !=NULL) ; i++ )

    {
	mitems=(char **)xRealloc(mitems,(i+1)*sizeof(char*));
	mitems[i]=p;
     
	printf("\n\t%d: %s",i+1, p);
            printf("\n\t\t+++ %s",mitems[i]);
    }
…..

per gli argomenti variabili nessun suggerimento?

[misterx]

io non ho capito se devi prendere n argomenti in numero e lunghezza variabile e memorizzarli in un array: è così?

[marilynm69]

Originariamente inviato da misterx

io non ho capito se devi prendere n argomenti in numero e lunghezza variabile e memorizzarli in un array: è così?

esatto....per l'array e l'allocazione risolto, non capisco perchè mi inizia a prendere gli argomenti dal secondo

se faccio

void addit(char *elems,...)

funziona come dovrebbe, ma a me serve passare argomenti prima, e per chiarezza un altro char * come titolo...

[misterx]

int main()
{
    addit("FILE","new", "open", "save", "backup", "print", "setup", "exit", NULL);

    return 0;
}
//---------------------------------------------------------------------------

void addit( char *title, char *elems ...)

{
        va_list argP;
	va_start(argP, elems);

        char **mitems;
        mitems=(char **)malloc(sizeof(char*));

	char *p;
        int i;

        for (i=0; ((p=va_arg(argP,char*)) !=NULL) ; i++ )
        {
                mitems=(char **)realloc(mitems,sizeof(mitems)+sizeof(*mitems));
                mitems[i]=(char *)calloc(1, sizeof(char*));
                mitems[i]=p;

		printf("\n\t%d: %s",i+1, p);
        	printf("\n\t\t+++ %s",mitems[i]);
        }

        printf("\n\n%d arguments\n", i);
        va_end(argP);

        getchar();
}
//---------------------------------------------------------------------------

        1: open
                +++ open
        2: save
                +++ save
        3: backup
                +++ backup
        4: print
                +++ print
        5: setup
                +++ setup
        6: exit
                +++ exit

6 arguments

int main()
{
    addit("FILE","new", "open", "save", "backup", "print", "setup", "exit", NULL);

    return 0;
}
//---------------------------------------------------------------------------

void addit( char *title ...)

{
        va_list argP;
	va_start(argP, title);

        char **mitems;
        mitems=(char **)malloc(sizeof(char*));

	char *p;
        int i;

        for (i=0; ((p=va_arg(argP, char*)) !=NULL) ; i++ )
        {
                mitems=(char **)realloc(mitems,sizeof(mitems)+sizeof(*mitems));
                mitems[i]=(char *)calloc(1, sizeof(char*));
                mitems[i]=p;

		printf("\n\t%d: %s",i+1, p);
        	printf("\n\t\t+++ %s",mitems[i]);
        }

        printf("\n\n%d arguments\n", i);
        va_end(argP);

        getchar();
}
//---------------------------------------------------------------------------

        1: new
                +++ new
        2: open
                +++ open
        3: save
                +++ save
        4: backup
                +++ backup
        5: print
                +++ print
        6: setup
                +++ setup
        7: exit
                +++ exit

7 arguments

[marilynm69]

fosse solo un elenco che mi serve andrebbe bene, ma a me serve passare un puntatore a una struttura, il titolo a parte, e gli elementi un altra cosa...
ad esempio la funzione execl:

int execl (const char *__path, const char *__arg, ...)

come vedi sono 2 cose differenti path e arguments....a me serve title e gli elementi...in ogni caso, anche come hai fatto tu, dov'è finito "FILE"? un probabile utente si vedrà sparire la prima variabile, perchè mai?

anche semplificando tutto:

void addit(char * elems,...){

va_list argP;
    va_start(argP, elems);
char *p;
    int i;
    for (i=0; ((p=va_arg(argP,char*)) !=NULL) ; i++ )
    {
        printf("\n%s",p);
    }
    va_end(argP);
}

stampa da new:

new
open
save
backup
print
setup
exit

tolgo pure il ciclo for:

void addit(char * elems,...){

    va_list argP;
    va_start(argP, elems);
    printf("\n%s",va_arg(argP,char*));
    va_end(argP);
}

stampa " new " perchè? dove va a finire la prima variabile?

[marilynm69]

void addit(char * elems, ...){

    va_list argP;
    va_start(argP, elems);
     
    printf("\n%s",elems);
    printf("\n%s",va_arg(argP,char*));

    va_end(argP);
}

la risolvo così, prendo elems come primo elemento, ci faccio il controllo se esiste almeno quello e continuo con il ciclo ,con va_start(argP, elems);

Grazie misterx per avermi portato comunque a risolverlo

PS. devo mettere risolto nel titolo? se si come lo modifico?

[misterx]

però se si fa a questo modo, funziona come vuoi tu, invertendo i parametri della funzione

da così void addit(char *title, char *elems ...); a così void addit(char *elems, char *title ...);

void addit(char *elems, char *title ...);

int main()
{
    addit("FILE","new", "open", "save", "backup", "print", "setup", "exit", NULL);

    return 0;
}
//---------------------------------------------------------------------------

void addit(char *elems, char *title ...)

{
        va_list argP;
	va_start(argP, elems);

        char **mitems;
        mitems=(char **)malloc(sizeof(char*));

	char *p;
        int i;

        for (i=0; ((p=va_arg(argP,char*)) !=NULL) ; i++ )
        {
                mitems=(char **)realloc(mitems,sizeof(mitems)+sizeof(*mitems));
                mitems[i]=(char *)calloc(1, sizeof(char*));
                mitems[i]=p;

		printf("\n\t%d: %s",i+1, p);
        	printf("\n\t\t+++ %s",mitems[i]);
        }

        printf("\n\n%d arguments\n", i);
        va_end(argP);

        getchar();
}
//---------------------------------------------------------------------------

sembra più un problema di posizione dei parametri

[marilynm69]

stessa cosa, comunque l'ho risolto così...ora il problema è un altro, ma il puntatore è puntatore a puntatore a struttura, e viene passato alla funzione addit per poi riallocare di volta in volta...non so se postarlo sempre quà, anche perchè il titolo sarebbe simile

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>


typedef struct s_drop_down_menu_labels
{
    char *title;
    char **items;
} MenuLabels;

MenuLabels ** ml_init(void)
{
    MenuLabels **ml;
    ml=(MenuLabels **)calloc(2,sizeof(MenuLabels*));
    ml[1]=NULL;
    return ml;
}



void addit(MenuLabels **mlabels, char *title, char *elems,...)
{

    int j;
    for (j=0; mlabels[j]!=NULL ; j++ );
    printf("\n\nCHECK:MenuLabels has %d menu",j);

    mlabels=(MenuLabels **)realloc(mlabels,(j+2)*sizeof(MenuLabels*));

    mlabels[j]=(MenuLabels *)malloc(1*sizeof(MenuLabels));

    mlabels[j+1]=NULL;




    mlabels[j]->title=title;

    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    int i=0;
    char **mitems=NULL;
    mitems=(char **)malloc(sizeof(char*));
    mitems[i]=elems;

    va_list argP;
    va_start(argP, elems);

    char *p;
    for (i=1; ((p=va_arg(argP,char*)) !=NULL) ; i++ )
    {
        mitems=(char **)realloc(mitems,(i+1)*sizeof(char*));
        mitems[i]=p;
    }

    if (!p)
    {
        mitems=(char **)realloc(mitems,(i+1)*sizeof(char*));
        mitems[i]=NULL;
    }

    va_end(argP);
    /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

    mlabels[j]->items=mitems;
}



int main()
{
    MenuLabels **ml;
    ml=ml_init();
    addit(ml,"FILE","new","open","save","backup","print","setup","exit",NULL);
    addit(ml,"AFILE","Anew","Asave","Abackup","Aexit",NULL);
    addit(ml,"BFILE","Bnew","Bopen","Bsave","Bprint","Bexit",NULL);
    addit(ml,"CFILE","Cnew","Copen","Csave","Cbackup","Cprint","Csetup","Cexit",NULL);
    addit(ml,"DFILE","Dnew","Dsave","Dbackup","Dexit",NULL);
    addit(ml,"EFILE","Enew","Eopen","Esave","Eprint","Eexit",NULL);

    free(ml);

    fprintf(stdout,"\n\033[1;91m***END***\033[0m\n");
    return 0;
}

output terminale:

CHECK:MenuLabels has 0 menu

CHECK:MenuLabels has 1 menu

CHECK:MenuLabels has 2 menu

CHECK:MenuLabels has 2 menu

CHECK:MenuLabels has 2 menu

CHECK:MenuLabels has 2 menu
***END***

output Valgrind:

==13907== Memcheck, a memory error detector
==13907== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==13907== Using Valgrind-3.11.0 and LibVEX; rerun with -h for copyright info
==13907== Command: ./prove
==13907== 


==13907== Invalid read of size 8
==13907==    at 0x400812: addit (main.c:26)
==13907==    by 0x400B27: main (main.c:75)
==13907==  Address 0x5204040 is 0 bytes inside a block of size 16 free'd
==13907==    at 0x4C2FD5F: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==13907==    by 0x400855: addit (main.c:29)
==13907==    by 0x400AF1: main (main.c:74)
==13907==  Block was alloc'd at
==13907==    at 0x4C2FB55: calloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==13907==    by 0x40075C: ml_init (main.c:15)
==13907==    by 0x400AB0: main (main.c:73)
==13907== 
CHECK:MenuLabels has 0 menu

==13907== Invalid free() / delete / delete[] / realloc()
==13907==    at 0x4C2FD5F: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==13907==    by 0x400855: addit (main.c:29)
==13907==    by 0x400B27: main (main.c:75)
==13907==  Address 0x5204040 is 0 bytes inside a block of size 16 free'd
==13907==    at 0x4C2FD5F: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==13907==    by 0x400855: addit (main.c:29)
==13907==    by 0x400AF1: main (main.c:74)
==13907==  Block was alloc'd at
==13907==    at 0x4C2FB55: calloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==13907==    by 0x40075C: ml_init (main.c:15)
==13907==    by 0x400AB0: main (main.c:73)
==13907== 
==13907== Invalid write of size 8
==13907==    at 0x400882: addit (main.c:31)
==13907==    by 0x400B27: main (main.c:75)
==13907==  Address 0x0 is not stack'd, malloc'd or (recently) free'd
==13907== 
==13907== 
==13907== Process terminating with default action of signal 11 (SIGSEGV)
==13907==  Access not within mapped region at address 0x0
==13907==    at 0x400882: addit (main.c:31)
==13907==    by 0x400B27: main (main.c:75)
==13907==  If you believe this happened as a result of a stack
==13907==  overflow in your program's main thread (unlikely but
==13907==  possible), you can try to increase the size of the
==13907==  main thread stack using the --main-stacksize= flag.
==13907==  The main thread stack size used in this run was 8388608.
CHECK:MenuLabels has 0 menu==13907== 
==13907== HEAP SUMMARY:
==13907==     in use at exit: 112 bytes in 4 blocks
==13907==   total heap usage: 14 allocs, 10 frees, 1,392 bytes allocated
==13907== 
==13907== 16 bytes in 1 blocks are definitely lost in loss record 2 of 4
==13907==    at 0x4C2DB8F: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==13907==    by 0x400881: addit (main.c:31)
==13907==    by 0x400B27: main (main.c:75)
==13907== 
==13907== 96 (16 direct, 80 indirect) bytes in 1 blocks are definitely lost in loss record 4 of 4
==13907==    at 0x4C2FD5F: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==13907==    by 0x400855: addit (main.c:29)
==13907==    by 0x400AF1: main (main.c:74)
==13907== 
==13907== LEAK SUMMARY:
==13907==    definitely lost: 32 bytes in 2 blocks
==13907==    indirectly lost: 80 bytes in 2 blocks
==13907==      possibly lost: 0 bytes in 0 blocks
==13907==    still reachable: 0 bytes in 0 blocks
==13907==         suppressed: 0 bytes in 0 blocks
==13907== 
==13907== For counts of detected and suppressed errors, rerun with: -v
==13907== ERROR SUMMARY: 5 errors from 5 contexts (suppressed: 0 from 0)

sembra ci sia un errore in

mlabels=(MenuLabels **)realloc(mlabels,(j+2)*sizeof(MenuLabels*));

sono giorni che non ne esco...la parte tra i due commenti "/*+++...+++*/" è a posto

[marilynm69]

Risolto finalmente ....ecco il codice:

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>


typedef struct s_drop_down_menu_labels
{
    char *title;
    char **items;
} MenuLabels;

MenuLabels ** ml_init(void)
{
    MenuLabels **ml;
    ml=(MenuLabels **)calloc(2,sizeof(MenuLabels*));
    ml[1]=NULL;
    return ml;
}



void addit(MenuLabels ***mlabels, char *title, char *elems,...)
{

    int j;
    for (j=0; (*mlabels)[j]!=NULL ; j++ );
    printf("\n\nCHECK:MenuLabels has %d menu",j);

    *mlabels=(MenuLabels **)realloc(*mlabels,(j+2)*sizeof(MenuLabels*));

    (*mlabels)[j]=(MenuLabels *)malloc(1*sizeof(MenuLabels));

    (*mlabels)[j+1]=NULL;




    (*mlabels)[j]->title=title;

    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    int i=0;
    char **mitems=NULL;
    mitems=(char **)malloc(sizeof(char*));
    mitems[i]=elems;

    va_list argP;
    va_start(argP, elems);

    char *p;
    for (i=1; ((p=va_arg(argP,char*)) !=NULL) ; i++ )
    {
        mitems=(char **)realloc(mitems,(i+1)*sizeof(char*));
        mitems[i]=p;
    }

    if (!p)
    {
        mitems=(char **)realloc(mitems,(i+1)*sizeof(char*));
        mitems[i]=NULL;
    }

    va_end(argP);
    /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

    (*mlabels)[j]->items=mitems;
    free(mitems);
}


int main()
{
    MenuLabels **ml;
    ml=ml_init();
    addit(&ml,"FILE","new","open","save","backup","print","setup","exit",NULL);
    addit(&ml,"AFILE","Anew","Asave","Abackup","Aexit",NULL);
    addit(&ml,"BFILE","Bnew","Bopen","Bsave","Bprint","Bexit",NULL);
    addit(&ml,"CFILE","Cnew","Copen","Csave","Cbackup","Cprint","Csetup","Cexit",NULL);
    addit(&ml,"DFILE","Dnew","Dsave","Dbackup","Dexit",NULL);
    addit(&ml,"EFILE","Enew","Eopen","Esave","Eprint","Eexit",NULL);


    printf("\n**********CHECK: %s",ml[0]->title);

for (int i=0;ml[i]!=NULL ;i++ )
    free(ml[i]);

    fprintf(stdout,"\n\033[1;91m***END***\033[0m\n");
    return 0;
}

unica cosa rimangono byte da deallocare che non capisco quali siano:

==18805== Memcheck, a memory error detector
==18805== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==18805== Using Valgrind-3.11.0 and LibVEX; rerun with -h for copyright info
==18805== Command: ./prove
==18805== 


CHECK:MenuLabels has 0 menu

CHECK:MenuLabels has 1 menu

CHECK:MenuLabels has 2 menu

CHECK:MenuLabels has 3 menu

CHECK:MenuLabels has 4 menu

CHECK:MenuLabels has 5 menu
**********CHECK: FILE
***END***
==18805== 
==18805== HEAP SUMMARY:
==18805==     in use at exit: 56 bytes in 1 blocks
==18805==   total heap usage: 52 allocs, 51 frees, 2,504 bytes allocated
==18805== 
==18805== 56 bytes in 1 blocks are definitely lost in loss record 1 of 1
==18805==    at 0x4C2FD5F: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==18805==    by 0x400858: addit (main.c:29)
==18805==    by 0x400C33: main (main.c:79)
==18805== 
==18805== LEAK SUMMARY:
==18805==    definitely lost: 56 bytes in 1 blocks
==18805==    indirectly lost: 0 bytes in 0 blocks
==18805==      possibly lost: 0 bytes in 0 blocks
==18805==    still reachable: 0 bytes in 0 blocks
==18805==         suppressed: 0 bytes in 0 blocks
==18805== 
==18805== For counts of detected and suppressed errors, rerun with: -v
==18805== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)