Nuestros programadores estrellas agotaron sus depósitos de café, investigando noche y día por la solución, hasta que Celeste halló la contestación en Gitea por lo tanto en este momento la compartimos contigo.
Solución:
Estas son constantes en C y C ++. El sufijo LL significa que la constante es de tipo long long, y UL medio unsigned long.
En general, cada L o l representa un long y cada U o u representa un unsigned. Entonces, por ejemplo
1uLL
significa la constante 1 con tipo unsigned long long.
Esto también se aplica a los números de coma flotante:
1.0f // of type 'float'
1.0 // of type 'double'
1.0L // of type 'long double'
y cadenas y caracteres, pero son prefijos:
'A' // of type 'char'
L'A' // of type 'wchar_t'
u'A' // of type 'char16_t' (C++0x only)
U'A' // of type 'char32_t' (C++0x only)
En C y C ++, las constantes enteras se evalúan utilizando su tipo original, lo que puede causar errores debido al desbordamiento de enteros:
long long nanosec_wrong = 1000000000 * 600;
// ^ you'll get '-1295421440' since the constants are of type 'int'
// which is usually only 32-bit long, not big enough to hold the result.
long long nanosec_correct = 1000000000LL * 600;
// ^ you'll correctly get '600000000000' with this
int secs = 600;
long long nanosec_2 = 1000000000LL * secs;
// ^ use the '1000000000LL' to ensure the multiplication is done as 'long long's.
En Google Go, todos los números enteros se evalúan como números enteros grandes (no se produce ningún truncamiento),
var nanosec_correct int64 = 1000000000 * 600
y no hay “promoción aritmética habitual”
var b int32 = 600
var a int64 = 1000000000 * b
// ^ cannot use 1000000000 * b (type int32) as type int64 in assignment
por lo que los sufijos no son necesarios.
Hay varios tipos numéricos básicos diferentes y las letras los diferencian:
0 // normal number is interpreted as int
0L // ending with 'L' makes it a long
0LL // ending with 'LL' makes it long long
0UL // unsigned long
0.0 // decimal point makes it a double
0.0f // 'f' makes it a float
0LL es un cero largo.
0x0UL es un cero largo sin signo, expresado mediante notación hexadecimal. 0x0UL == 0UL.
Reseñas y calificaciones
Si te ha sido de ayuda nuestro post, sería de mucha ayuda si lo compartieras con más entusiastas de la programación de este modo contrubuyes a difundir esta información.