Programmation d'E/S de fichiers sous Linux

#include <sys>
#include <sys>
#include
int open(const char *pathname, int flags);
</sys></sys>

Paramètre 1 : pathname, le chemin où se trouve le fichier
Paramètre 2 : indicateurs, autorisations de fichiers, relatifs au processus du programme
Les macros courantes sont : O_WRONLY,O_RDONLY,O_RDWR,O_EXCL,O_APPEND,O_DUMP
Paramètre 3 : mode, utilisé lors de la création d'un fichier, généralement la valeur de umask.
Valeur de retour : renvoie le descripteur de fichier avec succès, sinon renvoie -1.

#include
int close(int fd);

#include
ssize_t write(int fd, const void *buf, size_t count);

fd : descripteur de fichier
buf : stocke les données à écrire
count : La longueur de l'écriture, en octets
Valeur de retour : lorsque l'écriture réussit, la longueur des caractères écrits est renvoyée, sinon -1 est renvoyée.

#include
ssize_t read(int fd, void *buf, size_t count);

fd : descripteur de fichier
buf : stocke les données à lire
count : La longueur lue, en octets
Valeur de retour : lorsque la lecture est réussie, la longueur des caractères lus est renvoyée, sinon -1 est renvoyée.
Par exemple :
#inclure

#include <sys>
#include <unistd.h off_t lseek fd offset int whence>
<p>fd : descripteur de fichier<br>
offset : le nombre d'octets à décaler. <br>
d'où : décalé de cela, la macro est définie comme suit : <br>
SEEK_END Fin du fichier<br>
SEEK_CUR position de décalage actuelle<br>
SEEK_SET Le début du fichier<br>
Remarque : Lorsque le décalage est supérieur à la longueur du fichier, un trou est généré par le décalage défini dépassant la fin du fichier et l'écriture de certaines données, qui se situent entre la fin du fichier d'origine et la nouvelle position de décalage. . C'est le trou créé. Les trous n'occupent pas d'espace disque et peuvent être utilisés : </p>
<pre class="brush:php;toolbar:false">du filename #查看文件所占实际磁盘空间
ls filename #实际文件的大小

Par exemple :

#include
#include
#include
#include <sys>
#include <sys>
#include

#define BUFF 12
int main()
{
char str1[BUFF] = "jigntikai";
char str2[BUFF] = "wojisuhihawe";

int fd;
if ( (fd = open("a.txt",O_WRONLY|O_CREAT,0744)) =
{
perror("open file fail\n");
exit(EXIT_FAILURE);
}
if( write(fd,str1,BUFF) == -1 )
{
perror("write fial fail\n");
exit(EXIT_FAILURE);
}
if( lseek(fd,1024,SEEK_END) == -1 )
{
perror("lseek fail\n");
}

write(fd,str2,BUFF);

return 0;
}
</sys></sys>

#include
int access(const char *pathname, int mode);

chemin d'accès : nom du fichier
Le mode peut sélectionner les macros suivantes :
F_OK Le fichier existe-t-il ? R_OK Le fichier dispose-t-il d'une autorisation de lecture ? X_OK Le fichier a-t-il des autorisations exécutables
W_OK Le fichier a-t-il une autorisation en écriture
Valeur de retour : renvoie 0 si les paramètres de mode sont remplis et exécutés correctement, sinon -1 est renvoyé.

#include
int dup(int oldfd);

Voici une brève introduction à la structure du noyau des fichiers : Tout d'abord, il existe une table de processus dans le système informatique. Chaque entrée de la table de processus contient une table de descripteur de fichier ouverte. Il existe de nombreuses descriptions de fichiers dans la table de description de fichier ouverte. élément de table, chaque élément comprend deux parties : un indicateur de descripteur de fichier et un pointeur de fichier, où le pointeur de fichier pointe vers une table de fichiers. La table de fichiers stocke l'indicateur d'état du fichier, c'est-à-dire s'il est lisible ou inscriptible, et le décalage. du fichier actuel. Il existe également un pointeur de nœud v, qui pointe vers une table de nœuds v. La table de nœuds v stocke principalement une série d'informations telles que le propriétaire du fichier, la longueur du fichier, le périphérique du fichier et. l'emplacement du bloc de données réel du fichier sur le disque. Peut-être que cette description n'est pas claire, alors utilisons une image pour la décrire :

#include
void sync(void);将所有缓冲排入写队列，然后立即返回
int fsync(int fd);将所有缓冲排入写队列，直到该缓冲去的数据写入磁盘后才返回。
int fdatasync(int fd);几乎和fsync函数相同，只是fdatasync(int fd)函数只影响数据部分，而fsync还会同步更新文件的属性。

#include
#include
int fcntl(int fd, int cmd, ... /* arg */ );

#include
#include
#include
#include

int main(int argc,char * argv[])
{
int fd;
int val=3;
if( (fd = open(argv[1],O_RDWR|O_APPEND)) == -1 )//测试一下是否可以同时检测出文件的读写属性
{
exit(2);
}

if( val = fcntl(fd,F_GETFL,0) == -1 )
{
exit(1);
}
printf("%d\n",val);
printf("%d %d %d\n",O_RDONLY,O_WRONLY,O_RDWR);
int n = val & O_ACCMODE;

if( n == O_RDONLY)
printf("read\n");
if(O_WRONLY & val )
printf("write\n");
if( n == O_RDWR)
printf("read and write\n");
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!