web-dev-qa-db-fra.com

Que signifient 0LL ou 0x0UL?

Je lis le tutoriel Google Go et je l'ai vu dans la section des constantes:

Il n'y a pas de constantes comme 0LL ou 0x0UL

J'ai essayé de faire une recherche Google, mais tout ce qui arrive est des cas où les gens utilisent ces constantes mais aucune explication sur ce qu'elles signifient. 0x est censé démarrer un littéral hexadécimal mais ce ne sont pas des caractères possibles dans un nombre hexadécimal.

cconstants
22
Bjorn

Ce sont des constantes en C et C++. Le suffixe LL signifie que la constante est de type long long et UL signifie unsigned long.

En général, chaque L ou l représente un long et chaque U ou u représente un unsigned. Ainsi, par exemple.

1uLL

signifie la constante 1 de type unsigned long long.

Cela s'applique également aux nombres à virgule flottante:

1.0f    // of type 'float'
1.0     // of type 'double'
1.0L    // of type 'long double'

et des chaînes et des caractères, mais ce sont des préfixes:

 '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 et C++, les constantes entières sont évaluées en utilisant leur type d'origine, ce qui peut provoquer des bogues dus à un débordement d'entier:

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.

Dans Google Go, tous les entiers sont évalués en tant que grands entiers (aucune troncature ne se produit),

    var nanosec_correct int64 = 1000000000 * 600

et il n'y a pas de " promotion arithmétique habituelle "

    var b int32 = 600
    var a int64 = 1000000000 * b
    // ^ cannot use 1000000000 * b (type int32) as type int64 in assignment

les suffixes ne sont donc pas nécessaires.

31
kennytm

Il existe plusieurs types numériques de base différents, et les lettres les différencient:

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
8
Tim

0LL est un long long zéro.

0x0UL est un zéro long non signé, exprimé en notation hexadécimale. 0x0UL == 0UL.

3
wallyk

LL désigne un littéral comme long long et UL en désigne un comme unsigned long et 0x0 est hexadécimal pour 0. Alors 0LL et 0x0UL sont un nombre équivalent mais des types de données différents; l'ancien est un long long et ce dernier est un unsigned long.

Il existe plusieurs de ces spécificateurs:

1F // float
1L // long
1ull // unsigned long long
1.0 // double
3
Seth Carnegie

+ Dans les langages de type C, ces suffixes vous indiquent le type exact. Ainsi, par exemple. 9 est une variable int, mais 0LL est un long long

2
Charlie Martin