[C/C++] Gli errori che non esistono...

[Zero-Giulio]

Allora,

sono uno studente assolutamente non esperto con la programmazione. Vorrei esporvi il mio (ultimo, non certo il primo, sign) problema.

Allora...

Non so esattamente da dove incominciare per spiegarlo. Facciamo che vi parlo di quel che succede una volta avviato l'eseguibile.

Poi, qualsiasi informazione vorrete, ve la darò (naturalmente).

Anzi, partiamo da un piccolo frammento di codice.

GtG=(double **) malloc ((num_ker_nodes)*sizeof (double *));
if (GtG == NULL)
{
printf ("\nError: no memory available for GtG matrix.\n");
return 0;
}
for (i=0; i<num_ker_nodes; i++)
{
GtG [i]=(double *) malloc ((i+1)*sizeof (double));
if (GtG [i] == NULL)
{
printf ("\nError: no memory available for GtG matrix (row %ld).\n", i);
return 0;
}
}

nulla di che, come potete vedere. Alloco una matrice triangolare. Ne ho allocate almeno una 50-ina in tutto il programma; tutte sempre nello stesso modo.

Cmq, il programma mi da un errore, come dicevo.

Ricorda gli errori che da Windows quando tenti di accedere a una zona in memoria non consentita: con la finestra di segnalazione errori di windows.

Il tipico errore che succede quando, per esempio, un puntatore viene incrementato fin oltre i limiti di un vettore, per intenderci; parte la segnalazione errori, e poi il programma si chiude.

Qui però è particolare: parte la segnalazioni errori, ma il programma poi non si chiude, va come in standby: il cursore lampeggia per un pò (senza che il programma vada avanti, non vengono fatti altri calcoli dopo il frammento di codice che ho scritto) e solo dopo una decina di secondi il programma si chiude.

Che strano, intanto...

Poi, altra stranezza.

Modifichiamo il codice di prima in questo modo

GtG=(double **) malloc ((num_ker_nodes)*sizeof (double *));
if (GtG == NULL)
{
printf ("\nError: no memory available for GtG matrix.\n");
return 0;
}
//system ("PAUSE");
for (i=0; i<num_ker_nodes; i++)
{
GtG [i]=(double *) malloc ((i+1)*sizeof (double));
if (GtG [i] == NULL)
{
printf ("\nError: no memory available for GtG matrix (row %ld).\n", i);
return 0;
}
}

Sembra io non abbia fatto niente. Ho solo messo una pausa tra l'allocazione delle righe e quella delle colonne.

Miracolo! Il programma funziona!

Non da errore. Non solo, tutto il resto continua correttamente e il programma termina con tutti i risultati corretti.

Che cavolo succede? Perchè questo comportamento ambiguo?

Linux dice di più. Se compilo il codice in Linux, ricevo questo errore prima che il programma termini

*** glibc detected *** ./magneto-statics: free (): invalid next size (fast): 0x09c81158 ***

Poi il msg continua col Backtrace e col Memory map.

Non so leggere quelle cose.

Una idea potrebbe essere che la colpa è di qualche free fatta in precedenza, se non altro perchè leggo free nel testo del msg di errore.

Vediamo cosa sucecde se stampo i %p di tutte le matrici che alloco, dall'inizio del programma fino alla GtG (l'ultima prima dell'errore). In sostanza, se faccio questo:

M=(double **) malloc (n*sizeof (double *));
for (i=0; i<n; i++)
printf ("%p ", M [i]);

Con tutte le precedenti matrici trovo sempre zeri in tutte le posizioni (tranne, a volte, un paio di elementi non nulli), che penso stiano a indicare che lo spazio è/era libero, mentre con L GtG trovo TUTTI i valori strani (stringhe alfanumeriche). Mi viene da pensare che sia quindi spazio usato prima e poi da me liberato con la free ().

Inoltre, stampare i %p ha lo stesso effetto della system ("PAUSE").

Praticamnete, se stampo i %p della GtG, poi non ho errore (anche senza mettere la system ("PAUSE")).

Se invece non metto la system ("PAUSE"), e stampo cose diverse (tipo, for i=1:10 printf ("ciao")), allora l'errore si presenta lo stesso.

Capite adesso che razza di errore strano ho?

Ah, a scanso di equivoci. Tutti queste esperienze sono sistematiche. Son due pomeriggio che faccio girare il rpogramma. Succedono sempre le stesse cose (con la system ("PAUSE") va, senza no, ecc...).

Non riesco a capire.

Sarei motlo grato a chiunque riuscisse a darmi qualche dritta. io non so che pesci pigliare.

Ultimo, compilo con Code::Blocks (sia Windows, che Linux).

[fero86]

audace!
in C++ non si usano malloc e free, si usano new e delete

[ytsejam32]

Originariamente inviato da Zero-Giulio

Allora,


Che cavolo succede? Perchè questo comportamento ambiguo?

Linux dice di più. Se compilo il codice in Linux, ricevo questo errore prima che il programma termini

Poi il msg continua col Backtrace e col Memory map.

Non so leggere quelle cose.

Una idea potrebbe essere che la colpa è di qualche free fatta in precedenza, se non altro perchè leggo free nel testo del msg di errore.

Puo' darsi che in un'altra parte del programma tu abbia scritto oltre il buffer allocato, corrompendo una zona di memoria riservata all'allocatore. Quando chiami la free, l'allocatore legge quei dati e si incasina.
Su linux potresti provare ad usare valgrind, in questo modo:

valgrind --tool=memcheck ./tuo_programma

per cercare di scoprire errori di gestione della memoria allocata.

Ciao

[Zero-Giulio]

audace!
in C++ non si usano malloc e free, si usano new e delete

Lo so. Il mio codice è tutto in C (a parte i commenti, per i quali uso il //).

Cmq...

Ma che figata è Valgrind?!?

Cioè, mi trova gli errori di memoria (e non solo, da quel poco che ho letto)?!?

Sono assolutamente niubbo, non conoscevo Valgrind et annessi, non sapevo come usarli.

Ma...

Ma son bastati due minuti sul sito e questo

valgrind --tool=memcheck ./tuo_programma

e HO TROVATO l'errore!

C'era un indice che scappava fuori dal vettore, as usual.

Problema facile da trovare direte voi. Il punto è che sbagliavo in un punto del codice, ma poi l'errore me lo dava anni luce più avanti. Da quando chiedevo al puntatore di andare a leggere dove non poteva a quando crashava passava del tempo (e migliaia di istruzioni che venivano eseguite correttamente!).

Chissà perchè poi... Di errori con gli indici dei puntatori ne ho avuti a bizzeffe da quando ho cominciato a scrivere il programma, e li ho sempre risolti in due secondi giacchè windows mi avvisava all'istante. Qui invece, il sintomo si manifestava con ritardo.

Eh... La gestione della memoria. Brutta bestia per gli sprovveduti come me.

D'ora in poi farò sempre una passata con Valgrind. Troppo super come tool. Lode e onore a chi lo ha creato.

Ah, e mille grazie a chi me lo ha consigliato, of course. ;-)

PS: resterebbe da capire perchè la system ("PAUSE") "metteva a posto tutto". Diamine, quel comportamento strano mi ha messo un pò fuori strada. Io pensavo fosse chissà cosa. Certo che a volte i programmi son proprio strani...