Mensajes

Primer y principal problema:

Código (cpp) [Seleccionar] Expandir


void Carpeta::agregarAlumno(Alumno *a){

    if(isFull()){

        cout << "\nEsta lleno";

    }else{

        alumnos[cantAlumnos];
        cantAlumnos++;

    }

}

y más concretamente la línea:

Código (cpp) [Seleccionar] Expandir

alumnos[cantAlumnos];

esa línea no hace aboslutamente nada. No estás metiendo al alumno en la lista. La línea debería quedar así:

Código (cpp) [Seleccionar] Expandir

alumnos[cantAlumnos] = a;

Y luego tienes un segundo error en el código, lo que pasa es que éste es irrelevante porque no usas esa función... pero si la usases te daría problemas:

Código (cpp) [Seleccionar] Expandir


Carpeta::Carpeta(const Carpeta& orig) {   
}

Si implementas el constructor copia, lo mínimo que debes hacer es completar la función... si no vas a hacer nada mejor quita esa función o, mejor aún, declárala como privada. Si no la vas a usar puedes hasta evitar implementarla... así evitas que el compilador cree un constructor copia por defecto.

Y para rematar un consejo: intenta evitar las variables globales... no son buena idea porque en códigos más complejos pierdes la traza de dicha variable... además de que puedes modificarla sin querer en otras partes del código.

Eso es erróneo. Así estás sumandole a esa casilla, la otra casilla. Sumando y asignando.

???

Esto:

Código (c) [Seleccionar] Expandir

*pointer++ = *pointer+POSITIONS-i-1;

Es equivalente a esto:

Código (c) [Seleccionar] Expandir

*pointer = *pointer+POSITIONS-i-1;
pointer++;

Y esto a su vez es equivalente a esto:

Código (c) [Seleccionar] Expandir

*pointer += POSITIONS-i-1;
pointer++;

¿ Dónde está el problema entonces ?

Yo te lo digo. El problema es escribir ese tipo de líneas, que generan confusión. Y aquí tienes la prueba.

¿Como lo harias tu? Gracias.

Simplifica las instrucciones. Al final el código tiene algunas líneas más, pero éstas son más claras.

Código (c) [Seleccionar] Expandir


// v1
*pointer++ = *pointer+POSITIONS-i-1;

//v2.1
*pointer = *pointer+POSITIONS-i-1;
pointer++;

//v2.2
*pointer += POSITIONS-i-1;
pointer++;

El mayor problema, aparte de dificultar la legibilidad del código, que presenta el concatenar operaciones es que es bastante sencillo meter la pata...

Código (c) [Seleccionar] Expandir


// v1
int a = a+b++;

// v2, decides poner un preincremento de b porque has leido que es mejor
int a = a+++b;

// es lo mismo?? respuesta: no
// en que se traduce a+++b?? respuesta: en (a++) + b

Código (c) [Seleccionar] Expandir


*pointer++=i+10;

*pointer++ = *pointer+POSITIONS-i-1;

Vale que funcione pero, realmente es necesario tener código así?? Te ahorras una o dos líneas de código... realmente merece la pena?? La primera línea todavía... pero la segunda...

Tu piensa lo que te puede llegar a costar entender esto cuando vuelvas al código un par de meses después.

Lo que tienes que hacer es reordenar la lista y después volver a llamar a "listar".

Reordenar la lista implica cambiar los nodos de orden para que al recorrerla se queden los alumnos con sexo femenino en primer lugar.

Algoritmos de ordenación hay bastantes... unos son mas eficientes en tiempo, otros en recursos, otros son más sencillos de implementar... hay para todos los gustos.

Quizás el más sencillo sea el de la burbuja... tienes bastante documentación en internet sobre algoritmos de ordenamiento, quizás deberías invertir algo de tiempo en echarles un ojo y aprender sobre el tema, ya que ordenar es algo que te va a tocar en bastantes ocasiones.

Básicamente para ordenar lo que tienes que hacer es recorrer la lista e ir aplicando modificaciones en el orden de los nodos para conseguir que la lista final cumpla los requisitos de ordenación pedidos. En el caso que te ocupa, que las alumnas estén primero y los alumnos después.

Revisando más detenidamente tu código, efectivamente, la línea con la que tienes dudas está mal.

Lo que tienes que comprobar es que la conexión sigue abierta... pero tienes que pensar que el hecho de que la conexión se cierre no va a implicar que a ti, por arte de magia, se te modifique el identificador de la conexión.

Una forma que puedes utilizar para detectar esto es comprobar si recv te devuelve 0.

Al haber configurado la conexión como bloqueante, al intentar una lectura el programa se quedará congelado en dicha función hasta que se reciba algo por parte del cliente o bien se cierre la conexión.

[No se hacen tareas]

No me aburro de decirlo. No se hacen tareas.

Si quieres que te haga la tarea, en serio, mándame un mp y negociamos un precio... pero nadie te va a hacer la tarea del "cole" de forma gratuita.

Este foro está para ayudar cuando te atascas... para aprender y consultar dudas... no para librarte de hacer deberes.

Ponte con el programa y, cuando te atasques en alguna función, vuelves y comentas tus problemas... pero el problema desde luego no puede ser el típico "pueden ayudarme a hacer esta tarea?" o "necesito que alguien que haga esta practica" o similares...

Un saludo.

Cuando tu configuras el socket del servidor, lo tienes que configurar de tal forma que cuando te llega una petición, recibes un identificador de la conexión.

ese identificador actúa sobre el socket abierto... pero es independiente del socket. Esto quiere decir que tú el identificador debes cerrarlo después de enviarle la respuesta al cliente y quedar a la espera de que el socket te pase otro identificador.

Cuando tu cierras un identificador el socket sigue abierto. Lo que te debe estar pasando es que tú cierras el socket y, claro, cuando el cliente intenta una segunda conexión no puede contactar con el servidor porque éste ha cerrado la conexión... o eso o tu programa tiene un fallo y no se queda a la espera de nuevas conexiones.

Lo de las constantes, yo creo que un #define iría mejor.

Depende. Usar constantes tiene sus ventajas:
* Type-safe
* Se puede usar como parámetro en funciones que requieran el paso de punteros y/o referencias.
* Crea símbolos en depuración, lo que facilita el proceso de debug.

Define también tiene alguna ventaja sobre const... pero en c++ lo más lógico y recomendable es usar const.

Código (cpp) [Seleccionar] Expandir


for(int i=1;i<tam-1;i++)
{
for(int j=1;j<tam-i-1;j++)
{
if (vec[j].edad> vec[j+1].edad)
{
temp=vec[j].edad;
vec[j].edad=vec[j+1].edad;
vec[j+1].edad=temp;
}
}
}

Ahí estás ordenando las edades... pero le estás asignando a cada individuo una edad que no es la suya... lo que tienes que ordenar es las estructuras en sí.

Además si estás usando dos bucles ( i y j ), no tiene sentido que a la hora de cambiar el orden uses solo j.

Código (cpp) [Seleccionar] Expandir


for(int i=1;i<tam-1;i++)
{
  for(int j=1;j<tam-i-1;j++)
  {
    if (vec[i].edad> vec[j].edad)
    {
      struct empleado temp = vec[i];
      vec[i]= vec[j];
      vec[j] = temp;           
    }
  }
}

En el caso de ordenar por nombre te pasa exactamente lo mismo.

PD.: intenta no usar variables globales, no suelen ser una buena idea en el 99% de los casos.

PD2.: ya que estás usando c++, lo mismo te resulta más cómodo utilizar la clase string para manejar las cadenas, en vez de char*. Además, te podrías plantear usar la clase vector en vez de un array de c para gestionar la lista de empleados.

PD3.: Hay una tercera forma de ordenar y es usando las funciones qSort y sort... pero eso es algo que dejo que investigues por tu cuenta.

Un saludo.