void consulta()
{
Libro lib;
char codigo[7];
long posicion;
if(fh == NULL) fh = fopen(fich, "rb+");
printf("Código: "); fgets(codigo, 7, stdin);
posicion = hash(codigo);
posicion = desplazamiento(posicion);
fseek(fh, posicion, SEEK_SET);
fread(&lib, sizeof(Libro), 1, fh);
if(strcmp(lib.codigo, codigo) == 0)
escribir(lib);
else
{
int posicion;
posicion = indexSinonimo(codigo);
if(posicion != -1)
{
fseek(fh, -sizeof(Libro), SEEK_CUR);
fread(&lib, sizeof(Libro), 1, fh);
escribir(lib);
} else
puts("No se encuentra un ejemplar con ese código.");
}
}
void Logger::ponerFecha(){
time_t fecha;
time ( &fecha);
string sfecha = ctime (&fecha);
string guion = "-----------------------------------------------------------------";
escribir(guion);
sfecha.append(guion);
escribir(sfecha);
}
/*
* Escribe dato en el socket cliente. Devuelve numero de bytes escritos,
* o -1 si hay error.
*/
int enviarDatos(int socket, char** datos, uint32_t tamanio, char op) {
int escrito = 0;
/*
* Comprobacion de los parametros de entrada
*/
if ((socket == -1) || (*datos == NULL )|| (tamanio < 1))return -1;
/* HEADER
* Se envian primero los datos necesarios que dan informacion
* sobre el verdadero buffer a enviar
*/
char* buffer = malloc(tamanio + sizeof(char)+sizeof(uint32_t)); //1B de op y 4B de long
memcpy(buffer, &op, sizeof(char));
memcpy(buffer + sizeof(char), &tamanio, sizeof(uint32_t));
memcpy(buffer + sizeof(char)+sizeof(uint32_t), *datos, tamanio);
/*
* Envio de Buffer [tamanio B]
*/
escrito = escribir(socket, buffer, tamanio + sizeof(char)+sizeof(uint32_t));
free(buffer);
/*
* Devolvemos el total de caracteres leidos
*/
return escrito;
}
int main(int argc, const char * argv[])
{
int tuberia[2];
pid_t pid;
pipe(tuberia);
pid = fork();
if (pid == -1)
{
printf("Error al crear el proceso hijo");
exit(-1);
}
else if (pid == 0)
{
/* Hijo */
close(tuberia[1]);
printf(" Soy el hijo y estoy leyendo ... \n");
leer(tuberia[0]);
}
else {
/* Padre */
close(tuberia[0]);
printf(" Soy el padre y estoy escribiendo ... \n");
escribir(tuberia[1]);
}
return 0;
}
void principal::on_pushButton_8_clicked(){
QFile archivo1("/home/jossy/proyecto/llenados.txt");
archivo1.open(QIODevice::WriteOnly | QIODevice::Truncate);
QFile archivo("/home/jossy/proyecto/base09.txt");
archivo.open(QIODevice::WriteOnly | QIODevice::Truncate); //
QTextStream escribir(&archivo);
QTextStream escribir1(&archivo1);
for(int i=0; i<lista.size();i++){
QString txt= lista[i]->getplaca()+","+lista[i]->getmarca()+","+QString::number(lista[i]->getcilindraje());
escribir << txt <<endl;
QString subtxt =lista[i]->getplaca();
for(int r=0; r<lista[i]->getLista().size();r++){
subtxt +=lista[i]->getLista()[r].toString();
}
escribir1 << subtxt <<endl;
}
archivo.close();
archivo1.close();
QMessageBox::about(this,"Control","Grabado con exito");
}
void venta()
{
Libro libar;
char codigo[7], r;
long posicion;
if (fh == NULL) fh = fopen(fich, "rb+");
printf("Código: "); fgets(codigo, 7, stdin);
posicion = hash(codigo);
posicion = desplazamiento(posicion);
fseek(fh, posicion, SEEK_SET);
fread(&libar, sizeof(Libro), 1, fh);
if(strcmp(libar.codigo, codigo) != 0)
posicion = indexSinonimo(codigo);
if(posicion != -1)
{
escribir(libar);
printf("¿Son correctos los datos? (S/N): ");
if (toupper(r) == 'S')
{
strcpy(libar. codigo, " *");
fseek(fh, -sizeof(Libro), SEEK_CUR);
fwrite(&libar, sizeof(Libro), 1, fh);
}
} else {
puts("No se encuentra un registro con ese código.");
}
fflush(fh);
}
void principal::on_pushButton_5_clicked()
{
llenado n (ui->fechag->text(),ui->splp->value(),ui->splitro->value(),ui->spkilometro->value());
lista[::posicion]->setLista(n);
QMessageBox::about(this,"Se Cargo Gasolina al Carro con placa: ",ui->txtbusca->text());
QFile archivo1("/home/jossy/proyecto/llenados.txt");
archivo1.open(QIODevice::WriteOnly | QIODevice::Truncate);
QFile archivo("/home/jossy/proyecto/base09.txt");
archivo.open(QIODevice::WriteOnly | QIODevice::Truncate); //
QTextStream escribir(&archivo);
QTextStream escribir1(&archivo1);
for(int i=0; i<lista.size();i++){
QString txt= lista[i]->getplaca()+","+lista[i]->getmarca()+","+QString::number(lista[i]->getcilindraje());
escribir << txt <<endl;
QString subtxt =lista[i]->getplaca();
for(int r=0; r<lista[i]->getLista().size();r++){
subtxt +=lista[i]->getLista()[r].toString();
}
escribir1 << subtxt <<endl;
ui->pushButton_5->setEnabled(false);
}
archivo.close();
archivo1.close();
QMessageBox::about(this,"Control","Guardado con exito");
ui->txtbusca->setText("");
ui->splp->setValue(0);
ui->splitro->setValue(0);
ui->spkilometro->setValue(0);
}
void Guerrero ::guardarDatos(){
ofstream escribir("Personajes",ios::app);
escribir<<this->tipo<<endl;
escribir<<this->vida<<endl;
escribir<<this->ataque<<endl;
escribir.close();
}
int main(void) {
escribir();
leer();
multiplicar();
leer();
return 0;
}
int main() {
/*
ESCRITURA FICHEROS
*/
//Abrir fichero.
int fd512 = abrir("/FICHEROS/lectura/fichero_mul_child512", T_FICHERO);
printf("escribir_fichero_mul_child(%d) -> fd = %d", obtener_id_proceso(), fd512);
if(fd512 < 0) {
printf("escribir_fichero_mul_child(%d) -> Error al abrir fichero origen fichero_mul_child512\n", obtener_id_proceso());
return -1;
}
//Llenar bloque.
char buffer512[512];
char letra = (char) ('A' + obtener_id_proceso());
llenar_bloque(letra, buffer512, 512);
//Escribir bloque.
int escritos512 = escribir(fd512, buffer512, 512);
printf("escribir_fichero_mul_child(%d) -> Escritos(512%c): %d\n", obtener_id_proceso(), letra, escritos512);
//Cerrar fichero.
cerrar(fd512);
/*
SINCRONIZADO DISCOFS
*/
printf("escribir_fichero_mul_child(%d) -> Sincronizando el volumen montado en /FICHEROS/lectura\n", obtener_id_proceso());
if(sincronizar("lectura") < 0) {
printf("escribir_fichero_mul_child(%d) -> Error al sincronizar el volumen\n", obtener_id_proceso());
}
return 0;
}
void* escritor(){
while(1){
sem_wait(®ioncriticaVacia);
escribir();
sem_post(®ioncriticaVacia);
sleep(1);
}
}
void leer(int sem){
int c, i;
while(1){
c = semctl(sem,0,GETVAL,s);
printf("Se recibió el número: %d y su factorial es: %d \n", c, factorial(c));
escribir(sem);
if(c == -1) break;
}
}
int sendRSAkey(int sockfd, EVP_PKEY* pubKey){
char* buffKey = NULL;
int bufflen = 0;
if(!RSApubKeyToMsg(pubKey, &buffKey, &bufflen)) return 0;
escribir(sockfd, buffKey, bufflen);
free(buffKey);
return 1;
}
void mostrar (tlista l){
tposicion p;
for (p = l; p != NULL; p = p->sig) {
escribir(p->elemento);
}
}
int main(){
int pid = fork();
if(pid == 0){
char** arg = NULL;
execv("hijo",arg);
}else{
escribir('a');
}
sleep(1);
leer();
return 0;
}
int
main(int argc, char *argv[]){
int p[2];
char *argumento;
argumento = argv[1];
crearHijos(p);
escribir(argumento,p);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[]) {
FILE *fichero;
char sopa[NMAX][NMAX];
int opcion;
char nombre_de_fichero[0x20];
srand(time(NULL));
int sopa_cargada = 0; // 0 equivale a falso, cualquier cosa != 0 es verdadero
do {
switch(opcion = leer_menu()) {
case crear:
cabecera("Nueva Sopa");
rellenar(sopa);
sopa_cargada = 1;
pintar(sopa);
break;
case abrir:
imprimir_directorio("./");
printf("Elige un fichero sopa: ");
scanf(" %s", nombre_de_fichero);
fichero = fopen(nombre_de_fichero, "r");
leer(fichero, sopa);
sopa_cargada = 1;
fclose(fichero);
break;
case ver:
if (sopa_cargada) {
cabecera("Sopa Activa");
pintar(sopa);
} else
inform("De momento no hay ninguna sopa cargada.");
break;
case guardar:
if (sopa_cargada) {
imprimir_directorio("./");
printf("Elige un nombre para guardar la sopa: ");
scanf(" %s", nombre_de_fichero);
fichero = fopen(nombre_de_fichero, "w");
escribir(fichero, sopa);
fclose(fichero);
inform("Fichero Guardado.");
} else
inform("De momento no hay ninguna sopa cargada.");
break;
}
} while(opcion != salir);
return EXIT_SUCCESS;
}
void principal::on_pushButton_clicked()
{
bool Existe=false;
for(int i=0; i<lista.size();i++){
if(ui->placa->text()==lista[i]->getplaca()){
Existe=true;
}
}
if(Existe==true){
QMessageBox::about(this,"Control de Seguridad","Ya Existe Ese Numero de Placa");
}else{
if(ui->placa->text()=="" || ui->marca->text()==""){
QMessageBox::about(this,"Control de Seguridad","No debe dejar atributos vacios");
}else{
Carros* car = new Carros(ui->cilin->value(),ui->placa->text(),ui->marca->text(),"");
lista.push_back(car);
QFile archivo1("/home/jossy/proyecto/llenados.txt");
archivo1.open(QIODevice::WriteOnly | QIODevice::Truncate);
QFile archivo("/home/jossy/proyecto/base09.txt");
archivo.open(QIODevice::WriteOnly | QIODevice::Truncate); //
QTextStream escribir(&archivo);
QTextStream escribir1(&archivo1);
for(int i=0; i<lista.size();i++){
QString txt= lista[i]->getplaca()+","+lista[i]->getmarca()+","+QString::number(lista[i]->getcilindraje());
escribir << txt <<endl;
QString subtxt =lista[i]->getplaca();
for(int r=0; r<lista[i]->getLista().size();r++){
subtxt +=lista[i]->getLista()[r].toString();
}
escribir1 << subtxt <<endl;
}
archivo.close();
archivo1.close();
QMessageBox::about(this,"Control","Guardado con exito");
ui->placa->setText("");
ui->marca->setText("");
ui->cilin->setValue(2);
}
}
}
void principal::on_pushButton_7_clicked(){
QFile archivo("/home/jossy/proyecto/base09.txt");
archivo.open(QIODevice::ReadOnly | QIODevice::Text);
QTextStream escribir(&archivo);
QString line;
while (!escribir.atEnd()){
line = escribir.readLine();
qDebug() << "linea: "<<line;
QRegExp rx(",");
QStringList query = line.split(rx);
Carros* car = new Carros(query[2].toInt(0,10),query[0],query[1],"");
lista.push_back(car);
}
QFile archivo1("/home/jossy/proyecto/llenados.txt");
archivo1.open(QIODevice::ReadOnly | QIODevice::Text);
QTextStream escribir1(&archivo1);
QString line1;
while (!escribir1.atEnd()){
line1 = escribir1.readLine();
QRegExp rx1(":");
QStringList query1 = line1.split(rx1);
for(int q=0;q<lista.size();q++){
if(lista[q]->getplaca()==query1[0]){
for(int o=0;o<query1.size();o++){
if(o>0){
QRegExp rx2(",");
QStringList query2 = query1[o].split(rx2);
qDebug() << "sub listas"<<query2;
llenado n (query2[0],query2[1].toDouble(0),query2[2].toDouble(0),query2[3].toDouble(0));
lista[q]->setLista(n);
}
}
}
}
}
}
int main (int argc, const char * argv[]){
pid_t pid;
int estado;
key_t llave;
int idSemaforo;
llave = ftok("/tmp/testSem", 'S');
idSemaforo = semget(llave, 'S', 0666 | IPC_CREAT);
pid = fork();
if(pid == -1) printf("Error al crear el hijo\n");
else if(pid == 0) escribir(idSemaforo);
else{
wait(&estado);
leer(idSemaforo);
}
return 0;
}
void principal::on_pushButton_12_clicked()
{
if(ui->marca_3->text()=="" || ui->placa_3->text()==""){
QMessageBox::about(this,"Control","Ocurrio un Error \n No puede dejar espacios en blacos o Debe seleccionar un Vehiculo");
}else{
lista[posicion]->setmarca(ui->marca_3->text());
lista[posicion]->setplaca(ui->placa_3->text());
lista[posicion]->setcilindraje(ui->spcilin_2->value());
QMessageBox::about(this,"Comtrol de Cambio","::Los combios fueron guardados con exito:::");
QFile archivo1("/home/jossy/proyecto/llenados.txt");
archivo1.open(QIODevice::WriteOnly | QIODevice::Truncate);
QFile archivo("/home/jossy/proyecto/base09.txt");
archivo.open(QIODevice::WriteOnly | QIODevice::Truncate); //
QTextStream escribir(&archivo);
QTextStream escribir1(&archivo1);
for(int i=0; i<lista.size();i++){
QString txt= lista[i]->getplaca()+","+lista[i]->getmarca()+","+QString::number(lista[i]->getcilindraje());
escribir << txt <<endl;
QString subtxt =lista[i]->getplaca();
for(int r=0; r<lista[i]->getLista().size();r++){
subtxt +=lista[i]->getLista()[r].toString();
}
escribir1 << subtxt <<endl;
}
archivo.close();
archivo1.close();
QMessageBox::about(this,"Control","Guardado con exito");
ui->marca_3->setText("");
ui->placa_3->setText("");
ui->spcilin_2->setValue(2);
ui->combo->clear();
for(int i=0; i<lista.size();i++){
ui->combo->addItem(lista[i]->getplaca());
}
}
}
void principal::on_pushButton_2_clicked()
{
QMessageBox::StandardButton mensaje;
mensaje = QMessageBox::question(this, "Control de eliminacion", "Seguro de Eliminar",
QMessageBox::Yes|QMessageBox::No);
if (mensaje == QMessageBox::Yes) {
lista.erase(lista.begin()+::posicion);
QMessageBox::about(this,"Control de Eliminacion","Fue eliminado");
QFile archivo1("/home/jossy/proyecto/llenados.txt");
archivo1.open(QIODevice::WriteOnly | QIODevice::Truncate);
QFile archivo("/home/jossy/proyecto/base09.txt");
archivo.open(QIODevice::WriteOnly | QIODevice::Truncate); //
QTextStream escribir(&archivo);
QTextStream escribir1(&archivo1);
for(int i=0; i<lista.size();i++){
QString txt= lista[i]->getplaca()+","+lista[i]->getmarca()+","+QString::number(lista[i]->getcilindraje());
escribir << txt <<endl;
QString subtxt =lista[i]->getplaca();
for(int r=0; r<lista[i]->getLista().size();r++){
subtxt +=lista[i]->getLista()[r].toString();
}
escribir1 << subtxt <<endl;
}
archivo.close();
archivo1.close();
ui->combo_2->clear();
for(int i=0; i<lista.size();i++){
ui->combo_2->addItem(lista[i]->getplaca());
}
} else {
QMessageBox::about(this,"Control de Eliminacion","Proceso Cancelado");
}
ui->detalles_2->setText("");
}
int sendRSAsign(int sockfd, EVP_PKEY* privKey,
const unsigned char* msg, int msglen){
unsigned char* buff = NULL;
size_t slen = 0;
/*CONTROL DE ERRORES*/
if(privKey == NULL || msg == NULL || msglen <= 0){
return 0;
}
/*SE FIRMA EL MENSAJE*/
if (1 != signMsgRSA(privKey, msg, &buff, &slen, msglen)){
return 0;
}
buff = realloc(buff, sizeof(char) * (msglen + slen));
memcpy(&buff[slen], msg, msglen);
if(-1 == escribir(sockfd, (char*)buff, slen + msglen)){
return 0;
}
return 1;
}
int main(int argc, const char * argv[])
{
int tuberia[2];
pid_t pid;
pipe(tuberia);
pid = fork();
if (pid == -1)
{
printf("Error al crear el proceso hijo");
return 1;
}
else if (pid == 0)
{
leer(tuberia);
}
else {
escribir(tuberia);
}
return 0;
}
int main(){
char origen[MAX_STRING];
char buffer[TAM_BUFFER];
int escritos;
int ret;
int fd_origen;
printf("Montando el disco en la particion /FICHEROS/lectura con discoFS\n");
ret=montar("disco", "lectura", "discoFS");
if (0 > ret) {
printf("escribir_fichero: Error al montar particion lectura en disco con discoFS\n");
}
/* obtener los nombre de los ficheros */
printf("Introduzca el fichero destino EJ: /FICHEROS/lectura/datos:");
scanf("%s",origen);
/* abrir fichero origen */
fd_origen = abrir (origen,T_FICHERO);
if (0 > fd_origen) {
printf("escribir_fichero: Error al abrir fichero destino %s\n", origen);
return (-1);
}
llenar_bloque('A', buffer);
escritos = escribir(fd_origen,buffer,TAM_BUFFER);
printf("%d\n", escritos);
cerrar(fd_origen);
return (0);
}
// Hilo encargado de la ejecución de los procesos
void ejecutarProceso(proceso *procesoActual){
int shmid, datosID,llaveSegmento, contadorLinea, tipo;
char *prefijo = (char*)malloc(TAMANIO_LINEAS);
char *prefijoLog = (char*)malloc(TAMANIO_LINEAS);
char *shm;
datos *segmentoDatos;
sem_t *mutex,*semDatos;
int tamanioMem;
char *tipoProceso = (char*)malloc(30);
tipo = procesoActual->tipo;
switch(procesoActual->tipo){
case TIPO_WRITER:
sprintf(tipoProceso,"%s", WRITER);
sprintf(prefijo,"1|%s|%3d",WRITER,procesoActual->id);
sprintf(prefijoLog,"%s|%3d",WRITER,procesoActual->id);
llaveSegmento = LLAVE_SEGMENTO_WRITERS;
break;
case TIPO_READER:
sprintf(tipoProceso, "%s", READER);
sprintf(prefijoLog,"%s|%3d",READER,procesoActual->id);
llaveSegmento = LLAVE_SEGMENTO_READERS;
break;
case TIPO_READER_EGOISTA:
sprintf(tipoProceso, "%s", READER_EGOISTA);
sprintf(prefijoLog,"%s|%3d",READER_EGOISTA,procesoActual->id);
llaveSegmento = LLAVE_SEGMENTO_READERS_EGOISTAS;
break;
default:
break;
}
if(shmid = getMemID(LLAVE_SEGMENTO,NULL)){
datosID = getMem(LLAVE_SEGMENTO_DATOS);
shm = getMem(shmid);
segmentoDatos = getMem(datosID);
tamanioMem = getCantidadLineas() * TAMANIO_LINEAS;
mutex = sem_open(SEM_NAME,0,0644,1);
semDatos = sem_open(SEM_DATOS_NAME,0,0644,1);
}
else{
mutex = sem_open(SEM_NAME,O_CREAT,0644,1);
semDatos = sem_open(SEM_DATOS_NAME,O_CREAT,0644,1);
}
while(EXITO){
// Inicializamos el semaforo
if(tipo == TIPO_WRITER){
sem_wait(mutex);
sem_wait(semDatos);
/////////////////////////////////////////////////////
//region critica
if(getMemID(LLAVE_SEGMENTO,NULL)){
if(getLectores() == 0){
// Tiempo de escritura
if(contadorLinea = escribir(prefijo,tamanioMem,shm,procesoActual)){
setLectura(0);decReader();
actualizar(llaveSegmento,prefijoLog,procesoActual);
registrar(procesoActual);
sleep(procesoActual->escritura);
setLectura(1);
}
}
}
else{
sem_post(semDatos);
sem_post(mutex);
break;
}
sem_post(semDatos);
sem_post(mutex);
}
else if(tipo == TIPO_READER){
sem_wait(semDatos);
if(getMemID(LLAVE_SEGMENTO,NULL)){
if(getLectura()){
decReader();
incLectores();
sem_post(semDatos);
leer(tamanioMem,shm,procesoActual);
sem_wait(semDatos);
decLectores();
}
}
else{
sem_post(semDatos);
break;
}
sem_post(semDatos);
}
else if(tipo == TIPO_READER_EGOISTA){
/////////////////////////////////////////////////////
//region critica
sem_wait(mutex);
sem_wait(semDatos);
if(getMemID(LLAVE_SEGMENTO,NULL)){
if(incReader()<4 && getLectores() == 0){
// Tiempo de escritura
if(contadorLinea = borrar(tamanioMem,shm,procesoActual)){
setLectura(0);
actualizar(llaveSegmento,prefijoLog,procesoActual);
registrar(procesoActual);
sleep(procesoActual->escritura);
setLectura(1);
}
}
}
else{
sem_post(semDatos);
sem_post(mutex);
break;
}
sem_post(semDatos);
sem_post(mutex);
}
// Tiempo de descanso
procesoActual->estado = ESTADO_DESCANSO;
actualizar(llaveSegmento,prefijoLog,procesoActual);
sleep(procesoActual->descanso);
/////////////////////////////////////////////////////
// Luego de dormir se bloquean y esperan el semáforo
procesoActual->estado = ESTADO_BLOQUEADO;
actualizar(llaveSegmento,prefijoLog,procesoActual);
}
// Al no encontrar memoria compartida
// el proceso muere.
//sem_post(mutex);
sem_close(mutex);
sem_close(semDatos);
printf("El %s %d fue finalizado.\n",tipoProceso,procesoActual->id);
}
int main(){
char origen[MAX_STRING];
char destino[MAX_STRING];
char buffer[TAM_BUFFER];
int fd_origen, fd_destino;
int leidos, escritos;
int ret;
/* montar debugfs */
printf("Montando la depuracion en la particion /FICHEROS/proc con debugFS\n");
ret=montar("", "proc", "debugFS");
if (0 > ret) {
printf("mostrar_fichero: Error al montar particion de depuracion con debugFS\n");
return (-1);
}
/* montar cdrom */
printf("Montando el cdrom en la particion /FICHEROS/lectura con cdromFS\n");
ret=montar("cdrom","lectura", "cdromFS");
if (0 > ret) {
printf("Copiar_fichero: Error al montar particion lectura en cdrom con cdromFS\n");
return (-1);
}
/* montar disco */
printf("Montando el disco en la particion /FICHEROS/escritura con discoFS\n");
ret=montar("disco","escritura", "discoFS");
if (0 > ret) {
printf("Copiar_fichero: Error al montar particion escritura en disco con discoFS\n");
return (-1);
}
/* obtener los nombre de los ficheros */
printf("Introduzca el fichero origen EJ: /FICHEROS/lectura/datos:");
scanf("%s",origen);
printf("Introduzca el fichero destino EJ: /FICHEROS/escritura/resultado:");
scanf("%s",destino);
/* abrir fichero origen */
fd_origen = abrir (origen, T_FICHERO);
if (0 > fd_origen) {
printf("Copiar_fichero: Error al abrir fichero origen %s\n", origen);
return (-1);
}
/* abrir fichero destino */
fd_destino = abrir (destino, T_FICHERO);
if (0 > fd_destino) {
printf("Copiar_fichero: Error al abrir fichero destino %s\n", destino);
return (-1);
}
/* copiar origen en destino */
leidos = leer(fd_origen,buffer,TAM_BUFFER);
while (0 < leidos) {
escritos = escribir(fd_destino,buffer,leidos);
if (leidos != escritos) {
printf("Copiar_fichero: Error al escribir fichero destino %s\n", destino);
return (-1);
}
leidos = leer(fd_origen,buffer,TAM_BUFFER);
}
/* cerrar fichero origen */
cerrar (fd_origen);
/* cerrar fichero destino */
cerrar (fd_destino);
/* sincronizar las escrituras */
printf("Escribiendo los cambios de la particion /FICHEROS/escritura en el disco\n");
sincronizar("escritura");
return 0;
}
void evaluar()
{
int nota = 0;
escribir("archivo_evaluador1",new Gato(5,'f',"ruru","persa"),1);
escribir("archivo_evaluador1",new Gato(7,'m',"roro","siames"),0);
escribir("archivo_evaluador1",new Gato(3,'f',"rara","bengala"),2);
cout<<"Ejercicio escribir() y leer():\t\t";
bool correcto = true;
if( (leer("archivo_evaluador1",0)->edad == 7
&& leer("archivo_evaluador1",1)->edad == 5
&& leer("archivo_evaluador1",2)->edad == 3
&& leer("archivo_evaluador1",0)->sexo == 'm'
&& leer("archivo_evaluador1",1)->sexo == 'f'
&& leer("archivo_evaluador1",2)->sexo == 'f'
&& leer("archivo_evaluador1",0)->nombre == "roro"
&& leer("archivo_evaluador1",1)->nombre == "ruru"
&& leer("archivo_evaluador1",2)->nombre == "rara"
&& leer("archivo_evaluador1",0)->raza == "siames"
&& leer("archivo_evaluador1",1)->raza == "persa"
&& leer("archivo_evaluador1",2)->raza == "bengala"
)==false)
{
correcto=false;
}
escribir("archivo_evaluador2",new Gato(0,'m',"lolo","ragdoll"),0);
escribir("archivo_evaluador2",new Gato(153,'f',"lola","sphinx"),1);
if( (leer("archivo_evaluador2",0)->edad == 0
&& leer("archivo_evaluador2",1)->edad == 153
&& leer("archivo_evaluador2",0)->sexo == 'm'
&& leer("archivo_evaluador2",1)->sexo == 'f'
&& leer("archivo_evaluador2",0)->nombre == "lolo"
&& leer("archivo_evaluador2",1)->nombre == "lola"
&& leer("archivo_evaluador2",0)->raza == "ragdoll"
&& leer("archivo_evaluador2",1)->raza == "sphinx"
)==false)
{
correcto=false;
}
if(correcto)
{
nota+=4;
cout<<"Correcto"<<endl;
}else
{
cout<<"Incorrecto"<<endl;
}
cout<<"Ejercicio getPromedioDeEdad():\t\t";
if(getPromedioDeEdad("archivo_evaluador1")==5
&&getPromedioDeEdad("archivo_evaluador2")==76.5
)
{
nota+=3;
cout<<"Correcto"<<endl;
}else
{
cout<<"Incorrecto"<<endl;
}
set<int>s1;
s1.insert(1);
s1.insert(2);
s1.insert(3);
s1.insert(4);
set<int>s2;
s2.insert(10);
s2.insert(20);
s2.insert(30);
cout<<"Ejercicio getMayor():\t\t\t";
if(getMayor(s1)==4
&& getMayor(s2)==30
)
{
nota+=2;
cout<<"Correcto"<<endl;
}else
{
cout<<"Incorrecto"<<endl;
}
queue<char>q1;
q1.push('a');
q1.push('b');
q1.push('c');
q1.push('d');
queue<char>q2;
q2.push('q');
q2.push('w');
q2.push('e');
q2.push('r');
q2.push('t');
stack<char>sq1;
sq1.push('a');
sq1.push('b');
sq1.push('c');
sq1.push('d');
stack<char>sq2;
sq2.push('q');
sq2.push('w');
sq2.push('e');
cout<<"Ejercicio mezclarAlphabeticamente():\t";
set<char> rs1 = mezclarAlfabeticamente(q1,sq1);
set<char> rs2 = mezclarAlfabeticamente(q2,sq2);
set<char> rs3 = mezclarAlfabeticamente(q1,sq2);
if(rs1.size()==4
&& rs2.size()==5
&& rs3.size()==7
&& rs1.find('a')!=rs1.end()
&& rs1.find('e')==rs1.end()
&& rs2.find('q')!=rs2.end()
&& rs2.find('a')==rs2.end()
&& rs2.find('w')!=rs2.end()
&& rs2.find('e')!=rs2.end()
&& rs2.find('r')!=rs2.end()
&& rs2.find('t')!=rs2.end()
&& rs3.find('a')!=rs3.end()
&& rs3.find('e')!=rs3.end()
)
{
nota+=2;
cout<<"Correcto"<<endl;
}else
{
cout<<"Incorrecto"<<endl;
}
cout<<"Ejercicio existe():\t\t\t";
vector<string>v1;
v1.push_back("a");
v1.push_back("b");
v1.push_back("c");
vector<string>v2;
v2.push_back("1");
v2.push_back("2");
v2.push_back("3");
v2.push_back("4");
vector<string>v3;
v3.push_back("q");
v3.push_back("w");
map<string,vector<string> >m1;
m1["x"]=v1;
m1["y"]=v2;
map<string,vector<string> >m2;
m2["A"]=v1;
m2["B"]=v2;
m2["C"]=v3;
map<string,vector<string> >m3;
m3["X"]=v3;
if(existe(m1,"a")
&& existe(m2,"a")
&& !existe(m3,"a")
&& existe(m1,"a")
&& existe(m1,"x")
&& existe(m1,"y")
&& !existe(m1,"z")
&& existe(m1,"b")
&& existe(m1,"c")
&& !existe(m1,"d")
&& !existe(m1,"0")
&& existe(m1,"1")
&& existe(m1,"2")
&& existe(m1,"3")
&& existe(m1,"4")
&& !existe(m1,"5")
&& !existe(m1,"6")
&& existe(m2,"A")
&& existe(m2,"B")
&& existe(m2,"C")
&& !existe(m2,"D")
&& existe(m3,"X")
&& existe(m3,"q")
)
{
nota+=3;
cout<<"Correcto"<<endl;
}else
{
cout<<"Incorrecto"<<endl;
}
NodoTrinario* n1 = new NodoTrinario(1);
NodoTrinario* n2 = new NodoTrinario(2);
NodoTrinario* n3 = new NodoTrinario(3);
NodoTrinario* n4 = new NodoTrinario(4);
NodoTrinario* n5 = new NodoTrinario(5);
NodoTrinario* n6 = new NodoTrinario(6);
NodoTrinario* n7 = new NodoTrinario(7);
NodoTrinario* n8 = new NodoTrinario(8);
NodoTrinario* n9 = new NodoTrinario(9);
NodoTrinario* n10 = new NodoTrinario(10);
n1->izquierdo = n2;
n1->medio = n3;
n1->derecho = n4;
n2->izquierdo = n5;
n2->medio = n6;
n2->derecho = n7;
n3->izquierdo = n8;
n3->medio = n9;
n8->medio = n10;
cout<<"Ejercicio getMayor():\t\t\t";
if(getMayor(n1)==10
&& getMayor(n2)==7
&& getMayor(n3)==10
&& getMayor(n4)==4
)
{
nota+=3;
cout<<"Correcto"<<endl;
}else
{
cout<<"Incorrecto"<<endl;
}
cout<<"Ejercicio buscarYReemplazar():\t\t";
buscarYReemplazar(n1,1,13);
buscarYReemplazar(n1,8,18);
buscarYReemplazar(n1,4,666);
if(n1->valor == 13
&& n8->valor == 18
&& n4->valor == 666
)
{
nota+=3;
cout<<"Correcto"<<endl;
}else
{
cout<<"Incorrecto"<<endl;
}
cout<<"Ejercicio retener3Bits():\t\t";
if(retener3Bits(8)==0
&& retener3Bits(3)==3
&& retener3Bits(9)==1
&& retener3Bits(147)==3
&& retener3Bits(254)==6
)
{
nota+=2;
cout<<"Correcto"<<endl;
}else
{
cout<<"Incorrecto"<<endl;
}
cout<<endl<<"Nota: "<<nota<<"/15"<<endl;
}
void nimodo(){
printf(cadena1);
char *token;
// printf("cadena original %s \n",cadena1);
/* get the first token */
token = strtok(cadena1," ");
// printf("cadena original %s \n",cadena1);
/* walk through other tokens */
while( token != NULL )
{
// printf( "%s\n", token );
if(strcmp(token,"mkdisk")==0){
orden = 1;
// printf("cadena original %s \n",cadena1);
}
else if(strcmp(token,"rmdisk")==0){
orden = 2;
printf("orden 2\n");
}
else if(strcmp(token,"fdisk")==0){
orden = 3;
}
else if(strcmp(token,"mount")==0){
orden = 4;
}
else if(strcmp(token,"unmount")==0){
orden = 5;
}
else if(strcmp(token,"exec")==0){
orden = 6;
}
else if(strcmp(token,"rep")==0){
orden = 7;
}
else if(strcmp(token,"salir")==0){
orden = 0;
}else if(token[0]==35){
return;
}else if(orden == 10){
return;}
else{
evparametros(token);
}
/* if(token == "mkdisk"){
printf("esta es una PRUEBA %s\n",token);
}
*/
token = strtok(NULL, " ");
}
if(cont ==0){
// evcont();
escribir();
}else{
cont = 0;
}
// printf("ALFINAL DEL PRIMER WHILE %s \n",cadena1);
}
void pintar(char matriz[NMAX][NMAX]) {
escribir(stdout, matriz);
inform("Esta es tu sopa.");
}
