Espressioni gestite in C++

Articolo
09/12/2008

Aggiornamento: novembre 2007

Le informazioni contenute in questo argomento sono valide per:

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

Legenda tabella:

	Applicabile
	Non applicabile
	Comando o comandi nascosti per impostazione predefinita.

L'analizzatore di espressioni gestite accetta la maggior parte delle espressioni scritte in Visual C++. Negli argomenti riportati di seguito vengono fornite informazioni specifiche e vengono illustrati alcuni tipi di espressioni non supportati:

Identificatori e tipi
Valutazione delle funzioni
Operatori
Operatori di overload
Stringhe
Cast
Confronto e assegnazione di oggetti
Operatori typeof e sizeof
Boxing
Valutazione delle proprietà

L'analizzatore di espressioni ignora i qualificatori di accesso public, protected, internal e private. È ad esempio possibile chiamare un metodo private dalla finestra Espressioni di controllo.

L'analizzatore di espressioni esegue tutte le valutazioni in un contesto unsafe implicito, indipendentemente dal fatto che il codice eseguito sia di tipo safe o unsafe.

Per visualizzare il contenuto di un tipo di dati in formato significativo, nel debugger vengono utilizzate regole di espansione automatica. Se necessario, è possibile aggiungere elementi di espansione automatica personalizzati per visualizzare tipi di dati personalizzati. Per ulteriori informazioni, vedere Visualizzazione degli elementi di un tipo di dati personalizzato.

Identificatori e tipi

Nelle espressioni del debugger è possibile utilizzare qualsiasi identificatore visibile nell'ambito corrente. Se, ad esempio, il debugger viene interrotto nella funzione magh, è possibile utilizzare qualsiasi identificatore visibile all'interno di magh, tra cui costanti, nomi di variabili e nomi di funzioni.

Nel debugger è possibile visualizzare correttamente qualsiasi variabile di tipo primitive, enum o intrinsic. Nel caso di variabili di tipo class, il valore viene visualizzato correttamente in base al tipo derivato di livello più basso. Se si dispone di un oggetto leo di tipo lion derivato dal tipo cat, è possibile valutare leo.clawlength e ottenere il valore corretto per un oggetto di tipo lion.

È possibile assegnare un nuovo valore a qualsiasi espressione nella parte sinistra che è un l-value di tipo primitivo. Le assegnazioni ai tipi classe e matrice non sono supportate.

Valutazione delle funzioni

Il debugger supporta la valutazione delle funzioni, tra cui quelle in overload. Di conseguenza, quando si immette una delle espressioni seguenti, il debugger chiama la versione corretta della funzione in overload:

kanga ()
kanga (roo)

La valutazione di una funzione nel debugger comporta la chiamata e l'esecuzione del codice relativo a tale funzione. Se la funzione genera effetti collaterali, quali l'allocazione di memoria o la modifica del valore di una variabile globale, la valutazione della funzione in una finestra del debugger comporterà la modifica dello stato del programma e questa operazione può produrre risultati imprevisti.

Quando si imposta un punto di interruzione su una funzione in overload, la posizione del punto di interruzione dipende dal modo in cui si specifica la funzione. Se si specifica solo il nome della funzione, verrà impostato un punto di interruzione su ogni overload del nome della funzione. Se si specifica la firma completa, ossia il nome della funzione e l'elenco completo degli argomenti, verrà impostato un punto di interruzione sull'overload specificato.

Operatori

Nel debugger viene eseguita correttamente la valutazione della maggior parte degli operatori incorporati, tra cui:

Operatori relazionali: (expr1 >expr2, expr1 < expr2, expr1 <= expr2, expr1 => expr2, expr1 == expr2, expr1 != expr2).
Operatori booleani: (expr1 && expr2, expr1 || expr2).
Operatore condizionale: (expr1 ? expr2 : expr3).
Operatori aritmetici: (expr1 + expr2, expr1 - expr2,expr1 * expr2, expr1 / expr2, expr1 % expr2).
Operatori bit per bit: (expr1 & expr2, expr1 ^ expr2, expr1 | expr2, expr1 ~ expr2).
Operatori shift. Esempi: (expr1 >> expr2, expr1 << expr2, expr1 >>> expr2).
Operatori di assegnazione: (lvalue = expr2, lvalue *= expr2, lvalue /= expr2, lvalue %= expr2, lvalue += expr2, lvalue -= expr2, lvalue <<= expr2, lvalue >>=expr2, lvalue &= expr2, lvalue ^= expr2, lvalue |= expr2).
Operatori unari. Esempi: (+ expr1, - expr1, expr1++, ++ expr1, expr1--, -- expr1).

Per immettere una serie di espressioni, è possibile utilizzare l'operatore virgola: expr1, expr2,expr3.

Operatori di overload

Nel debugger è possibile utilizzare la maggior parte degli operatori di overload.

Gli operatori infissi di overload +, -, /, %, e & sono supportati:

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

Gli operatori infissi di overload =, &&, &, ||, | e ^ non sono supportati:

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

Gli operatori relazionali di overload ==, !=, >, <, >= e <= non sono supportati per C++:

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

Gli operatori infissi di overload |, ^, <<, >>, >, <, >= e <= non sono supportati:

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

Gli operatori prefissi di overload +, -, ++, --, ! e ~ sono supportati:

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

Gli operatori suffissi di overload ++ e -- sono supportati:

expr1++
expr1--

L'operatore di overload [] è supportato:

x[expr2]

Matrici multidimensionali

L'analizzatore di espressioni C++ utilizza la sintassi C# per le matrici multidimensionali, ad esempio:

c[0,0]

L'utilizzo della sintassi C++ normale genera un errore:

c[0][0]: indice '0' non compreso nell'intervallo per puntatore/matrice 'c'

Stringhe

Quando utilizzato con stringhe e matrici, l'operatore di indice viene riconosciuto. È ad esempio possibile digitare:

"hello world"[0]

Nella finestra Espressioni di controllo verrà visualizzato il valore corretto:

'h'

Cast

Nel debugger possono essere utilizzate espressioni cast semplici:

(A)x

I cast che implicano l'utilizzo di puntatori non possono essere utilizzati nel debugger.

I cast definiti dall'utente non sono supportati nel debugger per Visual C++.

Confronto e assegnazione di oggetti

Le operazioni di confronto e assegnazione di oggetti nel debugger non sono supportate per Visual C++.

Operatori typeof e sizeof

Il debugger supporta l'operatore typeof trasformandolo nella funzione .NET Framework equivalente.

typeof ( expression )

viene trasformato in:

System.Type.GetType(expression )

Viene quindi valutata l'espressione trasformata.

Il debugger non supporta l'operatore sizeof.

Boxing e unboxing

L'analizzatore di espressioni del debugger non supporta le operazioni di boxing e unboxing in Visual C++. Per ulteriori informazioni, vedere Boxing e unboxing. Una variabile integer i convertita in oggetto mediante boxing verrà valutata come integer e non come oggetto. I risultati potrebbero non essere quelli desiderati. Per ulteriori informazioni su come il boxing influisce sui valori, vedere Conversione boxing.

Valutazione delle proprietà

Il debugger è in grado di valutare le proprietà in qualsiasi finestra di variabile. La valutazione di una proprietà nel debugger può tuttavia produrre effetti collaterali che generano risultati imprevisti e indesiderati. Per evitare gli effetti collaterali causati da una valutazione accidentale, è possibile disattivare la valutazione delle proprietà nella finestra di dialogo Opzioni.

Condividi tramite