Il linguaggio C++/CLI, all’origine denominato Managed Extensions to C++, consente di integrare in .NET il Visual C++. Rispetto alle prime versioni, Il linguaggio è stato modificato nella sintassi, al fine di fornire ai tipi CLI, una forma più naturale.
Il CLI (Common Language Infrastructure) costituisce la specifica su cui si è basata la Microsoft per realizzare l’implementazione del CLR, mentre il Visual C++/CLI rappresenta il linguaggio di più basso livello per il CLR.
La principale difficoltà nell’utilizzo del C++/CLI è nella sintassi del linguaggio. Obiettivo di questo articolo, fatto di brevi flash, è di fornire le informazioni necessarie per chiarire gli aspetti formali del linguaggio.
Il CLR comprende il value types e il reference type. I value types sono stati introdotti per creare in memoria, in modo efficiente, i tipi predefiniti del C++, mentre il reference type è stato introdotto per consentire la costruzione degli oggetti e per fornire tutte ciò che è necessario per concretizzare la programmazione object oriented, cioè la possibilità di creare gerarchie di classi, derivazione, funzioni virtuali, gestione automatica della memoria (Garbage Collector).
I value types sono allocati nello stack, mentre i reference types vengono allocati nella Managed Heap gestista dal Garbage Collector di CLR (GC). E’ probabile che in un prossimo futuro anche i tipi nativi del linguaggio potranno essere memorizzati nella Managed Heap.
-
Oggetti e Tipi.
In C++, gli oggetti possono essere creati in tre diverse aree di memoria:
-
nello stack
, come oggetti statici nella native heap, come oggetti dinamici creati, mediante l’operatore new, nella memmoria dinamica. Questo tipo di allocazione è sotto il diretto controllo del programmatore, che è responsabile sia della sua allocazione, sia della sua restituzione alla native heap.
-
Nelle situazioni in cui vi è codice misto managed o unmanaged, è difficile distinguere se un riferimento è un pointer C++ o un reference type object creato nella managed heap. Per superare questa difficoltà di formalismo, in C++/CLI è stato introdotto il tipo handler e il valore null (nullptr). Gli handler vengono usati per puntare agli oggetti nella maneged-heap, gestiti e aggiornati in automatico dal garbage collector, quando il pointer all’oggetto viene spostato in memoria. Gli handler, che non sono indirizzi effettivi di memoria, ma riferimenti, vengono definiti mediante il simbolo ^. In C++/CLI, l’operatore new viene usato per allocare gli oggetti nella native heap, mentre l’operatore gcnew viene usato per allocare oggetti nella managed heap.
class Person { }; // Definizione della classe
Person antonio; // Oggetto allocato nello stack
Person* User = new Person; // oggetto creato nella native heap
Person^ User = gcnew Person; // Oggetto creato nella managed heap
nullptr è un null pointer constant che viene risolto al compile-time, cioè una definizione literal il cui valore è zero. Un esempio di utilizzo del valore nullptr è il seguente:
String^ s = nullptr; // s è un handler nella managed heap
if (s == nullptr)
s = gcnew String(“Evolution 2.0”);
Il CLR, per liberare le risorse, non supporta il concetto di distruttore. I tipi che gestiscono le risorse che devono essere rilasciate quando gli oggetti non sono più necessari, devono implementare il metodo IDisposable::Dispose() al fine di consentire al garbace collector di attivare il metodo, quando deve liberare le risorse.
La principale difficoltà nell’utilizzo del C++/CLI è nella sintassi del linguaggio. Obiettivo di questo articolo, fatto di brevi flash, è di fornire le informazioni necessarie per chiarire gli aspetti formali del linguaggio.
La Property.
E’ essenzialmente un campo il cui fine è di incapsulare la rappresentazione interna dei dati di una classe. La definizione di una property ha la seguente forma:
private
: int _bufferSize; // Definizione Property
public: propertyint BufferSize {
int
get() { return _bufferSize; }
void
set(int size) {
_bufferSize = (length<= 0) ? 1
: size;
}
}
La property, in questo caso, richiede la definizione di un membro privato, che viene letto mediante il metodo get, mentre il metodo set viene utilizzato per scrivere nella variabile. In questo caso viene anche impedito la scrittura di un valore negativo.
Boxing e Unboxing.
In diverse occasioni occorre che un
oggetto di tipo value
allocato nello stack, debba essere passato ad una funzione che richiede un argomento di
tipo reference
che è allocato nella heap. Questa conversione è detta boxing/unboxing. In C++/CLI il boxing viene effettuato mediante gli handles:
int
size = 30;
Object^ objSize = size; // boxing implicito
Size = (
int
)objSize; // unboxing esplicito
Classes
. Per creare una managed class in C++/CLI occorre far precedere alla definizione della classe il prefisso
ref
,
per il resto la definizione segue il comune formalismo. Anche il distructor viene dichiarato nel medesimo modo, tuttavia il compilatore trasla la sua attivazione nella chiamata al metodo
Dispose(),
in modo trasparente. La definizione di una classe ha la seguente forma:
public
ref
class ComManager // Definizione della classe
{
private:
String^ RxBuf;
int
NumTxByte;
public:
String^ PortName;
public: ComManager::ComManager() // Costruttore
{
}
}