{"id":23270,"date":"2023-12-17T12:10:09","date_gmt":"2023-12-17T12:10:09","guid":{"rendered":"https:\/\/linuxways.net\/?p=23270"},"modified":"2024-03-25T02:10:28","modified_gmt":"2024-03-25T02:10:28","slug":"c-printf-formatting-specifiers","status":"publish","type":"post","link":"https:\/\/linuxways.net\/de\/scripting\/c-printf-formatting-specifiers\/","title":{"rendered":"Printf() Formatting Specifiers in C Language"},"content":{"rendered":"

The printf() function has several interesting properties, both in terms of its use and its design and operation. First, it is a variadic function which means that it can accept as many input arguments as the programmer wishes to send, thus solving a task with a single call that would otherwise require multiple functions and calls. Another important feature of printf() is that it can display the variables in any format that is used in C and insert them into the text without converting them into strings or using the concatenation functions for it.<\/p>\n

In this LinuxWays article, you’ll learn how to specify the format in which you want to show the variables when using the printf() function. We’ll look at a theoretical section that shows the syntax and the method for setting the output formats. We’ll also look at the formats available in this function and learn how to nest the text and variables so you can output them to the screen with a single call.<\/p>\n

<\/a>How Does the Printf() Function Work?<\/h2>\n

To see how printf() handles the formats, we first need to understand some aspects of the function and how its input arguments are processed. Let\u2019s see the prototype of printf():<\/p>\n

int<\/span> printf<\/span><\/a> (<\/span> const<\/span> char<\/span> *<\/span>restrict format,<\/span> ... )<\/span>;<\/span><\/div><\/div>\n

As we see in the prototype, the first input argument is the format pointer to a string, while the second argument is an ellipsis (…).<\/p>\n

The string that is pointed to by the format performs the following three functions:<\/p>\n

    \n
  1. Contains the text that is used to concatenate the values of the variables converted to strings.<\/li>\n
  2. Includes the format specifiers for the conversion of variables.<\/li>\n
  3. Specifies in which part and in which order the conversion results are to be concatenated.<\/li>\n<\/ol>\n

    In variadic functions, ellipses stand for an indefinite number of input arguments. In the case of printf(), the programmer can insert as many variables as he wants to be converted and printed, with the only rule that each of them must be separated by commas and has its own format specifier in the format string.<\/p>\n

    When called, the printf() function parses the format string and replaces the format specifiers with the resulting string of converted variables. As we can see in the format string, we specify not only the information about the conversion formats, but also the order and location where the variable should be concatenated in the text to print the final string.<\/p>\n

    The format identifiers that we will see in this article are compatible with all functions of this family.<\/p>\n

    <\/a>Format Specifiers in the Printf() Function<\/h2>\n

    Format specifiers are strings or fragments of strings that are contained in the format string of the printf() function. These strings or fragments of them determine the type of conversion and how a variable will be displayed in the output text.<\/p>\n

    The format identifiers can be contained in explicit or implicit strings and must always begin with the symbol \u201c%\u201d and end with the letter that specifies the conversion type. Below we see the syntax of a format specifier:<\/p>\n

    %<\/span> [<\/span>order]<\/span>[<\/span>flags]<\/span>[<\/span>width]<\/span>[<\/span>.precision<\/span>]<\/span>[<\/span>length]<\/span>type<\/div><\/div>\n

    The arguments enclosed in square brackets are optional and, as we will see later, specify the precision, field size, etc.<\/p>\n

    The most common way to establish a conversion format is to specify the type letter preceded by the \u201c%\u201d symbol. Let\u2019s see a table with the letter of type, the syntax used, and a short description for each:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    Type<\/strong><\/td>\nSyntax<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
    c<\/em><\/strong><\/td>\n%c<\/em><\/strong><\/td>\nPrint ASCII character<\/td>\n<\/tr>\n
    s<\/em><\/strong><\/td>\n%s<\/em><\/strong><\/td>\nPrint character strings<\/td>\n<\/tr>\n
    i, d<\/em><\/strong><\/td>\n%i, %d<\/em><\/strong><\/td>\nSigned integers conversion<\/td>\n<\/tr>\n
    u<\/em><\/strong><\/td>\n%u<\/em><\/strong><\/td>\nUnsigned integers conversion<\/td>\n<\/tr>\n
    f, F<\/em><\/strong><\/td>\n%f, %F<\/em><\/strong><\/td>\nFloating point conversion (standard notation)<\/td>\n<\/tr>\n
    e, E<\/em><\/strong><\/td>\n%e, %E<\/em><\/strong><\/td>\nFloating point conversion (scientific notation)<\/td>\n<\/tr>\n
    g, G<\/em><\/strong><\/td>\n%g, %G<\/em><\/strong><\/td>\nReduced floating point conversion<\/td>\n<\/tr>\n
    x, X<\/em><\/strong><\/td>\n%x, %X<\/em><\/strong><\/td>\nHexadecimal conversion<\/td>\n<\/tr>\n
    o<\/em><\/strong><\/td>\n%o<\/em><\/strong><\/td>\nOctal conversion<\/td>\n<\/tr>\n
    p<\/em><\/strong><\/td>\n%p<\/em><\/strong><\/td>\nPointer conversion<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    How to Specify the Conversion Format in the Printf() Function<\/h2>\n

    Now, let’s look at an example where we declare a variable for each conversion type, assign it with a value, and then print it to the command console using the printf() function, specifying the appropriate format for each type:<\/p>\n

    #include <stdio.h><\/span>
    \n
    \nvoid<\/span> main (<\/span>)<\/span>{<\/span>
    \n
    \nchar<\/span> a =<\/span>'Z'<\/span>;<\/span>
    \nchar<\/span> *<\/span> Ptr =<\/span>"Hello World"<\/span>;<\/span>
    \nint<\/span>  b =-<\/span>2023<\/span>;<\/span>
    \nunsigned<\/span> int<\/span> c =<\/span>12345<\/span>;<\/span>
    \nfloat<\/span> d =<\/span>1.123456789<\/span>;<\/span>
    \ndouble<\/span> sc =<\/span>1.123457e+00<\/span>;<\/span>
    \nint<\/span> o =<\/span>100<\/span>;<\/span>
    \nint<\/span> x =<\/span> 0x2EFF02<\/span>;<\/span>
    \n
    \nprintf<\/span><\/a> (<\/span>"char: %c\\n<\/span>"<\/span>,<\/span> a)<\/span>;<\/span>
    \n    printf<\/span><\/a> (<\/span>"string: %s\\n<\/span>"<\/span>,<\/span> Ptr)<\/span>;<\/span>
    \n    printf<\/span><\/a> (<\/span>"Pointer address: %p\\n<\/span>"<\/span>,<\/span> Ptr)<\/span>;<\/span>
    \n    printf<\/span><\/a> (<\/span>"int: %i\\n<\/span>"<\/span>,<\/span> b)<\/span>;<\/span>
    \n    printf<\/span><\/a> (<\/span>"unsigned int: %u\\n<\/span>"<\/span>,<\/span> c)<\/span>;<\/span>
    \n    printf<\/span><\/a> (<\/span>"float: %f\\n<\/span>"<\/span>,<\/span> d)<\/span>;<\/span>
    \n    printf<\/span><\/a> (<\/span>"scientific float: %e\\n<\/span>"<\/span>,<\/span> d)<\/span>;<\/span>
    \n    printf<\/span><\/a> (<\/span>"octal: %o\\n<\/span>"<\/span>,<\/span> o)<\/span>;<\/span>
    \n    printf<\/span><\/a> (<\/span>"hexadecimal: 0x%x\\n<\/span>"<\/span>,<\/span> x)<\/span>;<\/span>
    \n}<\/span><\/div><\/div>\n

    Let\u2019s see the compilation and execution of this code:<\/p>\n

    <\/p>\n

    As we can see in the picture, the identifiers have been replaced by the value of the corresponding variable. To make the example more readable, we use a call to the printf() function for each variable to be displayed, but the correct way is to resolve everything in a single call as shown in the following:<\/p>\n

    printf<\/span><\/a> (<\/span>"char: %c\\n<\/span>string: %s\\n<\/span>Pointer address: %p\\n<\/span>int: %i\\n<\/span>unsigned int: %u\\n<\/span>float: %f\\n<\/span>scientific float: %e\\n<\/span>octal: %o\\n<\/span>hexadecimal: 0x%x\\n<\/span>"<\/span>,<\/span> a,<\/span> Ptr,<\/span> Ptr,<\/span> b,<\/span> c,<\/span> d,<\/span> sc,<\/span> o,<\/span> x)<\/span>;<\/span><\/div><\/div>\n

    How to Set the Order of Variables in the Printf() Function<\/h2>\n

    As we have already seen, the variables, by default, are displayed in the final text in the same order in which they appear in the input arguments. However, we can change this order using the format specifier. Let\u2019s see a table with the syntax that we can use to specify the order of the variables:<\/p>\n\n\n\n\n
    Syntax<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
    “%<\/strong>n$[type]”<\/strong><\/td>\nn stands for the order of occurrence of the variables<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

    Next, let’s look at an example where we call the printf() function twice to display the \u201cHello\u201d and \u201cWorld\u201d strings in the console.<\/p>\n

    The first call is done by default, while we change the order in the second call using the \u201c%2s%1s\u201d specifications. Let\u2019s see the code for this example:<\/p>\n

    #include <stdio.h><\/span>
    \n
    \nvoid<\/span> main (<\/span>)<\/span>{<\/span>
    \nchar<\/span> *<\/span> str_1 =<\/span>"Hello "<\/span>;<\/span>
    \nchar<\/span> *<\/span> str_2 =<\/span>"World "<\/span>;<\/span>
    \nprintf<\/span><\/a> (<\/span>"%s%s\\n<\/span>"<\/span>,<\/span> str_1,<\/span> str_2)<\/span>;<\/span>
    \n    printf<\/span><\/a> (<\/span>"%2$s%1$s\\n<\/span>"<\/span>,<\/span> str_1,<\/span> str_2)<\/span>;<\/span>
    \n}<\/span><\/div><\/div>\n

    As seen in the following figure, the \u201c$\u201d specifications change the order of appearance of the variables:<\/p>\n

    <\/p>\n

    <\/a>Flags in the Format Specifiers of the Printf() Function<\/h2>\n

    The flag field of a format specifier adds the following functions to the conversion:<\/p>\n

      \n
    1. Prepends the base notation of a variable<\/li>\n
    2. Prepends the sign of a variable<\/li>\n
    3. Prepends a blank space before a variable<\/li>\n<\/ol>\n

      Let\u2019s see a table of the most commonly used flags in the print() function:<\/p>\n\n\n\n\n\n\n
      Flag<\/strong><\/td>\nSyntax<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
      #<\/strong><\/td>\n“%#[type]”<\/strong><\/td>\nPrepends the base notation of the variable<\/td>\n<\/tr>\n
      +<\/td>\n“%<\/strong>+[type]”<\/strong><\/td>\nShows the sign of the variable<\/td>\n<\/tr>\n
      ‘ ‘<\/td>\n“%<\/strong>‘ ‘[type]”<\/strong><\/td>\nPrepends a blank space<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

      How to Prefix the Base Notation of a Variable with the Printf() Function in the C Language<\/h2>\n

      In this example, we convert the variable \u201ca\u201d from an integer to a hexadecimal number, and then call the printf() function twice to display it on the screen. In the first call, we omit the # <\/em><\/strong>indicator, while we insert it in the second call so that the base notation is displayed before the variable’s value.<\/p>\n

      #include <stdio.h><\/span>
      \n
      \nvoid<\/span> main (<\/span>)<\/span>{<\/span>
      \nint<\/span> a =<\/span> 2222<\/span>;<\/span>
      \nprintf<\/span><\/a> (<\/span>"Without: %x\\n<\/span>"<\/span>,<\/span> a)<\/span>;<\/span>
      \n      printf<\/span><\/a> (<\/span>"With: %#x\\n<\/span>"<\/span>,<\/span> a)<\/span>;<\/span>
      \n
      \n}<\/span><\/div><\/div>\n

      Let\u2019s see the following image that shows the execution of this code:<\/p>\n

      <\/p>\n

      <\/a>How to Print the Sign of a Variable with the Printf() Function in the C Language<\/h2>\n

      In this example, we will see how to print the sign of an integer variable. In C, the signed variables with negative values always output their sign by default, so the \u201c+\u201d specifier only affects the positive values.<\/p>\n

      In the following code, we declare the integer \u201ca\u201d and assign it the value of 12345. Then, we call the printf() function twice to print this variable. The first call does not include the \u201c+\u201d specifier, but the second call does.<\/p>\n

      #include <stdio.h><\/span>
      \n
      \nvoid<\/span> main (<\/span>)<\/span>{<\/span>
      \nint<\/span> a =<\/span> 12345<\/span>;<\/span>
      \n      printf<\/span><\/a> (<\/span>"Without +: %i\\n<\/span>"<\/span>,<\/span> a)<\/span>;<\/span>
      \n      printf<\/span><\/a> (<\/span>"With +: %+i\\n<\/span>"<\/span>,<\/span> a)<\/span>;<\/span>
      \n
      \n}<\/span><\/div><\/div>\n

      The following image shows the execution of this code:<\/p>\n

      <\/p>\n

      <\/a>Decimal Precision and Width Fields in the Printf() Function<\/h2>\n

      The precision and width fields in the format specifiers determine the precision and width of the field in which the variables are displayed. This specifier has the following two usage modes:<\/p>\n

        \n
      1. Sets the precision of the decimal part in floating point values<\/li>\n
      2. Sets the size of the field where the integer, double, long, and string variables will be displayed<\/li>\n<\/ol>\n

        For each of these specifiers that we insert into the string, an input argument \u201cn\u201d is added in the order of their occurrence of the variables, specifying the number of fields or precision digits to be displayed.<\/p>\n

        Let\u2019s see a table with the syntax of these specifiers and a description of them:<\/p>\n\n\n\n\n\n
        Specifier<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
        “%.*[type]”,n<\/strong><\/td>\nSpecifies the precision in the decimal part of a floating-point value.<\/td>\n<\/tr>\n
        “%* [type]”,n<\/strong><\/td>\nSpecifies the number of fields to display.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

        <\/a>
        \nHow to Set a Decimal Precision on a Floating Point Value with the Printf() Function<\/h2>\n

        In this example, we use the \u201c%.*\u201d formatter that we just saw to specify the decimal precision to display a floating point number. To do this, we declare the variable \u201ca\u201d of type float and give it the value of 1.22222222. Then, we use the \u201c%.*\u201d specifier to set the decimal precision of \u201ca\u201d to two digits, then to 3 and 4. Let\u2019s see the code for this example:<\/p>\n

        #include <stdio.h><\/span>
        \n
        \nvoid<\/span> main (<\/span>)<\/span>{<\/span>
        \nfloat<\/span> a =<\/span> 1.22222222<\/span>;<\/span>
        \n        printf<\/span><\/a> (<\/span>"%.*f\\n<\/span>"<\/span>,<\/span> 2<\/span>,<\/span> a)<\/span>;<\/span>
        \n        printf<\/span><\/a> (<\/span>"%.*f\\n<\/span>"<\/span>,<\/span> 3<\/span>,<\/span> a)<\/span>;<\/span>
        \n        printf<\/span><\/a> (<\/span>"%.*f\\n<\/span>"<\/span>,<\/span> 4<\/span>,<\/span> a)<\/span>;<\/span>
        \n
        \n}<\/span><\/div><\/div>\n

        As we can see, the printf() function now has three input arguments – the second is the precision indicator and the third is the variable to display. Let\u2019s see the compilation and execution of this code:<\/p>\n

        <\/p>\n

        <\/a>How to Adjust the Number of Fields to be Displayed in a Variable or String in the Printf() Function<\/h2>\n

        In this example, we will use the \u201c%*\u201d formatter to adjust the number of fields that we want to display from a variable or string. The operation of this formatter is identical to the previous one, except that its syntax does not include a period and it works with integers, double numbers, and strings.<\/p>\n

        In the following code, we will use the \u201cstr_1\u201d pointer with the \u201cHello world! Hello Linux Ways!\u201d<\/em> string and we use the incremental variable \u201ci” as an index of the number of fields in a \u201cfor\u201d loop, creating an animation in which the text is written letter by letter every 50 ms.<\/p>\n

        #include <stdio.h><\/span>
        \n#include <stdlib.h><\/span>
        \n#include <unistd.h><\/span>
        \n#include <string.h><\/span>
        \n
        \nvoid<\/span> main (<\/span>)<\/span>{<\/span>
        \nwhile<\/span> (<\/span>1<\/span>)<\/span>{<\/span>
        \nchar<\/span> *<\/span> str_2 =<\/span>"Hello world! Hello Linux Ways!!"<\/span>;<\/span>
        \nfor<\/span> (<\/span>int<\/span> i =<\/span>0<\/span>;<\/span> i!=<\/span>        strlen<\/span><\/a>(<\/span>str_2)<\/span>;<\/span>i++<\/span>)<\/span>{<\/span>
        \n        system<\/span><\/a> (<\/span>"clear"<\/span>)<\/span>;<\/span>
        \n        printf<\/span><\/a> (<\/span>"%.*s\\n<\/span>"<\/span>,<\/span> i,<\/span> str_2)<\/span>;<\/span>
        \nusleep(<\/span>50000<\/span>)<\/span>;<\/span>
        \n}<\/span>
        \nsleep(<\/span>1<\/span>)<\/span>;<\/span>
        \n}<\/span>}<\/span><\/div><\/div>\n

        Let\u2019s see an image with the execution of this code:<\/p>\n

        <\/p>\n

        <\/a>The Length Field in the Format Specifier of the Printf() Function<\/h2>\n

        Format specifiers also provide the option to convert certain types of data to integers. Let\u2019s see a table of them, their syntax, and a description of each:<\/p>\n\n\n\n\n\n\n\n\n\n\n
        Syntax<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
        \u201c%hhi\u201d<\/strong><\/td>\nConverts a char to int and prints it<\/td>\n<\/tr>\n
        \u201c%hi\u201d<\/strong><\/td>\nConverts a short int to int and prints it<\/td>\n<\/tr>\n
        \u201c%li\u201d<\/strong><\/td>\nConverts a long to int and prints it<\/td>\n<\/tr>\n
        \u201c%lli\u201d<\/strong><\/td>\nConverts a long long to int and prints it<\/td>\n<\/tr>\n
        \u201c%Li\u201d<\/strong><\/td>\nConverts a long double to int and prints it<\/td>\n<\/tr>\n
        \u201c%zi\u201d<\/strong><\/td>\nConverts a size_t to int and prints it<\/td>\n<\/tr>\n
        \u201c%ji!<\/strong><\/td>\nConverts a intmax_t or uintmax_t to int and prints it<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

        How to Convert a Data Type to Integer with the Format Specifier in the Printf() Function<\/h2>\n

        In this example, we will show you how to convert a character and a long value to an integer and display it to the command console using the width field of the printf() format specifier. For this, we declare the character \u201cc\u201d and the long l and assign them with a random value. Then, we call printf() on each of these variables, passing the “%hhi” specifier for the character and “%li” for the long. Let\u2019s see the code for this example:<\/p>\n

        #include <stdio.h><\/span>
        \n
        \nvoid<\/span> main (<\/span>)<\/span>{<\/span>
        \n
        \n  char<\/span> c =<\/span> 'C'<\/span>;<\/span>
        \n  long<\/span> l =<\/span> 1234899876<\/span>;<\/span>
        \n  printf<\/span><\/a> (<\/span>"%hhi\\n<\/span>"<\/span>,<\/span> c)<\/span>;<\/span>
        \n          printf<\/span><\/a> (<\/span>"%li\\n<\/span>"<\/span>,<\/span> l)<\/span>;<\/span>
        \n
        \n}<\/span><\/div><\/div>\n

        The following image shows the execution of this code, with the values of \u201cc\u201d and l converted to integers:<\/p>\n

        <\/p>\n

        <\/a>Conclusion<\/h2>\n

        In this Linux Ways article, we taught you all about the format specifications of the printf() family of functions so that you can harness their potential and save the lines of code by avoiding multiple calls to other functions. We explained how these functions handle their input arguments and we showed you what the syntax of a format specifier is. Then, in several sections, we explained the individual fields and showed how we can use them to specify the format and order of appearance of the variables that we want to print.<\/p>","protected":false},"excerpt":{"rendered":"

        Guide on how to specify the format in which you want to show a variable when using the printf() function, the syntax, and the method to set the output formats.<\/p>","protected":false},"author":110,"featured_media":23303,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[168],"tags":[],"class_list":["post-23270","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting"],"_links":{"self":[{"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/posts\/23270","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/users\/110"}],"replies":[{"embeddable":true,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/comments?post=23270"}],"version-history":[{"count":0,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/posts\/23270\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/media\/23303"}],"wp:attachment":[{"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/media?parent=23270"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/categories?post=23270"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/linuxways.net\/de\/wp-json\/wp\/v2\/tags?post=23270"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}