1. File reading and writing
A file, whether it is a text file or a binary file, represents a series of bytes. The C language not only provides functions that access the top level, but also provides underlying (OS) calls to process files on storage devices.
1.1 Open the file
We can usefopen( ) Functions to create a new file or open an existing file. This call will initialize an object of type FILE, which contains all the necessary information used to control the flow.
Here is the prototype of this function call:
FILE *fopen( const char * filename, const char * mode );
Here,filename is a string used to name files and access modemode The value of the value can be one of the following:
| model | describe |
|---|---|
| r | Open an existing text file to allow reading of the file. |
| w | Open a text file that allows writing to the file. If the file does not exist, a new file is created. Here, your program will write content from the beginning of the file. |
| a | Open a text file and write to the file in append mode. If the file does not exist, a new file is created. Here, your program will add content to the existing file content. |
| r+ | Open a text file that allows reading and writing of the file. |
| w+ | Open a text file that allows reading and writing of the file. If the file already exists, the file is truncated to zero length, and if the file does not exist, a new file is created. |
| a+ | Open a text file that allows reading and writing of the file. If the file does not exist, a new file is created. Reading starts from the beginning of the file, while writing can only be in append mode. |
If you are processing a binary file, you need to use the following access mode to replace the above access mode:
"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"
1.2 Close the file
To close the file, usefclose( ) letterNumber.
The prototype of the function is as follows:
int fclose( FILE *fp );
If the file is successfully closed,fclose( ) The function returns zero, and if an error occurs when closing the file, the function returns EOF. This function actually clears the data in the buffer, closes the file, and frees all memory used for the file. EOF is a defined file in the headerconstants in.
The C standard library provides various functions to read and write files by characters or as fixed-length strings.
1.3 Read the file
Here is the simplest function to read a single character from a file:
int fgetc( FILE * fp );
fgetc() The function reads a character from the input file pointed to by fp. The return value is a read character, and if an error occurs, it returns EOF. The following function allows you to read a string from a stream:
char *fgets( char *buf, int n, FILE *fp );
functionfgets()Read n - 1 characters from the input stream pointed to by fp. It copies the read string to the buffer buf and appends a null character to the end to terminate the string.
If this function encounters a newline '\n' or the end of the file EOF before reading the last character, only the read characters, including the newline. You can also useint fscanf(FILE *fp, const char *format, ...) The function to read a string from a file, but it stops reading when the first space character is encountered.
Example:
#define _CRT_SECURE_NO_WARNINGS
#include <>
#include <>
#include <>
//Read text filevoid main() {
char path[] = "C:\Users\Administrator\Desktop\"; //The sentence in the text is hello world
//Open FILE *fp = fopen(path, "r");
if (fp == NULL)
{
printf("File opening failed...");
return;
}
//Read char buff[50];//buffer while (fgets(buff,50,fp)) {
printf("%s", buff);
}
//closure fclose(fp);
getchar();
}
Results output:
hello world
1.4 Write to the file
Here is the simplest function to write characters into a stream:
int fputc( int c, FILE *fp );
functionfputc() Writes the character value of parameter c to the output stream pointed to by fp. If the write is successful, it returns the written character, and if an error occurs, it returns EOF.
We can use the following function to write a string ending in null to the stream:
int fputs( const char *s, FILE *fp );
The function fputs() writes the string s to the output stream pointed to by fp. If the write is successful, it returns a non-negative value, and if an error occurs, it returns EOF. You can also useint fprintf(FILE *fp,const char *format, ...) Function to write a string to the file.
Try the following example:
//Write to text filevoid main() {
char *path = "C:\Users\Administrator\Desktop\";
//Open FILE *fp = fopen(path, "w");
char *text = "The weather is good today\nGo out and have fun!";
fputs(text,fp);
//closure fclose(fp);
getchar();
}
Output in test text:
The weather is good today
Go out and have fun!
Notice:Make sure you have an available /tmp directory, which you need to create on your computer if it does not exist.
1.5 Read and write binary I/O files
Computer files are physically stored in binary. The difference between text files and binary is actually a human-made logical distinction.
The difference between C reading and writing text files and binary files is only reflected in carriage return line breaks:
- 1. When writing text, every time you encounter '\n', it will be converted to '\r\n' (carriage-return and line-win).
- 2. When reading text, every time you encounter '\r\n', it will be converted to '\n'.
- 3. However, the above conversion will not be done when reading and writing binary files.
Function prototype：
size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );
in:
-
ptr: Pointer to save the result; -
size: The size of each data type; -
count: The number of data; -
stream: File pointer
The function returns the number of data read.
size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );
where, ptr: pointer to the data being saved; size: size of each data type; count: number of data; stream: file pointer
The function returns the number of data written.
Here are examples of reading and writing binary files (copying images):
void main() {
char *read_path = "D:\BaiduNetdiskDownload\ndk\2016_08_08_C_Consortium_Enum_IO\files\";
char *write_path = "D:\BaiduNetdiskDownload\ndk\2016_08_08_C_Union_Enum_IO\files\girl_new.png";
//The b character indicates the operation binary file binary FILE *read_fp = fopen(read_path, "rb");
//The file written FILE *write_fp = fopen(write_path,"wb");
//copy int buff[50]; //Buffer area int len = 0;//The length of data read each time while ((len = fread(buff,sizeof(int), 50,read_fp))!=0) {//50 is a relatively large number written //Write the read content to a new file fwrite(buff, sizeof(int), len, write_fp);
}
fclose(read_fp);
fclose(write_fp);
getchar();
}
1.6 Get the file size
void main() {
char *read_path = "D:\BaiduNetdiskDownload\ndk\2016_08_08_C_Consortium_Enum_IO\files\";
FILE *fp = fopen(read_path, "r");
//Relocate the file pointer //The end of SEEK_END file, 0 offset fseek(fp, 0, SEEK_END);
//Return the current file pointer, the displacement relative to the beginning of the file long filesize = ftell(fp);
printf("%d\n", filesize);
getchar();
}
1.7 Simple text encryption and decryption
void crypt(char normal_path[], char crypt_path[]) {
//Open the file FILE *normal_fp = fopen(normal_path, "r");
FILE *crypt_fp = fopen(crypt_path, "w");
//Read one character at a time int ch;
while ((ch = fgetc(normal_fp)) != EOF) { //End of File
//Write (XOR operation) fputc(ch ^ 9, crypt_fp);
}
// closure fclose(crypt_fp);
fclose(normal_fp);
}
//Decryptionvoid decrypt(char crypt_path[],char decrypt_path[]) {
//Open the file FILE *normal_fp = fopen(crypt_path,"r");
FILE *crypt_fp = fopen(decrypt_path, "w");
//Read one character at a time int ch;
while ((ch = fgetc(normal_fp)) !=EOF)//End of File
{
//Write (XOR operation) fputc(ch ^ 9, crypt_fp);
}
//closure fclose(crypt_fp);
fclose(normal_fp);
}
void main() {
char *normal_path = "D:\";
char *crypt_path = "D:\userinfo_crypt.txt";
char *decrypt_path = "D:\userinfo_decrypt.txt";
//Encrypt the file crypt(normal_path, crypt_path);
//Decrypt the file decrypt(crypt_path, decrypt_path);
getchar();
}
1.8 Simple encryption and decryption of binary files
void crypt(char normal_path[], char crypt_path[], char password[]) {
//Open the file FILE *normal_fp = fopen(normal_path, "rb");
FILE *crypt_fp = fopen(crypt_path, "wb");
//Read one character at a time int ch;
int i = 0; //Cycling the letters in the password for XOR operation int pwd_len = strlen(password); //The length of the password while ((ch = fgetc(normal_fp)) != EOF) { //End of File
//Write (XOR operation) fputc(ch ^ password[i % pwd_len], crypt_fp);
i++;
}
//closure fclose(crypt_fp);
fclose(normal_fp);
}
//Decryptionvoid decrypt(char crypt_path[], char decrypt_path[], char password[]) {
//Open the file FILE *normal_fp = fopen(crypt_path, "rb");
FILE *crypt_fp = fopen(decrypt_path, "wb");
//Read one character at a time int ch;
int i = 0; //Cycling the letters in the password for XOR operation int pwd_len = strlen(password); //The length of the password while ((ch = fgetc(normal_fp)) != EOF) { //End of File
//Write (XOR operation) fputc(ch ^ password[i % pwd_len], crypt_fp);
i++;
}
//closure fclose(crypt_fp);
fclose(normal_fp);
}
void main() {
char *normal_path = "D:\";
char *crypt_path = "D:\girl_crypt.png";
char *decrypt_path = "D:\girl_decrypt.png";
//Encrypt the file crypt(normal_path, crypt_path, "123456");
//Encrypt the file decrypt(crypt_path, decrypt_path, "123456");
getchar();
}
Generally, the key user data of large companies such as Tencent and Alibaba are encrypted in C\C++ (dynamic library so is difficult to decompile). Because Java's encryption method is easier to crack.
This is the end of this article about Android NDK development (C language - file reading and writing). For more related C language - file reading and writing content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!