/////////////////////////////////////////////////
//  BUILDER C++          Wilo Carpio
//  Manejo de Archivos     26/9/2000
////////////////////////////////////////////////
  #include 
  #pragma hdrstop

  #include

  /////////////////////////////////////////////////
  // El archivo "Agenda.h" registra la declaración
  // de la estructura del registro a usar:
  //  struct TRegistro
  //  {
  //  char Nombre[30],Email[20];
  //  };
  //  private:	// User declarations
  //    fstream Archivo;
  //    TRegistro Registro;
  //
  //    int  NumeroRegistro();
  //    void NumeroRegistro(int);
  //    int  NumeroRegistros();
  //    void Actualiza();
  //////////////////////////////////////////////////////////////
#include "Agenda.h"

#pragma package(smart_init)
#pragma resource "*.dfm"

TMiFormulario *MiFormulario;

__fastcall TMiFormulario::TMiFormulario(TComponent* Owner): TForm(Owner)

{
  Archivo.open("EMAIL.DAT",ios::in|ios::out|ios::binary|ios::ate);

  if (!Archivo)
    {
     ShowMessage("No hay archivo che..!!");
     throw;
    }
    Actualiza();
}

void __fastcall TMiFormulario::BotonGrabarClick(TObject *Sender)
{
    strcpy(Registro.Nombre,BoxNombre->Text.c_str());
    strcpy(Registro.Email, BoxEmail->Text.c_str());

    Archivo.write((char *)&Registro, sizeof(Registro));

    if (!Archivo)
    	ShowMessage("No existe el archivo..!!");

    Actualiza();

    BoxNombre->SetFocus();

}

void __fastcall TMiFormulario::BotonSalirClick(TObject *Sender)
{
  int OpcionSalir;
  MiFormulario->Caption = "ELEGISTE BOTON CANCELAR";
  OpcionSalir= Application->MessageBox("Sales del Sistema..", "ESTAS POR CERRAR EL 
PROGRAMA", MB_OKCANCEL+    MB_DEFBUTTON1|MB_ICONQUESTION);
 if (OpcionSalir== IDOK)
   {
     MiFormulario->Close();
   }
 if (OpcionSalir == IDCANCEL)
  {
    MiFormulario->Caption = "Wilo Carpio   PROGRAMA MODELO    C++";
  }
}

void __fastcall TMiFormulario::BotonAntClick(TObject *Sender)
{
	if (NumeroRegistro()  > 1)
    	NumeroRegistro(NumeroRegistro()-1);

    Actualiza();

}

void __fastcall TMiFormulario::BotonSigClick(TObject *Sender)
{
    if (NumeroRegistro() <= NumeroRegistros())
        NumeroRegistro(NumeroRegistro()+1);

    Actualiza();

}

void TMiFormulario::Actualiza()
{
  if (NumeroRegistro()<=NumeroRegistros())
     {

    	 Archivo.read((char *)&Registro, sizeof(Registro));
        NumeroRegistro(NumeroRegistro()-1);

       BoxNombre->Text   = Registro.Nombre;
       BoxEmail->Text    = Registro.Email;
       }
      else
       {
    	 
    	 BoxNombre->Text   = "";
        BoxEmail->Text    = "";
       }
    MiFormulario->Caption = "AGENDA de WILO:  Fichas TOTAL: " +
    AnsiString(NumeroRegistros())+ "   ACTUAL: " + AnsiString(NumeroRegistro());
}


int TMiFormulario::NumeroRegistro()
{
 return Archivo.tellg()/sizeof(Registro)+1;
}


int TMiFormulario::NumeroRegistros()
{
     int PosicionActual = Archivo.tellg();
 
     Archivo.seekg(0, ios::end);

     int N = NumeroRegistro()-1;

    Archivo.seekg(PosicionActual);
    return N;
}

void TMiFormulario::NumeroRegistro(int NuevoNumero)
{
  Archivo.seekg((NuevoNumero-1)*sizeof(Registro));
}


void __fastcall TMiFormulario::BotonConsultaClick(TObject *Sender)
{
 MiFormulario->Caption = "AGENDA de WILO:  Fichas TOTAL: " +
 AnsiString(NumeroRegistros()) + "   ACTUAL: " + AnsiString(NumeroRegistro());
 if (BotonConsulta->Caption=="&Consulta")
    {
      if (NumeroRegistro() <= NumeroRegistros())
         NumeroRegistro(NumeroRegistro()+2);

      Actualiza();
      GrupoDatos->Visible=True;
      BotonConsulta->Caption="&Cerrar";
      BotonModifica->Visible=False;
      GrupoVer->Visible=True;
    }
   else
    {
      MiFormulario->Caption = "AGENDA de WILO:  Fichas TOTAL: " +
      AnsiString(NumeroRegistros());
      BotonConsulta->Caption="&Consulta";
      BotonModifica->Visible=True;
      GrupoVer->Visible=False;
      GrupoDatos->Visible=False;
   }

}

void __fastcall TMiFormulario::BotonModificaClick(TObject *Sender)
{
 MiFormulario->Caption = "AGENDA de WILO:  Fichas TOTAL: " +
 AnsiString(NumeroRegistros()) + "   ACTUAL: " +
 AnsiString(NumeroRegistro());
 if (BotonModifica->Caption=="&Modificar")
    {
     BotonModifica->Caption="&Cerrar";
     BotonConsulta->Visible=False;
     GrupoModifica->Visible=True;
     GrupoDatos->Visible=True;
    }
   else
    {
     MiFormulario->Caption = "AGENDA de WILO:  Fichas TOTAL: " +
     AnsiString(NumeroRegistros());
     BotonModifica->Caption="&Modificar";
     BotonConsulta->Visible=True;
     GrupoModifica->Visible=False;
     GrupoDatos->Visible=False;
     GrupoVer->Visible=False;
    }
}

void __fastcall TMiFormulario::BotonCambiosClick(TObject *Sender)
{
 MiFormulario->Caption = "Selecciona una ficha, modifica y luego graba.!!" ;
 if (BotonCambios->Caption=="&Cambios")
   {
    BotonCambios->Caption="&Cerrar";
    BotonConsulta->Visible=False;
    GrupoVer->Visible=True;
    GrupoDatos->Visible=True;
   }
   else
   {
    MiFormulario->Caption = "AGENDA de WILO:  Fichas TOTAL: " +
    AnsiString(NumeroRegistros());
    BotonModifica->Caption="&Modificar";
    BotonCambios->Caption="&Cambios";
    BotonConsulta->Visible=True;
    GrupoModifica->Visible=False;
    GrupoDatos->Visible=False;
    GrupoVer->Visible=False;
   }
}

---

---

TIPOS DE FICHEROS

ARCHIVOS SIN FORMATO

Están basadas en las funciones de biblioteca fread y fwrite o funciones de lectura y escritura sin formato, que permiten almacenar bloques de datos, consistentes en un número de bytes continuos, que representaran una estructura de datos compleja, tal como arrays simples o múltiples.

Para estas aplicaciones es necesario leer o escribir el bloque entero del archivo de datos en vez de leer o escribir separadamente las componentes individuales de cada bloque.

Estas funciones son operadas con cuatro argumentos: un puntero al bloque de datos, el tamaño del bloque de datos, el número de bloques a transferir y el puntero a un archivo secuencial.

La sintaxis es: fwrite(&VariableTipoRegistro, sizeof(Registro), 1, PunteroArchivoSecuencial);

Donde VariableTipoRegistro es una variable estructura de tipo registro y PunteroArchivoSecuencial es un puntero a archivo secuencial asociado a un archivo de datos abierto para salida.

ARCHIVOS DE ACCESO DIRECTO

También llamados aleatorios, están distribuidos de manera que se puede acceder directamente conociendo su dirección.

En C no existen archivos de acceso directo, sin embargo, existen funciones como fseek() y fgetpos() que permiten tratar los archivos como arrays, moviéndose directamente a un byte determinado del archivo abierto por fopen().

Para el acceso de estos archivos se usa el puntero asociado con el archivo, el cual a diferencia de los punteros de C++ , es un índice que apunta a una posición dada o a la posición actual es el punto en el que comienza el siguiente acceso archivo. El puntero puede ser:

• Puntero get, que especifica la posición del archivo en el que se producirá la siguiente operación de entrada.

• Puntero put , que especifica la posición del archivo en el que se producirá la siguiente de salida.

Cada vez que se realiza una transacción de entrada o salida, el puntero correspondiente avanza automáticamente. Pero, si se usan las funciones seekg ( ) y seekp ( ) se puede acceder al archivo de modo directo, no secuencial.

fseek() usa tres argumentos:

1. Puntero a FILE al archivo que es objeto de la búsqueda. Dicho archivo deberá haber sido abierto previamente con la función fopen().

2. offset. Este argumento indica la distancia a que debemos movernos desde el punto de comienzo; deberá declararse como tipo long. Puede ser positivo (movimiento hacia adelante), negativo (movimiento hacia atrás) o cero (permanece en el mismo sitio).

3. Modo, que identifica el punto de comienzo. El archivo cabecera stdio.h especifica las siguientes constantes explícitas para este modo:

   • SEEK_SET Comienzo del archivo

   • SEEK_CUR Posición actual

   • SEEK_END Fin del archivo

La función fgetpos devuelve la posición actual del puntero a FILE, para ello necesita dos argumentos

1. Apuntador asociado con el archivo sobre el cual queremos realizar la búsqueda.

2. Variable de tipo fpos_t en donde se almacena la posición actual del apuntador al archivo.

¿Hasta dónde se lavan la cara los pelados?

---

---

LEYENDO FICHEROS DE TEXTO

¿Por qué apretamos más fuerte los botones del control remoto cuando tiene poca batería??

LECTURA DE UN ARCHIVO TEXTO

Ejemplo que lee un Archivo de texto y lo muestra en la pantalla:

//////////////////////////////////////
//   Leer un archivo
// C                       WiloCarpio
//////////////////////////////////////

#include 

int main()
    {

Puntero FILE *: Todas las funciones de estrada/salida estándar usan este puntero para conseguir información sobre el Archivo abierto. No apunta al archivo sino a la estructura que contiene información sobre él.

Esta estructura incluye entre otras cosas información sobre el nombre del archivo, la dirección de la zona de memoria donde se almacena el Archivo, tamaño del buffer.

    FILE *Archivo;
    char letra;

Abrir el archivo:

Sintaxis de fopen.: FILE *fopen(const char *nombre_Archivo, const char *modo); El nombre de Archivo se puede indicar directamente o usando una variable. Se puede abrir de diversas formas

• r Abre un Archivo existente para lectura

• w Crea un Archivo nuevo (o borra su contenido si existe) y lo abre para escritura.

• a Abre un Archivo (si no existe lo crea) para escritura. El puntero se sitúa al final del archivo, así se puedan añadir datos si borrar los existentes.

  Se puede agregar: b Para abrir en modo binario, t modo texto y + modo lectura y escritura
  Ejemplo:

• rb+ Abre el Archivo en modo binario para lectura y escritura

• w+ Crea (o lo borra si existe) un Archivo para lectura y escritura

• rt Abre un archivo existente en modo texto para lectura.

    Archivo = fopen("origen.txt","r");

Comprobar si el archivo está abierto: Después de abrir un Archivo es comprobar si realmente está abierto, para evitar fallos: el archivo puede no existir, estar dañado o no tener permisos de lectura

Si el Archivo no se ha abierto el puntero Archivo (puntero a FILE) tendrá el valor NULL y significa que no se abrió por algún error y se debe salir del programa, usando exit( 1 ), el 1 indica al sistema operativo que se han producido errores.

    if (Archivo==NULL)
       {
         printf( "No se puede abrir el Archivo.\n" );
         exit( 1 );
       }

Leer el Archivo

La función getc, lee los caracteres uno a uno. Se puede usar también la función fgetc (son equivalentes, la diferencia es que getc está implementada como macro).

Además de estas dos existen otras funciones como fgets, fread que leen más de un carácter.

Sintaxis: getc (y de fgetc) es: int getc(FILE *Archivo);

Ej. letra = getc( Archivo ); Toma un carácter de Archivo, lo almacena en letra y el puntero se coloca en el siguiente carácter.

    printf ( "Contenido del Archivo:\n" );
    letra = getc ( Archivo);

Fin de Archivo: Cuando entramos en el bucle while, la lectura se realiza hasta que se encuentre el final del Archivo. Para detectar el final del Archivo se pueden usar dos formas: con la función feof() o comprobando si el valor de letra es EOF.

En el ejemplo hemos usado la función feof. Esta función es de la forma: int feof ( FILE *Archivo); Esta función comprueba si se ha llegado al final de Archivo en cuyo caso devuelve un valor distinto de 0.

Si no se ha llegado al final de Archivo devuelve un cero.

Por eso lo usamos del siguiente modo: while ( feof(Archivo)==0 ) o while ( !feof(Archivo) )

La segunda forma consiste en comprobar si el carácter leído es el de fin de Archivo EOF: while ( letra!=EOF ) Cuando trabajamos con Archivos de texto no hay ningún problema, pero si estamos manejando un Archivo binario podemos encontrarnos EOF antes del fin de Archivo. Por eso es mejor usar feof.

    while (feof(Archivo)==0)
          {
            printf( "%c",letra );
            letra=getc(Archivo);
          }

Una vez realizadas todas las operaciones deseadas sobre el Archivo hay que cerrarlo. Es importante no olvidar este paso pues el Archivo podría corromperse.

Al cerrarlo se vacían los buffers y se guarda el Archivo en disco. Un Archivo se cierra mediante la función fclose(Archivo). Si todo va bien fclose devuelve un cero, si hay problemas devuelve otro valor.

Estos problemas se pueden producir si el disco está lleno, por ejemplo.

    if (fclose(Archivo)!=0)
        printf( "Problemas al cerrar el Archivo\n" );
    }

¿Por qué la luz negra no es negra?

---

---

FGETS LECTURA DE FICHEROS

La vida se nos da, y la merecemos dándola..!!

LEER LINEAS COMPLETAS

La función fgets se usa para leer líneas completas desde un Archivo.

Sintaxis: char *fgets(char *buffer, int longitud_max, FILE *Archivo);

Esta función lee desde el Archivo hasta que encuentra un carácter '\n' o hasta que lee longitud_max-1 caracteres y añade '\0' al final de la cadena.

La cadena leída la almacena en buffer. Si se encuentra EOF antes de leer ningún carácter o si se produce un error la función devuelve NULL, en caso contrario devuelve la dirección de buffer.

//////////////////////////////////////
//   Leer un archivo
// C                       WiloCarpio
//////////////////////////////////////

#include 

int main()
    {
    FILE *Archivo;
    char MiTexto[100];

    Archivo=fopen("Origen.txt","r");
    if (Archivo==NULL)
       {
         printf( "No se puede abrir el Archivo.\n" );
         exit( 1 );
       }
    printf( "Contenido del Archivo:\n" );
    fgets(MiTexto,100,Archivo);
    while (feof(Archivo)==0)
          {
            printf( "%s",MiTexto );
            fgets(MiTexto,100,Archivo);
          }
    if (fclose(Archivo)!=0)
       printf( "Problemas al cerrar el Archivo\n" );
    }

Al mundo redondo lo llamamos planeta. Si fuese plano... ¿lo llamaríamos redondeta.??

---

---

ESCRIBIR EN FICHEROS

Si un abogado enloquece... ¿pierde el juicio?

ESCRITURA EN ARCHIVOS

Abrimos un Archivo 'origen.txt' y lo copiamos en otro Archivo 'destino.txt'. Además el Archivo se muestra en pantalla.

//////////////////////////////////////
//   Escribir en un archivo
// C                       WiloCarpio
//////////////////////////////////////
#include 

int main()
    {

Como hemos visto en el capítulo anterior el puntero FILE es la base de la escritura/lectura de archivos. Por eso definimos dos punteros FILE:

Puntero 'origen' para almacenar la información sobre el Archivo origen.txt

Puntero 'destino' para guardar la información del Archivo destino.txt (el nombre del puntero no tiene por qué coincidir con el de Archivo).

    FILE *origen, *destino;
    char letra;

Abrir el Archivo usando fopen. La diferencia es que ahora tenemos que abrirlo para escritura. Usamos el modo 'w' (crea el Archivo o lo vacía si existe) porque queremos crear un Archivo.

Después de abrir un Archivo hay que comprobar si la operación se ha realizado con éxito. En este caso, como es un sencillo ejemplo, los he comprobado ambos a la vez: if (origen==NULL || destino==NULL) pero es más correcto hacerlo por separado así sabemos dónde se está produciendo el posible fallo

    origen=fopen("origen.txt","r");
    destino=fopen("destino.txt","w");
    if (origen==NULL || destino==NULL)
       {
       printf( "Problemas con los Archivos.\n" );
       exit( 1 );
       }

Lectura del origen y escritura en destino- getc y putc

Para la escritura usamos la función putc: int putc(int c, FILE *Archivo); donde c contiene el carácter que queremos escribir en el Archivo y el puntero Archivo es el Archivo sobre el que trabajamos.

De esta forma vamos escribiendo en el Archivo destino.txt el contenido del Archivo origen.txt.

    letra=getc(origen);
    while (feof(origen)==0)
          {
          putc(letra,destino);
          printf( "%c",letra );
          letra=getc(origen);
          }
    if (fclose(origen)!=0)
       printf( "Problemas al cerrar el Archivo origen.txt\n" );

Leemos datos de un Archivo debemos comprobar si hemos llegado al final. Sólo debemos comprobar si estamos al final del Archivo que leemos.

No tenemos que comprobar el final del Archivo en el que escribimos puesto que lo estamos creando y aún no tiene final.

Cerrar el Archivo – fclose

Y por fin lo que nunca debemos olvidar al trabajar con Archivos: cerrarlos. Debemos cerrar tanto los Archivos que leemos como aquellos sobre los que escribimos.

    if (fclose(destino)!=0)
       printf( "Problemas al cerrar el Archivo destino.txt\n" );
    }

Escritura de líneas – fputs: La función fputs trabaja junto con la función fgets

int fputs(const char *cadena, FILE *Archivo);

---

---

fread y fwrite Funciones para manejar Archivos

¿Los infantes disfrutan la infancia tanto como los adultos el adulterio.??

SIMPLIFICANDO LA VIDA..!!

Como las funciones getc, putc, fgets, fputs son adecuadas solo para operar con caracteres (1 byte) y cadenas. Si quisiéramos trabajar con otros tipos de datos, como almacenar variables de tipo int en el archivo, sería necesario convertir los valores a cadenas (con la función itoa), luego, para recuperar estos valores deberíamos leerlos como cadenas y pasarlos a enteros (atoi).

Para simplificar esta tarea conviene usar las funciones fread y fwrite que nos permiten tratar con datos de cualquier tipo, incluso con estructuras.

Fwrite: Permite escribir en un Archivo. La sintaxis es

size_t fwrite(void *buffer, size_t tamano, size_t numero, FILE *pArchivo);

• buffer - variable que contiene los datos que vamos a escribir en el Archivo.

• tamano - el tamaño del tipo de dato a escribir. Puede ser un int, un float, una estructura, ... Para conocer su tamaño usamos el operador sizeof.

• numero - el número de datos a escribir.

• pArchivo - El puntero al Archivo sobre el que trabajamos.

Ejemplo:

//////////////////////////////////////
//   Archivo
// C                       WiloCarpio
//////////////////////////////////////

#include 

struct {
        char nombre[20];
        char apellido[20];
        char telefono[15];
        } registro;

int main()
    {
    FILE *Archivo;

    Archivo = fopen( "nombres.txt", "a" );
    do {
       printf( "Nombre: " ); fflush(stdout);
       gets(registro.nombre);
       if (strcmp(registro.nombre,""))
          {
            printf( "Apellido: " ); fflush(stdout);
            gets(registro.apellido);
            printf( "Teléfono: " ); fflush(stdout);
            gets(registro.telefono);
            fwrite( ®istro, sizeof(registro), 1, Archivo );
          }
       } while (strcmp(registro.nombre,"")!=0);
    fclose( Archivo );
    }

NOTA: El bucle termina cuando el 'nombre' se deja en blanco.

Este programa guarda los datos personales mediante fwrite usando la estructura registro. Abrimos el Archivo en modo 'a' (append, añadir), para que los datos que introducimos se añadan al final del Archivo.

Una vez abierto abrimos estramos en un bucle do-while mediante el cual introducimos los datos. Los datos se van almacenando en la variable registro (que es una estructura).

Una vez tenemos todos los datos de la persona los metemos en el Archivo con fwrite:

fwrite( ®istro, sizeof(registro), 1, Archivo );

• ®istro - es la variable (en este caso una estructura) que contiene la información a meter al Archivo.

• sizeof(registro) - lo utillizamos para saber cuál es el número de bytes que vamos a guardar, el tamaño en bytes que ocupa la estructura.

• 1 - indica que sólo vamos a guardar un elemento. Cada vez que se recorre el bucle guardamos sólo un elemento.

• Archivo - el puntero FILE al Archivo donde vamos a escribir.

Fread: se utiliza para sacar información de un Archivo. Su formato es:

size_t fread(void *buffer, size_t tamano, size_t numero, FILE *pArchivo);

Siendo buffer la variable donde se van a escribir los datos leídos del Archivo pArchivo.

El valor que devuelve la función indica el número de elementos de tamaño 'tamano' que ha conseguido leer. Podemos pedirle a fread que lea 10 elementos (numero=10), pero si en el Archivo sólo hay 6 elementos fread devolverá el número 6.

Si el pez nada... ¿la vaca todo..???

---

---

fread POSICIONANDO FICHAS

Cuando se hace el bién es preciso hacerlo alegremente..!!!

LOCALIZANDO REGISTROS

Siguiendo con el ejemplo anterior ahora vamos a leer los datos que habíamos introducido en "nombres.txt".

#include 

struct {
        char nombre[20];
        char apellido[20];
        char telefono[15];
        } registro;

int main()
    {
    FILE *Archivo;

    Archivo = fopen( "nombres.txt", "r" );
    while ( ! feof ( Archivo ) ) 
     {
       if (fread( ®istro, sizeof ( registro ) , 1, Archivo ) ) 
            {
              printf( "Nombre: %s\n", registro.nombre );
              printf( "Apellido: %s\n", registro.apellido);
              printf( "Teléfono: %s\n", registro.telefono);
              }
       }
    fclose( Archivo );
    }

Abrimos el Archivo nombres.txt en modo lectura. Con el bucle while nos aseguramos que recorremos el Archivo hasta el final (y que no nos pasamos).

La función fread lee un registro (numero=1) del tamaño de la estructura registro. Si realmente ha conseguido leer un registro la función devolverá un 1, en cuyo caso la condición del 'if' será verdadera y se imprimirá el registro en la pantalla.

En caso de que no queden más registros en el Archivo, fread devolverá 0 y no se mostrará nada en la pantalla.

Fseek: Permite situarnos en la posición que queramos de un Archivo abierto. Cuando leemos un Archivo hay un 'puntero' que indica en qué lugar del Archivo nos encontramos.

Cada vez que leemos datos del Archivo este puntero se desplaza.

Con la función fseek podemos situar este puntero en el lugar que deseemos.

Sintaxis de fseek: int fseek(FILE *pArchivo, long desplazamiento, int modo);

Como siempre pArchivo es un puntero de tipo FILE que apunta al Archivo con el que queremos trabajar. desplazamiento son las posiciones (o bytes) que queremos desplazar el puntero.

Este desplazamiento puede ser de tres tipos dependiendo del valor de modo:

SEEK_SET El puntero se desplaza desde el principio del Archivo.

SEEK_CUR El puntero se desplaza desde la posición actual del Archivo

SEEK_END El puntero se desplaza desde el final del Archivo

Si se produce algún error al intentar posicionar el puntero, la función devuelve un valor distinto de 0. Si todo ha ido bien el valor devuelto es 0.

Si la piscina es honda, ¿el mar es Toyota.???

---

---

FSEEK POSICIONANDO FICHAS

¿Debería cortarme las venas o dejármelas largas.??

LOCALIZACION ACTUAL

El siguiente ejemplo te muestra el funcionamiento de fseek. Se trata de un programa que lee la letra que hay en la posición que especifica el usuario.

#include 

int main()
    {
    FILE *Archivo;
    long posicion;
    int resultado;

    Archivo = fopen( "origen.txt", "r" );
    printf( "¿Qué posición quieres leer? " ); fflush(stdout);
    scanf( "%D", &posicion );
    resultado = fseek( Archivo, posicion, SEEK_SET );
    if (!resultado)
        printf( "En la posición %D está la letra %c.\n", posicion, getc(Archivo) );
    else
        printf( "Problemas posicionando el cursor.\n" );
    fclose( Archivo );
    }

ftell: Esta función es complementaria a fseek, devuelve la posición actual dentro del Archivo.

Su formato es el siguiente: long ftell(FILE *pArchivo);

El valor que nos da ftell puede ser usado por fseek para volver a la posición actual. fprintf y fscanf:

Estas dos funciones trabajan igual que sus equivalentes printf y scanf. La única diferencia es que podemos especificar el Archivo sobre el que operar (si se desea puede ser la pantalla para fprintf o el teclado para fscanf).

Los formatos de estas dos funciones son:

int fprintf(FILE *pArchivo, const char *formato, ...);

int fscanf(FILE *pArchivo, const char *formato, ...);

Cuando se 'reproduce' un disco... ¿queda 'encinta'?

---

Un parto en una calle... ¿es alumbrado público.??

---