C - problema di allocazione

[pgnvni]

salve a tutti, ho definito 2 funzioni in cui dato un doppio puntatore devono allocarmi spazio.

La seconda funzione è OK ma la prima no, ecco il codice compilato con Code::Blocks

Codice:

#include <string.h>
#include <ctype.h>

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


typedef struct ptoken
{
int PIelements;
int PImemory;
} INFOTOKEN;


int Tokenizer(char *filename, char** memory, INFOTOKEN *result)
{
if(!result){ printf("Parser: Nessun riferimento per recuperare informazioni.\n"); return 0; }
if(!memory){ printf("Parser: Nessun indirizzo base da allocare.\n"); return -1; }

FILE *f=fopen(filename,"r");
if(!f){ printf("Parser: Nessun file definito.\n"); return -1; }

char c, c2=0; // caratteri di buffers
char ir[5*1024]=""; // buffer istruzione
int j=0, k=0; // contatori
int len=0; // lunghezza parola da allocare
int flag_write=0; // flag di scrittura

// fin quando posso leggere dal file
while( ( c=fgetc(f) ) != EOF )
{

if( isalnum(c) ){ ir[j]=c; j++; }
else if( isspace(c) ) flag_write=1;
else{ c2=c; flag_write=1; }

if(flag_write==1)
{
ir[j]='\0'; // mette il fine stringa
j=0;

len=strlen(ir); // ricavo la lunghezza, se la lunghezza è accettabile scrive.
if(len > 0)
{
// allocazione dinamica
memory=(char**)realloc(memory, _msize(memory) + sizeof(char*) );
if(!memory) return -1;
memory[k]=(char*)calloc( len+1,sizeof(char) );
if(!memory[k]) return -1;
strcpy(memory[k],ir);
k++;
}

if(c2!=0) // allochiamo un simbolo di un solo byte
{
// allocazione dinamica per un simbolo
memory=(char**)realloc(memory,_msize(memory)+sizeo f(char*) );
if(!memory) return -1;
memory[k]=(char*)calloc( 2, sizeof(char) );
if(!memory[k]) return -1;
strcpy(memory[k],&c2);

k++;
c2=0;
}

// riazzero c2
flag_write=0;
} // endif 2
} // end while

if(j>0)
{
ir[j]='\0';
j=0;

len=strlen(ir); // ricavo la lunghezza, se la lunghezza è accettabile scrive.

if(len > 0)
{
// allocazione dinamica
memory=(char**)realloc(memory,_msize(memory)+sizeo f(char*) );
if(!memory) return -1;
memory[k]=(char*)calloc( len+1 , sizeof(char) );
if(!memory[k]) return -1;
strcpy(memory[k],ir);
}
}

if(c2!=0) // allochiamo un simbolo di un solo byte
{
memory=(char**)realloc(memory,_msize(memory)+sizeo f(char*) );
if(!memory) return -1;
memory[k]=(char*)calloc( 2 , sizeof(char) );
if(!memory[k]) return -1;
strcpy(memory[k],&c2);

c2=0;
}

// k-=1; // ripristino contatore dopo l'errore

fclose(f);

result->PIelements=k;
result->PImemory=_msize(memory);
return k;
}


void allocazione(char **array)
{
array=(char**)realloc( array , _msize(array)+10*sizeof(char*) );
}


int main(int argc, char *argv[])
{
//char **memory=(char**)malloc(1*sizeof(char*));
char *filename=argv[1];
INFOTOKEN p_info;

char **memory=(char**)malloc(0);
int esito=Tokenizer(filename, memory, &p_info);

char **array=(char**)malloc(0);

printf("Esito dell'operazione=%d elementi letti\n",esito);
printf("Elementi: %d\nMemoria occupata: %d\n", p_info.PIelements, p_info.PImemory );
printf("Memoria attuale occupata(in bytes): %d\n\n",_msize(memory) );

allocazione(array);
printf("dimensione di array=%d\n",_msize(array));
allocazione(array);
printf("nuova dimensione di array=%d\n\n",_msize(array));

free(memory);
free(array);
}

Il problema che mi si presenta è che:
Memoria occupata è diversa da Memoria attuale occupata

Dovrebbero essere uguali... E quindi di conseguenza non posso accedere a memory[i] per recuperare le stringhe che ho messo.

Questo è quello che mi dice il programma eseguibile:

Esito dell'operazione=97 elementi letti
Elementi: 97
Memoria occupata: 393
Memoria attuale occupata(in bytes): 2

dimensione di array=41
nuova dimensione di array=81

(Nel secondo caso come potete osservare funziona)

Qualcuno può aiutarmi??? Cosa sbaglio???

Grazie!!!


PS . Se lo faccio all'interno del main va tutto OK, ma a me serve incapslularlo in una funzione per renderlo disponibile anche per altri programmi.

[Pisciaiuooooo']

Sbagli a chiederlo in questo sito...

[Pisciaiuooooo']

Originariamente inviato da Pisciaiuooooo'
Sbagli a chiederlo in questo sito...

[MItaly]

A parte i due ultimi commenti che non ho ben capito, puoi ripostare il codice indentato nei tag [code]...[/code]? Attualmente risulta tutto non indentato ed è piuttosto complesso da leggere.

[oregon]

E indica anche cosa intendi fare con

char **memory=(char**)malloc(0);


@Pisciaiuooooo' .... mi sa che hai sbagliato universo ...

[pgnvni]

potevo anche fare:

char **memory;

ma avevo preferito allocare inizialmente 0 bytes quindi ho usato malloc(0)

sta di fatto che l'output del programma parla chiaro, nella seconda funzione, cioè "allocazione(.." io riesco ad allocare spazio e lo tengo anche dopo la funzione, nella prima no.

Vi prego aiutatemi non so proprio cosa fare, nel main funzionava(la memoria rimaneva allocata), è quello il bello... Qua me la libera e me la porta a 2 bytes e non ho capito perchè!

[oregon]

Originariamente inviato da pgnvni
ma avevo preferito allocare inizialmente 0 bytes ...

Ma che senso ha ... semmai si scrive

char **memory = NULL;

sta di fatto che l'output del programma parla chiaro

Parla chiaro per te ...

Dovresti indicare che tipo di file stai leggendo e mostrarne un esempio, altrimenti come si fa a testare il codice?