Dev - C++ - Patron prototype: como implementarlo

   
Vista:

Patron prototype: como implementarlo

Publicado por giuil (3 intervenciones) el 04/10/2015 13:02:28
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...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#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
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

Patron prototype: como implementarlo

Publicado por Hector (45 intervenciones) el 04/10/2015 19:08:22
Tienes unos cuantos conceptos confundidos amigo.

- Las funciones que estas creando en las clases no necesitan ; al final de su declaracion, el punto y coma solo va cuando estés llamando las funciones al utilizarlas o cuando vayas a declararlas dentro de la función pero desarrollarlas fuera de ella.

- La función virtual que declaraste en la clase prototipoTV esta declarada incorrectamente, puedes declarar una función virtual de dos formas:

Pura:
1
virtual void function() = 0;

Simple o impura:
1
2
3
4
virtual void function()
 {
  // El codigo
 }

La diferencia de ambas es que mientras que la impura puede ser instanciada, es decir, escribir sentencias dentro de ella, la función pura no se puede instanciar en la clase padre, solo a partir de sus hijos heredados.

- Por ultimo, no es necesario que uses la funcion clonar si lo que quieres es hacer una copia del objeto declarado, puedes instanciar el objeto directamente en la listaLED con new, y enviar el objeto al que deseas copiar, de esa forma creas multiples objetos dentro de la lista y cada uno va a ser independiente.

1
2
3
4
5
6
for (int x=0;x<10;x++)
{
    listaLED[x] = new prototipoLED(*primerLED);
 
    listaLED[x] -> getTipoTV();
}

Sobre el patron prototype, vi un código que estaba en google:

https://sourcemaking.com/design_patterns/prototype/cpp/1

Puedo ver que para devolver la instancia de la clase, hacen lo siguiente:

1
Stooge*   clone() { return new Curly; }

En tu caso tendrías que hacer esto:

1
prototipoTV* clonar(){     return new prototipoLED;         }

Espero que esto te ayude en algo, saludos.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar

Patron prototype: como implementarlo

Publicado por Hector (45 intervenciones) el 04/10/2015 19:36:51
Acabo de hacer una prueba amigo sobre el patron prototype, es algo parecido a lo que estabas haciendo:

En el prototipoTV

1
virtual prototipoTV* clonar() = 0;

En la clase prototipoLED

1
prototipoTV* clonar(){ return new prototipoLED(*this); }

Y en la clase cliente lo siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
static void obtenerTVs(){
 
            prototipoLED *primerLED =       new prototipoLED("samsung","dff","negro","IPS",1280,720,12,6);
 
            prototipoLED *listaLED[10];
 
            for (int x=0;x<10;x++)
            {
                listaLED[x] = (prototipoLED*)primerLED->clonar();
 
                listaLED[x] -> getTipoTV();
                cout << listaLED[x] -> get_m() << endl;
            }
 
        }

Si no funciona me dices.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar

Patron prototype: como implementarlo

Publicado por GIULI (3 intervenciones) el 04/10/2015 19:46:48
Correcto gracias amigo funciona perfecto.. me muestra soy un led 10 veces... repito para plasma y listo.. Sos un genio!!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar