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:
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:
En cuanto a los valores permitidos para los bytes, se puede añadir otro carácter a la cadena de modo:
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.
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:
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.
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.
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.
MUY BUENO PERO LE FALTAN MAS ESPECIFICACIONES Y EJEMPLOS
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;
}
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
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.
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!
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.
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++
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...
C++
1. Determine the operating system command or procedure provided by your computer to display the contents of a saved file.
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(®, 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", ®.DNI);
while (reg.DNI<10000000 || reg.DNI>99999999)
{
printf ("El DNI ingresado es invalido, por favor ingreselo nuevamente\n");
scanf ("%d", ®.DNI);
}
printf ("Ingrese la fecha de nacimiento del nuevo cliente AAAA/MM/DD: \n");
scanf ("%d", ®.anio);
scanf ("%d", ®.mes);
scanf ("%d", ®.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", ®.mes);
}
if (reg.dia>31)
{
printf ("\nEL dia ingresado es invalido, ingrese un dia valido\n"),
scanf ("%d", ®.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", ®.mes);
scanf ("%d", ®.dia);
}
printf ("Ingrese la direccion del nuevo cliente: \n");
fflush (stdin);
gets (reg.Direccion);
printf ("Ingrese el telefono del nuevo cliente \n");
scanf ("%d", ®.Telefono);
printf ("Ingrese los ingresos del nuevo cliente: \n");
scanf ("%f", ®.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(®, sizeof (struct Clientes1), 1, Clientes);
fclose(Clientes);
}
system ("cls");
}
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( ®, 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
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
nesecito ayuda no se como estructurar un afuncion de calcular la mora
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 :)
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() {
}
hola quisiera saber como hacer un programa de abrir y cerrar
como diseñar un algoritmo y programa que lea los datos de un alumno y que comparando su edad imprima si es mayor de edad o menor de edad
Como realizar un ordenamiento de archivos binarios, por ejemplo ordenar por nombre y apellido y a igual nombre y apellido ordenar por código de cliente.
Espero sus comentarios.
Gracias.
Hola... Me podrian ayudar en un programa en c, que te de el nombre,nombre secundario (apodo) y una contraseña... pero que la contraseña la encripte en la terminal y te guarde todo en un fichero donde hay este el nombre, el nombre secundario y la contraseña original.... Gracias
por favor alguien me puede ayudar como crear un archivo en el bloc de notas
luego desde el c++ tienes q crear un algoritmo q busque ese archivo lo modifique y vuelvas a guardarlo por favor soy nueva en esto
Hola
tengo un problema estoy estudiando Archivos y Achivos de Texto en c++; pero me he topado con el problema que no entiendo muy bien :s; encontré este ejercicio en la red pero la verdad ni idea de como codificarlo, así que agradecería mucho que me orienten en el código de esté en c++.
El departamento de Robótica de una compañía tiene varios tipos de robots. Para cada robot se tiene un archivo de texto secuencial (Archivo 1) que contiene los registros de las órdenes válidas formadas por 2 campos:
el campo parte (cabeza, manos, brazos, piernas, pies,etc.) del robot y
el campo movimiento (derecha, izquierda, arriba, abajo, etc.) de la parte
Este archivo contiene registros ordenados por el campo parte (puede estar duplicado!). Por otra parte, la interfaz del robot puede ingresar todas las combinaciones de partes y movimientos a través del Archivo 2, pero para cada tipo de robot el Archivo 1 determina sus movimientos válidos. El Archivo 2, entonces expresa los requerimientos del usuario para intentar mover el robot y contiene la misma estructura que el Archivo 1 con la diferencia que contiene movimientos válidos e inválidos desordenados del robot. Se quiere que ud., procese los archivos de texto secuencial para que:
Implemente un validador: dado como parámetros el Archivo 1 y Archivo 2, diga si el Archivo 2 es válido o inválido según el Archivo 1.
Implemente un filtro: dado como parámetros el Archivo 1 y Archivo 2, genere la partición del Archivo 2 en dos archivos de salidas: Ordenes Válidas y Ordenes Inválidas, según el Archivo 1.
que tal mi gente, tengo un ejercicio, creo sencillo, en el que realizo un ciclo "for" para calcular el valor de una funcion seno; la idea del ejercicio es escribir en un archivo .txt, de ser posible, el resultado de dicho calculo, tabularlo mejor dicho, de tal forma que luego pueda leerlo con otro programa para realizar una grafica de ser posible.
les muestro lo que tengo:
#include <stdio.h> #include <math.h> #include <string.h> #include <stdlib.h> double x; char seno; int main() { FILE *senMP2; senMP2 = fopen("sen.txt", "a"); //for( ; ; ) //{ for( x = 0; x < 2*M_PI; x = x + (M_PI)/8 ) { seno=sin(x); printf( " %f %f | %i\n", x, sin(x), seno ); fputc(seno, senMP2); } //} fclose(senMP2); return 0; }
el ciclo for que esta comentado era para crear un loop infinito, solo por caracter de estudio, como pueden ver tengo una base de donde partir para crear un archivo, lamentablemente no me genera un archivo coherente, lo que deseo es que me resulte un archivo donde se distinga algo asi:
0.000000
0.382683
0.707107
0.923880
1.000000
0.923880
0.707107
0.382683
0.000000
-0.382683
-0.707107
-0.923880
-1.000000
-0.923880
-0.707107
-0.382683
si les causa curiosidad de que se trata el proyecto, intento simular una onda senoidal de la corriente y el voltaje, por ello los valores oscilan entre 1, 0 y -1
Hola Luis,
Tienes algunos errores y matices a destacar:
- No uses variables globales, sino favorece locales. Escribe,
int main() { double x; char seno; ... }
- La constante simbólica, 'M_PI', no es estándar, aunque sí es popular.
- Acostumbra a usar el operador +=; por ejemplo,
for( x = 0; x < 2*M_PI; x += (M_PI)/8 ) ...
- Intentas asignar un 'double' a un 'char'. Esto no es correcto ni es lógico. Sospecho que querías convertir la información a una cadena de caracteres. Para esto, necesitas un array de 'char' y no una simple variable de tipo 'char'. Además, el lenguaje no sabe cómo convertir 'double' a una cadena de caracteres. La solución es usar una función estándar, como 'atof()'. Sin embargo, como quieres escribir esta cadena a un fichero de texto, entonces usa 'fprintf()'. Por ejemplo,
for( x = 0; x < 2*M_PI; x += (M_PI)/8 ) fprintf( senMP2, "%f\n", sin(x) );
No hace falta definir 'seno'.
Espero que esto te ayude.
Steven
Si en clipper los ficheros de datos son .DBF
¿Cuales son los ficheros de datos en C?
me gustaria un programa sencillo como ejemplo para crear ficheros de datos en C.
Por ejemplo.
Crear un fichero de datos que contenga.
No_Id
Nombre
Apellido
Direcion
Edad
Sueldo
Y poder hacer hacer las operaciones basicas de almacenar nuevo registro, consultar, modificar o eliminar registro existente
Gracias...
Hola Fridgar,
Un fichero de datos en C/C++ depende del formato que requiera el programa. En otras palabras, no existe un formato específico para C/C++ ni tampoco una extensión exclusiva al nombre del fichero. Diseña el formato que quieras con el nombre que quieras.
Como se explica en este curso de Archivos, existen diferentes estrategias dependiendo de las necesidades. Principalmente, debes decidir si describir los datos con una cantidad fija de bytes o variable. También podríamos clasificar el formato si es en binario o en texto; si es en texto, tenemos que interpretar las cadenas de caracteres y convertirlas a los datos que interesa. Una vez que tengas los datos representados correctamente, entonces puedes crear las funciones para realizar las operaciones básicas que te interesan: creación, eliminación, modificación o actualización, y consulta (sólo lectura).
En resumen, tienes que diseñar la organización de datos del fichero y luego crear las funciones para leer y escribir los datos de tal fichero. Dependiendo de la organización de los datos, es posible que tengas que interpretar el contenido del fichero para tu propósito.
Por último, aclaramos que Clipper es un lenguaje de programación de bases de datos, mientras que C/C++ son lenguajes de programación de propósito general. Por lo tanto, Clipper hace uso de ficheros de bases de datos, mientras que C/C++ sirve para crear programas ejecutables que pueden o no usar ficheros externos.
Espero que esto te oriente.
Steven
© Julio de 2001, Salvador Pozo Coronado, salvador@conclase.net