Newsgroup: it.comp.lang.c
Titolo: Il valore '\0'

Ciao a tutti!
Il seguente programma mi chiede una parola e poi la scrive al contrario!
--------------------------------------------------------------------------
#include <stdio.h>
#define max 200
char str[max], pali[max];
main()
{
        int i, j;
        printf("Inserisci una parola:\t");
        scanf("%s", str);
 
        for(i=0;str[i]!='\0' && i<max;i++)
                ;
 
        for(j=0;i>=0 && j<max;i--,j++)
                pali[j]=str[i-1];
        pali[j]='\0';           
 
                printf("%s\n%s\n", str, pali);  
 
}
---------------------------------------------------------------------------
Ho notato una cosa.L'assegnamento del valore '\0' a pali[j] secondo la
logica dovrebbe essere necessario e invece non lo è!
Infatti il programma funziona sia con sia senza l'assegnamento del valore
'\0'.Qualcuno può spiegarmi perchè?
Come interpreta questa situazione il compilatore? Io uso GCC su Linux!
Grazie a chi avrà la pazienza di rispondermi!   ^__^

 Grazie a chi avrà la pazienza di rispondermi!   ^__^
Nel _tuo ambiente_ funziona anche senza. Perche', come e' molto 
probabile, quella zona di memoria e' inizializzata a zero, e quindi, 
dato che '\0' == 0, il risultato e' che nulla cambia. Ma non e' detto 
che sia sempre cosi': se vuoi scrivere un programma che funzioni sempre, 
lo '\0' lo devi inserire.
-- 
Mat/tia Belletti - Undergraduate student @ 
cs.unibo.it
ICQ: 33292311    - email: 
mbel...@cs.unibo.it
IRC: RedGlow     - site(s): 
http://mbellett.web.cs.unibo.it/
Jabber: RedGlow  - Linux registered user 299762 @ machine 213003

 logica dovrebbe essere necessario e invece non lo è!
Le variabili globali (e quelle static) vengono inizializzate a zero dal
compilatore. Se str e pali fossero locali a main() il risultato sarebbe
diverso.
Luca
-- 
Home: 
http://kronoz.cjb.net
You and me baby ain't nothin' but mammals
So let's do it like they do on the Discovery Channel

#include <stdio.h>
#define max 200
char str[max], pali[max];
main()
{
        int i, j;
        printf("Inserisci una parola:\t");
        fgets(str, max, stdin);
 
        for(i=0;str[i]!='\0' && i<max;i++)
                ;
 
        for(j=0;i>=0 && j<max;i--,j++)  
                pali[j]=str[i-1];
        pali[j]='\0';           
 
                printf("%s%s\n", str, pali);    
 
}
Come faccio a evitare j ?
Mi sembra agevole.E poi cos'è un buffer overflow e cosa succede se non
scrivo "return 0;" alla fine ?
Scusa ma mi sono avvicinato alla programmazione da appena un mese!
Il C è il primo linguaggio che imparo ed mi fa arrapare un casino!
Grazie dei consigli che mi hai dato e degli eventuali preziosi chiarimenti e
Futuri!  ^__^        Ciauz!  

 lo '\0' lo devi inserire.
Lo standard prevede esplicitamente che le variabili statiche (e quindi 
quelle di classe extern) siano inizializzate prima che il programma 
inizi. Non prevede a quale valore ma tutti (o no ?) i compilatori 
inizializzano a zero.  In questo senso e' relativamente sicuro presumere 
che una var. globale non inizializzata esplicitamente sia zero. Concordo 
sulla maggior sicurezza di un' inizializzazione esplicita. Anche perche' 
cosi' si prende una buona abitudine e non si rischia di lasciare non 
inizializzate variabli automatiche (e li' sono dolori...).
Giorgio


wrote:
[CUT]
Puoi evitare sia l'indice che il secondo array, potresti agire in
questo modo:
- Leggi la parola
- Parti dall'ultimo carattere immesso valido e fai un ciclo a tornare
indietro.
così hai 2 piccioni con una fava :)

 Anche perche' cosi' si prende una buona abitudine
Dipende. Scrivere:
int a = 0;
al posto di:
int a;
puo` generare del codice sub-ottimale (stiamo parlando ovviamente di
variabili globali). Gli eseguibili ELF, ad esempio, hanno un'apposita
sezione (BSS) per le variabili globali non inizializzate; tutte queste
variabili finiscono in una (o piu`) pagine azzerate automaticamente.
Se viene fornito un'inizializzatore esplicito, anche se uguale a quello
implicito, il compilatore deve emettere il codice per
quell'assegnamento. Un buon modo per essere cazziati sulla lkml e`
mandare patch con variabili globali inizializzate esplicitamente ;)
Come ho detto sopra dipende tutto dall'ambito in cui si lavora, poi sono
daccordo che per chi e` alle prime armi l'inizializzazione esplicita
puo` risultare piu` chiara.
Luca
-- 
Home: 
http://kronoz.cjb.net
This message will self destruct in 5 seconds.

 mandare patch con variabili globali inizializzate esplicitamente ;)
Questo non lo capisco completamente. So bene che il compilatore  genera 
il codice per riservare memoria nella BSS ed azzerare i dati. Ma quello 
che non fa il compilatore, lo deve fare il loader (nel caso in cui 
manchi l'inizializzazione di una var. globale).  Dove sta quindi il 
problema di efficienza ? Non in termini di tempo di caricamento + 
esecuzione. A me sembra solo in termini di lunghezza dell' eseguibile 
(ma, a meno di un programmatore che utilizzi un numero esorbitante di 
var. globali non me ne farei un problema).
Sto trascurando qualcosa ?
Giorgio

 var. globali non me ne farei un problema).
La differenza sta solo nella minor dimensione dell'eseguibile. Come ho
detto dipende tutto dal contesto: a livello di kernel ha senso, a
livello di normali applicazioni diventa piu` che altro una questione di
gusti.
Luca
-- 
Home: 
http://kronoz.cjb.net
#include <stdio.h> 
int main(void) {printf("\t\t\b\b\b\b\b\b");
printf("\t\t\b\b\b\b\b\b");return 0;}