Mensajes

Aprender a montar en coche no es saber encenderlo y meter primera... hay que dominar muchos más aspectos para poder decir que alguien sabe conducir.

Para aprender a programar en c++ tienes que aprender no solo a manejar la stl, sino también cómo funciona el concepto de clase, qué es el polimorfismo y cómo se explota, como funciona la herencia, de qué formas se pueden sobrecargar operadores, implicaciones del constructor copia y del operador de asignación, responsabilidad de los destructores...

Si te limitas a manejar la stl y todo con lenguaje procedural no estás programando en c++.

c++ es mas facil que c

jejeje

va a ser que no.

En c no tienes que lidiar con sobrecarga de funciones y operadores, polimorfismo, herencia...

En c es más complicado hacer aplicaciones grandes porque no tienes encapsulación y tienes que andar con pies de plomo... pero c, para aprender, es muuuucho más facil.

Lo que pasa es que el que aprende c++ después de aprender c... es casi un paseo.

firewall físico o por software??

Si es físico tendrías que hacerte con la documentación que explique la forma de configurar ( mediante telnet, snmp, etc ) el firewall concreto que vayas a utilizar.

Si es por software... cada firewall tiene su propia interfaz, seguro que en internet vienen las instrucciones para los más comunes.

La parte que no entiendo es qué aporta preparar una aplicación que, a raiz de una instrucción recibida por una segunda, abra los puertos de un router... no sería más sencillo que la primera aplicación los abriese directamente?

wxdevcpp es una versión nueva y actualizada por otro autor.

Aunque personalmente sigo prefiriendo el CodeBlocks

La última release es de hace casi dos años... y el portal no es que registre demasiada actividad desde entonces.

Si es un polígono convexo se entiende que debería tener un centro de gravedad (CG)... es decir, un punto central que esté equidistante de todos sus vértices.

Con todo, para que sea convexo, se entiende que si la secuencia de vértices es V1, V2, V3, ..., entonces el ángulo CG^V1 es menor que CG^V2 y este a su vez menor que CG^V3... y así

Es como un reloj, el CG será el eje de las manecillas, si suponemos V0 las 12, V1 la 1, V2 las 2, etc...
CG^V0 = 0
CG^V1 = 360/12 = 30
CG^V2 = 360/6 = 60
CG^V3 = 90
...

Solo habría que ordenar esos ángulos y ya tendrías el orden de los vértices.

Bueno, técnicamente CG^V0 es un vector, lo que tienes que hacer es coger un primer vector como referencia y después calcular el ángulo del resto de vectores con respecto al de referencia.

De todas formas ya te digo yo que wxdevcpp, devcpp, qtcreator, codeblocks... no son los responsables de que no te funcione un código... no dejan de ser editores de c++.

Al final todo pasa por el compilador de c++ y ese es el que te genera el ejecutable.

Si en uno te compila y en otro no generalmente es porque tienes mal configurado el proyecto.

Y a título personal, procura no usar los devcpp ni derivados, llevan años sin mantenimiento y dan problemas.

No tienes muy claros los conceptos sobre sockets. Me explico:

Que un puerto esté abierto significa que hay una aplicación escuchando por ese puerto... si la aplicación se cierra el puerto también.

Esto significa que un puerto no queda abierto indefinidamente porque si... son las aplicaciones las responsables de solicitárselos al sistema operativo y este puede adjudicárselo o denegárselo ( porque el puerto ya esté adjudicado a otra aplicación o sea un puerto reservado ).

Otra cosa diferente es abrir puertos en un router... abrir un puerto en un router significa que has creado una ruta en el router, de tal forma que todas las peticiones que lleguen a través de una interfaz determinada ( generalmente la de internet ) y por un puerto determinado se redirijan a una ip determinada ( generalmente el pc que va a hacer uso de ese puerto ).

Y luego podría aburrirte con varias horas de explicaciones sobre sockets, puertos, redes, paquetes y demás, pero creo que con esto te puedes hacer una idea de cómo funcionan los puertos y replantearte tu aplicación.

Me refería a algo más o menos así...

Fíjate que mi main tiene unas 40 líneas frente a las 200 del tuyo... aparte de que el mío funciona jejejeje.

Serás capaz de terminarlo??

Hay cosas que habría hecho de forma diferente, pero he intentado mantener el estilo de tu programa.

Código (cpp) [Seleccionar] Expandir

//* JUEGO CONECTA 4*//

/*Librerias utilizadas*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define LENGTH_JUGADOR    40
#define LENGTH_CEDULA     8
#define MAX_PARTIDAS      20
#define DIM               16 //Constante utilizada para definir la maxima dimension del tablero

/* Estructuras */

struct jugador
{
 char nom_jug[ LENGTH_JUGADOR + 1 ];
 char ced_jug[ LENGTH_CEDULA + 1 ];
};

struct partida
{
 // Para almacenar los datos del jugador1
 struct jugador jugador1;

 // Para almacenar los datos del jugador2
 struct jugador jugador2;

 // Almacena 1 ( ganador jugador 1 ) o 2 ( ganador jugador 2 ).
 int ganador;
};

struct manager_partidas
{
 // Almacena todas las partidas jugadas
 struct partida partidas[ MAX_PARTIDAS ];

 // Indica la partida actual
 int num_partida;
};

/*PROCEDIMIENTOS Y FUNCIONES*/

void pausa( );
int mostrar_menu( int );
int calcula_numero_jugadores( struct partida* );
void pedir_datos_jugador( struct jugador* );
void mostrar_resultados( struct manager_partidas* );

void inicializar_tablero(char tablero[][DIM],int);
int juegan_O_(char tabla[][DIM],int,int);
int juegan_X_(char tablero[][DIM],int,int);
int cuatro_en_linea(char tablero[][DIM],int);
int limpiar(char nom_jug[]);

int main()
{
 char tablero[ DIM ][ DIM ];
 int numero_jugadores = 0;
 int opcion = -1;

 // Se inicializa la estructura de las partidas
 struct manager_partidas manager;
 memset( &manager, 0, sizeof( manager ) );

 while ( opcion != 5 )
 {
   // Puntero a la partida actual... para evitar líneas de código
   struct partida* partida_actual = &manager.partidas[ manager.num_partida ];

   // Se comprueba el número de jugadores en la partida actual
   numero_jugadores = calcula_numero_jugadores( partida_actual );

   opcion = mostrar_menu( numero_jugadores );

   switch ( opcion )
   {
     case 1:
       pedir_datos_jugador( &partida_actual->jugador1 );
       break;

     case 2:
       pedir_datos_jugador( &partida_actual->jugador2 );
       break;

     case 3:
       // Se simula una partida, para ello se elige un ganador
       // y se incrementa el contador de la partida
       partida_actual->ganador = ( manager.num_partida % 2 );
       ++manager.num_partida;

       // Jugar
       break;

     case 4:
       // Se pasa una referencia para no copiar toda la estructura
       mostrar_resultados( &manager );
       break;

     case 5:
       break;
   }
 }
}

void pausa( )
{
 printf( "\nPulse una tecla para continuar..." );
 fseek( stdin, 0, SEEK_END);
 getchar( );
}

int mostrar_menu( int numero_jugadores )
{
 int ok = 0;
 int opcion = -1;

 while ( !ok )
 {
   // Limpiamos el buffer, por si acaso
   fseek( stdin, 0, SEEK_END);

   system( "cls" );
   printf( "\n\n\n     JUEGO CUATRO EN LINEA\n\n\n\n\n" );
   printf( "  1) Ingresar datos del primer jugador\n\n" );
   printf( "  2) Ingresar datos del segundo jugador\n\n" );
   printf( "  3) Jugar\n\n" );
   printf( "  4) Listar todos los juegos realizados\n\n" );
   printf( "  5) Salir\n\n\n" );

   if ( opcion == 3 )
   {
     printf( "  Error: Antes de jugar debe ingresar los datos de los dos jugadores. \n\n\n" );
     printf( "  REINGRESE SU OPCION: " );
   }
   else if ( opcion != -1 )
   {
     printf( "  Opcion incorrecta \n\n\n" );
     printf( "  REINGRESE SU OPCION: " );
   }
   else
   {
     printf( "INGRESE SU OPCION: " );
   }

   scanf( "%d", &opcion );
   if ( opcion == 3 )
     ok = ( numero_jugadores == 2 );
   else
     ok = ( opcion > 0 && opcion < 6 );
 }

 return opcion;
}


int calcula_numero_jugadores( struct partida* partida )
{
 int jugadores = 0;

 if ( partida->jugador1.nom_jug[ 0 ] != '\0' )
   ++jugadores;

 if ( partida->jugador2.nom_jug[ 0 ] != '\0' )
   ++jugadores;

 return jugadores;
}


void pedir_datos_jugador( struct jugador* jugador )
{
 int ok = 0;

 while ( !ok )
 {
   // Se limpia el buffer de entrada.
   fseek( stdin, 0, SEEK_END);

   printf( "\n Ingrese su Nombre: " );
   scanf("%40[^\n]", jugador->nom_jug );
   ok = ( jugador->nom_jug[ 0 ] != '\0' );

   if ( !ok )
     printf("\n ERROR" );
 }

 ok = 0;
 while ( !ok )
 {
   // Se limpia el buffer de entrada.
   fseek( stdin, 0, SEEK_END);

   printf( "\n Ingrese su cedula: " );
   scanf("%40[^\n]", jugador->ced_jug );
   ok = ( jugador->ced_jug[ 0 ] != '\0' );

   if ( !ok )
     printf("\n ERROR" );
 }

 pausa( );
}

void mostrar_resultados( struct manager_partidas* manager )
{
 if ( manager->num_partida == 0 )
 {
   printf ( "No se han jugador partidas." );
 }
 else
 {
   int i;
   for ( i=0; i<manager->num_partida; ++i )
   {
     printf( "Partida %d\n", i+1 );
     printf( "\n");
     printf( "Jugador 1: %s\n", manager->partidas[ i ].jugador1.nom_jug );
     printf( "Cedula:    %s\n", manager->partidas[ i ].jugador1.ced_jug );
     printf( "Jugador 2: %s\n", manager->partidas[ i ].jugador2.nom_jug );
     printf( "Cedula:    %s\n", manager->partidas[ i ].jugador2.ced_jug );
     printf( "Ganador jugador %d\n\n", manager->partidas[ i ].ganador );
   }
 }

 pausa( );
}

veo que no tienes las ideas muy claras.

.cpp es la extensión utilizada para los archivos de código fuente de c++... no es ejecutable de por si.

Si lo compilas y enlazas ( en windows ) se genera un archivo con extensión .exe que ese sí es ejecutable.

En cualquier caso tendrás alguna idea de c++ no?? o te has lanzado a la aventura ??

si te has lanzado a la aventura, empieza por cosas más sencillas o cambia de lenguaje. Empezar de primeras en c++ manejando estructuras y sockets no es la mejor forma de iniciarse en una aventura... y menos aún si ni tan siquiera sabes qué quieres hacer.

Es simple... si lo haces por diversión y aprender, te gustaría entender lo que estás haciendo hasta el punto de ser capaz de reproducirlo sin ayuda... si lo haces por obligación y quieres que otros lo hagan por ti... hay opciones de pago para los que no quieren esforzarse.

Aún así te voy a dar algunas ideas:

1. si pretendes abrir varios puertos en varias llamadas el método "app -parametros" no te va a funcionar porque por cada llamada crearás una nueva instancia del programa... cada copia del programa manejará los puertos que le hayas indicado en la llamada correspondiente.

2. En base al punto 1, una posibilidad es comunicarse entre las dos aplicaciones por sockets, empleando para ello un puerto conocido por ambas aplicaciones para entablar conversación y que se puedan enviar órdenes... como abrir otros puertos.

3. Si lo de los sockets no te va, se pueden enviar mensajes entre aplicaciones... pero es más engorroso e implica llamadas al sistema y procesos más difíciles de trazar.

4. No hay 4, al menos no de momento mientras no haya más información sobre la mesa.

Has tenido suerte, hize una cosa parecida hace unos días:

Eres demasiado bueno dándole la solución... al menos le podías haber puesto un desbordamiento de buffer para que se lo currase un poco jejeje.

Estoy por montar un chiringuito para que el que quiera que le resuelvan las prácticas que pague. Ya que no va a hacer esfuerzo intelectual, al menos que lo haga económicamente....