MEMORIADELACUARTAPRCTICADE

FUNDAMENTOSDEPROGRAMACIN
GradoenIngenieraInformtica,UNED
Alumno:78564970YAlonsoLujnTorresTao
CentroasociadoValenciaAlzira,AulaSagunto

DESCRIPCINDELAPRCTICA.
El enunciado de la prctica peda realizar un programa que almacene, hasta un mximo de
1000 registros, las ventas de una empresa, determinadas por la fecha de venta, un
identificadornumricodeproductoylasunidadesvendidas.Eneldesarrollo,seexigequese
hagausodelaprogramacinmodular.
Elprogramahadeconstardecincoapartados:

mendeseleccin
introduccindeventas
borradodeventas
listadodeventasdeunproductoenunmesdado
listadoanualdeproductosporordendeventas

Desdeelmendeseleccinsedebepoderaccederacadaunadelascuatroopciones,adems
deunaquintaqueaborteelprogramaysalgadelmismo.
Enlaopcinintroduccindeventas,sehadesolicitaralusuariolafechadelaventa,da,mesy
ao, el identificador de producto y las unidades vendidas. Si ya hay una venta con la misma
fechayproducto,lasunidadesvendidasdelanuevaventasesumarnalasyaregistradas.
Enlaopcinborradodeventas,sehadesolicitaralusuariolafechadelaventaaborrar,da,
mes y ao y el identificador de producto. En esta opcin se borrar el registro del da
completo,aunqueeltotaldeunidadesvendassehayacompletadomediantevariasventas.
En la opcin listado de ventas se ha de solicitar al usuario una fecha, mes y ao, y un
identificador de producto, para imprimir por pantalla un calendario del mes solicitado en el
que se marquen los das en los que se est registrada alguna venta del producto indicado.
Adems,bajoelcalendariosemostrarporordencronolgicounlistadodelasventas.
Enlaopcinlistadoanualsehadesolicitaralusuariounaoyelprogramahademostrarun
listadodeproductosconsusventas,ordenadodemayoramenorporlacantidaddestas.

ESTRATEGIADEDESRROLLO
La estrategia de desarrollo que eleg fue la programacin en bloque de todo el cdigo
necesario para completar el programa en un solo archivo fuente para, una vez revisado y
comprobado su funcionamiento, proceder a la segmentacin en tantos mdulos como
opcioneshayaenelmen.Adems,procedarealizarsobreelpapeldiagramasrepresentando
lasaccionesaimplementarposteriormentemediantecdigo.
Desarrollcadaunadelascuatroprimerasopcionesdelmenprincipal,enelarchivofuente
dedesarrollo,enunprocedimientoindependienteparafacilitarassuposteriorseparacinen
mdulos.
Decidabordarlaprcticaparadesarrollarlosprocedimientosenelmismoordenenquestos
aparecen en la lista de opciones del men, sin pasar a desarrollar el siguiente hasta que el
anterior estuviera completado. No obstante, volv atrs 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
mejorarecindescubierta.
Al igual que separ por procedimientos las diferentes opciones, tambin separ por bloques
declarativoslasdeclaracionesdelasvariablespropiasdecadaprocedimiento,parafacilitaras
tambinsuseparacinmodularposterior.
As,elesquemadelcdigofuenteduranteeldesarrolloenunsoloarchivoquedara
Comentario de cabecera
#include <stdio.h>
#include <string.h>
Declaracin variables main
Declaracin variables bloque Introducir
Declaracin variables bloque Borrar
Declaracin variables bloque Listar
Declaracin variables bloque Ordenar
Declaracin procedimiento Introducir
Declaracin procedimiento Borrar
Declaracin procedimiento Listar
Declaracin procedimiento Ordenar
Declaracin main() con el men de seleccin

DESARROLLODELAPRCTICA
Mendeseleccin.
Loprimeroencodificarfue,porsusencillez,elmendeseleccin,talcomosemostrabaenel
enunciadodelaprctica.Cadaunadelascuatroprimerasopcioneshaceunallamadaaunode
loscuatroprocedimientosquesecodificaronacontinuacinyqueposteriormentepasarona
sermdulosindependientes.Laquintaopcin,simplementeabortalaejecucindelprograma.
Opcin1.Introduccindeventas
Desdeunprincipio,tuveclarocmoalmacenarlasventasrequeridas.Paraellohiceusodeun
tipostruct(llamadoventas)compuestoportrestipoarrayde1000elementoscadaunoms
otrotipostructanidado(llamadofecha),conotrostrestipoarrayde1000elementos,dejando
as, en definitiva, al tipo struct principal con seis campos, que seran las cinco variables
solicitadas al introducir una venta nueva ms una identificacin de venta. La fecha se
almacenaraenlostresarraysdelstructanidado,unoparaelao,otroparaelmesyotropara
el da, y la identificacin de venta, el identificador de producto y las unidades vendidas se
almacenaranenlostresarraysdelstructprincipal.
Una vez definido el tipo struct, pas a declarar una variable con este tipo. Dicha variable se
llamaraventaysuestructurasera:

Venta
Fecha
Dia[1000]
Mes[1000]
Ao[1000]
o Identificador venta[1000]
o Identificador producto[1000]
o Unidades vendidas[1000]
o

El siguiente paso era comprobar que las variables introducidas por teclado para la fecha se
ajustabanalosparmetrosrequeridos:daymescorrectoseintervalodeaosdesde1600a
3000.Estacomprobacinlaresolvconunaseriedecomparadoresif.
Ahora tocaba escribir el cdigo que introducira 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,estepasoashubierallevadoaerrorlaprctica,puesnosesabraenquposicin
delstructventaalmacenarlainformacin.Paraellohiceusodeunavariableenteracontador
k, que se inicia a cero y se va incrementando con cada nueva venta aadida mientras el
programa est operativo. As, cada venta se aadira en la posicin siguiente a la venta
anterior.
Peroconestonoestcompletoestapartedelenunciado,puesdosventasconlamismafecha
yproductoannosesuman.Paraello,diseeunbucleforquerecorrieratodoslosregistros

comparando mediante una sentencia if si la fecha y producto introducidos por teclado

coincidanconalgunaventayaalmacenada.Estebucleseejecutaraantesdelaintroduccin
decadaventa.Siresultaraqueexistecoincidenciaentrelosdatosintroducidosyalgunodelos
almacenados,seprocederaasumarlasventasynoguardarunregistronuevo.
Conestoyadiporterminadoelprimerbloque.Msadelanteseverquetuvequevolveral
trastrabajarconlasegundaopcin,enlaqueseborranlasventas.

Opcin2.Borradodeventas.
Estaopcinmeresultfcildeprogramar,puestansolohabaquecomprobarquelafechadel
registroaborrarestuvieradentrodelosparmetroscorrectosyprocederaborrarelregistro
del struct venta coincidente en fecha e identificador de producto con lo introducido por
teclado,siesquehubiesedichacoincidencia.Denuevo,hiceusodeunbucleforquerecorriera
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
igualaranacero.
Comoelenunciadoobligaaquesinohaycoincidenciasemuestreunmensajeindicandoesto,
aadunavariablebooleanaborrado,inicializadacomofalse,quesehacetruecuandoexiste
coincidencia.Encasodenoexistircoincidencia,almantenerseenfalse,semuestraelmensaje
deerror.
Cuandomedicuentadequetalcomoestabaelcdigoenestemomentoalborrarelltimo
registroeintroducirunanuevaventa,stasealmacenabanoenelhuecorecindejado,sino
en el registro siguiente, entend que haba que conseguir que una vez que creara un hueco
dondefueraalborrarunregistro,lossiguientesregistrosintroducidosdebancubrirloshuecos
creados.Estohizonecesariodosmodificaciones.Laprimera,hacerquealborrarunregistro,el
contadorkseredujeraenunaunidad.Lasegunda,modificarelcdigodelaopcin1paraque
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 opcin 1 que
recorrelosregistrosalmacenadosytraslacomprobacindeigualdadporlaquesecreeste
bucle, introduje una nueva sentencia if que buscara huecos (identificador de venta igual a
cero)entrelosregistrosintroducidos.Unavezseencontraraunhueco,unavariablebooleana
flag,inicializadaacero(false),pasaraavaleruno(true)yotravariableenteravaciopasaraa
contener el nmero de registro vaco. Ya fuera del bucle for, se evala el valor de flag y se
procede a insertar en el hueco indicado por la variable vacio los datos de la nueva venta
introducidosporteclado,incrementandoelcontadorkenuno.
Ahoras,yaparecaestarterminadalasdosprimerasopcionesdelaprctica.

Opcin3.Listadodeventasdeunproductoenunmesdado.

Enestaopcinserequeraimprimiruncalendarioconelmismoformatoqueelutilizadoenla
prctica3,asqueestapartedeldesarrollofueinmediato,alimportarprcticamentetodoel
cdigodelaterceraprcticaaestaopcin.Eldesarrolloimplementadoenlaprctica3porel
quesecalculaeldadelasemanaquecorrespondeaunafechadada(lacongruenciaZeller)
mevinomuybien,puesnotuvequemodificarelcdigoparamodificarelrangodeaosenlos
que se puede efectuar la prctica. He de recordar que el enunciado de la tercera prctica
indicaba que el rango de aos estaba comprendido entre 1601 y 3000, ambos inclusive,
mientrasqueelrangodeestacuartaprcticaestcomprendidoentre1600y3000.Tansolo
tuvequecambiarelaodeiniciodelrango.
Pero el calendario s que tena que llevar modificaciones, pues los das del mes que hubiera
ventaparaelproductointroducidoportecladodebanaparecerconunaXenlugardelnmero
deldacorrespondiente.Estomellevaintroduciralgunassentenciascomparativasdentrodel
cdigodelcalendariosinexcesivascomplicaciones.
Adems del calendario, haba 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
recorrieratodoelstructventa,guardaraenunodelosarraysdelstructlista_meslosdascon
ventadelproductoindicado,yenelotro,elidentificadordeventacorrespondiente.
Unavezcompletadoelpasodelosdasconventaalstructlista_mes,procedalaordenacin
por fecha del mismo, mediante el mtodo de comparacin con el vecino. Con este struct
ordenado, me fue ms fcil configurar las comparaciones entre los das con venta
almacenadosenestestructylosdasdelcalendario,parasealarlosconunaX,talcomoexiga
elenunciado.
Tras la impresin en pantalla del calendario, codifiqu la escritura de la lista ordenada
mediante un bucle for que recorriera los das 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 da del
mesylasunidadesvendidas.
Yaestabaterminadalaterceraopcin.Quedabaportantolacuartayltimaopcin.

Opcin4.Listadoanualdeproductosporordendeventas
Paraestaopcinproceddeformamuysimilaracomohiceenlaopcin3alahoradepasar
losdatosdeventasaunavariablenuevayordenarlosenl,conlasalvedaddequeaquantes
deordenarlosdatoshayquesumartodaslasventasanualesdecadaunodelosproductos.
Para ello, declar un nuevo tipo array compuesto a su vez por dos arrays ms con el que
declarunavariablearraylista_annodondesealmacenaranlosidentificadoresdeproductoy
las unidades vendas de cada registro almacenado. Una vez pasados los datos a este array,
procedadisearelcdigonecesarioparasumarlasventascorrespondientesacadaproducto,
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 mtodo de comparacin con el vecino, con el nico nimo de tener
todaslasventasdelmismoproductojuntas,ydespusprocedalasumadetodaslasventas
consecutivasquetuviesenelmismoidentificadordeproducto.Estassumassealmacenanen
unnuevoarraysumadosdelasmismascaractersticasquelista_anno.
Unavezsumadaslasventasensumados,soloquedabaprocederasuordenado,nuevamente
medianteelmismomtodo,paraposteriormentemostrarellistadoordenadoenpantalla.

Despliegueenmdulos
Conlascuatroopcionesyacompletadascodificadasenunnicoarchivofuente,solorestaba
comprobar el correcto funcionamiento del programa y, una vez comprobado, proceder a la
separacinenmdulosdelosdiferentesprocedimientos,unoparacadaopcin,definidoscon
anterioridad.
Paraello,crecuatroarchivosfuenteascomocuatroarchivosdecabecera,transportandoa
cada uno de ellos la parte correspondiente del cdigo y codificando las dependencias
necesariasparaelfuncionamientodelprogramaenformamodular.
Realizada la divisin modular, una serie de nuevas comprobaciones de funcionamiento con
resultados satisfactorios me llevaron a dar por terminada la prctica y a comenzar con la
escrituradeestamemoria.

Acontinuacinseanexalatranscripcindelosarchivosfuenteprogramadosparaestaprctica

/********************************
* 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 Lujn#
* PRIMER APELLIDO: #Torres#
* SEGUNDO APELLIDO: #Tao#
* DNI: #78564970#
* EMAIL:#spycho80@gmail.com#
****************************/
/**********************************************************************************
* Programa practica4.
*
*
*
* Este programa cumple los requisitos del enunciado de la cuarta prctica
*
* de Fundamentos de Programacin del Grado de Ingeniera Informtica
*
*
*
* Este programa almacena hasta 1000 ventas de un producto segn su identificador, *
* permite borrar y reescribir ventas, listarlas por producto y mes y por orden de *
* ventas y ao.
*
***********************************************************************************/
#include "Practica4.h"
int opcion;
/**
*Mdulo principal. Men de seleccin 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; //mximo nmero de ventas diferentes almacenables
const 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;
/**
* Mdulo 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);
//comprobacin 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
if (mes == 2){
dias_mes = 29;
}
}
if (dia <= 0 || dia > dias_mes){
printf("\nFecha no correcta\n" );
} else {

||

anno%400 == 0)){

//comprobacin 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;
/**
* Mdulo Borrar. Borra ventas segn 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
printf("\nFecha no correcta\n" );}
if (mes == 1 || mes == 3 || mes
dias_mes=31;
} else if (mes==2){
dias_mes=28;
} else if (mes == 4 || mes == 6
dias_mes=30;
}

<= Anno_min-1 || anno >= Anno_max+1){

else {
== 5 || mes == 7 || mes == 8 || mes == 10 || mes == 12){

|| mes == 9 || mes == 11){

if (anno%4 == 0 && (anno%100 != 0

if (mes == 2){
dias_mes = 29;}
}
if (dia <= 0 || dia > dias_mes){
printf("\nFecha no correcta\n" );
} else {

||

anno%400 == 0)){

//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;
/**
* Mdulo 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,
dias_mes=31;
break;
case 2:
strcpy( nombre_mes,
dias_mes=28;
break;
case 3:
strcpy( nombre_mes,
dias_mes=31;
break;
case 4:
strcpy( nombre_mes,
dias_mes=30;
break;
case 5:
strcpy( nombre_mes,
dias_mes=31;
break;
case 6:
strcpy( nombre_mes,
dias_mes=30;
break;
case 7:
strcpy( nombre_mes,
dias_mes=31;
break;
case 8:
strcpy( nombre_mes,
dias_mes=31;
break;
case 9:
strcpy( nombre_mes,
dias_mes=30;

"ENERO" );

"FEBRERO" );

"MARZO" );

"ABRIL" );

"MAYO" );

"JUNIO" );

"JULIO" );

"AGOSTO" );

"SEPTIEMBRE" );

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
if (mes == 2){
dias_mes = 29;}
}

||

anno%400 == 0)){

//Congruencia Zeller para encontrar el primer da del mes y ao 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;
//comprobacin de das 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 das 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 das 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;
/**
* Mdulo Ordenar. Suma las ventas por producto en un ao 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 ao 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);
}
}
}