Visto le mie difficoltà qualcuno puo' riassumermi alcuni concetti su questi argomenti:
"Ambito delle variabili, concetto di "scope", passaggio dei parametri per valore, right-value e left-value di una variabile"
Il mio libro non è molto ben fatto e la spiegazione è troppo veloce per me..
Grazie a tutti.
Farò riferimento al Pascal ma il concetto è generale ;)
Puoi pensare ad un programma come ad una gerarchia di procedure: al livello più alto ci sono quelle da affinare, al livello più basso quelle completamente affinate :sisi:
Ok … quindi la struttura di un programma consiste in una serie di sottoprogrammi (eventualmente annidati) :sisi:
Ora, di solito gli oggetti che vengono dichiarati all'interno del sottoprogramma hanno significato solo nell'ambito del sottoprogramma stesso.
Negli altri casi le dichiarazioni vengono effettuate nella parte dichiarativa del programma stesso.
Dunque nell'ambito di un sottoprogramma possono esistere due tipi di oggetti: quelli LOCALI e quelli GLOBALI (qualcuno li definisce anche NON LOCALI).
Gli oggetti locali possono essere costanti, variabili, ecc., definiti nella parte dichiarativa del sottoprogramma.
Gli oggetti globali vengono definiti nell'ambiente della procedura.
In particolare gli oggetti globali vengono definiti nel MAIN del programma mentre gli oggetti non locali sono definiti nei sottoprogrammi di livello superiore.
Tieni conto che questa distinzione che ho voluto puntualizzare non viene più usata, per cui si parla indifferentemente di oggetti globali o non locali.
Riassumendo, ciascun identificatore ha un suo SCOPE, ossia un CAMPO DI VALIDITA' in cui, per quanto possa essere ristretto, è riconosciuto e usato.
Possiamo dire che lo "scope" è quella subroutine in cui l'oggetto è stato dichiarato, nel caso però di subroutine annidate la faccenda si complica :asd:
Quello che dobbiamo fare in questo caso è definire delle regole precise per determinare lo scope di oggetti locali, non locali e globali del programma :sisi:
Spero di aver contribuito a chiarire meglio i termini della questione posta :look:
A presto ;)
--- i due messaggi sono stati uniti ---
Caspita ma sei un professore? Complimenti per la spiegazione!!
Ho solo un dubbio sulla definizione "passaggio dei parametri per valore".
Come sai, uno dei motivi per cui le subroutine sono largamente utilizzate è quello di evitare di riscrivere intere parti di programma :sisi:
Ora, soprattutto nel caso di algoritmi complessi, non è raro trovare parti di programma in più punti assolutamente uguali nella logica, che operano su dati di valore diverso.
Ovviamente questo implica alcuni inconvenienti: errori di copiatura in primo luogo, operazioni di testing su tutte le "occorrenze" delle istruzioni in secondo luogo.
Per risolvere il problema ci viene in aiuto una "nuova" struttura: i parametri :asd:
I parametri sono oggetti che possiedono un identificatore, un tipo e un valore che verrà definito successivamente.
In modo del tutto intuitivo, possiamo dire che si scrivono le istruzioni della subroutine facendole "lavorare" su oggetti "fittizi": i cosiddetti PARAMETRI FORMALI.
Al momento della chiamata della subroutine si forniscono le indicazioni per effettuare le "corrispondenze" tra gli oggetti reali, cioè i PARAMETRI ATTUALI, e i parametri formali (che sono fittizi, come abbiamo detto).
In base a queste corrispondenze, la CPU attua la cosiddetta TRASMISSIONE DEI PARAMETRI, ossia sostituisce i parametri formali con quelli attuali :asd:
Si tratta di un passaggio completamente automatico e trasparente per il programmatore.
L'utilizzo dei parametri comporta evidenti vantaggi nella programmazione ma occorre innanzitutto individuare questi parametri, gli oggetti locali, non locali e globali, poi occorre anche dichiarare sia i parametri formali che quelli attuali e infine dare le indicazioni sulle corrispondenze per la sostituzione.
Sicuramente la sostituzione dei parametri costituisce, se vogliamo, il problema più impegnativo: dobbiamo trovare un modo più o meno semplice per dare alla CPU tutte le informazioni necessarie per la corretta attuazione della sostituzione dei parametri.
Possiamo considerare la sostituzione per nome (o per "valore") come quella di "default" per quanto riguarda il passaggio dei parametri.
Al momento della chiamata della subroutine la CPU riserva una zona di memoria per i parametri formali, poi questi parametri formali vengono inizializzati coi valori dei parametri attuali.
Da questo momento in poi i parametri attuali non vengono più considerati, la CPU lavora solo sui parametri formali, ossia sull'area di memoria ad essi riservata.
Ovviamente al rientro dalla subroutine l'area di memoria dedicata viene rilasciata.
In sintesi, il passaggio dei parametri per nome garantisce che il valore del parametro attuale non venga in alcun modo modificato dalla subroutine, in quanto la CPU lo utilizza soltanto per inizializzare l'area di memoria.
Ecco ... questo sistema è valido se il parametro è un argomento e non un risultato poiché in quest'ultimo caso andrebbe perso.
Se il parametro è un risultato della subroutine dovremo ricorrere alla trasmissione dei parametri per "referenza" :sisi:
A presto ;)
P.S. Faccio sempre riferimento al Pascal ma il concetto è generale :)