C++ integers, long och long long vad är egentligen rätt?

Det var länge sedan jag jonglerade med C/C++ men det är av historiska skäl som long "beter sig" så där (från 16-bit-systemens tid troligen), och har inte ändrats pga bakåtkompatibilitet. Har ingen specifik rekommendation, men om antalet bitar för dina heltal är viktigt så är det väl bäst att explicit specificera det (dvs __int64 kommer ju alltid att bli 64-bit, signed, oberoende av eventuella framtida förändringar och kompilatorer).

Nu är jag inte jättehaj på just c++, men ska försöka svara. En long kan lagra större värden än en vanlig int32 eftersom den använder 64 bitar för att lagra värden, istället för 32 (på samma sätt som short int använder 16 bitar istället för 32). Vad du ska använda beror på. Ett exempel är om du vill mäta hur lång tid en viss bit kod tar att köra. I java brukar man anropa System.currentTimeMillis() för en start och en slutpunkt och beräkna differensen. System.currentTimeMillis() returnerar en long (motsvarande long int i c++), helt enkelt för att antalet millisekunder från 00:00 1:a januari 1970 är ett för stort tal för att lagra i en vanlig int. I de allra flesta fall fungerar vanliga ints, men om du nån gång behöver spara tal större än 2'147'483'647, då använder du long int.

Jag hoppas att jag inte missförstod frågan

Det spelar roll eftersom long är inkonsekvent med storleken vid kompilering. Det är betydligt bättre att använda __intXX för dina variabler, speciellt om man har koll på hur stora värden man avser lagra i dem.

I C++ så är int garanterad att vara minst 16 bitar, medan en long är minst 32 bitar. Det är också garanterat att long är minst lika stor som int. Så int och long kan vara lika stora, men long kan också vara större. På mitt 64-bitars Linux-system så är t.ex. int 32 bitar och long 64 bitar. Du kan läsa mer om vilka regler som gäller för typerna här.

Om du vill ha en datatyp med en fast garanterad storlek så kan du inkludera cstdint och använda dessa datatyper. __int64 o.s.v. bör du undvika eftersom det är datatyper specifika för Microsofts C++-kompilator, och därmed inte standard C++.

Man behöver för övrigt inte skriva ut int när man använder short, long, signed eller unsigned. D.v.s. istället för unsigned int så räcker det att bara använda unsigned.

C++ standarden säger endast detta om char, short int, int och long int:

• long int kan hålla minst lika stort tal som int

• int kan hålla minst lika stort tal som short int

• char kan hålla minst lika stort tal som short int

D.v.s. den garanti som finns är sizeof(char) <= sizeof(short int) <= sizeof(int) <= sizeof(long int)

Standarden säger också att sizeof(char) == 1. Så en fullt kompatibel implementation kan alltså ha long int där sizeof(long int) == 1!!! Tittar man på t.ex. 8-bitars AVR (används i de flesta Arduino-kort) och PIC så är sizeof(int) == 1 och kan därmed hålla tal -128..127.

Du ska använda int när du behöver hantera ett heltal som inte är jättestort, enda egentliga garanti du har är att int är av en storlek som är effektiv för underliggande arkitektur. Exakt hur stor dessa typer är bestäms både av CPU och OS. Jämför du Windows och Linux på x86_64 så är sizeof(long int) olika, den är 4 på Windows och 8 på Linux då 64-bitars Windows använder sig av en standard som kallas LLP64 (endast long long int och pekare är 64-bitars) medan Linux kör med LP64 (long int och pekare är 64-bitars). sizeof(int) är 4 både för IA32 (32-bitars x86) och x86_64, både i Windows och Linux.

Om du behöver en viss storlek använd standardtyperna för detta. __int64 är Windows-specifika och ska undvikas, standard C++ (och standard C) har idag intN_t och uintN_t där N är 8, 16, 32 eller 64. Så för att deklarera en heltalsvariabel som garanterat är 64 bitar, gör detta

#include <cstdint>
...
    int64_t myvar;
...