Newsgroup: it.comp.lang.c
Titolo: esercizio in c per principianti

ciao a tutti.
ho comprato un manuale di c e ho cominciato il mio studio.
alle volte però il manuale non si spiega bene, o come in questo caso, 
non si spiega affatto.
alla fine del 1° capitolo si propongono una serie di esercizi risolti.
tra questi, un breve programma per calcolare l'area del cerchio.
però questo programma introduce degli elementi di programmazione che non 
ha spiegato e io non lo capendo.
insomma, lo incollo e vi dico quali parti non mi sono chiare.
=============
/* programma per calcolare l'area del cerchio */
#include <stdio.h>
#define PI 3.14159
float process(float raggio);
main()
{
	float raggio, area;
 
	printf("Raggio = ? ");
	scanf("%f", &raggio);
	area = process(raggio);
	printf("Area = %f", area);
}
float process(float r)
{
	float a;
	a = PI * r * r;
	return(a);
}
=============
allora provo a scioglierlo come l'ho capito finora...
includi la libreria c per lo standard input/output.
definisci PI 3.14159, ovvero il valore del pigreco.
ecco qui non capisco, xché finora non ho mai visto variabili così (come 
avrete capito sono agli inizi).
cosa comanda <float process(float raggio);>?
ovvero capisco che è una funzione, che gli stiamo dicendo che è a 
virgola mobile e che la chiamiamo process; ma quella parentesi e di 
nuovo float e poi raggio non me lo spiego... :(
poi la funzione principale main
fin qui niente di strano, neanche nelle sue istruzioni di espressione, 
eccetto <area = process(raggio);> che non capisco...
qui dice che area, la funzione che prima abbiamo dichiarato a virgola 
mobile è uguale a process(raggio)...non capisco.
la parte finale mi è oscura assai e avvolta nel mistero.
lo so che la maggioranza degli iscritti qui queste cose deve averle 
masticate almeno 20 fa e che a vederle scritte come minimo gli viene un 
attacco di sonno se non di bile, ma potreste provare lo stesso a 
spiegarmi questo esercizio?
grazie e ri*ciao.
maurizio c.

 }
In conclusione, il programma stampa l'area del cerchio avente il raggio 
ricevuto in input.

 eccetto <area = process(raggio);> che non capisco...
Quella riga si interpreta come:
- chiama la funzione "process" con il parametro raggio (il fatto che il nome
che ha il parametro nel main sia uguale a quello della definizione della
funzione e' solo un caso)
- assegna il risultato della funzione "process" alla variabile "area"
Se hai altri dubbi (anche solo su questo post) chiedi :)
-- 
Mox
"Trust the programmer."
"Don't prevent the programmer from doing what needs to be done."
"Keep the language small and simple."
"Provide only one way to do an operation."

 Se hai altri dubbi (anche solo su questo post) chiedi :)
grazie moltizzime!
anke a enrico...
adesso mi rileggo con attenzione i vostri due post, ci sono molte 
informazioni utili.
oh, 'sto manuale l'ho pagato 31 skifosi euri ma ne vale 5.
va contro i principi della pedagogia introdurre un concetto e non 
spiegarlo. per non parlare della traduzione dall'inglese...
accidenti al commesso della feltrinelli che me lo ha consigliato e che 
sembrava capirne.
ciao * maurizio c.

 sembrava capirne.
Che libro e'?


 Che libro e'?
programmare in c, di byron s. gottfriend
seconda edizione, mcgraw-hill
isbn: 8838650489

 > float process(float raggio);
vediamo se ho capito quelle parti inerenti la funzione process().
allora *prima* la dichiaro facendole prendere un parametro float e 
facendole restituire un valore float che chiamo raggio.
 > area = process(raggio);
poi in una delle istruzioni di espressione di main() stabilisco che alla 
variabile area viene assegnato il valore restituito da process(), il cui 
parametro è il raggio ricevuto in input.
insomma questa parte del programma - la funzione main() - si occupa di 
gestire l'imput e l'output, mentre il calcolo viene affidato alla 
funzione process().
cioè, la logica è dividere i due momenti, quello strettamente legato 
all'interratività utente/macchina e quello del calcolo.
sbaglio???
 > float process(float r)
qua non capisco perché prima process() deve restituire raggio e poi qui r.
 > a = PI * r * r;
come fa qua il programma a sapere che l'input è uguale a r?
noi prima, tramite scanf in main() gli abbiamo detto che l'imput è da 
attribuire a raggio, non a r.
ciao * maurizio c.

  > float process(float r)
Facciamo un esempio completo. I numeri all'interno dei commenti sono i
riferimenti che usero' dopo per spiegare.
<code>
/* 1 */
float area_triangolo (float base, float altezza);
/* 2 */
float area_triangolo (float b, float a)
{
    return b * a / 2;
}
/* 3 */
int main (int argc, char *argv[])
{
    float area1, area2;
    float base_triangolo = 10;
    float altezza_triangolo = 5;
    /* BLA BLA BLA */
    area1 = area_triangolo(base_triangolo, altezza_triangolo);
    area2 = area_triangolo(12, 14);
    printf("%f", area1); /* stampa 25 */
    printf("%f", area2); /* stampa 84 */
    /* BLA BLA BLA */ 
}
</code>
1) Qui sta' dichiarando la funzione. Prima che in un qualunque pezzo di 
   codice tu possa usare una funzione la devi dichiarare (cosi' il 
   compilatore ne conosce il prototipo).
   In questa dichiarazione tu devi fornire: tipo di ritorno, nome della 
   funzione, tipo (nota, solo il tipo) dei parametri e opzionalmente un nome 
   fittizio per i parametri.
2) Definizione. Devi indicare tipo di ritorno, nome, parametri con relativo 
   nome (che poi saranno validi all'interno del codice della funzione) e 
   codice della funzione (tra parentesi graffe).
   Analizziamo brevemente il codice.
   La return e' una keyword e ritorna alla funzione chiamante il valore 
   dell'espressione alla sua destra.
   Es:
   return 10;         Ritorna al chiamante il valore 10.
   return 10+20;      Ritorna al chiamante il valore 30.
   Come sai l'area di un qualunque triangolo si calcola come base*altezza/2.
   La base e' un parametro della funzione, si chiama solo "b" ed e' di tipo 
   float, l'altezza si chiama "a" ed e' anch'esso un parametro di tipo 
   float.
3) Chiamata. Qui ti faccio vedere come avviene la chiamata. Puoi usare delle 
   variabili o delle costanti numeriche, il risultato non cambia.
   Quando fai una chiamata a funzione, i parametri con cui chiami la 
   funzione (per esempio nel main) vengono associati ai nomi simbolici che 
   hai dato nella DEFINIZIONE (quella del punto 2, non nella dichiarazione 
   del punto 1).
   I parametri sono copiati per valore, ovvero hai una copia dei valori con 
   cui hai chiamato la funzione.
   Cosa significa?
   Che se la funzione e' questa
   <code>
   int dimezza(int valore)
   {
       printf("valore = %d", valore);
       valore = valore / 2;
       printf("valore = %d", valore);
       return valore;
   }
   </code>
   e hai queste righe di codice:
   <code>
   valore = 10;
   risultato = dimezza(valore);
   /* 2 stampe della funzione "dimezza":
    * "valore =  10"
    * "valore = 5"
    */
   printf("%d", risultato); /* stampa 5 */
   printf("%d", valore);    /* stampa 10 */
   </code>
   Come vedi anche se io altero in parametro nella funzione, al di fuori di 
   questa il suo valore non cambia. Questo appunto perche' i parametri sono 
   passati per copia.
   Piccolo spoiler: per ovviare a questo l'unico modo e' passare un 
   puntatore alla variabile (ovvero l'indirizzo di memoria della variabile), 
   cosi' il puntatore non puo essere alterato, ma l'oggetto puntato si.


 riferimenti che usero' dopo per spiegare.
grazie della pazienza mox.