Heltal bokstavligt

Inom datavetenskap är en heltalsliteral en sorts bokstavlig för ett heltal vars värde är direkt representerat i källkoden . Till exempel, i tilldelningssatsen x = 1 , är strängen 1 ett heltalsliteral som anger värdet 1, medan i satsen x = 0x10 är strängen 0x10 en heltalsliteral som anger värdet 16, vilket representeras av 10 i hexadecimal ( indikeras av prefixet 0x ).

Däremot i x = cos(0) evalueras uttrycket cos(0) till 1 (som cosinus för 0), men värdet 1 ingår inte bokstavligen i källkoden. Enklare, i x = 2 + 2, evalueras uttrycket 2 + 2 till 4, men värdet 4 ingår inte bokstavligen. Vidare, i x = "1" är "1" en sträng literal , inte en heltalsliteral, eftersom den står inom citattecken. Strängens värde är 1 , vilket råkar vara en heltalssträng, men detta är semantisk analys av strängen literal – på den syntaktiska nivån är "1" helt enkelt en sträng, inte annorlunda än "foo" .

Parsing

Att känna igen en sträng (teckensekvens i källkoden) som en heltalsliteral är en del av den lexikaliska analysfasen (lexing), medan utvärdering av det bokstavliga till dess värde är en del av den semantiska analysfasen . Inom lexer- och frasgrammatiken betecknas tokenklassen ofta heltal , där gemener indikerar en tokenklass på lexikalnivå, i motsats till produktionsregeln på frasnivå (som ListOfIntegers ). När en sträng har lexerats (tokeniserats) som en heltalsliteral, kan dess värde inte bestämmas syntaktisk (det är bara ett heltal), och utvärdering av dess värde blir en semantisk fråga.

Heltalsliterala ord lexas vanligtvis med reguljära uttryck , som i Python .

Utvärdering

Liksom med andra bokstaver, utvärderas heltalsliteraler i allmänhet vid kompilering, som en del av den semantiska analysfasen. I vissa fall görs denna semantiska analys i lexern, omedelbart efter igenkänning av en heltalsliteral, medan detta i andra fall skjuts upp till analysstadiet, eller tills efter att analysträdet har konstruerats fullständigt . Till exempel, när lexern känner igen strängen 0x10 , kunde lexern omedelbart utvärdera detta till 16 och lagra det (en token av typen heltal och värde 16), eller skjuta upp utvärderingen och istället spela in en token av typen heltal och värdet 0x10 .

När bokstavliga uttryck har utvärderats är ytterligare semantisk analys i form av konstant vikning möjlig, vilket innebär att bokstavliga uttryck som involverar bokstavliga värden kan utvärderas i kompileringsfasen. Till exempel, i påståendet x = 2 + 2 efter att de bokstavliga har utvärderats och uttrycket 2 + 2 har analyserats, kan det sedan utvärderas till 4, även om värdet 4 inte i sig visas som en bokstavlig.

Anbringar

Heltalsliteraler har ofta prefix som anger bas och mer sällan suffix som anger typ. Till exempel, i C++ anger 0x10ULL värdet 16 (eftersom hexadecimalt) som ett långt långt heltal utan tecken.

Vanliga prefix inkluderar:

• 0x eller 0X för hexadecimal (bas 16);
• 0 0o eller 0O för oktal (bas 8) ;
• 0b eller 0B för binär (bas 2).

Vanliga suffix inkluderar:

• l eller L för långt heltal;
• ll eller LL för långt långt heltal;
• u eller U för heltal utan tecken.

Dessa affix påminner något om sigils , även om sigils fäster vid identifierare (namn), inte bokstavliga.

Sifferavgränsare

På vissa språk kan heltalsliteraler innehålla sifferavgränsare för att tillåta siffergruppering i mer läsbara former. Om detta är tillgängligt kan det vanligtvis också göras för flyttal. Detta är särskilt användbart för bitfält och gör det lättare att se storleken på stora siffror (som en miljon) på ett ögonkast genom att subitiera istället för att räkna siffror. Det är också användbart för nummer som vanligtvis är grupperade, till exempel kreditkortsnummer eller personnummer . Mycket långa nummer kan grupperas ytterligare genom att dubbla upp separatorer.

Vanligtvis är decimaltal (bas-10) grupperade i tresiffriga grupper (representerar ett av 1000 möjliga värden), binära tal (bas-2) i fyrsiffriga grupper (en nibble , representerar ett av 16 möjliga värden) och hexadecimala tal ( base-16) i tvåsiffriga grupper (varje siffra är en bit, så två siffror är en byte , som representerar ett av 256 möjliga värden). Nummer från andra system (som id-nummer) grupperas enligt vilken konvention som helst som används.

Exempel

I Ada , C# (från version 7.0), D , Eiffel , Go (från version 1.13), Haskell (från GHC version 8.6.1), Java (från version 7), Julia , Perl , Python (från version 3.6), Ruby , Rust och Swift , heltalsliteraler och floatliteraler kan separeras med ett understreck ( _ ). Det kan finnas vissa restriktioner för placering; till exempel, i Java kan de inte visas i början eller slutet av bokstaven, inte heller bredvid en decimalkomma. Observera att även om punkt, kommatecken och (tunna) mellanslag används i normal skrivning för sifferseparering, står dessa i konflikt med deras befintliga användning i programmeringsspråk som radixpunkt , listseparator (och i C/C++, kommaoperatorn ) , och token separator.

Exempel inkluderar:

   
   
    int  oneMillion  =  1_000_000  ;  int  creditCardNumber  =  1234_5678_9012_3456  ;  int  socialSecurityNumber  =  123_45_6789  ; 

I C++14 (2014) och nästa version av C från 2022, C23 , kan apostroftecknet användas för att separera siffror godtyckligt i numeriska bokstaver. Understrecket föreslogs ursprungligen, med ett första förslag 1993, och igen för C++11 , efter andra språk. Detta orsakade dock konflikt med användardefinierade bokstaver , så apostrof föreslogs istället som ett " övre kommatecken " (som används i vissa andra sammanhang).

   
   
  
     auto  heltal_literal  =  1'000'000  ;  auto  binary_literal  =  0b0100'1100'0110  ;  auto  very_long_binary_literal  =  0b0000'0001'0010'0011  ''  0100'0101'0110'0111  ;