gcc e quesito importante

Sari · Messaggio da **Sari** » gio 5 mag 2005, 18:53

spesso e volentieri o a che fare con questo linguaggio (ogni giorno per
 ore

), e con il compilatore gcc della mia slackware 10.1. 
 Oggi mi e´ capitata una cosa molto strana e ora ve la spiego. 
 
 Ho una struttura di questo genere 
 
 typedef struct char_data CHAR_DATA; 
 
 struct char_data 
 { 
 CHAR_DATA * next; 
 CHAR_DATA * prev; 
 CHAR_DATA * next_in_room; 
 CHAR_DATA * prev_in_room; 
 CHAR_DATA * master; 
 CHAR_DATA * leader; 
 FIGHT_DATA * fighting; 
 CHAR_DATA * reply; 
 CHAR_DATA * retell; 
 CHAR_DATA * switched; 
 CHAR_DATA * mount; 
 HHF_DATA * hunting; 
 HHF_DATA * fearing; 
 HHF_DATA * hating; 
 SPEC_FUN * spec_fun; 
 MPROG_ACT_LIST * mpact; 
 int mpactnum; 
 sh_int mpscriptpos; 
 MOB_INDEX_DATA * pIndexData; 
 int mob_editor; 
 DESCRIPTOR_DATA * desc; 
 AFFECT_DATA * first_affect; 
 AFFECT_DATA * last_affect; 
 NOTE_DATA * pnote; 
 NOTE_DATA * comments; 
 OBJ_DATA * first_carrying; 
 OBJ_DATA * last_carrying; 
 ROOM_INDEX_DATA * in_room; 
 ROOM_INDEX_DATA * was_in_room; 
 PC_DATA * pcdata; 
 DO_FUN * last_cmd; 
 DO_FUN * prev_cmd; /* mapping */ 
 void * dest_buf; /* This one is to assign to differen things */ 
 
 eccetera eccetera eccetera

sh_int count; 
 
 }; 
 
 dove sh_int e´ uno short int giustamente definito. 
 
 
 ed ora il bello 
 
 - Dichiaro e riempio una struttura di CHAR_DATA 
 - ne tiro fuori uno con un ciclo for 
 
 CHAR_DATA *ch; 
 CHAR_DATA *ch_next; 
 
 for ( ch = first_char; ch; ch = ch_next ) 
 { 
 ch_next = ch->next; 
 
 
 
 /* all´interno di una funzione ho questo if */ 
 
 if ( ---ch->count <= 0 ) 
 
 { 
 
 /* blblbl */ 
 
 } 
 
 } 
 
 
 quel --ch->count dovrebbe decrementarmi il contatore count, elemento della struttura ch ? 
 quell´if e´ equivalente a if ( ( ( ch->count -= 1 ) + 1 ) <= 0 ) ? 
 
 quel --ch->count, seguendo con vari metodi il codice, va a
 decrementare tutt´altro che ch->count

decrementa un´altro
 elemento intero ( non short int ) di un´altro elemento della struttura
 CHAR_DATA, cioe´ un macello

. 
 Il fatto e´ che per il gcc quelle due forme sono equivalenti (un
 semplice make non va a ricreare il file .o dal sorgente .c )....
 provare per credere. 
 Qualcuno mi spiega il motivo?

Messaggio da **useless** » gio 5 mag 2005, 21:15

if ( ---ch->count <= 0 )
 
 nota che hai scritto 3 meno (---). è solo un errore di trascrizione? eventualmente prova anche a usare un po´ di parentesi: --(ch -> count); se non altro è + leggibile

.

Sari · Messaggio da **Sari** » gio 5 mag 2005, 22:15

sisi errore di trascrizione

rob · Messaggio da **rob** » ven 6 mag 2005, 0:14

prova ch->count -= 1 
 
 ciao, rob

Sari · Messaggio da **Sari** » ven 6 mag 2005, 7:54

si lo so che con ch->count -= 1 funziona tutto, ma perche´ il gcc mi
 deve riconoscere entrambe le forme (quella sbagliata e quella giusta)
 come uguali?

Messaggio da **useless** » ven 6 mag 2005, 9:36

<TABLE BORDER=0 ALIGN=CENTER WIDTH=85%><TR><TD>Quote:<HR></TD></TR><TR><TD><BLOCKQUOTE>
 sukko@ccl10 ~ $ pico test.c
 #include <stdio.h>
 
 typedef struct test_s {
 short int sint;
 } test;
 
 int main (void) {
 test *t;
 
 t = (test *) malloc (sizeof (test));
 t -> sint = 99;
 printf ("Ora t -> sint vale %d\n", t -> sint);
 --t -> sint;
 printf ("Dopo il decremento t -> sint vale %d\n", t -> sint);
 
 free (t);
 return (0);
 }
 
 sukko@ccl10 ~ $ gcc test.c
 sukko@ccl10 ~ $ ./a.out
 Ora t -> sint vale 99
 Dopo il decremento t -> sint vale 98
 </BLOCKQUOTE></TD></TR><TR><TD><HR></TD></TR></TABLE>
 
 non capisco dove sia il problema!

rob · Messaggio da **rob** » ven 6 mag 2005, 9:44

azz, scusa ma non avevo visto che nel primo post già avevi provato con ch->count -= 1. 
 sinceramente non so perchè hai quel comportamento, ma ho provato con il
 suggerimento di useless e (ovviamente

funziona. funziona anche
 ch->count--. 
 io l´if lo scriverei così: 
 if( ch->count-- ) { blablabla } 
 
 ciao, rob 
 
 edit: ooops, post (semi)contemporaneo 
 
 
 "L´esperto lo si riconosce dal fatto che contraddice il dilettante anche quando quest´ultimo ha ragione." [Theo Herbst]
 
 [ Questo Messaggio è stato Modificato da: rob il 06-05-2005 09:46 ]

Sari · Messaggio da **Sari** » sab 7 mag 2005, 14:30

mhm e´ da due giorni che provo a ricreare l´errore su un codice di
 prova ma nulla, eppure sul codice dove ho riscontrato questa stranezza,
 continua a rimanere. 
 A questo punto qualcuno ha una minima idea del perche´ possa succedere? 
 
 Il codice e´ piu´ o meno cosi´ (anche se mooolto piu´ complesso, ma il
 comportamento e´ quello classico di una lista concatenata). 
 Al codice sotto aggiungete solo, alla struttura, dei puntatori a liste
 concatenate di altro
 genere, nient´altro di sconvolgente

, ma il codice sotto funziona
 l´altro no... perchè? Dove potrei aver sbagliato? nel dispose magari?
 Insomma qualcosa manda a farsi friggere i miei puntatori

(( 
 
 Ovviamente ho arricchito solo il codice di useless della lista. 
 
 /* Link */ 
 #define LINK(link, first, last, next,
 prev)
 \ 
 do
 \ 
 {
 \ 
 if ( !(first) ) \ 
 {
 \ 
 (first) = (link); \ 
 (last) = (link); \ 
 }
 
 \ 
 
 else
 \ 
 (last)->next =
 (link); \ 
 (link)->next = 0;
 \ 
 if ((first) == (link))
 \ 
 (link)->prev = 0;
 \ 
 else
 \ 
 (link)->prev =
 (last); \ 
 (last) = (link);
 \ 
 } while(0) 
 
 
 typedef struct test_s TEST_S; 
 
 struct test_s { 
 TEST_S *next; 
 TEST_S *prev; 
 short int sint; 
 int sint_b; 
 }; 
 
 TEST_S *first_test = 0; 
 TEST_S *last_test = 0; 
 
 int main (void) { 
 
 TEST_S *t; 
 int i; 
 
 for ( i = 0 ; i < 10 ; i++ ) 
 { 
 
 TEST_S *tt; 
 
 tt = (TEST_S *) malloc (sizeof (TEST_S)); 
 tt->sint = 99; 
 tt->sint_b = i; 
 LINK(tt, first_test, last_test, next, prev); 
 
 } 
 
 for ( t = first_test; t; t = t->next ) 
 { 
 if (t->sint_b == 5) 
 { 
 printf ("Ora t->sint vale %d\n", t->sint); 
 --t->sint; 
 printf ("Dopo il decremento t->sint vale %d\n", t->sint); 
 } 
 } 
 
 for ( t = first_test; t; t = t->next ) 
 printf ("t->sint_b : %d t->sint %d\n", t->sint_b, t->sint); 
 
 return (0); 
 }