1 Generalidades:

Muy a menudo necesitamos almacenar cierta cantidad de datos de forma más o menos permanente. La memoria del ordenador es volatil, y lo que es peor, escasa y cara. De modo que cuando tenemos que guardar nuestros datos durante cierto tiempo tenemos que recurrir a sistemas de almacenamiento más económicos, aunque sea a costa de que sean más lentos.

Durante la historia de los ordenadores se han usado varios métodos distintos para el almacenamiento de datos. Al principio se recurrió a cintas de papel perforadas, después a tarjetas perforadas. Más adelante se pasó al soporte magnético, empezando por grandes rollos de cintas magnéticas abiertas.

Hasta aquí, todos los sistemas de almacenamiento externo eran secuenciales, es decir, no permitían acceder al punto exacto donde se guardaba la información sin antes haber partido desde el principio y sin haber leído toda la información, hasta el punto donde se encontrase la que estábamos buscando.

Con las cintas magnéticas empezó lo que con el tiempo sería el acceso aleatorio a los datos. Se podía reservar parte de la cinta para guardar cierta información sobre la situación de los datos, y añadir ciertas marcas que hicieran más sencillo localizarla.

Pero no fué hasta la aparición de los discos magnéticos cuando ésta técnica llegó a su sentido más amplio. En los discos es más sencillo acceder a cualquier punto de la superficie en poco tiempo, ya que se accede al punto de lectura y escritura usando dos coordenadas físicas. Por una parte la cabeza de lectura/escritura se puede mover en el sentido del radio del disco, y por otra el disco gira permanentemente, con lo que cualquier punto del disco pasa por la cabeza en un tiempo relativamente corto. Esto no pasa con las cintas, donde sólo hay una coordenada física.

Con la invención y proliferación de los discos se desarrollaron los ficheros de acceso aleatorio, que permiten acceder a cualquier dato almacenado en un fichero en relativamente poco tiempo.

Actualmente, los discos duros tienen una enorme capacidad y son muy rápidos, aunque aún siguen siendo lentos, en comparación con las memorias RAM. El caso de los CD es algo intermedio. En realidad son secuenciales en cuanto al modo de guardar los datos, cada disco sólo tiene una pista de datos grabada en espiral. Sin embargo, este sistema, combinado con algo de memoria RAM, proporciona un acceso muy próximo al de los discos duros.

En cuanto al tipo de acceso, en C y C++ podemos clasificar los archivos según varias categorías:

  1. Dependiendo de la dirección del flujo de datos:
    • De entrada: los datos se leen por el programa desde el archivo.
    • De salida: los datos se escriben por el programa hacia el archivo.
    • De entrada/salida: los datos pueden se escritos o leídos.
  2. Dependiendo del tipo de valores permitidos a cada byte:
    • De texto: sólo están permitidos ciertos rangos de valores para cada byte. Algunos bytes tienen un significado especial, por ejemplo, el valor hexadecimal 0x1A marca el fin de fichero. Si abrimos un archivo en modo texto, no será posible leer más allá de un byte con ese valor, aunque el fichero sea más largo.
    • Binarios: están permitidos todos lo valores para cada byte. En estos archivos el final del fichero se detecta de otro modo, dependiendo del soporte y del sistema operativo. La mayoría de las veces se hace guardando la longitud del fichero. Cuando queramos almacenar valores enteros, o en coma flotante, o imágenes, etc, deberemos usar este tipo de archivos.
  3. Según el tipo de acceso:
    • Archivos secuenciales: imitan el modo de acceso de los antiguos ficheros secuenciales almacenados en cintas magnéticas y
    • Archivos de acceso aleatorio: permiten acceder a cualquier punto de ellos para realizar lecturas y/o escrituras.
  4. Según la longitud de registro:
    • Longitud variable: en realidad, en este tipo de archivos no tiene sentido hablar de longitud de registro, podemos considerar cada byte como un registro. También puede suceder que nuestra aplicación conozca el tipo y longitud de cada dato almacenado en el archivo, y lea o escriba los bytes necesarios en cada ocasión. Otro caso es cuando se usa una marca para el final de registro, por ejemplo, en ficheros de texto se usa el carácter de retorno de línea para eso. En estos casos cada registro es de longitud diferente.
    • Longitud constante: en estos archivos los datos se almacenan en forma de registro de tamaño constante. En C usaremos estructuras para definir los registros. C dispone de funciones de biblioteca adecuadas para manejar este tipo de ficheros.
    • Mixtos: en ocasiones pueden crearse archivos que combinen los dos tipos de registros, por ejemplo, dBASE usa registros de longitud constante, pero añade un registro especial de cabecera al principio para definir, entre otras cosas, el tamaño y el tipo de los registros.

Es posible crear archivos combinando cada una de estas categorías, por ejemplo: archivos secuenciales de texto de longitud de registro variable, que son los típicos archivos de texto. Archivos de acceso aleatorio binarios de longitud de registro constante, normalmente usados en bases de datos. Y también cualquier combinación menos corriente, como archivos secuenciales binarios de longitud de registro constante, etc.

En cuanto a cómo se definen estas propiedades, hay dos casos. Si son binarios o de texto o de entrada, salida o entrada/salida, se define al abrir el fichero, mediante la función fopen en C o mediante el método open de fstream en C++.

La función open usa dos parámetros. El primero es el nombre del fichero que contiene el archivo. El segundo es em modo que es una cadena que indica el modo en que se abrirá el archivo: lectura o escritura, y el tipo de datos que contiene: de texto o binarios.

En C, los ficheros admiten seis modos en cuanto a la dirección del flujo de datos:

  • r: sólo lectura. El fichero debe existir.
  • w: se abre para escritura, se crea un fichero nuevo o se sobrescribe si ya existe.
  • a: añadir, se abre para escritura, el cursor se situa al final del fichero. Si el fichero no existe, se crea.
  • r+: lectura y escritura. El fichero debe existir.
  • w+: lectura y escritura, se crea un fichero nuevo o se sobrescribe si ya existe.
  • a+: añadir, lectura y escritura, el cursor se situa al final del fichero. Si el fichero no existe, se crea.

En cuanto a los valores permitidos para los bytes, se puede añadir otro carácter a la cadena de modo:

  • t: modo texto. Normalmente es el modo por defecto. Se suele omitir.
  • b: modo binario.

En ciertos sistemas operativos no existe esta distinción, y todos los ficheros son binarios.

En C++ es algo diferente, el constructor de las clases ifstream, ofstream y fstream admite los parámetros para abrir el fichero directamente, y también disponemos del método open, para poder crear el stream sin asociarlo con un fichero concreto y hacer esa asociación más tarde.

Buffers

Ya hemos comentado que el acceso a los ficheros es lento, y lo es mucho, comparado con el acceso a memoria. Es por eso que, generalmente, no se accede a ficheros externos cada vez que se realiza una operación de lectura o escritura.

En su lugar, se mantiene una copia de una parte del fichero en la memoria, se realizan las operaciones de lectura/escritura que sea posible dentro de esa zona, y cuando sea necesario, porque alguna operación acceda a posiciones fuera de la zona almacenada, se vuelca esa zona al fichero y se lee otro tramo del fichero en memoria.

A estas zonas se le llaman buffers, y mejoran sensiblemente el acceso a los ficheros en lo que respecta a la velocidad.

Cuanto más grande es un buffer, mejor será el tiempo de acceso al fichero. En el caso ideal, el tamaño del buffer es mayor o igual que el del fichero, y todas las operaciones de lectura y escritura del fichero se realizan en memoria, de modo que sólo es necesario hacer una lectura del fichero y, si se ha modificado, una escritura.

Pero no todo son ventajas. Cuando se trabaja con buffers, las actualizaciones físicas del fichero están diferidas, en relación a las actualizaciones hechas por el programa, de modo que el fichero no siempre tiene una información actualizada.

Esto plantea dos problemas:

  • Si la aplicación termina de forma inesperada, por un error o por una avería, el contenido del buffer modificado no se almacenará en el fichero, y su estructura puede quedar corrupta y los datos inservibles.
  • Cuando un fichero deba ser accedido por varios usuarios de forma simultánea, se pueden presentar problemas de concurrencia. Por ejemplo, un usuario lee una parte del fichero en su buffer, y modifica su contenido. Mientras tanto, otro usuario, desde otra máquina, accede al mismo fichero, y a la misma zona, pero el contenido no está actualizado con las modificaciones realizadas por el primer usuario. El peligro es mayor si los dos están haciendo modificaciones en el mismo fichero, ya que es posible que las modificaciones realizadas por un usuario queden anuladas por las que ha hecho el otro.

El primer caso puede minimizarse, aunque no evitarse siempre, si se guarda el contenido del buffer antes de realizar operaciones potencialmente peligrosas. Aunque nada puede evitar la corrupción de ficheros en caso de avería.

El segundo caso requiere protecciones por parte del sistema operativo o de las aplicaciones que accedan a ficheros compartidos. Estas protecciones van desde las más simples, como la imposibilidad de que un segundo usuario acceda a un fichero abierto, hasta métodos más sutiles, como bloqueo de ficheros, o partes de ficheros. Estos bloqueos asignan una zona del fichero al primer usuario que lo solicite, e impiden a otros usuarios acceder a la misma zona, aunque no a otras.

Cómo funcionan los discos

Para empezar, los discos distribuyen los datos en dos o tres dimensiones. Las cabezas de lectura/escritura se mueven a lo largo del radio del disco, a distancias preestablecidas. Cada una de esas distancias define una pista.

Si la cabeza no se mueve, permanece siempre sobre la misma pista. Dependiendo de la densidad del soporte magnético, las pistas podrán estar más o menos próximas entre si, y por lo tanto, en la misma superficie se podrán almacenar más o menos pistas.

A su vez, cada pista está dividida en partes más pequeñas, llamadas sectores. Cada sector puede almacenar un número determinado de bytes, y de nuevo, dependiendo de la densidad del soporte, cada pista se podrá dividir en más o menos sectores.

Por último, en el caso de los discos duros, cada disco está compuesto en realidad por varios discos llamados platos, cada plato tiene dos caras, y en cada cara se coloca una cabeza de lectura/escritura.

De modo que para acceder a un dato será necesario calcular en qué plato, pista y sector está almacenado, mover la cabeza a la pista adecuada y esperar a que el sector pase por debajo de la cabeza correspondiente al plato indicado.

El tiempo de acceso depende de la capacidad de la cabeza para localizar la pista, del número de sectores por pista (cuantos más haya, mayor será el promedio de tiempo necesario para que un sector pase bajo la cabeza), y de la velocidad de giro del disco.

Parece sencillo localizar una pista, pero no tanto localizar un sector. A fin de cuentas, el disco puede empezar a girar en cualquier posición, y no es posible distinguir donde estaban los sectores la última vez que el disco estuvo girando. Además, en los discos duros actuales se aprovecha mejor el espacio haciendo que las pistas exteriores, con mayor circunferencia, se dividan en más sectores que las interiores. Esto permite aprovechar mejor la densidad del disco, que por supuesto, es uniforme.

Para que sea posible localizar la información en un disco hay que almacenar ciertas marcas en él. Al conjunto de esas marcas se le llama formato y a la acción de hacer esas marcas, se le llama formatear el disco.

En los discos magnéticos, las marcas se almacenan del mismo modo que los datos: mediante campos magnéticos creados por la cabeza de lectura/escritura. En cada pista se almacenan ciertas marcas que indican donde empieza cada sector y que identifican cada una de las pistas y sectores. Esto, por cierto, disminuye el espacio disponible para los datos. Antiguamente se distinguía entre la capacidad bruta del disco, sin descontar el espacio destinado al formato, y la capacidad útil, que es la que nos interesa en realidad.

Otros soportes, como algunos disquetes primitivos, tenían orificios en la superficie del disco que podían ser detectados ópticamente, aunque esto no evitaba que el disco tuviese que tener un formato.

En los discos magneto-ópticos las escrituras se hacen de forma magnética, sobre un disco con dos capas calentado mediante un láser de alta densidad, mientras que las lecturas se hacen de forma óptica, mediante un láser de baja densidad. De modo que estos discos permiten mayor capacidad de almacenamiento, y permiten hacer lecturas muchos más rápidas, aunque la escritura es más lenta.

En los discos duros la estructura es más complicada, ya que existe más de un disco, y las cabezas se sitúan en ambas caras de cada disco. Sin embargo, todas las cabezas se mueven de forma simultánea, aunque las lecturas y escrituras sólo se hacen en una superficie a la vez. Esto hace que el acceso sea más rápido cuantos más platos existan.

La unidad mínima que se puede leer o escribir en un disco es un sector. El tamaño del sector es variable, generalmente son de 512 bytes, pero pueden ser diferentes. El sistema operativo no trabaja directamente con sectores, sino con clusters. Cada cluster tiene un número entero de sectores.

Los clusters son una unidad lógica, no física. En principio se crearon cuando la capacidad de los discos creció hasta el punto que con los protoclos de 16 bits no era posible direccionar todos los sectores. Agrupando sectores seguía siendo posible aprovechar toda la capacidad del disco. Esto volvió a suceder con los protocolos de 32 bits.

Generalmente es mejor que el tamaño de los clusters sea pequeño, ya que de ese modo se aprovecha mejor el espacio de almacenamiento del disco. Si por ejemplo, en un disco de 100KB almacenamos sólo ficheros de 1KB, en teoría podríamos almacenar 100 ficheros. Pero si el tamaño del cluster es de 2KB, el número máximo de ficheros será 50, y si el tamaño del cluster es de 16Kb, sólo podremos almacenar 6. De hecho, en un disco con clusters de 16KB, un fichero de un byte ocupará el mismo espacio que uno de 16KB.

Ficheros que cambian de tamaño

Por supuesto, todo lo explicado anteriormente es muy simple cuando sólo hacemos lecturas o cuando las escrituras no implican que el fichero deba ser más largos o más cortos.

Físicamente, los ficheros sólo pueden crecer por el extremo final. Esto es evidente en el caso de ficheros secuenciales, donde cualquier escritura que no se realize al final implica la sobrescritura de datos previos.

Las limitaciones físicas de los soportes de datos explican por qué no se pueden insertar datos en el interior de un fichero. En teoría se podría insertar un bloque de datos cuyo tamaño sea múltiplo del tamaño del cluster. De ese modo se podrían insertar nuevos clusters dentro del fichero. Pero esto es un caso muy especial, y nunca se hace.

Lo que se hace en realidad es mover el resto del fichero hacia adelante para dejar espacio para la nueva información, o en caso de borrar datos, mover hacia atrás, de modo que se sobrescriban los datos eliminados. De modo que si hay que añadir un byte en la primera posición de un fichero, esto implica que se ha de copiar todo el fichero.

Comentarios de los usuarios (15)

johanna
2011-08-25 18:00:34

MUY BUENO PERO LE FALTAN MAS ESPECIFICACIONES Y EJEMPLOS

OMAR MURCIA
2011-12-07 05:49:03

hola, quiero saber como capturar una variable tipo int o float, y escribirla en un fichero!!! o caso solo puedo capturar variables tipo char???? espero sus respuestas! gracias desde ya!

NOTA: uso la libreria #include <stdio.h>, usando c++;

ejemplo:

#include <iostream>

#include <stdio.h>

using namespace std;

int main()

{

FILE *arch;

arch=fopen("parcial.txt", "a");

char palabras[1000];

float numero;

cout<< "Digite unas Palabras: ";

fgets(palabras, 1000, stdin);

fputs(palabras, arch);

cout<< "Digite un numero: ";

system("pause");

return 0;

}

Steven R. Davidson
2011-12-11 13:04:28

Hola Omar,

Hablamos de las funciones de ANSI C para ficheros en el siguiente capítulo 2: http://c.conclase.net/ficheros/?cap=002#inicio Te adelantamos que deberías usar 'fprintf()' que es de la misma familia que 'printf()', 'sprintf()', y las versiones de "argumentos variables", como 'vprintf()'. La explicación del formato de estas funciones está en el apéndice C de nuestro curso de C++; el enlace es: http://c.conclase.net/curso/index.php?cap=902c#lib_printf Puedes usar 'fprintf()' directamente para escribir la información al fichero como cadenas de caracteres a un fichero de texto.

La otra forma es mantener el formato de la información en memoria y "volcarla" en un fichero binario. Para esto, tendrás que usar 'fwrite()', la cual no tiene formato; simplemente escribe una cantidad de bytes.

En tu código fuente, recuerda que debes cerrar el fichero, previamente abierto, con 'fclose()'.

Espero haber aclarado la duda.

Steven

Jheovany
2012-01-21 18:50:47

A quí está tu respuesta OMAR MURCIA.

http://c.conclase.net/curso/index.php?cap=039#inicio

Contine ejemplos de cómo crear archivos de texto y binarios.

Vaquero
2012-05-22 12:01:50

Hola, me gustaría saber cómo poner al nombre de un fichero lo que hay en una variable, es decir, yo quiero que mi fichero se llame juan_mensajes.txt y ese 'juan' tiene que provenir de una variable char. Gracias!

Salvador Pozo
2012-05-23 14:47:53

Es sencillo Vaquero.

En C, la función fopen, espera como primer argumento una cadena que indica el nombre del fichero. Esa cadena no tiene por qué ser un literal, puede ser una variable.

char nombre[32];
char nombrefichero[64];
FILE *fs;

strcpy(nombre, "juan");
sprintf(nombrefichero, "%s_mensajes.txt", nombre);
fs = fopen(nombrefichero, "w");

En C++ es similar, salvo que usaremos esa cadena (variable) en el constructor o en el método open.

Hasta pronto.

Ale Caceres
2012-07-15 06:35:22

hola me gustaría que me ayudaran en este ejercicio...

Crear dos arreglos, uno unidimensional y el otro bidimensional de 4*2. el primero debe guardar el código de un producto y el segundo debe almacenar en la primera columna la cantidad y el la segunda columna el precio del producto. el sistema debe permitir al usuario realizar una búsqueda por código y mostrar la información y lo tengo que hacer en C++

Cristhian Bazurto
2012-08-22 15:57:04

hola necesito ayuda, quiero recuperar una lista con el uso de ficheros, ejemplo, mi sistema es de registro de personas para un sistema de turnos, bien quiero que cuando ingrese al sistema la lista se llene nuevamente con los datos ingresados al fichero para poder trabajar con esos datos...

José Mulero
2013-03-25 19:47:18

C++

1. Determine the operating system command or procedure provided by your computer to display the contents of a saved file.

Agu
2013-08-23 04:49:57

necesito ayuda con un programa: en un archivo en el que el codcliente se autogenera, es decir el numero debe incrementar de 1 en 1, reg.CodCliente=reg.CodCliente+1, cada vez ke se ingresa a este modulo, pero por alguna razon, el codcliente regresa a 1 si cierro y luego lo vuelvo a abrir al programa. si alguien me puede ayudar muchas gracias

void Agre()

{

system ("cls");

fseek(Clientes, 0, SEEK_END);

fread(&reg, sizeof(struct Clientes1), 0, Clientes);

reg.CodCliente=reg.CodCliente+1;

printf ("El codigo de cliente es: %d \n", reg.CodCliente);

printf ("Ingrese el DNI del nuevo cliente: \n");

scanf ("%d", &reg.DNI);

while (reg.DNI<10000000 || reg.DNI>99999999)

{

printf ("El DNI ingresado es invalido, por favor ingreselo nuevamente\n");

scanf ("%d", &reg.DNI);

}

printf ("Ingrese la fecha de nacimiento del nuevo cliente AAAA/MM/DD: \n");

scanf ("%d", &reg.anio);

scanf ("%d", &reg.mes);

scanf ("%d", &reg.dia);

while (reg.mes>12 || reg.dia>31)

{

if (reg.mes>12)

{

printf ("\nEl mes ingresado es invalido, ingrese un mes valido\n");

scanf ("%d", &reg.mes);

}

if (reg.dia>31)

{

printf ("\nEL dia ingresado es invalido, ingrese un dia valido\n"),

scanf ("%d", &reg.dia);

}

}

while ((reg.mes==2 || reg.mes==4 || reg.mes==6 || reg.mes==7 || reg.mes==9 || reg.mes==11) && (reg.dia>30))

{

printf ("\nLa fecha ingresada no es valida, el dia no concuerda con el mes por favor ingrese el mes y dia nuevamente\n");

scanf ("%d", &reg.mes);

scanf ("%d", &reg.dia);

}

printf ("Ingrese la direccion del nuevo cliente: \n");

fflush (stdin);

gets (reg.Direccion);

printf ("Ingrese el telefono del nuevo cliente \n");

scanf ("%d", &reg.Telefono);

printf ("Ingrese los ingresos del nuevo cliente: \n");

scanf ("%f", &reg.Ingresos);

printf ("Ingrese el apellido y el nombre del nuevo cliente: \n");

fflush (stdin);

gets (reg.ApellidoNombre);

printf ("Desea guardar los datos asignados? (1=SI , 0=NO)");

scanf ("%d", &Elegir);

if (Elegir==1)

{

fseek(Clientes, 0, SEEK_END);

fwrite(&reg, sizeof (struct Clientes1), 1, Clientes);

fclose(Clientes);

}

system ("cls");

}

Steven R. Davidson
2013-08-24 16:17:38

Hola Agu,

El problema es a la hora de leer el registro. Previamente has colocado el cursor de fichero al final, por lo tanto, al encontrarse con el carácter de fin-de-fichero (EOF), la lectura no se realiza y el bit de EOF se activa. Como no hay ninguna lectura, esto implica que 'reg' no es modificada y contendrá su valor original.

Si quieres leer el último registro, tendrás que "retroceder" el cursor del fichero. Por ejemplo,

fseek( Clientes, - sizeof reg, SEEK_END );
fread( &reg, sizeof reg, 1, Clientes );

Como puedes comprobar, he cambiado el valor del tercer parámetro de 'fread()', ya que se debe indicar cuántos registros se pide leer, que es 1, en tu caso.

Espero haber aclarado la duda.

Steven

emmanuel ortega
2013-10-13 21:31:09

ola a todos lo que conforman la cuminidad tengo una duda el problema que tengo que resolver es este

ELABORAR UN PROGRAMA QUE PROCESE VARIOS EMPLEADOS NO SABIENDO CUANTOS SERAN EN TOTAL, PEDIR NOMBRE Y SALARIO SEMANAL Y MOSTRARLOS. AL FINAL MOSTRAR UN TOTAL DE SALARIOS DE TODOS LOS EMPLEADOS.

bueno ya lo resolví a qui esta

#include <cstdlib>

#include <iostream>

using namespace std;

int nt,c;

string nom;

int main(int argc, char *argv[])

{

int i,j,n;

cout<<endl;

cout<<"********************* REPORTE DE EMPLEADOS **********************"<<endl;

cout<<endl;

cout<<"Numero de empleados: ";

cin>>n;

cout<<endl;

for(i=0;i<n;i++)

{

c=c+1;

cout<<"_________________________________________________________________"<<endl;

cout<<endl;

cout<<"nombre del empleado: "<<endl;

cin>>nom;

cout<<endl;

cout<<"sueldo del empleado: "<< c <<": ";

cin>>j;

nt=nt+j;

}

cout<<endl;

cout<<"******************************************************************"<<endl;

cout<<endl;

cout<<"EL TOTAL DE LOS SALARIOS PAGADOS ES DE: "<<nt<<endl;

cout<<endl;

system("PAUSE");

return EXIT_SUCCESS;

}

pero ahora no se como deben de ir la clases espero y me puedan auxiliar

jose valladares
2014-06-13 04:58:38

nesecito ayuda no se como estructurar un afuncion de calcular la mora

Paul
2014-08-06 08:45:22

Tengo una duda muy grande, ya que necesito trabajar con un archivo de texto cuyas columnas tienen más de 900.000 datos!!. Lo que hice hasta el momento fue utilizar strings, pero la cantidad de filas en este archivo supera con creces la capacidad máxima de los strings, entonces el programa se cae. Leí en algún foro cómo se puede separar el archivo en bloques, pero la verdad es que no me sirve esa opción. Sabrán de alguna manera de poder trabajar con esos datos?

Saludos y espero puedan ayudarme :)

miguel perez
2014-12-03 06:30:37

hola tengo un error en el encriptador hill ayudaaa

/*

* Encriptador.cpp

*

* Created on: 10/09/2010

* Author: julfc

*/

#include "Encriptador.h"

Encriptador::Encriptador() {

ManejadorConfiguracion mc;

vector<string> parametros = mc.obtenerParamsLibspopc();

string claveMatriz = parametros[1] + parametros[2];

int h1 = Hash1(claveMatriz);

int h2 = Hash2(claveMatriz);

//TODO: Obtener de la configuracion el tamanio de la matriz

this->tamanioMatriz = getTamanioMatriz();

Matriz matriz = Matriz(h1,h2,this->tamanioMatriz);

this->matriz = matriz;

this->matrizInversa = Matriz(tamanioMatriz);

this->matrizInversa.matriz = matriz.calcularInversaLoca();

// Matriz matriz = Matriz(h1,h2,this->tamanioMatriz);

// this->matriz = matriz;

// cout<< "matriz" << endl;

// cout<< endl;

// this->matriz.ImprimirMatriz();

// cout<< endl;

// cout<< "matriz inversa" << endl;

// cout<< endl;

// this->matrizInversa = Matriz(tamanioMatriz);

// this->matrizInversa.matriz = matriz.calcularInversaLoca();

// this->matrizInversa.ImprimirMatriz();

// cout << endl;

// cout << "Encriptando la palabra pez" << endl;

// char* res= this->Encriptar("PUTitoPUTitoAAAA");

// cout << "\n\n Bloque encriptado fianl: " << res << endl;

// char* palabra = this->Desencriptar(res);

// cout << "\n\nLa palabra desencriptada es: " << palabra;

}

int Encriptador::getTamanioMatriz() {

return 8;

}

long Encriptador::getTamanioBloque() {

ManejadorConfiguracion mc;

long tam_bloques = mc.obtenerTamanioBloque() * mc.BYTES_IN_KB;

return tam_bloques;

}

int Encriptador::Hash1(string clave){

int aux = (int)clave[5];

if ((aux % 2) == 0)

return aux + 1;

else

return aux;

}

int Encriptador::Hash2(string clave){

int aux = (int)clave[6];

if ((aux % 2) == 0)

return aux + 1;

else

return aux;

}

char* Encriptador::Encriptar(char* bloque) {

char* bloqueIterador = bloque;

ManejadorConfiguracion mc;

long tam_bloques = getTamanioBloque();

long i = 0;

vector<unsigned char> bloquecito;

vector<unsigned char> bloquecitoEncriptado;

unsigned char byteBloque;

//string bloqueEncriptado;

char* charEnc = (char*) malloc(tam_bloques + 1);

memset(charEnc, 0, tam_bloques);

charEnc[tam_bloques]='\0';

char* auxCharEnc = charEnc;

while(i < tam_bloques) {

memcpy(&(byteBloque), bloqueIterador, sizeof(unsigned char));

bloqueIterador+=sizeof(unsigned char);

bloquecito.push_back(byteBloque);

if((i + 1) % this->tamanioMatriz == 0) {

bloquecitoEncriptado = this->Hill(bloquecito);

//Hago append en el bloque encriptado del bloquecitoEncriptado

//char enc[bloquecitoEncriptado.size()];

for(unsigned int j = 0; j < bloquecitoEncriptado.size(); j++) {

unsigned char auxCharBlocEnc = bloquecitoEncriptado[j];

memcpy(auxCharEnc, &auxCharBlocEnc, sizeof(unsigned char));

auxCharEnc+= sizeof(unsigned char);

}

bloquecito.clear();

bloquecitoEncriptado.clear();

}

i++;

}

//cout << bloqueEncriptado << endl;

return charEnc;

}

vector<unsigned char> Encriptador::Hill(vector<unsigned char> bloquecito) {

//Como encripta Hill:

// Tengo un ascii

// Lo paso a entero

// Lo encripto y me da un numero entro 0 y 255 (por el Mod 256)

// Lo paso a ascii de vuelta y lo guardo en lugar del otro

vector<unsigned int> bloquecitoaEncriptar;

vector<unsigned char> bloquecitoResultante;

for (unsigned int i=0; i < bloquecito.size(); i++) {

unsigned int nroEnc = bloquecito[i];

bloquecitoaEncriptar.push_back(nroEnc);

}

vector<unsigned int> bloquecitoEncriptado = this->matriz.ObtenerVector(bloquecitoaEncriptar);

for (unsigned int i=0; i < bloquecitoEncriptado.size(); i++) {

//cout << bloquecitoEncriptado[i] << endl;

unsigned char encChar = bloquecitoEncriptado[i];

bloquecitoResultante.push_back(encChar);

}

// for (unsigned int i=0; i< bloquecitoResultante.size(); i++) {

// cout << bloquecitoResultante[i] << endl;

// }

return bloquecitoResultante;

}

vector<unsigned char> Encriptador::UnHill(vector<unsigned char> bloquecitoEncriptado){

vector<unsigned int> bloquecitoaDesEncriptar;

vector<unsigned char> bloquecitoResultante;

//cout << "\nDesencripto...\n";

for (unsigned int i=0; i < bloquecitoEncriptado.size(); i++){

unsigned int desencChar = bloquecitoEncriptado[i];

bloquecitoaDesEncriptar.push_back(desencChar);

//cout << desencChar << endl;

}

vector<unsigned int> bloquecitoDesEncriptado = this->matrizInversa.ObtenerVectorAlVerres(bloquecitoaDesEncriptar);

for(unsigned int i=0; i< bloquecitoDesEncriptado.size(); i++){

//cout << bloquecitoDesEncriptado[i] << endl;

bloquecitoResultante.push_back((unsigned char)(bloquecitoDesEncriptado[i]));

}

// for(unsigned int i=0; i< bloquecitoDesEncriptado.size(); i++){

// cout << bloquecitoResultante[i];

// }

return bloquecitoResultante;

}

char* Encriptador::Desencriptar(char* bloqueEncriptado) {

char* bloqueIterador = bloqueEncriptado;

ManejadorConfiguracion mc;

long tam_bloques = getTamanioBloque();

long i = 0;

vector<unsigned char> bloquecito;

vector<unsigned char> bloquecitoDesEncriptado;

unsigned char byteBloque;

//string bloqueDesEncriptado;

char* charDesnc = (char*) malloc(tam_bloques + 1);

memset(charDesnc, 0, tam_bloques);

charDesnc[tam_bloques]='\0';

char* auxCharDesEnc = charDesnc;

while(i < tam_bloques) {

memcpy(&(byteBloque), bloqueIterador, sizeof(unsigned char));

bloqueIterador+=sizeof(unsigned char);

bloquecito.push_back(byteBloque);

if((i + 1) % this->tamanioMatriz == 0) {

bloquecitoDesEncriptado = this->UnHill(bloquecito);

//Hago append en el bloque encriptado del bloquecitoEncriptado

// for(unsigned int j = 0; j < bloquecitoDesEncriptado.size(); j++) {

// unsigned char auxCharBlocDesEnc = bloquecitoDesEncriptado[j];

// bloqueDesEncriptado+=auxCharBlocDesEnc;

// }

for(unsigned int j = 0; j < bloquecitoDesEncriptado.size(); j++) {

unsigned char auxCharBlocDesEnc = bloquecitoDesEncriptado[j];

memcpy(auxCharDesEnc, &auxCharBlocDesEnc, sizeof(unsigned char));

auxCharDesEnc+= sizeof(unsigned char);

}

bloquecito.clear();

bloquecitoDesEncriptado.clear();

}

i++;

}

//cout << bloqueDesEncriptado << endl;

//return (char*)bloqueDesEncriptado.c_str();

return charDesnc;

}

Encriptador::~Encriptador() {

}