Mensajes

Nota inicial 1: El programa tienes que hacerlo en C, no en C++, por tanto sobra "using namespace".
Nota inicial 2: "fflush" está pensado para buffers de salida, no de entrada. fflush(stdin) puede dar resultados inesperados.

Necesitas crear 3 listas:

Código (cpp) [Seleccionar] Expandir


typedef struct Disquera
{
 char nombre[20];
 struct Disquera* siguiente;
} Disquera;

typedef struct Cd
{
 char nombre[20];
 Disquera* disquera;
 struct Cd* siguiente;
} Cd;

typedef struct Interprete
{
 char nombre[20];
 Cd* inicioListaCds;
 Cd* finListaCds;
 struct  Interprete* siguiente;
} Interprete;

Al final la estructura que queda es la que sigue:

Tienes una lista de intérpretes, cada intérprete tiene su propia lista de Cds. De forma paralela hay una lista de disqueras, de tal forma que cada CD acaba apuntando a la disquera que le corresponde.

De esto se deduce que tu estructura TEMPTATIONS no es correcta, ya que ahí estás forzando a que la relación intérprete-cd sea 1-1.

Perdón si la respuesta daba a entender que me pasaba de listo... tenía poco tiempo y fue una respuesta rápida.

Ahora matizo. A mí la pregunta me ha dado a entender que el lo que pretendía era ejecutar el mismo código en el switch para dos condiciones diferentes... el, claro está, lo intentaba usando el operador ||, cuando realmente en un switch lo más acertado es poner varios case seguidos sin un break de por medio.

Obviamente un switch es bastante restrictivo. Sus case no admiten el uso de operadores ni de tipos que no sean los básicos.

Un saludo.

En pocas palabras, no.

seguro??

Código (cpp) [Seleccionar] Expandir

switch(opcion){
                 
    case 'a':
    case 'A':
          printf("La suma de %g + %g = %g ",num1,num2,num1+num2);             
                 break;
                 
                 
    }

A ver, si no quieres que las IPs pasen a ser públicas lo mejor es tener un servidor central.

* Un usuario se conecta al usuario usando un usuario y contraseña
* El servidor marca a este usuario como activo en su base de datos. No necesita almacenar la IP porque mantiene una conexión activa con el usuario.
* El usuario puede pedir bien una lista de usuarios conectados (obtiene nombres o alias) o bien una lista de "pizarras" activas
* El usuario elige conectarse a una pizarra... el servidor centraliza las conexiones para que todos los integrantes puedan compartir información. Nadie sabe dónde se encuentran los demás.
* Cuando el usuario abandona el sistema o pasa cierto tiempo de inactividad, el servidor lo marca como desconectado y cierra la conexión con el mismo.

Si no usan IP... y más si el protocolo es propio... los routers no sabrán como utilizar ese protocolo, no sabrán como enrutarlo ni como identificar el destino y los paquetes se perderán.

En el momento en el que dos equipos se encuentren en redes diferentes... salvo que utilices una VPN no podrás conseguir que se comuniquen si limitas el rango de IPs. El motivo es que las redes locales tienen IPs ubicadas en unos rangos reservados. Estos rangos se reutilizan en miles de redes locales, por lo que esas IPs se repiten miles de veces. Lo que sucede es que estas redes locales hacen uso de un router... y la IP pública de ese router sí es única... si no lo fuese no podrías crear un DNS que apuntase directamente a la IP de tu router. El caso es que para comunicar con algún equipo de esa red local desde el exterior tu tienes que hacer dos pasos:

* Proporcionar la IP pública del router
* Crear una redirección en el router para que todas las conexiones que reciba del protocolo X (TCP o UDP) y que vayan por el puerto Y las mande directamente al equipo que te interesa.

Las IPs públicas no las puedes acotar.

Otra cosa es que todos los equipos vayan a estar en la misma red local... entonces ya si podrías plantearte crear un sistema más a medida (aunque eso implica que será un diseño más rígido y complicado de cambiar).

[engel lex]

Bienvenida al foro.

Lo primero que te recomiendo es editar tu mensaje y decorar el código con la etiqueta GeSHi correspondiente a C o C++, según el lenguaje de programación del que se trate. Es obligatorio según las normas del foro, pero sin tener en cuenta ese detallito sin importancia, si es cierto que facilita bastante la lectura del código.

Código (c) [Seleccionar] Expandir


#include<stdio.h>

int main ()
{
 int cont=0;
 int N,i;
 scanf("%d",&N);

 { // <<< 1
 for(int i= 1; i<=N; i ++) // <<< 3
 {
   if((N%div) == 0)
   {
     cont ++; // <<< 4
   }
 }
 } // <<< 2
}

El código tiene varios comentarios, significan lo siguiente:

* 1 y 2: Estas llaves no son necesarias. No aportan absolutamente nada y son redundantes. Puedes eliminarlas sin ningún miedo.

* 3: Los "for" en C no permiten declarar variables. "int i" no está permitido dentro de un "for". Además, ya has declarado una variable "i" 4 líneas antes. El "for" debería quedar tal que:

Código (c) [Seleccionar] Expandir

for( i= 1; i<=N; i++ )

* 4: Esta variable no la estás usando absolutamente para nada. Después del bucle deberías imprimir su valor para saber cuántos divisores tiene el número.

Un saludo



Edito: Se me adelantó engel lex

[1. Lagunas de memoria]

1. Lagunas de memoria

Código (cpp) [Seleccionar] Expandir

return *(new prueba(p1.a + p2.a, p1.b + p2.b) );

Fíjate que estás reservando memoria dinámica con el new. En esta reserva pones un objeto que almacena el resultado de sumar p1 y p2. Después haces una copia de dicho objeto y retornas dicha copia... pero no has liberado la memoria que has reservado, por lo que estás creando lagunas de memoria.

Si en un método devuelves un objeto por valor, ese método no debe hacer uso de un "new" para almacenar el objeto que vas a retornar porque entonces tendrás problemas con la memoria. Dicho con pocas palabras, el "new" sobra:

Código (cpp) [Seleccionar] Expandir

return prueba(p1.a + p2.a, p1.b + p2.b);

2. Retorno de referencias

Código (cpp) [Seleccionar] Expandir

prueba& operator +( const prueba &p1, const prueba &p2)
{
 return prueba(p1.a + p2.a, p1.b + p2.b);
}

Partimos del operador una vez aplicada la corrección anterior porque no tiene sentido ir dejando lagunas de memoria. El problema ahora es que el objeto "prueba" que estamos creando dentro del operador se elimina automáticamente cuando la ejecución abandona el método. Resulta que estamos devolviendo una referencia, luego estaremos devolviendo una referencia a un objeto que no existe. El compilador seguramente te avise de esta circunstancia con, al menos, un warning.

Este método no puede devolver una referencia.

Código (cpp) [Seleccionar] Expandir


prueba operator +( const prueba &p1, const prueba &p2)
{
 return prueba(p1.a + p2.a, p1.b + p2.b);
}

3. Nombres de variables

Código (cpp) [Seleccionar] Expandir


prueba operator+( const prueba &p1, const prueba &p2);
prueba operator-( const prueba &p3, const prueba &p4);
prueba operator*( const prueba &p5, const prueba &p6);
prueba operator/( const prueba &p7, const prueba &p8);

La variable "p1" que usa como argumento el operador de suma únicamente va a existir dentro de dicha función. Fuera del operador suma la variable "p1" no existe, y cualquier intento por acceder a ella provocará un error al compilar. Por este motivo no hay ningún problema si repites los nombres en los diferentes métodos:

Código (cpp) [Seleccionar] Expandir


prueba operator+( const prueba &p1, const prueba &p2);
prueba operator-( const prueba &p1, const prueba &p2);
prueba operator*( const prueba &p1, const prueba &p2);
prueba operator/( const prueba &p1, const prueba &p2);

Puede parecer un cambio meramente estético, pero como pretendas escribir un programa completo sin repetir el nombre de ninguna variable, incluso si el nombre únicamente se usa en un ámbito muy reducido, puedes acabar con un dolor de cabeza muy serio.

4. Uso de los operadores

Ya has definido los operadores... ahora solo te queda usarlos. Crea varios elementos con diferentes valores y haz uso de los diferentes operadores. Después saca por pantalla los resultados y verifica que el resultado obtenido coincide con el esperado:

Código (cpp) [Seleccionar] Expandir


int main( )
{
 prueba p1( 10, 20 );
 prueba p2( 4.67, 2.44 );

 prueba resultado = p1 + p2;

 std::cout << "a=" << resultado.a << std::endl;
 std::cout << "b=" << resultado.b << std::endl;
}

Las redes distribuidas sin servidor no son tal, lo que sucede es que cada cliente hace también las veces de servidor. Lo que sucede en estos casos es que un cliente nuevo que se quiera conectar ha de conocer la dirección de, al menos, uno de los integrantes de la red para poder conectarse a la misma... un cliente no se va a poder conectar a esta red únicamente conociendo el protocolo de la conexión, necesita también una IP que le permita integrarse en el sistema.

La ventaja de que haya un servidor central es que se simplifica el proceso de establecer una conexión (whatsapp, skype, la mayoría de los juegos online, ... todos ellos utilizan un servidor central, aunque sea para integrar a los nuevos clientes en el sistema).

La ventaja de evitar el servidor central es que no dependes del mismo para que funcione el sistema, aunque esto es a costa de complicar el establecimiento de la conexión. Y aún así hay algo contra lo que no podrás luchar... si se cae el que hace de servidor, los clientes serán expulsados del sistema.

Yo te recomiendo dos opciones:

* Programas un servidor. Los clientes se conectan a dicho servidor y es éste el que proporciona las ips de los clientes que estén conectados en ese momento. Esta transacción se puede hacer de forma segura utilizando certificados digitales. Si además obligas a que cada cliente tenga que tener una cuenta creada en el servidor (con su correspondiente contraseña), mejor aún.

* Los clientes que quieran compartir "pizarra" se ponen en contacto entre ellos para facilitarse la dirección IP. Es mucho más engorroso, pero también es mucho más fácil de programar y más barato.

No hay muchas más opciones... Internet no te proporciona ninguna facilidad adicional en este aspecto.