archivos c/c++

Las opciones basicas son , lectura y escritura.
mintras las operaciones serian ordenamiento y busqueda. como cualquier estructura de datos.

Tipos de archivos

Archivos Secuenciales.-

En este caso los datos se almacenan en forma consecutiva y no es posible leer (recuerdan que significa esta operación) ningun registro (recuerdan la nota de arriba) directmente, es decir para leer el registro n se debera recorrer o accesar los n-1 registros anteriores.

Archivos Directos o Random.-

Para este caso si se puede acceder o leer un renglon n cualquier porsicion del archivo.

Tipos de almacenamiento

Modo Texto: en este caso los datos son almacenados usando Ascii y por tanto son plenamente visibles usando cualquier editor.

Modo Binario: en este caso los datos son almacenados en notación hexadecimal y por tanto se ocupa un editor binario para reconocerlos, sin embargo un archivo binario es mas compacto que un archivo texto.

En C es necesario declarara una struct con typedef se usan las siguiente librerias:

#include

#include

Las siguientes funciones para lectura

getc()

fgets()

fscanf()

fread()//Necesita una struct

para escritura.

putc()

fputs()

fprintf()

fwrite()//Necesita una struct

En C++

#include

#include

#include

#include

#include

/*Modos de Crear Archivo En C++*/

ofstream fout(“File1.txt” ); SALIDA

ifstream fin(“File1.txt” ); ENTRADA

fstream arch(“File.txt”); AMBOS

Ejemplo de como de clararlo,

ifstream arch ( “archivo.txt” );

//DOnde arch es el nombre de la variable. y “archivo.txt” el nombre del arhivo a crear.

/////////////////////////////////////ARCHIVOS SECUENCIALES;TEXTO ////////////////////////

/*ESCRIBIR SECUENCIAL*/

Delclaracion del stream salida de datos;

ofstream fout(“texto.txt”);

fout < < " Hola mundo de los streams :p " ;

/*LEER SECUENCIAL .leer una cadena hasta el salto de linea \n*/

Declaracion del stream entrada datos:

ifstream lectura_arch("texto.txt");

char Variable[300];

/*Leer Todo el archivo hasta EOF y mostralo en pantalla */

while ( ! lectura_arch.eof( ) )

{ fin.getline(Variable,300); //Esto quiere decir que en lugar de leerlo de teclado lo lee del archivo;

cout < < variable ;

}

/////////////////////////////////////ARCHIVOS ALEATORIOS; BINARIOS ////////////////////////

//Crear un archivo, Binario ,

Parametros que se pueden seleccionar en un fstream son:

("archivo.dat", ios::trunc | ios::binary );

Esto seria un archivo Binario y trunc es por si existe el archivo lo sobreecribe 😛 los demas bienen implicitos. como ::in ::out dependiendo el tipo de stream,, osea ya no se escriben,

struct Alumno

{ char nombre [30];

char matricula[10];

};

/*ESCRIBIR ALEATORIO_BINARIO*/

Sintaxis:

variableOfstream.write(reinterpret_cast (& objetoGuardar ), sizeof( tamañoClase_Struct ) ) ;

ejemplo:

ofstream arch (” archivo.dat ” , ios::binary);

//creamos un objeto ,

Alumno obj_alumno;

obj_alumno.nombre = “paquito”;

obj_alumno.matircula= “13234”;

arch.write( reinterpret_cast (& obj_alumno) , sizeof(alumno )); // ESTO GUarda en Los datos De objeto creado

/*Como moverse en el stream */

/*Nos posicionamos al inicio del stream */

fin.seekg ( 0 , ios::beg ); // en un archivo de Lextura, ifstream

fin.seekg(0, ios::end);

fin.seekg(0, ios::cur);

fout.seekp( 0 , ios::beg );// en un archivo de Escritura ofstream

fout.seekp(0 , ios::end);

fout.seekp(0 , ios::cur);

//Usando el streampos , un tipo de dato

streampos posicion =( sizeof(tamañoClaseStruct) * (Movimineto,1,2,3…) );

ejemplo:

streampos posicion = (sizeof(Alumno) * 3);

// Guardar en una variable la posicion deseada en 3 registro ,y ahora si usar seek

fout.seekp( posicion );

fin .sekg( posicion );

o

fout .seekp( sizeof(Alumno)*5 ) // a qui no s moveriamos al registro 5 =),

/*LEER BINARIO*/

Sintaxis

variableIfstream.read(reinterpret_cast (& objetoGuardar ), sizeof( tamañoClase_Struct ) ) ;

Ejemplo:

ifstream fin (“archivo.dat”, ios::binary);

Alumno obj2;

fin.read( (char*)&obj2, sizeof(Alumno) ) ;

//Ahora lo que leeiste del archivo se quedo en obj2,

cout < < "nombre " < < ob2.nombre ;

cout < < "matircula " < < ob2.matricula;

DEPUES DE LEER O ESCRIBIR SIMPRE QUEDA UNA POSICION DEPUES DIGAMOS QUE TIENES 3 REGISTROS ALUMNO , Roberto ; Juan ; Pepe , ,

Lees el registo 2, con

stream.seekp( sizeof(Alumno)*2);

stream.read ( (char* )&obj_alumno , sizeof(Alumno) ) ;

ahora si quieres escribir o cambiarle algo, digamos que modificas obj_alumo .nombre = "JuanCarlos";

y lo quieres escribir pensado que quedaste en el 2.

stream.write( (char* )&obj_alumno , sizeof(Alumno) ) ;

Se empezaria a sobre Escribir en el Registro 3, de pepe , y ya no modificaste nada correcto,

//NOTAAANOTAAS

/*Depues de hacer una lectura hasta EOF*/ usar stream.clean( );

Ejemplo, si tenemos un ifstream llamado fin

ifstream fin("archivo.dat" , ios::binary )

depues de hacer fin.read.(…..);

haces esto.

fin.clean( );

o arbirr y cerrar el archiv cada que se requiera, no dejarlos abiertos ,

/*Cerrar Archivo*/

Nombrestream.close();

Anuncios

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