file function --> include <stdio.h> for c, <cstdio> for cpp    
    FILE* fopen (const char* fileName, const char* fileMode)

        FILE *(NAME) = fopen(("file name"),(mode))
            mode -> r, w, a, r+, w+, a+ 
                r: read mode
                w: write mode
                a: append mode
                r+ read, write, if no file = error
                w+ read, write, if no file = make file
                a+ read, write, if no file = make file
    fclose(const char* fileName)
    
    int fputc(int c, FILE *stream); 
        save one letter into steram, if save success -> return c, if not -> return EOF

    int fgetc(FILE *stream);  
        read one letter from pointed steram, if read success -> 
        return letter, if not(reached to the EOF) -> return EOF
    
            ex)

            while(EOF != (ch = fgetc(ptr_file))) 
            {
                fputc(ch, stdout);
            }
    
    char *fgets(char * restrict s, int n, FILE * restrict stream)
        
        This function reads a string from the specified stream.

        The first argument of this function is the address where the read string will be stored, 
            and the third argument is a pointer to a FILE structure variable to determine the stream.

        Reads one or fewer characters than the maximum number of input characters 
            passed in as the second argument, or until the end of the file is reached.

        This function returns the address where the read string is stored 
            if the read is successful, and NULL if the end of the file is reached or the read fails.

    int fputs(const char * restrict s, FILE * restrict stream);  
        
        This is a function that prints (saves) a string to the specified stream.
        
        The first argument of this function is the address of the string to be written, 
            and the second argument is a pointer to a FILE structure variable to determine the stream.

        If the stream passed as an argument is stdout, it prints a string to the monitor, 
            and if it is a file, it saves the string to the file.

        This function returns a non-negative value if the write (save) is successful, 
            and EOF if the save fails.

            ex) 
                int main(void)
            {
                char str[100];

                FILE* ptr_src = fopen("text_readonly.txt", "r");
                FILE* ptr_dst = fopen("text_writeonly.txt", "w");

                while(fgets(str, 100, ptr_src) != NULL) // NULL -> stdlib
                {
                    fputs(str, ptr_dst);                
                }

                return 0;
            }  

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

        This function reads a string from the specified stream 
            using various format conversion characters.

        The second argument is the format of the string to be read.

        This function returns the number of variables read 
            if the read is successful, and EOF if the read fails.

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

        This is a function that prints (saves) a string 
            using various format conversion characters in the specified stream.

        The first argument of this function is a pointer to a FILE structure variable to determine the stream, 
            and the second argument is the format of the string to be output.

        This function returns the size of the saved string in bytes 
            if the write (save) is successful, and a negative number if it fails.
        

            ex)
            #include <stdio.h>
            #include <stdlib.h>

            int main(void)
            {
                int scan_num, int_num;
                double double_num;
                char str[100];

                FILE* ptr_file = fopen("text_fscanf.txt", "r");

                while(scan_num = (fscanf(ptr_file, "%d %lf %s", &int_num, &double_num, str)) != EOF)
                {         
                    fprintf(stdout, "%d %f %s\n", int_num, double_num, str);
                }
                return 0;
            }

feof((NAME)): check whether file pointer is the end of the file

sscanf
    int sscanf (const char * buffer ,const char *format,...);  
        Function to read by specifying the format from the buffer
    
    ex)
    
    #pragma warning(disable:4996) // warning about not recommended function use
    #include <stdio.h>
    
    int main (void)
    {
        char buffer[256]="name:Kildong Hong num:12 age:20";
        char name[30];
        int num;
        int age;
    
        //Set the contents of the buffer to the name, number, and age variables
        sscanf(buffer,"name:%s num:%d age:%d",name,&num,&age);
        //Print name, number, and age
        printf("Name:%s Number:%d Age:%d \n",name,num,age);
        return 0;
    }
    return : 
    Name:kildong hong Number:12 Age:20
    
    //*int -> &, char -> none

strtok: string truncation
    char* strtok(char* str, char* delimiters);
    <string.h> for c, <cstring> for cpp

    *strtok scans the target string from left to right. Whenever it finds a delimiter, 
    it replaces the delimiter with a "null" termination character and returns the extracted token. 

    ex)
    #include<stdio.h>
    #include<string.h>    //C++ : <cstring>
    
    int main(void)
    {
        char str[] = "Kim,Park,Lee,Choi,Seo";
    
        char *ptr = strtok(str, ",");    
    
        while (ptr != NULL)
        {
            printf("%s\n", ptr);        
            ptr = strtok(NULL, ",");
        }
    
        return 0;
    }
 
    return:

    Kim
    Park
    Lee
    Choi
    Seo

    "\t":  refers to one tab horizontal space