Visualizza wikitesto di Ada (linguaggio di programmazione)

{{Linguaggio di programmazione
|nome = Ada
|immagine = Ada horizon green logo with slogan.svg
|didascalia = 
|autore = {{sp}}
* [[Jean Ichbiah]] (Ada 83)
* [[S. Tucker Taft]] (Ada 95, Ada 2005, Ada 2012)
|data = 1980
|utilizzo = [[general purpose]]
|paradigmi = {{sp}}
* [[programmazione modulare|modulare]]
* [[programmazione procedurale|procedurale]]
* [[programmazione orientata agli oggetti|object-oriented]]
|tipizzazione = {{sp}}
* [[tipizzazione statica|statica]]
* [[Tipizzazione forte|forte]]
* [[sistema di tipi nominale|nominale]]
* [[sicurezza rispetto ai tipi|typesafe]]
|estensione = .adb .ads
|influenzato_da = [[ALGOL 68]] (Ada 83), [[Pascal (linguaggio di programmazione)|Pascal]] (Ada 83), [[C++]] (Ada 95), [[Smalltalk]] (Ada 95), [[Java (linguaggio di programmazione)|Java]] (Ada 2005)
|ha_influenzato = [[C++]], [[Eiffel (linguaggio)|Eiffel]], [[PL/SQL]], [[VHDL]], [[Ruby (linguaggio di programmazione)|Ruby]], [[Java (linguaggio di programmazione)|Java]], [[Seed7]]
}}
'''Ada''' è un [[linguaggio di programmazione]] sviluppato verso la fine degli [[anni 1970|anni settanta]] su iniziativa del [[Dipartimento della Difesa degli Stati Uniti|Dipartimento della Difesa]] (DOD) degli [[Stati Uniti d'America|Stati Uniti]]. Sia le specifiche che lo sviluppo del linguaggio furono affidati a bandi di gara. Tra le 17 proposte inviate in seguito al bando indetto dal DOD, fu scelto nel [[1979]] il progetto di [[Jean Ichbiah]], che all'epoca lavorava presso la [[CII Honeywell Bull]]. Le specifiche divennero uno standard [[ANSI]] e [[Organizzazione internazionale per la normazione|ISO]] nel [[1983]], seguito dalle successive revisioni nel 1995, 2005 e 2012. Un sottoinsieme [[Sistema real-time|hard real-time]] del linguaggio è noto come [[profilo Ravenscar]].<ref name="adaic">{{cita web|url=https://www.adaic.org/resources/add_content/standards/05rat/html/Rat-5-4.html|titolo=The Ravenscar profile|autore=[[John Barnes (informatico)|John Barnes]]}}</ref>

Ada combina principi e tecniche provenienti da diversi [[paradigma di programmazione|paradigmi di programmazione]], in particolare [[programmazione modulare]], [[programmazione orientata agli oggetti]], [[programmazione concorrente]] e [[calcolo distribuito]]. Sebbene l'interesse del DOD vertesse principalmente sullo sviluppo di [[applicazione (informatica)|applicazioni]] militari, Ada è un linguaggio [[general purpose]] che si presta all'utilizzo in qualsiasi [[dominio applicativo]]. L'origine militare si rivela però nella presenza di caratteristiche fortemente orientate alla sicurezza del codice; per questo motivo, il linguaggio viene ancora oggi usato in molti contesti in cui il corretto funzionamento del software è critico, come [[astronautica]], [[avionica]], [[controllo del traffico aereo]], [[finanza]] e dispositivi medici.<ref>{{Cita web|titolo=Ada helps churn out less-buggy code|url=http://gcn.com/Articles/1999/06/30/Ada-helps-churn-out-lessbuggy-code.aspx|editore=Government Computer News|accesso=14 settembre 2010|autore=S. Tucker Taft|autore2=Florence Olsen|pp=2-3|data=30 giugno 1999|urlarchivio=https://web.archive.org/web/20150831211902/http://gcn.com/Articles/1999/06/30/Ada-helps-churn-out-lessbuggy-code.aspx|dataarchivio=31 agosto 2015|urlmorto=no}}</ref><ref name=Ada_usage>{{Cita web|cognome=Feldman|nome=Michael|titolo=Who's using Ada?|url=https://www.seas.gwu.edu/~mfeldman/ada-project-summary.html|editore=SIGAda Education Working Group|urlarchivio=https://web.archive.org/web/20150831212010/http://www.seas.gwu.edu/~mfeldman/ada-project-summary.html|dataarchivio=31 agosto 2015|urlmorto=no}}</ref><ref>{{cita testo|titolo=Pulling strings 220 miles above Earth - The ISS software serves as the orbiting lab's central nervous system|editore=Boeing|url=http://www.boeing.com/assets/pdf/defense-space/space_exploration/features/ISS_Software_10-09.pdf|urlarchivio=https://web.archive.org/web/20150423170227/http://www.boeing.com/assets/pdf/defense-space/space_exploration/features/ISS_Software_10-09.pdf|dataarchivio=23 aprile 2015|urlmorto=sì}}</ref>

I compilatori Ada impiegati per lo sviluppo di software mission-critical devono seguire un processo di certificazione secondo lo standard internazionale ISO/IEC 18009 (''Ada: Conformity Assessment of a Language Processor''), implementato nella suite ''Ada Conformity Assessment Test Suite'' (ACATS), parte integrante del processo di certificazione svolto da laboratori autorizzati dall'Ada Compiler Assessment Authority (ACAA).

Il nome iniziale del linguaggio doveva essere ''DOD-1'', ma venne in seguito cambiato in Ada in onore di [[Ada Lovelace]], illustre matematica dei primi anni del XIX secolo, accreditata come la prima programmatrice della storia per aver [[Algoritmo di Ada Lovelace per i numeri di Bernoulli|sviluppato un algoritmo]] per il calcolo dei [[numeri di Bernoulli]] sulla [[macchina analitica]] di [[Charles Babbage]].

== Caratteristiche ==
Ada eredita alcune caratteristiche stilistiche fondamentali da [[ALGOL]], rispetto al quale aggiunge molte funzionalità basilari (come il [[tipo di dato|sistema di tipi]], i [[record (tipo di dato)|record]], i [[puntatore (programmazione)|puntatori]] o le [[tipo enumerativo|enumerazioni]], implementati in buona parte in stile [[Pascal (linguaggio di programmazione)|Pascal]]) e funzionalità avanzate proprie dei moderni linguaggi di programmazione ([[polimorfismo (informatica)|polimorfismo]], [[ereditarietà (informatica)|ereditarietà]], [[eccezione (informatica)|eccezioni]], [[Processo (informatica)|tasking]]).

Il linguaggio fornisce un gran numero di controlli sia statici (a tempo di compilazione) sia dinamici (a [[runtime]]), che prevengono un'ampia varietà di errori (uso errato dei parametri, errori di tipo, violazione di range e [[Off-by-one error|off-by-one]]). I controlli dinamici sono disattivabili se si vuole massimizzare l'efficienza, tramite il [[direttiva (programmazione)|pragma]] <code>Suppress</code>,<ref>{{cita|Barnes (2014)|p. 380|barnes14}}.</ref> o tramite switch specifici dei vari compilatori. Sicurezza e affidabilità del codice sono infatti uno dei principali aspetti che hanno guidato lo sviluppo del linguaggio.<ref>{{cita web|autore=Gary Dismukes|sito=adacore.com|titolo=Gem #63: The Effect of Pragma Suppress|url=https://www.adacore.com/adaanswers/gems/gem-63/|urlarchivio=https://web.archive.org/web/20150728111611/http://www.adacore.com/adaanswers/gems/gem-63/|dataarchivio=28 luglio 2015|urlmorto=no}}</ref>

=== "Hello, world!" in Ada ===
Un [[Hello world]] in Ada è il seguente:<ref>Il programma, salvato nel file <code>hello.adb</code>, può essere compilato usando il compilatore [[GNAT]] con il comando <code>gnatmake hello.adb</code></ref>

<syntaxhighlight lang="ada">
with Ada.Text_IO; use Ada.Text_IO;
procedure Hello is
begin
  Put_Line("Hello, world!");
end Hello;
</syntaxhighlight>

== Sintassi ==
A differenza della maggior parte dei linguaggi di programmazione, Ada è [[Sensibile alle maiuscole|insensibile alle maiuscole]].<ref>Fanno eccezione i letterali di tipo carattere o stringa.</ref> Le convenzioni stilistiche più comuni prevedono di scrivere le keyword del linguaggio interamente in minuscolo (o, meno comunemente, interamente in maiuscolo) e i nomi di tutti gli identificatori (tipi, variabili, subroutine, package etc.) in [[snake case]] con l'iniziale di ogni parola maiuscola. I commenti sono su singola linea, iniziati da un doppio [[trattino]] <code>--</code> e terminati dal ritorno a capo. Per gli identificatori e i commenti Ada supporta il set di caratteri [[ISO 10646]], permettendo quindi di scrivere codice in caratteri non [[ASCII]], e la lunghezza massima consentita per gli identificatori è legata all'implementazione (nelle implementazioni standard deve essere pari a non meno di 200 caratteri).<ref>{{cita|Barnes (2014)|p. 67|barnes14}}.</ref>

La sintassi di Ada impiega pochi simboli, prediligendo l'uso di parole in lingua inglese. I simboli sono l'assegnazione <code>:=</code>, gli operatori aritmetici elementari (<code>+</code>, <code>-</code>, <code>*</code>, <code>/</code> e <code>**</code>), gli operatori di comparazione (<code><</code>, <code><=</code>, <code>></code>, <code>>=</code>, <code>=</code>, <code>/=</code>), i due punti <code>:</code> per dichiarare il tipo di una variabile, la freccia <code>=></code> negli aggregati, la virgola <code>,</code> come separatore negli aggregati, l'operatore di accesso ai campi <code>.</code>, l'indicazione di range <code>..</code>, il ''tick'' <code>'</code> per accedere agli attributi, il ''box'' <code><></code> per indicare un parametro variabile nelle dichiarazioni, il punto e virgola <code>;</code> per separare i parametri di una routine e per terminare le istruzioni. L'istruzione nulla è costituita dalla keyword <code>null</code> terminata da punto e virgola, mentre una riga vuota terminata da punto e virgola non è valida. I restanti operatori sono implementati tramite keyword (<code>and</code>, <code>or</code>, <code>rem</code>, <code>mod</code> etc.).

Ada è un linguaggio [[programmazione strutturata|strutturato]] e i blocchi sono delimitati da keyword. La chiusura del blocco contiene un riferimento o identificatore per capire immediatamente a quale apertura appartiene ed evitare confusione, impedendo inoltre potenziali [[dangling else]] o analoghi errori. Ad esempio, una subroutine contenente un ciclo <code>for</code> appare come:

<syntaxhighlight lang=ada>
procedure Example is
  X: array (Integer range 1..5) of Integer;
begin
  for I in X'Range loop
    X(I) := I;
  end loop;
end Example;
</syntaxhighlight>

=== Parole riservate ===
Il linguaggio, in riferimento allo standard Ada 2012, ha 73 [[parola riservata|parole riservate]]:<ref>{{cita|Barnes (2014)|p. 851|barnes14}}.</ref>
{{div col|cols=3}}
<syntaxhighlight lang="ada">
abort
abs
abstract
accept
access
aliased
all
and
array
at
begin
body
case
constant
declare
delay
delta
digits
do
else
elsif
end
entry
exception
exit
for
function
generic
goto
if
in
interface
is
limited
loop
mod
new
not
null
of
or
others
out
overriding
package
pragma
private
procedure
protected
raise
range
record
rem
renames
requeue
return
reverse
select
separate
some
subtype
synchronized
tagged
task
terminate
then
type
until
use
when
while
with
xor
</syntaxhighlight>
{{div col end}}

Esiste un'omonimia tra le parole riservate <code>access</code>, <code>delta</code>, <code>digits</code>, <code>mod</code> e <code>range</code> e gli omonimi attributi, ma essendo gli attributi sempre preceduti da un apostrofo (detto ''tick'') non esiste rischio di ambiguità.<ref>{{cita|Barnes (2014)|p. 68|barnes14}}.</ref>

=== Dichiarazioni di variabile ===
Le dichiarazioni di variabile in Ada si effettuano indicando il nome dell'entità dichiarata, seguito da <code>:</code> e poi dal tipo, quest'ultimo preceduto da eventuali specificatori (<code>constant</code>, <code>aliased</code>, <code>not null</code> etc.). Un valore di inizializzazione statico o dinamico può essere indicato facoltativamente dopo il tipo, separato da <code>:=</code>, e la dichiarazione è infine terminata da <code>;</code>. Le dichiarazioni possono essere collocate nella [[#Package|specifica di un package]] o nella parte dichiarativa di una [[#Routine|routine]] o di un blocco <code>declare</code>. Più variabili possono essere dichiarate nella stessa dichiarazione, separando i nomi con virgole, ma si tratta solo di [[zucchero sintattico]] e tecnicamente le dichiarazioni sono comunque distinte ed indipendenti fra loro, quindi ad esempio un'eventuale espressione di inizializzazione viene valutata una volta per ciascuna variabile.<ref>{{cita|Barnes (2014)|pp. 73-74|barnes14}}.</ref>

È possibile definire variabili costanti facendo precedere il tipo dalla keyword <code>constant</code>, nel quale caso è obbligatorio fornire un'inizializzazione, ed è inoltre possibile definire costanti numeriche omettendo il tipo prima dell'inizializzazione, che deve consistere in un'espressione statica, ovvero nota a tempo di compilazione (il tipo della costante viene inferito dall'inizializzatore letterale). La differenza tra variabili costanti e costanti numeriche consiste nel fatto che le prime sono variabili calcolate a runtime, mentre le seconde vengono risolte a tempo di compilazione.<ref>{{cita|Barnes (2014)|p. 75|barnes14}}.</ref>

<syntaxhighlight lang=ada>
-- variabile intera
N: Integer;

-- due variabili intere, inizializzate con un valore casuale
-- (possono assumere due valori diversi)
I, J: Integer := Random(Seed);

-- variabile costante (valutata a runtime)
F: constant Float := Float(I + J);

-- costante numerica (risolta staticamente a tempo di compilazione)
π: constant := 3.14159_26535_89793_23846;
</syntaxhighlight>

=== Goto ===
A differenza di molti linguaggi moderni, Ada conserva l'istruzione <code>[[GOTO|goto]]</code>. Pur essendo generalmente deprecata nella [[programmazione strutturata]], è infatti un'istruzione utile per la generazione automatica di codice a partire da sorgenti in altri linguaggi o specifiche formalizzate ad alto livello. È inoltre accettabile in alcuni contesti, come il salto verso il termine di un blocco<ref>La label come ultima riga del blocco è valida solo a partire dallo standard Ada 2012, mentre le versioni precedenti richiedevano che il <code>goto</code> fosse seguito da un'istruzione (quindi bisognava aggiungere un'istruzione nulla al termine del blocco, dopo la label).</ref> (ad esempio un'iterazione di un ciclo) o l'uscita da cicli profondamente annidati,<ref>{{cita|Barnes (2014)|p. 114|barnes14}}.</ref> contesto nel quale è più leggibile rispetto ad analoghe istruzioni <code>break</code> o <code>continue</code> in altri linguaggi in quanto il punto di arrivo del salto nel codice è chiaramente indicato dalla label (mentre il <code>break</code> in linguaggi come il C può essere ''error prone'').<ref>{{cita libro|titolo=Expert C Programming: Deep C Secrets|url=https://archive.org/details/expertcprogrammi00vand|nome=Peter|cognome=Van der Linden|editore=prentice Hall Professional|anno=1994|ISBN=978-0-13-177429-2|pp=[https://archive.org/details/expertcprogrammi00vand/page/36 36]-38}}</ref>

<syntaxhighlight lang=ada>
procedure Print_Integers is
begin
  for I in 1..20 loop
    Put(Integer'Image(I));
    if I mod 5 = 0 then
      New_Line;
      goto Continue; -- goto
    end if;
    Put(", ");
  <<Continue>> -- label
  end loop;
end Print_Integers;
</syntaxhighlight>

== Sistema di tipi ==
[[File:Mappa dei Tipi di Ada.svg|miniatura|upright=2|Gerarchia dei tipi in Ada]]
Ada è un [[Tipizzazione forte|linguaggio fortemente tipizzato]] e [[sicurezza rispetto ai tipi|typesafe]].<ref>{{cita|Barnes (2014)|p. 11|barnes14}}.</ref> A differenza del C e dei suoi derivati, Ada non ammette [[conversione di tipo|conversioni di tipo]] implicite (tranne che per i tipi universali e gli access type anonimi)<ref>{{cita|Barnes (2014)|p. 211|barnes14}}.</ref> e la conversione di tipo si effettua scrivendo il nome del tipo seguito dalla variabile da convertire tra parentesi<ref>{{cita|Barnes (2014)|p. 83|barnes14}}.</ref>, ad esempio:

<syntaxhighlight lang=ada>
procedure Conversion is
  X: Float := 2.9;
  Y: Integer;
begin
  Y := X;          -- illegale (assegna valore Float a variabile Integer)
  X := X + 1;      -- illegale (l'operatore + non è definito su tipi misti)
  X := X + 1.0;    -- legale
  Y := Integer(X); -- conversione di tipo (con arrotondamento): ora Y vale 3
end Conversion;
</syntaxhighlight>

Il tipo di un letterale può essere indicato esplicitamente con una sintassi simile alla conversione, aggiungendo un tick prima della parentesi aperta. Questo è utile soprattutto in caso di ambiguità, quando uno stesso letterale (ad esempio una stringa, o un valore enumerativo) può riferirsi a tipi diversi.<ref>{{cita|Barnes (2014)|p. 87|barnes14}}.</ref>

=== Tipi predefiniti ===
A differenza del [[C (linguaggio)|C]] e dei suoi derivati, in Ada non esistono keyword che identificano tipi primitivi, e tutti i tipi predefiniti sono definiti nella standard library. I tipi predefiniti fondamentali (come <code>Integer</code>, <code>Float</code> o <code>Character</code>) sono definiti nel [[#Package|package]] <code>Standard</code>, ma per massimizzare la portabilità è considerata buona pratica non usare direttamente i tipi predefiniti e definire invece i propri, anche per i tipi numerici più semplici.<ref>{{cita|Barnes (2014)|p. 18|barnes14}}.</ref>

I tipi definiti nel [[#Package|package]] <code>Standard</code> sono sempre visibili in ogni parte del programma, mentre gli altri tipi definiti nei restanti package della libreria standard richiedono una clausola <code>with</code> per essere visibili. I tipi definiti in <code>Standard</code> sono:<ref>{{cita|Taft et al.|pp. 356-359|rm}}.</ref>
* <code>Integer</code>: tipo discreto intero, che assume valori in un intervallo di estensione legata all'implementazione, non inferiore a <math>-2^{15}+1</math> .. <math>+2^{15}-1</math>.
** <code>Natural</code>: sottotipo di <code>Integer</code> che può assumere solo valori non negativi;
** <code>Positive</code>: sottotipo che può assumere solo valori positivi non nulli;
* <code>Float</code>: tipo in virgola mobile con almeno sei cifre;
* <code>Duration</code>: tipo in virgola fissa, usato per esprimere un tempo in secondi;
* <code>Character</code>, <code>Wide_Character</code>, <code>Wide_Wide_Character</code>: tipi speciali di enumerazione, usati per i caratteri di testo con codifica rispettivamente a 8, 16 e 32 bit (gli ultimi due sono stati aggiunti rispettivamente in Ada 95 e in Ada 2005)
* <code>String</code>, <code>Wide_String</code>, <code>Wide_Wide_String</code>: stringhe di lunghezza fissa, costituite da array di caratteri. Altre due varietà di stringhe, più flessibili ma anche più pesanti dal punto di vista computazionale, sono definite in altri package della libreria, e sono <code>Ada.Strings.Bounded.Bounded_String</code> (per stringhe di lunghezza variabile fino ad un valore massimo) e <code>Ada.Strings.Unbounded.Unbounded_String</code> (per stringhe di lunghezza variabile senza restrizioni), i cui rispettivi package forniscono anche routine per la manipolazione;
* <code>Boolean</code>: tipo enumerativo che può assumere i valori <code>False</code> e <code>True</code>, e che gode di una semantica particolare.

I package <code>System</code> e <code>System.Storage_Elements</code> forniscono alcuni tipi che sono utili per la programmazione a basso livello:<ref>{{cita|Taft et al.|pp. 319-322|rm}}.</ref>
* <code>System.Address</code>: rappresenta un indirizzo di memoria;
* <code>System.Storage_Elements.Storage_Offset</code>: rappresenta un offset di memoria, che può essere aggiunto o sottratto ad un indirizzo per ottenere un altro indirizzo;
* <code>System.Storage_Elements.Storage_Count</code>: un sottotipo di <code>Storage_Offset</code> che può assumere solo valori non negativi, usato per rappresentare la dimensione di una struttura dati;
* <code>System.Storage_Elements.Storage_Element</code>: rappresenta l'unità minima di memoria indirizzabile (ovvero un singolo [[byte]] nella maggior parte delle implementazioni);
* <code>System.Storage_Elements.Storage_Array</code>: array di <code>Storage_Element</code>.

=== Dichiarazione di tipi e sottotipi ===
I tipi possono essere definiti usando la keyword <code>type</code>, sotto forma di enumerazione, come tipo in virgola mobile con la keyword <code>digits</code> o a partire da un altro tipo preesistente, usando la keyword <code>new</code>, mentre l'attributo <code>'Base</code> di un tipo fornisce il tipo base da cui deriva. A partire da un tipo è possibile definire un sottotipo (con la keyword <code>subtype</code>), che consiste in un insieme di valori contenuto nel dominio del tipo da cui deriva.<ref>{{cita|Barnes (2014)|pp. 77-79|barnes14}}.</ref>

<syntaxhighlight lang=ada>
-- nuovo tipo numerico definito a partire da Integer
type Giorno is new Integer;

-- sottotipo di Giorno
subtype Giorno_Del_Mese is Giorno range 1..31;
</syntaxhighlight>

=== 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>

<syntaxhighlight lang="ada">
procedure P is
  type Divinità is (Giove, Giunone, Minerva, Eros, Venere);
  type Pianeta is (Mercurio, Venere, Terra, Marte, Giove, Saturno, Urano, Nettuno);
  subtype Pianeta_Roccioso is Pianeta range Mercurio .. Marte;

  P1: Pianeta  := Mercurio;
  D1: Divinità := Giunone;

  -- letterali ambigui
  P2: Pianeta  := Pianeta'(Giove);
  D2: Divinità := Divinità'(Giove);

  B: Boolean;
  I: Integer;
  D: Divinità;
  P: Pianeta;
begin
  -- esempi di operatori e attributi
  B := Giunone < Minerva;       -- True
  I := Pianeta'Pos(Venere);     -- 1
  P := Pianeta_Roccioso'Last;   -- Marte
  D := Divinità'Pred(Minerva);  -- Giunone
end P;
</syntaxhighlight>

=== Array ===
Gli [[array]] sono definiti tramite la keyword <code>array</code>, specificando tra parentesi la natura degli indici (che possono essere di un qualsiasi tipo discreto). Oltre al tipo è possibile specificare un range per gli indici dell'array, indicando non la dimensione della struttura, ma una coppia di valori minimo e massimo per l'indice, eliminando alla radice il problema della scelta tra array zero-based e one-based. L'accesso agli elementi di un array avviene segnando l'indice tra parentesi tonde.<ref>{{cita|Barnes (2014)|p. 117|barnes14}}.</ref>

Un tipo array può essere definito anonimamente nella dichiarazione di variabile, oppure può essere dichiarato un tipo specifico per l'array con la keyword <code>type</code>. La differenza fondamentale è che nel primo caso due array non possono essere assegnati fra loro, anche se dichiarati con un tipo anonimo che sembra lo stesso, in quanto si tratta formalmente di due tipi diversi (anche se la dichiarazione avviene nella stessa riga separando i nomi delle variabili con la virgola, in quanto tale notazione è solo [[zucchero sintattico]] per due dichiarazioni distinte).<ref>{{cita|Barnes (2014)|p. 112|barnes14}}.</ref>

Gli array supportano lo slicing, assegnando contemporaneamente un range (non necessariamente statico) di indici, anche con sovrapposizione di elementi.<ref>{{cita|Barnes (2014)|p. 137|barnes14}}.</ref>

<syntaxhighlight lang=ada>
procedure P is
  -- array di tipo anonimo
  A, B: array (Integer range 1..5) of Float;
  
  -- tipo per array, di lunghezza variabile
  type Vettore is array (Integer range <>) of Float;
  -- sottotipo per array di lunghezza fissa
  subtype Vettore_5 is Vettore(1..5);

  -- array con indice 1..5
  C, D: Vettore_5;

  -- array con indice 1..6
  E: Vettore (1..6);
begin
  A := B; -- illegale (non compila), le due variabili hanno tipo (anonimo) diverso
  C := D; -- legale
  C := E; -- illegale

  A(1..3) := B(2..4); -- slice
  A(1..3) := A(2..4); -- slice con sovrapposizione di elementi (ok)
end P;
</syntaxhighlight>

È possibile dichiarare array mutlidimensionali nativi, separando gli indici con virgole, oppure sotto forma di array di array (e quindi [[jagged array]]), in questo caso avendo cura di fare attenzione all'ordine delle dichiarazioni.<ref>{{cita|Barnes (2014)|pp. 118, 135-136|barnes14}}.</ref>

<syntaxhighlight lang=ada>
procedure P is
  A: array (Integer range 1..5, Integer range 2..7) of Float;           -- array di dimensione 2
  B: array (Integer range 2..7) of array (Integer range 1..5) of Float; -- array di array
begin
  A(1, 2) := 5.0; -- accesso ad un elemento di un array multidimensionale
  B(1)(2) := 5.0; -- accesso ad un elemento di un array di array
end P;
</syntaxhighlight>

Per gli array è possibile utilizzare nelle dichiarazioni o nelle istruzioni dei letterali (detti aggregati), costituiti da un insieme di valori tra parentesi tonde, separati da virgole. Gli aggregati possono essere posizionali oppure nominativi: nel primo caso la corrispondenza del valore con l'indice cui si riferisce è data dalla posizione nell'aggregato (l'ordine dei valori deve seguire quindi quello degli elementi dell'array), nel secondo caso invece per ogni valore si specifica l'indice, usando il simbolo <code>=></code> per separarlo dal valore. È possibile assegnare uno stesso valore a più indici, usando il range <code>..</code> se sono consecutivi o una [[barra verticale|pipe]] <code>|</code> per elencare dei valori non consecutivi. La sintassi degli aggregati è rigorosa e non consente inizializzazioni parziali, ma è possibile specificare individualmente solo alcuni elementi e completare l'assegnazione con un valore per tutti i restanti elementi, usando la keyword <code>others</code>.<ref>{{cita|Barnes (2014)|p. 128|barnes14}}.</ref>

<syntaxhighlight lang=ada>
-- aggregato posizionale
A: array (Integer range 1..5) of Integer := (1, 2, 3, 4, 5);

-- aggregato nominativo, con range e others (gli aggregati per gli array annidati sono invece posizionali)
B: array (Integer range 2..7) of array (Integer range 1..5) of Integer
  := (2 .. 4 | 6 => (1, 3, 5, 7, 9), others => (2, 4, 6, 8, 10));
</syntaxhighlight>

È possibile applicare agli array unidimensionali di valori <code>Boolean</code> che abbiano stesso tipo e lunghezza gli operatori <code>not</code>, <code>and</code>, <code>or</code> e <code>xor</code>, e il risultato è un array le cui componenti sono calcolate applicando l'operatore alle singole coppie di componenti degli array operandi.<ref>{{cita|Barnes (2014)|p. 138|barnes14}}.</ref>

=== Record ===
I [[record (tipo di dato)|record]] possono essere definiti con la keyword <code>record</code>, specificando i campi analogamente alle dichiarazioni di variabili (inclusa la possibilità di assegnare valori predefiniti). È possibile accedere ai campi di un record con la [[dot notation]], ed utilizzare aggregati costruiti analogamente a quelli degli array. È inoltre possibile definire un record senza campi con la coppia di keyword <code>null record</code>, utile per definire tipi astratti o per estendere un tipo senza aggiungere nuovi campi.<ref>{{cita|Barnes (2014)|pp. 143-146|barnes14}}.</ref>

<syntaxhighlight lang=ada>
procedure P is
  -- record
  type Data is
    record
      Giorno : Integer range 1..31 := 1;
      Mese   : Nome_Mese           := Gennaio; -- Nome_Mese è un qualche tipo enumerativo
      Anno   : Integer             := 1970;
    end record;

  D, E: Data;

  type Null_Record is null record; -- record senza campi
begin
  D := (10, Gennaio, 1995);
  E.Giorno := D.Giorno;
end P;
</syntaxhighlight>

=== Tipi parametrici ===
È possibile utilizzare dei parametri (detti discriminanti) nella dichiarazione di un tipo, che verranno specificati quando si dichiarano le variabili o si deriva un tipo non parametrico.<ref>{{cita|Barnes (2014)|pp. 439 ss.|barnes14}}</ref>

<syntaxhighlight lang=ada>
package Discriminanti is
  -- tipo per un testo di lunghezza generica, specificata dal discriminante Size
  type Testo(Size:  Positive) is
    record
      Position :  Positive :=  1;
      Data     :  String(1 .. Size);
    end record;

  -- variabile per un testo di 100 caratteri
  T: Testo (100);
end Discriminanti;
</syntaxhighlight>

=== Tipi limitati ===
Un ulteriore meccanismo di controllo sui tipi è dato dalla possibilità di definire tipi limitati, tramite la keyword <code>limited</code>. I tipi limitati dispongono solo delle operazioni dichiarate nel package, quindi non sono assegnabili con <code>:=</code> e non dispongono delle operazioni di confronto predefinite <code>=</code> e <code>/=</code>. Un tipo privato può essere definito limitato ma implementato internamente come non limitato, in questo caso il tipo è limitato all'esterno del package ma non limitato nella parte privata dello stesso, garantendo flessibilità all'interno del package, dove le operazioni predefinite rimangono disponibili, e allo stesso tempo il controllo sul tipo rispetto a chi lo usa all'esterno del package.<ref>{{cita|Barnes (2014)|p. 251|barnes14}}.</ref>

== Modularità ==
Ada è un linguaggio [[programmazione strutturata|strutturato]] e permette di dividere il codice in più unità di compilazione (routine e package), che possono essere compilate separatamente.

=== Routine ===
Ada supporta due tipi di [[funzione (informatica)|routine]], funzioni e procedure, dichiarate con le keyword <code>function</code> e  <code>procedure</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 un'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 un'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 un'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>

<syntaxhighlight lang="ada">
-- esempio di procedura con parametro facoltativo
procedure Incrementa(X: in out Integer; Incremento: Integer := 1) is
begin
  X := X + Incremento;
end Incrementa;

-- esempio di chiamata in un'altra porzione di codice
procedure P is
  N: Integer := 0;
begin
  Incrementa(N);
  -- ora N vale 1
  Incrementa(N, 3);
  -- ora N vale 4
end P;
</syntaxhighlight>

Anche gli operatori sono funzioni, definite indicando il nome dell'operatore tra doppi apici, e Ada supporta l'[[overloading]] degli stessi, così come l'overload e l'[[override]] delle routine in generale.<ref>{{cita|Barnes (2014)|pp. 181-182, 185|barnes14}}.</ref>

<syntaxhighlight lang=ada>
-- esempio di overload dell'operatore + con operandi di un tipo T
-- la cui somma è definita nella funzione Somma_T
function "+"(Left, Right: T) return T is
begin
  return Somma_T(Left, Right);
end "+";
</syntaxhighlight>

Gli operatori sono identificati dalle seguenti keyword:<ref>{{cita|Barnes (2014)|p. 169|barnes14}}.</ref>

<syntaxhighlight lang=ada>
abs and mod not or rem xor
= /= < <= > >=
+ - * / ** &
</syntaxhighlight>

=== Package ===
La modularità del codice ad un livello più astratto rispetto alle routine è ottenuta tramite i package. Un package è suddiviso in due parti distinte, specifica e implementazione, e alcuni compilatori (come [[GNAT]]) obbligano ad inserire una sola unità di compilazione per file, dividendo inoltre specifica e implementazione in due file separati (rispettivamente <code>.ads</code> e <code>.adb</code>). La specifica rappresenta l'interfaccia del package accessibile dall'esterno e può essere compilata indipendentemente dall'implementazione, facilitando i test nelle fasi iniziali di sviluppo. L'implementazione contiene il codice effettivo delle routine definite nell'interfaccia, più altre eventuali routine non accessibili dall'esterno del package. I package possono essere compilati separatamente e, in caso di modifica all'implementazione di un package senza alterarne la specifica, eventuali altri package da esso dipendenti non necessitano di essere ricompilati.<ref>{{cita|Barnes (2014)|pp. 265-266|barnes14}}.</ref>

Le dichiarazioni delle routine contenute devono essere inserite nella specifica del package (file <code>.ads</code>), mentre l'implementazione si colloca nel body (file <code>.adb</code>).  Specifica e implementazione devono avere una ''type conformance'' completa, ovvero il nome della routine, l'eventuale tipo di ritorno, il numero, tipo, modo, ordine, valore predefinito e nome dei parametri devono essere identici nella specifica e nell'implementazione, a meno di alcune differenze non sostanziali: un letterale numerico può essere sostituito con uno formalmente diverso ma con lo stesso valore, a un identificatore può essere aggiunto un prefisso in [[dot notation]], un'indicazione esplicita del modo <code>in</code> può essere omessa, un insieme di parametri dello stesso sottotipo possono essere indicati separatamente. Tutte le routine dichiarate nella specifica devono essere necessariamente implementate nel body, salvo alcune eccezioni: le procedure nulle (la cui dichiarazione termina con <code>is null</code>, ed è equivalente a una procedura contenente solo un'istruzione nulla), le routine [[#Tipi astratti e interfacce|astratte]] (che non hanno un'implementazione) e le funzioni costituite da un'[[#Espressioni condizionali|espressione condizionale]] (che viene inserita direttamente nella specifica).<ref>{{cita|Barnes (2014)|p. 183|barnes14}}.</ref>

<syntaxhighlight lang=ada>
-- specifica
package P is
  -- routine implementate nel body
  procedure Somma(A, B: in Integer; S: out Integer);
  function Somma(A, B: Integer := 0) return Integer;

  -- routine non implementate nel body
  procedure Foo(A: Integer) is null;         -- procedura nulla
  function Baz is abstract;                  -- routine astratta
  function Bar(A: Integer) return Boolean is -- funzione costituita da un'espressione condizionale
    (if A > 0 then True else False);
end P;

-- implementazione
package body P is
  procedure Somma(A, B: in Integer; S: out Integer) is
  begin
    -- inizio istruzioni
    S := A + B;
  end Somma;

  function Somma(A, B: Integer := 0) return Integer is
    -- inizio parte dichiarativa
    C: Integer;
  begin
    -- inizio istruzioni
    C := A + B;
    return C;
  end Somma;
end P;
</syntaxhighlight>

Si può creare una gerarchia di package in due modi: con l'annidamento, definendo un package dentro l'altro, e con la parentela, definendo un package come figlio dell'altro (separando padre e figlio con la [[dot notation]]). I package figli possono essere inoltre definiti come privati, e in questo modo sono totalmente inaccessibili fuori dal package padre.<ref>{{cita|Barnes (2014)|pp. 272-273|barnes14}}.</ref>

<syntaxhighlight lang=ada>
-- package padre
package Padre is
    -- package annidato
    package Annidato is
      ...
    end Annidato;
end Padre;

-- package figlio
package Padre.Figlio is
   ...
end Padre.Figlio;

-- package figlio privato
private package Padre.Figlio_Privato is
  ...
end Padre.Figlio_Privato;

</syntaxhighlight>

{{§|incapsulamento|I package forniscono un meccanismo di incapsulamento per tipi, variabili e subroutine, permettendo di definire una parte privata che non è accessibile al di fuori del package stesso, dei suoi package annidati e dei suoi figli. È anche possibile definire dei tipi con implementazione privata, che sono visibili utilizzabili al di fuori del package, ma la cui implementazione effettiva non è accessibile al di fuori dello stesso.}} Tali tipi avranno perciò una vista parziale nella parte pubblica, e una vista completa nella parte privata del package. I package figli condividono la parte privata del padre ma non dei fratelli, tuttavia è possibile importare un package fratello in modo da poterne vedere anche la parte privata usando la clausola <code>private with</code> invece della solita <code>with</code>.<ref>{{cita|Barnes (2014)|p. 277|barnes14}}.</ref>

<syntaxhighlight lang=ada>
package P is
  type T is private; -- T è visibile fuori da P, ma non la sua implementazione

private
  -- S non può essere visto né usato fuori dal package P
  type S is
    record
      ...
    end record;

  -- completa la definizione di T
  type T is
    record
      -- i campi di T non sono visibili né utilizzabili fuori dal package P
      I: Integer;
    end record;
end P;

</syntaxhighlight>

=== Generics ===
In Ada le routine o i package possono avere dei parametri risolti staticamente a tempo di compilazione, specificati facendo precedere l'unità dalla keyword <code>generic</code> e specificati tra parentesi tonde quando si istanzia l'unità generica. I generics sono un meccanismo statico che consente un riuso del codice, permettendo di istanziare la stessa unità con parametri di tipo differenti, ma a differenza di altri linguaggi i parametri generici possono essere non solo tipi, ma anche valori o routine. Nel caso di package generici, non può essere usata su essi la clausola <code>use</code> (può essere usata solo sulle loro istanze concrete) ed ogni eventuale loro package figlio deve necessariamente essere generico.<ref>{{cita|Barnes (2014)|pp. 469 ss.|barnes14}}</ref>

Ad esempio, una procedura per scambiare due elementi può essere parametrizzata rispetto al tipo degli stessi

<syntaxhighlight lang=ada>
generic
  type T is private;
procedure Scambia(A, B: in out T);

procedure Scambia(A, B: in out T) is
  Temp: T;
begin
  Temp := A;
  A := B;
  B := Temp;
end Scambia;
</syntaxhighlight>

ed essere istanziata per l'uso su tipi diversi:<ref>{{cita|Barnes (2014)|p. 470|barnes14}}.</ref>

<syntaxhighlight lang=ada>
procedure Scambia_Interi is new Scambia (Integer);
procedure Scambia_Float  is new Scambia (Float);
</syntaxhighlight>

Analogamente un package può implementare uno stack generico

<syntaxhighlight lang=ada>
generic
  type T is private;
  Capacità: Positive;
package Stack is
  procedure Push(X: T);
  function Pop return T;
private
  A: array (1 .. Capacità) of T;
  Posizione: Integer range 0 .. Capacità;
end Stack;
</syntaxhighlight>

che può essere istanziato per contenere oggetti di differente tipo e scegliendo di volta in volta la capacità massima:<ref>{{cita|Barnes (2014)|p. 471|barnes14}}.</ref>

<syntaxhighlight lang=ada>
package Int_Stack   is new Stack (Integer, 100); -- stack con una capacità di 100 valori interi
package Float_Stack is new Stack (Float, 50);    -- stack con una capacità di  50 valori float
</syntaxhighlight>

==== Parametri di tipo ====
Nel caso più semplice, un parametro di tipo generico è istanziabile e ha solo la definizione di assegnamento e uguaglianza. Possono essere specificati diversi attributi del parametro di tipo, che ne modificano l'interfaccia: può essere limitato, può avere dei discriminanti (anche non specificati, indicati con il ''box'' <code><></code>, in tal caso il tipo non è istanziabile), può essere tagged, astratto, può essere discendente di un tipo preesistente o può essere un'interfaccia con una o più interfacce progenitrici. Alcuni esempi di parametri di tipo generici:<ref>{{cita|Barnes (2014)|p. 475|barnes14}}.</ref>
<syntaxhighlight lang=ada>
generic
  type A is private;               -- tipo privato
  type B is limited;               -- tipo limitato
  type C (X: Integer);             -- tipo con discriminante X
  type D (<>);                     -- tipo con discriminante sconosciuto
  type E is tagged;                -- tipo tagged
  type F is new T;                 -- tipo derivato dal tipo non tagged T
  type G is new T with private;    -- tipo derivato dal tipo tagged T
  type H is interface and I and J; -- tipo interfaccia con due progenitrici
package Generic_Package is
  ...
end Generic_Package;
</syntaxhighlight>

Per i tipi enumerativi e numerici esistono anche delle indicazioni particolari, e per ognuno di essi sono disponibili le operazioni predefinite per tale tipo.<ref>{{cita|Barnes (2014)|p. 477|barnes14}}.</ref>

<syntaxhighlight lang=ada>
generic
  type A is (<>);               -- tipo enumerativo
  type B is range <>;           -- tipo numerico con segno
  type C is mod <>;             -- tipo numerico modulare
  type D is digits <>;          -- tipo in virgola mobile
  type E is delta <>;           -- tipo in virgola fissa
  type F is delta <> digits <>; -- tipo decimale
</syntaxhighlight>

==== Parametri routine ====
Poiché per un tipo generico si assume l'esistenza delle sole funzioni predefinite per quella categoria di tipi, può essere necessario passare come parametro anche una o più routine. Ad esempio, implementando un [[albero binario di ricerca]] che possa contenere chiavi di un tipo qualsiasi, per effettuare le operazioni di inserimento o ricerca è necessario poter comparare le chiavi, ma l'operatore di confronto <code><</code> non è predefinito per ogni tipo. Si può quindi ovviare al problema passando tale operatore come parametro generico. I parametri generici per le routine devono essere quindi passati esplicitamente quando si istanzia il package, ma possono essere omessi se nella dichiarazione del parametro generico si specifica <code>is <></code>. In questo caso la routine viene scelta automaticamente quando si istanzia il package, a patto che sia definita e visibile, sia unica e abbia completa ''type conformance'' con la dichiarazione del parametro generico.<ref>{{cita|Barnes (2014)|pp. 485-491|barnes14}}.</ref>

<syntaxhighlight lang=ada>
-- package generico
generic
  type T is private;
  with function "<"(Sinistra, Destra: T) return Boolean is <>;
package Albero_Binario is
  ...
end Albero_Binario;

-- package che usa l'Albero_Binario
package P is
  type Data is
    record
      ...
    end record;
  function Confronta_Data(Sinistra, Destra: Data) return Boolean;

  -- istanzia il package generico sul tipo Data
  package Albero_Data is new Albero_Binario(Data, Confronta_Data);

  -- l'operatore può anche essere omesso, perché esiste ed è visibile per il tipo Float
  package Albero_Float is new Albero_Binario(Float);
end P;
</syntaxhighlight>

== Memoria dinamica ==
La memoria dinamica (chiamata ''storage pool'') è gestita ad alto livello ed è [[sicurezza rispetto ai tipi|typesafe]]. Il linguaggio non fornisce puntatori flessibili come quelli del C (che sono una tra le principali fonti di bug, errori e vulnerabilità), ma utilizza dei riferimenti (detti ''access type'') che conservano informazioni sull'accessibilità degli oggetti ai quali fanno riferimento e seguono precise regole di accessibilità, prevenendo il problema dei [[dangling pointer]]. La versatilità del linguaggio per applicazioni a basso livello è comunque garantita, grazie all'attributo <code>'Address</code> e al package <code>System</code>, che permettono di manipolare [[indirizzi di memoria]] raw. L'interfaccia <code>Interfaces.C.Pointers</code> fornisce inoltre dei puntatori in stile C, utili quando si interfaccia un'applicazione Ada con una in C.

La semantica del linguaggio permette la [[garbage collection]], la cui presenza è però legata all'implementazione: solitamente è assente nei compilatori per le architetture native (in quanto può influire in maniera imprevedibile sul timing, e questo è un effetto deleterio nei sistemi [[Sistema real-time|real-time]])<ref>{{cita libro|titolo=Doing Hard Time: Developing Real-time Systems with UML, Objects, Frameworks, and Patterns|url=https://archive.org/details/doinghardtimedev0000doug|autore=Bruce Powel Douglass|editore=Addison-Wesley|anno=1999|ISBN=978-0-201-49837-0|p=[https://archive.org/details/doinghardtimedev0000doug/page/91 91]}}</ref> ma è talvolta presente per i compilatori che hanno come architettura target la [[macchina virtuale Java|JVM]]. La deallocazione può essere effettuata manualmente, istanziando l'unità generica <code>Ada.Unchecked_Deallocation</code>, che deve essere usata con attenzione per evitare di deallocare oggetti nello [[call stack|stack]] o creare dangling pointer.<ref>{{cita|Barnes (2014)|p. 787|barnes14}}.</ref> Per aumentare la sicurezza si può applicare un pattern di ''[[smart pointer]]'', creando oggetti che contano e gestiscono autonomamente i riferimenti alle risorse, in modo che il programmatore del client non debba deallocare niente in maniera esplicita.<ref>{{cita web|url=https://www.adacore.com/adaanswers/gems/gem-107-preventing-deallocation-for-reference-counted-types/|titolo=Preventing Deallocation for Reference-counted Types|sito=adacore.com|editore=AdaCore|autore=C.K.W. Grein|urlarchivio=https://web.archive.org/web/20150731213030/http://www.adacore.com/adaanswers/gems/gem-107-preventing-deallocation-for-reference-counted-types/|dataarchivio=31 luglio 2015|urlmorto=no}}</ref>

== Programmazione orientata agli oggetti ==
A differenza di molti linguaggi [[programmazione orientata agli oggetti|orientati agli oggetti]], Ada non ha un costrutto per le classi analogo a C++ o Java. Tra i principali aspetti della programmazione OOP vi sono la possibilità di distinguere il tipo di un oggetto a runtime, di definire un tipo a partire da un altro e di permettere a tali tipi di ereditare le operazioni primitive del tipo da cui deriva.<ref>{{cita|Barnes (2014)|p. 30|barnes14}}.</ref> In Ada la differenza tra variabili che sono "oggetti" e che non lo sono consiste nel fatto che le prime conservano a runtime le informazioni sul proprio tipo, consentendo il [[polimorfismo (informatica)|polimorfismo]] e il [[dynamic dispatch]]. {{§|tipi tagged|I tipi che riportano tale informazione sono detti ''tagged'' (che significa "etichettati"), e viene specificato nella dichiarazione del tipo con l'omonima keyword.<ref name=barnes31 />}}

=== Ereditarietà ===
L'[[ereditarietà]] si ha tramite estensione, che rende possibile aggiungere nuovi campi, mantenendo anche quelli ereditati. È possibile convertire un oggetto (record tagged) di un sottotipo in un tipo antenato, mentre non è possibile fare il contrario, ma è possibile assegnare un oggetto di tipo antenato ad un tipo discendente usando un aggregato che completi i campi mancanti (''extension aggregate''). L'estensione <code>S</code> di un tipo tagged <code>T</code> tramite la keyword <code>new</code> eredita anche le operazioni primitive per <code>T</code>, ovvero quelle subroutine dichiarate nello stesso package in cui è dichiarato <code>T</code> e che abbiano un parametro o un risultato di tipo <code>T</code>.<ref name=barnes31>{{cita|Barnes (2014)|p. 31|barnes14}}.</ref> I tipi derivati hanno quindi un'interfaccia che è sempre un sovrainsieme di quella del tipo da cui derivano, e l'implementazione effettiva delle operazioni ereditate può essere modificata tramite [[override]] (l'indicazione esplicita di override nella dichiarazione dell'operazione tramite la keyword <code>overriding</code>, o viceversa di non override con <code>not overriding</code>, è facoltativa ma costituisce un utile controllo statico a tempo di compilazione).<ref>{{cita|Barnes (2014)|p. 306|barnes14}}.</ref> Le funzioni di un tipo tagged possono essere richiamate con la [[dot notation]] sulla variabile dell'oggetto. L'incapsulamento dello stato interno degli oggetti non è diverso da quello per i tipi non tagged, ed è ottenuto usando il meccanismo di [[#incapsulamento|incapsulamento dei package]]. L'estensione di un tipo può avvenire anche privatamente, per cui i campi aggiunti nell'estensione non sono visibili all'esterno del package.<ref>{{cita|Barnes (2014)|p. 334|barnes14}}.</ref>

<syntaxhighlight lang=ada>
package Persone is
  type Persona is tagged -- tipo tagged
    record
      Nome    : String;
      Cognome : String;
      Età     : Natural;
    end record;
  function Salario(P: Persona) return Float; -- operazione primitiva, restituisce zero come default
  
  type Lavoratore is new Persona with  -- tipo derivato aggiungendo nuovi campi
    record
      Mansione  : Job;    -- un qualche tipo enumerativo
      Anzianità : Natural;
    end record;
  overriding
  function Salario(L: Lavoratore) return Float; -- override di un'operazione primitiva

  type Studente is new Persona with
    record
      Istituto : School; -- tipo enumerativo
      Corso    : Year;   -- altro tipo enumerativo
    end record;
  -- Studente eredita la funzione Salario di Persona, che restituisce zero

  -- estensione privata
  type Dottorando is new Studente with private;

  -- dichiarazione di un oggetto Studente
  S: Studente := ("John", "Doe", 20, "Trinity College", III);

  -- conversione da un sottotipo ad un tipo antenato
  P: Persona := Persona(S);

  -- assegnamento ad un sottotipo con un extension aggregate
  T: Studente := (P with Istituto => "MIT", Corso => IV);

private
  type Dottorando is new Studente with
    record
      -- i campi aggiunti non sono visibili fuori dal package
      Dipartimento: Department;
    end record;
end Persone;
</syntaxhighlight>

=== 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 un'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>
function Reddito_Annuo(P: Persona) return Float is
  return 12.0 * P.Salario;
end Reddito_Annuo;
</syntaxhighlight>

si ha che la funzione restituirà sempre zero per tutti gli oggetti, anche dei tipi come <code>Lavoratore</code> che avessero salario non nullo, perché al suo interno viene sempre richiamata staticamente la funzione <code>Salario</code> definita per il tipo <code>Persona</code>, che restituisce zero. Se invece l'operazione è definita come

<syntaxhighlight lang=ada>
function Reddito_Annuo(P: Persona'Class) return Float is
  return 12.0 * P.Salario;
end Reddito_Annuo;
</syntaxhighlight>

il dispatch della funzione <code>Salario</code> avviene dinamicamente e il risultato restituito è quello corretto anche per gli oggetti di tipo <code>Lavoratore</code>.<ref>{{cita|Barnes (2014)|p. 35|barnes14}}.</ref>

=== Tipi astratti e interfacce ===
Se un tipo tagged viene dichiarato astratto, tramite la keyword <code>abstract</code>, non è possibile dichiarare variabili di quel tipo, ma solo usarlo come base da cui derivare altri tipi. I tipi astratti possono avere componenti e routine concrete, ma anche routine a loro volta definite come astratte, che non sono provviste di implementazione. Quando si deriva un tipo concreto da un tipo astratto, tutte le sue routine astratte devono necessariamente essere oggetto di override. Un'interfaccia è un tipo dichiarato con la keyword <code>interface</code>, ed è analogo ad un tipo astratto ma ha maggiori restrizioni, in quanto non può avere componenti né routine concrete, salvo procedure nulle o routine con parametri ''class wide''.

Ada ha un meccanismo di ereditarietà singola per le implementazioni e multipla per le interfacce, simile al Java, per cui è possibile definire tipi che estendono al massimo un tipo concreto o astratto, ma allo stesso tempo possono implementare un numero arbitrario di interfacce. Questo previene possibili conflitti o ambiguità derivanti dall'ereditarietà multipla completa, ma conserva comunque la flessibilità consentendo ad un tipo di poter avere più interfacce di routine.<ref>{{cita|Barnes (2014)|pp. 347-348|barnes14}}.</ref> Le interfacce possono essere usate anche con estensioni private, ma in quel caso la vista completa e quella parziale del tipo devono essere conformi rispetto alle interfacce implementate, per cui non è possibile aggiungere o togliere interfacce nel completamento privato della dichiarazione.<ref name=barnes350>{{cita|Barnes (2014)|p. 350|barnes14}}.</ref>

<syntaxhighlight lang=ada>
package P is
  -- tipo astratto: può avere campi, procedure concrete e astratte
  type S is abstract tagged
    record
      ...
    end record;
  procedure Foo(X: S);
  procedure Baz(X: S) is abstract;

  -- interfaccia: non può avere campi né operazioni concrete (che non 
  -- siano nulle o con parametro class wide)
  type T is interface;
  procedure Foo(X: T) is abstract;
  procedure Baz(X: T) is null;
  procedure Bar(X: T'Class);
end P;
</syntaxhighlight>

=== Tipi controllati ===
In Ada non esiste il concetto di [[costruttore (informatica)|costruttore]], ma è possibile sostituirne le caratteristiche funzionali usando un tipo controllato. Un tipo controllato è un tipo che estende <code>Ada.Finalization.Controlled</code> (oppure <code>Ada.Finalization.Limited_Controlled</code> per i tipi controllati e limitati), per il quale è possibile eseguire l'override di tre procedure (due nel caso dei tipi limitati, dove manca la procedura <code>Adjust</code>):

<syntaxhighlight lang=ada>
with Ada.Finalization;
package P is
  type T is new Ada.Finalization.Controlled with
    record
      ...
    end record;

  overriding procedure Initialize (This: in out T);
  overriding procedure Adjust     (This: in out T);
  overriding procedure Finalize   (This: in out T);
end P;
</syntaxhighlight>

La procedura <code>Initialize</code> viene eseguita sull'oggetto subito dopo la creazione e può svolgere le funzionalità di inizializzazione tipicamente delegate ad un costruttore,<ref>Tecnicamente non si tratta di un costruttore, che viene eseguito durante la creazione dell'oggetto e dopo l'esecuzione dei costruttori di eventuali superclassi.</ref> la procedura <code>Adjust</code> viene eseguita subito dopo un'assegnazione (per cui non è disponibile per i tipi <code>Limited_Controlled</code>) e può fungere da costruttore di copia, mentre la procedura <code>Finalize</code> viene eseguita immediatamente prima della deallocazione di un oggetto, e funge da [[distruttore (informatica)|distruttore]].<ref>{{cita|Barnes (2014)|pp. 342-346|barnes14}}.</ref>

Per ragioni storiche, i tipi <code>Ada.Finalization.Controlled</code> e <code>Ada.Finalization.Limited_Controlled</code> non sono interfacce (aggiunte solo in Ada 2005) ma tipi astratti, per cui non è possibile definire un tipo che sia controllato e che contemporaneamente erediti l'implementazione di un tipo non controllato.<ref name=barnes350 />

== Note ==
<references/>

== Bibliografia ==
*{{cita libro|autore=Daniel-Jean David|titolo=Il linguaggio Ada|editore=Gruppo Editoriale Jackson|anno=1985|ISBN=88-7056-206-9|url=https://archive.org/details/illinguaggioada}}
*{{RivistaVG|bit|40|52-58|6|1983|titolo=Uno sguardo su Ada}}
*{{RivistaVG|mc|51|108-110|4|1986|titolo=Ada - L'evoluzione del linguaggio - Prima parte}}
*{{RivistaVG|mc|52|110-111|5|1986|titolo=Ada - L'evoluzione del linguaggio - Seconda parte}}

===Inglese===
* {{cita libro|cognome=Allen Weiss|nome=Mark|titolo=Data Structures and Algorithm Analysis in Ada|anno=1993|url=https://archive.org/details/datastructuresal0000weis_c9m5|editore=Benjamin-Cummings Publishing Company|isbn=0-8053-9055-3}}
* {{cita libro|cognome=Atkinson|nome=Colin|titolo=Object-Oriented Reuse, Concurrency and Distribution: An Ada-Based Approach|anno=1991|url=https://archive.org/details/objectorientedre0000atki|editore=Addison-Wesley|isbn=0-201-56527-7}}
* {{cita libro|cognome=Baker|nome=Louis|titolo=Artificial Intelligence With Ada|anno=1989|url=https://archive.org/details/artificialintell0000bake|editore=McGraw-Hill|isbn=0-07-003350-1}}
* {{cita libro|cognome=Barnes|nome=John|wkautore=John Barnes (informatico)|titolo=High Integrity Ada: The Spark Approach|editore=Addison-Wesley|ISBN=0-201-17517-7}}
* {{cita libro|cognome=Barnes|nome=John|titolo=Programming in Ada 2012|url=https://archive.org/details/programminginada0000barn_t6c3|editore=Cambridge University Press|anno=2014|isbn=978-1-107-42481-4|cid=barnes14}}
* {{cita libro|cognome=Barnes|nome=John|titolo=Programming in Ada 95|anno=1998|url=https://archive.org/details/programminginada0000barn_i7o6|editore=Addison-Wesley|ISBN=0-201-34293-6}}
* {{cita libro|cognome=Barnes|nome=John|titolo=Programming in Ada plus Language Reference Manual|anno=1991|url=https://archive.org/details/programminginada0000barn|editore=Addison-Wesley|ISBN=0-201-56539-0}}
* {{cita libro|cognome=Ben-Ari|nome=Mordechai|titolo=Ada for Software Engineers|anno=1998|url=https://archive.org/details/adaforsoftwareen0000bena|editore=John Wiley & Sons|isbn=0-471-97912-0}}
* {{cita libro|cognome=Bishop|nome=Judy|titolo=Distributed Ada: Developments and Experiences|anno=1990|url=https://archive.org/details/distributedadade0000dist|editore=Cambridge University Press|isbn=0-521-39251-9}}
* {{cita libro|cognome=Booch|nome=Grady|wkautore=Grady Booch|nome2=Doug|cognome2=Bryan|titolo=Software Engineering with Ada|anno=1994|url=https://archive.org/details/softwareengineer0000booc|editore=Addison-Wesley|isbn=0-8053-0608-0}}
* {{cita libro|cognome=Burns|nome=Alan|nome2=Andy|cognome2=Wellings|titolo=Concurrency in Ada|anno=1995|url=https://archive.org/details/concurrencyinada0000burn|editore=Cambridge University Press|isbn=0-521-62911-X}}
* {{cita libro|cognome=Burns|nome=Alan|nome2=Andy|cognome2=Wellings|titolo=Hrt-Hood: A Structured Design Method for Hard Real-Time Ada Systems|editore=North-Holland|isbn=0-444-82164-3}}
* {{cita libro|cognome=Burns|nome=Alan|nome2=Andy|cognome2=Wellings|titolo=Real-Time Systems and Programming Languages. Ada 95, Real-Time Java and Real-Time POSIX.|anno=2001|url=https://archive.org/details/realtimesystemsp0000burn|editore=Addison-Wesley|isbn=0-201-72988-1}}
* {{cita libro|cognome=Cohen|nome=Norman|titolo=Ada as a Second Language|anno=1996|url=https://archive.org/details/adaassecondlangu0000cohe|editore=McGraw-Hill Science/Engineering/Math|isbn=0-07-011607-5}}
* {{cita libro|cognome=Culwin|nome=Fintan|titolo=Ada, a Developmental Approach|anno=1992|url=https://archive.org/details/adadevelopmental0000culw|editore=Prentice Hall|isbn=0-13-264680-3}}
* {{cita libro|cognome=Dale|nome=Nell|nome2=Chip|cognome2=Weems|nome3=John|cognome3=McCormick|titolo=Programming and Problem Solving with Ada 95|editore=Jones & Bartlett Publishers|isbn=0-7637-0293-5}}
* {{cita libro|cognome=Dale|nome=Nell|nome2=Susan|cognome2=Lilly|nome3=John|cognome3=McCormick|titolo=Ada Plus Data Structures: An Object-Based Approach|editore=Jones & Bartlett Publishers|isbn=0-669-41676-2}}
* {{cita libro|cognome=English|nome=John|nome2=Fintan|cognome2=Culwin|titolo=Ada 95 the Craft of Object Oriented Programming|anno=1997|url=https://archive.org/details/ada95craftofobje0000engl|editore=Prentice Hall|isbn=0-13-230350-7}}
* {{cita libro|cognome=Feldman|nome=Michael B.|nome2=Elliot B.|cognome2=Koffman|titolo=Ada 95|anno=1999|url=https://archive.org/details/ada95problemsolv0000feld|editore=Addison-Wesley|isbn=0-201-36123-X}}
* {{cita libro|cognome=Feldman|nome=Michael B.|titolo=Software Construction and Data Structures with Ada 95|anno=1997|url=https://archive.org/details/softwareconstruc0000feld|editore=Addison-Wesley|isbn=0-201-88795-9}}
* {{cita libro|cognome=Gonzalez|nome=Dean W.|titolo=Ada Programmer's Handbook|anno=1991|url=https://archive.org/details/adaprogrammersha0000gonz|editore=Benjamin-Cummings Publishing Company|isbn=0-8053-2529-8}}
* {{cita libro|cognome=Hillam|nome=Bruce|titolo=Introduction to Abstract Data Types Using Ada|anno=1994|url=https://archive.org/details/introductiontoab00hill|editore=Prentice Hall|isbn=0-13-045949-6}}
* {{cita libro|cognome=Johnston|nome=Simon|titolo=Ada95 for C and C++ Programmers|anno=1997|url=https://archive.org/details/ada95forccprogra0000john|editore=Addison-Wesley|isbn=0-201-40363-3}}
* {{cita libro|cognome=Krell|nome=Bruce C.|titolo=Developing With Ada: Life-Cycle Methods|anno=1992|url=https://archive.org/details/developingwithad0000krel|editore=Bantam Dell Pub Group|isbn=0-553-09102-6}}
* {{cita libro|cognome=Musser|nome=David R.|nome2=Alexander|cognome2=Stepanov|titolo=The Ada Generic Library: Linear List Processing Packages|editore=Springer-Verlag|isbn=0-387-97133-5}}
* {{cita libro|cognome=Pyle|nome=Ian C.|titolo=Developing Safety Systems: A Guide Using Ada|anno=1991|url=https://archive.org/details/developingsafety0000pyle|editore=Prentice Hall|isbn=0-13-204298-3}}
* {{cita libro|cognome=Rudd|nome=David|titolo=Introduction to Software Design and Development With Ada|anno=1995|url=https://archive.org/details/introductiontoso0000rudd|editore=Brooks Cole|isbn=0-314-02829-3}}
* {{cita libro|cognome=Sanden|nome=Bo|titolo=Software Systems Construction With Examples in Ada|anno=1994|url=https://archive.org/details/softwaresystemsc0000sand|editore=Prentice Hall|isbn=0-13-030834-X}}
* {{cita libro|cognome=Savitch|nome=Walter|wkautore= Walter Savitch|nome2=Charles|cognome2=Peterson|titolo=Ada: An Introduction to the Art and Science of Programming|anno=1992|url=https://archive.org/details/isbn_0805370781|editore=Benjamin-Cummings Publishing Company|isbn=0-8053-7070-6}}
* {{cita libro|cognome=Skansholm|nome=Jan|titolo=Ada 95 From the Beginning|anno=1996|url=https://archive.org/details/ada95frombeginni0000skan|editore=Addison-Wesley|ISBN=0-201-40376-5}}
* {{cita libro|cognome=Stubbs|nome=Daniel|nome2=Neil W.|cognome2=Webre|titolo=Data Structures with Abstract Data Types and Ada|anno=1993|url=https://archive.org/details/datastructureswi0000stub_l9s3|editore=Brooks Cole|isbn=0-534-14448-9}}
* {{cita libro|nome=S. Tucker|cognome=Taft|wkautore=S. Tucker Taft|autore2=Robert A. Duff|autore3=Randall L. Brukardt|autore4=Erhard Ploedereder|autore5=Pascal Leroy|autore6=Edmond Schonberg|titolo=Ada 2012 Reference Manual|editore=Springer-Verlag|anno=2014|ISBN=978-3-642-45419-6|url=http://www.adaic.org/resources/add_content/standards/05rm/html/RM-TOC.html|cid=rm}}
* {{cita libro|cognome=Wheeler|nome=David A.|titolo=Ada 95|anno=1997|url=https://archive.org/details/ada95lovelacetut0000whee|editore=Springer-Verlag|isbn=0-387-94801-5}}

== Altri progetti ==
{{interprogetto|b=Ada|b_preposizione=sul|b_etichetta=linguaggio Ada}}

== Collegamenti esterni ==
* {{Collegamenti esterni}}
* {{FOLDOC}}
* {{cita web|http://www.sigada.org/|ACM SIGAda|lingua=en}}
* {{cita web|http://www.gnuada.org/|GNU Ada Homepage|lingua=en}}
* {{cita web|http://adapower.com/|AdaPower|lingua=en}}
* {{en}} [news:comp.lang.ada Forum]
* {{cita web|1=http://oopweb.com/Ada/Documents/Lovelace/Volume.html|2=Ada Tutorial|lingua=en|accesso=30 giugno 2004|urlarchivio=https://web.archive.org/web/20041019114231/http://oopweb.com/Ada/Documents/Lovelace/Volume.html|dataarchivio=19 ottobre 2004|urlmorto=sì}}
* {{cita web|https://www.seas.gwu.edu/~mfeldman/ada-project-summary.html|Progetti che usano Ada|lingua=en}}

{{ada}}
{{Principali linguaggi di programmazione}}
{{Controllo di autorità}}
{{Portale|informatica}}

[[Categoria:Ada| ]]