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 MASM (Microsoft Macro Assembler). 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 unários e binários do C++.
As janelasInspeção e Locais no depurador sempre usam o avaliador de expressão C++.
No exemplo a seguir, o comando ?? evaluate expressão 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 for 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, confira Sintaxe de registro.
Neste exemplo, o valor hexadecimal de 0xD é adicionado ao registro de 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. Registros reais e pseudo-registros de valor inteiro são convertidos ULONG64em . Todos os endereços são convertidos em , é convertido ETHREAD*em , $proc é convertido em EPROCESS*, $teb é convertido em TEB*e $peb é convertido em PEB*. $threadPUCHAR
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
Não é possível 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 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.
O radix do depurador padrão não afeta a forma como você insere expressões C++. Não é possível 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 xxxxxxxxx'xxxxxxxx. Você também pode omitir o acento grave ('). Ambos os formatos produzem o mesmo valor.
Você pode usar os Lsufixos , Ue I64 com 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 de 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 em um inteiro ou um ponteiro, ocorrerá um erro de sintaxe.
Você pode usar o 0n prefixo (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 ao redor dele com aspas simples ('). Os caracteres de escape C++ padrão são permitidos.
Você pode inserir literais de cadeia de caracteres cercando-os com aspas duplas ("). Você pode usar \" como uma sequência de escape dentro dessa cadeia de caracteres. 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, dentro de uma expressão C++.
Você pode usar um acento grave (') ou um apóstrofo (') em um nome de símbolo somente se você adicionar um nome de módulo e 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 de símbolo 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 at (@@) antes da expressão, a expressão será interpretada de acordo com as regras de expressão MASM. Não é possível adicionar um espaço entre os dois em sinais 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 têm suporte, incluindo operadores de atribuição e efeito colateral. No entanto, você não pode usar os newoperadores , deletee throw e não pode realmente chamar uma função.
Há suporte para a aritmética de ponteiro 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 no 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 operadores em 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. Esse final permite que você use efetivamente expressões como ?? myPtr && *myPtr.
Conversão de referência e tipo
| Operador | Significado |
|---|---|
| Expressão // Comentário | Ignorar todo o texto subsequente |
| Classe :: Member | Membro da classe |
| Classe ::~Member | 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 a avaliação) |
| Lvalue -- | Decremento (após a avaliação) |
| Dynamic_cast<Tipo>(Valor) | Typecast (sempre executado) |
| Static_cast<Tipo>(Valor) | Typecast (sempre executado) |
| Reinterpret_cast<Tipo>(Valor) | Typecast (sempre executado) |
| Const_cast<Tipo>(Valor) | Typecast (sempre executado) |
Operações de valor
| Operador | Significado |
|---|---|
| (tipo) Valor | Typecast (sempre executado) |
| valor sizeof | Tamanho da expressão |
| sizeof( type ) | Tamanho do tipo de dados |
| ++ Lvalue | Incremento (antes da avaliação) |
| -- Lvalue | Decremento (antes da avaliação) |
| ~ Value | Complemento de bits |
| ! Valor | Não (booliano) |
| Valor | Subtração unária |
| + Value | 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 do 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 a (comparação) |
| Valor>Valor | Maior que (comparação) |
| Valor>= Valor | Maior ou igual a (comparação) |
| Valor == Valor | Igual (comparação) |
| Valor != Valor | Não é igual (comparação) |
| Valor & Valor | AND bit a bit |
| Valor ^ Valor | XOR bit a bit (OR exclusivo) |
| Valor | Valor | OR bit a bit |
| Valor && Valor | AND lógico |
| Valor || Valor | OR lógico |
Os exemplos a seguir pressupõem que os pseudo-registros sejam 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 | Multiplicar e atribuir |
| 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 &= Value | AND e atribuir |
| Lvalue |= Valor | OR e atribuir |
| Lvalue ^= Valor | XOR e atribuir |
Avaliação
| Operador | Significado |
|---|---|
| Valor ? Valor : Valor | Avaliação condicional |
| Valor , Valor | Avalie todos os valores e 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 em Winnt.h.
| Macro | Retornar valor |
|---|---|
| #CONTAINING_RECORD(Address, Type, Field) | 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(Type, Field) | Retorna o deslocamento de bytes de um campo nomeado em um tipo de estrutura conhecido. |
| #RTL_CONTAINS_FIELD(Struct, Size, Field) | Indica se o tamanho do byte especificado inclui o campo desejado. |
| #RTL_FIELD_SIZE(Type, Field) | Retorna o tamanho de um campo em uma estrutura de tipo conhecido, sem exigir o tipo do campo. |
| #RTL_NUMBER_OF(Array) | Retorna o número de elementos em uma matriz de tamanho estatica. |
| #RTL_SIZEOF_THROUGH_FIELD(Type, Field) | Retorna o tamanho de uma estrutura de tipo conhecido, até e incluindo um campo especificado. |
Este exemplo mostra o uso da #FIELD_OFFSET 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 versus expressões C++
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de