Tout d'abord, le document donne un aperçu
1.1 Le concept de fichier
Fichier est généralement sur un disque ou un lecteur à état solide pour une zone de stockage nommé. C les documents en tant que série d'octets successifs, chaque octet peut être lu individuellement. C propose deux modes de fichiers: le mode texte et en mode binaire.
Mode 1.2 texte et le mode binaire
1.2.1 texte et contenu binaire
Le contenu de tous les fichiers sont sous forme binaire (0 ou 1) de stockage. Cependant, si le fichier était à l'origine le caractère codé en binaire (par exemple, ASCll ou Unicode) texte représentant, le fichier est un fichier texte qui contient le contenu du texte, si le fichier en binaire représente le code de langage machine ou des données numériques ou d'images ou de codage de la musique, la fichier est un fichier binaire qui contient le contenu binaire.
1.2.2 en mode texte et en mode binaire
Afin de normaliser le traitement, langage C permet d'accéder deux fichiers texte en fichiers Drang: mode binaire et texte. En mode binaire, le programme peut accéder à chaque octet du fichier, en mode texte, le contenu réel du contenu du programme et du document vu pas la même chose.
Programme pour lire des fichiers d'écriture en mode texte, la fin de la ligne ou la fin du fichier dans l'environnement local représenté par la carte au mode C. Par exemple, le programme C lit le fichier en mode texte ancien Maciontosh dans le répertoire \ r mis en correspondance avec un fichier \ n, lorsque les données sont écrites en mode texte, \ n converti \ r.
Lorsque le programme de lecture et d'écriture des fichiers en mode binaire, le programme ne sera pas voir les fichiers dans le répertoire \ r \ n, le mappage ne se produit pas.
Bien que C fournit le mode binaire et le texte, mais la mise en œuvre de ces deux modes peuvent être identiques, par exemple, ne UNIX et Linux exactement la même méthode des deux modes.
1.3 Niveau I / O
En plus de sélectionner le mode de fichier, vous pouvez également choisir deux niveaux de E / S: la norme E / S et sous-jacente avancée I / O. Le système d'exploitation d'E / S sous-jacent fournit les services d'E / S de base, standard avancée E / S en utilisant le package standard et le fichier d'en-tête stdio.h définit la bibliothèque C.
En second lieu, l'E / S standard
2.1 document standard
programme C sera par défaut pour ouvrir trois fichiers: l' entrée standard, sortie standard et la sortie d'erreur standard.
Par défaut, le dispositif d'entrée est un système d'entrée standard commun, généralement le clavier; dispositif de sortie standard est le système de sortie généralement normale, habituellement un écran d'affichage.
exemple:
/*本例实在 linux 环境中运行的，open 为系统调用，头文件是 open 函数所需要的文件。*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(void)
{
int fd;
//获得文件描述符
fd = open("./array1.c", O_RDONLY);
printf("fd is: %d\n", fd);
return 0;
}
/*运行结果
fd is: 3
*/
Analyse des résultats: fd = 3, ont été décrits dans le fichier 0,1,2 est ouvert, qui est, le décrit ci-dessus l'entrée standard, la sortie standard et l'erreur standard.
2,2 exit () fonction
fonction de sortie () pour fermer tous les fichiers ouverts et la fin du programme, en passant ses paramètres à une partie du système d'exploitation, pour une utilisation par d'autres programmes, comme dans UNIX parent nous dira comment ce n'est pas. 0 procédure de transfert normalement terminée, le programme passe anormalement terminé valeur non nulle, correspondant à différentes valeurs de sortie des raisons différentes.
ANSI C fournit l'utilisation de la même chose en retour de l'appel principal initial () avec l'effet de sortie d'appel ().
différence:
Ⅰ. Si la procédure principale () dans une récursif, la sortie () prendra fin le programme directement, mais retournera une récursion de retour.
Ⅱ. Dans d'autres fonctions, la sortie () peut mettre fin à l'ensemble du programme.
2.3 Fonctions d'E / S standard
2.3.1 fopen ()
Après le succès du programme pour ouvrir le fichier, fopen () renvoie le pointeur de fichier. Type pointeur de fichier de fichier est un pointeur vers un pointeur.
2.3.2 getc () 和 putc ()
GETC () et putc () et getchar () et la fonction putchar () est similaire, sauf que, getc () et putc (), vous pouvez spécifier un fichier, les fichiers getchar () et putchar () ne peut être stdin et stdout .
exemple:
#include <stdio.h>
int main(void)
{
FILE *rfp; //读文件的指针
FILE *wfp; //写文件的指针
char ch;
rfp = fopen("./read", "r");
wfp = fopen("./write","w");
while((ch = getc(rfp)) != EOF)
{
putc(ch, wfp); //向 write.c 中写入
putc(ch, stdout); //向屏幕输出
}
//保存文件
if(fclose(wfp) != 0)
printf("Error in closing file write\n");
return 0;
}
2.3.3 fclose ()
flcose fonction () ferme le fichier spécifié par fp, des tampons à chasse d'eau si nécessaire. Si elle est fermée avec succès, les retours fclose () 0, sinon il retourne EOF.
2.3.5 fscanf () et fprintf () (Note: Ce n'est pas une norme E / S, fichier E / S)
Ces deux fonctions sont similaires à scanf () et printf ().
exemple:
/*fprintf() demo*/
#include <stdio.h>
int main(void)
{
FILE *file;
double d = 0.3333;
char *a = "aldskjf";
file = fopen("fprintf", "w"); //打开文件
fprintf(file, "%.2f\n%s\n", d, a); //写入 file 文件中
fprintf(stdout, "%.2f\n%s\n", d, a); //写入标准输出中
return 0;
}
/*fscanf() demo*/
#include <stdio.h>
int main(void)
{
FILE *file;
char words[50];
file = fopen("fprintf", "r");
while(fscanf(file, "%s", words) == 1) //从 file 文件中读取内容输出到屏幕
puts(words);
return 0;
}
2.3.6 fread () 和 fwrite ()
Deux E / S fonctions sont orientés texte mentionnés précédemment, et pour le traitement des chaînes de caractères. Quand il est utilisé pour% de transformation pour enregistrer la valeur, mais la valeur est convertie en valeur de données de caractère peuvent changer, le changement est irréversible. Pour assurer la cohérence des valeurs avant et après le stockage, l'approche la plus précise est d'utiliser un ordinateur pour stocker le même bit. Ce processus de conversion de la forme numérique à la chaîne n'existe pas. Ce type de notation utilisée dans le programme est stocké dans le procédé de traitement de données est désigné en tant que données de fichier au format binaire.
exemple:
/*fwrite() demo*/
#include <stdio.h>
#define SIZE 7
int main(void)
{
FILE *arrayfile;
//定义一个 double 数组
double array[SIZE] = {4, 5, 1, 1, 4, 6, 7};
arrayfile = fopen("array", "wb"); //以二进制的形式打开文件
fwrite(array, sizeof(double), 7, arrayfile); //把数组中内容写到 books 文件中
fclose(arrayfile);
return 0;
}
/*结果：
存在文件中的数据（二进制编码）：
^@^@^@^@^@^@^P@^@^@^@^@^@^@^T@^@^@^@^@^@^@ð?^@^@^@^@^@^@ð?^@^@^@^@^@^@^P@^@^@^@^@^@^@^X@^@^@^@^@^@^@^\@
*/
/*fread() demo*/
#include <stdio.h>
#define SIZE 7
int main(void)
{
int i;
FILE *arrayfile; //文件指针
double array[SIZE];
arrayfile = fopen("array", "rb"); //以二进制的形式打开 array
fread(array, sizeof(double), SIZE, arrayfile); //把文件中的内容读到结构数组中
//输出
printf("array: \n");
for(i = 0; i < SIZE; i++)
printf("%.2f ", array[i]);
printf("\n");
return 0;
}
/*运行结果
array:
4.00 5.00 1.00 1.00 4.00 6.00 7.00
*/
2.3.7 tampon
E / S standard de la première étape consiste à appeler la fonction fopen (). fopen () de ne pas ouvrir un fichier, un tampon est également créé (créer deux tampons en mode lecture-écriture), et de donner une structure comprenant des données mises en mémoire tampon et les fichiers.
entrée du fichier. Utilisation d'E / S standard appelle l'étape 2 est défini en fonction d'entrée stdio.h, comme fscanf (), getc (). Un appel de ces fonctions, la taille du tampon de blocs de données du fichier est copié dans la mémoire tampon.
Sortie de fichier. Semblable à la façon dont les données sont écrites dans le tampon d'entrée de fichier. Lorsque le tampon est plein, les données seront copiées dans le fichier.
Les fichiers en lecture et d'écriture E / S standard pour simplifier considérablement, ne reflètent pas les tampons du programme, seulement besoin d'écrire directement sur elle.
exemple:
/*Linux 的底层级别读写文件 */
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main(int argc, char * argv[])
{
int rfd; //读文件的 fd
int wfd; //写文件的 fd
char buf[512];
ssize_t n;
printf("%s\n%s\n", argv[1], argv[2]);
//打卡文件
rfd = open(argv[1], O_RDONLY); //读模式
wfd = open(argv[2], O_WRONLY|O_CREAT); //写模式，没有就创建一个
while((n = read(rfd, buf, sizeof(buf))) > 0) //读文件，linux 如果没有读到末尾，n>0
{
printf("%zd\n", n); //输出读了多少内容
write(wfd, buf, n); //写文件
}
close(rfd);
if(close(wfd) == 0) //保存文件，linux 中如果成功保存 close 返回 0
printf("write successfully\n");
return 0;
}
Comme on peut le voir, l'utilisation du niveau sous-jacent E / S et lire les fichiers d'écriture pas de plus, la comparaison, la procédure beaucoup plus simple 2.3.2.
Livres de référence
C Primer Plus (sixième édition) version chinoise
