Mensajes

Si estás detrás de un compilador GCC o parecido este es el makefile:

Código (bash) [Seleccionar] Expandir

CC=gcc

p: main.o dato.o dato.h
${CC} main.o dato.o dato.h -o p
dato.o: dato.c dato.h
${CC} -c dato.c dato.h
main.o: main.c dato.h
${CC} -c main.c dato.h

Aquí se generan dos objetos que después se enlazan: por un lado el propio del tipo de dato, aquí dato.o, y por otro el del cliente consumidor del tipo de dato, aquí main.o.
dato.o se compila a partir de dato.c, del cual el cliente no sabe nada, y dato.h. Como programador darás el objeto generado y la cabecera dato.h a tu cliente.

Tu cliente hará su propio programa incluyendo la cabecera dato.h a su código (aquí representado por main.c) y enlazando su código objeto, aquí representado por main.o, con el que tu le proporcionas.
Compilado de esta forma no puede acceder al miembro del struct ya que solo ve el dato incompleto de la cabecera. Los datos internos están ocultos en el código objeto.
Lo único que ve el cliente es la interfaz proporcionada por el archivo de cabecera.

Lo irás viendo con el tiempo pero las funciones deben ser lo más independientes posibles. Deben pasársele los datos mínimos para realizar su trabajo.

Código [Seleccionar] Expandir

control=MENU(&opcion,   control, intentos);}while(control==1);
por ejemplo, está mal diseñada. Le pasas una variable control para que te la saque otra vez y dentro de la función ésta sirve solo para saber si debe repetir el ciclo. Esto es mucha dependencia y se debe reestructurar.
Le pasas por referencia la 'opcion' pero la usa dentro y no debe variarla. Has gastado tiempo y recursos realizando un trabajo que podría haber hecho la función sola. Y de nuevo has creado una dependencia que se podría haber evitado.
La interfaz de las funciones siempre debe ser lo más simple posible.

Por otra parte has escrito algo sin sentido

Código [Seleccionar] Expandir

printf("2f\t", dificultad);
Supongo que es una cadena de control para mostrar el dato dificultad. El doble error que hay en ella es que querías hacer %2f, pero resulta que dificultad en un entero, no un real. Tampoco tiene sentido terminarlo en \t, a lo mejor te referirías \n. Su código debería ser

Código [Seleccionar] Expandir

printf("%2d\n", dificultad);

Como puedes ver la lista de errores, tanto técnicos como de lógica eran muchos y opté por reescribir el código, era más rápido que enumerarlos, de esta forma podrías comparar las dos formas de hacer y que sacaras tus conclusiones al ver las diferencias entre uno y otro.

[dato.h]

Como digo esto se trata de C y no de C++.

Es posible emular, en C, el comportamiento de miembros privados de datos definidos por el programador, al estilo de la POO, para que los usuarios de esa estructura no puedan acceder directamente a los datos que hay dentro de ella.

Las ventajas que tiene esta técnica:
1. El usuario no puede modificar los datos directamente y deben pasar por los filtros que imponga el programador.
2. El programador puede cambiar los datos internos que tiene la estructura y su interfaz (funciones getters y setters) sin que el usuario tenga que recompilar todo su código para hacer uso de estas modificaciones.

Los inconvenientes:
1. Sólo se puede situar la estructura en memoria del montón con lo que aparece el problema de la fragmentación de la memoria
2. La memoria se debe liberar ya sea mediante free o una función que proporcione el programador a modo de destructor.

Aquí va el código:


dato.h

Código (c) [Seleccionar] Expandir


#ifndef __DATO_H__
#define __DATO_H__

typedef struct __dato__ DATO;

DATO* new_dato();
void delete_dato(DATO* objeto);
int get_dato(DATO* objeto);
void set_dato(DATO* objeto, int valor);

#endif


dato.c

Código (c) [Seleccionar] Expandir


#include <stdlib.h>
#include "dato.h"

struct __dato__ {
   int miembro_privado;
};

DATO* new_dato() {
   DATO* d = malloc(sizeof(DATO));
   d->miembro_privado = 0;
   return d;
}

void delete_dato(DATO* objeto) {
   free(objeto);
}

int get_dato(DATO* objeto) {
   return objeto->miembro_privado;
}

void set_dato(DATO* objeto, int valor) {
   objeto->miembro_privado = valor;
}



Ahora el cliente:

main.c

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include "dato.h"

int main() {
   DATO *d;
   
   d = new_dato();
   set_dato(d, 5);
   printf("%i\n", get_dato(d));
   
   /* d->miembro_privado = 4; /* <- Esto va a fallar */
   /* printf("%i\n", get_dato(d)); */
   
   delete_dato(d);
   
   return 0;
}

La verdad: te has complicado muchísimo a la hora de adquirir la ruta del archivo.
¿No puedes hacer que el usuario la entre de una vez?

A ver: son archivos binarios y guardan los datos de forma binaria. Vas a ver sìmbolos raros porque traduces los bytes a ascii, pero son eso, bytes. Pueden ser enteros, reales, complejos, cadenas, cadenas ofuscadas, código ejecutable, cualquier cosa.

A lo mejor con un desensamblador, tienes suerte, y te puede arrojar el código máquina y puedes llegar a ver las cadenas de texto.

Cómo te dije expon tu consulta en ingeniería inversa, los chicos de allí se dedican a eso.

Pásate por la página que te ha dado Gunhack. En ella te explican como usar esa clase.

Pues esa se me ocurrió cuándo estábamos con el otro post de un problema similar XD

A ver si alguien con compilador C++ puede probar. Pero por lo que he visto así a simple vista:
Declaras la variable 'omitidos', nótese que es plural, y cuándo la usas escribes 'omitido', en singular. El compilador debe haberte avisado en los mensajes de error.



Más, por lo poco que se de C++, si declaras un array con new TIPO[], debes usar delete [] variable para borrarla.



Te falta incluir los caracteres de final de cadena '\0' al final de las cadenas que creas.

Like this! Viene bien, de vez en cuánto realizar pequeños rompecabezas, hace más emocionante esta sección

He reconstruido un poco el código. No he llegado a entender tus intenciones en la función Gen_Num_Aleatorio_y_Comp, parece que querías que el ordenador mismo fuera adivinando los números; pero no se ve muy claro.
Sobran muchos argumentos a las funciones, las interconexiones entre ellas son muy difusas. Además debes recordar que en C los argumentos se pasan por valor, eso es, las funciones no modifican el valor de las variables que se les pasan, a no ser que explícitamente las pases por referencia o sean arrays.

Dicho esto aquí te dejo un código un poco reconstruido que deberás completar. Para que te sea fácil retomar el hilo: el programa, a la hora de iniciar el juego, en un array de 4 elementos de tipo entero introduce 4 números aleatorios de 0 a 9. El jugador tiene tantos intentos como marca la variable dificultad para adivinar. La opción 2 del menú inicia el juego con siempre 100 intentos.

Tu deberás incluir el código en la función JugarPart en donde lo tienes marcado con un comentario.

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <time.h>

//FUNCIONES CREADAS:

#define ARRAY_COUNT(x) sizeof((x))/sizeof((x)[0])
void impresionCARATULA();
void JugarPart(int dificultad);
void Gene_Num_Aleatorios(int array_numeros_aleatorios[], size_t size);
int NivelDificultad();
int MENU();

int main(){
   // int num_jugador;
   int opcion;
   int dificultad = 100;

   impresionCARATULA();
   do {
       opcion = MENU();
       switch(opcion) {
   case 1:
       JugarPart(dificultad);
       break;
   case 2:
    JugarPart(100);
       break;
   case 3:
       dificultad = NivelDificultad();
       break;
   case 4:
       printf("Has selecionado Listar historial de partidas\n");
       break;
   case 0:
       printf("Has seleccionado Salir\n");
       opcion = 0;
       break;
   default:
       printf("Has seleccionado una opcion no valida\n");
       break;
}
   } while(opcion);
   
   return 0;
}

//CODIGO DE LAS FUNCIONES CREADAS:

void impresionCARATULA() { //imprimir la caratula intentar que sea lo mas corto posible.
   int i;
   int linea = 0;
   
   do {
       linea++;
       if(linea != 4) {
           for(i = 0; i < 80; i++) {// LINEA DE ASTERISCOS
               putchar('*');
           }
           putchar('\n');
       }
       else {
           for(i = 0; i < 32; i++) {
               putchar('*');
           }
           printf(" MASTER MIND ");
           for(i = 0; i < 35; i++) {
               putchar('*');
           }
           putchar('\n');//Linea mastermind
       }
   } while(linea < 7);
}

int MENU() { //imprimir el menú
int opcion;

   putchar('\n');
   puts("1) Jugar partida");
   puts("2) Jugar partida de prueba");
   puts("3) Establecer nivel de dificultad");
   puts("4) Listar historial de partidas");
   puts("0) Salir\n");
   printf("   Elija opcion >> ");
   scanf("%i", &opcion);

   return opcion;
}

int NivelDificultad() {
   int c1;
   int dificultad;

   do {
       printf("Seleccione un numero de 1 a 100 para establecer el numero de intentos:\t");
       scanf("%i", &dificultad);
       if(1 <= dificultad && dificultad <= 100) {
           printf("Has establecido numero de intentos máximo como: %i\n\n", dificultad);
           c1 = 0;
       }
       else {
           puts("Has selecionado un numero no valido");
           c1 = 1;
       }
   } while(c1);
   return dificultad;
}  

void Gen_Num_Aleatorio(int array_numeros_aleatorios[], size_t size) {
   int i;
   
   srand(time(NULL));
   for(i = 0; i < size; i++) {
       array_numeros_aleatorios[i] = rand() % 10; //del 0 al 9
   }
}

void JugarPart(int dificultad) {
   int numeros[4];
   int i;
   /* Declara aquí las variables que vayas a usar para la lógica
    * del juego.
    */    


   printf("Has seleccionado Jugar Partida con dificultad %i\n", dificultad);
   Gen_Num_Aleatorio(numeros, ARRAY_COUNT(numeros));
   for(i = 0; i < dificultad; ++i) {
    /* Inserta aquí tu lógica para que
    * el jugador adivine los números
    */
   }
}