Funciones open/close y read/write en C

Las funciones open y close se usan para abrir abrir y cerrar ficheros, respectivamente. Sus prototipos son los siguientes:

int open(const char *camino, int flags);
int open(const char *camino, int flags, mode_t modo);
int close(int fd);

La función open devuelve un número entero que identifica a un descriptor de fichero o -1 en caso de error, y tiene como parámetros un puntero a la ruta del fichero que queramos abrir y unas banderas (flags) que indican la forma de apertura: sólo lectura (O_RDONLY), sólo escritura (O_WRONLY), lectura/escritura (O_RDWR) u otros (O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC, O_APPEND, O_NONBLOCK u O_NDELAY, O_SYNC, O_NOFOLLOW, O_DIRECTORY, O_DIRECT, O_ASYNC y O_LARGEFILE). Se puede leer más información sobre las banderas en el manual de open.

En la función open podemos especificar un tercer parámentro, el modo, que se usa para especificar los permisos en caso de que se esté creando el archivo. Dichos permisos o modos pueden ser S_IRWXU (el usuario puede leer, escribir y ejecutar (rwx)), S_IRUSR (el usuario puede leer (r)), S_IWUSR (el usuario puede escribir (w)), S_IXUSR (el usuario puede ejecutar (x)), S_IRWXG, S_IRGRP, S_IWGRP, S_IXGRP, S_IRWXO, S_IROTH, S_IWOTH y S_IXOTH.

La función close cierra el descriptor de fichero que le pasemos como parámetro. Devuelve 0 en caso de éxito y -1 en caso de error.

Las funciones read y write se usan para leer y escribir en un descriptor de fichero que previamente hayamos abierto. Sus prototipos son los siguientes:

ssize_t read(int fd, void *buf, size_t nbytes);
ssize_t write(int fd, const void *buf, size_t num);

Como véis, ambas funciones son iguales y los parámetros que reciben son el descriptor de fichero que devolvía la función open, un puntero a un buffer de memoria y un tamaño que indica el número de bytes del buffer que queramos leer o escribir. Ambas funciones devuelven el número de bytes leídos o escritos, o -1 en caso de error.

Aquí os muestro un ejemplo de cómo se pueden usar estas cuatro funciones para copiar un fichero en otro. Este programa recibe dos parámetros que son el archivo origen y el archivo destino. El archivo origen lo abre en modo sólo lectura (O_RDONLY), mientras que el archivo destino lo abre en modo sólo escritura, creándose en caso de que no exista y truncándolo (O_WRONLY|O_CREAT|O_TRUNC). Luego se usa un bucle para leer del descriptor fd1 (origen), guardarlos en un buffer de memoria y escribirlos en el descriptor fd2 (destino). Finalmente cerrará ambos archivos.

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>

int main(int argc, char *argv[]){

  /* Variables */
  int fd1,fd2;
  char buffer[1024];
  int numbytes;

  /* Comprobamos que se pasan dos argumentos */
  if (argc != 3){
    printf("Uso: %s origen destino\n", argv[0]);
    exit(1);
  }

  /* Abrimos los dos archivos */
  fd1 = open(argv[1], O_RDONLY);
  fd2 = open(argv[2], O_WRONLY|O_CREAT|O_TRUNC, 0700);

  /* Bucle de lectura/escritura */
  while ((numbytes = read(fd1, &buffer, sizeof(char))) > 0){
    write(fd2, &buffer, numbytes);
  }

  /* Cierre de archivos */
  close(fd1);
  close(fd2);
}
Anuncios

8 pensamientos en “Funciones open/close y read/write en C

  1. joer ke se lo ha currao, un poko de respeto.
    Ni puto kaso a los novatos q no pueden ni deducir “de donde koño sale la c”, y a otros ke se kreen ke saben mas pero no lo muestran y llaman a la gente “cutre”

    • Hace ya tiempo que hice este artículo sobre read y write, cuando lo estudié en la universidad, así que no soy ningún experto, pero creo que para eso están las funciones fopen, fread, fwrite y fclose. Suerte!

  2. Hola, te consulto una duda, yo tengo un programa ya compilado que es el siguiente
    int main(int argc, char **argv) {
    printf(“%s\n”,argv[1]);
    return EXIT_SUCCESS;
    }
    luego tengo otro programa que ejecuta dentro el programa anterior, mi intencion es hacer que el 2do programa alimente la entrada del 1ero y capture la salida del mismo en un archivo, hasta ahora solo logre capturar la salida del programa en el archivo, pero mi problema es que no logro hacer que la entrada del programa compilado sea alimentada por los datos del 1er programa, como es un poco confuso te paso tambien el codigo del programa pcipal::

    int main()
    {
    FILE* archDeEntrada= fopen(“datosDeEntrada.txt”,”r”);
    FILE* archTemporal = fopen(“archivoTemporal.txt”,”w”);

    dup2(fileno(archDeEntrada),STDIN_FILENO);
    dup2(fileno(archTemporal),STDOUT_FILENO);

    char* espacio= malloc(4);
    read(STDIN_FILENO,espacio,4);

    system(“/home/utnso/workspace/EjemplosC/Debug/./EjemplosC “);

    close(fileno(archDeEntrada));
    close(fileno(archTemporal));
    fclose(archDeEntrada);
    fclose(archTemporal);

    free(espacio);
    return 0;
    }
    El archivoDeEntrada, tiene escrito la palabra hola, mi intencion es hacer que system tome como entrada ese “hola” y lo vuelque en el archTemporal. La salida puedo hacer que archTemporal la capture, pero no puedo hacer que el system tome como entrada los datos del archDeEntrada, alguien me ayuda??

  3. Que tal Amigo. Estoy tratando de recordar como bloquear cierta sección de un archivo pero no recuerdo como se hace. Es decir; abrir un archivo; y leer y bloquear 10 caracteres por ejemplo para que no se pueda acceder a ellos. ¿ Recuerdas como se hace ? Saludos !

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s