Quelltext der Seite C++/CLI

Zur Navigation springen Zur Suche springen

Du bist aus dem folgenden Grund nicht berechtigt, die Seite zu bearbeiten:

Deine IP-Adresse befindet sich in einem Bereich, der in allen Wikimedia Foundation-Wikis gesperrt ist.

Die Sperre wurde durchgeführt von ‪Hasley‬. Die angegebene Begründung ist Open proxy/Webhost: See the help page if you are affected: .

Beginn der Sperre: 17:21, 18. Dez. 2022
Ablauf der Sperre: 17:21, 18. Dez. 2025

Deine aktuelle IP-Adresse ist 62.210.136.28. Der gesperrte Bereich ist 62.210.0.0/16.

Bitte füge alle Informationen jeder Anfrage hinzu, die du stellst. Wenn du glaubst, dass die Sperre ein Fehler ist, kannst du zusätzliche Informationen und Hilfestellungen in der globalen Richtlinie „Keine offenen Proxys“ finden.

Anderenfalls stelle bitte eine Anfrage im Meta-Wiki, um die Sperre zu diskutieren. Du kannst auch eine E-Mail an die Steward-VRT-Queue per stewards@wikimedia.org inklusive aller obigen Details schicken.

Du kannst den Quelltext dieser Seite betrachten und kopieren.

'''C++/CLI''' ist eine von [[Microsoft]] entwickelte Variante der [[Programmiersprache]] [[C++]], die den Zugriff auf die virtuelle [[Laufzeitumgebung]] des [[.Net-Framework]]s mit Hilfe von speziell darauf zugeschnittenen Spracherweiterungen ermöglicht.

C++/CLI erfüllt die ebenfalls von Microsoft entwickelte Spezifikation namens [[Common Language Infrastructure]] (CLI) zur Sprach- und Plattform-neutralen Entwicklung und Ausführung von .NET-Anwendungen. Programme, die in C++/CLI geschrieben sind, können vom Compiler in [[Common Intermediate Language|CIL]] übersetzt und auf der [[Virtuelle Maschine|virtuellen Maschine]] der .NET-Plattform betrieben werden.

Seit Dezember 2005 liegt ein offiziell von der [[Ecma International|Ecma]] ratifizierter Standard für C++/CLI vor.

[[Microsoft Visual Studio .NET|Microsoft Visual Studio]] ab Version 2005 und das Compiler-Frontend der [[Edison Design Group]] bieten eine Implementierung von C++/CLI an.<ref>{{Internetquelle |url=https://www.edg.com/docs/edg_cpp.pdf |titel=C++ Front End |titelerg=Internal Documentation (excerpt); Version 6.5 |werk=edg.com |hrsg=Edison Design Group |datum=2023-06-21 |format=PDF; 529&nbsp;kB |sprache=en |abruf=2023-08-08}}</ref>

== Sinn und Zweck der Erweiterungen ==

Ziele bei der Entwicklung von C++/CLI waren:
* Schaffung einer eleganten Syntax, die gut zum bisherigen C++ passt. Wer bereits mit C++ vertraut ist, soll die Spracherweiterungen als möglichst natürlich empfinden.
* Komfortable Unterstützung von Besonderheiten der CLI wie [[Eigenschaft (Programmierung)|Eigenschaften]], [[Ereignis (Programmierung)|Ereignisse]], [[Generischer Typ|generische Typen]], [[automatische Speicherbereinigung]], [[Referenz (Programmierung)|Referenzklassen]] usw.
* Gute Unterstützung von Sprachmitteln, die im bisherigen C++ verbreitet sind, wie etwa Templates oder deterministische Deinitialisierungen, und zwar für alle Typen, einschließlich der neuartigen CLI-Klassen.
* Kompatibilität mit bestehenden C++-Programmen durch das Einbringen von fast ausschließlich reinen Erweiterungen gegenüber [[Internationale Organisation für Normung|ISO]]-C++.

== Unterschiede zu Managed C++ ==

C++/CLI ist das Ergebnis einer grundlegenden Überarbeitung von Managed C++, der ersten Version von C++ mit Spracherweiterungen für die .NET-Plattform. Managed C++ litt unter Akzeptanzproblemen, weil viele Programmierer die Syntaxerweiterungen als schwer lesbar empfanden. Beispielsweise enthielt die Syntax Bestandteile, die nicht eindeutig erkennen ließen, ob verwaltete oder nichtverwaltete [[Objekt (Programmierung)|Objekte]] erzeugt werden.<ref>{{Internetquelle |autor=Kenny Kerr |url=https://learn.microsoft.com/en-us/previous-versions/ms379617(v=vs.80) |titel=C++: The Most Powerful Language for .NET Framework |werk=learn.microsoft.com |hrsg=Microsoft |datum=2004-07 |sprache=en |abruf=2010-10-21}}</ref>

Auch wirkten die mit Managed C++ eingeführten Syntaxelemente für viele Programmierer behelfsmäßig in die Sprache integriert. So waren z.&nbsp;B. viele [[Schlüsselwort (Programmierung)|Schlüsselwörter]] eingeführt worden, die mit zwei Unterstrichen beginnen. Zwar ist dies bei Spracherweiterungen gegenüber Standard-C++ üblich, die große Anzahl solcher Schlüsselwörter, sowie deren starke Durchdringung in Programmen, die von den Erweiterungen Gebrauch machten, wirkten jedoch störend auf das Gesamtbild der Quelltexte.

Beispiele:

{| class="wikitable"
! Managed C++
! C++/CLI
|-----
| <span style="font-family:monospace;color:#0000FF">__gc __interface</span>
| <span style="font-family:monospace;"><span style="color:#0000FF">interface class</span></span>
|-----
|<span style="font-family:monospace;">Console::WriteLine(<span style="color:#0000FF">S</span>"{0}", <span style="color:#0000FF">__box(</span>15<span style="color:#0000FF">)</span>);</span>
| <span style="font-family:monospace;">Console::WriteLine("{0}", 15);</span>
|----
|align="center" colspan="2"|
|-----
| <span style="font-family:monospace;"><span style="color:#0000FF">int</span> f()<span style="color:#0000FF">__gc[]</span>; // Deklaration</span>
| <span style="font-family:monospace;"><span style="color:#0000FF">array<int>^</span> f(); // Deklaration</span> <sup>1)</sup>
|-----
| <span style="font-family:monospace;">Object<span style="color:#0000FF">*</span> A <span style="color:#0000FF">__gc[]</span> = { <span style="color:#0000FF">__box(</span>41<span style="color:#0000FF">)</span>, <span style="color:#0000FF">__box(</span>42<span style="color:#0000FF">)</span> };</span>
| <span style="font-family:monospace;"><span style="color:#0000FF">array<</span>Object<span style="color:#0000FF">^>^</span> A = { 41, 42 };</span>
|}
1) Deklaration einer Funktion f, die eine CLI-Reihung (array) zurückgibt.

Im Unterschied zu Managed C++ wird die [[Destruktor]]-Syntax <code>~T()</code> nicht mehr auf den [[Garbage Collection#Finalisierung|Finalisierer]] abgebildet. Destruktor und Finalisierer werden in C++/CLI unterschieden; der Finalisierer hat jetzt die Syntax <code>!T()</code>. Der Destruktor ist außerdem identisch mit der Funktion <code>Dispose</code> (dies wurde durch technische Änderungen an der [[Common Language Runtime|CLR]] ermöglicht).

== Weitere Neuerungen ==
Weitere Neuerungen gegenüber ISO-C++ sind: verbesserte Aufzählungsklassen (enum class), [[Delegate (CLI)|Delegaten]], Verpacken (''boxing''), Schnittstellenklassen, versiegelte Klassen, [[Attribut (Programmierung)#C#|Attribute]] usw.

== Objektzeiger ==
Die augenfälligste Neuerung ist die Syntax <code>^</code> für Objektzeiger (manchmal auch ''[[Handle]]s'' genannt). Beispiel:

 T<span style="color:#0000FF">^</span> whole_object_pointer = <span style="color:#0000FF">gcnew</span> T(a, b);

Dabei ist <span style="font-family:monospace;">gcnew</span> ein Operator zur [[Allokation (Informatik)|Allokation]] von Objekten, die von der [[Automatische Speicherbereinigung|automatischen Speicherbereinigung]] verwaltet werden.

Im Vergleich dazu die herkömmliche Syntax für [[Zeiger (Informatik)|Zeiger]]:

 T<span style="color:#0000FF">*</span> plain_old_pointer = <span style="color:#0000FF">new</span> T(a, b);

=== Deinitialisierung und Speicherfreigabe ===
Anders als bei gewöhnlichen Zeigern wird beim Löschen von Handles mittels <code>delete</code> zwar der Destruktor aufgerufen, nicht aber der Speicher freigegeben. Stattdessen wird der vom Objekt belegte Speicher durch die automatische Speicherbereinigung an das System zurückgegeben.

Im Unterschied zu anderen Sprachen mit automatischer Speicherbereinigung (z.&nbsp;B. [[C-Sharp|C#]] oder [[Java (Programmiersprache)|Java]]) wird hier also die problematische Zusammenfassung der Verwaltung von Speicher und anderen Ressourcen voneinander getrennt: Speicher und andere Ressourcen werden nicht mehr zusammen mit Hilfe der Speicherbereinigung freigegeben (also keine deterministische Deinitialisierung); siehe [[Automatische Speicherbereinigung#Finalisierung|Finalisierung]].

=== Als automatische Variablen anlegbare CLI-Objekte ===
Eine weitere technische Neuerung und einer der wichtigsten Unterschiede zu anderen Sprachen mit automatischer Speicherbereinigung sind die als [[automatische Variable]]n (d.&nbsp;h. auf dem Stack) anlegbaren CLI-Objekte. Die Lebensdauer von automatischen Variablen endet in dem Augenblick, in welchem sie ihren [[Gültigkeitsbereich]] verlassen.

Im Zusammenspiel mit den neuartigen Objektzeigern bleiben in C++ dadurch häufig angewandte Programmiertechniken wie [[Ressourcenbelegung ist Initialisierung|RAII]] (Abkürzung für engl. ''resource acquisition is initialization'') auch für die mit der automatischen Speicherbereinigung verwalteten CLI-Objekte möglich. Fehleranfällige Kodiertechniken, wie sie aus anderen Programmiersprachen bekannt sind, lassen sich damit vermeiden.

Dazu ein Beispiel in C++/CLI:
<syntaxhighlight lang="cpp">
void Uebertragung()
{
  MessageQueue source("server\\sourceQueue");
  String^ mqname = safe_cast<String^>(source.Receive().Body);

  MessageQueue dest1("server\\" + mqname), dest2("backup\\" + mqname);
  Message^ message = source.Receive();
  dest1.Send(message);
  dest2.Send(message);
}
</syntaxhighlight>
Beim Verlassen der Funktion <code>Uebertragung</code> (mit <code>return</code> oder beim Auftreten einer [[Ausnahmebehandlung|Ausnahme]]) rufen Objekte implizit ihre Funktion <code>Dispose</code> auf, und zwar in umgekehrter Reihenfolge zu ihrer Konstruktion. Im obigen Beispiel also wird zuerst der Destruktor von <code>dest2</code> aufgerufen, dann der von <code>dest1</code> und zuletzt der von <code>source</code>, da diese Objekte in der Reihenfolge <code>source</code>, <code>dest1</code>, <code>dest2</code> konstruiert wurden.

Wenn ein automatisches Objekt seinen Gültigkeitsbereich verlässt, oder beim Löschen mit <code>delete</code> wird sein Destruktor aufgerufen. Der Compiler unterdrückt dann den Aufruf der normalerweise von der automatischen Speicherverwaltung angestoßenen [[Automatische Speicherbereinigung#Finalisierung|Finalisierungsfunktion]].

Der Wegfall von Finalisierungsfunktionen kann sich insgesamt positiv auf die Ausführungsgeschwindigkeit auswirken, hilft aber noch andere Probleme zu vermeiden; zu Problemen bei Verwendung der Finalisierungsfunktion siehe [[Automatische Speicherbereinigung#Finalisierung|Finalisierung]].

Im Unterschied zu C++/CLI muss beispielsweise in Java oder C# zur Ressourcenfreigabe eine entsprechende Funktion (in C# <code>Dispose</code>, in Java meist <code>close</code>) immer explizit aufgerufen werden. Beide Sprachen haben daher spezielle Syntaxkonstrukte entwickelt, mit denen solche Aufrufe sichergestellt werden sollen: In C# sind das die sogenannten ''using-Blöcke'', in Java das ''try-with-resources''-Konstrukt. Solche Blöcke nehmen dem Programmierer zwar die Sicherstellung von Dispose-Aufrufen beim Verlassen des Blocks ab, müssen aber immer mitangegeben werden und sind daher in dieser Hinsicht immer noch fehleranfälliger als die deterministische Deinitialisierung von C++/CLI.

== Vergleich mit anderen .NET-Sprachen ==
Eine Besonderheit von C++/CLI ist die Mischbarkeit von Code, der auf der virtuellen Maschine läuft, und Code, der direkt auf der [[CPU]] ausgeführt wird. Beide Arten von Programmcode können in einer einzigen Programmdatei zusammengestellt werden.<ref>{{Internetquelle |autor=Tyler Whitney et al. |url=https://learn.microsoft.com/en-us/cpp/dotnet/mixed-native-and-managed-assemblies |titel=Mixed (native and managed) assemblies |werk=learn.microsoft.com |hrsg=Microsoft |datum=2021-08-03 |sprache=en |abruf=2023-08-08}}</ref> Mit dieser Möglichkeit nimmt C++/CLI bislang eine Sonderstellung unter den .NET-Sprachen ein.

== Weblinks ==
* [https://www.ecma-international.org/publications-and-standards/standards/ecma-372/ Standard ECMA-372: C++/CLI Language Specification] (englisch)
* [https://learn.microsoft.com/en-us/previous-versions/ms379617(v=vs.80) C++: The Most Powerful Language for .NET Framework] (englisch) Beschreibung der Gründe für die Syntaxänderungen von Managed C++ nach C++/CLI.

== Einzelnachweise ==
<references />

[[Kategorie:C++]]
[[Kategorie:.NET]]
[[Kategorie:Virtuelle Maschine]]
[[Kategorie:Programmiersprache für die Common Language Runtime]]

Folgende Vorlagen werden von diesem Artikel verwendet:

Vorlage:Internetquelle (Quelltext anzeigen) (schreibgeschützt (nur Sichter))
Vorlage:Str len (Quelltext anzeigen) (schreibgeschützt (nur Sichter))
Modul:DateTime (Quelltext anzeigen) (schreibgeschützt (nur Administratoren))
Modul:DateTime/local (Quelltext anzeigen) (schreibgeschützt (nur Administratoren))
Modul:Multilingual (Quelltext anzeigen) (schreibgeschützt (nur Sichter))
Modul:Multilingual/config (Quelltext anzeigen) (schreibgeschützt (nur Sichter))
Modul:Multilingual/names (Quelltext anzeigen) (schreibgeschützt (nur Sichter))
Modul:Str (Quelltext anzeigen) (schreibgeschützt (nur Administratoren))
Modul:TemplUtl (Quelltext anzeigen) (schreibgeschützt (nur Sichter))
Modul:TemplatePar (Quelltext anzeigen) (schreibgeschützt (nur Administratoren))
Modul:Text (Quelltext anzeigen) (schreibgeschützt (nur Sichter))
Modul:URLutil (Quelltext anzeigen) (schreibgeschützt (nur Administratoren))
Modul:Vorlage:Internetquelle (Quelltext anzeigen) (schreibgeschützt (nur Sichter))
Modul:WLink (Quelltext anzeigen) (schreibgeschützt (nur Administratoren))

Zurück zur Seite C++/CLI.

Abgerufen von „https://de.wikipedia.org/wiki/C%2B%2B/CLI“

Quelltext der Seite C++/CLI

Navigationsmenü

Suche