Dev - C++ - Traducir Modelo UML "roles cambiantes" a C++

 
Vista:
sin imagen de perfil
Val: 2
Ha disminuido su posición en 7 puestos en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Traducir Modelo UML "roles cambiantes" a C++

Publicado por GisiNA (1 intervención) el 21/02/2021 20:56:58
Estoy intentando de traducir el patrón de análisis de UML "roles cambiantes" a C ++, solo para entender cómo se traduce UML en código en general.

El patrón de análisis de "roles cambiantes" es el que se ve en la imgen adjunta.

Resumiré brevemente el patrón. Existe una asociación bidireccional de 1 a infinito entre las clases Visitante y RollesVisitante. RollesVisitante en sí misma es una clase base abstracta de las clases de Artistas e Invitados. Se obtiene un "rol cambiante" cuando un artista visita un evento como visitante. Si está como artista, no puede ser un invitado. A una obra en la que no actúa puede asistir como invitado. Entonces puede asumir el papel de invitado o de artista, pero en este contexto no al mismo tiempo. O es un invitado o un artista.

Acá el código que escribí:

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
#include <iostream>
#include <string>
#include <vector>
 
// ********************************** Clases ***********************************
class RollesVisitante;
class Visitante
{
  public:
    std::string nombre;
    bool permisoIngreso;
    std::vector<RollesVisitante*> razonVisita;
 
    Visitante ();
    Visitante (RollesVisitante&);
};
 
// Clase base abstracta
class RollesVisitante
{
  public:
    std::string visitanteRolle;
    virtual void defineVisitante ()=0;
 
  protected:
    Visitante * visitante;
};
 
 
// Herencia
class Invitado : public RollesVisitante
{
  public:
    bool adquirioEntrada;
    void defineVisitante () override;
};
 
class Artista : public RollesVisitante
{
  public:
    int rolleID;
    void defineVisitante () override;
};
 
// ********************************* METODOS ***********************************
Visitante ::Visitante (){}
Visitante ::Visitante (RollesVisitante& tipoVisitante )
{
  razonVisita.push_back(&tipoVisitante );
  razonVisita.at(0)->visitanteRolle="Invitado";
  // Downcasten geht hier nicht:
  //dynamic_cast<Invitado*>(razonVisita.at(0)->adquirioEntrada);
 
  razonVisita.push_back(new Artista);
  razonVisita.at(1)->visitanteRolle="Artista";
}
 
void Invitado::defineVisitante ()
{
  adquirioEntrada=true;
}
 
void Artista::defineVisitante () {/*steht was*/}
 
*
// *********************************** MAIN ************************************
int main()
{
  Invitado einInvitado;
  Visitante  visitanteRob(einInvitado);
  visitanteRob.permisoIngreso=true;
  visitanteRob.nombre="Rob";
 
  einInvitado.adquirioEntrada=true;
 
  return 0;
}


Primera pregunta: ¿Traduje adequadamente el modelo códico C++? Es correcta la utilización del vector? Si no es así, ¿cómo se implementaría?

Segunda pregunta: si es así. De esta forma, sin embargo, no puedo acceder a las clases hijas de "RollesVisitante": o sea a las clases Invitado y Artista.

1
razonVisita.at(0)->visitanteRolle.adquirioEntrada;

Tampco me resultó con dynamic_cast que me da un error de compilador:

1
error: 'rol de visitante de clase' no tiene un miembro llamado 'adquirioEntrada
'

Además, no creo que la solución con un cast sea óptima. Cómo sería una solución sin cast?

Este ejercicio es uno para mí. Estoy tratando de traspasar diferentes patrones de análisis UML a C ++. Pero soy nueva en este tema. Por eso pido comprensión si mis preguntas y mi intento son de novato.

Espero atenta vuestras respuestas!
Analysemodell_wechselnde_rollen
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