Segmentation Fault con strutture in linguaggio C

[francowr]

Ciao a tutti ragazzi,
ho il seguente problema. Se scrivo il seguente programma con C:

Codice: Seleziona tutto

#include <stdio.h>

main()
{
struct pap {int pippo;
           int pluto;
      union {
         long    * integer;
         char    * tizi;
         } val;
      };
      
struct pap *prova;
struct pap pp;

prova = &pp; // sono costretto ad inizializzarlo

prova->pluto=45;

*prova->val.integer=4;

printf ("Valore= %d\n", prova->pluto);

printf ("Valore= %ld\n", *prova->val.integer);

return 0;
}

In linux lo compilo e riesco pure a far girare l'esegubile poi.

nel seguente programma invece (che evolve dal precedente, ho scritto + a destra solo le righe che ho aggiunto):

Codice: Seleziona tutto

#include <stdio.h>

main()
{
struct pap {int pippo;
           int pluto;
      union {
         long    * integer;
         char    * tizi;
         } val;
      };

struct pap *prova;
struct pap pp;

                   struct pap *prova2;
                   struct pap pp2;

prova = &pp; // sono costretto ad inizializzarlo

prova->pluto=45;

*prova->val.integer=4;

printf ("Valore= %d\n", prova->pluto);

printf ("Valore= %ld\n", *prova->val.integer);

                   prova2 =&pp2;
                   *prova2->val.integer=3;
                   printf ("Valore= %ld\n", *prova2->val.integer);

return 0;
}

In questo caso lo compilo sempre ma l'eseguibile va in Segmentation fault; che cosa sbaglio???
GRAZIE!!!! CIAO

[francowr]

scusate ma nel secondo programma non si notano a destra le righe che ho aggiunto: ve le asterisco qui sotto

Codice: Seleziona tutto

#include <stdio.h>

main()
{
struct pap {int pippo;
           int pluto;
      union {
         long    * integer;
         char    * tizi;
         } val;
      };

struct pap *prova;
struct pap pp;

          ******          struct pap *prova2;
          ******        struct pap pp2;

prova = &pp; // sono costretto ad inizializzarlo

prova->pluto=45;

*prova->val.integer=4;

printf ("Valore= %d\n", prova->pluto);

printf ("Valore= %ld\n", *prova->val.integer);

                   ******     prova2 =&pp2;
                   ******       *prova2->val.integer=3;
                  ********     printf ("Valore= %ld\n", *prova2->val.integer);

return 0;
}

non capisco aggiungendo queste righe (che fanno la stessa cosa, sono identiche, a quello che fa i primo programma nelle altre righe poi...) che succede ...

[francowr]

Lo ho provato a compilare sotto windows e funziona... Forse il compilatore? Cosa mi consigliate???

[GAD]

union {
long * integer;
char * tizi;
} val;

Questi non sono inizializzati e sono puntatori, si possono generare una miriade di problemi.
Per fare le cose per bene dovresti fare

struct pap *prova;
struct pap pp;
pp.val.integer =(long*) malloc(sizeof(long));
pp.val.tizi=(char*)malloc(sizeof(char));
prova = &pp;
//.... fai quello che vuoi...
// prima di uscire dal prog fai
free(pp.val.integer);
free(pp.val.tizi)

Altrimenti per non usare la variabile statica pp che non serve ad una cippa visto che poi lavori di puntatore

struct pap *prova;
prova = (pap*) malloc(sizeof(pap));
prova ->val.integer =(long*) malloc(sizeof(long));
prova ->val.tizi=(char*)malloc(sizeof(char));

//.... fai quello che vuoi...
// prima di uscire dal prog fai
free(prova->val.integer);
free(prova->val.tizi)
free(prova)

[francowr]

Grazie! A esser sinceri a prima letta non mi è chiaro tutto, ma ora vedo, provo e sono sicuro che funzionerà!!!
ciao ciao

[GAD]

E' che long * integer; e char * tizi; sono due puntatori che non puntano a niente, non sono nemmeno inizializzati. Devi associrali a qualcosa che sia allocato in memoria, sia essa una variabile statica definita da te o un'allocazione dato lo stesso puntatore come ho fatto io con la malloc.
Se ci lavori sopra senza farlo vai in un'area di memoria non definita proprio perche' non essendo inizializzati puntano ad un area di memoria a caso di cui non si sa nemmeno la dimensione.
E' come dover mettere della roba in una scatola di cui non sai ne la grandezza ne dove si trova in questo momento. Prima trovi la scatola, poi decidi quanto deve essere grande e poi la riempi. Se parti a riempire senza aver definito quanto e' grossa e dove sta, i dati ti escono dalla dimensione che il compilatore alloca alla variabile e vanno a sovrascrivere aree che non dovevano toccare.

Es: statico

long ceppo=5;
prova->val.integer=&ceppo;

es. dinamico
prova->val.integer=(long*) malloc(sizeof(long));

[GAD]

ps: guarda questi link e cerca anche su google "c allocazione puntatori" e troverai un po' di spiegazioni piu' dettagliate
http://a2.pluto.it/a2497.htm
http://ada2.unipv.it/biblio/trickyc/08c.htm

[francowr]

Ti ringrazio, sei stato fin troppo cortese a spiegarmi il tutto. Ora penso di aver capito cmq! CIAO!!!!

[francowr]

Compilato con windows funziona tutto, una volta inclusa la libreria alloc.h!

Con linux (libreria malloc.h, ma come dice il link che mi hai incluso credo dipenda dal compilatore) devo escludere:

free(pp.val.integer);
free(pp.val.tizi)

Altrimenti mi da il seguente errore:


*** glibc detected *** double free or corruption (fasttop): 0x0804a018 ***
Aborted

Cmq funziona!!! Ora provo a vedere con il programma vero e proprio (quelloc he avevo riportato qui era solo un esempio per spiegare che tipo di problema avevo...)

Grazie ancora!!
CIAO

[BianConiglio]

non ho letto nulla, solo l'ultimo post..

devi fare free(pp) credo

ciau

[francowr]

Grazie! ora ci provo!
ciao