Ada (linguaggio di programmazione): differenze tra le versioni
Contenuto cancellato Contenuto aggiunto
→Tipi controllati: disamb |
m Bot: fix citazione web (v. discussione) |
||
Riga 233:
=== Tipi enumerativi ===
I tipi enumerativi possono essere specificati indicando tra parentesi i possibili valori. I letterali di tipo enumerativo possono confliggere, e in tale caso per risolvere l'ambiguità si indica il tipo esplicitamente. È possibile specificare un range di valori enumerativi, ed è possibile dichiarare sottotipi enumerativi che assumano solo una parte dei valori del tipo da cui derivano.
Per i tipi enumerativi sono definiti automaticamente gli operatori di confronto (l'ordine è dato dalla posizione nella dichiarazione, partendo dal valore minimo verso il massimo), e dispongono di diversi attributi utili, tra i quali <code>'First</code> e <code>'Last</code>, che restituiscono il primo e l'ultimo valore del tipo, <code>'Succ</code> e <code>'Pred</code>, che restituiscono i valori precedente e successivo, <code>'Pos</code> e <code>'Val</code>, che restituiscono rispettivamente l'indice posizionale (zero-based) del valore (ovvero la posizione nella dichiarazione) e il valore associato ad un indice.<ref>{{cita|Barnes (2014)|pp. 87-89|barnes14}}.</ref>
Riga 366:
=== Routine ===
Ada supporta due tipi di [[funzione (informatica)|routine]], funzioni e procedure, dichiarate con le keyword <code>procedure</code> e <code>function</code>.<ref>In questa voce si usano distintamente i tre termini, con significato differente: "funzione" per indicare un sottoprogramma che ha un valore di ritorno, "procedura" per indicare un sottoprogramma che non ha un valore di ritorno, "routine" per indicare un generico sottoprogramma (procedura o funzione).</ref> Le prime hanno un valore di ritorno e possono essere usate solo nel contesto di una espressione (in Ada, a differenza dei linguaggi derivati dal C, non esistono ''expression statement''), mentre le seconde non hanno valore di ritorno e possono essere usate solo come istruzione. Sia le procedure sia le funzioni sono costituite da due parti distinte, una parte dichiarativa tra le keyword <code>is</code> e <code>begin</code>, che può contenere solo dichiarazioni (come variabili, tipi o altre routine annidate), e una parte contenente solo istruzioni, tra le keyword <code>begin</code> e <code>end</code>. È possibile inserire dichiarazioni fuori dalla parte dichiarativa usando un blocco <code>declare</code>, e le relative dichiarazioni sono visibili solo al suo interno. Una routine può costituire una unità di compilazione autonoma oppure può essere dichiarata ed implementata all'interno di un [[#Package|package]] o nella parte dichiarativa di un'altra routine.
I parametri di una routine vengono specificati tra parentesi tonde, e Ada supporta il passaggio di parametri sia per valore sia per riferimento, con tre diversi modi: <code>in</code>, <code>out</code> e <code>in out</code>. I parametri passati in modo <code>in</code> possono solo essere letti dalla routine, quelli in modo <code>out</code> possono solo essere scritti, quelli in modo <code>in out</code> possono essere letti e scritti. Il modo di un parametro viene specificato dopo i <code>:</code> e prima del tipo, e se omesso viene assunto <code>in</code> come predefinito. È possibile definire un valore predefinito per i parametri, che in questo modo diventano opzionali e possono essere omessi nelle chiamate alla routine: in tale caso viene usato il valore predefinito. Per i parametri e i valori di ritorno di tipo ''access'' è possibile specificare la ''null exclusion'', che causa una eccezione a runtime se il parametro (o il valore restituito) sono <code>null</code>. Le routine vengono invocate facendo seguire al nome delle stesse una coppia di parentesi tonde contenenti i parametri, ma se una routine viene dichiarata o chiamata senza passare alcun parametro le parentesi tonde possono essere omesse. Le routine definite su [[#tipi tagged|tipi tagged]] possono essere richiamate anche con la [[dot notation]] rispetto al parametro di tipo tagged.<ref>{{cita|Barnes (2014)|pp. 180 ss.|barnes14}}.</ref>
Riga 639:
-- conversione da un sottotipo ad un tipo antenato
P: Persona := Persona(S);
-- assegnamento ad un sottotipo con un extension aggregate
Riga 654:
=== Dynamic dispatch ===
Con il termine "classe" in Ada si indica un insieme di tipi (''class wide''), costituito da un tipo tagged e da tutti i tipi da esso derivati direttamente o indirettamente. È possibile definire operazioni che hanno parametri o risultato di un tipo ''class wide'' usando l'attributo <code>'Class</code>, ad esempio per un tipo <code>T</code> il suo tipo ''class wide'' viene indicato con <code>T'Class</code>. La differenza tra una operazione con un parametro di tipo <code>T</code> e uno di tipo <code>T'Class</code> è che nel primo caso la scelta della routine da eseguire è determinata staticamente a tempo di compilazione, nel secondo caso è determinata dinamicamente a runtime (dynamic dispatch).<ref>{{cita|Barnes (2014)|pp. 34-35|barnes14}}.</ref> Se nell'esempio precedente si aggiunge al tipo <code>Persona</code> la seguente operazione primitiva
<syntaxhighlight lang=ada>
Riga 759:
== Collegamenti esterni ==
* {{
* {{
* {{
* {{en}} [news:comp.lang.ada Forum]
* {{
* {{
{{ada}}
| |||