¿Qué significan 0LL o 0x0UL?

estoy leyendo el Tutorial de Google Go y vi esto en la sección de constantes:

No hay constantes como 0LL o 0x0UL

Traté de hacer una búsqueda en Google, pero todo lo que aparece son casos en los que las personas usan estas constantes, pero no hay explicación de lo que significan. Se supone que 0x inicia un literal hexadecimal, pero estos no son caracteres posibles en un número hexadecimal.

Estas son constantes en C y C++. el sufijo LL significa que la constante es de tipo long longy 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 provocar 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 trunca),

    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 largo.

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

LL designa un literal como long long y UL designa a uno 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 este último es un unsigned long.

Hay muchos de estos especificadores:

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

+En lenguajes tipo C, esos sufijos te dicen el tipo exacto. Así por ejemplo. 9 es un int variables, pero 0LL es un long long