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
/******************************************************* /************************************ ************************************** ************************************** ************************ ***** * Módulo: practica_4 * Muestra el menú de opciones disponibles para gestionar las ventas de una empresa. * * Autor: Rafael Grau * Versión: 2013.12.20 ************************************* ****************** ************************************** ************************************** ************************************** ***********************/ ****/ #include #include #include "ventas.h" /* PROGRAMA PRINCIPAL -----------------------------------------------------------------------------------------------------------------------------------------------------Muestra un menú con las opciones opciones disponibles disponibles del programa. ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/ ---*/ main (){ int main(){
int respuesta; respuesta; bool continuar= continuar=true;
TipoVe TipoVecto ctorVe rVenta ntas s listaV listaVent entas as; ; Tipo TipoVe Vent nta a vent venta a; venta.InicializarVectorVentas InicializarVectorVentas( (listaVentas); listaVentas);
do{ system ("cls" "cls"); ); printf ("ANALIZADOR DE VENTAS\n" ); printf ("\n" "\n"); ); printf ("1. Introducir venta\n"); venta\n" ); printf ("2. Eliminar venta\n"); venta\n"); printf ("3. Listar ventas de un mes\n"); mes\n" ); printf ("4. Listar productos por orden de ventas\n" ventas\n"); ); printf ("\n" "\n"); ); printf ("5. Salir\n"); Salir\n"); printf ("\n" "\n"); ); printf ("Opcion?" "Opcion?"); ); scanf("%d" "%d",& ,&respuesta respuesta); );
switch (respuesta){ respuesta){ case 1 1: :
venta.IntroducirVenta IntroducirVenta( (listaVentas); listaVentas);
break; 2: : case 2
break; case 3 3: :
break; 4: : case 4
break; 5: : case 5
venta.EliminarVenta( EliminarVenta(listaVentas); listaVentas);
venta.ListarVentasMes ListarVentasMes( (listaVentas); listaVentas);
venta.ListarProductosOrdenVentas ListarProductosOrdenVentas( (listaVentas); listaVentas);
continuar=false; system ("cls" "cls"); ); break;
}
while }while(continuar); continuar); }
/************************************************************************************************** 1 2 * Interfaz de módulo: Ventas 3 * Gestiona y analiza las ventas de una empresa: * 4 5 * Autor: Rafael Grau 6 * Versión: 2014.01.02 **************************************************************************************************/ 7 8 #pragma once 9 10 /* Constante con el máximo de ventas permitidas según las especificaciones de la práctica */ const int MAXVENTAS=1000; 11 12 13 /*DEFINICION DE TIPOS*/ 14 typedef struct TipoFecha{ 15 int anio; 16 int mes; int dia; 17 18 }; 19 typedef struct TipoProducto { 20 int identificador; 21 int unidades; 22 TipoFecha fechaVenta; 23 }; 24 /*Tipo vector para almacenar las ventas*/ 25 typedef TipoProducto TipoVectorVentas[MAXVENTAS]; 26 27 typedef struct TipoVenta{ 28 /*Inicializa un vector TipoVentorVentas*/ 29 void InicializarVectorVentas(TipoVectorVentas vectorVentas); 30 /*Introduce una nueva venta en el vector*/ 31 void IntroducirVenta(TipoVectorVentas vectorVentas); 32 /*Elimina una venta existente del vector*/ 33 void EliminarVenta(TipoVectorVentas vectorVentas); 34 /*Lista las ventas de un mes dado existentes en el vector*/ 35 void ListarVentasMes(TipoVectorVentas vectorVentas); 36 /*Lista las ventas de un año dado ordenadas de mayor a menor número de unidades vendidas.*/ 37 void ListarProductosOrdenVentas(TipoVectorVentas vectorVentas); 38 39 private : 40 /*Inicializa un refistro TipoProducto*/ 41 void InicializarRegistro(TipoProducto &producto); 42 /*Copia en un vector el conenido de otro vector */ 43 void CopiarVectorVentas(TipoVectorVentas &vectorDestino, TipoVectorVentas vectorOrigen); 44 /*Pide el identificador del producto*/ 45 void PedirIdentificador(int &identificador); 46 /*Ordena el vector moviendo los elementos vacios a la derecha*/ 47 void CompactarVectorVentas(TipoVectorVentas vectorVentas,int inicio, int final); 48 /*Ordena el vector de mayor a menor número de ventas*/ 49 void OrdenarVectorPorVentas(TipoVectorVentas vectorVentas,int limiteVector); 50 /*Ordena el vector de menor a mayor fecha*/ 51 void OrdenarVectorPorFecha(TipoVectorVentas vectorVentas,int limiteVector); 52 /*Pide el número de unidades vendidas*/ 53 void PedirUnidades(int &unidades); 54 /*Comprueba que dos fechas son iguales*/ 55 bool FechasIguales(TipoFecha fecha1, TipoFecha fecha2); 56 /*Compara dos fechas. Devuelve ’true’ si la primera es posterior a la segunda.*/ 57 bool FechaPosterior (const TipoFecha fecha1,const TipoFecha fecha2); 58 /*Comprueba que se ha registrado almenos una venta*/ 59 bool ComprobarVentasRealizadas(int ventas); 60 /*Comprueba si se ha alcanzado el máximo de ventas permitido.*/ 61 bool MaximoVentasAlcanzado(int ventas); 62 /*Imprime un mensaje de error avisando que todavía no se han almacenado ventas en el vector*/ 63 void MensajeMaximoVentasPermitido(); 64 /*Imprime un mensaje de error avisando que Ya ha introdicido el numero maximo de ventas permitido.*/ 65 void MensajeVectorVacio(); 66 /*Imprime un mensaje de error avisando que no existen ventas en la fecha introducida*/ 67 void MensajeVentaNoEncontrada(); 68 /*Imprime un mensaje de error avisando que el vector se ha borrado satisfactoriamente*/ 69 void MensajeVectorBorrado(); 70 }; 71 72 73 74
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
/************************************************************************************************** * Módulo: Ventas * Gestiona y analiza las ventas de una empresa: * * Autor: Rafael Grau * Versión: 2014.01.02 **************************************************************************************************/ #include #include #include #include "Ventas.h" #include "calendario.h" int ventasRealizadas=0; T ip oCa len da ri o c ale nda rio; /* Procedimiento InicializarVectorVentas --------------------------------------------------------Copia en cada uno de los elementos del vector un registro con los variables inicializadas a cero. -------------------------------------------------------------------------------------------------*/ void TipoVenta::InicializarVectorVentas(TipoVectorVentas vectorVentas){ TipoProducto producto; InicializarRegistro(producto); for (int i=0;i
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
/*creamos las variables necesarias para el procedimiento y las inicializamos*/ bool encontrado=false; //variable centinela para controlar si existen ventas TipoProducto elementoBuscado; InicializarRegistro(elementoBuscado); /*borramos la pantalla*/ system("cls"); /*Si todavía no hay ventas almacenadas, terminamos el procedimiento*/ if (!ComprobarVentasRealizadas(ventasRealizadas)){ return ; } /*pedimos el numero identificador del producto*/ PedirIdentificador(elementoBuscado.identificador); /*pedimos los datos del calendario*/ calendario.PedirFecha(elementoBuscado.fechaVenta.dia,elementoBuscado.fechaVenta.mes,elementoBuscado.fechaVenta. anio); /*si la fecha NO es correcta finalizamos el proceso*/ if (!calendario.ComprobarFecha(elementoBuscado.fechaVenta.dia,elementoBuscado.fechaVenta.mes,elementoBuscado. fechaVenta.anio)) { return ; } /*recorremos el vector en busca de los datos solicitados*/ for (int i=0;i
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 /* Procedimientos ListarVentasMes ----------------------------------------------------------------145 Pide identificador del producto, mes y año y lista las ventas coincidentes con los datos dados. 146 Si no encuentra ventas coincidentes, imprime un mensaje de error explicativo. 147 Antes de pedir los datos, comprueba que previamente se ha introducido alguna venta en el vector de ventas. 148 Si no existe alguna venta almacenada, se imprime un mensaje de advertencia y finalizamos el procedimiento. 149 -------------------------------------------------------------------------------------------------*/ 150 void TipoVenta::ListarVentasMes(TipoVectorVentas vectorVentas){ 151 bool ventaEncontrada=false; //variable centinela para controlar si existen ventas 152 TipoProducto producto; 153 InicializarRegistro(producto); 154 /*borramos la pantalla*/ 155 system("cls"); 156 /*Si todavía no hay ventas almacenadas, terminamos el procedimiento */ 157 if (!ComprobarVentasRealizadas(ventasRealizadas)){ 158 return ; 159 } 160 /*pedimos el numero identificador del producto*/ 161 PedirIdentificador(producto.identificador); 162 /*pedimos los datos del calendario*/ 163 calendario.PedirFechaMes(producto.fechaVenta.mes); 164 /*pedimos los datos del calendario*/ 165 calendario.PedirFechaAnio(producto.fechaVenta.anio); 166 /*si la fecha NO es correcta finalizamos el proceso*/ 167 if ((!calendario.ComprobarFechaMes(producto.fechaVenta.mes))&& 168 (!calendario.ComprobarFechaAnio(producto.fechaVenta.anio))){ 169 return ; 170 }else { 171 /*si la fecha es correcta se imprime el calendario*/ 172 calendario.ImprimirCalendarioVentas(producto.fechaVenta.mes,producto.fechaVenta.anio,vectorVentas); 173 } 174 /*buscamos si existen en el vector ventas en la fecha introducida*/ for (int i=0;i
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 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
void TipoVenta::ListarProductosOrdenVentas(TipoVectorVentas vectorVentas){ bool ventaEncontrada=false; //variable centinela para controlar si existen ventas TipoVectorVentas vectorAux; //no hace falta inicializarlo porque voy a copiar datos en él. TipoProducto producto; //no hace falta inicializarlo porque voy a copiar datos en él. int posicion,anio; int num=1; //variable usada como contador numerar ventas listadas. /*borramos la pantalla*/ system("cls"); /*Si todavía no hay ventas almacenadas, terminamos el procedimiento */ if (!ComprobarVentasRealizadas(ventasRealizadas)){ return ; } /*pedimos los datos del calendario*/ calendario.PedirFechaAnio(anio); /*si la fecha NO es correcta finalizamos el proceso*/ if (!calendario.ComprobarFechaAnio(anio)) { return ; } /*Copiamos el vector de ventas en un vector auxiliar*/ CopiarVectorVentas(vectorAux,vectorVentas); /*Ordenamos el vector auxiliar de mayor a menor número de ventas*/ OrdenarVectorPorVentas(vectorAux,ventasRealizadas); /* Buscamos en el vector auxiliar los datos solicitados*/ for (int i=0;i inicio) && (vectorVentas[posicion-1].unidades == 0)){ vectorVentas[posicion]=vectorVentas[posicion-1]; posicion--; } vectorVentas[posicion]=valor; } } /* Procedimiento OrdenarVectorPorVentas ----------------------------------------------------------Ordena el vectorVentas de mayor a menor número de unidades vendidas. -------------------------------------------------------------------------------------------------*/ void TipoVenta::OrdenarVectorPorVentas(TipoVectorVentas vectorVentas,int limiteVector){ TipoProducto valor; int posicion; for (int i=1;i 0) && (valor.unidades > vectorVentas[posicion-1].unidades)){ vectorVentas[posicion]=vectorVentas[posicion-1]; posicion--; } vectorVentas[posicion]=valor; } } /* Procedimiento OrdenarVectorPorFecha -----------------------------------------------------------Ordena el vectorVentas de nenor a mayor fecha. -------------------------------------------------------------------------------------------------*/ void TipoVenta::OrdenarVectorPorFecha(TipoVectorVentas vectorVentas,int limiteVector){ TipoProducto valor; int posicion; for (int i=1;i 0) && (FechaPosterior(vectorVentas[posicion-1].fechaVenta,valor.fechaVenta)) && (valor.unidades!=0)){ vectorVentas[posicion]=vectorVentas[posicion-1]; posicion--; } vectorVentas[posicion]=valor; } } /* Funcion FechaPosterior -------------------------------------------------------------------------
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
Compara si una fecha es posterior a otra. Devuelve verdadero si la primera es posterior a la segunda. (Obtenido del libro de la asignatura) -------------------------------------------------------------------------------------------------*/ bool TipoVenta::FechaPosterior (const TipoFecha fecha1,const TipoFecha fecha2){ if (fecha1.anio != fecha2.anio){ return (fecha1.anio > fecha2.anio); }else if (fecha1.mes != fecha2.mes){ return (fecha1.mes > fecha2.mes); }else { return (fecha1.dia > fecha2.dia); } } /* Funcion FechasIguales -------------------------------------------------------------------------Compara si dos fechas son iguales. Devuelve verdadero si son iguales. -------------------------------------------------------------------------------------------------*/ bool TipoVenta::FechasIguales (TipoFecha fecha1, TipoFecha fecha2){ if ((fecha1.dia == fecha2.dia) && (fecha1.mes == fecha2.mes) && (fecha1.anio == fecha2.anio)){ return true ; }else { return false; } } /* Procedimiento PedirIdentificador --------------------------------------------------------------Pide el identificador de producto y lo almacena en la variable pasada por referencia. Verifica que las unidades introducidas sean positivas y muestra un mensaje en caso contrario. -------------------------------------------------------------------------------------------------*/ void TipoVenta::PedirIdentificador(int &identificador){ printf("Identificador de Producto? " ); fflush(stdin); //limpiamos el buffer del teclado scanf("%d",&identificador); while ((identificador<1) || (identificador>INT MAX)){ printf("\nAviso. Solo se permiten n%cmeros positivos.\n" ,163); //163 = "ú" printf("Identificador de Producto? " ); fflush(stdin); //limpiamos el buffer del teclado scanf("%d",&identificador); } } /* Procedimiento PedirUnidades -------------------------------------------------------------------Pide el las unidades de producto y lo almacena en la variable pasada por referencia. Verifica que las unidades introducidas sean positivas y muestra un mensaje en caso contrario. -------------------------------------------------------------------------------------------------*/ void TipoVenta::PedirUnidades(int &unidades){ printf("Unidades? "); fflush(stdin); //limpiamos el buffer del teclado scanf("%d",&unidades); while ((unidades<1) || (unidades>INT MAX)){ printf("\nAviso. Solo se permiten n%cmeros positivos.\n" ,163); //163 = "ú" printf("Unidades? "); fflush(stdin); //limpiamos el buffer del teclado scanf("%d",&unidades); } } /* Procedimiento ComprobarVentasRealizadas -------------------------------------------------------Devuelve verdadero si la variable ventasRealizadas tiene registrada alguna venta. En caso contrario se imprime mensaje de error y devuelve ’false’ -------------------------------------------------------------------------------------------------*/ bool TipoVenta::ComprobarVentasRealizadas(int ventas){ if (ventas>0){ return true ; }else { MensajeVectorVacio(); return false; } } /* Procedimiento MaximoVentasAlcanzado -----------------------------------------------------------Devuelve verdadero si se ha alcanzado el máximo de ventas impuesto por la variable ’MAXVENTAS’ y se imprime un mensaje de error. En caso contrario devuelve ’false’. -------------------------------------------------------------------------------------------------*/ bool TipoVenta::MaximoVentasAlcanzado(int ventas){ if (ventas
399 Imprime un mensaje de error avisando que no existen ventas en la fecha introducida 400 -------------------------------------------------------------------------------------------------*/ 401 void TipoVenta::MensajeVentaNoEncontrada(){ 402 printf("\nNo existen ventas en la fecha introducida.\n\n"); 403 calendario.HacerPausa(); 404 } 405 406 /* Procedimiento MensajeVectorBorrado ------------------------------------------------------------407 Imprime un mensaje de error avisando que el vector se ha borrado satisfactoriamente. 408 -------------------------------------------------------------------------------------------------*/ 409 void TipoVenta::MensajeVectorBorrado(){ 410 printf("\nVenta borrada satisfactoriamente.\n\n"); 411 calendario.HacerPausa(); 412 } 413
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
/************************************************************************************************** * Interfaz de módulo: calendario * Imprime en pantalla un calendario para un mes y año dados. * Admite la entrada de un dato TipoVectorVentas para poder señalar en el calendario los días en los * cuales se ha introducido una venta. * Valida que los datos de la fecha introducidos estan dentro del rango permitido. * * Autor: Rafael Grau * Versión: 2013.12.15 **************************************************************************************************/ #pragma once #include "Ventas.h" /*Tipo enumerado con los dias de la semana*/ typedef enum TipoDia {Lunes,Martes,Miercoles,Jueves,Viernes,Sabado,Domingo}; /*Tipo cadena de texto para nombre del mes*/ typedef char TipoCadenaNombreMes[12]; /*Tipo vector con cadenas de texto para almacenar el nombre de los 12 meses*/ typedef TipoCadenaNombreMes vectorMeses[12]; /*Tipo estructura para manejar las fechas y el calendario*/ typedef struct TipoCalendario{ /*Imprimime el calendario correspondiente a un mes y año dados y marca en él con una X los días con ventas encontrados en el vectorVentas dado*/ void ImprimirCalendarioVentas(int mes, int anio, TipoVectorVentas vectorVentas); /*Pausa la ejecución del programa hasta que se pulsa la tecla enter*/ void HacerPausa(); /*Pide los datos de la fecha: dia, mes y año*/ void PedirFecha(int &dia,int &mes,int &anio); /*Pide dia*/ void PedirFechaDia(int &dia); /*Pide mes*/ void PedirFechaMes(int &mes); /*Pide año*/ void PedirFechaAnio(int &anio); /*Verifica fecha introducida (dia,mes y año)*/ bool ComprobarFecha(int diaEntrada, int mesEntrada, int anioEntrada); /*Verifica mes introducido */ bool ComprobarFechaMes(int mesEntrada); /*Verifica año introducido */ bool ComprobarFechaAnio(int anioEntrada);
private: /*Devuelve los dias de un mes*/ int DiasMes(int mesEntrada, int anioEntrada); /*Devuelve un tipo enumerado correspondiente al dia de la semana*/ T ip oDi a D iaS ema naI ni ci oMe s (int mesEntrada, int anioEntrada); /*Calcula si un año es bisiesto*/ bool EsBisiesto(int anioEntrada); /*Imprime espacios en blanco entre un intervalo dado*/ void ImprimirEspacios (int inicio, int fin); /*Imprime un punto en un dia del calendario dado*/ void ImprimirPunto (int diaPonerPunto); };
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
/************************************************************************************************** * Módulo: calendario * Imprime en pantalla un calendario para un mes y año dados. * Necesita la entrada de un dato TipoVectorVentas para poder señalar en el calendario los días en los * cuales se ha introducido una venta. * Valida que los datos de la fecha introducidos estan dentro del rango permitido. * * Autor: Rafael Grau * Versión: 2013.12.15 **************************************************************************************************/ #include #include #include #include "Calendario.h" /*Crear e iniciar vector nombresMeses con el nombre de los 12 meses*/ v ec tor Mes es n omb res Mes es = {"ENERO","FEBRERO","MARZO","ABRIL","MAYO","JUNIO","JULIO","AGOSTO","SEPTIEMBRE", "OCTUBRE","NOVIEMBRE","DICIEMBRE"};
/*Función DiasMes --------------------------------------------------------------------------------Devuelve los dias de un mes Necesita mes y año para calcular los días que corresponden a febrero. -------------------------------------------------------------------------------------------------*/ int TipoCalendario::DiasMes(int mesEntrada, int anioEntrada){ /*Definir vector para almacenar el número de dias que tiene cada uno de los 12 meses*/ typedef int numeroDiasMeses[12]; /*Crear e iniciar vector diasMeses con el número de dias de cada mes. Si el año es bisiesto, en la función ComprobarFechaEntrada se corrigen los dias de febrero*/ numeroDiasMeses diasMeses = {31,28,31,30,31,30,31,31,30,31,30,31}; /*Si el año es bisiesto reasignamos 29 días a Febrero en el vector diasMeses*/ if (EsBisiesto(anioEntrada)) { diasMeses[1]=29; } return (diasMeses[mesEntrada-1]); } /* Funcion DiaSemanaInicioMes --------------------------------------------------------------------Calcula el dia de la semana en que comienza un mes y año dados. Devuelve un tipo enumerado correspondiente al dia de la semana. El algoritmo utiliza la Congruencia de Zeller para calcular el día de la semana de comienzo del mes. Esta fórmula tiene en cuenta los años bisiestos -------------------------------------------------------------------------------------------------*/ TipoDia TipoCalendario::DiaSemanaInicioMes (int mesEntrada, int anioEntrada){ const int dia=1; int diaInicio; TipoDia diaSemanaInicio; int a=(14-mesEntrada)/12; /*Congruencia de Zeller*/ int y=anioEntrada-a; int m=mesEntrada+(12*a)-2; diaInicio=(dia+y+(y/4)-(y/100)+(y/400)+(31*m)/12)%7; if (diaInicio==0) { /*Cuando el resto de la division es 0 es Domingo.*/ diaInicio=7; } diaSemanaInicio=TipoDia (diaInicio); return diaSemanaInicio; } /* Funcion EsBisiesto ----------------------------------------------------------------------------Calcula si un año es bisiesto. Devuelve true si el año es bisiesto. -------------------------------------------------------------------------------------------------*/ bool TipoCalendario::EsBisiesto(int anioEntrada){ /* Son años bisiestos los múltiplos de 4, excepto los que son multiplos de 100 que no son múltiplos de 400*/ if (anioEntrada%4==0 && !(anioEntrada%100==0 && anioEntrada%400!=0)) { return true; } return false ; } /* Procedimiento ImprimirEspacios ----------------------------------------------------------------Imprime espacios en blanco entre un intervalo dado. -------------------------------------------------------------------------------------------------*/ void TipoCalendario::ImprimirEspacios (int inicio, int fin){ for (int i=inicio;i
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
-------------------------------------------------------------------------------------------------*/ void TipoCalendario::HacerPausa(){ printf("\n\nPulse para continuar . . ."); fflush(stdin); //limpiamos el buffer del teclado getchar(); //esperamos la pulsación de la tecla } /* Procedimiento PedirFecha ----------------------------------------------------------------------Pide los datos de la fecha: dia, mes y año. Utiliza los procedimientos PedirFechaDia,PedirFechaMes y PedirFechaAnio -------------------------------------------------------------------------------------------------*/ void TipoCalendario::PedirFecha(int &dia,int &mes,int &anio) { PedirFechaDia(dia); PedirFechaMes(mes); PedirFechaAnio(anio); } /* Procedimiento PedirFechaDia -------------------------------------------------------------------Pide el dato dia y lo almacena en la variable pasada por referencia. -------------------------------------------------------------------------------------------------*/ void TipoCalendario::PedirFechaDia(int &dia){ printf("Dia (1..31)? "); fflush(stdin); //limpiamos el buffer del teclado scanf ("%d",&dia); } /* Procedimiento PedirFechaMes -------------------------------------------------------------------Pide el dato mes y lo almacena en la variable pasada por referencia. -------------------------------------------------------------------------------------------------*/ void TipoCalendario::PedirFechaMes(int &mes){ printf("Mes (1..12)? "); fflush(stdin); //limpiamos el buffer del teclado scanf ("%d",&mes); } /* Procedimiento PedirFechaAnio ------------------------------------------------------------Pide el dato año y lo almacena en la variable pasada por referencia. -------------------------------------------------------------------------------------------------*/ void TipoCalendario::PedirFechaAnio(int &anio){ printf("A%co (1600..3000)? ",164); //164 = "ñ" fflush(stdin); //limpiamos el buffer del teclado scanf ("%d",&anio); } /* Función ComprobarFecha ------------------------------------------------------------------------Verifica fecha de entrada. Devuelve true si el dia, mes y año están dentro de los límites requeridos. Tiene en cuenta los dias que corresponden a cada mes utilizando la funcion DiasMes. -------------------------------------------------------------------------------------------------*/ bool TipoCalendario::ComprobarFecha(int diaEntrada, int mesEntrada, int anioEntrada){ /*Si el día, mes o año estan fuera de rango se imprime un mensaje de error*/ if (diaEntrada < int(1) || diaEntrada > int(DiasMes(mesEntrada,anioEntrada))){ printf("\nERROR. El dia introducido es incorrecto" ); HacerPausa(); return false; } if (!ComprobarFechaMes(mesEntrada)){ return false; } if (!ComprobarFechaAnio(anioEntrada)){ return false; } /*Si la fecha es correcta se devuelve un valor verdadero*/ return true; } /* Función ComprobarFechaMes ---------------------------------------------------------------------Verifica fecha de entrada (mes). Devuelve true si el mes está dentro de los límites requeridos (1...12). -------------------------------------------------------------------------------------------------*/ bool TipoCalendario::ComprobarFechaMes(int mesEntrada){ /*Si el mes o año estan fuera de rango se imprime un mensaje de error*/ if (mesEntrada < int(1) || mesEntrada > int(12)){ printf("\nERROR. El mes introducido es incorrecto" ); HacerPausa(); return false; } /*Si el mes es correcto se devuelve un valor verdadero*/ return true; } /* Función ComprobarFechaAnio --------------------------------------------------------------------Verifica fecha de entrada (año). Devuelve true si el año está dentro de los límites requeridos (1600...3000). -------------------------------------------------------------------------------------------------*/ bool TipoCalendario::ComprobarFechaAnio(int anioEntrada){ /*Si el año esta fuera de rango se imprime un mensaje de error*/ if (anioEntrada < int(1600) || anioEntrada > int(3000)){ printf("\nERROR. El a%co introducido es incorrecto",164); HacerPausa(); return false; } /*Si el año es correcto se devuelve un valor verdadero*/ return true; }
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 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
/* Procedimiento ImprimirCalendarioVentas --------------------------------------------------------Imprime el calendario correspondiente a un mes y año dados y marca en él con una X los dias en los que se han efectuado ventas. -------------------------------------------------------------------------------------------------*/ void TipoCalendario::ImprimirCalendarioVentas(int mes, int anio, TipoVectorVentas vectorVentas) { /*--DEFINIR VARIABLES--*/ const int anchoCalendario=27; /*Constante ancho calendario*/ TipoDia diaSemana, comienzoSemana; /*Variables de tipo enumerado*/ bool ventaEncontrada=false; /*Inicializar variable dia de la semana en que comienza un mes utilizando la función DiaSemanaInicioMes*/ comienzoSemana = DiaSemanaInicioMes(mes, anio); /*--CABECERA DEL CALENDARIO--*/ { printf("\n"); /*ponemos el mes*/ printf("%s",nombresMeses[mes-1]); /*ponemos espacios en blanco hasta completar ancho del calendario menos cuatro caracteres que reservamos para el año*/ ImprimirEspacios(strlen(nombresMeses[mes-1]),anchoCalendario-4); /*ponemos el año*/ printf("%d\n",anio); /*ponemos una cabecera fija con los dias de la semana*/ printf("%s\n","==========================="); printf("%s\n","LU MA MI JU VI | SA DO"); printf("%s\n","==========================="); } /*--CUERPO DEL CALENDARIO--*/ /*Imprimir puntos enlos días de la semana en los que el mes aún no ha comenzado*/ for (int diaSemana=Lunes;diaSemana
