¿Por qué las operaciones de cambio siempre dan como resultado un int firmado cuando el operando es <32 bits

Question

¿Por qué las operaciones de cambio en ints sin signo dan un resultado sin signo, pero las operaciones en operandos sin firmar más pequeños dan como resultado un int firmado?

int signedInt = 1; 
int shiftedSignedInt = signedInt << 2; 

uint unsignedInt = 1; 
uint shiftedUnsignedInt = unsignedInt << 2;  //OK. unsigned result 

short signedShort = 1; 
int shiftedsignedShort = signedShort << 2; 

ushort unsignedShort = 1; 
uint shiftedUnsignedShort = unsignedShort << 2; //CS0266: Can't cast int to uint 

sbyte signedByte = 1; 
int shiftedSignedByte = signedByte << 2; 

byte unsignedByte = 1; 
uint shiftedUnsignedByte = unsignedByte << 2; //CS0266: Can't cast int to uint 

Answer 1

El shift operators están predefinidos sólo para estos casos (desplazamiento a la izquierda):

int operator <<(int x, int count); (1) 
uint operator <<(uint x, int count); (2) 
long operator <<(long x, int count); (3) 
ulong operator <<(ulong x, int count); (4) 

La expresión uint shiftedUnsignedShort = unsignedShort << 2 se interpreta como (1) -st caso (implicit up-casting from ushort to int y (int)2), por lo que lleva a cabo una advertencia en fundición ilegal (no hay conversión implícita del resultado int a ushort).
La misma situación que podemos ver para uint shiftedUnsignedByte = unsignedByte << 2. También se interpretó como (1) -st caso (up-casting implícito desde byte a int y (int)2, pero sin conversión implícita de valor resultante a uint).

Puede resolver estos problemas utilizando el siguiente enfoque:

uint shiftedUnsignedShort = (uint)unsignedShort << 2 //force use the (2)-nd shift operator case 
uint shiftedUnsignedByte = (uint)unsignedByte << 2; //force use the (2)-nd shift operator case 

Answer 2

Según Wikipedia<< y >> representan dos operadores diferentes. Un cambio lógico vor ulong y uint y un cambio aritmético para int y largo.

Ahora mi suposición (!) Es, que el ushort "undefined" o ubyte se echan en una int en lugar de un uint.

Lo siento, pero eso es todo lo que puedo ofrecer.

Answer 3

En Shift operators artículo de MSDN hay una mención de que existen operadores de desplazamiento predefinidos sólo para int, uint, tipos ULONG largos. Para todos los demás tipos, están sobrecargados. Para todas las operaciones de cambio, el segundo operando siempre será del tipo int. Por lo tanto, cualquier tipo corto siempre se convierte en int antes de realizar la operación de cambio.