Mensajes

Muchísimas gracias eferion, ese era el problema, declarando consecuentes[] como atributo de BaseDeHechos he matado los dos pájaros de un tiro, ahora le he cambiado la función de retorno a Asociacion* y devuelvo un puntero a consecuentes

• y todo perfecto.
  
  Gracias de nuevo.
  
  Posteo por aquí también para que cierren el tema.

Buenas tardes chic@s,

Estoy implementando un motor de inferencia y tengo un pequeño problema que me lleva mosqueado un par de días, así que acudo a vosotros para ver si alguien más experimentado que yo en c++ me puede dar indicaciones de donde estoy fallando.

El problema empieza en este método:

Código [Seleccionar] Expandir


bool MotorDeInferencia::aplicar(Regla* r, Asociacion* as){
    cout << "MotorDeInferencia::aplicar()"<<endl;


    bool aplicada =bh->aplicar(r, as);  //<---------


    cout << "as.t" << as->t << endl;
    cout <<"Retornando al primer consecuente de la regla: " << r->getId()<<endl;;
    cout << "Valor: " << as->valor << endl;
    return aplicada;

}


El caso es que el objeto bh contenido en la clase MotorDeInferencia llama a su método aplicar. (el parámetro r es una regla con la que construiremos el objeto as).
Hasta ahí todo bien.

El siguiente método es el llamado anteriormente por bh y es aquí donde se construye el objeto.

Código [Seleccionar] Expandir


bool BaseDeHechos::aplicar(Regla* r, Asociacion* as){
    cout << "BaseDeHechos::aplicar()"<<endl;
    vector<Asociacion> consecuentes=r->getConsecuente();
    if(consecuentes.size()==2 &&(isContenido(consecuentes[0])
                             || isContenido(consecuentes[1])))
        return false;
    if(consecuentes.size()==2 && isNegacion(consecuentes[0])){
        *as=consecuentes[1];
        return true;
    }       
    as=&consecuentes[0];

/* cout << "consecuentes.size:"<<consecuentes.size()<<endl;
    cout << "as->t" << as->t << endl;
    cout << "as->valor: " << as->valor << endl;*/

    return true;   
   
}

Este método muestra los valores correctos por pantalla, pero una vez que salimos de este método al de MotorDeInferencia, los accesos al objeto "as" dan valores sin sentido.

No logro entender porque pierdo el objeto al devolverlo. Agradezco muchísimo la ayuda que me pudiesen dar, he probado a cambiar de todo, tanto como cambiar los acceso a los objetos mediante punteros o sin ellos, a devolver en el return contenido[0] (Que es el que me interesa en esa regla), y muchas más cosas.

Saludos.

Hola amigos, estoy diseñando un programa que lee cadenas y devuelve true o false si las acepta o no. La condición para que acepte las cadenas es que contengan una o más palabras concatenadas definidas. Estas son las palabras "TGATCA","TTCGAA","GGCC" Y "GGTACC", (por si a alguien le interesa son cuatro enzimas de ADN).

Bien pues para ello hago uso de la clase Matcher de este modo.

Código [Seleccionar] Expandir

public static void main(String[] args) throws IOException {
//Validacion con Afd.
Afd automata = new Afd("adn.jff");
System.out.println("Introduzca una o varias cadenas separadas"
+ " por coma para su validación: \n");
Scanner consola = new Scanner(System.in);
String linea = consola.nextLine();
String[] listaCadenas = linea.split(",");
System.out.println("********Validación con Afd.********\n");
for (String cadena : listaCadenas) {
System.out.println("La cadena (" + cadena + ") ¿Es válida? "
+ ValidacionADN.esValida(automata, cadena));
if (ValidacionADN.esValida(automata, cadena) == false) {
System.out.println("estado: " + automata.getEstadoActual()
+ ", símbolo: " + automata.getSimboloActual());

}
}
//Validación con Matcher.
System.out.println("********Validacion con Matcher********");


Pattern patEnzimas= Pattern.compile("[[GGCC]*|[GGTACC]*|[TTCGAA]*|[TGATCA]*]+"); // ESTA ES LA LÍNEA QUE TENGO MAL


for (String cadena: listaCadenas){
Matcher matEnzimas= patEnzimas.matcher(cadena);
System.out.println("¿Es válida la cadena ("+cadena+")?"+matEnzimas.matches());
}

}

Mi pregunta es ¿Qué patrón debo pasarle para que me devuelva true si la cadena de entrada es una composición de una o más cadenas descritas anteriormente?

Te refieres a que debería haber inicializado también en la función de ArrayCreaFichero??

A ver si puedo lograr que me entiendas. Cuando yo le estoy pidiendo al usuario que me indique dos valores, inferior y superior, el lo está haciendo en una escala de +1, para el usuario el primer índice es el 1, pero para el compilador el primer índice es el 0, como ya sabemos. Ahora si yo introduzco como parámetro en la función este índice, cuando vaya a dirigirme a él dentro de la función tendré que restarle 1 para que concuerden.

for (int x=0; x<j-i+1;x++)   a2->v

• =ap->v[i+x-1];
  
  ejemplo:
  El usuario quiere que se cree un subarray b, a partir del array a, para ello introduce los índices 2 y 4 (para el compilador serían 1 y 3), estos son los argumentos i y j de la función.
  j-i+1=3
  a[0]=3; a[1]=6; a[2]=1; a[3]=9; a[4]=2; a[5]=0;
    Ahora el recorrido:
       
  x=0; a2->v[0]=a->v[2+0-1=1]; ------>a2->v[0]=6;
  x=1; a2->v[1]=a->v[2+1-1=2];------->a2->v[1]=1;
  x=2; a2->v[2]=a->v[2+2-1=3];------->02->v[2]=9;
  Fin de recorrido porque no se cumple la condición (x<3).
  
  Esta mañana he comprobado que el error raíz, está relacionado con otra función que carga el array desde un fichero. Ya que el resultado es correcto al crear el array desde la siguiente función que crea el array aleatoriamente.
  
  Código [Seleccionar] Expandir
  Array ArrayCreaAleatorio(int linf, int lsup)
{
      ArrayAp a=malloc(sizeof(ArrayRep));
      a->n=lsup-linf+1;
      a->v=malloc(sizeof(int)*a->n);
      for (int i=0; i<a->n;i++)
          a->v[i]=linf+i;
      for (int j=0;j<=a->n-2;j++)
      {
          int k=EnteroAleatorio(j+1,a->n-1);
          int aux=a->v[j];
          a->v[j]=a->v[k];
          a->v[k]=aux;
      }
      return a;
}
  
  Pero al crear el array desde un fichero si llamo a subarray con el array cargado en una variable, lo único que hace es imprimir los i-j+1 primer elementos.
  
  Aquí la función problemática:
  
  
  Código [Seleccionar] Expandir
  // Crea y devuelve un array cuyos elementos han sido
// leídos desde un fichero de texto con descriptor de fichero f.
// Req: El formato del fichero de lectura es el siguiente:
//  n v_1 v_2 ... v_n
//  con n>0.
// Por ejemplo, el array {4,6,3,5} estaría en el fichero como:
//  4 4 6 3 5
Array ArrayCreaFichero(FILE * f)
{
      ArrayAp a;
      fscanf(f,"%d",&a->n);
      a->v=malloc(sizeof(int)*a->n);
      for(int i=0;i<a->n;i++)
         fscanf(f,"%d",&a->v[i]);
      return a;
}
  
  Y he comprobado que el error no se encuentra en el primer elemento del array(el que representa a n). Al imprimir por pantalla un array creado desde esta función devuelve lo esperado, en el caso del ejemplo: 4 6 3 5
  
  
  

No, eso no es, si te das cuenta el array a está indexado desde 1 hasta n, así que para el usuario sería el indice i y para el compilador seria i-1 ya que en C se empieza a indexar por el 0.

Yo tb llegué a liarme mucho con esto, la profesora nos amarga la vida  


De todos modos lo probé y sigue pasando lo mismo.

Lo siento, se me olvidó, aquí te la pongo.

Código [Seleccionar] Expandir

// Crea y devuelve un array de tamaño n con sus elementos
// inicializados a cero e indexados desde 1 hasta n.
// Req: n>0
Array ArrayCrea(int n)
{
      ArrayAp a=malloc(sizeof(ArrayRep));
      a->n=n;
      a->v=malloc(sizeof(int)*n);
      for (int i=0;i<a->n;i++)
          a->v[i]=0;
      return a;     
}
Por eso solo tiene un argumento.

Hola amigos, estoy teniendo un problema al definir una función, este es el codigo:

Código [Seleccionar] Expandir

typedef struct {int *v; int n;}ArrayRep;
typedef ArrayRep *ArrayAp;

// Crea y devuelve un subarray del array a comprendido
// entre los índices i y j.
// Req: 1<=i<=j<=ArrayTam(a)
Array ArrayCreaSubarray(Array a, int i, int j)
{     
       ArrayAp ap=a;
       ArrayAp a2=ArrayCrea(j-i+1);
       for (int x=0; x<j-i+1;x++)   a2->v[x]=ap->v[i+x-1];
       return a2;
}
El problema es que no crea el subarray desde el índice i al indice j sino que genera un array con los primeros i-j+1 elementos.
Por ejemplo:
Si el array a fuese: 1 2 3 4 5 6.
Los enteros i y j fuesen: 2 y 4.
El array correcto sería:2 3 4 sin embargo se crea el 1 2 3.

Espero que alguien me pueda ayudar.

Muchas gracias, estaba cometiendo el error al declarar la estructura, he utilizado typedef para definirla y no me ha causado problemas. Muchas gracias por todos los que me han respondido. Espero ser yo el que ayude la proxima vez. Aunque por ahora sólo sepa programar en ensamblador y Pascal.

No, compilo en C, no se las diferencias que habrá porque es mi primer año de carrera pero de momento C. Publico todo el código para verlo mejor.

Código [Seleccionar] Expandir

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


// Lee por teclado dos enteros linf y lsup,
// tales que linf<=lsup.

void LimitesLee(int * linf, int * lsup)
{
    printf("Introduzca dos enteros para los límites inferior y superior: \n");
    scanf ("%d %d",linf,lsup);
    while (*linf>*lsup)
    {
          printf("El limite inferior no puede ser mayor que el superior\n");
          printf("Por favor, vuelva a introducir los límites\n");
          scanf("%d %d",linf,lsup);
    }
}
// Imprime por pantalla los enteros linf y lsup con formato:
// Limites: [linf,lsup]
void LimitesImprime(int linf, int lsup)
{
    printf("Los límites inferior y superior son:[%d,%d]\n",linf,lsup);
}
// Genera y devuelve un entero aleatorio entre los límites
// linf y lsup.
int EnteroAleatorio(int linf, int lsup)
{
   return linf+rand()%(lsup-linf+1);
}
// Imprime por pantalla un entero e con formato:
// Entero: e
void EnteroImprime(int e)
{
    printf("Entero: %d \n",e);
}



// Crea y devuelve un array de tamaño n = lsup-linf+1
// con los números enteros comprendidos entre los límites
// linf y lsup, asignados al array de forma aleatoria entre los
// índices 1 y n. El array contendrá finalmente una
// permutación con los números enteros comprendidos entre
// dichos límites.
// Req: linf<=lsup
struct Array {int *v; int n;}

Array ArrayCreaAleatorio(int linf, int lsup)
{
     Array a;
     a.n=lsup-linf+1;
     a.v=malloc(sizeof(Array)*(a.n));
     for (int i=0; i<a.n;i++)
         a.v[i]=linf+i;
     for (int j=0;j<=a.n-2;j++)
     {
         int k=EnteroAleatorio(j+1,a.n-1);
         int aux=a.v[j];
         a.v[j]=a.v[k];
         a.v[k]=aux;
     }
     return a;      
}



int main()
{
   char nombre[10];
   int  edad;
   printf ("Hola mundo\n");
   printf ("Dime tu nombre: ");
   scanf  ("%s",nombre);
   printf ("Dime tu edad: ");
   scanf  ("%d",&edad);
   while(edad<0)
             {
             printf("Edad erronea, introduce edad: ");
             scanf("%d",&edad);
             }
   printf ("Hola %s tienes %d tacos\n",nombre,edad);
   
   int linf=0;
   int lsup=0;
   int ernd=0;
   int opcion=0;
   Array a=ArrayCreaAleatorio(linf,lsup);
   while (opcion!=7)
   {
         printf("1. Imprimir en pantalla los límites actuales.\n");
         printf("2. Imprimir en pantalla el entero aleatorio actual.\n");
         printf("3. Imprimir en pantalla el array actual.\n");
         printf("4. Leer desde teclado nuevos límites.\n");
         printf("5. Generar un nuevo entero aleatorio dentro de los límites actuales.\n");
         printf("6. Generar un nuevo array aleatorio dentro de los limites actuales.\n");
         printf("7. Salir.\n");
         printf("Introducir opción (1-5):\n");
         scanf("%d",&opcion);
         switch(opcion)
         {
             case 1:LimitesImprime(linf,lsup);break;
             case 2:EnteroImprime(ernd);break;
             case 3:break;
             case 4:LimitesLee(&linf,&lsup);
                    LimitesImprime(linf,lsup);break;
             case 5:ernd=EnteroAleatorio(linf,lsup);
                    EnteroImprime(ernd);break;
              case 6:break;
             case 7:break;
             default: printf("Error, la opción ha de estar comprendida entre 1-5\n");
         }
                     
                       
   }
       system("pause");
   return 0;
}