Compartir a través de


Expresiones administradas en C++

Actualización: noviembre 2007

Este tema hace referencia a:

Edición

Visual Basic

C#

C++

Web Developer

Express

Estándar

Pro y Team

Leyenda de la tabla:

Se aplica

No procede

Comando o comandos ocultos de manera predeterminada.

El evaluador de expresiones administradas acepta la mayoría de las expresiones escritas en Visual C++. Los temas siguientes ofrecen información específica y tratan algunos de los tipos de expresión no compatibles:

  • Identificadores y tipos

  • Evaluación de funciones

  • Operadores

  • Operadores sobrecargados

  • Cadenas

  • Conversiones de tipo

  • Comparación y asignación de objetos

  • Operadores typeof y sizeof

  • Boxing

  • Evaluación de propiedades

El evaluador de expresiones omite los calificadores de acceso, public, protected, internal y private. Puede llamar a un método private desde la ventana Inspección, por ejemplo.

El evaluador de expresiones realiza todas las evaluaciones en un contexto no seguro implícito, independientemente de que el código que se está ejecutando sea seguro o no.

El depurador utiliza reglas de ampliación automática para mostrar el contenido de un tipo de datos de un modo coherente. Si es preciso, puede agregar elementos de ampliación automática personalizados para mostrar sus propios tipos de datos. Para obtener más información, vea Mostrar elementos de un tipo de datos personalizado.

Identificadores y tipos

Las expresiones del depurador pueden utilizar cualquier identificador visible en el ámbito actual. Si se detiene el depurador en la función magh, por ejemplo, puede utilizar cualquier identificador visible en magh, incluidos las constantes, los nombres de variable y los nombres de función.

El depurador puede mostrar correctamente cualquier variable de tipo primitive, enum, o intrinsic. Para las variables de tipo class, el depurador muestra correctamente el valor según el tipo más derivado. Si se tiene un objeto leo de tipo lion, derivado del tipo cat, se puede evaluar leo.clawlength y obtener el valor correcto del objeto de tipo lion.

Se puede asignar un nuevo valor a cualquier expresión del lado izquierdo que sea un valor L de un tipo primitivo. No se admiten asignaciones a tipos de clase ni de matriz.

Evaluación de funciones

El depurador admite la evaluación de funciones, incluidas funciones sobrecargadas. Por tanto, se puede escribir cualquiera de las siguientes expresiones y el depurador llamará a la versión correcta de la función sobrecargada:

kanga ()
kanga (roo)

Cuando se evalúa una función en el depurador, en realidad se llama y se ejecuta el código de esa función. Si la función tiene efectos secundarios, como la asignación de memoria o el cambio de valor de una variable global, evaluar la función en la ventana del depurador cambiará el estado del programa, lo que puede producir resultados inesperados.

Cuando se establece un punto de interrupción en una función sobrecargada, la ubicación del punto de interrupción depende de cómo se especifica la función. Si se especifica únicamente el nombre de la función, el depurador establecerá un punto de interrupción en cada sobrecarga de ese nombre de función. Si se especifica la firma completa, el nombre de función y la lista de argumentos completa, el depurador establecerá un punto de interrupción en la sobrecarga especificada.

Operadores

El depurador evalúa correctamente la mayoría de los operadores integrados, incluidos:

  • Operadores relacionales: (expr1 >expr2, expr1 < expr2, expr1 < = expr2, expr1 = > expr2, expr1 == expr2, expr1 ! = expr2).

  • Operadores booleanos: (expr1 && expr2, expr1 || expr2).

  • Operador condicional: (expr1 ? expr2 : expr3).

  • Operadores aritméticos: (expr1 + expr2, expr1 - expr2,expr1 * expr2, expr1 / expr2, expr1 % expr2).

  • Operadores bit a bit: (expr1 & expr2, expr1 ^ expr2, expr1 | expr2, expr1 ~ expr2).

  • Operadores de desplazamiento. Ejemplos: (expr1 >> expr2, expr1 << expr2, expr1 >>> expr2).

  • Operadores de asignación: (valorL = expr2, valorL *= expr2, valorL /= expr2, valorL %= expr2, valorL += expr2, valorL -= expr2, valorL <<= expr2, valorL >>=expr2, valorL &= expr2, valorL ^= expr2, valorL |= expr2).

  • Operadores unarios. Ejemplos: (+ expr1, - expr1, expr1++, ++ expr1, expr1--, -- expr1).

Puede usar el operador coma para escribir una serie de expresiones: expr1, expr2,expr3.

Operadores sobrecargados

La mayoría de los operadores sobrecargados funcionan en el depurador.

Funcionan los operadores infijos sobrecargados +, -, /, % y &:

  • expr1 + expr2

  • expr1expr2

  • expr1 / expr2

  • expr1 % expr2

  • expr1 & expr2

Los operadores infijos sobrecargados =, &&, &, ||, | y ^ no funcionan:

  • expr1 = expr2

  • expr1 && expr2

  • expr1 & expr2

  • expr1 || expr2

  • expr1 | expr2

  • expr1 ^ expr2

Los operadores relacionales sobrecargados ==, !=, >, <, >=, y <= no funcionan para C++:

  • expr1 == expr2

  • expr1 != expr2

  • expr1 > expr2

  • expr1 < expr2

  • expr1 >= expr2

  • expr1 <= expr2

Los operadores infijos sobrecargados |, ^, <<, >>, >, <, >=, y <= no funcionan:

  • expr1 | expr2

  • expr1 ^ expr2

  • expr1 << expr2

  • expr1 >> expr2

  • expr1 > expr2

  • expr1 < expr2

  • expr1 >= expr2

  • expr1 <= expr2

Los operadores prefijos sobrecargados +, -, ++, --, ! y ~ funcionan.

  • + + expr1

  • - - expr1

  • ++ ++ expr1

  • -- -- expr1

  • ! expr1

  • ~ ~ expr1

Los operadores sufijos sobrecargados ++ y -- funcionan:

  • expr1++

  • expr1--

El operador sobrecargado [] funciona:

  • x[expr2]

Matrices multidimensionales

El evaluador de expresiones de C++ utiliza sintaxis de estilo C# para las matrices multidimensionales. Por ejemplo:

c[0,0]

El uso de la sintaxis de C++ habitual genera un error:

Error c[0][0]: índice '0' fuera del límite para el puntero/matriz 'c'

Cadenas

El depurador reconoce el operador indizado cuando se utiliza con cadenas y con matrices. Por ejemplo, se puede escribir:

"hello world"[0]

La ventana Inspección mostrará el valor correcto:

'h'

Conversiones de tipo

En el depurador, funcionan expresiones de conversión de tipos sencillas:

(A)x

Las conversiones de tipo que utilizan punteros no funcionarán en el depurador:

Las conversiones de tipos definidos por el usuario no funcionan en el depurador para Visual C++.

Comparación y asignación de objetos

La comparación y asignación de objetos en el depurador no funciona para Visual C++.

Operadores typeof y sizeof

El depurador admite los operadores typeof y sizeof transformándolos en las funciones de .NET Framework equivalentes.

typeof ( expresión )

se transforma en:

System.Type.GetType(expression )

El depurador evalúa esta expresión transformada.

El depurador no admite el operador sizeof.

Boxing y Unboxing

El evaluador de expresiones del depurador no admite boxing y unboxing en Visual C++. Para obtener más información, vea Boxing y Unboxing. Si tiene una variable de un entero i que se ha convertido en un objeto mediante boxing, el depurador evaluará i como un entero, no como un objeto. Los resultados pueden no ser los esperados. Para más información sobre cómo afecta la conversión boxing a los valores, vea Conversión boxing.

Evaluación de propiedades

El depurador puede evaluar propiedades en cualquier ventana de variable. Sin embargo, evaluar una propiedad en el depurador puede tener efectos secundarios que produzcan resultados inesperados y no deseados. Para proteger de los efectos secundarios causados por una evaluación accidental, se puede desactivar la evaluación de propiedades en el cuadro de diálogo Opciones.

WebMethods

No se puede llamar a WebMethods desde las ventanas del depurador.

Vea también

Otros recursos

Expresiones en el depurador