Newsgroup: it.comp.lang.c
Titolo: Ormai la follia è vicina

e più veloce
i=i+j
oppure
i+=j
Inoltre è corretto il return?
void pippo(){
......
if (x<y) return
else
    printf("aaa");
a=b;
b=c;
}
Insomma è corretto il return su una funzione void per uscire dalla funzione
quando si esegue quel ramo di if?

 if (x<y) return
Sì, è corretto, però sarebbe bene che le funzioni avessero un unico punto
di uscita (alla fine).  Sel atua funzione deve compiere operazioni che
possono andare o meno a buon fine, è bene che tu le faccia restituire un
int (tipicamente 0=errore, 1=successo), cosicché il chiamante possa
testare che cosa è successo.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 testare che cosa è successo.
Non è il mio caso. Il fatto è che l'if in questione è in un for e quindi con
il return uscirei immediatamente.
Però pensandoci in luogo di:
  for(i=1; i<=n; i++){
    if((*nrcl)==0) return 0; /* se la rcl è vuota ritorna  */
        etc....
Potrei scrivere:
 for(i=1; (i<=n && *nrcl!=0); i++){
      etc.
Sarebbe meglio, vero?

 i+=j
E' meglio che ti fidi del tuo compilatore
(caso mai ti studi le diverse opzioni di ottimizzazione)
Il compilatore e' in grado di fare ottimizzazioni che
tu neanche ti immagini, anche perche' non ottimizza
istruzione per istruzione ma anche piu' istruzioni
insieme.
per esempio se scrivi
for (i=0; i<3; i++) A[i]=B[i]+C[i];
probabilmente si accorge che il for fa sempre 3
cicli e lo svolge scrivendo
A[0]=B[0]+C[0];
A[1]=B[1]+C[1];
A[2]=B[2]+C[2];
i=3;
se poi si accorge che il valore della i all'uscita del ciclo
non viene mai riutilizzato (come spesso accade) la i=3;
non la esegue o addirittura la variabile i scompare del tutto
dal programma. etc.etc.etc.
A meno di codici ipercritici di solito non ha molto
senso cercare di battere il compilatore sulle
ottimizzazioni di basso livello.
Quello che ha senso e' considerare l'algoritmo
a livello globale e vedere se per caso
non esiste un algoritmo alternativo piu' performante.
ciao,
g.

 il return uscirei immediatamente.
Sicuramente testare il valore d'uscita nella condizione del for č la via
piů pulita.


 testare che cosa è successo.
Mi intrometto per una banalita': quando una funzione ha avuto successo 
_dovrebbe_ (il dovrebbe ovviamente e' soggettivo) ritornare 0 o 1???
vedo molti che come dice Andrea ritornano 1 se la funzione ha avuto 
successo, ma il main fa diversamente: ritorna 0 se e' andato tutto bene... 
Non esiste uno "standard" anche per il valore di ritorno? E' forse piu' un 
modo standard di operare piuttosto che uno standard di fatto...
grazie e scusate l'off-tread
Dade

 ha scritto nel messaggio
news:42bac...@x-privat.org...

Io restituisco sempre 0 se tutto ok, 1 altrimenti. Se poi possono esserci
diverse cause di errore restituisco 1,2, etc, indicando in documentazione la
codifica del tipo di errore.
Ciao

 _dovrebbe_ (il dovrebbe ovviamente e' soggettivo) ritornare 0 o 1???
Questione di convenzioni (dipende se leggi il risultato come "successo" o
come "presenza di errori").  Io uso sempre 1 per il successo e 0 per
l'errore, perché mi sembra molto più intuitivo scrivere:
if (func()) ... 
che non:
if (!func()) ...
per testare la buona riuscita.
Mi ha sempre fatto storcere il naso, ad esempio, il risultato di strcmp(),
perché scrivere:
if (!strcmp(a,b))...
mi lascia più pensare a una differenza tra a e b che ad un'eguaglianza.
In ogni caso, il valore di ritorno di main() viene mappato, generalmente,
sul valore interpretato dal sistema operativo (ad esempio, con DOS/Windows
è l'errorlevel che è possibile testare nei batch, 0 indica mancanza di
errori e quindi successo).


 Io restituisco sempre 0 se tutto ok, 1 altrimenti. 
Può andare bene, ma mi raccomando a mantenere la coerenza.
Coerenza significa anche decidere che il valore di ritorno di una funzione
sia sempre l'indicazione di errore.  Se scrivi una funzione di allocazione
della memoria e lasci che restituisca il puntatore allocato, devi
necessariamente invertire la regola.  Un valore di ritorno != 0, in questo
caso, significa presenza di informazione e quindi successo.  Gli
sviluppatori delle API di Windows, ad esempio, hanno mischiato le due cose
e ti lascio immaginare la confusione che può venirne fuori (vabbé, loro
hanno anche mischiato funzioni che restituiscono 0 per successo a quelle
che restituiscono 1)...


 Mi ha sempre fatto storcere il naso, ad esempio, il risultato di strcmp()
Anche a me.
Anche se capisco che in questo caso il fatto e' voluto perche'
la strcmp in realta' non testa la mera uguaglianza, ma se una
stringa viene prima o dopo in ordine alfabetico e quindi puo'
restituire un valore positivo, negativo o nullo.
Quindi ad esempio si puo' usare direttamente la strcmp() in
una routine di confronto pensata per essere passata a qsort
per ordinare un array di stringhe.
ciao,
g

 restituire un valore positivo, negativo o nullo.
Si poteva fare ugualmente con una enum {} ;-)
