{"id":288,"date":"2013-09-21T00:01:40","date_gmt":"2013-09-21T08:01:40","guid":{"rendered":"http:\/\/c-for-dummies.com\/blog\/?p=288"},"modified":"2017-01-21T08:56:24","modified_gmt":"2017-01-21T16:56:24","slug":"conversion-character-mania-integer-output","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=288","title":{"rendered":"Conversion Character Mania: Integer Output"},"content":{"rendered":"

The printf()<\/em> function’s power lies in its formatting abilities, specifically the display of values. That power is vast, but the documentation showing how it works really sucks.
\n
\nRather than try to create this massive grid that shows all the printf()<\/em> conversion character options and settings, I thought I’d concentrate on presenting each conversion character based on the type of value it formats. This week’s lesson is about the integer output conversion characters.<\/p>\n

Because integer values can be either signed<\/em> or unsigned<\/em>, C uses two different conversion characters to format output: %d<\/code> for signed int<\/em> values and %u<\/code> for unsigned<\/em>.<\/p>\n

The %d<\/code> and %u<\/code> conversion characters handle the variable types shown in Table 1.<\/p>\n

\n\n\n\n\n\n\n\n\n\n\n
 <\/td>\n%d<\/code><\/td>\n%u<\/code><\/td>\n<\/tr>\n
int<\/em><\/td>\nX<\/td>\n <\/td>\n<\/tr>\n
short<\/em><\/td>\nX<\/td>\n <\/td>\n<\/tr>\n
signed int<\/em><\/td>\nX<\/td>\n <\/td>\n<\/tr>\n
unsigned<\/em><\/td>\n <\/td>\nX<\/td>\n<\/tr>\n
unsigned short<\/em><\/td>\n <\/td>\nX<\/td>\n<\/tr>\n
unsigned int<\/em><\/td>\n <\/td>\nX<\/td>\n<\/tr>\n
char<\/em><\/td>\nX<\/td>\n <\/td>\n<\/tr>\n
unsigned char<\/em><\/td>\n <\/td>\nX<\/td>\n<\/tr>\n<\/table>\n<\/div>\n

The same conversion characters are used for long int<\/em> values as well. In that case you prefix the d<\/code> or u<\/code> with an l<\/code> (lower case L): %ld<\/code> and %lu<\/code><\/p>\n

The double long<\/em> or long long<\/em> integer values use two Ls: %lld<\/code> and %llu<\/code><\/p>\n

You can sandwich a width value between the percent sign and the conversion character letters. This value specifies how many characters wide to format the output. The purpose of the width value is to help align output to a fixed field.<\/p>\n

In the following code, the value 8 is used to set the output to 8 characters.<\/p>\n

\r\n#include <stdio.h>\r\n\r\nint main()\r\n{\r\n    int i = 498;\r\n\r\n    printf(\"Value:%8d\\n\",i);\r\n    printf(\"Value:%8d\\n\",i*10);\r\n    printf(\"Value:%8d\\n\",i*100);\r\n\r\n    return(0);\r\n}<\/pre>\n
The integer is right-aligned in the output, which looks like this:<\/p>\n
Value:     498\r\nValue:    4980\r\nValue:   49800<\/code><\/pre>\n
The width value can apparently be any size; I’ve tested it up to 4,300,000,000 characters wide and the compiler didn’t puke.<\/p>\n
If, for some bizarre reason, you wanted to left-justify the values, change the placeholder to %-8d<\/code> in each printf()<\/em> statement. Here’s the output:<\/p>\n
Value:498
\nValue:4980
\nValue:49800<\/code><\/p>\n
You don’t see it, but spaces are output to the right of the numbers above.<\/p>\n
Another prefix you can toss into integer output is 0<\/code>. What it does is to prefix output with zeros to pad the specified width. The 0<\/code> has to appear before the width value.<\/p>\n
For example, if you change all the %8d<\/code> conversion characters in the above code to %08d<\/code>, the output looks like this:<\/p>\n
Value:00000498
\nValue:00004980
\nValue:00049800<\/code><\/p>\n
The output is still 8 characters wide, but zeros pad each value on the left.<\/p>\n
In case you’re curious, you can’t use both -<\/code> and 0<\/code> together. If you want to pad zeros on the right side of a number, you’ll need to concoct your own function.<\/p>\n
To prefix a sign (+ or -) to the output, place a +<\/code> character right after the %<\/code> symbol. That character is inserted along with other options except the 0<\/code> prefix. All of these formats are valid:<\/p>\n
printf(\"Value:%8d\\n\",678);
\nprintf(\"Value:%08d\\n\",678);
\nprintf(\"Value:%+8d\\n\",678);
\nprintf(\"Value:%-8d\\n\",678);
\nprintf(\"Value:%+-8d\\n\",678);<\/code><\/p>\n
Here’s the output for those five statements:<\/p>\n
Value:     678\r\nValue:00000678\r\nValue:    +678\r\nValue:678     \r\nValue:+678  <\/code><\/pre>\n
In case you’re curious, you cannot prefix a currency symbol to the output by using a conversion character. Something like %$d<\/code> or %$8d<\/code> isn’t valid, although it might be in other programming languages.<\/p>\n
And now, the stragglers.<\/p>\n
Some integer conversion characters linger from the early days of C, although they’re pretty much unused these days. For example, the %i<\/code> conversion character displays integer values, but I recommend using %d<\/code> instead.<\/p>\n
The h<\/code> prefix can be used like l<\/code>, but to display short int<\/em> values. For example, %hd<\/code> ensures that a short int<\/em> value is output. I believe the h<\/code> stands for “half” as in half an int<\/em> value. (Internally, that means the variable would be represented by two bytes instead of four.)<\/p>\n
I’ll cover conversion character options for displaying floating point values in next week’s Lesson<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
Explore the various options available for displaying integer values by using printf()<\/em>‘s integer output conversion characters. Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-288","post","type-post","status-publish","format-standard","hentry","category-main"],"_links":{"self":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/288","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=288"}],"version-history":[{"count":15,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/288\/revisions"}],"predecessor-version":[{"id":2339,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/288\/revisions\/2339"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=288"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=288"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=288"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}