Mensajes

Una forma sencilla pudiera ser tener un catálogo de funciones:

* Función para comprobar 4 en línea en diagonal hacia la derecha
* Función para comprobar 4 en línea en diagonal hacia la izquierda
* Función para comprobar 4 en línea en vertical
* Función para comprobar 4 en línea en horizontal

Cada una de estas funciones podría recibir únicamente la fila y columna desde la que empezar a comprobar:

Código (cpp) [Seleccionar] Expandir


bool Comprobar4EnLinea( int fila, int columna, int incFila, int incColumna )
{
  bool to_return = true;

  if ( fila > 0 && fila < MAXFILAS && columna >= 0 && columna < MAXCOLUMNAS )
  {
    int ficha = Mint[fila][columna];

    for ( int i = 0; i < 3; i++ )
    {
      fila += incFila;
      columna += incColumna;

      if ( fila >= 0 && fila < MAXFILAS && columna >= 0 && columna < MAXCOLUMNAS )
      {
        if ( Mint[fila][columna] != ficha )
        {
          to_return = false;
          break;
        }
      }
      else
        to_return = false;
    }
  }
  else
    to_return = false;

  return to_return;
}

bool ComprobarDiagonalDerecha( int fila, int columna )
{
  bool to_return = false;

  // Se prueban todas las combinaciones en las que esta involucrada la ficha recien puesta
  for ( int i = 0; i < 4; i++ )
  {
    if ( Comprobar4EnLinea( fila + i, columna + i, -1, -1 ) )
    {
      to_return = true;
      break;
    }
  }

  return to_return;
}

Con este catálogo el proceso se puede simplificar bastante:

Código (cpp) [Seleccionar] Expandir


void MainWindow::Ganado(int fila,int columna,int ficha)
{
  bool ganador = false;

  ganador |= ComprobarDiagonalDerecha( fila, columna );
  ganador |= ComprobarDiagonalIzquierda( fila, columna );
  ganador |= ComprobarVertical( fila, columna) ;
  ganador |= ComprobarHorizontal( fila, columna );

  if ( ganador )
  {
    if ( ficha == 1 )
      cout << "Ganan las amarillas" << endl;
    else
      cout << "Ganan las rojas" << endl;
  }
}

A la hora de poner código, usa las etiquetas GeSHi, por favor.

En el algoritmo para calcular si hay 4 fichas alineadas...

Código (cpp) [Seleccionar] Expandir


    if(Mint[fila][columna-1]==ficha || Mint[fila][columna+1]==ficha){
        cont++;
        if(Mint[fila][columna-2]==ficha || Mint[fila][columna+2]==ficha){
            cont++;
            if(Mint[fila][columna-3]==ficha || Mint[fila][columna+3]==ficha){
                cont++;
                if(ficha==1 && cont==4){
                    ganadorojas=true;
                }else{
                    ganadoamar=true;
                }
            }
        }
    }

... hay varios problemas:

* No compruebas si estás en el borde del tablero, por lo que, efectivamente, podrías salirte del mismo.

* ¿Qué sucede si "Mint[fila][columna-1] == ficha && Mint[fila][columna+2] == ficha && Mint[fila][columna-3] == ficha" ?? pues básicamente que te da el juego por ganado aunque realmente las fichas no están alineadas

* ¿Qué utilidad tiene ahí cont?? Ninguna, los ifs están anidados, luego es imposible llegar a if(ficha==1 && cont==4) y que cont sea distinto de 4... además... ¿y el else de ese if? ¿no necesita comprobar que "cont == 4" ? Mejor quitar directamente "cont", no crees?

* ¿Qué sucede si la ficha que acabas de poner hace un 4 en raya pero no pertenece a uno de los extremos? Pues básicamente que no va a reconocer la jugada como ganadora, tu algoritmo asume que la nueva ficha pertenece SIEMPRE a uno de los dos extremos de la secuencia.

Para el caso de búsquedas en horizontal, el código presenta problemas similares.

Además tampoco está implementado el caso de tener las 4 fichas en vertical.

Un saludo.

La base sí, es compatible tanto en C como en C++. Me explico.

Cuando se organiza el código fuente se suelen generar dos tipos de archivos:

* Cabeceras.
* Código fuente.

Las cabeceras se usan para poner los prototipos de las funciones, las constantes de uso público, la definición de estructuras y clases, ...

Los archivos de código fuente contienen la implementación de las diferentes funciones.

Como norma general, las funciones se suelen agrupar, por ejemplo por funcionalidad. Entonces para cada conjunto de éstas funciones se crea un archivo de cabecera y otro de código fuente. La idea de tener este diseño es permitir que cualquiera pueda usar las funciones contenidas en el archivo de código fuente desde cualquier otra parte de la aplicación. Para poder hacer uso de éstas funciones únicamente es necesario añadir un include en el que se referencie el archivo de cabecera.

Un ejemplo en c:

cabecera.h

Código (c) [Seleccionar] Expandir


#ifndef __CABECERA_H
#define __CABECERA_H

int func( );

#endif // __CABECERA_H

cabecera.c

Código (c) [Seleccionar] Expandir


#include "cabecera.h"

int func( )
{
  return 4;
}

main.cpp

Código (c) [Seleccionar] Expandir


#include <stdio.h>

#include "cabecera.h"

int main( )
{
  printf( "%d\n", func( ) );
}

Y no sería más facil mapear los label usando un vector??

Código (cpp) [Seleccionar] Expandir


std::vector< Label* > labels;
labels.push_back( label1 );
labels.push_back( label2 );

// ...

if ( ( click > 0 ) && ( click <= labels.size( ) ) )
  labels[ click ]->hide( );


Aquí encontrarás algo de información.

StackOverflow

Nota: Usa las etiquetas GeSHi para que el código sea legible, gracias.

Vamos a ver, si tu programa incial tiene algo tal que:

Código (c) [Seleccionar] Expandir


main( )
{
  int Tam = 10;
  int i;
  float *Num, *Pos;
  int NoVec, Mayor;
  Num = new float [Tam];
  Pos = new float [NoVec];
  // ...
}

Es decir, declaras las variables que vas a usar después... ¿por qué asumes que al usar funciones ya no es necesario hacer esas declaraciones?

La función "Lectura" requiere un arreglo de enteros... decláralo en main y pásalo como argumento:

Código (c) [Seleccionar] Expandir


main ()
{
  int Tam = 10;
  int*Num = new float[Tam];

  Lectura ( Num );
}


Con las otras dos funciones te pasa exactamente lo mismo.

Un saludo.

Lo que te sucede es que únicamente estás pasando a minúsculas 'aux'... ¿qué pasa con 'palabra'?

Al no convertir ambas cadenas a minúsculas es difícil que coincidan.

PD.: Si usas C++... por qué no usas la clase string??

* Invertir una cadena:

Código (cpp) [Seleccionar] Expandir


std::string Invertir( const std::string& cadena )
{
 return std::string( cadena.rbegin( ), cadena.rend( ) );
}

* Pasar a minúsculas:

Código (cpp) [Seleccionar] Expandir


std::string AMinusculas( const std::string& cadena )
{
 std::string to_return = cadena;
 std::transform( to_return .begin( ), to_return .end( ), to_return .begin( ), ::tolower);
 return to_return;
}

* Comprobar si dos cadenas son iguales:

Código (cpp) [Seleccionar] Expandir


bool Comparar( const std::string& cadena1, const std::string& cadena2 )
{
 return cadena1 == cadena2;
}

* Conocer la longitud de una cadena:

Código (cpp) [Seleccionar] Expandir


int Longitud( const std::string& cadena )
{
 return cadena.size( );
}

Y aprovecho para declarar que estoy en desacuerdo con la línea del programa:

suma += array

puesto que no está sumando los elementos del arreglo, como cabría esperar. Debería ser:

suma += array[ i ]

¿no?

Exacto, array es un puntero... sin el asterisco el código suma posiciones de memoria, no valores.

También, tiene otras cosas extrañas, por ejemplo

if(*mayor<array) *mayor=array;

para empezar no debería ser '<', sino '>' ...

¿¿??

Si el programa pretende almacenar en "mayor" el número más alto dentro de un array... debería actualizar "mayor" cada vez que el número correspondiente en "array" es más grande, no?

En consecuencia el operador está bien... lo que sucede es como has coemntado, que se siguen sumando posiciones de memoria.

o a menos que incrementes el valor de array en cada ejecución del ciclo, cosa que tampoco veo que se haga

O usa el operador de indización o usa asteriscos, si usa el puntero como lo está haciendo únicamente obtendrá posiciones de memoria.

A ver, en lineas generales el diseño es confuso.

* En "temporales" tienes "tamanovectord" ... si esa variable guarda el tamaño de un vector... eso lo puedes obtener con vector.size( ) y te ahorras esa variable.

* En "temporales" tienes "numcol" y "numfil"... que se refieren a dic... esto no debería estar aquí.

No puedes pretender usar "temporales" como si fuese un cajón de sastre y a la vez tener un diseño de aplicación claro y sencillo de mantener.

Si te parece bien, dame por privado un enlace al código fuente, le echo un vistazo y te comento mis impresiones.

Un saludo.

Los compiladores, al menos en Windows, suelen enlazar los programas que generan con unas librerías propias del compilador. Estas librerías son necesarias porque tienen el código necesario para poder enlazar con la api de Windows.

* Si compilas con msvc tendrás que arrastrar MSVCR[00].DLL o MSVCP[00].DLL, dependiendo de si el programa se compila en C o en C++. nota: [00] se sustituye por la versión del compilador.

* Si compilas con mingw, tienes que copiar junto a tu programa la librería MINGWM[00].DLL.