Printf() Formatting Specifiers in C Language – LinuxWays

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’s see the prototype of printf():

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.

The format identifiers can be contained in explicit or implicit strings and must always begin with the symbol “%” and end with the letter that specifies the conversion type. Below we see the syntax of a format specifier:

The arguments enclosed in square brackets are optional and, as we will see later, specify the precision, field size, etc.

The most common way to establish a conversion format is to specify the type letter preceded by the “%” symbol. Let’s see a table with the letter of type, the syntax used, and a short description for each:

How to Specify the Conversion Format in the Printf() Function

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:

The flag field of a format specifier adds the following functions to the conversion:

1. Prepends the base notation of a variable
2. Prepends the sign of a variable
3. Prepends a blank space before a variable

Let’s see a table of the most commonly used flags in the print() function:

How to Prefix the Base Notation of a Variable with the Printf() Function in the C Language

In this example, we convert the variable “a” 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 # indicator, while we insert it in the second call so that the base notation is displayed before the variable’s value.

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 “+” specifier only affects the positive values.

In the following code, we declare the integer “a” 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 “+” specifier, but the second call does.

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:

1. Sets the precision of the decimal part in floating point values
2. Sets the size of the field where the integer, double, long, and string variables will be displayed

For each of these specifiers that we insert into the string, an input argument “n” is added in the order of their occurrence of the variables, specifying the number of fields or precision digits to be displayed.

Let’s see a table with the syntax of these specifiers and a description of them:

In this example, we use the “%.*” formatter that we just saw to specify the decimal precision to display a floating point number. To do this, we declare the variable “a” of type float and give it the value of 1.22222222. Then, we use the “%.*” specifier to set the decimal precision of “a” to two digits, then to 3 and 4. Let’s see the code for this example:

In this example, we will use the “%*” 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.

In the following code, we will use the “str_1” pointer with the “Hello world! Hello Linux Ways!” string and we use the incremental variable “i” as an index of the number of fields in a “for” loop, creating an animation in which the text is written letter by letter every 50 ms.

Format specifiers also provide the option to convert certain types of data to integers. Let’s see a table of them, their syntax, and a description of each:

How to Convert a Data Type to Integer with the Format Specifier in the Printf() Function

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 “c” 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’s see the code for this example:

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.