Newsgroup: it.comp.lang.c
Titolo: Dopo la funzione l'array cambia valore

Ciao a tutti, come mai in questa porzione di codice, l'array stampato 
dalla funzione mi da' i valori giusti mentre tornando al main() questi 
valori cambiano?
Se invece alloco la memoria dell'array dinamicamente nel main() i valori 
stampati coincidono.
	ciao e grazie, rz.
---CODICE---
int fetch_cmd( char*  cmd_line ){
int i;
   for( i=0; i<COMMANDCHARS; i++){
     *(cmd_line+i) = getchar();
     if( (int)*(cmd_line+i)=='\n' ){
        *(cmd_line+i)='\0';
        break;
     }
   }
printf("\n%c%c%c%c%c%c", *cmd_line, *(cmd_line+1), *(cmd_line+2), 
*(cmd_line+3), *(cmd_line+4), *(cmd_line+5));
/* stampa correttamente quello che ho inserito da tastiera */
return i;
}
int main( int argc, char** argv ){
char* cmd_line[COMMANDCHARS];
   while( 1 ){
      prnt_prompt();                            /* stampa il prompt */
      fflush(stdout);
      i = fetch_cmd( cmd_line ); /* memorizza il comando impartito da 
stdin e ritorna il #char letti senza contare '/n' */
      printf("\n%c%c%c%c%c%c", *cmd_line, *(cmd_line+1), *(cmd_line+2), 
*(cmd_line+3), *(cmd_line+4), *(cmd_line+5));
      exit(0);
/* qui i valori stampati non sono i medesimi di prima */
return 0;
}
-------


i è stato dimenticato in fase di copia&incolla ma nel mio codice c'è.
Anche altre parti di codice sono state rimosse perchè non credo 
influenzino questo aspetto del programma.
	ciao, rz.

 return 0;
Perche' usi sia la exit() che la return? Forse perche' il compilatore dice
che main deve ritornare un int? Togli la exit(), non serve: nel main, la
return equivale alla exit.
Un'altro piccolo appunto... non capisco perche' ti ostini ad usare
l'aritmetica dei puntatori quando accedi agli array. D'accordo che il
C la offre, che e` potente e pure sborona, ma, a mio modestissimo avviso,
   cmd_line[i]
e` un po' piu` leggibile di
   *(cmd_line + i)
e meno error prone, visto che se ti scordi l'asterisco sei fregato.
Poi fai come vuoi, ma io trovo che abusare dell'aritmetica dei puntori
non sia un bene. Non e` nemmeno giustificata da questioni di efficienza:
il compilatore dovrebbe tradurre le due cose esattamente nello stesso
codice; a volte, pero`, la notazione cmd_line[i] puo` aiutare il
compilatore a capire cosa stai cercando di fare (e` meno generica di
*(cmd_line + i)) e questo puo` portare a un codice migliore.
Saluti,
Marco
-- 
To email me, remove the no_ and _spam from my address.

 /* qui i valori stampati non sono i medesimi di prima */
Perche` qui` cmdline e` un array di puntatori.
(cmd_line + 1) nel main e` *diverso* da (cmd_line + 1) all'interno di
fetch_cmd, perche` i puntatori in gioco sono diversi.
All'intero di main viene calcolato un offeset pari sizeof(char *)
(tipicamente 4 byte), mentre all'interno di fetch_cmd l'offset e` di un
byte solo (sizeof(char) == 1)).
Luca
-- 
Home: 
http://kronoz.cjb.net
Io mi ricordo sempre il compleanno della mia ragazza:
cade il giorno dopo di quando lei me lo ricorda

 
		ciao e grazie, rz
-- 
http://mrzac.altervista.org

 Luca


[...]
Il K&R afferma che a[i] viene tradotto in *(a + i) dal compilatore e che
quindi le due forme sono identiche.
Sulla questione dell'efficienza mi sorge quindi il dubbio... quasi quasi
faccio qualche prova.
Cmq, io preferisco usare la notazione array quando voglio sottolineare
la natura di array della variabile... scelta del tutto opinabile,
ovviamente :)


 come la exit().
Chiedo venia ho sbagliato io... la exit() sta in un ciclo, ma mancando
nel codice che hai messo la parentesi che chiude il ciclo, mi sono
lasciato ingannare e ho pensato che exit() e return stessero entrambe
fuori dal ciclo e una dopo l'altra.
Scusate, ancora


 
		ciao, rz
-- 
http://mrzac.altervista.org