posible problema con una clase

[starfix]

hola a todos, tengo un error de compilacion con mi programa, como es muy largo todo el codigo tenia pensado si me podian ayudar a encontrar el problema leyendolo de a poco, por ahora comenzando con la clase principal con la cual se genera el problema, para ver si esta bien echa:

bueno, este es el codigo de la clase:

ARCHIVO ".h":

Código C++:

//---------------------------------------------------------------------------
 
#ifndef cmesaH
#define cmesaH
#include "cproductos.h"
#include <vector>
 
using namespace std;
//---------------------------------------------------------------------------
 
class Mesa{
 
private:
 
UnicodeString __Mozo;
 
vector<Producto*> __Consumo;
vector<float> __Cantidad;
 
int __Numero;
float __Monto;
 
Mesa *__Siguiente;
 
public:
 
   __property float Total= {read= __Monto, write= __Monto};
   __property int Numero_Mesa= {read= __Numero, write= __Numero};
   __property UnicodeString Mozo= {read= __Mozo, write= __Mozo};
   __property Mesa* Siguiente= {read= __Siguiente, write= __Siguiente};
   __property vector<Producto*> Consumo= {read= __Consumo};
   __property vector<float> Cantidad= {read= __Cantidad};
 
   Mesa(int Numero, UnicodeString Mozo);
   Mesa(Mesa *__Mesa);
 
   ~Mesa();
 
   int Buscar(Producto *__Producto);
 
   void Ordenar(){};
   bool Agregar(Producto *__Producto, float __Cantidad);
 
   Producto* Quitar(Producto *__Producto);
   bool Quitar(UnicodeString __Nombre, float __Cantidad);
 
 
   friend class Lista_Mesa;
};
 
//---------------------------------------------------------------------------
 
class Lista_Mesa{
 
private:
 
Mesa *__Primero, *__Ultimo;
 
public:
 
__property Mesa* Primero= {read= __Primero, write= __Primero};
__property Mesa* Ultimo= {read= __Ultimo};
 
Lista_Mesa(){this->__Primero= NULL; this->__Ultimo=NULL;};
 
 
Mesa* Buscar_Mesa(int Numero);
Mesa* Buscar_Ultima_Mesa(int Numero);
 
bool Nueva_Mesa(int Numero, UnicodeString __Mozo);
bool Nueva_Mesa(Mesa *__Mesa, bool __Repetir = false);
 
Mesa* Cobrar(int Numero_Mesa);
 
};
#endif
 

ARCHIVO ".cpp":

Código C++:

//---------------------------------------------------------------------------
 
 
#pragma hdrstop
 
#include "cmesa.h"
//---------------------------------------------------------------------------
 
Mesa::Mesa(int Numero,UnicodeString Mozo){
 
this->__Numero= Numero;
this->__Mozo= Mozo;
this->__Monto= 0;
}
//---------------------------------------------------------------------------
 
Mesa::Mesa(Mesa *__Mesa){
 
this->__Numero= __Mesa->Numero_Mesa;
this->__Mozo= __Mesa->Mozo;
this->__Monto= __Mesa->Total;
 
for (unsigned int i = 0; i < __Mesa->Consumo.size(); i++)
     this->Agregar(__Mesa->Consumo[i], __Mesa->Cantidad[i]);
 
}
 
//---------------------------------------------------------------------------
 
Mesa::~Mesa(){
__Consumo.erase(__Consumo.begin(), __Consumo.end());
__Cantidad.erase(__Cantidad.begin(), __Cantidad.end());
}
 
//---------------------------------------------------------------------------
 
bool Mesa::Agregar(Producto *__Producto, float __Cantidad){
 
 
int Posicion= this->Buscar(__Producto);
 
if (Posicion == -1){
 
Producto *__Nuevo= new Producto(__Producto);
 
this->__Consumo.push_back(__Nuevo);
this->__Cantidad.push_back(__Cantidad);
 
}else this->__Cantidad.at(Posicion)+= __Cantidad;
 
this->__Monto+= __Producto->Precio * __Cantidad;
 
return 1;
 
}
 
//---------------------------------------------------------------------------
 
 
Producto* Mesa::Quitar(Producto *__Producto){
 
Producto *Devolver= NULL;
 
 
for (unsigned int i = 0; i < this->__Consumo.size(); i++) {
   if (this->__Consumo[i] == __Producto) {
 
            Devolver= __Producto;
            this->__Consumo[i]= this->__Consumo[this->__Consumo.size()-1];
            this->__Consumo.pop_back();
 
            this->__Cantidad[i]= this->__Cantidad[this->__Cantidad.size()-1];
            this->__Cantidad.pop_back();
 
            break;
   }
}
return Devolver;
}
 
 
//---------------------------------------------------------------------------
 
int Mesa::Buscar(Producto *__Producto){
 
 
for (unsigned int i = 0; i < this->__Consumo.size(); i++){
   if ((this->__Consumo.at(i)->Nombre == __Producto->Nombre) &&
       (this->__Consumo.at(i)->SubTipo == __Producto->SubTipo))
 
       return i;
       }
 
 
return -1;
 
}
 
//---------------------------------------------------------------------------
 
bool Mesa::Quitar(UnicodeString __Nombre, float __Cantidad){
 
for (unsigned int i = 0; i < this->__Consumo.size(); i++)
 
    if ((this->__Consumo[i]->Nombre== __Nombre) &&
        (this->__Cantidad[i] == __Cantidad)){
 
         this->__Monto-= this->__Consumo[i]->Precio * this->__Cantidad[i];
 
         this->__Consumo[i]= this->__Consumo[this->__Consumo.size()-1];
         this->__Consumo.pop_back();
 
         this->__Cantidad[i]= this->__Cantidad[this->__Cantidad.size()-1];
         this->__Cantidad.pop_back();
 
         return 1;
         }
 
return 0;
}
 
//---------------------------------------------------------------------------
 
 
 
 
//---------------------------------------------------------------------------
 
bool Lista_Mesa::Nueva_Mesa(int Numero, UnicodeString __Mozo){
 
if (this->Buscar_Mesa(Numero)) return 0;
 
Mesa *Aux= new Mesa(Numero, __Mozo);
 
 
if (this->Ultimo) Ultimo->__Siguiente= Aux;
 
this->__Ultimo= Aux;
this->__Ultimo->__Siguiente= NULL;
 
if (!this->__Primero) this->__Primero= Aux;
 
return 1;
}
 
//---------------------------------------------------------------------------
 
bool Lista_Mesa::Nueva_Mesa(Mesa *__Mesa, bool __Repetir){
 
if (__Repetir == false)
    if (this->Buscar_Mesa(__Mesa->Numero_Mesa)) return 0;
 
if (this->__Ultimo) Ultimo->__Siguiente= __Mesa;
 
this->__Ultimo= __Mesa;
this->__Ultimo->__Siguiente= NULL;
 
if (!this->__Primero) this->__Primero= __Mesa;
 
return 1;
}
 
//---------------------------------------------------------------------------
 
Mesa* Lista_Mesa::Buscar_Mesa(int Numero){
 
Mesa *Devolver= this->__Primero;
 
while (Devolver){
 
   if (Devolver->__Numero == Numero) return Devolver;
 
Devolver= Devolver->Siguiente;
}
 
return Devolver;
}
//---------------------------------------------------------------------------
 
Mesa* Lista_Mesa::Buscar_Ultima_Mesa(int Numero){
 
Mesa *Devolver= NULL;
Mesa *Aux= this->__Primero;
 
while (Aux){
 
   if (Aux->__Numero == Numero) Devolver = Aux;
 
Aux= Aux->Siguiente;
}
 
return Devolver;
}
 
//---------------------------------------------------------------------------
Mesa* Lista_Mesa::Cobrar(int Numero_Mesa){
 
Mesa *Devolver= this->Primero;
Mesa *Sig= Devolver->Siguiente;
 
 
if (Devolver->Numero_Mesa == Numero_Mesa) {
 
this->Primero= Sig;
Devolver->Siguiente= NULL;
 
return Devolver;
}
 
while (Sig){
 
            if (Sig->Numero_Mesa == Numero_Mesa) {
 
            Devolver->Siguiente= Sig->Siguiente;
            Sig->Siguiente= NULL;
            return Sig;
                  }
 
Devolver= Sig;
 
Sig= Sig->Siguiente;
}
 
return Sig;
}
//---------------------------------------------------------------------------
#pragma package(smart_init)
 

bien, esta clase, o lo que trate de definir, es una lista enlazada.

el problema radica cuando ejecuto el codigo Mesa* Cobrar(int Numero_Mesa); y luego trato crear una nueva mesa si es que no existe con bool Nueva_Mesa(int Numero, UnicodeString __Mozo); no lo hace. En simples palabras, luego de cobrar una mesa, no puedo crear una nueva

se que el codigo es algo largo de ver, pero tengo tiempo si es que lo hacen, el programa recien lo voy a presentar en julio para rendir y este es el unico problema que tengo.....


como dice el titulo es posible que la clase tenga un error, puede que sea en la implementacion propia del programa, pero es mejor si lo vamos viendo de a poco, yo hace 1 me y medio que estoy con este problema :S

saludos y gracias de antemano