c# - sirve - no se puede convertir implícitamente el tipo ''string'' en string[]
Sufijo C#detrás de literal numérico (3)
Soy nuevo en C # y quiero entender cómo funcionan los valores. Si observo un valor entero normal, tiene 3 partes importantes: el tipo, el nombre y el valor.
int testInt = 3;
| | |
Type Name Value
Pero cuando veo un valor flotante, me confunde un poco por el sufijo F
float testFloat = 3.0F;
| | | |
Type Name Value Type
Ahora hay dos tipos en él, y sin el sufijo F el valor sería un doble. Pero ¿por qué sucede esto cuando puedo declarar la variable doble con
double testDouble = 3.0D;
El double como la primera palabra debería ser suficiente, ¿no es así? Lo mismo ocurre con el valor decimal con el sufijo M:
decimal testDecimal = 3.0M;
Entonces comienza realmente a confundirme cuando se trata de los otros sufijos:
ulong bigOne = 2985825802805280508UL;
Utilicé ulong en una prueba anterior y sé que u es para "no firmado" y permite que el valor sea dos veces más alto de lo normal. Luego obtienes la U nuevamente como sufijo y la L para el literal como Google dijo. Como lo entiendo, los "literales" son tipos de valor que contienen números. Pero lo que no entiendo es, ¿por qué este ulong funciona incluso sin el sufijo?
ulong bigOne = 2985825802805280508;
Luego intenté algo diferente para entender la importancia del sufijo.
byte testLong = 12312UL;
Esto no funcionó porque el valor es demasiado alto para el byte (254) y el sufijo no lo convierte en una variable larga.
¿Por qué la primera palabra (tipo) no es suficiente para una declaración? La primera palabra debería ser suficiente para decir el tipo. ¿Es la mejor práctica dar siempre un sufijo a los valores?
Estás confundiendo dos cosas diferentes aquí:
float testFloat = 3.0F;
El float le dice al compilador que la variable testFloat será un valor de punto flotante. La F le dice al compilador que el literal 3.0 es un float . El compilador necesita conocer ambas partes antes de poder decidir si puede o no asignar el literal a la variable sin conversión o con una conversión implícita.
Por ejemplo, puedes hacer esto:
float testFloat = 3;
Y eso está bien. Porque el compilador verá 3 como un entero literal, pero sabe que puede asignarlo a un flotador sin pérdida de precisión (esto es conversión implícita). Pero si haces esto:
float testFloat = 3.0;
3.0 es un doble literal (porque ese es el valor predeterminado sin un sufijo) y no puede (implícitamente) convertir implícitamente un doble en un flotador porque un flotador tiene menos precisión. En otras palabras, la información podría perderse. Entonces, o le dices al compilador que es un flotador literal:
float testFloat = 3.0f;
O dile que estás de acuerdo con cualquier pérdida de precisión al usar un reparto explícito :
float testFloat = (float)3.0;
Existe otra forma de declarar una variable sin especificar el tipo antes del nombre:
var myNumber = 10;
En este caso, el tipo de variable será definido por el valor literal.
Si usa el tipo (double | float | int | ...) en lugar de "var", el compilador realiza una conversión de valor literal a tipo de variable (cuando es posible).
Entonces, creo que el sufijo es importante cuando usas "var" para declarar variables y el tipo de valor literal no es el predeterminado asociado cuando no se usa el sufijo;
Hay otra razón por la que el uso del sufijo es demasiado útil, como en una situación en la que desea realizar conversiones implícitas en expresiones.
Todas las expresiones 1 deben poder resolverse en un tipo. Así que la expresión 42 siempre necesita tener exactamente un tipo (pasa a ser un int ). No puede ser un int si lo asigna a una variable int y un double si lo asigna a un double . El contexto en el que se usa una expresión nunca se usa para determinar a qué tipo se resuelve.
Es por esto que los literales numéricos pueden tener sufijos; es una forma de definir el tipo de esa expresión en esa expresión .
Tenga en cuenta que también hay conversiones implícitas entre muchos de los tipos numéricos, por lo que si escribe double d = 42; la expresión 42 es en realidad un número entero , pero se está realizando un operador de conversión implícito que lo convertirá en un double antes de la asignación.
1 Hay algunas excepciones aquí, como lambdas, a las que el tipo de expresión depende de cómo se usa, y los grupos de métodos; en un vacío estas expresiones no tienen tipo.