¿Cuál es la forma correcta de declarar y usar un puntero ARCHIVO * en C/C++?

Question

¿Cuál es la forma correcta de declarar y usar un puntero FILE * en C/C++? ¿Debería ser declarado global o local? ¿Alguien puede mostrar un buen ejemplo?

Answer 1

No importa en absoluto si es local o global. El alcance del puntero del archivo no tiene nada que ver con su uso.

En general, es una buena idea para evitar las variables globales tanto como sea posible.

Aquí hay un ejemplo que muestra cómo copiar desde input.txt a output.txt:

#include <stdio.h> 
int main (void) { 
    FILE *fin; 
    FILE *fout; 
    int c; 

    fin = fopen ("input.txt", "r"); 
    if (fin != NULL) { 
     fout = fopen ("output.txt", "w"); 
     if (fout != NULL) { 
      c = fgetc (fin); 
      while (c >= 0) { 
       fputc (c, fout); 
       c = fgetc (fin); 
      } 
      fclose (fout); 
     } else { 
      fprintf (stderr, "Cannot write to output.txt"); 
     } 
     fclose (fin); 
    } else { 
     fprintf (stderr, "Cannot read from input.txt"); 
    } 
    return 0; 
} 

Answer 2

Aquí es el primer éxito en Google para "io archivo en c"

http://www.cs.bu.edu/teaching/c/file-io/intro/

Aquí es la tercera golpeado desde gamedev con más de una inclinación de C++

http://www.gamedev.net/reference/articles/article1127.asp

Declara el puntero en el alcance que lo necesita.

Answer 3

Es sólo un puntero ordinario como cualquier otro.

FILE *CreateLogFile() 
{ 
    return fopen("logfile.txt","w"); // allocates a FILE object and returns a pointer to it 
} 

void UsefulFunction() 
{ 
    FILE *pLog = CreateLogFile(); // it's safe to return a pointer from a func 
    int resultsOfWork = DoSomeWork(); 
    fprintf(pLog, "Work did %d\n", resultsOfWork); // you can pass it to other functions 
    fclose(pLog); // just be sure to clean it up when you are done with fclose() 
    pLog = NULL; // and it's a good idea to overwrite the pointer afterwards 
        // so it's obvious you deleted what it points to 
} 

Answer 4

int main(void) 
{ 
    char c; 
    FILE *read; 
    read = fopen("myfile", "r"); // opens "myfile" for reading 
    if(read == NULL) 
    { 
    perror("Error: could not open \"myfile\" for reading.\n"); 
    exit(1); 
    } 
    c = fgetc(read); 
    fclose(read); 
    printf("The first character of myfile is %c.\n", c); 
    return 0; 
} 

Eres perfectamente autorizados a declarar filehandles globales si se quiere, al igual que cualquier otra variable, pero no puede ser recomendada.

Esta es la manera C. C++ puede usar esto, pero creo que hay una manera más amigable de C++ de hacerlo. Como nota, lo odio cuando las preguntas están marcados C/C++, debido a que C y C++ son no el mismo idioma y hacer no funcionan de la misma. C++ tiene muchas formas diferentes de hacer cosas que C no tiene, y pueden ser más fáciles de hacer en el contexto de C++, pero no son válidas C. Entonces, si bien esto funcionará para cualquier idioma, no es lo que querer si usas predominantemente C++.

EDIT: Añadido comprobación de errores. Siempre use la comprobación de errores en su código.

Answer 5

En primer lugar, tenga en cuenta que un apuntador de archivo (y la estructura asignada asociado) se basa en el nivel inferior de escritura abierta() read()() llama. El descriptor de archivo asociado (obtenido por fileno (file_pointer) es lo menos interesante, pero es posible que desee ver su alcance con.

Si va a declarar un puntero de archivo como global en un módulo, generalmente es un buena idea mantenerlo estático (contenido dentro del archivo de módulo/objeto). Algunas veces esto es un poco más fácil que almacenarlo en una estructura que pasa de una función a otra si necesita escribir algo rápidamente.

Para ejemplo, (mala)

#include <stdio.h> 
#include ... 

#define MY_LOG_FILE "file.txt" 

FILE *logfile 

realizan mejor como:

#include <stdio.h> 

#define MY_LOG_FILE "file.txt" 

static FILE *logfile; 

int main(void) 
{ 

A MENOS QUE necesite varios módulos para tener acceso a ese puntero, en cuyo caso es mejor colocarlo en una estructura que se pueda pasar.

Si se necesita solo en un módulo, considere declararlo en main() y dejar que otras funciones acepten un puntero de archivo como argumento. Entonces, a menos que sus funciones dentro del módulo tengan tantos argumentos que otro sea insoportable ... no hay (generalmente) ninguna razón para declarar un puntero de archivo globalmente.

Algunas bibliotecas de registro lo hacen, lo que no me importa ... especialmente cuando se trata de funciones de reentrada. El espacio de nombres monolítico de Nevermind C :)