Números e operadores C++
Este artigo descreve o uso da sintaxe de expressão C++ com as ferramentas de depuração do Windows.
O depurador aceita dois tipos diferentes de expressões numéricas: expressões C++ e expressões do Microsoft Macro Assembler (MASM). Cada uma dessas expressões segue suas próprias regras de sintaxe para entrada e saída.
Para obter mais informações sobre quando cada tipo de sintaxe é usado, consulte Avaliando expressões e o comando ? evaluate expression .
O analisador de expressão C++ dá suporte a todas as formas de sintaxe de expressão C++. A sintaxe inclui todos os tipos de dados, incluindo ponteiros, números de ponto flutuante e matrizes, e todos os operadores binários e unários do C++.
As janelas Inspeção e Locais no depurador sempre usam o avaliador de expressão C++.
No exemplo a seguir, o comando de expressão ?? evaluate C++ exibe o valor do registro do ponteiro de instrução.
0:000> ?? @eip
unsigned int 0x771e1a02
Podemos usar a função C++ sizeof para determinar o tamanho das estruturas.
0:000> ?? (sizeof(_TEB))
unsigned int 0x1000
Definir o avaliador de expressão como C++
Use o avaliador de expressão .expr choose para ver o avaliador de expressão padrão e alterá-lo para C++.
0:000> .expr
Current expression evaluator: MASM - Microsoft Assembler expressions
0:000> .expr /s c++
Current expression evaluator: C++ - C++ source expressions
Depois que o avaliador de expressão padrão tiver sido alterado, o comando ? evaluate expression poderá ser usado para exibir expressões C++. O exemplo a seguir exibe o valor do registro do ponteiro de instrução.
0:000> ? @eip
Evaluate expression: 1998461442 = 771e1a02
Para saber mais sobre a referência de @eip registro, consulte Sintaxe de registro.
Neste exemplo, o valor hexadecimal de 0xD é adicionado ao registro eip.
0:000> ? @eip + 0xD
Evaluate expression: 1998461455 = 771e1a0f
Registros e pseudo-registros em expressões C++
Você pode usar registros e pseudo-registros em expressões C++. O sinal @ deve ser adicionado antes do registro ou pseudo-registro.
O avaliador de expressão executa automaticamente a conversão adequada. Os registros reais e os pseudo-registros de valor inteiro são convertidos em ULONG64. Todos os endereços são convertidos em PUCHAR, são convertidos em ETHREAD*, $proc são convertidos em EPROCESS*, $teb são convertidos em TEB*e $peb são convertidos em PEB*$thread .
Este exemplo exibe o TEB.
0:000> ?? @$teb
struct _TEB * 0x004ec000
+0x000 NtTib : _NT_TIB
+0x01c EnvironmentPointer : (null)
+0x020 ClientId : _CLIENT_ID
+0x028 ActiveRpcHandle : (null)
+0x02c ThreadLocalStoragePointer : 0x004ec02c Void
+0x030 ProcessEnvironmentBlock : 0x004e9000 _PEB
+0x034 LastErrorValue : 0xbb
+0x038 CountOfOwnedCriticalSections : 0
Você não pode alterar um registro ou pseudo-registro por um operador de atribuição ou efeito colateral. Você deve usar o comando r registers para alterar esses valores.
O exemplo a seguir define o pseudo-registro como um valor de 5 e o exibe.
0:000> r $t0 = 5
0:000> ?? @$t0
unsigned int64 5
Para obter mais informações sobre registros e pseudo-registros, consulte Sintaxe de registro e Sintaxe de pseudo-registro.
Números em expressões C++
Os números em expressões C++ são interpretados como números decimais, a menos que você os especifique de outra maneira. Para especificar um inteiro hexadecimal, adicione 0x antes do número. Para especificar um inteiro octal, adicione 0 (zero) antes do número.
A base do depurador padrão não afeta como você insere expressões C++. Você não pode inserir diretamente um número binário, exceto aninhando uma expressão MASM dentro da expressão C++.
Você pode inserir um valor hexadecimal de 64 bits no formato xxxxxxxx'xxxxxxxx. Você também pode omitir o acento grave ('). Ambos os formatos produzem o mesmo valor.
Você pode usar os sufixos L, Ue com I64 valores inteiros. O tamanho real do número criado depende do sufixo e do número inserido. Para obter mais informações sobre essa interpretação, consulte uma referência da linguagem C++.
A saída do avaliador de expressão C++ mantém o tipo de dados especificado pelas regras de expressão C++. No entanto, se você usar essa expressão como um argumento para um comando, uma conversão sempre será feita. Por exemplo, você não precisa converter valores inteiros em ponteiros quando eles são usados como endereços em argumentos de comando. Se o valor da expressão não puder ser convertido de forma válida em um inteiro ou ponteiro, ocorrerá um erro de sintaxe.
Você pode usar o prefixo 0n (decimal) para alguma saída, mas não pode usá-lo para entrada de expressão C++.
Caracteres e cadeias de caracteres em expressões C++
Você pode inserir um caractere colocando-o entre aspas simples ('). Os caracteres de escape padrão do C++ são permitidos.
Você pode inserir literais de cadeia de caracteres colocando-os entre aspas duplas ("). Você pode usar \" como uma sequência de escape dentro dessa string. No entanto, as cadeias de caracteres não têm significado para o avaliador de expressão.
Símbolos em expressões C++
Em uma expressão C++, cada símbolo é interpretado de acordo com seu tipo. Dependendo do que o símbolo se refere, ele pode ser interpretado como um inteiro, uma estrutura de dados, um ponteiro de função ou qualquer outro tipo de dados. Ocorrerá um erro de sintaxe se você usar um símbolo que não corresponda a um tipo de dados C++, como um nome de módulo não modificado, em uma expressão C++.
Você pode usar um acento grave (') ou um apóstrofo (') em um nome de símbolo somente se adicionar um nome de módulo e um ponto de exclamação antes do nome do símbolo. Ao adicionar os < delimitadores e > após um nome de modelo, você pode adicionar espaços entre esses delimitadores.
Se o símbolo puder ser ambíguo, você poderá adicionar um nome de módulo e um ponto de exclamação (!) ou apenas um ponto de exclamação antes do símbolo. Para especificar que um símbolo deve ser local, omita o nome do módulo e inclua um cifrão e um ponto de exclamação ($!) antes do nome do símbolo. Para obter mais informações sobre o reconhecimento de símbolos, consulte Sintaxe e correspondência de símbolos.
Estruturas em expressões C++
O avaliador de expressão C++ converte pseudo-registros em seus tipos apropriados. Por exemplo, $teb é convertido como um TEB*.
0:000> ?? @$teb
struct _TEB * 0x004ec000
+0x000 NtTib : _NT_TIB
+0x01c EnvironmentPointer : (null)
+0x020 ClientId : _CLIENT_ID
+0x028 ActiveRpcHandle : (null)
+0x02c ThreadLocalStoragePointer : 0x004ec02c Void
+0x030 ProcessEnvironmentBlock : 0x004e9000 _PEB
+0x034 LastErrorValue : 0xbb
+0x038 CountOfOwnedCriticalSections : 0
O exemplo a seguir exibe a ID do processo na estrutura TEB mostrando o uso de um ponteiro para um membro da estrutura referenciada.
0:000> ?? @$teb->ClientId.UniqueProcess
void * 0x0000059c
Operadores em expressões C++
Você pode usar parênteses para substituir as regras de precedência.
Se você colocar parte de uma expressão C++ entre parênteses e adicionar dois sinais de arroba (@@) antes da expressão, a expressão será interpretada de acordo com as regras de expressão MASM. Você não pode adicionar um espaço entre os dois sinais de arroba e o parêntese de abertura. O valor final dessa expressão é passado para o avaliador de expressão C++ como um valor ULONG64. Você também pode especificar o avaliador de expressão usando @@c++( ... ) ou @@masm( ... ).
Os tipos de dados são indicados como de costume na linguagem C++. Os símbolos que indicam matrizes ([ ]), membros de ponteiro (->), membros UDT (.) e membros de classes (::) são todos reconhecidos. Todos os operadores aritméticos são suportados, incluindo operadores de atribuição e efeito colateral. No entanto, você não pode usar os newoperadores , delete, e throw não pode realmente chamar uma função.
A aritmética do ponteiro é suportada e os deslocamentos são dimensionados corretamente. Observe que você não pode adicionar um deslocamento a um ponteiro de função. Se você precisar adicionar um deslocamento a um ponteiro de função, converta o deslocamento em um ponteiro de caractere primeiro.
Como em C++, se você usar operadores com tipos de dados inválidos, ocorrerá um erro de sintaxe. O analisador de expressão C++ do depurador usa regras um pouco mais relaxadas do que a maioria dos compiladores C++, mas todas as regras principais são impostas. Por exemplo, você não pode deslocar um valor não inteiro.
Você pode usar os operadores a seguir. Os operadores em cada célula têm precedência sobre os operadores nas células inferiores. Os operadores na mesma célula têm a mesma precedência e são analisados da esquerda para a direita.
Assim como acontece com o C++, a avaliação da expressão termina quando seu valor é conhecido. Essa terminação permite que você use efetivamente expressões como ?? myPtr && *myPtr.
Referência e fundição de tipo
| Operador | Significado |
|---|---|
| Comentário de expressão // | Ignorar todo o texto subsequente |
| Classe :: Membro | Membro da classe |
| Classe ::~Membro | Membro da classe (destruidor) |
| :: Nome | Global |
| Estrutura. Campo | Campo em uma estrutura |
| Ponteiro ->Campo | Campo na estrutura referenciada |
| Nome [inteiro] | Subscrito de matriz |
| Lvalue ++ | Incremento (após avaliação) |
| Lvalue -- | Diminuição (após avaliação) |
| <dynamic_cast type>(Value) | Typecast (sempre executado) |
| <static_cast type>(Valor) | Typecast (sempre executado) |
| <reinterpret_cast type>(Value) | Typecast (sempre executado) |
| <const_cast type>(Value) | Typecast (sempre executado) |
Operações de valor
| Operador | Significado |
|---|---|
| (tipo) Valor | Typecast (sempre executado) |
| tamanho do valor | Tamanho da expressão |
| sizeof( tipo ) | Tamanho do tipo de dados |
| ++ Lvalue | Incremento (antes da avaliação) |
| -- Lvalue | Diminuir (antes da avaliação) |
| ~ Valor | Complemento de broca |
| ! Valor | Não (booleano) |
| Valor | Menos unário |
| + Valor | Adição de unário |
| & LValue | Endereço do tipo de dados |
| Valor | Desreferenciar |
| Estrutura. Ponteiro | Ponteiro para membro da estrutura |
| Ponteiro -> * Ponteiro | Ponteiro para membro da estrutura referenciada |
Aritmético
| Operador | Significado |
|---|---|
| Valor Valor | Multiplicação |
| Valor / Valor | Divisão |
| Valor % Valor | Módulo |
| Valor + Valor | Adição |
| Valor - Valor | Subtração |
| Valor<<Valor | Deslocamento bit a bit para a esquerda |
| Valor>>Valor | Deslocamento bit a bit para a direita |
| Valor<Valor | Menor que (comparação) |
| Valor< = Valor | Menor ou igual (comparação) |
| Valor>Valor | Maior que (comparação) |
| Valor> = Valor | Maior ou igual (comparação) |
| Valor == Valor | Igual (comparação) |
| Valor != Valor | Não igual (comparação) |
| Valor e valor | AND bit a bit |
| Valor ^ Valor | XOR bit a bit (OR exclusivo) |
| Valor | Valor | OR bit a bit |
| Valor e valor | AND lógico |
| Valor || Valor | OR lógico |
Os exemplos a seguir pressupõem que os pseudo-registros são definidos conforme mostrado.
0:000> r $t0 = 0
0:000> r $t1 = 1
0:000> r $t2 = 2
0:000> ?? @$t1 + @$t2
unsigned int64 3
0:000> ?? @$t2/@$t1
unsigned int64 2
0:000> ?? @$t2|@$t1
unsigned int64 3
Atribuição
| Operador | Significado |
|---|---|
| LValue = Valor | Atribuir |
| LValue *= Valor | Multiplique e atribua |
| LValue /= Valor | Dividir e atribuir |
| LValue %= Valor | Módulo e atribuir |
| LValue += Valor | Adicionar e atribuir |
| LValue -= Valor | Subtrair e atribuir |
| LValue<<= Valor | Deslocar para a esquerda e atribuir |
| LValue>>= Valor | Deslocar para a direita e atribuir |
| LValue &= Valor | E e atribuir |
| LValue |= Valor | OU e atribuir |
| LValue ^= Valor | XOR e atribuir |
Avaliação
| Operador | Significado |
|---|---|
| Valor ? Valor : Valor | Avaliação condicional |
| Valor , Valor | Avalie todos os valores e, em seguida, descarte todos, exceto o valor mais à direita |
Macros em expressões C++
Você pode usar macros em expressões C++. Você deve adicionar um sinal numérico (#) antes das macros.
Você pode usar as macros a seguir. Essas macros têm as mesmas definições que as macros do Microsoft Windows com o mesmo nome. As macros do Windows são definidas no Winnt.h.
| Macro | Valor retornado |
|---|---|
| #CONTAINING_RECORD(Endereço, Tipo, Campo) | Retorna o endereço base de uma instância de uma estrutura, dado o tipo da estrutura e o endereço de um campo dentro da estrutura. |
| #FIELD_OFFSET(Tipo, Campo) | Retorna o deslocamento de bytes de um campo nomeado em um tipo de estrutura conhecido. |
| #RTL_CONTAINS_FIELD(Estrutura, Tamanho, Campo) | Indica se o tamanho de byte fornecido inclui o campo desejado. |
| #RTL_FIELD_SIZE(Tipo, Campo) | Retorna o tamanho de um campo em uma estrutura de tipo conhecido, sem exigir o tipo do campo. |
| #RTL_NUMBER_OF(Matriz) | Retorna o número de elementos em uma matriz de tamanho estático. |
| #RTL_SIZEOF_THROUGH_FIELD(Tipo, Campo) | Retorna o tamanho de uma estrutura de tipo conhecido, até e incluindo um campo especificado. |
Este exemplo mostra o #FIELD_OFFSET uso da macro para calcular o deslocamento de bytes para um campo em uma estrutura.
0:000> ?? #FIELD_OFFSET(_PEB, BeingDebugged)
long 0n2
Confira também
Expressões MASM vs. expressões C++