C++/CLI: differenze tra le versioni

Versione delle 13:23, 10 feb 2018

Versione attuale delle 02:53, 26 dic 2024

(15 versioni intermedie di 12 utenti non mostrate)

Riga 1:

{{T|inglese|informatica|dicembre 2016}}

'''C++/CLI''' ([[C++]] modificato per la [[Common Language Infrastructure]]) è un [[linguaggio di programmazione]] specifico creato da Microsoft e destinato a sostituire le [[Managed extensions per C++]]. Si tratta di una revisione completa che mira a semplificare la vecchia sintassi del Managed C++, ora deprecato.<ref>[httphttps://msdn.microsoft.com/en-us/library/b23b94s7.aspx Managed Extensions for C++ Syntax Upgrade Checklist - MSDN Library]</ref> C++/CLI è stato standardizzato da [[ECMA International|EcmaECMA]] come '''ECMA-372'''. È disponibile in [[Microsoft Visual Studio|Visual Studio]] 2005, 2008, 2010, 2012, 2013, 2015 e 20152017, incluse le versioni Express.

== Cambiamenti sintattici ==

C++/CLI è concepito come un linguaggio a sé stante, (ad esempio con un nuovo insieme di parole chiave), a differenza del Managed C++ (MC++), che è piuttosto un ''superset'' del C++ in cui le parole chiave non standard erano identifcateidentificate con <code>__gc</code> o <code>__value</code>. Di conseguenza, introduce alcune importanti modifiche sintattiche, legate principalmente all'eliminazione di identificatori ambigui e all'aggiunta di funzionalità specifiche NET.

Molte sintassi in conflitto, come le versioni multiple dell'operatore <code>new()</code> in MC++, sono state separate: nel C++/CLI e in . NET i tipi di riferimento vengono creati con la nuova parola chiave <code>gcnew</code> (che sta per ''[[Garbage collection|garbage collected]] new ()''). Inoltre, C++/CLI ha introdotto il concetto dei generici da . NET (simile, per gli scopi più comuni, ai template standard C++, ma molto diversi nella loro implementazione).

===PuntatoriHandles===

In MC++, vi erano due diversi tipi di [[Puntatore (programmazione)|puntatori]]: i puntatori <code>__nogc</code>, essenzialmente ordinari puntatori C++, e i puntatori <code>__gc</code>, usati per i tipi di riferimento . NET. Nel C++/CLI, invece, l'unico tipo di puntatore è il normale puntatore C++, mentre i tipi di riferimento . NET sono accessibili attraverso un ''handle'' usando la nuova sintassi <code>ClassName^</code> invece di <code>ClassName*</code>. Questo nuovo costrutto è particolarmente utile quando il codice contiene insieme codice C++ standard e codice gestito; consente di rendere chiaro quali sono gli oggetti gestiti dal ''garbage collection'' automatico di. .NET e quali sono invece gli oggetti che il programmatore deve distruggere in modo esplicito.

===Rintracciamento di riferimenti===

Un '''rintracciamento di riferimenti''' (anche detto tracking references) in C++/CLI è un handle di una variabile passata per riferimento. Come concetto è simile all'utilizzo di <code>*&</code> (riferimento a un puntatore) nel C++ classico, e (nella dichiarazione di funzioni) corrisponde alla parola chiave <code>ref</code> applicata a tipi in C#, o <code> ByRef </code> in. NET. Per indicare un rintracciamento di riferimento il C++/CLI utilizza come sintassi <code>^%</code>.

Un esempio sull'utilizzo del ''rintracciamento di riferimenti'' viene mostrato nel codice che segue. Rimpiazzare il rintracciamento di riferimenti con un handle regolare lascerebbe l'array di stringhe risultante con 10 stringhe handles non inizializzate, in quanto sarebbero impostate solamente le stringhe handle nell'array, dato che vengono passate per valore e non per riferimento.

<syntaxhighlight lang=Cpp>

int main()

{

array<String^> ^arr = gcnew array<String^>(10);

int i = 0;

for each(String^% s in arr) {

s = i++.ToString();

}

return 0;

}

</syntaxhighlight>

Si noti che in C# tale costrutto non sarebbe permesso, dato che non permette il passaggio di valori per riferimento mediante cicli <code>foreach</code>. Pertanto occorrerebbe una soluzione secondaria o temporanea.

===Finalizzatori e variabili automatiche===

Un'ulteriore differenza con C++/CLI è l'introduzione sintattica di [[finalizzatori]] <code>!ClassName</code>, un tipo speciale di distruttore non deterministico eseguito come parte della [[Garbage collection|garbage collection routine]]. La sintassi dei distruttori classica del C++, quale <code>~ClassName()</code>, esiste anche per oggetti gestiti, e riflette meglio la semantica "tradizionale" del C++ di una distruzione deterministica (di fatto i distruttori possono essere invocati a livello di codice mediante <code>delete</code>.

Nel paradigma .NET naturale, il modello di distruzione non deterministico annulla il metodo protetto <code>Finalize</code> della classe root <code>Object</code>; mentre il modello deterministico è implementato attraverso il metodo <code>Dispose</code> dell'[[interfaccia]] <code>IDisposable</code> (che il compilatore C++/CLI trasforma in un distruttore). Oggetti provenienti da C# o VB.NET, che annullano il metodo Dipose, possono essere posti manualmente in C++/CLI mediante <code>delete</code>, esattamente come le classi. NET in C++/CLI.

<syntaxhighlight lang=Cpp>

// C++/CLI

ref class MiaClasse{

public:

MiaClasse(); // costruttore

~MiaClasse(); // distruttore (deterministico) (implementato come IDisposable.Dispose())

protected:

!MiaClasse(); // finalizzatore (distruttore non-deterministico) (implemented as Finalize())

public:

static void Test(){

MiaClasse automatic; // Non un handle, e non inizializzato: il compilatore invoca qui il costruttore

MiaClasse ^user = gcnew MiaClasse();

delete user;

// Il compilatore invoca il distruttore automatico quando l'automatico esce dalla visibilità (scope)

}

};

</syntaxhighlight>

===Operatore di overloading===

Un operatore di [[overloading]] (o di sovraccarico) funziona esattamente come nel C++ classico. Ogni * diventa un ^, ogni & diventa un %, con il resto della sintassi completamente invariato, con un'eccezione: per le classi. NET, l'operatore di overloading è instanziabile e invocabile non solo per le classi stesse, ma anche per i riferimenti alle classi. Tale peculiarità è necessaria per dare a ''ref class'' la semantica per l'operatore di overloading che le ''ref classes'' .NET si aspettano (Al contrario, questo significa anche che le ref classes presenti nel framework. NET fanno riferimento operatori di overloading, spesso implicitamente implementati in C++/CLI.

Per esempio, facendo un paragone tra due Stringhe di riferimento (String^) mediante l'operatore == restituirà "true" (vero) a prescindere. Essendo l'operatore di overloading statico, effettuare un cast a Object^ rimuove la semantica di overloading.

<syntaxhighlight lang=Cpp>

//effetti sulla referenza dell'operatore di overloading

String ^s1 = "abc";

String ^s2 = "ab" + "c";

Object ^o1 = s1;

Object ^o2 = s2;

s1 == s2; // true, perché riferiscono allo stesso oggetto

o1 == o2; // false, perché non sono lo stesso oggetto

</syntaxhighlight>

==C++/CX==

Il nuovo [[C++/CX]] con l'obiettivo di [[WinRT]], sebbene produca interamente codice "unmanaged", prende in prestito il concetto di ref e la sintassi ^ per la referenza sul conteggio delle componenti di WinRT, che sono simili agli oggetti [[Component Object Model|COM]].<ref>[https://blogs.msdn.com/b/vcblog/archive/2011/10/20/10228473.aspx Inside the C++/CX Design - Visual C++ Team Blog - Site Home - MSDN Blogs]</ref>

==Note==

<references />

==Collegamenti esterni==

* [https://www.ecma-international.org/publications/standards/Ecma-372.htm ECMA 372: C++/CLI Language Specification]

* [[Herb Sutter]]: [https://blogs.msdn.com/hsutter/archive/2003/11/23/53519.aspx C++/CLI keywords: Under the hood]

* [[Herb Sutter]]: [http://www.gotw.ca/publications/C++CLIRationale.pdf C++/CLI Rationale]

* [https://msdn.microsoft.com/en-us/library/xey702bw.aspx MSDN documentation for C++/CLI]

* [http://appft1.uspto.gov/netacgi/nph-Parser?Sect1=PTO1&Sect2=HITOFF&d=PG01&p=1&u=%2Fnetahtml%2FPTO%2Fsrchnum.html&r=1&f=G&l=50&s1=%2220060089942%22.PGNR.&OS=DN/20060089942&RS=DN/20060089942 Patent application regarding whitespace in keywords]

* [http://www.stroustrup.com/bs_faq.html#CppCLI Bjarne Stroustrup's (designer/author of C++) views on C++/CLI]

* [[Stanley B. Lippman]]: [https://web.archive.org/web/20080205003004/http://msdn.microsoft.com/msdnmag/issues/06/00/PureC/default.aspx Hello, C++/CLI]

* [[Stanley B. Lippman]]: [https://blogs.msdn.com/slippman/archive/2004/08/05/209606.aspx Why C++/CLI Supports both Templates for CLI Types and the CLI Generic Mechanism]

{{Controllo di autorità}}

{{DEFAULTSORT:C++ CLI}}

[[Categoria:Framework .NET]]