¿Qué significa 0LL o 0x0UL?

Question

Estoy leyendo el Google Go tutorial y vi esto en la sección constantes:

no hay constantes como 0LL o 0x0UL

Se ha intentado realizar una búsqueda en Google, pero todo lo que viene a los casos donde las personas están usando estas constantes pero no tienen una explicación de lo que significan. 0x se supone que debe iniciar un literal hexadecimal, pero estos no son caracteres que son posibles en un número hexadecimal.

Answer 1

Estas son constantes en C y C++. El sufijo LL significa que la constante es del tipo long long, y UL significa unsigned long.

En general, cada L o l representa un long y cada U o u representa un unsigned. Entonces, v.g.

1uLL 

significa la constante 1 con el 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, 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 enteros se evalúan como enteros grandes (sin truncamiento ocurre),

var nanosec_correct int64 = 1000000000 * 600 

y no hay "usual arithmetic promotion"

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.

Answer 2

0LL es un cero largo largo.

0x0UL es un cero largo sin signo, expresado mediante notación hexadecimal. 0x0UL == 0UL.

Answer 3

LL designa un literal como long long y UL se designa como unsigned long y 0x0 es hexadecimal para 0. Entonces, 0LL y 0x0UL son un número equivalente pero diferentes tipos de datos; el primero es un long long y el último es un unsigned long.

Hay muchos de estos especificadores:

1F // float 
1L // long 
1ull // unsigned long long 
1.0 // double 

Answer 4

+ En lenguajes como C, los sufijos te dice el tipo exacto. Así por ejemplo.9 es una variable int, pero 0LL es una long long

Answer 5

Hay varios diferentes tipos numéricos básicos, y las letras a diferenciarse:

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