Archivo de datos

Definicin:
Dev-C++ es un compilador y entorno de desarrollo para C/C++
Consiste en un editor de mltiples ventanas integrado con un compilador que nos
permitir una compilacin, un enlace y una ejecucin de aplicaciones rpida y de
fcil uso.
C/C++ son lenguajes de programacin, donde c++ fue creado para extender el
lenguaje de programacin c y as dar la posibilidad de usar manipulacin de
objetos.
A diferencia de DFD que habamos visto antes de comenzar con Dev-C++, pues
no usa smbolos ( ver entrada sobre los smbolos en DFD ) as como en los
diagramas de flujo que aprendimos, si no que usa cdigos para reemplazar
aquellos smbolos, por eso es importante saber hacer un diagrama de flujo /
algoritmo, para poder realizar bien un programa en c, c++, o cualquier programa
que use lenguaje de programacin con cdigo, porque la idea sigue siendo la
mismo solo cambian los smbolos por palabras restringidas en dicho lenguaje.
Primero se debe declarar un puntero de tipo FILE para poder guardar la direccin
de memoria del archivo de texto que se quiere crear, sobrescribir o leer (segn
como se defina lo que se quiera hacer, cosa que veremos ms adelante)
Ejemplo:
# include <stdio.h>
# include <conio.h>
FILE *doc;
int main(){
doc = fopen("prueba.txt","w");
printf("ponga los nombres de los jugadores");
char jug[15];
char resp;
int n = 0;
do{
printf("\nfJugador %d : ",n);
scanf("%s",jug);
 fprintf(doc,"%s \n",jug);
n++;
printf("\nIngresar nuevo jugador? (s/n)");
resp = getch();
}while( resp == 's' || resp == 'S');
fclose(doc);
return 0;
}

En la cabecera del programa se declara un puntero a un archivo de texto

FILE *doc;
Adems, la instruccin:
doc = fopen("prueba.txt","w");
Le decimos al compilador que el puntero tome la direccin del archivo prueba.txt y
poniendo "w" como segundo parmetro definimos que el archivo debe ser creado
en caso de que no exista y en caso de existir se sobrescribir (se borraran los
datos ya existentes) adems que solo podemos usar el archivo para escritura
nicamente.
Dependiendo de la letra que se ponga como segundo parmetro se puede hacer
distintos usos del archivo por ejemplo para la lectura de datos.
"r" Abrir un archivo para lectura. El archivo debe existir.
"w" Crear un archivo vaco para la escritura. Si un archivo con el mismo nombre
ya existe su contenido se borra y el archivo se trata como un nuevo archivo vaco.
"a" Anexar a un archivo. Operaciones de escritura aadir datos al final del
archivo. El archivo se crea si no existe.
"r+" Abrir un archivo de actualizacin de la lectura y la escritura. El archivo debe
existir.
"w+" Crear un archivo vaco, tanto para la lectura y la escritura. Si un archivo con
el mismo nombre ya existe su contenido se borra y el archivo se trata como un
nuevo archivo vaco.
"a+" Abrir un archivo para leer y aadir. Toda la operacin de escritura se realiza
al final del archivo, la proteccin del contenido anterior a ser sobrescrito. Puede
cambiar la posicin ( fseek , rewind ) el puntero interno a cualquier parte del
archivo para su lectura, pero la operacin de escritura har que se mueva de
nuevo al final del archivo. El archivo se crea si no existe.
Despus guardamos el nombre del jugador en la variable jug e imprimimos la
cadena jug en el archivo de texto con las siguientes lneas de cdigo:
scanf("%s",jug);
fprintf(doc,"%s \n",jug);
Las funciones para imprimir o leer datos son parecidas a las que ya conocemos
solo que se le antecede con una f (fprintf , fscanf) y se le aumenta un parmetro el
cual se pone al principio con el nombre del puntero.
Si se desea ingresar ms nombres solo se tiene que presionar una tecla distinta
de "s"
Una vez que se haya ejecutado el programa aparecer un archivo de texto con el
nombre prueba y dentro veremos los nombres que se han ingresado durante la
ejecucin del programa.
Si se quiere leer los datos directamente desde el programa se debe creas otro
puntero FILE y declaro de la siguiente manera:
(la implementacin de esta parte al cdigo original para que se pueda leer todos
los nombres se le deja al lector)
FILE *leer;
int main(){
leer = fopen("prueba.txt","r");
char nombre[15];
// leer el primer nombre
fscanf(leer,"%s",nombre);
printf("%s\n",nombre);
......................
......................
......................
}
Ejemplo 2:
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
ofstream archivo_salida("file.txt"); // Se abre el archivo para escribir.
struct _persona // Tu estructura
{
char name[80];
// Demas datos
} persona;
cout << "Nombre : ";
cin.getline(persona.name, 80); // Se almacena en la variable
archivo_salida << persona.name << endl; // Se escribe en el archivo
archivo_salida.close(); // SE cierra el archivo
return 0;
}
Con esta linea, el archivo es creado:
ofstream archivo_salida("file.txt");
En la misma linea, puedes especificar donde crear el archivo, ejemplo:
ofstream archivo_salida("c:\\batch\\file.txt");

Crear e ingresar datos (archivos)

#include<iostream>
#include<fstream>//LIBRERIA PARA MANEJAR ARCHIVOS
#include<string>
#include<windows.h>
using namespace std;
ofstream entrada; //OBJETO O VARIABLE PARA CREAR EL ARCHIVO
int main()
{
//variables usados para ingresar y guardar los datos
string nombre, apellidos;
int codigo, sueldo;
char opc;

entrada.open("datos_empleados.txt",ios::out|ios::app);//LLAMAR EL ARCHIVO
if (entrada.fail())//PREGUNTAR SI EL ARCHIVO EXISTE
{
cout<< "ERROR AL ABRIR EL ARCHIVO"<<endl;
}
else
{
do
{
cout<<"******datos de empleados*******"<<endl;
cout<<endl;
cout<<"CODIGO: ";
cin>> codigo;
cout<<"NOMBRE: ";
cin>>nombre;
cout<<"APELLIDOS: ";
cin>>apellidos;
cout<<"SUELDO: ";
cin>>sueldo;
entrada<<codigo<<" "<<nombre<<" "<<apellidos<<"
"<<sueldo<<endl;//GUARDAR LOS DATOS
cout<<endl;
cout<<"desea continuar ingresando datos s/n"<<endl;
 cin>>opc;
opc=toupper(opc);
}while (opc == 'S');
}
entrada.close();
system ("pausa");
return (0);
}

Modos de apertura de archivo

Al especificar la apertura de un archivo como se ha mostrado en los programas
anteriores, el programa sobreescribe cualquier archivo existente llamado Datos.txt
en el directorio de trabajo del programa. Dependiendo del propsito del programa
es posible que sea necesario agregar datos a los ya existentes en el archivo, o
quiz sea necesario que las operaciones del programa no se lleven a cabo en
caso de que el archivo especificado exista en el disco, para stos casos podemos
especificar el modo de apertura del archivo incluyendo un parmetro adicional en
el constructor, cualquiera de los siguientes:
ios::app Operaciones de aadidura.
ios::ate Coloca el apuntador del archivo al final del mismo.
ios::in Operaciones de lectura. Esta es la opcin por defecto para objetos de la
clase ifstream.
ios::out Operaciones de escritura. Esta es la opcin por defecto para objetos de la
clase ofstream.
ios::nocreate Si el archivo no existe se suspende la operacin.
ios::noreplace Crea un archivo, si existe uno con el mismo nombre la operacin se
suspende.
ios::trunc Crea un archivo, si existe uno con el mismo nombre lo borra.
ios::binary Operaciones binarias.
De esta manera, podemos modificar el modo de apertura del programa
archiv02.cpp para que los datos del programa se concatenen en el archivo
Datos.txt simplemente escribiendo el constructor as: ofstream archivo("Datos.txt",
ios::app);. Si deseamos que el programa no sobreescriba un archivo existente
especificamos el constructor de sta manera: ofstream archivo("Datos.txt",
ios::noreplace);. Utilizando los especificadores de modo de apertura se puede
conseguir un mayor control en las operaciones de E/S en archivos.

Operaciones de lectura de archivos

Para abrir un archivo y realizar operaciones de lectura se crea un objeto de la
clase ifstream y se procede prcticamente de la misma forma que lo expuesto en
el apartado anterior. Despus de abrir el archivo se puede leer su contenido
utilizando las funciones miembro de la clase ifstream o bin el operador de
extraccin. Cuando se lee un archivo, por lo general se empieza al principio del
mismo y se leer su contenido hasta que se encuentre el final del archivo. Para
determinar si se ha llegado al final del archivo se puede utilizar la funcin miembro
eof como condicin de un bucle while. Adems se puede utilizar la funcin
miembro fail para detectar un error al abrir el archivo, esto se demuestra en el
siguiente programa:
#include <fstream.h>
int main()
{
ifstream archivo("Pruebas.txt", ios::noreplace);
char linea[128];
long contador = 0L;
if(archivo.fail())
cerr << "Error al abrir el archivo Pruebas.txt" << endl;
else
while(!archivo.eof())
{
archivo.getline(linea, sizeof(linea));
cout << linea << endl;
if((++contador % 24)==0)
{
cout << "continua...";
cin.get();
 }
}
archivo.close();
return 0;
}

Lectura y escritura en un archivo

En ciertas aplicaciones es necesario efectuar operaciones de lectura/escritura en
un archivo como es el caso de una base de datos, para esto es necesario crear un
objeto de la clase fstream. Cuando un programa abre un archivo para operaciones
de E/S ste mantiene el registro de dos apuntadores de archivo, uno para
operaciones de lectura y otro para operaciones de escritura. Como en la mayora
de los casos en que se abre un archivo para operaciones de E/S se efecta
acceso aleatorio, analizaremos sta condicin.
Acceso aleatorio de archivos
En los programas presentados hasta este punto se han realizados operaciones
secuenciales en el archivo, ya sea para escritura lectura de datos, empezando
por el principio y continuando hasta el final del mismo. Las operaciones aleatorias
en un archivo no necesariamente inician por el principio del archivo, en lugar de
sto es posible desplazarse por el contenido del archivo para realizar una
operacin de E/S. Para mover los apuntadores de archivo a posiciones especficas
se utilizan dos funciones: seekg( ) coloca el apuntador de escritura de archivo en
un lugar especfico, y seekp( ) mueve el apuntador de lectura a una posicin
especfica en el archivo, la sintxis de las funciones es sta:
seekp(desplazamiento, posicin)
seekg(desplazamiento, posicin)
El parmetro desplazamiento especifica la cantidad de bytes que se mover el
apuntador de archivo, puede ser un valor positivo negativo. El parmetro
posicin especifica el lugar del archivo a partir del cual se mover el apuntador de
archivo, de acuerdo a las siguientes banderas
ios::beg Desde el principio del archivo
ios::cur Desde la posicin actual del apuntador
ios::end Desde el fin del archivo
Para demostrar las operaciones aleatorias conviene generar un breve archivo de
texto en donde poder efectuar algunas operaciones de E/S, use el siguiente
cdigo:

#include <fstream.h>
int main()
{
ofstream archivo("Letras.txt");

for(char letra='A'; letra <='Z'; letra++)

archivo << letra;
archivo.close();

return 0;
}
El cdigo genera un alfabeto en el archivo llamado Letras.txt, ahora utilizaremos el
programa archiv06.cpp para "navegar" por el contenido del archivo y generar una
palabra amigable en pantalla:
#include <fstream.h>
int main()
{
char letra;
fstream letras("Letras.txt", ios::in|ios::out);

letras.seekg(7, ios::beg); // obtiene la letra H

letra=letras.get();
letras.seekp(0, ios::end);
letras << letra; // coloca la letra al final

letras.seekg(-13, ios::end); // obtiene la letra O

 letra = letras.get();
letras.seekp(0, ios::end);
letras << letra;

letras.seekg(-17, ios::end); // obtiene la letra L

letra = letras.get();
letras.seekp(0, ios::end);
letras << letra;

letras.seekg(0, ios::beg); // obtiene la letra A

letra = letras.get();
letras.seekp(0, ios::end);
letras << letra;

letras.seekg(-4, ios::end);
while(!letras.eof())
cout.put((char)letras.get());

letras.close();

return 0;
}
Declaracin de estructuras
En contra de lo que ocurre con el resto de los tipos, que estn pre-definidos en el
lenguaje. Por ejemplo, al declarar char ch; ya se sabe exactamente que cosa es
ch, en este caso hay que definir previamente el tipo. Los tipos estructura se
declaran mediante la palabra clave struct. Sera algo as como:
struct Punto;
struct Punt2 {int x; int y; int z; };
La primera sentencia es una declaracin incompleta (ver ms abajo); la segunda
es una definicin completa de una nueva clase tipo struct denominado Punt2; tiene
tres componentes perfectamente definidos (tres int: x, y, z respectivamente).
Ya hemos sealado que en C++ las estructuras son un tipo de clases; entonces, si
nos referimos a la terminologa de la POO diramos que en esta fase estamos
definiendo la clase. El conjunto de declaraciones dentro de los corchetes {...; ...; ...;
} declara los nombres y tipos de sus miembros. Los miembros pueden ser de
cualquier tipo con una excepcin:
-Un miembro no puede ser la estructura que se declara porque dara lugar a una
declaracin circular (lo definido est dentro de su definicin). Ejemplo:
struct mystr { mystr s }; // Ilegal
-Uno, o varios, de los miembros puede ser un puntero a la estructura que se est
declarando. Ejemplo:
struct mystr { mystr *ps } // Ok: Correcto
Nota: constituye la base de estructuras auto referenciadas; una tcnica de
programacin que tiene amplias posibilidades de aplicacin. Por ejemplo, listas
enlazadas y rboles
Tambin es posible que los miembros de una estructura sean a su vez estructuras
previamente definidas, dando lugar a estructuras anidadas. Por ejemplo:
struct Punto {
int x; int y;
};
struct Linea {
struct Punto p1;
struct Punto p2;
} c1;
Nota: un miembro no puede ser del tipo "funcin devolviendo...". Es decir, las
funciones no pueden ser miembros de la estructuras C (de lo contrario seran
clases). En cambio, s estn admitidos los "punteros a funcin devolviendo..." (ya
que son variables, no mtodos). Las estructuras C++ s pueden incluir funciones
miembro (de hecho son clases), adems, en C++ la palabra struct puede omitirse.
rear un objeto (instanciar la clase)
Un segundo paso es declarar una variable como perteneciente al nuevo tipo. Del
mismo modo que para declarar una variable ch como de tipo char declarbamos:
char ch;, en este caso, para declarar una variable st como estructura tipo punto se
utiliza:
struct Punto pt; // C y C++
En C++ no es necesario sealar que Punto es una estructura (suponemos que ya
lo sabe el compilador por las sentencias anteriores), de forma que si no existe
ninguna otra variable punto en el mismo mbito de nombres, no hay ambigedad y
se puede poner directamente:
Usando la terminologa de la POO diramos que estamos instanciando la clase, es
decir, creando un objeto concreto pt, con espacio en memoria, que pertenece a (es
derivado de) dicha clase. Dichos objetos s pueden ser asignados con valores
concretos en sus miembros.
Advertir que cada declaracin de (tipo de) estructura introduce un nuevo tipo,
distinto de los dems (una nueva clase), de forma que las declaraciones:
struct StA {
int i,j;
} a, a1;
struct StB {
int i,j;
} b;
Definen dos tipos de estructura distintas: StA y StB; los objetos a y b1 son del tipo
StA, pero a y b son de tipo distinto.
Desde la ptica de la POO la frase anterior se enunciara como sigue: "definen dos
clases distintas, StA y StB; los objetos a y b1 son instancias de StA, pero b lo es
de la clase StB. Por tanto, a y b son objetos de tipo distinto.
Iniciar el objeto
Un tercer paso es inicializar dicha variable. Del mismo modo que para iniciar ch se
realizaba una asignacin del tipo: ch = 'x', en este caso se utiliza la asignacin
(anloga a la de matrices):
st = { 12, 25, 3};
Los pasos 2 y 3 se pueden realizar en la misma sentencia. Por ejemplo:
struct punto st = { 12, 25, 3};
Tambin puede realizarse los tres pasos en una misma sentencia:
struct punto { int x; int y; intz; } p1 = { 12, 25, 3};
Una vez definido el nuevo tipo, pueden declararse punteros y matrices de
estructuras de dicho tipo. Por ejemplo:
struct stA { ... }; // define la estructura tipo stA
struct stA st, *pst, arst[10];
La segunda lnea declara que st es una estructura de tipo stA; que pst es un
puntero a dicho tipo, y que arst es un array de 10 estructuras tipo stA.
Como se ver a continuacin , es posible incluso declarar estructuras sin asignar
un nombre al tipo correspondiente. Por ejemplo:
struct { ... } st, *pst, arst[10];
Ejemplo
goto s;
...
s: // L.3 Etiqueta
struct s { // L.4 OK: nombres de tipo_de_estructura y etiqueta en
// espacios diferentes
int s; // L.6 OK: nombres miembro de estructura en espacio privado
float s; // L.7 ILEGAL: nombre de miembro duplicado
} s; // L.8 OK: nombre_de_estructura en espacio diferente de
// nombre de etiqueta (L.3) y de tipo_de_estructura (L4)
// En C++, esto solo es posible si s no tiene un constructor
union s { // L.11 ILEGAL: nombre duplicado con el de tipo s (L.4)
int s; // L.12 OK: nuevo espacio de miembros
float f;
} f; // L.14 OK: espacio diferente que el de miembros (ver L.8)
struct t {
int s; // L.16 OK: nuevo espacio de miembros
...
} s; // L.18 ILEGAL: nombre duplicado con el de estructura s (L8)

Libreras Estndar
Para poner un poco de orden, el Estndar C++ define la denominada Librera
Estndar

que debe acompaar a cada implementacin del compilador que se adhiera al

estndar. Es decir: la norma determina cuales son, como se llaman y como se
utiliza este conjunto de algoritmos que deben acompaar (como mnimo) a cada
implementacin del compilador que quiera llamarse "Estndar". La ltima
versin, ISO/IEC 14882 del ao 1998, especifica que se compone de 32 ficheros
de cabecera de nombres fijos y conocidos agrupados segn la funcionalidad de
los algoritmos. Son los siguientes:

Ficheros Funcionalidad/funciones

<algorithm> Parte de la STL que describe los algoritmos

<bitset> Parte de la STL relativa a contenedores tipo bitset. Set de valores

booleanos.

<complex> Parte de la librera numrica de la STL relativa a los complejos

<deque> Parte de la STL relativa a contenedores tipo deque; un tipo de

colas: "Double-ended-queue"

<exception> Parte de la librera de diagnstico relativa al manejo de

excepciones

<fstream> Flujos hacia/desde ficheros.

<functional> Parte de la STL relativa a Objetos-funcin

<iomanip> Manipuladores.

<ios> Supreclases para manejo de flujos de E/S.

<iosfwd> Contiene declaraciones adelantadas de todas las plantillas de flujos

y sus typedefs estndar. Por ejemplo ostream.

<iostream> Parte del a STL que contiene los algoritmos estndar de E/S.

<istream> Algoritmos estndar de flujos de entrada.

<iterator> Parte de la STL relacionada con iteradores ,un tipo de puntero que
permite utilizar los algoritmos de la Librera con las estructuras de
datos representadas por los contenedores.

<limits> Descripcin de propiedades dependientes de la implementacin

que afectan a los tipos fundamentales.
<list> Parte de la STL relativa a contenedores tipo list ; listas doblemente
enlazadas

<locale> Parte de la STL relativa a la internacionalizacin

<map> Parte de la STL relativa a contenedores tipo map

<memory> Utilidades relativas a la gestin de memoria, incluyendo

asignadores y punteros inteligentes

<new> Manejo de memoria dinmica

<numeric> Parte de la librera numrica de la STL relativa a operaciones

numricas

<ostream> Algoritmos estndar para los flujos de salida.

<queue> Parte de la STL relativa a contenedores tipo queue ; colas de

objetos

<set> Parte de la STL relativa a contenedores tipo set

<sstream> Flujos hacia/desde cadenas alfanumricas.

<stack> Parte de la STL relativa a contenedores tipo stack; pilas de objetos

<stdexcept> Parte de la STL relativa a las clases de las que derivan los objetos
lanzados por las excepciones ocasionadas en los algoritmos de la
propia STL y otras expresiones. Estas clases son utilizadas para
reportar errores detectados durante runtime. Los usuarios tambin
pueden utilizar excepciones para reportar errores en sus propios
programas

<streambuf> Parte de la STL relativa al Almacenamiento de flujos de E/S

("Stream buffers"). Define los tipos que controlan la capa de
transporte

<string> Parte de la STL relativa a contenedores tipo; una generalizacin de

las cadenas alfanumricas para albergar cadenas de objetos.

<typeinfo> Mecanismo de identificacin de tipos en tiempo de ejecucin

<utility> Parte de la STL que contiene elementos auxiliares como

operadores y pares (pairs).

<valarray> Parte de la librera numrica de la STL relativa a manejo de

matrices numricas ()

<vector> Parte de la STL relativa a los contenedores tipo vector; una

generalizacin de las matrices unidimensionales C/C++
Referencias:
- http://c.conclase.net/curso/?cap=039
- https://www.genbetadev.com/cc/como-se-hace-en-c-manejo-de-ficheros-de-
configuracion
- https://eperdomo89.wordpress.com/2011/04/16/dev-c-clase19-
%E2%80%93-punteros-o-apuntadores/
- http://www.lawebdelprogramador.com/foros/Dev-C/883902-Declaracion-de-
punteros.html
- http://www.programacionenc.net/index.php?
option=com_content&view=article&id=69:manejo-de-archivos-en-
c&catid=37:programacion-cc&Itemid=55
- http://creatusjuegosdecero.webege.com/index.php?topic=99.0
- http://www.nebrija.es/~abustind/Informatica/MetodologiaI/Archivos.pdf
- http://altair.lcc.uma.es/clases/laboratorio/curso200102/tema9.pdf
- https://prezi.com/ey5dqhh6hds2/escritura-y-lectura-de/
- http://programacionendevc.blogspot.mx/2012/08/manejo-de-archivos-en-
dev-c.html
- https://conalepdalia.files.wordpress.com/2013/07/comercio.pdf
- http://www.aprendeaprogramar.com/mod/forum/discuss.php?d=664
- https://www.programarya.com/Cursos/C++/Bibliotecas-O-Librerias
- http://www.zator.com/Cpp/E5.htm
- http://www.zator.com/Cpp/E4_5_1.htm