Colas en c++

[juanluisalmonte]

Necesito hacer un generador de tickets en c++, ya tengo la interfaz grafica, pero aun no tengo idea de como implementar colas para asi manejar los tickets y posicionarlos.

Alguna ayuda.
Gracias de antemano.

[sam90]

Una cola puede ser representado con una lista o vector. Cuando necesitas un elementos sacas el primero...cuando agragas un elemento lo pones al final...

Esa es la idea general... necesitariamos saber mas sobre tu programa para dar mejores explicaciones,

[fightmx]

Puedes utilizar queue.

[juanluisalmonte]

Gracias sam90, pero en realida lo que tengo es una gran duda de como manejarlas, de como manejar los nodos, introducirlos, eliminarlos, agregarlos e implementar dicha cola en mi programa.

En si, el programa trata de un generador de tickets, parecido al de los bancos, donde el cliente toma su ticket y en la pantalla apareceraa el numero que esta siendo atendido.

Gracias de antemano.

[sam90]

Mira si tienes interfaz grafica, muy dificil no deberia ser crear una cola.
Podrias definir al nodo de esta forma:

Código C:

typedef struct  {
     int numero;
    struct nnodo * next;
}  Nodo;
 

Código C:

typedef struct  {
    struct nnodo * primero, ultimo;
}   Cola;
 

Teniendo esas estructuras primero inicializas la cola poniendo a primero y ultimo como NULL.
Para insertar en la cola lo que haces es.

ultimo->next = nuevonodo;
ultimo = nuevonodo;

Para borrar seria
aux = primero;
primero = primero->Next;
return aux;

Obviamente tenes que considerar los casos donde la cola esta vacia y esa cosas. Pensalo bien, desarrolla algo y si tenes alguna duda, comenta

[juanluisalmonte]

Gracias a todos por sus apreciados comentarios. Aqui les dejo lo que he adelantado y la idea de lo que quiero seguir haciendo.

tengo mis clases: Turno.h, Turno.cpp, Cola.h, Cola.cpp y Sistema.cpp
Lo que quiero ahora es que mis turnos vallan pasando uno por uno luego de que
el cliente tome uno.AAlguna idea.

El turno, vendria siendo cada nodo de mi cola.

clase: Turno.h

#include <iostream>
#include <string>

using namespace std;

class Turno{
private:
string nombre;
Turno* anterior;

public:
string getNombre();
void setNombre(string nombre);
Turno* getAnterior();
void setAnterior(Turno* anterior);
Turno();

};


Clase: Turno.cpp

#include "Turno.h"

string Turno:: getNombre(){

return nombre;
}

void Turno::setNombre(string nombre){
this -> nombre = nombre;
}

Turno* Turno::getAnterior(){

return anterior;
}

void Turno::setAnterior(Turno* anterior){
this -> anterior = anterior;
}

Turno::Turno(){
anterior = NULL;
}


Clase: Cola.h


#include "Turno.cpp"

class Cola{
private:
int tamano;
Turno* primero;
Turno* ultimo;

public:
Cola();
~Cola();
int getTamano();
void setTamano(int tamano);
Turno* getPrimero();
Turno* getUltimo();
Turno* extraer();
void agregar(Turno* turno);


};

Clase: Cola.cpp

#include "Cola.h"

Cola::Cola(){
primero = NULL;
ultimo = NULL;

}

Cola::~Cola(){
Turno* tempA;
Turno* tempB;

if(primero != NULL){
tempA = primero;
while(tempA != NULL){
tempB = tempA;
tempA = (*tempA).getAnterior();
delete tempB;
}

}
Cola();
}


int Cola::getTamano(){
return tamano;
}

Turno* Cola::getPrimero(){
return primero;

}

Turno* Cola::getUltimo(){
return ultimo;

}

void Cola::setTamano(int tamano){
this -> tamano = tamano;

}

void Cola::agregar(Turno* turno){
if(primero == NULL){
primero = turno;
ultimo = turno;
}
else{
Turno* temp = ultimo;
ultimo = turno;
temp->setAnterior(ultimo);

}
}

Turno* Cola:: extraer(){
if(primero == NULL){
return NULL;

}
Turno* temp = primero;
primero = primero -> getAnterior();
return temp;
}


Clase: Sistema.cpp (main)

#include "Cola.cpp"

using namespace std;

int main(){

Cola* cola = new Cola();

Turno* turno1 = new Turno();
Turno* turno2 = new Turno();

turno1 -> setNombre("JuanlUis");
turno2 -> setNombre("Otro");

cola ->agregar(turno1);
cola ->agregar(turno2);


Turno* i = cola -> extraer();

while(i != NULL){
cout<<i -> getNombre()<<endl;
delete i;
i = cola -> extraer();
}


system("PAUSE");
return 0;
}


Disculpen lo largo del comentario.

[sam90]

El codigo esta bien. Lo estuve leyendo y parece correcto. Lo que no logro entender eso de que vayan pasando los turnos?? Tu quieres representar eso de que la gente saca un numero y tiene que esperar a que le toque??

[juanluisalmonte]

Mis disculpas por no haberme explicado bien y gracias por tus comentarios.

Es exactamente eso que quiero, lo que mencionaste.Una persona toma un turno, pero luego espera a que su turno llegue.

pero el turno siguiente sera indicado por otra parte de la aplicacion.


Gracias de antemano.

[sam90]

Lo que podrias hacer es que al sacar un tuno se agrega a la cola. Despues habria un proceso que saca un item de la cola (el primero), ahi deberias comparar el turno sacado con todos los "clientes esperando". El que tenga ese mismo turno es al que antendes.

Deberias crear una comparacion de turnos. Una forma seria comparar el array. Otra fijarte si tenes el mismo puntero.

Igualmente estaria bueno saber mas sobre lo que quieres hacer...Para que lo estas aplicando.