-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathdiseño_tda.txt
231 lines (173 loc) · 15 KB
/
diseño_tda.txt
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
Diseño de los Tipos de Dato Abstracto (T.D.A):
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
Nombre de la clase: Menu.
Atributos de la clase:
- opcion_usuario: Será de tipo caracter. Dominio = {a, b, c, d, e, f, g, h} Vale la pena destacar que la opción h indica que el usuario
desea salir del menú principal.
- Gondola_principal: Será un objeto de clase Góndola.
- Chango_principal: Será un objeto de clase Chango.
Métodos de la clase:
//Descripción: Es el método constructor por defecto de un objeto de clase Menu. Se encarga de inicializar el atributo opcion_usuario con el
caracter a, de crear un objeto de clase Gondola con el constructor por defecto, y de crear un objeto de clase Chango con el constructor por
defecto.
//Precondiciones: -.
//Postcondiciones: Al crear un objeto de clase Menu, se inicializa el atributo opcion_usuario con el caracter a, se crea un objeto de clase
Gondola y otro objeto de clase Chango.
+ Menu();
//Descripción: Este método se encargará de devolver un caracter que indica la opcion de menú elegida por el usuario.
//Precondiciones: -.
//Postcondiciones: Retorna un caracter que representa al atributo opcion_usuario correspondiente a un objeto de clase Menu.
+ caracter obtener_opcion();
//Descripción: Este método se encargará de asignarle un nuevo caracter al atributo opcion_usuario perteneciente a un objeto de clase Menú.
//Precondiciones: La opcion pasada como parámetro debe encontrarse dentro del dominio de dicho atributo.
//Postcondiciones: El atributo opcion_usuario de clase Menu es asignado con el caracter pasado como parámetro opcion.
+ vacío asignar_opcion(char opcion);
//Descripción: De acuerdo con la opción que ha elegido el usuario, realiza una tarea particular.
//Precondiciones: La opción elegida por el usuario se encuentra dentro del dominio de dicho atributo.
//Postcondiciones: Ejecuta la opción acorde con lo que haya elegido el usuario.
+ vacío ejecutar_opcion();
//Descripción: Este método se encarga de mostrarle el menú de opciones del supermercado al usuario a través de una interfaz gráfica rudimentaria.
//Precondiciones: -.
//Postcondiciones: Se imprime por pantalla el menú de opciones para la visualización del usuario.
+ vacío mostrar_menu();
//Descripción: Este método privado tendrá como objetivo, realizar correctamente la opción a del Menú del supermercado.
//Precondiciones: Se ejecuta siempre que el usuario haya optado por la opción a del Menú del Supermercado.
//Postcondiciones: Cumple con eficacia la tarea a del Menú del supermercado.
- vacío ejecutar_opcion_a();
//Descripción: Este método privado tendrá como objetivo, realizar correctamente la opción b del Menú del supermercado.
//Precondiciones: Se ejecuta siempre que el usuario haya optado por la opción b del Menú del Supermercado.
//Postcondiciones: Cumple con eficacia la tarea b del Menú del supermercado.
- vacío ejecutar_opcion_b();
//Descripción: Este método privado tendrá como objetivo, realizar correctamente la opción c del Menú del supermercado.
//Precondiciones: Se ejecuta siempre que el usuario haya optado por la opción c del Menú del Supermercado.
//Postcondiciones: Cumple con eficacia la tarea c del Menú del supermercado.
- vacío ejecutar_opcion_c();
//Descripción: Este método privado tendrá como objetivo, realizar correctamente la opción d del Menú del supermercado.
//Precondiciones: Se ejecuta siempre que el usuario haya optado por la opción d del Menú del Supermercado.
//Postcondiciones: Cumple con eficacia la tarea d del Menú del supermercado.
- vacío ejecutar_opcion_d();
//Descripción: Este método privado tendrá como objetivo, realizar correctamente la opción e del Menú del supermercado.
//Precondiciones: Se ejecuta siempre que el usuario haya optado por la opción e del Menú del Supermercado.
//Postcondiciones: Cumple con eficacia la tarea e del Menú del supermercado.
- vacío ejecutar_opcion_e();
//Descripción: Este método privado tendrá como objetivo, realizar correctamente la opción f del Menú del supermercado.
//Precondiciones: Se ejecuta siempre que el usuario haya optado por la opción f del Menú del Supermercado.
//Postcondiciones: Cumple con eficacia la tarea f del Menú del supermercado.
- vacío ejecutar_opcion_f();
//Descripción: Este método privado tendrá como objetivo, realizar correctamente la opción g del Menú del supermercado.
//Precondiciones: Se ejecuta siempre que el usuario haya optado por la opción g del Menú del Supermercado.
//Postcondiciones: Cumple con eficacia la tarea g del Menú del supermercado.
- vacío ejecutar_opcion_g();
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
Nombre de la clase: Gondola.
Atributos:
- tamanio_gondola: Será un entero que represente la cantidad de productos que posea la Góndola. Dominio = {0...50}
- productos_de_gondola: Será un vector dinámico de objetos de clase Producto.
Métodos de la clase:
//Descripción: Es el método constructor de objetos de clase Gondola por defecto. Al crear un objeto de clase Gondola, inicializa el tamaño de la
Gondola en 1 y crea un vector dinámico de productos con el método constructor por defecto de productos.
//Precondiciones: -.
//Postcondiciones: Crea un objeto de clase Gondola con tamanio_gondola igual a 1 junto con un vector dinámico de productos.
+ Gondola();
//Descripción: Es el método destructor de objetos de clase Gondola. Se encarga de liberar el espacio destinado para alocar el vector de Productos
en memoria dinámica.
//Precondiciones: -.
//Postcondiciones: Libera el espacio utilizado para alocar el vector de productos en memoria dinámica.
+ ~Gondola();
//Descripción: Este método se encargará de devolver el tamanio_gondola de un objeto de clase Gondola.
//Precondiciones: -.
//Postcondiciones: Retorna el valor de tamanio_gondola de un objeto de clase Gondola.
+ entero obtener_tamanio_gondola();
//Descripción: Este método se encargará de asignarle un nuevo valor al tamaño de la góndola, que representa la cantidad de productos presentes en ella.
//Precondiciones: El tamanio_de_la_gondola pasado como parámetro debe ser un número positivo y natural, que no supere 50.
//Postcondiciones: Al atributo tamanio_gondola de un objeto de clase Gondola se le asigna el valor de tamanio_de_la_gondola, variable pasada como
parámetro.
+ vacío asignar_tamanio_gondola(entero tamanio_de_la_gondola);
//Descripción: Este método se encargará de leer todos los productos presentes en el archivo de texto, guarndando sus diferentes datos en el vector dinámico
productos_de_gondola, atributo de los objetos de clase Góndola.
//Precondición: Todos los productos, junto con sus diferentes datos, se encuentran acordes al estándar planteado por el enunciado de este trabajo. Es decir,
codigo_producto nombre_producto precio 0/1. El archivo txt existe y se puede abrir correctamente.
//Postcondición: Guarda los diferentes productos con sus atributos en el vector de memoria dinámica productos_de_gondola.
+ vacío lectura_productos_archivo_de_texto();
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
Nombre de la clase: Chango.
Atributos:
- tamanio_chango: Será un entero que represente la cantidad de productos que posee el Chango. Dominio = {0...50}
- productos_de_chango: Será un vector dinámico de objetos de clase Producto.
Métodos de la clase:
//Descripción: Es el método constructor de objetos de clase Chango por defecto. Al crear un objeto de clase Chango, inicializa el tamaño del
Chango en 1 y crea un vector dinámico de productos con el método constructor por defecto de productos.
//Precondiciones: -.
//Postcondiciones: Crea un objeto de clase Chango con tamanio_chango igual a 1 junto con un vector dinámico de productos.
+ Chango();
//Descripción: Es el método destructor de objetos de clase Chango. Se encarga de liberar el espacio destinado para alocar el vector de Productos
en memoria dinámica.
//Precondiciones: -.
//Postcondiciones: Libera el espacio utilizado para alocar el vector de productos en memoria dinámica.
+ ~Chango();
//Descripción: Este método se encargará de devolver el tamanio_chango de un objeto de clase Chango.
//Precondiciones: -.
//Postcondiciones: Retorna el valor de tamanio_chango de un objeto de clase Chango.
+ entero obtener_tamanio_chango();
//Descripción: Este método se encargará de asignarle un nuevo valor al tamaño del Chango, que representa la cantidad de productos presentes en éste.
//Precondiciones: El tamanio_del_chango pasado como parámetro debe ser un número positivo y natural, que no supere 50.
//Postcondiciones: Al atributo tamanio_chango de un objeto de clase Chango se le asigna el valor de tamanio_del_chango, variable pasada como
parámetro.
+ vacío asignar_tamanio_chango(entero tamanio_del_chango);
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
Nombre de la clase: Producto.
Atributos de la clase:
- nombre: Será una cadena de caracteres. Dominio = Letras comunes (Mayúsculas y minúsculas) y números. No se aceptan caracteres especiales.
El tamaño de la cadena deberá ser mayor que cero y menor que 50 (Máximo preestablecido).
- codigo_de_barras: Será un entero. Dominio = {0...9999}
- precio: Será un flotante. Dominio = {0...9999}
- esta_en_oferta: Será un booleano.
Métodos de la clase:
//Descripción: Es el método constructor por defecto. Al crear un objeto de clase Producto iniciliza todos los atributos con el valor 0.
//Precondiciones: -.
//Postcondiciones: Inicializa todos los atributos de un objeto de clase Producto con el valor 0.
+ Producto();
//Descripción: Es una sobrecarga del método constructor. Al utilizar este método para crear un objeto de clase Producto, se inicializan
todos los atributos con los valores o datos correspondientes que le ingresan a este método como parámetros.
//Precondiciones: Todos los parámetros que son pasados corresponden a datos válidos. La cadena de caracteres nombre_producto tiene un tamaño mayor
a cero y su cantidad de caracteres no supere al máximo preestablecido. El entero codigo_producto es mayor que cero, al igual que el precio_producto.
//Postcondiciones: Inicializa todos los atributos de un objeto de clase Producto con los valores o datos obtenidos como parámetros de este
método.
+ Producto(cadena de caracteres nombre_producto, entero codigo_producto, flotante precio_producto, booleano producto_en_oferta);
//Descripción: Este método se encargará de devolver la cadena de caracteres que representa el nombre del producto.
//Precondiciones: -.
//Postcondiciones: Retorna la cadena de caracteres que representa el nombre producto.
+ cadena de caracteres obtener_nombre();
//Descripción: Este método se encargará de asignarle un nuevo nombre al objeto de clase Producto.
//Precondiciones: El tamaño de la cadena de caracteres es mayor que cero y menor que el máximo preestablecido.
//Postcondiciones: Le otorga el nuevo nombre nombre pasado como párametro al objeto de clase Producto.
+ vacío asignar_nombre(cadena de caracteres nombre_producto);
//Descripción: Este método se encargará de devolver el código de barras de un objeto de clase Producto.
//Precondiciones: -.
//Postcondiciones: Retorna el código de barras correspondiente de un objeto de clase Prodcuto.
+ entero obtener_codigo();
//Descripción: Este método se encargará de asignarle un nuevo código al objeto de clase Producto.
//Precondiciones: El codigo_producto pasado como parámetro debe encontrarse dentro del dominio del atributo.
//Postcondiciones: El atributo codigo_de_barras del objeto de clase Producto es asignado con el valor de codigo_producto.
+ vacío asignar_codigo(entero codigo_producto);
//Descripción: Este método se encargará de devolver el precio de un objeto de clase Producto.
//Precondiciones: -.
//Postcondiciones: Retorna el precio correspondiente de un objeto de clase Prodcuto.
+ flotante obtener_precio();
//Descripción: Este método se encargará de asignarle un nuevo precio al objeto de clase Producto.
//Precondiciones: El precio_producto pasado como parámetro debe encontrarse dentro del dominio del atributo.
//Postcondiciones: El atributo precio del objeto de clase Producto es asignado con el valor de precio_producto.
+ vacío asignar_precio(flotante precio_producto);
//Descripción: Este método se encargará de devolver un booleana indicando si el objeto de clase Producto se encuentra o no en oferta.
//Precondiciones: -.
//Postcondiciones: Retorna un booleano indicando la condición de oferta de un objeto de clase Producto.
+ booleano obtener_condicion_oferta();
//Descripción: Este método se encargará de asignarle una nueva condición al booleano esta_en_oferta de un objeto determinado de clase Producto.
//Precondiciones: -.
//Postcondiciones: El atributo esta_en_oferta de un determinado objeto de clase Producto es reemplazado en condición por parámetro envíado
a través del método.
+ vacío asignar_condicion_oferta(booleano producto_en_oferta);
--------------------------------------------------------------------------------------------------------------------------------------------------------------------