Eventos
17 de mar., 21 - 21 de mar., 10
Junte-se à série de encontros para criar soluções de IA escaláveis com base em casos de uso do mundo real com outros desenvolvedores e especialistas.
Registrar agoraIntPtr numérico
Observação
Este artigo é uma especificação de recurso. A especificação serve como o documento de design para o recurso. Ela inclui alterações de especificação propostas, juntamente com as informações necessárias durante o design e o desenvolvimento do recurso. Esses artigos são publicados até que as alterações de especificação propostas sejam finalizadas e incorporadas na especificação ECMA atual.
Pode haver algumas divergências entre a especificação do recurso e a implementação concluída. Essas diferenças são capturadas nas notas pertinentes da reunião de design de idioma (LDM).
Você pode saber mais sobre o processo de adoção de speclets de recursos no padrão de linguagem C# no artigo sobre as especificações de .
Problema do especialista: https://github.com/dotnet/csharplang/issues/6065
Essa é uma revisão do recurso inicial de inteiros nativos (especificação), onde os tipos nint/nuint eram distintos dos tipos subjacentes System.IntPtr/System.UIntPtr.
Em suma, agora tratamos nint/nuint como alias simples dos tipos System.IntPtr/System.UIntPtr, assim como fazemos para int em relação a System.Int32. O sinalizador de recurso em tempo de execução System.Runtime.CompilerServices.RuntimeFeature.NumericIntPtr dispara esse novo comportamento.
O C# fornece um conjunto de tipos de struct predefinidos chamados de tipos simples. Os tipos simples são identificados por meio de palavras-chave, mas essas palavras-chave são meramente aliases para tipos struct predefinidos no namespace System, conforme descrito na tabela a seguir.
| Palavra-chave | Tipo com alias |
|---|---|
sbyte |
System.SByte |
byte |
System.Byte |
short |
System.Int16 |
ushort |
System.UInt16 |
int |
System.Int32 |
uint |
System.UInt32 |
nint |
System.IntPtr |
nuint |
System.UIntPtr |
long |
System.Int64 |
ulong |
System.UInt64 |
char |
System.Char |
float |
System.Single |
double |
System.Double |
bool |
System.Boolean |
decimal |
System.Decimal |
[...]
O C# dá suporte a onze tipos integrais: sbyte, byte, short, ushort, int, uint, nint, nuint, long, ulonge char. [...]
Em outras palavras, um unmanaged_type é um dos seguintes:
-
sbyte,byte,short,ushort,int,uint,nint,nuint,long,ulong,char,float,double,decimal, oubool. - Any enum_type.
- Qualquer struct_type definido pelo usuário que não seja tipo construído e contenha somente campos de tipos não gerenciados.
- Em código não seguro, qualquer pointer_type.
As conversões numéricas implícitas são:
- De
sbyteparashort,int,nint,long,float,doubleoudecimal. - De
byteparashort,ushort,int,uint,nint,nuint,long,ulong,float,doubleoudecimal. - De
shortparaint,nint,long,float,doubleoudecimal. - De
ushortparaint,uint,nint,nuint,long,ulong,float,doubleoudecimal. - De
intparanint,long,float,doubleoudecimal. - De
uintparanuint,long,ulong,float,doubleoudecimal. - De
nintparalong,float,doubleoudecimal. - De
nuintparaulong,float,doubleoudecimal. - De
longparafloat,doubleoudecimal. - De
ulongparafloat,doubleoudecimal. - De
charparaushort,int,uint,nint,nuint,long,ulong,float,doubleoudecimal. - De
floatparadouble.
[...]
Uma conversão de expressão constante implícita permite as conversões a seguir:
- Uma constant_expression do tipo
intpode ser convertida no tipo typesbyte,byte,short,ushort,uint,nint,nuintouulong, desde que o valor da constant_expression esteja dentro do intervalo do tipo de destino. [...]
As conversões numéricas explícitas são as conversões de uma numeric_type para outra numeric_type para a qual ainda não existe uma conversão numérica implícita:
- De
sbyteparabyte,ushort,uint,nuint,ulongouchar. - De
byteparasbyteouchar. - De
shortparasbyte,byte,ushort,uint,nuint,ulongouchar. - De
ushortparasbyte,byte,shortouchar. - De
intparasbyte,byte,short,ushort,uint,nuint,ulongouchar. - De
uintparasbyte,byte,short,ushort,int,nintouchar. - De
longparasbyte,byte,short,ushort,int,uint,nint,nuint,ulongouchar. - De
nintparasbyte,byte,short,ushort,int,uint,nuint,ulongouchar. - De
nuintparasbyte,byte,short,ushort,int,uint,nint,longouchar. - De
ulongparasbyte,byte,short,ushort,int,uint,nint,nuint,longouchar. - De
charparasbyte,byteoushort. - De
floatparasbyte,byte,short,ushort,int,uint,nint,nuint,long,ulong,charoudecimal. - De
doubleparasbyte,byte,short,ushort,int,uint,nint,nuint,long,ulong,char,floatoudecimal. - De
decimalparasbyte,byte,short,ushort,int,uint,nint,nuint,long,ulong,char,floatoudouble.
[...]
As conversões de enumeração explícitas são:
- De
sbyte,byte,short,ushort,int,uint,nint,nuint,long,ulong,char,float,doubleoudecimala qualquer enum_type. - De qualquer enum_type a
sbyte,byte,short,ushort,int,uint,nint,nuint,long,ulong,char,float,doubleoudecimal. - De qualquer enum_type para qualquer outro enum_type.
Considerando dois tipos T₁ e T₂, T₁ é um destino de conversão melhor do que T₂ se uma das seguintes condições for atendida:
- Existe uma conversão implícita de
T₁paraT₂e não existe nenhuma conversão implícita deT₂paraT₁ -
T₁éTask<S₁>,T₂éTask<S₂>eS₁é um destino de conversão melhor do queS₂ -
T₁éS₁ouS₁?em queS₁é um tipo integral assinado eT₂éS₂ouS₂?em queS₂é um tipo integral sem sinal. Especificamente: [...]
[...] O número de expressões no argument_list deve ser igual à classificação de array_type, e cada expressão deve ser do tipo int, uint, nint, nuint, long, ou ulong, ou deve ser implicitamente conversível para um ou mais desses tipos.
[...] O número de expressões no argument_list deve ser igual à classificação de array_type, e cada expressão deve ser do tipo int, uint, nint, nuint, long, ou ulong, ou deve ser implicitamente conversível para um ou mais desses tipos.
[...] O processamento em tempo de execução de um acesso de matriz do formulário P[A], em que P é um primary_no_array_creation_expression de um array_type e A é um argument_list, consiste nas seguintes etapas: [...]
- As expressões de índice de argument_list são avaliadas em ordem, da esquerda para a direita. Após a avaliação de cada expressão de índice, uma conversão implícita para um dos seguintes tipos é executada:
int,uint,nint,nuint,long,ulong. O primeiro tipo nessa lista para o qual existe uma conversão implícita é escolhido. [...]
A resolução de sobrecarga de operador unário é aplicada para selecionar uma implementação de operador específica. Os operadores predefinidos ++ e -- existem para os seguintes tipos: sbyte, byte, short, ushort, int, uint, nint, nuint,long, ulong, char, float, double, decimal e qualquer tipo de enumeração.
Os operadores de adição de unários predefinidos são:
C#
...
nint operator +(nint x);
nuint operator +(nuint x);
Os operadores de subtração de unários predefinidos são:
Negação de inteiro:
C#... nint operator –(nint x);
Os operadores predefinidos ++ e -- existem para os seguintes tipos: sbyte, byte, short, ushort, int, uint, nint, nuint, long, ulong, char, float, double, decimal e qualquer tipo de enumeração.
Além disso, um default_value_expression será uma expressão constante se o tipo for um dos seguintes tipos de valor: sbyte, byte, short, ushort, int, uint, nint, nuint, long, ulong, char, float, double, decimal, bool, ou qualquer tipo de enumeração.
Os operadores de complemento bit a bit predefinidos são:
C#
...
nint operator ~(nint x);
nuint operator ~(nuint x);
Os operadores predefinidos ++ e -- existem para os seguintes tipos: sbyte, byte, short, ushort, int, uint, nint, nuint, long, ulong, char, float, double, decimal e qualquer tipo de enumeração.
Os operadores de multiplicação predefinidos estão listados abaixo. Todos os operadores computam o produto de x e y.
Multiplicação de inteiros
C#... nint operator *(nint x, nint y); nuint operator *(nuint x, nuint y);
Os operadores de divisão predefinidos estão listados abaixo. Todos os operadores computam o quociente de x e y.
Divisão de inteiros:
C#... nint operator /(nint x, nint y); nuint operator /(nuint x, nuint y);
Os operadores restantes predefinidos estão listados abaixo. Todos os operadores computam o restante da divisão entre x e y.
Resto inteiro:
C#... nint operator %(nint x, nint y); nuint operator %(nuint x, nuint y);
Adição de inteiros:
C#... nint operator +(nint x, nint y); nuint operator +(nuint x, nuint y);
Subtração de inteiros
C#... nint operator –(nint x, nint y); nuint operator –(nuint x, nuint y);
Os operadores de deslocamento predefinidos estão listados abaixo.
Deslocar à esquerda:
C#... nint operator <<(nint x, int count); nuint operator <<(nuint x, int count);Deslocar à direita:
C#... nint operator >>(nint x, int count); nuint operator >>(nuint x, int count);O operador
>>deslocaxpara a direita por um número de bits calculado conforme descrito abaixo.Quando
xé do tipoint,nintlong, os bits de ordem baixa dexsão descartados, os bits restantes são deslocados para a direita e as posições de bits vazias de ordem alta são definidas como zero sexnão for negativo e definido como um sexfor negativo.Quando
xé do tipouint,nuintouulongos bits de ordem baixa dexsão descartados, os bits restantes são deslocados para a direita e as posições de bits vazias de ordem alta são definidas como zero.Deslocamento para a direita sem sinal:
C#... nint operator >>>(nint x, int count); nuint operator >>>(nuint x, int count);
Para os operadores predefinidos, o número de bits a serem deslocados é computado da seguinte maneira: [...]
- Quando o tipo de
xénintounuint, a contagem de deslocamento é fornecida pelos cinco bits de ordem baixa decountem uma plataforma de 32 bits ou pelos seis bits de ordem baixa decountem uma plataforma de 64 bits.
Os operadores de comparação de inteiro predefinidos são:
C#
...
bool operator ==(nint x, nint y);
bool operator ==(nuint x, nuint y);
bool operator !=(nint x, nint y);
bool operator !=(nuint x, nuint y);
bool operator <(nint x, nint y);
bool operator <(nuint x, nuint y);
bool operator >(nint x, nint y);
bool operator >(nuint x, nuint y);
bool operator <=(nint x, nint y);
bool operator <=(nuint x, nuint y);
bool operator >=(nint x, nint y);
bool operator >=(nuint x, nuint y);
Os operadores lógicos inteiros predefinidos são:
C#
...
nint operator &(nint x, nint y);
nuint operator &(nuint x, nuint y);
nint operator |(nint x, nint y);
nuint operator |(nuint x, nuint y);
nint operator ^(nint x, nint y);
nuint operator ^(nuint x, nuint y);
Uma expressão constante pode ser um tipo de valor ou um tipo de referência. Se uma expressão constante for um tipo de valor, deverá ser um dos seguintes tipos: sbyte, byte, short, ushort, int, uint, nint, nuint, long, ulong, char, float, double, decimal, bool, ou qualquer tipo de enumeração.
[...]
Uma conversão de expressão constante implícita (§10.2.11) permite que uma expressão constante do tipo int seja convertida em sbyte, byte, short, ushort, uint, nint, nuint, ou ulong, desde que o valor da expressão constante esteja dentro do intervalo do tipo de destino.
Os elementos de matriz são acessados usando expressões element_access do formulário A[I₁, I₂, ..., Iₓ], em que A é uma expressão de um tipo de matriz e cada Iₑ é uma expressão do tipo int, uint, nint, nuint,long, ulong ou pode ser convertido implicitamente em um ou mais desses tipos. O resultado de um acesso de elemento de matriz é uma variável, ou seja, o elemento de matriz selecionado pelos índices.
[...]
Além disso, em um contexto não seguro, o conjunto de conversões explícitas disponíveis é estendido para que inclua as seguintes conversões explícitas de ponteiro:
- De qualquer pointer_type para qualquer outro pointer_type.
- De
sbyte,byte,short,ushort,int,uint,nint,nuint,longouulonga qualquer pointer_type. - De qualquer pointer_type a
sbyte,byte,short,ushort,int,uint,nint,nuint,longouulong.
[...] Em um acesso de elemento de ponteiro do formulário P[E], P deve ser uma expressão de um tipo de ponteiro que não seja void*e E deve ser uma expressão que pode ser convertida implicitamente em int, uint, nint, nuint,longou ulong.
Em um contexto não seguro, o operador + e o operador – podem ser aplicados a valores de todos os tipos de ponteiro, exceto void*. Portanto, para cada tipo de ponteiro T*, os seguintes operadores são definidos implicitamente:
C#
[...]
T* operator +(T* x, nint y);
T* operator +(T* x, nuint y);
T* operator +(nint x, T* y);
T* operator +(nuint x, T* y);
T* operator -(T* x, nint y);
T* operator -(T* x, nuint y);
Dada uma expressão P de um tipo de ponteiro T* e uma expressão N do tipo int, uint, nint, nuint, long ou ulong, as expressões P + N e N + P computam o valor do ponteiro do tipo T* que resulta da adição de N * sizeof(T) ao endereço fornecido pelo P. Da mesma forma, a expressão P – N calcula o valor do ponteiro do tipo T* que resulta da subtração de N * sizeof(T) do endereço fornecido por P.
Um dos principais impactos desse design é que System.IntPtr e System.UIntPtr ganham alguns operadores embutidos (conversões, unários e binários).
Eles incluem os operadores checked, o que significa que os seguintes operadores nesses tipos agora lançarão uma exceção ao ocorrer um estouro:
IntPtr + intIntPtr - intIntPtr -> intlong -> IntPtrvoid* -> IntPtr
Esse design significa que nint e nuint podem simplesmente ser emitidos como System.IntPtr e System.UIntPtr, sem usar System.Runtime.CompilerServices.NativeIntegerAttribute.
Da mesma forma, ao carregar metadados, NativeIntegerAttribute pode ser ignorado.
Colaborar conosco no GitHub
A fonte deste conteúdo pode ser encontrada no GitHub, onde você também pode criar e revisar problemas e solicitações de pull. Para obter mais informações, confira o nosso guia para colaboradores.
Comentários do C# feature specifications
O C# feature specifications é um projeto código aberto. Selecione um link para fornecer comentários: