[Linux] - base de IO
Hoy en día, en el momento de la revisión, consulte la base de Linux E / S, sentí la necesidad de volver a organizarse bajo las ideas, revisar las operaciones básicas de E / S.
Aquí para escribir dos códigos en el lenguaje C biblioteca de archivos de entrada y de salida estándar
Recordando la biblioteca estándar del lenguaje C de E / S
Escribir archivos en el interior Test.c
#include <stdio.h>
#include <string.h>
int main()
{
FILE *fp=fopen("myfile.txt","w");
if(!=fp)
{
printf("fopen error\n");
}
const char *msg="hello world\n";
int count=5;
while(count--)
{
fwrite(msg,strlen(msg),1,fp);
}
fclose(fp);
return 0;
}
dentro test.c para leer el archivo
#include <stdio.h>
#include <string.h>
int main()
{
FILE *fp=fopen("myfile.txt","r");
if(!=fp)
{
printf("fopen error\n");
}
char buff[1024];
const char*msg="hello world";
while(1)
{
ssize_t s=fread(buff,1,strlen(msg),fp);
if(s>0)
{
buff[s]=0;
printf("%s",buff);
}
if(feof(fp)
{
break;
}
}
fclose(fp);
return 0;
}
Pro-test los tres métodos siguientes en el contenido de C se puede imprimir a la pantalla
#include <stdio.h>
#include <string.h>
int main()
{
const char*msg="1:hello world\n";
fwrite(msg,strlen(msg),1,stdout);
printf("2:hello world\n");
fprintf(stdout,"3:hello fprintf\n");
return 0;
}La salida resultante es:
1: el mundo Hola
2: el mundo Hola
3: el mundo Hola
exacto decir que hay tres de entrada y salida corrientes de idioma por defecto C, es decir, la entrada estándar, stdout y stderr
con las páginas del manual encontrará que estas tres corrientes de todos los tipos es el archivo *.
sistema de archivos de E / S
Se puede observar, además de las interfaces de manipulación c-archivo, también puede C ++. Bajo ese linnux, el dispositivo está en la forma de archivos, que cuando queremos usar estos dispositivos, es abrir estos archivos. Así es como en el acceso a los archivos de Linux que?
En primer lugar, para abrir un archivo:
Abra el prototipo de la función: (1).
Int abierta (const char * nombre de ruta, int las banderas, MODO mode_t);
archivo de cabecera de la función:
#include <sys / types.h>
#include <sys / definida en stat.h>
# incluir <fcntl.h>
parámetros:
nombre de ruta: abrir o crear un nombre de archivo, tales como "miarchivo.txt";
banderas: la forma en que expresa las operaciones a realizar. Hay O_RDONLY (sólo lectura), O_WRONLY (sólo escritura), O_RDWR (lectura y escritura), O_PPEND (adicionales de escritura), O_CREAT (creación de un archivo), O_TRUNC (el archivo se ha borrado de los datos originales). Que es el obligatorias primeros tres opciones, las tres últimas opciones son opcionales. (Por supuesto, hay muchas opciones, los lectores son de libre acceso, sólo para nombrar algunos de uso común)
MODE: Tienes que crear el código de autorización de operación del archivo actual, y sólo cuando se crea, este parámetro será muy útil
Valor de retorno:
Si no se devuelve -1 rendimientos éxito un número entero no negativo (es decir, los descriptores de archivo - al funcionamiento identificador de archivo abierto , se mencionará más adelante)
(2) cerca prototipo de la función
int estrecha (int fd);
archivo de cabecera: `# include <unistd.h>
: Parámetro realmente nada aquí, abiertas devuelve la llamada al operador de archivos
(3) para leer el archivo de
cabecera: # include <unistd.h>
prototipo de la función:
una ssize_t Read (FD int, nula buf, size_t count);
parámetros:
FD: regresar al archivo del operador abiertas llamando
buf: se utiliza para almacenar los datos originales de la memoria intermedia de archivo
recuento : número de bytes leídos
valor de retorno:
rendimientos número éxito única de bytes leídos si el final del archivo, devuelve 0 en caso contrario devuelve -1
(4) de datos de escritura
de archivo de encabezado: <. unistd, H> #include
función prototipo : un ssize_t escritura (int FD, const void buf, size_t cOUNT);
parámetros:
FD: regresar a la llamada descriptor de fichero abierto
buf: Nunca almacene datos del buffer
cuenta: el número de bytes de datos de escritura
* valor de retorno: * devuelve el número de bytes escritos con éxito, no regresó a -1
la implementación del código
Si queremos alcanzar dicho al principio del archivo para escritura a Test.c dentro, cómo hacerlo? Este uso a la que acabamos de hablar del conocimiento, y no hablar mucho sobre el código:
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcnl.h>
#include <unistd.h>
#include <string.h>
int main()
{
umask(0);
int fd=open("myfile.txt",O_WRONLY|O_CREAT,0644);
if(fd<0)
{
perror("open error\n");
return -1;
}
int count=5;
const char*msg="hello world\n";
int len=strlen(msg);
while(count--)
{
write(fd,msg,len);
}
close(fd);
return 0;
}umask significa que cada vez los permisos de archivo establece en 0
descriptor de archivo
Al aprender a función de apertura, sabemos que el descriptor de archivo es un número entero no negativo, entonces ¿qué es lo que al final, tener tales capacidades nos permiten el acceso al archivo que?
En pocas palabras, los operadores de archivos que las operaciones de archivo mango, de hecho, antes de que también mencionamos el lenguaje C, la entrada y salida estándar son: stdin, stdout, stderr, lo que nos sucede en relación con el descriptor de archivo de tres : 0 corresponde a la entrada estándar, salida estándar correspondiente a 1, 2 es el error estándar correspondiente . Por lo tanto, al aire libre un archivo general existente o crear un nuevo archivo, el núcleo devuelve un descriptor de archivo para el proceso, sino también entender por qué abrir un archivo, el archivo descriptor 3 son desde el principio, porque los tres primeros ya está ocupado.
Cuando abrimos un archivo, en el núcleo de Linux por lo general tienen una estructura task_struct para mantener la tabla relacionada con el proceso, llamado el bloque de control de proceso, este bloque no será un puntero a un archivo * a una estructura llamada file_struct descripción del archivo tabla de descriptores, esta tabla contiene un puntero a un array, los elementos de los cuales es un puntero para abrir el archivo, en circunstancias normales, el proceso no es una forma de archivos directamente de acceso, sólo a través de descriptores de archivos, esta es la tabla de índices para encontrar archivo.
redirección
Primer vistazo a un fragmento de código:
#include <stdio.h>
#include <sys/type.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()
{
close(0);
//close(2);
int fd=open("myfile.txt",O_RDONLY);
if(fd<0)
{
perror("open file");
return 1;
}
printf("fd:%d\n",fd);
close(fd);
return 0;
}En este código, que cerraba el 0 (o cerca 2), encontraron que la producción se FD: 0 (2 cuando está cerrado, la salida se FD: 2), lo que quiere decir esto? Es decir nuestros agentes de expedientes reglas de asignación es, en file_struct entre la matriz de encontrar el menor índice no está siendo utilizado actualmente como un nuevo descriptor de archivo.
La pregunta es, ¿por qué no se apague 1?
#include <stdio.h>
#include <sys/type.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()
{
close(1);
int fd=open("myfile.txt",O_WRDONLY|O_CREAT,0664);
if(fd<0)
{
perror("open error");
return 1;
}
printf("fd:%d\n",fd);
fflush(stdout);
close(fd);
return 0;
}
En este momento, se encontró que debería haber sido la salida con el contenido de la salida de la pantalla a la parte interior miarchivo.txt de archivos, donde fd = 1, este fenómeno se le llama redirección.
¿Qué significa? La razón es porque cerramos 1, que es la salida estándar, cuando abrimos un nuevo archivo, se asignará en un descriptor de archivo 1 se asignará al archivo, el descriptor de archivo número 1 en todos los contenidos escritos, son escribió miarchivo.txt, en lugar de la salida estándar.
Linux medios de redirección para modificar el algo original por defecto, cambiar la aplicación por defecto de los comandos originales del sistema, por ejemplo, simplemente no quieren ver en la salida de la pantalla, pero desea que la salida a un archivo, se puede por Linux redirigir para llevar a cabo este trabajo. Se obtiene?
