Verwaltete Ausdrücke in C++

Artikel
09/02/2008

Aktualisiert: November 2007

Dieses Thema gilt für folgende Anwendungsbereiche:

Edition	Visual Basic	C#	C++	Web Developer
Express
Standard
Pro und Team

Tabellenlegende:

	Vorhanden
	Nicht vorhanden
	Befehl oder Befehle, die standardmäßig ausgeblendet sind.

Die meisten in Visual C++ verfassten Ausdrücke werden von der verwalteten Ausdrucksauswertung akzeptiert. In den folgenden Themen erhalten Sie neben spezifischen Informationen auch Erläuterungen zu einigen der nicht unterstützten Ausdruckstypen:

Bezeichner und Typen
Funktionsauswertung
Operatoren
Überladene Operatoren
Zeichenfolgen
Typumwandlungen
Vergleich und Zuweisung von Objekten
typeof-Operator und sizeof-Operator
Boxing
Eigenschaftenauswertung

Die Ausdrucksauswertung ignoriert die Zugriffsqualifizierer public, protected, internal und private. Sie können eine private-Methode z. B. im Fenster Überwachen aufrufen.

Die Ausdrucksauswertung führt alle Auswertungen in einem impliziten, unsicheren Kontext durch. Das geschieht unabhängig davon, ob der ausgeführte Code sicher oder unsicher ist.

Mithilfe der Regeln für die automatische Erweiterung zeigt der Debugger den Inhalt eines Datentyps in aussagekräftiger Form an. Falls erforderlich, können Sie benutzerdefinierte Elemente für die automatische Erweiterung hinzufügen, um eigene benutzerdefinierte Datentypen anzuzeigen. Weitere Informationen finden Sie unter Anzeigen von Elementen eines benutzerdefinierten Datentyps.

Bezeichner und Typen

In Debuggerausdrücken können alle Bezeichner verwendet werden, die innerhalb des aktuellen Gültigkeitsbereichs sichtbar sind. Wenn der Debugger beispielsweise in der magh-Funktion angehalten wird, können Sie jeden innerhalb von magh sichtbaren Bezeichner verwenden, einschließlich von Konstanten, Variablennamen und Funktionsnamen.

Der Debugger kann alle Variablen eines primitive-Typs, eines enum-Typs oder eines intrinsic-Typs ordnungsgemäß anzeigen. Bei Variablen des class-Typs zeigt der Debugger den Wert ordnungsgemäß an, der auf dem in der Ableitungshierarchie ganz unten stehenden Typ basiert. Angenommen, es gibt ein Objekt leo vom Typ lion, der vom Typ cat abgeleitet ist. Bei Auswertung von leo.clawlength würden Sie in diesem Fall den korrekten Wert für ein Objekt vom Typ lion erhalten.

Sie können jedem linksseitigen Ausdruck, der ein l-Wert eines primitiven Typs ist, einen neuen Wert zuweisen. Zuweisungen für Klassen- und Arraytypen werden nicht unterstützt.

Funktionsauswertung

Der Debugger unterstützt die Auswertung von Funktionen, einschließlich überladener Funktionen. Daher können Sie einen der folgenden Ausdrücke eingeben, um die korrekte Version der überladenen Funktion aufzurufen:

kanga ()
kanga (roo)

Beim Auswerten einer Funktion im Debugger wird der Code dieser Funktion aufgerufen und ausgeführt. Wenn die Funktion Nebeneffekte aufweist (z. B. Zuweisen von Speicher oder Ändern des Werts einer globalen Variablen), wird durch das Auswerten der Funktion in einem Debugfenster der Status des Programms geändert, was zu unerwarteten Ergebnissen führen kann.

Wenn Sie in einer überladenen Funktion einen Haltepunkt festlegen, hängt dessen Position davon ab, wie Sie die Funktion angeben. Wenn Sie lediglich den Namen der Funktion angeben, legt der Debugger an jeder Überladung dieses Funktionsnamens einen Haltepunkt fest. Wenn Sie dagegen die vollständige Signatur angeben, d. h. den Funktionsnamen und die komplette Argumentliste, wird nur an der angegebenen Überladung ein Haltepunkt festgelegt.

Operatoren

Der Debugger wertet die meisten integrierten Operatoren ordnungsgemäß aus, einschließlich der folgenden:

Relationale Operatoren: (expr1 >expr2, expr1 < expr2, expr1 <= expr2, expr1 => expr2, expr1 == expr2, expr1 != expr2).
Boolesche Operatoren: (expr1 && expr2, expr1 || expr2).
Bedingter Operator: (expr1 ? expr2 : expr3).
Arithmetische Operatoren: ( expr1 + expr2, expr1 - expr2,expr1 * expr2, expr1 / expr2, expr1 % expr2).
Bitweise Operatoren: (expr1 & expr2, expr1 ^ expr2, expr1 | expr2, expr1 ~ expr2).
Schiebeoperatoren. Beispiele: (expr1 >> expr2, expr1 << expr2, expr1 >>> expr2).
Zuweisungsoperatoren: ( lvalue = expr2, lvalue *= expr2, lvalue /= expr2, lvalue %= expr2, lvalue += expr2, lvalue -= expr2, lvalue <<= expr2, lvalue >>=expr2, lvalue &= expr2, lvalue ^= expr2, lvalue |= expr2 ).
Unäre Operatoren Beispiele: ( + expr1, - expr1, expr1++, ++ expr1, expr1--, -- expr1 ).

Sie können den Kommaoperator verwenden, um eine Reihe von Ausdrücken einzugeben: expr1, expr2,expr3.

Überladene Operatoren

Die meisten überladenen Operatoren funktionieren im Debugger.

Die überladenen Infixoperatoren +, -, /, % und & funktionieren:

expr1 + expr2
expr1expr2
expr1 / expr2
expr1 % expr2
expr1 & expr2

Die überladenen Infixoperatoren =, &&, &, ||, | und ^ funktionieren nicht:

expr1 = expr2
expr1 && expr2
expr1 & expr2
expr1 || expr2
expr1 | expr2
expr1 ^ expr2

Die überladenen relationalen Operatoren ==, !=, >, <, >= und <= funktionieren nicht in C++:

expr1 == expr2
expr1 != expr2
expr1 > expr2
expr1 < expr2
expr1 >= expr2
expr1 <= expr2

Die überladenen Infixoperatoren |, ^, <<, >>, >, <, >= und <= funktionieren nicht:

expr1 | expr2
expr1 ^ expr2
expr1 << expr2
expr1 >> expr2
expr1 > expr2
expr1 < expr2
expr1 >= expr2
expr1 <= expr2

Die überladenen Präfixoperatoren +, -, ++, --, ! und ~ funktionieren:

+ + expr1
- - expr1
++ ++ expr1
-- -- expr1
! expr1
~ ~ expr1

Die überladenen Suffixoperatoren ++ und -- funktionieren:

expr1++
expr1--

Der überladene Operator [] funktioniert:

x[expr2]

Mehrdimensionale Arrays

Die C++-Ausdrucksauswertung verwendet Syntax im C#-Format für mehrdimensionale Arrays. Beispiel:

c[0,0]

Die Verwendung normaler C++-Syntax generiert einen Fehler:

c[0][0] Fehler: Index '0' nicht im zulässigen Bereich für Zeiger/Array 'c'

Zeichenfolgen

Der Debugger erkennt den indizierten Operator sowohl bei der Verwendung mit Zeichenfolgen als auch bei der Verwendung mit Arrays. Sie können also beispielsweise Folgendes eingeben:

"hello world"[0]

Im Fenster Überwachen wird der richtige Wert angezeigt:

'h'

Typumwandlungen

Einfache Typumwandlungsausdrücke funktionieren im Debugger:

(A)x

Typumwandlungen mit Zeigern funktionieren dagegen nicht:

Benutzerdefinierte Typumwandlungen funktionieren im Debugger für Visual C++ nicht.

Vergleich und Zuweisung von Objekten

Das Vergleichen und Zuweisen von Objekten im Debugger funktioniert nicht für Visual C++.

typeof-Operator und sizeof-Operator

Der Debugger unterstützt den typeof-Operator und den sizeof-Operator, indem er ihn jeweils in die entsprechende .NET Framework-Funktion umwandelt.

typeof ( expression )

wird umgewandelt in:

System.Type.GetType(expression )

Anschließend wertet der Debugger diesen umgewandelten Ausdruck aus.

Der sizeof-Operator wird vom Debugger nicht unterstützt.

Boxing und Unboxing

Boxing und Unboxing werden von der Ausdrucksauswertung des Debuggers in Visual C++ nicht unterstützt. Weitere Informationen hierzu finden Sie unter Boxing und Unboxing. Wenn eine ganzzahlige Variable i durch Boxing in ein Objekt konvertiert wurde, wertet der Debugger i als ganze Zahl (nicht als Objekt) aus. Die Ergebnisse entsprechen dann möglicherweise nicht Ihren Erwartungen. Weitere Informationen darüber, wie Werte durch Boxing beeinflusst werden, finden Sie unter Boxing-Konvertierung.

Eigenschaftenauswertung

Der Debugger kann in beliebigen Variablenfenstern Eigenschaften auswerten. Beim Auswerten von Eigenschaften im Debugger können jedoch Nebeneffekte auftreten, die unerwartete und unerwünschte Ergebnisse liefern. Sie können die Eigenschaftenauswertung im Dialogfeld Optionen deaktivieren, um eventuellen Nebeneffekten durch eine versehentliche Auswertung vorzubeugen.

Freigeben über