Newsgroup: it.comp.lang.c
Titolo: proceduralità!

Che brutto subject :-)!
Sto facendo un po' di esperimenti ed ho notato come il C sia un linguaggio
molto "elastico" e "libero". Questo però, credo, imponga la necessità di un
po' di disciplina.
Ad es,
questa:
------------------------------
#include <stdio.h>
int pippo(void)
{
     int ret;
     scanf("%d",&ret);
     return 0;
}
int main(void)
{
     printf("Ecco l'effetto della funzione seguente:\n    ");
     pippo();
     return 0;
}
int pippo(void);
-------------------------------,
e questa:
------------------------------
#include <stdio.h>
int pippo(void);
int main(void)
{
     printf("Ecco l'effetto della funzione seguente:\n    ");
     pippo();
     return 0;
}
int pippo(void)
{
     int ret;
     scanf("%d",&ret);
     return 0;
}
-------------------------------,
funzionano entrambe, ma mi sembra più ordinata e logica la seconda. Insomma:
io ero abituato ad un certa proceduralità dei linguaggi e nel C, mentre la
trovo benissimo _dentro_ ogni singola funzione, la perdo di vista guardando
il listato nel suo complesso. E' come se ogni funzione fosse un "pezzo" a
sè... e non fosse importante l'ordine di questi pezzi. Ho trovato, finora,
solo una eccezione: gli #include vanno, comunque, messi sempre per primi:
----------
#include <stdio.h>
#include "pippo.h"
int main(void)
{
     printf("Ecco l'effetto della funzione seguente:  ");
     pippo();
     return 0;
}
int pippo(void)
{
     int ret;
     scanf("%d",&ret);
     return 0;
}
-----------------
in cui pippo.h contiene il prototipo di pippo().
Quello che vi chiedo è: gli standard, la consuetudine, ecc, dettano delle
regole sulla leggibilità dei sorgenti e sull'ordine in cui disporre le varie
funzioni e dichiarazioni?
Per ora sto seguendo queste due regole:
1) indentare di una tabulazione il corpo di ogni funzione (le istruzioni,
chiamate, ecc., contentute tra due graffe)
2) mettere una sola istruzione per riga
Pensavo di aggiungere una terza:
1) Ordine degli elementi di un listato:
- include
- dichiarazioni/prototipi
- main()
- altre funzioni in ordine logico di chiamata
Può andare??
Grazie

 Grazie
Direi che dovresti anche aggiungere:
1.5) Indentare con una tab anche il corpo di ifs, whiles, fors, ecc.
Anche se forse ci avevi giá pensato.
Quanto agli standards, non saprei con esattezza, ma credo non dicano
niente in proposito. Sono piú abitudini rafforzate da una voce
perentoria che esclama "Che schifo di codice!" che regole.
-- 
Adriano Varoli Piazza
The Inside Out: 
http://moranar.com.ar
MSN: 
adri...@hotmail.com
ICQ: 4410132

 - altre funzioni in ordine logico di chiamata


addirittura perche` c'e` un certo statement.
Certo, condivido e comprendo perfettamente. Anche adesso che sto solo
imparando le basi, metto commenti quasi ad ogni riga.
Grazie

 imparando le basi, metto commenti quasi ad ogni riga.
Melius abundare quam deficere, ma evita commenti inutili.
Un esempio di commento inutile è il seguente:
a = b; /* assegno ad a il valore di b */
I commenti servono, appunto, da "commento", ovvero spiegano che cosa fa
una parte del codice, quinid is rendolo utili laddove sia realmente
necessario "spiegare".
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 bisogno del prototipo.
Perfetto! Mi mancava questo "ultimo" tassello sull'argomento. Ora č tutto
chiarissimo. Ho fatto diverse prove per verificare la copmprensione di
quello che tu e gli altri mi avete scritto: tutto ok.
Grazie a tutti..
Alla prossima...

 "funzione" è un concetto "logico"??
No blocco, in genere, identifica il codice fra { ... }
Quindi anche il codice all'interno di un while o for, dopo if/else se ci 
sono le parentesi {} e` un blocco.
Per esempio:
while (1) {
#include "pippo.h"
	int rc = pippo();
	if (rc < 0) break;
}
Questo caso non e` molto significativo e non da` alcun vantaggio, ma se 
pippo() viene chiamata solo in quel punto il prototipo della funzione 
dichiarato in pippo.h ha validita` limitata solo all'interno del blocco.
Come e` possibile definire nuove variabili cosi` puoi mettere degli 
#include se questi hanno solo delle dichiarazioni.
