C primer plus learning notes - 3. Character IO (input / output)

getchar() and putchar()

The last chapter introduced printf and scanf Functions belong to IO function .
Here we introduce two functions getchar() and putchar() For characters IO.

explain

getchar() The function takes no arguments , If the buffer is empty , Will wait for the buffer , When you enter and press enter , The next character will be returned from the input queue .
putchar() Function to print the input parameters .
getchar() The function interprets each character as a character code , and scanf() Function looks at input in the same way as it reads characters , But he will convert the character input into the corresponding numerical value according to the conversion instructions .

give an example ： Read one line of input string

such as ：

#include <stdio.h>
int main(void)
{
    
    char ch;
    ch = getchar();           // read a character 
    putchar(ch);              // print the newline 
    return 0;
}

If I type... On the keyboard abcd agf And then go back , Then the print will be a.
because getchar() Will read a line we entered Enter enter to end , Spaces do not end .
Then he will read the next character （ That's the first one ） And assign it to ch
putchar() take ch Print out .
Look at the following procedure ：

int main(void)
{
    
    char ch;
    ch = getchar();           // read a character 
    while (ch != '\n')        // while not end of line 
    {
    
        putchar(ch);
        ch = getchar();       // get next character 
    }
    putchar(ch);              // print the \n 
    
    return 0;
}

When we type in ndn ang And then go back , prints ndn ang.
Look at the ：

1. When we enter the string, press enter , The actual input is ndn ang\n Indicates that one line of input is complete .
2. ch At this time, the first character of the input is read
3. Then judge , It's not a newline , Will print ,
4. Call again after printing getchar() It means to read the next character in the queue just entered .
5. Then judge whether it is a newline character , No more printing , By analogy .

The above code can be abbreviated , Replace cycle

int main(void)
{
    
    char ch;
      
    while ((ch = getchar()) != '\n')        // while not end of line 
    {
    
        putchar(ch);  
    }      
    return 0;
}

In the above example, we can read a line of input string with spaces .

We can also end with a specific character

while ((ch = getchar()) != '#')        // while not end of line 

So when we enter
angn asdn#dng
Will get
angn asdn

buffer

Buffered and unbuffered

In the above example, we find that , When we enter a line of string
ndn ang Only when we hit enter , The program will print . If we don't hit enter, we can always enter . This input is called Make buffered input .
So where are the input strings . The characters entered by the user are collected in a storage location called buffer .

But when we play games , We press a key , There will be an immediate response , Like release q Skill . This is called Unbuffered input . Therefore, buffered input and unbuffered input have their own application scenarios .

ANSI C And subsequent C The standard specifies that the input is buffered , But at first C The input in the standard is unbuffered .

Buffer classification

There are two types of buffers ： Completely buffered IO And line buffering IO.

1. Completely buffered ： The buffer is flushed only when it is full （ That is, send the content to the destination and empty the buffer ）. It usually appears in file input , The buffer size usually depends on the 512B or 4K.
2. The line buffer ： This means that the buffer is flushed when a line break occurs （ That is, send the content to the destination and empty the buffer ）. Keyboard entry Usually line buffered input , Press down Enter Key before refreshing the buffer .

Keyboard input Terminator

In the example above , We use carriage return to end , The other is to use ‘#’ Symbol to end the program .
These symbols are commonly used , We should not end the program with common symbols . So we should find a way to end it with a relatively unique thing ,C Such a character is provided .

file

Let's briefly introduce the concept of file , It is the area of memory where information is stored .
Programs often manipulate files , Like opening , Read , Turn off writing, etc .

Why use unification C standard IO

C The language will call the underlying IO That is, operating system functions operate on files . such as linux System function write() open() etc. .
But if windows On , Call directly write() open No way. , Need to call windows The system function of . therefore C Language encapsulates the file processing functions of different systems into C Standards for IO package . He deals with the differences between different systems , Expose unified functions to users, such as fopen(),fwrite() etc. .

Handling file differences

Different systems not only expose different file handling functions , They also deal with documents in different ways . For example, some systems store the contents of files in one place , File related information is stored in another place . Some systems create special file descriptions in each file .
Different systems also end with different files .

C How to process input

C Treat keyboard input and output as automatically opened files .stdin Represents keyboard input ,stdout Indicates output to the screen .
That is to say C Handle keyboard input by processing files .
for example , When the program reads a file, it needs to check the end of the file to know when to stop . Keyboard input is a file , When you enter what character , The program will detect and stop .

End of file

A few systems use Ctrl+Z. such as ngnag ^Z, The system reads Ctrl+Z ends .
Other systems store file size information , If the document has 300 byte , Then the program is finished 300 Bytes later, it will stop . such as Unix System .

getchar() When the end of the file is detected, a EOF. He -1 The macro definition of , stay stdio.h In file .
#define EOF (-1)
because getchar() Itself returns the next character read ,-1 As he reads the Terminator .

int main(void)
{
    
    int ch;
      
    while ((ch = getchar()) != EOF)        // while not end of line 
    {
    
        putchar(ch);  
    }      
    return 0;
}

because EOF yes -1 So the variable ch To be changed to int, and getchar() The actual return type is also int.
The above example , Let's enter a line , Press enter , Will flush the buffer . Program getchar() It will read in the input line in turn and print .
Continue to wait for input after printing .
In most Unix and Linux The system will use Ctrl+D As input Terminator .

asdn aslkd
asdn aslkd
aghn
aghn

Redirect

Redirection is a command line concept , instead of C Concepts in programs .
We said earlier stdin It's the input stream , We use keyboard input as input and stdin The input stream is associated with .
We can also use the contents of the file as stdin Input stream , such getchar() Functions can also use .
The program doesn't care whether the input comes from the keyboard or from a file , All he knows is that this is the character stream to be imported

Redirect input :

We can use programs to read files 1.txt
./echo_eof < 1.txt

int main(void)
{
    
    int ch;
      
    while ((ch = getchar()) != EOF)        // while not end of line 
    {
    
        putchar(ch);  
    }      
    return 0;
}

Because there will be a terminator at the end of the file , So the program can read the end symbol and then end .

Redirect output

./echo_eof > 1.txt He will output the program to 1.txt In file

Combined redirection

For example, I read a file , Enter the program , Then the program input to another file
./echo_eof < in.txt > out.txt
./echo_eof > out.txt < in.txt
The above two sentences are the same , Because redirection symbols have no order .