Patron prototype: como implementarlo

[giuli956]

Bueno, quise implementar el patron prototype con 2 prototipos de tv que hereda del prototipo TV. PrototipoLED y prototypePLASMA, pero no funciona.
Obtengo el error 101 no matching function for call to `prototipoLED::prototipoLED(prototipoTV)' y luego muestra los parametros del constructor, es el tipico error de los atributos en el constructor pero no se como se resuleve...

Aqui el codigo

Código C++:

#include <iostream>
using namespace std;
class prototipoTV{
 
      protected:
      string marca;
      string modelo;
      string color;
      int resvert;
      int reshori;
      string TEC;
      int brillomax;
      int garantia;
      public:
             
      prototipoTV(string marcaTV,string modeloTV,string colorTV,string TECTV,
      int resvertTV,int reshoriTV,int brillomaxTV,int garantiaTV){
             marca=marcaTV;
             modelo=modeloTV;
             color=colorTV;
             TEC=TECTV;
             resvert=resvertTV;
             reshori=reshoriTV;
             brillomax=brillomaxTV;
             garantia=garantiaTV;
      };
      virtual prototipoTV clonar();
      
      void setMarca(string marcaTV){this->marca=marcaTV;};
      void setModelo(string modeloTV){this->modelo=modeloTV;};
      void setColor(string colorTV){this->color=colorTV;};
      void setTEC(string TECTV){this->TEC=TECTV;};
      void setResvert(int resvertTV){this->resvert=resvertTV;};
      void setReshori(int reshoriTV){this->reshori=reshoriTV;};
      void setBrillomax(int brillomaxTV){this->brillomax=brillomaxTV;};
      void setGarantia(int garantiaTV){this->garantia=garantiaTV;};
};      
class prototipoLED:public prototipoTV{
      private:
              int garantia;
      public:
            
             prototipoLED::prototipoLED(string marcaTV,string modeloTV,string colorTV,string TECTV,
             int resvertTV,int reshoriTV,int brillomaxTV,int garantiaTV):prototipoTV(marcaTV,modeloTV,
             colorTV,TECTV,resvertTV,reshoriTV,brillomaxTV,garantiaTV){
                                                               
                                                                       };
             void getTipoTV(){
                         cout<<("soy un LED")<<endl;
                         };
             prototipoTV clonar(){
                         //prototipoLED *LED2= new prototipoLED("A","A","A","A",1,1,1,1);
                         prototipoTV *LED2= new prototipoLED(*this);
                         /*LED2->setMarca(this->marca);
                         LED2->setBrillomax(this->brillomax);
                         LED2->setColor(this->color);
                         LED2->setModelo(this->modelo);
                         LED2->setReshori(this->reshori);
                         LED2->setResvert(this->resvert);
                         LED2->setTEC(this->TEC);
                         LED2->setGarantia(this->garantia);*/
                         return *LED2;
                         };
      };
class prototipoPLASMA:public prototipoTV{
      private:
              int garantia;
      public:
          
             prototipoPLASMA::prototipoPLASMA(string marcaTV,string modeloTV,string colorTV,string TECTV,
             int resvertTV,int reshoriTV,int brillomaxTV,int garantiaTV):prototipoTV(marcaTV,modeloTV,
             colorTV,TECTV,resvertTV,reshoriTV,brillomaxTV,garantiaTV){
                                                                   
                                                                       };
             void getTipoTV(){
                         cout<<("soy un PLASMA")<<endl;
                         }
             prototipoTV clonar(){
                         prototipoPLASMA *PLASMA2= new prototipoPLASMA("samsung","dff","negro","IPS",1280,720,12,24);
                         PLASMA2->setMarca(this->marca);
                         PLASMA2->setBrillomax(this->brillomax);
                         PLASMA2->setColor(this->color);
                         PLASMA2->setModelo(this->modelo);
                         PLASMA2->setReshori(this->reshori);
                         PLASMA2->setResvert(this->resvert);
                         PLASMA2->setTEC(this->TEC);
                         return *PLASMA2;
                         };
      };
class Cliente{
     
      
    
    public: static void obtenerTVs(){ 
            prototipoLED *primerLED=new prototipoLED("samsung","dff","negro","IPS",1280,720,12,6);
            prototipoPLASMA *primerPLASMA= new prototipoPLASMA("samsung","dff","negro","IPS",1280,720,12,6);
            prototipoLED *listaLED[10];
            prototipoPLASMA *listaPLASMA[10];
            for (int x=0;x<10;x++){
                       // cout<<primerLED->clonar()<<endl;  
                        listaLED[x]= (prototipoLED) primerLED->clonar();
                     //  listaPLASMA[x]=(prototipoPLASMA) primerPLASMA->clonar();
                      
                       
                       listaLED[x]->getTipoTV();
                   
                                     };
           
                            }; 
      };
int main(){
    
    Cliente::obtenerTVs();
        
           system("pause");
           return 0;
           };
 

estoy probando primero con LEd para luego hacer PLASMA.
Saludos

[eferion]

Tienes varios errores:

Código C++:

class prototipoLED:public prototipoTV{
      private:
              int garantia;
      public:
            
             prototipoLED::prototipoLED(string marcaTV,string modeloTV,string colorTV,string TECTV,
 

En la declaración de una clase, las funciones miembro no deben indicar el ámbito de la función prototipoLED::prototipoLED() debería ser, simplemente prototipoLED(). Lo otro déjalo para las implementaciones. ¿Por qué? Si prototipoLED tiene una clase anidada que se llama prototipoLED vas a implementar la función de esta segunda clase... la confusión está asegurada.

Código C++:

class prototipoTV{
  virtual prototipoTV clonar();
};
 

Dos cosas respecto a esta función:

1. Si prototipoTV no va a ser una clase construible como tal, ésta función debería ser virtual pura, es decir, la declaración debería terminar con =0 y no debería poseer implementación.
2. Si devuelves un objeto de tipo prototipoTV en vez de devolver un puntero lo que va a suceder es que al llamar a prototipoLED::clonar() vas a obtener un objeto de tipo prototipoTV que no podrás convertir a uno de tipo prototipoLED. ¿Por qué? porque al hacer:
   
   
   Código C++:

   class prototipoLED
   {
     prototipoTV clonar()
     {
       prototipoTV *LED2= new prototipoLED(*this);
       return *LED2; // <<< AQUI!!!
     }
   };
    

   Estarás llamando al constructor copia de prototipoTV, el cual te devolverá una instancia de prototipoTV no convertible a ninguna otra clase hija. Si no entiendes este punto deberías revisar el tema del polimorfismo... el polimorfismo no funciona con objetos usados por valor.

Volviendo a la función prototipoLED::clonar()...

Código C++:

class prototipoLED
{
  prototipoTV clonar()
  {
    prototipoTV *LED2= new prototipoLED(*this);
    return *LED2; // <<< AQUI!!!
  }
};
 

Otras dos cosillas:

1. Al hacer:
   
   Código C++:

   new prototipoLED(*this)
    

   
   estás llamando al constructor copia de prototipoLED. Como no lo has implementado el compilador creará una versión por defecto... esta versión por defecto llamará al constructor por defecto de prototipoTV. Este último constructor copiará el valor de todos los miembros a la nueva instancia. Este detalle no suele dar problemas hasta que gestionas memoria dinámica. No es tu caso, pero ándate con ojo al usar constructores no implementados explícitamente.
2. No se si te estás dando cuenta, pero al hacer:
   
   Código C++:

   return *LED2;
    

   Estás dejando a LED2 en el limbo, ya que has reservado memoria con new pero no has hecho ningún delete. Esto se llama fuga de memoria y es un problema muy serio en un programa. Este problema se resolverá cuando descubras que "clonar" tiene que devolver punteros.

Más cosillas. ¿Qué imaginas que estás haciendo con estas dos líneas?

Código C++:

prototipoLED *listaLED[10];
prototipoPLASMA *listaPLASMA[10];
 

¿cada una de estas listas almacena objetos por valor? ¿referencias tal vez? ¿punteros?

Son listas de punteros, luego la siguiente línea no tiene ningún sentido:

Código C++:

listaLED[x]= (prototipoLED) primerLED->clonar();
 

por lo siguiente:

primerLED->clonar() devuelve un objeto por valor de tipo prototipoTV, como este objeto ya no es, a diferencia de lo que esperas, de tipo prototipoLED, el compilador tiene que llamar implícitamente al constructor prototipoLED(constructorTV) el cual no no existe porque tú no lo has implementado y porque el compilador no lo va a crear por su cuenta. Por cierto... te suena de algo este constructor?. Bueno, el caso es que después intentas almacenar un objeto por valor dentro de una lista de punteros!!!!!!

Y, por otro lado, una de las gracias de usar polimorfismo es poder usar prototipoLED y prototipoPlasma en una misma lista sin tener que preocuparte de sus diferencias internas... crear este esquema de clases para luego usar cada clase por separado no tiene absolutamente ningún sentido. Para eso usas el patrón decoración y te ahorras un montón de trabajo.

Lo suyo sería que tuvieses:

Código C++:

prototipoTV* lista[10];
 

Y que ahí almacenases todas las televisiones.

Y bueno, para terminar, decir que Cliente::obtenerTVs() crea dos listas de elementos pero ni limpia memoria ni devuelve dichas listas, luego acabarás creando nuevamente fugas de memoria.

Un saludo.