Expressions managées en C++

Article
08/21/2008

Mise à jour : novembre 2007

Cette rubrique s'applique à :

Édition	Visual Basic	C#	C++	Web Developer
Express
Standard
Pro et Team

Légende du tableau :

	Applicable
	Non applicable
	Commande ou commandes masquées par défaut.

L'évaluateur d'expression managée accepte la plupart des expressions écrites en Visual C++. Les rubriques suivantes donnent des informations spécifiques et décrivent certains types d'expression qui ne sont pas pris en charge :

Identificateurs et types
Évaluation de fonction
Opérateurs
Opérateurs surchargés
Chaînes
Casts
Comparaison et assignation d'objet
Opérateurs typeof et sizeof
Conversion boxing
Évaluation de propriété

L'évaluateur d'expression ignore les qualificateurs d'accès, public, protected, internal et private. Vous pouvez appeler une méthode private depuis la fenêtre Espion, par exemple.

L'évaluateur d'expression effectue toutes les évaluations dans un contexte unsafe implicite, que le code exécuté soit safe ou unsafe.

Le débogueur utilise les règles de développement automatique pour afficher le contenu d'un type de données sous une forme significative. Si vous le souhaitez, vous pouvez ajouter des éléments de développement automatique personnalisés pour afficher vos propres types de données personnalisés. Pour plus d'informations, consultez Affichage d'éléments d'un type de données personnalisé.

Identificateurs et types

Les expressions du débogueur peuvent utiliser n'importe quel identificateur visible à l'intérieur de la portée actuelle. Si le débogueur est interrompu dans la fonction magh, par exemple, vous pouvez utiliser n'importe quel identificateur visible dans magh, y compris les constantes, les noms de variables et les noms de fonctions.

Le débogueur peut correctement afficher n'importe quelle variable de type primitive, enum ou intrinsic. Pour les variables de type class, le débogueur affiche correctement la valeur en fonction du type le plus dérivé. Si vous avez un objet leo de type lion, dérivé du type cat, vous pouvez évaluer leo.clawlength et obtenir la valeur correcte pour un objet de type lion.

Vous pouvez assigner une nouvelle valeur à toute expression de gauche qui a une valeur l de type primitif. Les assignations aux types classe et tableau ne sont pas prises en charge.

Évaluation de fonction

Le débogueur prend en charge l'évaluation des fonctions, y compris les fonctions surchargées. Par conséquent, vous pouvez entrer l'une des expressions suivantes et le débogueur appellera la version correcte de la fonction surchargée :

kanga ()
kanga (roo)

L'évaluation d'une fonction dans le débogueur appelle et exécute le code pour cette fonction. Si la fonction a des effets secondaires, par exemple l'allocation de mémoire ou le changement de la valeur d'une variable globale, l'évaluation de la fonction dans une fenêtre du débogueur change l'état de votre programme, ce qui peut produire des résultats inattendus.

Lorsque vous définissez un point d'arrêt sur une fonction surchargée, l'emplacement du point d'arrêt dépend de la façon dont vous spécifiez la fonction. Si vous spécifiez uniquement le nom de la fonction, le débogueur définit un point d'arrêt sur chaque surcharge du nom de cette fonction. Si vous spécifiez la signature complète (nom de fonction et liste d'arguments complète), le débogueur définit un point d'arrêt sur la surcharge spécifiée.

Opérateurs

Le débogueur évalue correctement la plupart des opérateurs intégrés, y compris :

Les opérateurs relationnels : (expr1 >expr2, expr1 < expr2, expr1 <= expr2, expr1 => expr2, expr1 == expr2, expr1 != expr2).
Les opérateurs booléens : (expr1 && expr2, expr1 || expr2).
L'opérateur conditionnel : expr1 ? expr2 : expr3).
Les opérateurs arithmétiques (expr1 + expr2, expr1 - expr2,expr1 * expr2, expr1 / expr2, expr1 % expr2).
Les opérateurs de bits : (expr1 & expr2, expr1 ^ expr2, expr1 | expr2, expr1 ~ expr2).
Opérateurs de décalage. Exemples : (expr1 >> expr2, expr1 << expr2, expr1 >>> expr2).
Les opérateurs d'assignation : ( lvalue = expr2, lvalue *= expr2, lvalue /= expr2, lvalue %= expr2, lvalue += expr2, lvalue -= expr2, lvalue <<= expr2, lvalue >>=expr2, lvalue &= expr2, lvalue ^= expr2, lvalue |= expr2).
Les opérateurs unaires. Exemples : (+ expr1, - expr1, expr1++, ++ expr1, expr1--, -- expr1).

Vous pouvez utiliser l'opérateur virgule pour entrer une série d'expressions : expr1, expr2,expr3.

Opérateurs surchargés

La plupart des opérateurs surchargés fonctionnent dans le débogueur.

Les opérateurs infix surchargés +, -, /, % et & fonctionnent.

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

Les opérateurs infixes surchargés =, &&, &, ||, | et ^ ne fonctionnent pas :

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

Les opérateurs relationnels surchargés ==, !=, >, <, >= et <= ne fonctionnent pas en C++ :

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

Les opérateurs infixes surchargés |, ^, <<, >>, >, <, >= et <= ne fonctionnent pas :

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

Les opérateurs de préfixe surchargés +, -, ++, --, ! et ~ fonctionnent :

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

Les opérateurs de suffixe surchargés ++ et -- fonctionnent :

expr1++
expr1--

L'opérateur surchargé [] fonctionne :

x[expr2]

Tableaux multidimensionnels

L'évaluateur d'expression C++ utilise une syntaxe de style C# pour les tableaux multidimensionnels. Par exemple :

c[0,0]

L'utilisation d'une syntaxe C++ normale génère une erreur :

c[0][0] erreur : l'index '0' est hors limites pour le pointeur/tableau 'c'

Chaînes

Le débogueur reconnaît l'opérateur indexé lorsqu'il est utilisé avec des chaînes et des tableaux. Par exemple, vous pouvez entrer :

"hello world"[0]

La fenêtre Espion affiche la valeur correcte :

'h'

Casts

Les expressions de cast simples fonctionnent dans le débogueur :

(A)x

Les casts qui utilisent des pointeurs ne fonctionnent pas dans le débogueur :

Les casts définis par l'utilisateur ne fonctionnent pas dans le débogueur pour Visual C++.

Comparaison et assignation d'objet

La comparaison et l'assignation d'objet dans le débogueur ne fonctionnent pas pour Visual C++.

Opérateurs typeof et sizeof

Le débogueur prend en charge les opérateurs typeof et sizeof en les transformant en fonctions .NET Framework équivalentes.

typeof ( expression )

est transformé en :

System.Type.GetType(expression )

Le débogueur évalue ensuite cette expression transformée.

Le débogueur ne prend pas en charge l'opérateur sizeof.

Conversion boxing et unboxing

L'évaluateur d'expression du débogueur ne prend pas en charge les conversions boxing et unboxing en Visual C++. Pour plus d'informations, consultez Conversion boxing et unboxing. Si vous avez une variable entière i qui a été convertie en objet via une conversion boxing, le débogueur évalue i en tant qu'entier, et non en tant qu'objet. Les résultats peuvent vous surprendre. Pour plus d'informations sur la façon dont la conversion boxing affecte les valeurs, consultez Conversion boxing.

Évaluation de propriété

Le débogueur peut évaluer les propriétés dans n'importe quelle fenêtre de variable. Cependant, l'évaluation d'une propriété dans le débogueur peut avoir des effets secondaires qui produisent des résultats inattendus et non souhaitables. Pour une protection contre les effets secondaires dus à une évaluation accidentelle, vous pouvez désactiver l'évaluation de propriété dans la boîte de dialogue Options.

Partager via