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.
asked Sep 1, 2008 at 22:45
7 Answers
Put an l (lowercased letter L) directly before the specifier.
unsigned long n;
long m;
printf("%lu %ld", n, m);
answered Sep 1, 2008 at 22:50
-
20
printf("%ld", ULONG_MAX)outputs the value as -1. Should beprintf("%lu", ULONG_MAX)for unsigned long as described by @Blorgbeard below.– jammusCommented Nov 12, 2011 at 16:03 -
2Actually, you should change it to be
%ld, to be more harmonic with OP question.– DrBecoCommented Jun 21, 2015 at 5:28 -
Yep Dr Beco; further, just
%ltriggerswarning: unknown conversion type character 0x20 in format [-Wformat]Commented Jul 29, 2015 at 10:53
I think you mean:
unsigned long n;
printf("%lu", n); // unsigned long
or
long n;
printf("%ld", n); // signed long
answered Sep 1, 2008 at 23:26
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
answered Jan 30, 2013 at 18:15
-
7Just 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– AndresRCommented Sep 6, 2016 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. Commented Sep 7, 2016 at 19:44
-
2I'm not so sure that "most platforms have a
longthat's of size 32" is still true. E.g., I'm on Oracle Linux x86_64/amd64, and withnvccalongis 8 bytes. Commented Jun 17, 2019 at 18:02 -
"Oh, and of course, it's different in Windows". Is there a cross-platform solution? Commented May 13, 2020 at 9:05
-
@interestedparty333 Yes, I'm >95% sure that in Linux
longhas 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 inlongorunsigned longvariables. Actually, a few weeks ago a colleague of mine who ported some code from Windows to Linux had to go and change all ourlongs touint32_tbecause we would constantly misuse them when developing under Windows. Commented Feb 19, 2021 at 22:21
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".
answered Sep 1, 2008 at 22:47
I needed to print unsigned long long, so I found this works:
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).
answered Oct 28, 2012 at 19:24
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.
-
4Your answer should be a comment and not an answer by itself. Commented Aug 29, 2019 at 5:01
-
No: there is no platform dependency on the correct format for printing a
long— the correct answer is%ld. The range of values that may be printed does depend on the platform — on some platformslongwill be a 32-bit type (especially back in 2008) and on other platforms it will be a 64-bit type (especially in 2022 and later). But if the data type islong, the correctprintf()conversion specifier is%ld(though you can use%li). Commented Nov 4, 2022 at 21:00
intportable. Historically,intwas a 16-bit value; it has also been a 64-bit value on some machines (Cray, for example). Even the 'exact width types' such asint64_tare not 100% portable; they're defined only if the architecture supports such a type. Theint_least64_ttypes are as close as it gets to portable.fprintffunction — the entry in §7.21.6.3 Theprintffunction largely redirects to ¶7.21.6.1. The POSIX specification isprintf().intis not portable either yet it can be the best choice in some cases; for instance the index of a smallforloop does typically not require portability. On the other hand,longis not portable and it's never useful and never the best choice.longis just bad. If you need something guaranteed to be 32bits or 64bits big then useuint32_toruint64_t. Simple. If they're not available on some exotic platform then your code will not compile which is what you want.