Newsgroup: it.comp.programmare
Titolo: Programma

Chiedo scusa per la banale domanda che non mi sarebbe mai venuta in mente
di fare.
In una lezione tenuta dal mio professore di informatica sul Visual Basic si
è detto che i programmi scritti in tale linguaggio sono gli unici in cui il
computer esegue anche le parti dichiarative, ed ha aggiunto che in Pascal
si esegue solamente il codice compreso tra begin e l'end ed in C solamente
quello scritto in main.  
Io credevo che tutte le istruzioni venissero eseguite, sia dichiarative che
non.
Sono io che sbaglio o il professore?
Personalmente non mi sono mai posto il problema, davo tutto per scontato.
Saluti
 
 

 Sono io che sbaglio o il professore?
Probabilmente ti e' sfuggito qualche passo del discorso. Detta cosi' come
l'hai riferita tu sembra che il tuo professore abbia qualche lacuna teorica.
Forse il tuo professore intendeva fare un paragone semplificato fra
linguaggi compilati (C) e quelli interpretati o semi-compilati come il
Visual Basic (anche se qui ci sarebbero dei distinguo). L'accenno al Pascal
e' fuorviante perche' dipendente dall'implementazione.
Comunque in questa ottica e' evidente che in un linguaggio compilato le
parti dichiarative (come ad esempio le istruzioni #include) non vengono
eseguite a run-time, anche se nulla vieta che un #include contenga del
codice, come infatti succede abbastanza normalmente.
In ogni caso l'inizializzazione di una variabile statica in C (cioe' esterna
al corpo della main ) comporta comunque l'esecuzione di codice.
In conclusione e' meglio che tu rimanga della tua idea: tutto il codice
viene eseguito. E' piu' semplice e provoca meno conclusione (IMMO).
Bye, Sonic.

No, non sono stato io a capire male in quanto gli  ho chiesto delucidazioni
e la sostanza del discorso non è variata molto. 
Ti riporto una domanda che mi ha fatto dopo la mia richiesta:
<< Come mai in C e in Pascal sei obbligato a dichiarare le funzioni prima
del blocco esecutivo - nel caso del Pascal - e prima della funzione main
nel C - escludendo l'uso dei prototipi -? >>
Io gli ho risposto semplicemente per chiarezza del linguaggio nei confronti
di chi legge il codice e per il compilatore in modo che possa verificare le
chiamate e soprattutto il corretto passaggio di valori e il return type
delle funzioni.
<<Sbagliato, puoi anche trovare linguaggi dove le funzioni le scrivi dove
cazzo ti pare. Semplicemente quando tu avvii il programma ogni funzione
viene "segretamente eseguita per dichiararla" e poi viene eseguita nel modo
corretto quando si ha la sua chiamata dal programma principale >>
Saluti e grazie per quanto mi hai detto(permettimi il tu) SoNic.
 

quello scritto in main.  
Cosa intendi per "parti dichiarative"; intendi forse qualcosa del tipo
dim i as integer?
Se intendi questo bisogna anche vedere cosa intendi per "eseguire"; ad
esempio quando il compilatore trova una dichiarazione di variabile
deve allocare uno spazio adatto a contenerla in memoria. Bisogna
vedere se questa operazione di allocazione implicita rientra nella
definizione di "esecuzione di codice", in quanto spesso (ma qui non so
entrare più in dettaglio) la memoria non viene allocata nel punto in
cui si trova la dichiarazione ma viene allocata prima, appena si entra
nel blocco di codice che ne fa uso. Solitamente i compilatori allocano
le variabili automatiche (cioè quelle normali) nello stack, o memoria
statica. Cmq resta il fatto che anche il Pascal e il C devono allocare
la memoria statica, quindi non *dovrebbe* esserci differenza.
Diverso è il caso della memoria dinamica (nello heap): in questo caso
la memoria non è allocata a priori ma dinamicamente (appunto) in
precisi punti del programma (ad esempio quando fai "dim db as new
database"); solitamente la memoria dinamica è usata in modo esplicito
(ad esempio l'uso di new) ma ci sono anche dei linguaggi che allocano
qualunque variabile nello heap, come il Java.
Dopo tutto questo lungo excursus l'unica cosa che mi viene in mente è
che il tuo prof intenda con "eseguire le parti dichiarative" che il VB
usi l'allocazione dinamica per tutte le variabili (ma in questo caso
non sarebbe l'unico, c'è anche il Java).
Spero di essere stato chiaro (speranza vana...)
Anto
P.S Fai le superiori o l'università?

corretto quando si ha la sua chiamata dal programma principale >>
Il tuo prof non capisce niente. Spero vivamente che non sia un docente
universitario.

P.S Fai le superiori o l'università?
Superiori (3 anno).

 provvede già a segnalare la sua presenza alla funzione.
In fase di compilazione il compilatore provvede a riservare nel segmento
dati l'area di memoria necessaria alla variabile 'a' e la inizializza con il
valore 10. Per le regole di scope, tale variabile è visibile a tutte le
funzioni (globale), e tutte le occorrenze di 'a' vengono sostituite con
l'indirizzo assegnatogli.
In esecuzione, per l'istruzione 'int a = 10' non viene fatto nulla, perchè è
già stato fatto tutto dal compilatore.
Cosa diversa è 'int a = 10' all'interno di una funzione; in questo caso
infatti verrebbe allocato spazio nello stack e verrebbe fatta
l'inizializzazione = 10 al momento dell'esecuzione. In questo caso è
NECESSARIO fare così se il linguaggio permette la ricorsione delle funzioni.
PS: Per forzare una dichiarazione del 1° tipo all'interno di una funzione, è
sufficiente dichiarare la variabile a 'statica'
PS2: vista così sembra che il tuo prof. non abbia poi tutti i torti!

Anche se in fase di esecuzione per int a = 10; non viene fatto nulla penso
che venga "processata" lo stesso.

 che venga "processata" lo stesso.
Non ne vedo la ragione: vengono "processate" solo delle istruzioni, dato che
l'area di memoria è già allocata nel segmento dati, l'inizializzazione è già
stata fatta non c'è nessuna istruzione da eseguire.