Cum imprimați un lung int intrinsec nesemnificat (specificatorul de format pentru int long long unsigned)?

 
#include 
int main() {
    unsigned long long int num = 285212672; //FYI: fits in 29 bits
    int normalInt = 5;
    printf("My number is %d bytes wide and its value is %ul. A normal number is %d.\n", sizeof(num), num, normalInt);
    return 0;
}

ieşire:

My number is 8 bytes wide and its value is 285212672l. A normal number is 0.

Presupun că acest rezultat neașteptat este de la imprimarea codului unsigned long long int . Cum face printf() un cod ?

 0
adăugat editat
Vizualizări: 127
sursa
fr hi bn
Consultați, de asemenea, stackoverflow.com/questions/5140871/sprintf-for-unsigned- int & zwnj; 64
adăugat autor hippietrail, sursa
Aș sugera utilizarea folosind stdint.h și fiind explicit despre numărul de biți din variabila dvs. Încă suntem într-o perioadă de tranziție între arhitecturile de 32 și 64 de biți și "intrinsec nesemnificat de lungă durată" nu înseamnă același lucru în ambele.
adăugat autor BD at Rivenhill, sursa
Tocmai v-am compilat codul (cu% llu) cu gcc și ieșirea a fost cea corectă. Transferați vreo opțiune la compilator?
adăugat autor Juan, sursa
Rețineți că newlib-ul lui samsung bada pare să nu accepte "% lld": adăugat autor RzR, sursa

9 răspunsuri

Ei bine, o modalitate este să o compilați ca x64 cu VS2008

Aceasta se întâmplă așa cum v-ați aștepta:

int normalInt = 5; 
unsigned long long int num=285212672;
printf(
    "My number is %d bytes wide and its value is %ul. 
    A normal number is %d \n", 
    sizeof(num), 
    num, 
    normalInt);

Pentru codul de 32 de biți, trebuie să folosim specificatorul de format __int64 corect% I64u. Deci, devine.

int normalInt = 5; 
unsigned __int64 num=285212672;
printf(
    "My number is %d bytes wide and its value is %I64u. 
    A normal number is %d", 
    sizeof(num),
    num, normalInt);

Acest cod funcționează atât pentru compilatorul VS de 32 și 64 de biți.

0
adăugat
sursa

Lucrurile non-standard sunt întotdeauna ciudate :)

for the long long portion under GNU it's L, ll or q

și sub ferestre cred că este doar ll

0
adăugat
sursa

Poate doriți să încercați să utilizați biblioteca inttypes.h care vă oferă tipuri precum int32_t , int64_t , uint64_t etc. Apoi puteți utiliza macrocomenzile sale, cum ar fi:

uint64_t x;
uint32_t y;

printf("x: %"PRId64", y: %"PRId32"\n", x, y);

Acest lucru este "garantat" pentru a nu vă provoca aceleași probleme ca long , long unsigned long etc, deoarece nu trebuie să ghiciți câte biți sunt în fiecare tip de date .

0
adăugat
sursa
@happy_marmoset: acestea sunt definite în inttypes.h
adăugat autor Nathan Fellman, sursa
Intele sunt în ambele, inttypes conține, de asemenea, bools care pot fi găsite în stdbool.h
adăugat autor user2316602, sursa
Este inttypes.h standard? Nu ar fi stdint.h ?
adăugat autor MD XF, sursa
unde sunt definite aceste macrocomenzi PRId64 , PRId32 ?
adăugat autor happy_marmoset, sursa
Cred că aveți nevoie de PRIu64 și PRIu32 pentru numere întregi fără semn.
adăugat autor Lasse Kliemann, sursa

In Linux it is %llu and in Windows it is %I64u

Deși am descoperit că nu funcționează în Windows 2000, se pare că există un bug acolo!

0
adăugat
sursa
Se pare că MS își exercită "libertatea de a inova" din nou ... ;-)
adăugat autor Dronz, sursa
Doar ceea ce am observat. Am scris o aplicație care a folosit această construcție și a funcționat perfect pe WinXP, dar a scuipat gunoi pe Win2k. Poate că are legătură cu un apel de sistem pe care biblioteca C o face la kernel, poate că are legătură cu Unicode, cine știe. Îmi amintesc că trebuie să lucrez în jurul acestuia folosind _i64tot() sau ceva de genul asta.
adăugat autor Adam Pierce, sursa
cu ferestre, (sau cel puțin, cu compilatorul Microsoft pentru Windows) există și% I64d,% I32u și% I32d
adăugat autor JustJeff, sursa
Ce are de-a face cu Windows 2000? Biblioteca C este cea care se ocupă de printf.
adăugat autor CMircea, sursa

hex:

printf("64bit: %llp", 0xffffffffffffffff);

ieşire:

64bit: FFFFFFFFFFFFFFFF
0
adăugat
sursa
Dar, aproape toți compilatoarele C ++ și C dau avertismentul: avertisment: utilizarea modificatorului de lungime 'll' cu caracterul de tip "p" [-Wformat =]
adăugat autor Seshadri R, sursa
Foarte frumos! Mă întrebam cum aș putea să o obțin în reprezentare hex
adăugat autor RE-Beginner, sursa

Utilizați modificatorul ll (el-el) de lungă durată cu conversia u (nesemnată). (Lucrări în ferestre, GNU).

printf("%llu", 285212672);
0
adăugat
sursa
Acesta nu este un lucru Linux / UNIX, modificatorul de lungime "ll" a fost adăugat la standardul C în C99, dacă nu funcționează în "Microsoft C", atunci se datorează faptului că nu sunt compatibile cu standardele.
adăugat autor Robert Gamble, sursa
Funcționează în Turbo C ++ pe Windows
adăugat autor Patrick McDonald, sursa
Nu înțeleg de ce nu a fost încă acceptat un astfel de răspuns răzbunat.
adăugat autor 0decimal0, sursa
Lucrează pentru mine în VS2008. Mai mult decât atât, din câte îmi amintesc MS C Compiler (când este configurat pentru a compila drept C) se presupune că este C90 conform designului; C99 a introdus câteva lucruri pe care nu le-a plăcut toată lumea.
adăugat autor スーパーファミコン, sursa
totul se schimbă cu mașina de 64 de biți
adăugat autor Antarus, sursa
Pentru ieșirea Hex, o lungă lungime nesemnată va fi tipărită cu% I64x. Modul practic portabil este de a arunca numărul la intmax_t și de a folosi PRIXMAX. Și pentru a folosi PRIXMAX sau ceva asemănător cu C ++ într-un compilator GNU, trebuie să #define __STDC_FORMAT_MACROS. Și în condițiile pe care le descriu, definiția PRIXMAX pe care o primesc pare a fi cea greșită și trebuie să forțez% I64X care funcționează.
adăugat autor cardiff space man, sursa
Folosind compilatorul Cygwin care se compilează încrucișat cu x86_64 (x86_64-w64-mingw32-g ++)% lx cu un lung int nesemnificat int dă o eroare că formatul și tipul nu merg împreună și folosind% llx cu aceeași variabilă și același compilator dă o eroare că% llx este un format necunoscut. Și variabila este de fapt o pthread_t. Deci nu funcționează în Windows / GNU și problema nu este că este compilatorul Microsoft.
adăugat autor cardiff space man, sursa
Nu funcționează pe Windows - este doar pentru Linux / UNIX.
adăugat autor Paul Hargreaves, sursa
Sau pentru a fi precis este pentru GNU libc, și nu funcționează cu runtime-ul Microsoft.
adăugat autor Mark Baker, sursa
Eu folosesc Visual C ++ 2005 și funcționează bine
adăugat autor JProgrammer, sursa
Un lucru pe care trebuie să-l rețineți este că dacă treceți mai multe long long argumente la printf și utilizați format greșit % d în loc de % lld , chiar și argumentele tipărite după printf pentru a crash). În esență, argumentele variabile sunt transmise printf fără nici o informație de tip, deci dacă șirul format este incorect, rezultatul este imprevizibil.
adăugat autor dmitrii, sursa
Heard Herb Sutter spune într-un interviu că clienții Microsoft nu cer C99, astfel încât compilatorul lor C pur a fost înghețat la C90. Acest lucru este valabil dacă compilați ca C. Dacă compilați ca C ++, după cum au menționat și ceilalți, ar trebui să fiți bine.
adăugat autor ahcox, sursa
Utilizați PRId64 ca în răspunsul lui @Nathan Fellman.
adăugat autor jcoffland, sursa

Acest lucru se datorează faptului că% llu nu funcționează corect în Windows și% d nu poate gestiona numere întregi de 64 de biți. Vă sugerăm să utilizați în schimb PRIu64 și veți găsi că este portabil și pentru Linux.

Încercați în schimb:

#include 
#include 

int main() {
    unsigned long long int num = 285212672; //FYI: fits in 29 bits
    int normalInt = 5;
    /* NOTE: PRIu64 is a preprocessor macro and thus should go outside the quoted string. */
    printf("My number is %d bytes wide and its value is %"PRIu64". A normal number is %d.\n", sizeof(num), num, normalInt);
    return 0;
}

producție

My number is 8 bytes wide and its value is 285212672. A normal number is 5.
0
adăugat
sursa
+1 pentru referința la PRIu64, pe care nu l-am văzut niciodată, dar acest lucru nu pare portabil la 64 de biți Linux (cel puțin) deoarece PRIu64 se extinde la "lu" în loc de "llu".
adăugat autor BD at Rivenhill, sursa
totuși, pentru ao face mai portabilă, folosiți int64_t în loc pentru că s-ar putea să existe unele implementări cu lungi lungi mai mari decât lungi
adăugat autor Lưu Vĩnh Phúc, sursa
@BDatRivenhill Linux / Unix utilizează LP64 în care este lung 64 biți
adăugat autor Lưu Vĩnh Phúc, sursa
Și de ce ar fi rău? O lungă este o valoare pe 64 biți pe Linux pe 64 de biți, la fel ca pe toate celelalte sisteme, cu excepția Windows.
adăugat autor Ringding, sursa

Compilați-l ca x64 cu VS2005:

% llu funcționează bine.

0
adăugat
sursa

%d--> for int

%u--> for unsigned int

%ld--> for long int

%lu--> for unsigned long int

%lld--> for long long int

%llu--> for unsigned long long int

0
adăugat
sursa