[C/C++]Allocazione Dinamica Matrice

[d0c1Le.Killah]

Salve a tutti... ho un noiosissimo problema di funzionamento con una matrice allocata dinamicamente... il problema è che ho una matrice in cui inizialmente è allocata solo una riga (o una colonna, come volete voi ), in modo da aggiungere una nuova riga, di lunghezza fissa di 4 int, solo se necessario.
Il programma prende una stringa da XML, comunque la riporto come se fosse inizializzata all'inizio.
Vi riporto il codice incriminato:

#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <string>

using namespace std;

int main(int argc, char* argv[])
{
	int i1, i2, j1, j2; //indici per calcolare gli intervalli
		j2 = 0;
	int **seqLati;  //vettore contenente la sequenza - 4 per motivi pratici

	seqLati = (int**)calloc(1, sizeof(int*));
	seqLati[0] = (int*)calloc(4,sizeof(int));

	string coordinatefield="1 21 22 , 2 22 23 , 3 23 24 , 4 24 25 ,
 5 25 26 , 6 26 27 , 7 27 28 , 8 28 29 , 9 29 30 , 10 30 31 , 11 31 32 ,
 12 32 33 , 13 33 34 , 14 34 35 , 15 35 36 , 16 36 37 , 17 37 38 , 
18 38 39 , 19 39 40 , 20 40 41 , 22 42 43 , 23 43 44 , 24 44 45 , 
25 45 46 , 26 46 47 , 27 47 48 , 28 48 49 , 29 49 50 , 30 50 51 , 
31 51 52 , 32 52 53 , 33 53 54 , 34 54 55 , 35 55 56 , 36 56 57 , 
37 57 58 , 38 58 59 , 39 59 60 , 40 60 61 , ";

	string temp;
	string temp2;

//Load sequenza triangoli
	int i = 0;
	int j = 0;
	for(i1 = 0; i1 < coordinatefield.size();) {
		i2 = coordinatefield.find(",",i1);
		temp = coordinatefield.substr(i1,i2-i1);
		i1 = i2+1;
		j2 = 0;
		for(j1 = 0; j1 < temp.size();){
			j = 0;
			while(j2 != -1){
				if(temp.find(" ",j1)== NULL)
					j1++;
				else {
					float x;
					j2 = temp.find(" ",j1);
					temp2 = temp.substr(j1, j2-j1);
					x = atof(temp2.c_str());
					seqLati[i][j]= (int)x;
					cout << seqLati[i][j] << endl;
					j++;
					j1 = j2+1;
				}
				if (j2 == -1)
				j1 = temp.size();
			}
			i++;
			seqLati[i] = (int *)realloc(seqLati, 4*sizeof(int));
			if ( seqLati[i] == NULL )
				cout << ( "Memoria disponibile insufficiente\n" );
			cout << "Reallocato" << endl;
			
		}		
		cout << seqLati[1][0] <<" e " <<seqLati[1][1]<<" e " << seqLati[1][2] << endl;
	}
	
	return 0;

}

Si... manca la free, che metterò quando avrò risolto questo problema.
Il programma deve trasformare i punti elencati in quel modo nella stringa, in una matrice di punti, con i vettori monodimensionali composti dai 3 vertici. La gestione del parsing spiega il caos dentro il for, visto che dovrei ignorare tutte le possibili situazioni "fastidiose" causate da più spazi bianchi...

La cosa che mi stupisce è che programma si blocca dopo aver letto correttamente i primi punti...!!
Ci sto sbattendo la testa da un bel po', senza trovare alcuna soluzione...
grazie mille a chi mi vorrà aiutare!!!!!!!!!!!!!!!!!!

[DanieleC88]

Il parsing magari poteva essere leggermente diverso per essere più leggibile, ma comunque...

seqLati[i] = (int *)realloc(seqLati, 4*sizeof(int));

Che diavolo è questa?
Rivedi la riga e riprova...

In più c'è un "coordinatefield.size()" nel for che dovrebbe invece essere coordinatefield.length() (lo stesso per il temp del ciclo annidato e così via). Usi una chiamata ad atof() quando una atoi() era ben più indicata (sono tutti numeri interi, perché vai a leggere un numero in virgola mobile?), e dai per scontato che la ricerca di uno spazio a partire dalla posizione temp abbia successo (e se invece è l'ultimo numero nella stringa e poi la stringa termina?).

[Noixe]

La classe string ha sia il metodo size che quello length, i quali fanno la stessa cosa.

Cmq, perché non usi new invece dei vari alloc?

Inoltre, il metodo find quando non trova la stringa restituisce string::npos, (considerato anche -1) ma tu lo confronti con NULL che equivale a 0, ma forse la tua intenzione e' quella di verificare se lo spazio ci sia o no.

Ciao

[d0c1Le.Killah]

Ciao ragazzi, grazie per la risposta... Daniele, grazie per la critica, ma size va benissimo, atof subisce casting perchè all'inizio erano float e ho fatto tutto al volo (comunque sì, lo correggo). Infine, le stringhe finiscono con " ," in quanto generate da tool di exporting.

Il while mi serve per terminare appunto quando i 3 punti sono letti, mentre il confronto con il NULL riguarda gli spazi.

Va detto che all'inizio usavo vettori statici e funzionava alla perfezione... quindi il problema potrebbe riguardare qualche indirizzamento che non riesco a trovare...

La riga:

seqLati[i] = (int *)realloc(seqLati, 4*sizeof(int));

è quella che potrebbe non andare... non lo so, per me significa che ogni volta che è entrato nel ciclo (e quindi ho ancora dei punti da leggere), preparo un nuovo spazio per 4 int... non si fa così?

P.S.:Sì, uso malloc ormai per principio, perchè voglio capire dove sta l'errore, poi magari lo converto in new e delete...

Grazie!

[DanieleC88]

Originariamente inviato da d0c1Le.Killah

size va benissimo

Vero, errore mio. Anche se length() è un nome migliore, IMHO.

Originariamente inviato da d0c1Le.Killah

La riga:

seqLati[i] = (int *)realloc(seqLati, 4*sizeof(int));

è quella che potrebbe non andare... non lo so, per me significa che ogni volta che è entrato nel ciclo (e quindi ho ancora dei punti da leggere), preparo un nuovo spazio per 4 int... non si fa così?

No, non si fa così, devi dirli sempre di allocare spazio per n*sizeof(int) elementi, dove n è il numero che ti interessa (e che devi incrementare ad ogni ciclo).

Originariamente inviato da d0c1Le.Killah

P.S.:Sì, uso malloc ormai per principio, perchè voglio capire dove sta l'errore, poi magari lo converto in new e delete...

Se devi usare realloc() non mischiare le cose e a tal punto metti anche la calloc().

[DanieleC88]

Originariamente inviato da d0c1Le.Killah

La riga:

seqLati[i] = (int *)realloc(seqLati, 4*sizeof(int));

è quella che potrebbe non andare...

Dimenticavo, prima, oltre al fatto che realloc() non alloca ogni volta nuovi spazi (e quindi devi dirgli tu ogni volta la dimensione totale cercata), stai anche riallocando seqLati e assegni il tutto a seqLati[i], stai introducendo un memory leak.

[Noixe]

Credo sia:

seqLati[i] = (int *)calloc(4*sizeof(int));

Ciao

[d0c1Le.Killah]

Ciao.
Anche scrivendo

seqLati[i] = (int *)calloc(4*sizeof(int));

ho lo stesso errore allo stesso punto... maledette matrici!

[d0c1Le.Killah]

Ciò che mi lascia completamente inerme, è che ho il seguente output (ho sostituito la realloc con la calloc, seguendo il precedente consiglio):

1
21
22
0
Reallocato
0 e 0 e 0
2
22
23
0
Reallocato
0 e 0 e 0
3
23
24
0
Reallocato
0 e 0 e 0
4
24
25
0
Reallocato
0 e 0 e 0
5
25
26
0
Reallocato
0 e 0 e 0
6
26
27
0
Reallocato
0 e 0 e 0
7
27
28
0
Reallocato
0 e 0 e 0
8
28
29
0
Reallocato
0 e 0 e 0
9
29
30
0
Reallocato
0 e 0 e 01
10
30
31
Reallocato

Come dire, la memoria per il prossimo vettore è allocata (e pulita, per via di calloc).
Dopo un po' va in crash, sebbene sia riuscito comunque ad allocare la memoria...
Se qualcuno volesse gentilmente testare il codice, per farlo funzionare basta dichiarare insieme alla matrice:

	int i1, i2, j1, j2; //indici per calcolare gli intervalli
		j2 = 0;

[Noixe]

prova a commentare le righe in cui appare seqLati, precisamente:

seqLati[i][j]= (int)x;
cout << seqLati[i][j] << endl;


seqLati[i] = (int *)realloc(seqLati, 4*sizeof(int));
if ( seqLati[i] == NULL )

Noterai che entra in un ciclo infinito senza bloccarsi perché non accedi a locazioni non valide. Vuol dire che la memoria puntata da seqLati[i] ad un certo punto non e' stata piu allocata.

Ho provato a tracciare l'output come te e si blocca dopo aver letto l'ultimo.

[d0c1Le.Killah]

Ciao a tutti...
ho risolto!
In pratica sbagliavo l'allocazione dinamica... forse il codice sarà più esplicativo:

	int i = 0;
	int j = 0;
	for(i1 = 0; i1 < coordinatefield.size();) {
		i2 = coordinatefield.find(",",i1);
		temp = coordinatefield.substr(i1,i2-i1);
		i1 = i2+1;
		j2 = 0;
		for(j1 = 0; j1 < temp.size();){
			j = 0;
			while(j2 != -1){
				if(temp.find(" ",j1)== NULL)
					j1++;
				else {
					float x;
					j2 = temp.find(" ",j1);
					temp2 = temp.substr(j1, j2-j1);
					x = atoi(temp2.c_str());
					seqLati[i][j]= x;
					//cout << seqLati[i][j] << endl;
					j++;
					j1 = j2+1;
				}
				if (j2 == -1)
				j1 = temp.size();
			}
		}	
		i++;
		seqLati = (int**)realloc(seqLati,(i+1)*sizeof(int*));
		seqLati[i] = (int *)calloc(4,sizeof(int));
			if ( seqLati[i] == NULL )
				cout << ( "Memoria disponibile insufficiente\n" );
			cout << "Reallocato" << endl;
	}

In realtà a questo punto (ormai era diventata una questione di principio), posso più semplicemente fare un for in cui conto il numero di righe, e poi utilizzo la classica calloc... anche perchè il file lo leggo di getto, non sto di certo gestendo dei messaggi che arrivano in dinamico... tra l'alrto mi diventerebbe più leggibile. Mi chiedo solo se la realloc non mi vada ad azzerare il lavoro precedente, ma ho provato a stampare tutto e non ho trovato zeri... (daltronde in tal caso la realloc non servirebbe a niente)
Era il mio primo post qui. Vorrei ringraziarvi in quanto ho subito trovato un sacco di gente pronta ad aiutarmi...

[DanieleC88]

Originariamente inviato da d0c1Le.Killah

Ciao a tutti...
ho risolto!
In pratica sbagliavo l'allocazione dinamica... forse il codice sarà più esplicativo:
[...]

Bravo, era proprio lì che volevo farti arrivare.

Originariamente inviato da d0c1Le.Killah

In realtà a questo punto (ormai era diventata una questione di principio), posso più semplicemente fare un for in cui conto il numero di righe, e poi utilizzo la classica calloc...

Ci sono tanti metodi, ma io se possibile questo lo eviterei perché implica che dovrai analizzare per due volte l'intero contenuto della stringa, quando puoi farlo una sola volta. Per piccole stringhe non è un problema, ma se ti dovesse arrivare qualcosa di grosso ti ci vorrebbe molto più tempo.

Originariamente inviato da d0c1Le.Killah

Mi chiedo solo se la realloc non mi vada ad azzerare il lavoro precedente, ma ho provato a stampare tutto e non ho trovato zeri... (daltronde in tal caso la realloc non servirebbe a niente)

No, per l'appunto, la tua memoria è preservata così com'era. Però devi fare attenzione quando usi realloc() e tutte le funzioni di allocazione dinamica della memoria: in alcuni casi (rari, ma possibili) l'allocazione può fallire, e tali funzioni restituirebbero NULL. Quindi, semplicemente assegnandolo, perderesti il vecchio puntatore e non potresti più liberare quella memoria (memory leak ).
Magari puoi aggirarlo:

void *pTemp;

pTemp = (void *) realloc(pMatrice, n * sizeof(T));
if (pTemp == NULL)
{
    printf("Errore\n");
    free(pMatrice);
    exit(EXIT_FAILURE);
}

pMatrice = pTemp;

Liberando ovviamente anche il resto della memoria finora utilizzata, se necessario (qui ho messo pMatrice solo come esempio).

[d0c1Le.Killah]

Grazie per i consigli..
per carità, purtroppo a scovare i problemi di persona ci sono abituato, semplicemente non avevo mai avuto la necessità di fare quest'operazione e le guide che ho trovato comunque ricavavano la dimensione all'inizio, cosa che io non potevo e volevo fare... per questo ho deciso di postare...
in ogni caso grazie ancora!!!