What are the printf functions for C?

> gcc -Wall -Wextra -O2 program.c -o program
> ./program
> ```


---

In general, printf** **()** ** is a library function under C header file *stdio.h* and *conio.h* both. And generally, it is used for displaying an outcome of a program to outside world. **Printf()** function is often used to our program to do formatted output. All variants of printf function use same formatting techniques. There is a string that specifies the layouts of output is call format specifier. i.e. %s, %d, %f, %c, %x, %u etc.

This function uses first format specifier for the first argument, second format specifier for the second argument and so on. There must be enough arguments for each format specifier otherwise, the result will be unpredictable due to less argument. And excess arguments are merely ignored. Format specifier determines how and what kind of data types will print to screen. There are various format specifiers you can use, these are:

 	
- *%c   ->char single character*
 	
- *%d (%i) ->int signed integer*
 	
- *%e (%E) ->float or double exponential format*
 	
- *%f ->float or double signed decimal*
 	
- *%g (%G) ->float or double use %f or %e as required*
 	
- *%o ->int unsigned octal value*
 	
- *%p ->pointer address stored in pointer*
 	
- *%s ->array of char sequence of characters*
 	
- *%u ->int unsigned decimal*
 	
- *%x (%X) ->int unsigned hex value*

In turbo C  there are seven variants of printf function to do the different specific job. These are:

 	
- printf*()   -> sends formatted output to a standard output device*
 	
- cprintf*() -> sends formatted output to a text window on the screen*
 	
- sprintf*() -> sends formatted output to a string (sends to an array in memory)*
 	
- fprintf*() -> sends formatted output to a File stream*
 	
- vprintf*() -> sends formatted output to stdin using an argument list*
 	
- vfprintf*()->sends formatted output to a File using an argument list*
 	
- vsprintf*()->sends formatted output to a string using an argument list*

## Here prefix of printf f,s,v,c stands for:

 	
- *f -> means it takes a FILE* param to write to.*
 	
- *s -> means it writes to a string buffer.*
 	
- *v ->means it takes all the value args as a single vector (array).*
 	
- *c ->means it write to the console (Text window on the screen)*

## Function and its argument table by turbo C

<table style="height: 634px;" width="588">
<tbody>
<tr>
<td width="202">**Argument**</td>
<td width="202">**Functions**</td>
<td width="202">**What Argument Is/Does**</td>
</tr>
<tr>
<td width="202">arglist</td>
<td width="202">vprintf</td>
<td width="202">Pointer to a list of arguments</td>
</tr>
<tr>
<td width="202">argument</td>
<td width="202">cprintf,

fprintf,

printf,

sprintf</td>
<td width="202">One of a series of arguments to which the functions apply a format specifier contained in *format</td>
</tr>
<tr>
<td width="202">buffer</td>
<td width="202">sprintf,

vsprintf</td>
<td width="202">Buffer where function writes the string</td>
</tr>
<tr>
<td width="202">format</td>
<td width="202">(all) printf variant</td>
<td width="202">Format string</td>
</tr>
<tr>
<td width="202">stream</td>
<td width="202">fprintf,

vfprintf</td>
<td width="202">Stream where the functions output the formatted data</td>
</tr>
</tbody>
</table>
 

## More details about specifier, flags, width, precision used with printf varrient:

<table class="boxed">
<tbody>
<tr>
<th>

#### specifier

</th>
<th>

#### Output

</th>
<th>

#### Example

</th>
</tr>
<tr>
<td><tt>d</tt> *or* <tt>i</tt></td>
<td>Signed decimal integer</td>
<td><tt>392</tt></td>
</tr>
<tr>
<td><tt>u</tt></td>
<td>Unsigned decimal integer</td>
<td><tt>7235</tt></td>
</tr>
<tr>
<td><tt>o</tt></td>
<td>Unsigned octal</td>
<td><tt>610</tt></td>
</tr>
<tr>
<td><tt>x</tt></td>
<td>Unsigned hexadecimal integer</td>
<td><tt>7fa</tt></td>
</tr>
<tr>
<td><tt>X</tt></td>
<td>Unsigned hexadecimal integer (uppercase)</td>
<td><tt>7FA</tt></td>
</tr>
<tr>
<td><tt>f</tt></td>
<td>Decimal floating point, lowercase</td>
<td><tt>392.65</tt></td>
</tr>
<tr class="cpp11">
<td><tt>F</tt></td>
<td>Decimal floating point, uppercase</td>
<td><tt>392.65</tt></td>
</tr>
<tr>
<td><tt>e</tt></td>
<td>Scientific notation (mantissa/exponent), lowercase</td>
<td><tt>3.9265e+2</tt></td>
</tr>
<tr>
<td><tt>E</tt></td>
<td>Scientific notation (mantissa/exponent), uppercase</td>
<td><tt>3.9265E+2</tt></td>
</tr>
<tr>
<td><tt>g</tt></td>
<td>Use the shortest representation: <tt>%e</tt> or <tt>%f</tt></td>
<td><tt>392.65</tt></td>
</tr>
<tr>
<td><tt>G</tt></td>
<td>Use the shortest representation: <tt>%E</tt> or <tt>%F</tt></td>
<td><tt>392.65</tt></td>
</tr>
<tr class="cpp11">
<td><tt>a</tt></td>
<td>Hexadecimal floating point, lowercase</td>
<td><tt>-0xc.90fep-2</tt></td>
</tr>
<tr class="cpp11">
<td><tt>A</tt></td>
<td>Hexadecimal floating point, uppercase</td>
<td><tt>-0XC.90FEP-2</tt></td>
</tr>
<tr>
<td><tt>c</tt></td>
<td>Character</td>
<td><tt>a</tt></td>
</tr>
<tr>
<td><tt>s</tt></td>
<td>String of characters</td>
<td><tt>sample</tt></td>
</tr>
<tr>
<td><tt>p</tt></td>
<td>Pointer address</td>
<td><tt>b8000000</tt></td>
</tr>
<tr>
<td><tt>n</tt></td>
<td>Nothing printed.
The corresponding argument must be a pointer to a <tt>signed int</tt>.
The number of characters written so far is stored in the pointed location.</td>
<td></td>
</tr>
<tr>
<td><tt>%</tt></td>
<td>A <tt>%</tt> followed by another <tt>%</tt> character will write a single <tt>%</tt> to the stream.</td>
<td><tt>%</tt></td>
</tr>
</tbody>
</table>
The *format specifier* can also contain sub-specifiers: *flags*, *width*, *.precision* and *modifiers* (in that order), which are optional and follow these specifications:
<table class="boxed">
<tbody>
<tr>
<th>

#### flags

</th>
<th>

#### description

</th>
</tr>
<tr>
<td><tt>-</tt></td>
<td>Left-justify within the given field width; Right justification is the default (see *width* sub-specifier).</td>
</tr>
<tr>
<td><tt>+</tt></td>
<td>Forces to preceded the result with a plus or minus sign (<tt>+</tt> or <tt>-</tt>) even for positive numbers. By default, only negative numbers are preceded with a <tt>-</tt> sign.</td>
</tr>
<tr>
<td>*(space)*</td>
<td>If no sign is going to be written, a blank space is inserted before the value.</td>
</tr>
<tr>
<td><tt>#</tt></td>
<td>Used with <tt>o</tt>, <tt>x</tt> or <tt>X</tt> specifiers the value is preceded with <tt>0</tt>, <tt>0x</tt> or <tt>0X</tt> respectively for values different than zero.
Used with <tt>a</tt>, <tt>A</tt>, <tt>e</tt>, <tt>E</tt>, <tt>f</tt>, <tt>F</tt>, <tt>g</tt> or <tt>G</tt> it forces the written output to contain a decimal point even if no more digits follow. By default, if no digits follow, no decimal point is written.</td>
</tr>
<tr>
<td><tt>0</tt></td>
<td>Left-pads the number with zeroes (<tt>0</tt>) instead of spaces when padding is specified.</td>
</tr>
</tbody>
</table>
 
<table class="boxed">
<tbody>
<tr>
<th>

#### width

</th>
<th>

#### description

</th>
</tr>
<tr>
<td>*(number)*</td>
<td>The minimum number of characters to be printed. If the value to be printed is shorter than this number, the result is padded with blank spaces. The value is not truncated even if the result is larger.</td>
</tr>
<tr>
<td><tt>*</tt></td>
<td>The *width* is not specified in the *format* string, but as an additional integer, value argument preceding the argument that has to be formatted.</td>
</tr>
</tbody>
</table>
 
<table class="boxed">
<tbody>
<tr>
<th>

#### .precision

</th>
<th>

#### description

</th>
</tr>
<tr>
<td><tt>.</tt>*number*</td>
<td>For integer specifiers (<tt>d</tt>, <tt>i</tt>, <tt>o</tt>, <tt>u</tt>, <tt>x</tt>, <tt>X</tt>): *precision* specifies the minimum number of digits to be written. If the value to be written is shorter than this number, the result is padded with leading zeros. The value is not truncated even if the result is longer. A *precision* of <tt>0</tt> means that no character is written for the value <tt>0</tt>.
For <tt>a</tt>, <tt>A</tt>, <tt>e</tt>, <tt>E</tt>, <tt>f</tt> and <tt>F</tt> specifiers: this is the number of digits to be printed **after** the decimal point (by default, this is 6).
For <tt>g</tt> and <tt>G</tt> specifiers: This is the maximum number of significant digits to be printed.
For <tt>s</tt>: this is the maximum number of characters to be printed. By default, all characters are printed until the ending null character is encountered.
If the period is specified without an explicit value for *precision*, <tt>0</tt> is assumed.</td>
</tr>
<tr>
<td><tt>.*</tt></td>
<td>The *precision* is not specified in the *format* string, but as an additional integer, value argument preceding the argument that has to be formatted.</td>
</tr>
</tbody>
</table>

## Now we move on each example of printf variant:

## printf**():**

Print formatted data to stdout device. It's writing the C string pointed by format to the standard output (stdout). If format includes format specifiers (subsequences beginning with %), the additional arguments following format are formatted and inserted in the resulting string replacing their respective specifiers.

### Prototype of printf:

### parameters:

[*Format*](#jump1)

Format specifier prototype for printf function:

*%[[flags](#jump2)][[width](#jump3)][.[precision](#jump4)][length][specifier](#jump1)*

### Return Value:

Returns number of written character if successful otherwise, return a negative value.

### Program #1

Output

### program #2

Output:

Here we change the format specifier %d to %4d, as a result, you will see the alignment will change.

### program #3

Output:

The value of total is = 1511
The value of total is = 0235
The value of total is = 0012

#include<stdio.h>
#include<conio.h>
 
void main()
{

   int total1=1511,total2=235, total3=12 total4=25;

//Specify exact number of format specifier in respect of argument//
   printf("The value of total1 is = %d,\n total2 is =%d,\n total3 is =%d \n",total1,total2,total3,total5);
  

// Wait for a keypress //
   getch();
   
}

The value of total is = 1511
The value of total is = 235
The value of total is = 12

int cprintf(const char *format[, argument, ...]);

#include <conio.h>

int main(void)
{
 /* clear the screen */
 clrscr();

 /* create a text window */
 window(10, 10, 80, 25);

 /* output some text in the window */
 cprintf("Hello TechNHIT\r\n");

 /* wait for a key */
 getch();
 return 0;
}

#include <conio.h>

int main(void)
{

 window(10,10,40,11);

 textcolor(RED);

 textbackground(WHITE);

 cprintf("This is a test Program\r\n");

 getch();

 return 0;
}

#include<stdio.h>
#include<conio.h>
 
main()
{
   window(10,10,40,11);

   textcolor(YELLOW+BLINK);

   cprintf("Hello TechNhit");
 
   getch();
   return 0;
}

int sprintf ( char * str, const char * format, ... );

#include <stdio.h>
int main(void)
{
 char buffer[80];
 //here we declare some variable with value
 char user[10]={"Mondal"};
 clrscr();
 // sprintf dose not print to screen its sets formatted output to an array
 sprintf(buffer, "Hey Hello %s\n", user);
 // prints an array to screen
 puts(buffer);
 strcpy(user,"Paul");
 sprintf(buffer, "Hey Hello %s\n", user);
 puts(buffer);
 strcpy(user,"Bannerjee");
 sprintf(buffer, "Hey Hello %s\n", user);
 puts(buffer);
 getch();
 return 0;
}

int fprintf ( FILE * stream, const char * format, ... );

#include <stdio.h>

int main(void)
{
 FILE *stream;
 int i = 100;
 char c = 'C';
 float f = 1.234;

 /* open a file for update w+ (Write Mode) */
 stream = fopen("DUMMY.FIL", "w+");

 /* write some data to the file */
 fprintf(stream, "%d %c %f", i, c, f);

 /* close the file */
 fclose(stream);
 return 0;
}

int vprintf ( const char * format, va_list arg );

/* vprintf example */
#include <stdio.h>
#include <stdarg.h>

void WriteFormattedOutput ( const char * format, ... )
{
 va_list args;
 va_start (args, format);
 vprintf (format, args);
 va_end (args);
}

int main ()
{
 WriteFormattedOutput ("Call with %d variable argument.\n",1);
 WriteFormattedOutput ("Call with %d variable %s.\n",2,"arguments");

 return 0;
}

int vsprintf (char * str, const char * format, va_list arg );

#include <stdio.h>
#include <stdarg.h>

void PrintFError ( const char * format, ... )
{
 char buffer[256];
 va_list args;
 va_start (args, format);
 vsprintf (buffer,format, args);
 perror (buffer);
 va_end (args);
}

int main ()
{
 FILE * pFile;
 char szFileName[]="myfile.txt";

 pFile = fopen (szFileName,"r");
 if (pFile == NULL)
 PrintFError ("Error opening '%s'",szFileName);
 else
 {
 
 fclose (pFile);
 }
 return 0;
}