¿Cómo escribir un archivo con C en Linux?

Question

Quiero volver a escribir el comando "cp" de Linux. Entonces, este programa funcionará como #./a.out originalfile copiedfile. Puedo abrir el archivo, crear un nuevo archivo pero no puedo escribir el nuevo archivo. Nada está escrito. ¿Cuál podría ser la razón?

El código C actual es:

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

int main(int argc,char *aa[]){ 
    int fd,fd1; 
    char buffer[100]; 

    if(argc!=3){ 
     printf("Usage : ./a.out <original> <copy> \n"); 
     return -1; 
    } 

    fd=open(aa[1],O_RDONLY,S_IRUSR); 
    if(fd==-1){ 
     printf("file not found.\n"); 
     return -1; 
    } 
    fd1=open(aa[2],O_CREAT | O_WRONLY,S_IRUSR); 
    if(fd1!=-1){ 
     printf("file is created.\n"); 
    } 
    ssize_t n; 
    while(n=read(fd,buffer,50)){ 
     write(fd1,buffer,n); 
     printf("..writing..\n"); 
    } 
    close(fd); 
    close(fd1); 
} 

Answer 1

tiene que escribir() read() de datos en el nuevo archivo:

ssize_t nrd; 
int fd; 
int fd1; 

fd = open(aa[1], O_RDONLY); 
fd1 = open(aa[2], O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR); 
while (nrd = read(fd,buffer,50)) { 
    write(fd1,buffer,nrd); 
} 

close(fd); 
close(fd1); 

Actualización: Añadido abre el correcto ...

Por cierto, el O_CREAT puede usando OR (O_CREAT | O_WRONLY). En realidad, estás abriendo demasiados identificadores de archivo. Solo haz la apertura una vez.

Answer 2

que tiene que hacer write en el mismo bucle que read.

Answer 3

En primer lugar, el código que escribió no es portátil, incluso si lo hace funcionar. ¿Por qué utilizar funciones específicas del sistema operativo cuando existe una forma de hacerlo perfectamente independiente de la plataforma? Aquí hay una versión que usa solo un archivo de encabezado y es portátil para cualquier plataforma que implemente la biblioteca estándar de C.

#include <stdio.h> 

int main(int argc, char **argv) 
{ 
    FILE* sourceFile; 
    FILE* destFile; 
    char buf[50]; 
    int numBytes; 

    if(argc!=3) 
    { 
     printf("Usage: fcopy source destination\n"); 
     return 1; 
    } 

    sourceFile = fopen(argv[1], "rb"); 
    destFile = fopen(argv[2], "wb"); 

    if(sourceFile==NULL) 
    { 
     printf("Could not open source file\n"); 
     return 2; 
    } 
    if(destFile==NULL) 
    { 
     printf("Could not open destination file\n"); 
     return 3; 
    } 

    while(numBytes=fread(buf, 1, 50, sourceFile)) 
    { 
     fwrite(buf, 1, numBytes, destFile); 
    } 

    fclose(sourceFile); 
    fclose(destFile); 

    return 0; 
} 

EDIT: El glibc reference tiene esto que decir:

En general, usted debe pegarse con utilizando corrientes en lugar de presentar descriptores, a menos que haya alguna operación específica que desea hacer eso solo se puede hacer en un descriptor de archivo. Si usted es un programador de inicio y no está seguro de cuáles son las funciones que debe utilizar, sugerimos que se concentre en los funciones de entrada formateados (ver de entrada con formato) y el formato de salida funciones (véase la salida con formato).

Si usted está preocupado acerca de la portabilidad de sus programas a sistemas distintos GNU, también se debe tener en cuenta que descriptores de archivos no son tan portátil como corrientes . Usted puede esperar cualquier sistema correr ISO C para soportar corrientes, pero sistemas no GNU no sea compatible con archivos descriptores en absoluto, o sólo se puede aplicar un subconjunto de GNU funciones que operan en el archivo descriptores. La mayoría de las funciones del descriptor de archivo en la biblioteca GNU están incluidas en el estándar POSIX.1 , sin embargo.