MEMORIA DE LA CUARTA PRÁCTICA DE FUNDAMENTOS DE PROGRAMACIÓN 

Grado en Ingeniería Informática, UNED 

Alumno: 78564970‐Y Alonso Luján Torres Taño 

Centro asociado Valencia‐Alzira, Aula Sagunto 

 

DESCRIPCIÓN DE LA PRÁCTICA. 

El enunciado de  la práctica pedía  realizar un programa que almacene, hasta un máximo de 1000  registros,  las  ventas  de  una  empresa,  determinadas  por  la  fecha  de  venta,  un identificador numérico de producto y  las unidades vendidas. En el desarrollo, se exige que se haga uso de la programación modular. 

El programa ha de constar de cinco apartados: 

‐ menú de selección ‐ introducción de ventas ‐ borrado de ventas ‐ listado de ventas de un producto en un mes dado ‐ listado anual de productos por orden de ventas 

Desde el menú de selección se debe poder acceder a cada una de las cuatro opciones, además de una quinta que aborte el programa y salga del mismo. 

En la opción introducción de ventas, se ha de solicitar al usuario la fecha de la venta, día, mes y año, el  identificador de producto y  las unidades vendidas. Si ya hay una venta con  la misma fecha y producto, las unidades vendidas de la nueva venta se sumarán a las ya registradas. 

En la opción borrado de ventas, se ha de solicitar al usuario la fecha de la venta a borrar, día, mes  y  año  y  el  identificador  de  producto.  En  esta  opción  se  borrará  el  registro  del  día completo, aunque el total de unidades vendías se haya completado mediante varias ventas. 

En  la  opción  listado  de  ventas  se  ha  de  solicitar  al  usuario  una  fecha,  mes  y  año,  y  un identificador de producto, para  imprimir por pantalla un calendario del mes  solicitado en el que  se marquen  los días en  los que  se  esté  registrada  alguna  venta del producto  indicado. Además, bajo el calendario se mostrará por orden cronológico un listado de las ventas. 

En la opción listado anual se ha de solicitar al usuario un año y el programa ha de mostrar un listado de productos con sus ventas, ordenado de mayor a menor por la cantidad de éstas. 

   

ESTRATEGIA DE DESRROLLO 

La  estrategia  de  desarrollo  que  elegí  fue  la  programación  en  bloque  de  todo  el  código necesario  para  completar  el  programa  en  un  solo  archivo  fuente  para,  una  vez  revisado  y comprobado  su  funcionamiento,  proceder  a  la  segmentación  en  tantos  módulos  como opciones haya en el menú. Además, procedí a realizar sobre el papel diagramas representando las acciones a implementar posteriormente mediante código. 

Desarrollé cada una de  las cuatro primeras opciones del menú principal, en el archivo fuente de desarrollo, en un procedimiento independiente para facilitar así su posterior separación en módulos. 

Decidí abordar la práctica para desarrollar los procedimientos en el mismo orden en que éstos aparecen en  la  lista de opciones del menú,  sin pasar a desarrollar el  siguiente hasta que el anterior  estuviera  completado.  No  obstante,  volví  atrás  cuantas  veces  fue  necesario  para modificar  aspectos  de  los  procedimientos  ya  programados  cuando  se  hizo  necesario  por requerimientos  del  procedimiento  en  el  que  trabajaba,  o  bien  para  implementar  alguna mejora recién descubierta. 

Al  igual que separé por procedimientos  las diferentes opciones,  también separé por bloques declarativos las declaraciones de las variables propias de cada procedimiento, para facilitar así también su separación modular posterior. 

Así, el esquema del código fuente durante el desarrollo en un solo archivo quedaría 

Comentario de cabecera #include <stdio.h> #include <string.h> Declaración variables main Declaración variables bloque Introducir Declaración variables bloque Borrar Declaración variables bloque Listar Declaración variables bloque Ordenar Declaración procedimiento Introducir Declaración procedimiento Borrar Declaración procedimiento Listar Declaración procedimiento Ordenar Declaración main() con el menú de selección

   

DESARROLLO DE LA PRÁCTICA 

Menú de selección. 

Lo primero en codificar fue, por su sencillez, el menú de selección, tal como se mostraba en el enunciado de la práctica. Cada una de las cuatro primeras opciones hace una llamada a uno de los cuatro procedimientos que se codificaron a continuación y que posteriormente pasaron a ser módulos independientes. La quinta opción, simplemente aborta la ejecución del programa. 

Opción 1. Introducción de ventas 

Desde un principio, tuve claro cómo almacenar las ventas requeridas. Para ello hice uso de un tipo struct (llamado ventas) compuesto por tres tipo array de 1000 elementos cada uno más otro tipo struct anidado (llamado fecha), con otros tres tipo array de 1000 elementos, dejando así,  en  definitiva,  al  tipo  struct  principal  con  seis  campos,  que  serían  las  cinco  variables solicitadas  al  introducir  una  venta  nueva  más  una  identificación  de  venta.  La  fecha  se almacenaría en los tres arrays del struct anidado, uno para el año, otro para el mes y otro para el  día,  y  la  identificación  de  venta,  el  identificador  de  producto  y  las  unidades  vendidas  se almacenarían en los tres arrays del struct principal. 

Una vez definido el  tipo struct, pasé a declarar una variable con este  tipo. Dicha variable  se llamaría venta y su estructura sería: 

− Venta o Fecha

Dia[1000] Mes[1000] Año[1000]

o Identificador venta[1000] o Identificador producto[1000] o Unidades vendidas[1000]

 

El  siguiente paso era  comprobar que  las variables  introducidas por  teclado para  la  fecha  se ajustaban a  los parámetros requeridos: día y mes correctos e  intervalo de años desde 1600 a 3000. Esta comprobación la resolví con una serie de comparadores if. 

Ahora  tocaba escribir el código que  introduciría una venta en el struct venta declarado para ello.  Una  vez  comprobado  que  la  fecha  es  correcta,  el  paso  fue  inmediato,  simplemente haciendo  que  las  secciones  del  struct  venta  se  igualasen  a  las  variables  introducidas  por teclado,  y  haciendo  que  el  identificado  de  venta  aumentase  en  uno  con  cada  venta.  No obstante, este paso así hubiera  llevado a error  la práctica, pues no se sabría en qué posición del struct venta almacenar la información. Para ello hice uso de una variable entera contador k,  que  se  inicia  a  cero  y  se  va  incrementando  con  cada  nueva  venta  añadida mientras  el programa  esté  operativo.  Así,  cada  venta  se  añadiría  en  la  posición  siguiente  a  la  venta anterior. 

Pero con esto no está completo esta parte del enunciado, pues dos ventas con la misma fecha y producto aún no se suman. Para ello, diseñe un bucle for que recorriera todos  los registros 

comparando  mediante  una  sentencia  if  si  la  fecha  y  producto  introducidos  por  teclado coincidían con alguna venta ya almacenada. Este bucle se ejecutaría antes de  la  introducción de cada venta. Si resultara que existe coincidencia entre los datos introducidos y alguno de los almacenados, se procedería a sumar las ventas y no guardar un registro nuevo. 

Con esto ya di por terminado el primer bloque. Más adelante se verá que tuve que volver a él tras trabajar con la segunda opción, en la que se borran las ventas. 

 

Opción 2. Borrado de ventas. 

Esta opción me resultó fácil de programar, pues tan solo había que comprobar que la fecha del registro a borrar estuviera dentro de  los parámetros correctos y proceder a borrar el registro del  struct  venta  coincidente  en  fecha  e  identificador  de  producto  con  lo  introducido  por teclado, si es que hubiese dicha coincidencia. De nuevo, hice uso de un bucle for que recorriera todos  los  registros  comparando  la  fecha  e  identificador  de  producto  de  los mismos  con  lo introducido  por  teclado.  En  caso  de  existir  coincidencia,  los  seis  valores  del  registro  se igualarían a cero. 

Como el enunciado obliga a que si no hay coincidencia se muestre un mensaje indicando esto, añadí una variable booleana borrado,  inicializada como false, que se hace true cuando existe coincidencia. En caso de no existir coincidencia, al mantenerse en false, se muestra el mensaje de error. 

Cuando me di cuenta de que tal como estaba el código en este momento al borrar el último registro e  introducir una nueva venta, ésta se almacenaba no en el hueco recién dejado, sino en el  registro  siguiente, entendí que había que  conseguir que una vez que  creara un hueco donde fuera al borrar un registro, los siguientes registros introducidos debían cubrir los huecos creados. Esto hizo necesario dos modificaciones. La primera, hacer que al borrar un registro, el contador k se redujera en una unidad. La segunda, modificar el código de la opción 1 para que al  introducir  un  nuevo  registro  buscara  huecos  entre  los  registros  guardados  y  guardara  el nuevo  registro  en  el primer hueco  libre. Para  ello, dentro del bucle  for de  la opción 1 que recorre  los registros almacenados y tras  la comprobación de  igualdad por  la que se creó este bucle,  introduje  una  nueva  sentencia  if  que  buscara  huecos  (identificador  de  venta  igual  a cero) entre los registros introducidos. Una vez se encontrara un hueco, una variable booleana flag, inicializada a cero (false), pasaría a valer uno (true) y otra variable entera vacio pasaría a contener el número de  registro vacío. Ya  fuera del bucle  for,  se evalúa el valor de  flag y  se procede  a  insertar  en  el  hueco  indicado  por  la  variable  vacio  los  datos  de  la  nueva  venta introducidos por teclado, incrementando el contador k en uno. 

Ahora sí, ya parecía estar terminada las dos primeras opciones de la práctica. 

 

Opción 3. Listado de ventas de un producto en un mes dado. 

En esta opción se requería imprimir un calendario con el mismo formato que el utilizado en la práctica 3, así que esta parte del desarrollo fue  inmediato, al  importar prácticamente todo el código de la tercera práctica a esta opción. El desarrollo implementado en la práctica 3 por el que se calcula el día de  la semana que corresponde a una fecha dada  (la congruencia Zeller) me vino muy bien, pues no tuve que modificar el código para modificar el rango de años en los que  se  puede  efectuar  la  práctica. He  de  recordar  que  el  enunciado  de  la  tercera  práctica indicaba  que  el  rango  de  años  estaba  comprendido  entre  1601  y  3000,  ambos  inclusive, mientras que el rango de esta cuarta práctica está comprendido entre 1600 y 3000. Tan solo tuve que cambiar el año de inicio del rango. 

Pero el calendario sí que  tenía que  llevar modificaciones, pues  los días del mes que hubiera venta para el producto introducido por teclado debían aparecer con una X en lugar del número del día correspondiente. Esto me llevó a introducir algunas sentencias comparativas dentro del código del calendario sin excesivas complicaciones. 

Además  del  calendario,  había  que  mostrar  una  lista  ordenada  por  fecha  de  las  ventas realizadas  en  el mes  y  para  el  producto  introducido.  Para  ello,  definí  un  nuevo  tipo  struct listado compuesto por dos  tipo array y  llamado  lista_mes en el que, haciendo un bucle que recorriera todo el struct venta, guardara en uno de los arrays del struct lista_mes los días con venta del producto indicado, y en el otro, el identificador de venta correspondiente. 

Una vez completado el paso de los días con venta al struct lista_mes, procedí a la ordenación por  fecha  del mismo, mediante  el método  de  comparación  con  el  vecino.  Con  este  struct ordenado,  me  fue  más  fácil  configurar  las  comparaciones  entre  los  días  con  venta almacenados en este struct y los días del calendario, para señalarlos con una X, tal como exigía el enunciado. 

Tras  la  impresión  en  pantalla  del  calendario,  codifiqué  la  escritura  de  la  lista  ordenada mediante  un  bucle  for  que  recorriera  los  días  con  venta  almacenados  en  lista_mes,  y comparara  el  identificador  de  venta  almacenados  en  este  struct  con  los  identificadores  de venta del struct venta, donde se guardan  todas  las ventas, mostrando en pantalla el día del mes y las unidades vendidas. 

Ya estaba terminada la tercera opción. Quedaba por tanto la cuarta y última opción. 

 

Opción 4. Listado anual de productos por orden de ventas 

Para esta opción procedí de forma muy similar a como hice en  la opción 3 a  la hora de pasar los datos de ventas a una variable nueva y ordenarlos en él, con la salvedad de que aquí antes de ordenar los datos hay que sumar todas las ventas anuales de cada uno de los productos. 

Para  ello,  declaré  un  nuevo  tipo  array  compuesto  a  su  vez  por  dos  arrays más  con  el  que declaré una variable array lista_anno donde se almacenarían los identificadores de producto y las unidades  vendías de  cada  registro  almacenado. Una  vez pasados  los datos  a este  array, procedí a diseñar el código necesario para sumar las ventas correspondientes a cada producto, así  como una  vez  sumadas, proceder  a  su ordenado por unidades  totales  vendidas.  Esto  lo 

realicé  en  dos  pasos:  primero  ordené  el  array  lista_anno  por  orden  de  identificador  de producto, mediante el método de  comparación  con el  vecino,  con el único  ánimo de  tener todas  las ventas del mismo producto  juntas, y después procedí a  la suma de todas  las ventas consecutivas que tuviesen el mismo  identificador de producto. Estas sumas se almacenan en un nuevo array sumados de las mismas características que lista_anno. 

Una vez sumadas las ventas en sumados, solo quedaba proceder a su ordenado, nuevamente mediante el mismo método, para posteriormente mostrar el listado ordenado en pantalla. 

 

Despliegue en módulos 

Con  las cuatro opciones ya completadas codificadas en un único archivo fuente, solo restaba comprobar el  correcto  funcionamiento del programa  y, una  vez  comprobado, proceder  a  la separación en módulos de los diferentes procedimientos, uno para cada opción, definidos con anterioridad. 

Para ello, creé cuatro archivos fuente así como cuatro archivos de cabecera, transportando a cada  uno  de  ellos  la  parte  correspondiente  del  código  y  codificando  las  dependencias necesarias para el funcionamiento del programa en forma modular. 

Realizada  la  división modular, una  serie de nuevas  comprobaciones de  funcionamiento  con resultados  satisfactorios me  llevaron  a  dar  por  terminada  la  práctica  y  a  comenzar  con  la escritura de esta memoria. 

 

A continuación se anexa la transcripción de los archivos fuente programados para esta práctica 

/********************************* CABECERA DEL MODULO PRINCIPAL *********************************/

#pragma once#include <stdio.h>#include <string.h>#include "Introducir.h"#include "Borrar.h"#include "Listar.h"#include "Ordenar.h"

/**************************** NOMBRE: #Alonso Luján#* PRIMER APELLIDO: #Torres#* SEGUNDO APELLIDO: #Taño#* DNI: #78564970#* EMAIL:#spycho80@gmail.com#****************************/

/*********************************************************************************** Programa practica4. ** ** Este programa cumple los requisitos del enunciado de la cuarta práctica ** de Fundamentos de Programación del Grado de Ingeniería Informática ** ** Este programa almacena hasta 1000 ventas de un producto según su identificador, ** permite borrar y reescribir ventas, listarlas por producto y mes y por orden de ** ventas y año. ************************************************************************************/

#include "Practica4.h"

int opcion;

/***Módulo principal. Menú de selección de opciones.**/

int main (){

while (opcion != 5 ){

printf("\n\nANALIZADOR DE VENTAS\n\n"); printf("1. Introducir venta\n"); printf("2. Eliminar venta\n"); printf("3. Listar ventas de un mes\n"); printf("4. Listar productos por orden de ventas\n\n" ); printf("5. Salir\n\n"); printf("Opcion?"); scanf("%d",&opcion);

printf ("Opcion elegida, %d\n\n",opcion);

//seleccionar opcion -> modulo switch (opcion){ case 1: Introducir(); break;

case 2: Borrar(); break;

case 3: Listar(); break;

case 4: Ordenar(); break;

default: printf ("\nVuelva a elegir\n"); } }}//fin principal

/********************************************** CABECERA DEL MODULO PARA INTRODUCIR VENTAS **********************************************/

#pragma once#include <stdio.h>#include <string.h>

const int Max=1000; //máximo número de ventas diferentes almacenablesconst int Anno_min=1600;const int Anno_max=3000;

typedef int vector_int[Max];typedef char vector_car[Max];

typedef struct tipofecha{ vector_int dia_fecha; vector_int mes_fecha; vector_int anno_fecha;};

typedef struct ventas { tipofecha fecha; vector_int id_venta; vector_int id_producto; vector_int unidades;};

extern ventas venta;extern int dia, mes, anno, id_prod, unid;extern int dias_mes, k;

void Introducir();

/********************************* MODULO PARA INTRODUCIR VENTAS *********************************/

#include "Introducir.h"

ventas venta;

int dia, mes, anno, id_prod, unid;int dias_mes;

int antiguas, i, vacio;int k=1;

bool flag;

/*** Módulo Introducir. Introduce ventas, sumando las que son del mismo producto y fecha.**/

void Introducir(){

printf("Dia (1...31)?"); scanf ("%d",&dia); printf("Mes (1...12)?"); scanf ("%d",&mes); printf("Anno (%d...%d)?",Anno_min, Anno_max); scanf ("%d",&anno); printf("Identificador de producto?"); scanf ("%d",&id_prod); printf("Unidades?"); scanf ("%d",&unid);

//comprobación de fecha if (mes <= 0 || mes >= 13 || anno <= Anno_min-1 || anno >= Anno_max+1){ printf("\nFecha no correcta\n");} else { if (mes == 1 || mes == 3 || mes == 5 || mes == 7 || mes == 8 || mes == 10 || mes == 12){ dias_mes=31; } else if (mes==2){ dias_mes=28; } else if (mes == 4 || mes == 6 || mes == 9 || mes == 11){ dias_mes=30; }

if (anno%4 == 0 && (anno%100 != 0 || anno%400 == 0)){ if (mes == 2){ dias_mes = 29; } } if (dia <= 0 || dia > dias_mes){ printf("\nFecha no correcta\n"); } else {

//comprobación de ventas completas if (k>Max){ printf("\nNo se pueden almacenar mas ventas no coincidentes\n" ); } else{ printf ("\nvendidas %d unidades del producto %d el %d/%d/%d\n" ,unid,id_prod,dia,mes,anno);

//buscando coincidencia de fechas y producto i=k; antiguas=0;

for (int j=0;j<=Max-1;j++){ if (anno == venta.fecha.anno_fecha[j] && mes == venta.fecha.mes_fecha[j] && dia == venta.fecha.dia_fecha[j] && id_prod == venta.id_producto[j]){ printf("\nexiste venta anterior con fecha e id_producto igual. Sumando\n" ); antiguas=venta.unidades[j]; i=j+1; k--; }

//buscando huecos de ventas borradas if (venta.id_venta[j] == 0 && j<k-1){ flag=1; vacio=j; }

}

//si hay hueco, se guarda en el hueco if (flag==1){ printf("\nventa vacia en id %d. Se introduce venta en este id;\n" ,vacio+1);

venta.id_venta[vacio]=vacio+1; venta.fecha.dia_fecha[vacio]=dia; venta.fecha.mes_fecha[vacio]=mes; venta.fecha.anno_fecha[vacio]=anno; venta.id_producto[vacio]=id_prod; venta.unidades[vacio] = unid + antiguas;

k++; }

//guardado de la venta si no hay hueco if (i==k){ venta.id_venta[i-1]=i; venta.fecha.dia_fecha[i-1]=dia; venta.fecha.mes_fecha[i-1]=mes; venta.fecha.anno_fecha[i-1]=anno; venta.id_producto[i-1]=id_prod; venta.unidades[i-1] = unid + antiguas;

k++; } } } }}//fin modulo intro

/****************************************** CABECERA DEL MODULO PARA BORRAR VENTAS ******************************************/

#pragma once#include "Introducir.h"

void Borrar();

/***************************** MODULO PARA BORRAR VENTAS *****************************/

#include "Borrar.h"

bool borrado;

/*** Módulo Borrar. Borra ventas según fecha y producto.**/

void Borrar(){

borrado=false; printf("Dia (1...31)?"); scanf ("%d",&dia); printf("Mes (1...12)?"); scanf ("%d",&mes); printf("Anno (%d...%d)?",Anno_min,Anno_max); scanf ("%d",&anno); printf("Identificador de producto?"); scanf ("%d",&id_prod);

//comprobacion de fechas if (mes <= 0 || mes >= 13 || anno <= Anno_min-1 || anno >= Anno_max+1){ printf("\nFecha no correcta\n");} else { if (mes == 1 || mes == 3 || mes == 5 || mes == 7 || mes == 8 || mes == 10 || mes == 12){ dias_mes=31; } else if (mes==2){ dias_mes=28; } else if (mes == 4 || mes == 6 || mes == 9 || mes == 11){ dias_mes=30; }

if (anno%4 == 0 && (anno%100 != 0 || anno%400 == 0)){ if (mes == 2){ dias_mes = 29;} } if (dia <= 0 || dia > dias_mes){ printf("\nFecha no correcta\n"); } else {

//borrado de venta

printf ("\nborrando las ventas del producto %d el %d/%d/%d\n" ,id_prod,dia,mes,anno);

for (int j=0;j<=Max-1;j++){ if (anno == venta.fecha.anno_fecha[j] && mes == venta.fecha.mes_fecha[j] && dia == venta.fecha.dia_fecha[j] && id_prod == venta.id_producto[j]){ printf("\nexiste venta anterior con fecha e id_producto igual, %d. Borrando\n" ,id_prod);

venta.id_venta[j]=0; venta.fecha.dia_fecha[j]=0; venta.fecha.mes_fecha[j]=0; venta.fecha.anno_fecha[j]=0; venta.id_producto[j]=0; venta.unidades[j]=0;

borrado = true; k--; } } if (borrado == false) {printf("\nno hay venta coincidente con fecha %d/%d/%d y producto %d\n",dia,mes,anno,id_prod); } } }}//fin modulo borrar

/****************************************** CABECERA DEL MODULO PARA LISTAR VENTAS ******************************************/

#pragma once#include "Introducir.h"

typedef char Tipo_cadena[11];

extern Tipo_cadena cantidad;

void Listar();

/***************************** MODULO PARA LISTAR VENTAS *****************************/

#include "Listar.h"

int aux1,aux2;

int a,y,m,d,dias_cal,dias_venta;

typedef int Tipo_vector_venta[31];

typedef struct listado{ Tipo_vector_venta venta_mes; Tipo_vector_venta venta_id; };

listado lista_mes;

Tipo_cadena cantidad, nombre_mes;

bool esta;

/*** Módulo Listar. Muestra las ventas de un producto en un mes determinado en un calendario y por fecha**/

void Listar(){

printf("Mes? (1-12)"); scanf("%d",&mes); printf("Anno? (%d-%d)",Anno_min,Anno_max); scanf("%d",&anno); printf("Identificador de producto?"); scanf ("%d",&id_prod);

//comprobacion de fecha if (mes <= 0 || mes >= 13 || anno <= Anno_min-1 || anno >= Anno_max+1){ printf("\nFecha no correcta");} else {

switch (mes){ case 1: strcpy( nombre_mes, "ENERO" ); dias_mes=31; break; case 2: strcpy( nombre_mes, "FEBRERO" ); dias_mes=28; break; case 3: strcpy( nombre_mes, "MARZO" ); dias_mes=31; break; case 4: strcpy( nombre_mes, "ABRIL" ); dias_mes=30; break; case 5: strcpy( nombre_mes, "MAYO" ); dias_mes=31; break; case 6: strcpy( nombre_mes, "JUNIO" ); dias_mes=30; break; case 7: strcpy( nombre_mes, "JULIO" ); dias_mes=31; break; case 8: strcpy( nombre_mes, "AGOSTO" ); dias_mes=31; break; case 9: strcpy( nombre_mes, "SEPTIEMBRE" ); dias_mes=30;

break; case 10: strcpy( nombre_mes, "OCTUBRE" ); dias_mes=31; break; case 11: strcpy( nombre_mes, "NOVIEMBRE" ); dias_mes=30; break; case 12: strcpy( nombre_mes, "DICIEMBRE" ); dias_mes=31; break; }

if (anno%4 == 0 && (anno%100 != 0 || anno%400 == 0)){ if (mes == 2){ dias_mes = 29;} }

//Congruencia Zeller para encontrar el primer día del mes y año pedidos.

a = (14 - mes) / 12; y = anno - a; m = mes + 12 * a - 2;

d = ((1 + y + y/4 - y/100 + y/400 + (31*m)/12) % 7)-1;

//comprobación de días con venta dias_venta=0; for (int k=0; k<=Max-1; k++){ if (mes == venta.fecha.mes_fecha[k] && id_prod == venta.id_producto[k] && anno == venta.fecha.anno_fecha[k]){ lista_mes.venta_mes[dias_venta]=venta.fecha.dia_fecha[k]; lista_mes.venta_id[dias_venta]=venta.id_venta[k]; dias_venta++; } }

//Ordenar días de ventas for (int vec=1;vec<=dias_venta;vec++){ for (int vect=0;vect<=dias_venta-2;vect++){ if (lista_mes.venta_mes[vect]>lista_mes.venta_mes[vect+1]){ aux1=lista_mes.venta_mes[vect]; aux2=lista_mes.venta_id[vect]; lista_mes.venta_mes[vect]=lista_mes.venta_mes[vect+1]; lista_mes.venta_id[vect]=lista_mes.venta_id[vect+1]; lista_mes.venta_mes[vect+1]=aux1; lista_mes.venta_id[vect+1]=aux2; } } }

//pintado del calendario printf("\n%s",nombre_mes); for (int i = 0; i<=22-int(strlen(nombre_mes));i++ ){ printf (" "); } printf("%d\n",anno);

//pintado de cabecera del calendario printf("===========================\n"); printf("LU MA MI JU VI | SA DO\n"); printf("===========================\n");

//pintado del calendario en sí

//cuenta de los huecos a rellenar if ((dias_mes+d)%7==0){ dias_cal=(dias_mes+d); } else if ((dias_mes+d)%7!=0){ dias_cal=((dias_mes+d)/7+1)*7; } for (int i = 1; i<=dias_cal;i++){ esta=false;

//rellenado de huecos antes del dia 1 del mes

if (i<=d && i%7 > 0 && i%7 != 5){ printf (" . "); } else if (i<=d && i%7==5){ printf(" . | "); } else if (i>d && i<=dias_mes+d && i%7 > 0 && i%7 != 5){

//rellenado de los dias del mes for (int dias=0;dias<dias_venta;dias++){ if (i-d == lista_mes.venta_mes[dias]){ printf(" X "); esta=true; } } if (esta==false){ printf("%2d ",i-d); } } else if (i>d && i<=dias_mes+d && i%7==5){ for (int dias=0;dias<dias_venta;dias++){ if (i-d == lista_mes.venta_mes[dias]){ printf(" X | "); esta=true; } } if (esta==false){ printf("%2d | ",i-d); } } else if (i>d && i<=dias_mes+d && i%7==0){ for (int dias=0;dias<dias_venta;dias++){ if (i-d == lista_mes.venta_mes[dias]){ printf(" X\n"); esta=true; } } if (esta==false){ printf("%2d\n",i-d); } } else if (i>dias_mes+d && i%7 > 0 && i%7 != 5){

//rellenado de los dias despues del ultimo de mes printf (" . "); } else if (i>dias_mes+d && i%7==5){ printf(" . | "); } else if (i>dias_mes+d && i%7==0){ printf(" .\n\n"); } }

//escritura de la lista de días con venta for (int vec=1;vec<=dias_venta;vec++){ for (int k=0; k<=Max-1; k++){ if (lista_mes.venta_id[vec-1] == venta.id_producto[k]){ switch (venta.unidades[k]){ case 1: strcpy( cantidad, "unidad" ); break; default: strcpy( cantidad, "unidades" ); } printf ("- %2d: %d %s\n",venta.fecha.dia_fecha[k],venta.unidades[k],cantidad); } } } }}//fin modulo listar

/****************************************** CABECERA DEL MODULO PARA ORDENAR VENTAS******************************************/

#pragma once#include "Listar.h"

void Ordenar();

/***************************** MODULO PARA ORDENAR VENTAS*****************************/

#include "Ordenar.h"

int id_anno, aux3, aux4, aux5, aux6, suma, sum;

bool idem;

typedef int Tipo_vector_anno[2][1000];Tipo_vector_anno lista_anno;Tipo_vector_anno sumados;

/*** Módulo Ordenar. Suma las ventas por producto en un año y las muestra ordenadas de mayor a menor ventas**/

void Ordenar(){ printf("Anno? (%d-%d)",Anno_min,Anno_max); scanf("%d",&anno); printf("\n");

id_anno=0; sum=0;

//comprobacion de fecha if (anno <= Anno_min-1 || anno >= Anno_max+1){ printf("\nFecha no correcta");} else {

//buscar año en ventas for (int k=0; k<=Max-1; k++){ if (anno == venta.fecha.anno_fecha[k]){ lista_anno[0][id_anno]=venta.id_producto[k]; lista_anno[1][id_anno]=venta.unidades[k];

id_anno++; } }

//ordenar array ventas por id_producto for (int vec=1;vec<=id_anno;vec++){ for (int vect=0;vect<=id_anno-2;vect++){ if (lista_anno[0][vect]>lista_anno[0][vect+1]){ aux3=lista_anno[0][vect]; aux4=lista_anno[1][vect]; lista_anno[0][vect]=lista_anno[0][vect+1]; lista_anno[1][vect]=lista_anno[1][vect+1]; lista_anno[0][vect+1]=aux3; lista_anno[1][vect+1]=aux4; } } }

//sumar ventas por productos for (int j=0;j<id_anno;j++){ suma=0; do{ suma=suma+lista_anno[1][j]; if(lista_anno[0][j]==lista_anno[0][j+1]){ idem=1;

j++; } else{ idem=0; sumados[1][sum]=suma; sumados[0][sum]=lista_anno[0][j];

sum++; } } while (idem); }

//ordenar ventas sumadas for (int vec=1;vec<=sum;vec++){ for (int vect=0;vect<=sum-2;vect++){

if (sumados[1][vect]<sumados[1][vect+1]){ aux5=sumados[0][vect]; aux6=sumados[1][vect]; sumados[0][vect]=sumados[0][vect+1]; sumados[1][vect]=sumados[1][vect+1]; sumados[0][vect+1]=aux5; sumados[1][vect+1]=aux6; } } }

//imprimir ventas sumadas ordenadas for (int m=0;m<=sum-1;m++){ switch (sumados[1][m]){ case 1: strcpy( cantidad, "unidad" ); break; default: strcpy( cantidad, "unidades" ); } printf("%d) producto %d: %d %s\n",m+1,sumados[0][m],sumados[1][m],cantidad); } }}