566

The printf function takes an argument type, such as %d or %i for a signed int. However, I don't see anything for a long value.

Rodrigo de Azevedo
  • 1,035
  • 9
  • 17
Thomas Owens
  • 111,344
  • 96
  • 305
  • 429
  • Don't use long, it's not portable. https://stackoverflow.com/questions/16859500/mmh-who-are-you-priu64 – MarcH Nov 23 '19 at 01:02

7 Answers7

730

Put an l (lowercased letter L) directly before the specifier. 

unsigned long n;
long m;

printf("%lu %ld", n, m);
rogerdpack
  • 56,766
  • 33
  • 241
  • 361
postfuturist
  • 21,503
  • 11
  • 60
  • 84
  • 20
    `printf("%ld", ULONG_MAX)` outputs the value as -1. Should be `printf("%lu", ULONG_MAX)` for unsigned long as described by @Blorgbeard below. – jammus Nov 12 '11 at 16:03
  • 2
    Actually, you should change it to be `%ld`, to be more harmonic with OP question. – DrBeco Jun 21 '15 at 05:28
  • Yep Dr Beco; further, just `%l` triggers `warning: unknown conversion type character 0x20 in format [-Wformat]` – Patrizio Bertoni Jul 29 '15 at 10:53
203

I think you mean:

unsigned long n;
printf("%lu", n);   // unsigned long

or

long n;
printf("%ld", n);   // signed long
kiritsuku
  • 52,365
  • 18
  • 112
  • 133
Blorgbeard
  • 97,316
  • 47
  • 222
  • 267
90

On most platforms, long and int are the same size (32 bits). Still, it does have its own format specifier:

long n;
unsigned long un;
printf("%ld", n); // signed
printf("%lu", un); // unsigned

For 64 bits, you'd want a long long:

long long n;
unsigned long long un;
printf("%lld", n); // signed
printf("%llu", un); // unsigned

Oh, and of course, it's different in Windows:

printf("%l64d", n); // signed
printf("%l64u", un); // unsigned

Frequently, when I'm printing 64-bit values, I find it helpful to print them in hex (usually with numbers that big, they are pointers or bit fields).

unsigned long long n;
printf("0x%016llX", n); // "0x" followed by "0-padded", "16 char wide", "long long", "HEX with 0-9A-F"

will print:

0x00000000DEADBEEF

Btw, "long" doesn't mean that much anymore (on mainstream x64). "int" is the platform default int size, typically 32 bits. "long" is usually the same size. However, they have different portability semantics on older platforms (and modern embedded platforms!). "long long" is a 64-bit number and usually what people meant to use unless they really really knew what they were doing editing a piece of x-platform portable code. Even then, they probably would have used a macro instead to capture the semantic meaning of the type (eg uint64_t).

char c;       // 8 bits
short s;      // 16 bits
int i;        // 32 bits (on modern platforms)
long l;       // 32 bits
long long ll; // 64 bits

Back in the day, "int" was 16 bits. You'd think it would now be 64 bits, but no, that would have caused insane portability issues. Of course, even this is a simplification of the arcane and history-rich truth. See wiki:Integer

Dave Dopson
  • 39,848
  • 19
  • 88
  • 85
  • 7
    Just to clarify: there are more architectures than x86 and x64, and on those architectures, char, short, int, long and long long have different meanings. For example, a 32 bit mcu with 16 bit memory alignment could use: char=short=int=16 bit; long=32 bits; long long = 64 bits – AndresR Sep 06 '16 at 19:19
  • 2
    @AndresR - absolutely, and it matters very deeply to people who do embedded programming (I built a kernel module for a smoke alarm once). Pity those poor souls when they try to use code that wasn't written for portability. – Dave Dopson Sep 07 '16 at 19:44
  • 2
    I'm not so sure that "most platforms have a `long` that's of size 32" is still true. E.g., I'm on Oracle Linux x86_64/amd64, and with `nvcc` a `long` is 8 bytes. – interestedparty333 Jun 17 '19 at 18:02
  • "Oh, and of course, it's different in Windows". Is there a cross-platform solution? – Aaron Franke May 13 '20 at 09:05
  • @interestedparty333 Yes, I'm >95% sure that in Linux `long` has the same size as the word/pointer size (so 32-bits on 32-bit Linux and 64-bits on 64-bit Linux). If you look inside the Linux kernel's code or inside Linux drivers, they usually store pointers in `long` or `unsigned long` variables. Actually, a few weeks ago a colleague of mine who ported some code from Windows to Linux had to go and change all our `long`s to `uint32_t` because we would constantly misuse them when developing under Windows. – AnthonyD973 Feb 19 '21 at 22:21
  • The statement "On most platforms, long and int are the same size (32 bits)" is simply untrue... most Unix and Unix-like systems use the LP64 model where ints are 32-bit and long is 64-bit - https://en.wikipedia.org/wiki/64-bit_computing#64-bit_data_models – Nick Dowell Apr 19 '22 at 08:28
17

It depends, if you are referring to unsigned long the formatting character is "%lu". If you're referring to signed long the formatting character is "%ld".

krato
  • 1,176
  • 4
  • 12
  • 30
14

%ld see printf reference on cplusplus.com

kiritsuku
  • 52,365
  • 18
  • 112
  • 133
Rob Walker
  • 45,387
  • 15
  • 95
  • 136
13

In case you're looking to print unsigned long long as I was, use:

unsigned long long n;
printf("%llu", n);

For all other combinations, I believe you use the table from the printf manual, taking the row, then column label for whatever type you're trying to print (as I do with printf("%llu", n) above).

Dolan Antenucci
  • 14,712
  • 16
  • 70
  • 98
-2

I think to answer this question definitively would require knowing the compiler name and version that you are using and the platform (CPU type, OS etc.) that it is compiling for.

Andrew O'Reilly
  • 1,625
  • 13
  • 15