Je lis la Google Go tutorial et vu cela dans la section constantes:Que signifient 0LL ou 0x0UL?
Il n'y a pas de constantes comme 0LL ou 0x0UL
j'ai essayé de faire une recherche Google, mais tout ce qui arrive des cas où les gens utilisent ces constantes, mais aucune explication sur ce qu'ils signifient. 0x est supposé démarrer un littéral hexadécimal mais ce ne sont pas des caractères qui sont possibles dans un nombre hexadécimal.
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 vaut également pour les 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 personnages, mais ils sont 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 en raison d'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 comme les grands entiers (pas troncature se produit),
var nanosec_correct int64 = 1000000000 * 600
et il n'y a pas "usual arithmetic promotion"
var b int32 = 600
var a int64 = 1000000000 * b
//^cannot use 1000000000 * b (type int32) as type int64 in assignment
de sorte que les suffixes ne sont pas nécessaires.
0LL est un long long zéro.
0x0UL est un zéro long non signé, exprimé en notation hexadécimale. 0x0UL == 0UL.
LL désigne un littéral comme long long et ULunsigned long on désigne comme 0x0 et est hexadécimal pour 0. Donc 0LL et 0x0UL sont un nombre équivalent mais des types de données différents; le premier est un long long et le dernier est un unsigned long.
Il y a beaucoup de ces spécificateurs:
1F // float
1L // long
1ull // unsigned long long
1.0 // double
+ Dans les langages de type C, ces suffixes vous dire le type exact. Donc, par exemple.9 est une variable int, mais 0LL est un long long
Il existe plusieurs types numériques de base, 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
«J'ai essayé de faire une recherche Google » ... essayez la recherche terme 'constantes entières C++ LL'. :) –
Je les ai toujours considérés comme des 'littéraux' et des constantes comme des variables déclarées comme constantes. –
Assez juste, mais j'imagine que les résultats pour 'littéraux entiers C++ LL' sont similaires ... :) –