What is a buffer in C?

A buffer is an area of memory set aside for the temporary storage of data. A data buffer (or just buffer) is a region of a physical memory storage used to temporarily store data while moving from one place to another. It's mainly used to store various input and output commands. which get buffered in the operating system. For instance, in the case of standard input, when we hit a key on the keyboard, the operating system sends the data to the buffer rather than sending it to your program until the time given to that program has passed.

Examples of when a buffer is used in C (and other programming languages)

• Reading a file's contents before processing the data (such as parsing records, etc.).
• Preserving user input while awaiting more.

The C language is not required to use the phrase. It is often an array type in C. The term "buffer" implies that the information held there is somehow temporary. It is employed when there is any uncertainty regarding the quantity or pace of arrival of the data that will be stored there. The arrival of the data is "buffered" until it may be withdrawn or used by a separate section of the code from the procedure that filled the buffer.

A typical illustration of such a situation would be while reading data one line at a time from standard input or a file.

A discrete function reads information into the buffer without already knowing how long a line is. Once the data line has been read, other sections of the code can transfer it or use it in various ways. There is a chance that the buffer could be overfilled or that there could be a buffer overflow because it is difficult to predict what size of data would fill it. Defensive programming avoids this scenario.

In computers, buffers are utilized in various contexts, particularly when 'real world' data needs to be presented to an OS or running application, such as when reading from a disc, a network, or other hardware. There isn't a single array type or another data structure that is a buffer by default. The term simply describes how the memory is intended to be used.

Example

Let's say you wish to assign a string to a variable called String. When you type a string from your keyboard, it is not immediately put in the string variable because if it were, you wouldn't be able to store the entire string. If data were stored directly into the variable, then if you wanted to store the string "ABCDEF," first when you would press 'A' from the keyboard, it would be stored in the variable first. When you would press the next character, 'B', the 'A' that was previously stored would be overwritten with the new character 'B', and this 'B' would be stored. This is because whatever you enter from your keyboard comes from a stream of data.

The most frequent usage of C is this. Although it can be of any type, including void * (please note that you cannot dereference the void pointer directly; you must cast it to a different kind to access the contents of the buffer), a buffer is typically declared as an array of char or uint 8.

The term "buffering" may also be used in reference to the common IO streams library. Input/Output buffering is one of the tasks that the Standard IO Library (stdio.h) performs. This means that the stdio library intervenes and buffers file reading and writing processes.

Program to demonstrate buffer in C

Example 1

#include<stdio.h>
#include<conio.h>
void main()
{
 int value1,value2;
 printf("Enter Value 1: ");
 scanf("%d",&value1);
 printf("\n");
 printf("Enter Value 2: ");  
 scanf("%d",&value2);
 printf("\n");
 printf("value1*value2=%d \n ",value1*value2);
 getch();
}

Output 1

Explanation: Here, two buffers are in action: one is the Keyboard buffer, and another is the C standard buffer (input buffer). The characters are stored in the keyboard buffer when you press the keyboard buttons. So, when you type value1, then it is simply stored at the keyboard buffer. Pressing Enter key will go to C standard buffer with one more character \n (generated on pressing Enter key).

Now, let’s give the input in other way:

Output 2

Explanation: Here, user is not pressing any enter key, as a result, the buffer won't be cleared, and value 2 automatically takes from the previous run by the buffer.

Let’s look at another example now.

Example 2

Program 1

#include<stdio.h>
#include<conio.h>
void main()
{
 int integer;
 char character;
 printf("Enter a character : ");  
 scanf("%c",&character);
  printf("Enter an integer : ");
 scanf("%d",&integer);
 printf("\n");
 printf("Integer is :%d\n",integer);
 printf("Character is :%c\n",character);
 getch();
}

Output

Program 2

#include<stdio.h>
#include<conio.h>
void main()
{
 int integer;
 char character;
 printf("Enter an integer : ");
 scanf("%d",&integer);
 printf("Enter a character : ");  
 scanf("%c",&character);
 printf("\n");
 printf("Integer is :%d\n",integer);
 printf("Character is :%c\n",character);
 getch();
}

Output

Explanation: Here, the user gave an integer value as the first input. As soon as they pressed the enter key, an empty space occupied the memory of that character variable (because we didn't clear the buffer). As a result, the program skips the following input of the container/variable.

The difference between program 1 and program 2 is that, in program 1, since empty space is a character, the compiler waits for only an integer to give as input (as the input type is an integer). But in program 2, since empty space is a character. As a result, nothing gets printed.

These problems from both examples 1 and 2 can be solved by clearing the buffer in C.

How to clear the buffer in C?

In order to avoid such circumstances, fflush(stdin) can be used to clear the buffer. Now, if we execute the code with same input as above, the result would be different.

Programs to clear buffer in C

Example 1:

#include<stdio.h>
#include<conio.h>
int main()
{	
  int value1,value2;
  printf("Enter Value 1: ");
  scanf("%d",&value1);
  fflush(stdin);
  printf("\n");
  printf("Enter Value 2: ");
  scanf("%d",&value2);
  printf("\n");
  printf("value1*value2=%d \n ",value1*value2);
  getch();
  return 0;
} 

Output

Example 2:

#include<stdio.h>
#include<conio.h>
int main()
{
 int integer;
 char character;
 printf("Enter an integer : ");
 scanf("%d",&integer);
 fflush(stdin);
 printf("Enter a character : ");  
 scanf("%c",&character);
 printf("\n");
 printf("Integer is :%d\n",integer);
 printf("Character is :%c\n",character);
 getch();
 return 0;
}

Output