Anda di halaman 1dari 10

UNIVERSIDAD CATOLICA DE SANTA MARIA

FACULTAD DE CIENCIAS E INGENIERIAS FISICAS Y


FORMALES

PROGRAMA PROFESIONAL
DE INGENIERIA DE
SISTEMAS

Algoritmos y
Estructuras
de datos I
PROYECTO FINAL III
FASE
Alumnos:
TORRES SUAA JHON EDUARD
VILLEGAS CONDORI YANINA
CRISTAL
Seccin:B

Arequipa Per
2015
PROYECTO FINAL
La empresa ABC S.A. ubicada en el parque industrial de la ciudad de Arequipa, distribuye al por
mayor y menor artculos de primera necesidad. Los clientes de ABC pueden ser personas naturales
o jurdicas.
La empresa cuenta con diversos almacenes en los que se guardan los artculos. Un artculo podra
estar almacenado en ms de un almacn.
Los clientes realizan sus pedidos de uno o ms productos. Este pedido se registra y se emite una
nota de pedido el mismo que tiene un nmero (correlativo), una fecha, los datos del empleado que
atendi el pedido, los datos del cliente, la relacin de productos (descripcin, cantidad, precio
unitario y precio total), la fecha y la direccin donde se entregar el pedido.
Una vez registrado el pedido, de forma automtica se debe de descontar a cantidad disponible de
los productos pedidos de los almacenes correspondientes. Si el stock de un producto es
insuficiente en un nico almacn, este podra ser atendido acumulando los stocks de ms de un
almacn. Cuando no hay stock suficiente de un producto que solicita un cliente, este pedido de
este artculo pasa a un estado de pedido pendiente, el mismo que ser atendido ni bien se tenga el
producto en stock. Por este motivo es posible que un pedido genere uno o ms notas de pedido.
La empresa entrega todos los productos que el cliente haya pedido mximo en la fecha que se
consign como fecha de entrega en la nota de pedido. En caso no sea as, este pedido se catalog
como un pedido atrasado, siendo estos ltimos de inters para la empresa atenderlos lo antes
posible pues por cada da de atraso la empresa realiza un descuento de 0.5% del total de la nota
de pedido. Cuando se entrega un pedido al cliente, se le entrega su correspondiente factura o
boleta, consignndose los mismos datos de la nota de pedido ms
los siguientes datos: el nmero de nota de pedido que genero la factura o boleta, en caso de
factura se tiene el RUC del cliente, el IGV, el monto total (sin IGV) y el total general (incluye IGV).
En caso de ser boleta, se incluye el monto general.
Los pedidos pendientes se atienden tomando en consideracin, la existencia del stock suficiente, la
fecha de pedido y el tipo de cliente que lo efecto. La empresa categoriza a sus clientes como:
MAYORISTA FRECUENTE, MAYORISTA, MINORISTA FRECUENTE Y MINORISTA;
Los clientes que son atendidos primero son los mayoristas frecuentes. Algunos productos tienen un
lmite de stock mnimo, el mismo que debe ser verificado cada vez que el producto es pedido. En
caso ya se haya llegado al stock mnimo del producto se genera una orden de compra, la misma
que es tramitada por la oficina de abastecimiento. La orden de compra contempla los siguientes
datos: nmero de la orden, fecha de la orden, proveedor, urgencia (muy urgente, urgente, normal),
lista de productos, con sus respectivas cantidades.
Una vez que la oficina de abastecimiento efecta la compra, sta queda registrada ingresando el
producto a los almacenes donde existe el producto, de forma que la cantidad en el stock del
producto por almacn depende del grado de consumo de ese producto en un determinado
almacn, es decir; a mayor consumo del producto en el almacn, mayor es la cantidad del producto
en el stock.

Adems, se requiere saber el registro de ventas hechas por los empleados de la empresa, para
sacar un ranking del mejor vendedor,

CODIG
O
FUENT
E

SUPERMERCADO.H

#ifndef SUPERMERCADO_H
#define SUPERMERCADO_H
#include "exceptions.h"
#include <string>
class cliente
{
private:
int codigo;
string nombre;
bool deuda;
public:
cliente(int cod, string nom, bool deu)
{
this->codigo=cod;
this->nombre=nom;
this->deuda=deu;
}
cliente()
{
}
int getCodigo()
{
return codigo;
}
string getNombre()
{
return nombre;
}
bool getDeuda()
{
return deuda;
}
void setCodigo(int cod)
{
codigo=cod;
}

void setNombre(string nom)


{
nombre=nom;
}
void setDeuda(bool deu)
{
deuda=deu;
}
bool operator != (cliente & c)
{
return(this->codigo!=c.codigo);
}
friend ostream& operator << (ostream&,cliente&);
};
ostream& operator << (ostream &salida, cliente& c)
{
salida << c.getCodigo() << endl;
salida << c.getNombre() << endl;
return salida;
}

class producto
{
private:
int codigo;
string nombre;
double precio;
int stock;
public:
producto(int cod, string nom, double pre, int st)
{
this->codigo=cod;
this->nombre=nom;
this->precio=pre;
this->stock=st;
}
producto(){}
int getCodigo()
{
return codigo;
}
string getNombre()
{
return nombre;
}
int getStock()
{
return stock;
}
double getPrecio()
{
return precio;
}

};

void setCodigo(int cod)


{
codigo=cod;
}
void setNombre(string nom)
{
nombre=nom;
}
void setPrecio(double pre)
{
precio=pre;
}
void bajarStock(int cant)
{
int resta=0;
if (stock-cant>=0)
{
resta=stock-cant;
stock=resta;
}
}
friend ostream& operator << (ostream&,producto&);

ostream& operator << (ostream &salida, producto& p)


{
salida << p.getCodigo() << endl;
salida << p.getNombre() << endl;
salida << p.getPrecio() << endl;
salida << p.getStock() << endl;
return salida;
}
class pedido
{
private:
int cli;
int pro;
string fecha;
string nom_emple;
string dir_entrega;
public:
pedido(int c, int p, string fec,string empl ,string dir)
{
this->cli=c;
this->pro=p;
this->fecha=fec;
this->nom_emple=empl;
this->dir_entrega=dir;
}
void mostrarpedido()
{
cout << "fecha:" << fecha <<endl;
}

};
#endif

EXCEPTION.H

#ifndef EXCEPTIONS_H
#define EXCEPTIONS_H
#include <exception>
#include <iostream>
#include <stdio.h>
using namespace std;
class isNotExit:public exception
{
public:
const char* what() const throw()
{
return "Lista vacia o posicion invalida\n";
}
};
class stackEmpty:public exception
{
public:
const char* what() const throw()
{
return "Pila vacia\n";
}
};
#endif

LINKED.H

#ifndef LINKED_H
#define LINKED_H
#include <iostream>
using namespace std;
template<class E> class LEG;
template<class E> class NodoLEG
{

private:
E dato;
NodoLEG<E> *siguiente;
public:
NodoLEG(E dat, NodoLEG<E> *sig=NULL)
{
this->dato=dat;
this->siguiente=sig;
}
~NodoLEG()
{
this->siguiente=NULL;
}
E getDato()
{
return this->dato;
}
NodoLEG<E>* getSiguiente()
{
return this->siguiente;
}
void setdato(E dato)
{
this->dato=dato;
}
void setsiguiente(NodoLEG<E>*sig)
{
this->siguiente=sig;
}
friend class LEG<E>;
};

template<class E> class LEG


{
private:
NodoLEG<E> *primero, *ultimo;
int tamanio;
public:
LEG()
{
cout << "Creado" << endl;
primero=NULL;
ultimo=NULL;
tamanio=0;
}
~LEG();
void insert(E&);
bool isEmpty();
bool search(E&);
void insertLast(E&);
void remove(E&);
E& changefirst();
E& getItem(E&); //metodo usado en tablas hash
//No recomendable usarlo si no lo entiendes
friend ostream& operator << <>(ostream&,LEG<E>&);

};
template<class E> LEG<E>::~LEG()
{
NodoLEG<E> *aux;
while (primero!=NULL)
{
aux=primero;
primero=primero->siguiente;
delete aux;
}
tamanio=0;
}
template<class E>E& LEG<E>::changefirst()
{
NodoLEG<E> *aux=primero;
primero=primero->siguiente;
return aux->dato;
}
template<class E>void LEG<E>::insert(E& item)
{
primero=new NodoLEG<E>(item,primero);
tamanio++;
}
template<class E>void LEG<E>::remove(E& item)
{
NodoLEG<E> *aux=primero, *ant=NULL;
if (isEmpty())
return;
while (aux!=NULL && aux->dato!=item)
{
ant=aux;
aux=aux->siguiente;
}
if (!aux) return;
if (!ant)
primero=aux->siguiente;
else
ant->siguiente=aux->siguiente;
delete aux;
tamanio--;
}
template<class E>bool LEG<E>::isEmpty()
{
return (primero==NULL);
}
template<class E>bool LEG<E>::search(E& item)
{
NodoLEG<E>*aux=primero;
while (aux && aux->dato!=item)
aux=aux->siguiente;
return (aux!=NULL);
}
template<class E>E& LEG<E>::getItem(E& item)
{
NodoLEG<E>*aux=primero;
while (aux)
{

if (aux->dato==item) return aux->dato;


aux=aux->siguiente;

}
return (E)0;

}
template<class E>void LEG<E>::insertLast(E& item)
{
NodoLEG<E>*aux=primero, *ant=NULL;
NodoLEG<E>*nuevo= new NodoLEG<E>(item);
if (isEmpty())
return;
while (aux!=NULL)
{
ant=aux;
aux=aux->siguiente;
}
if (!ant)
{
primero=nuevo;
}
else
ant->siguiente=nuevo;
}
template<class E>
ostream& operator << (ostream &salida, LEG<E>& L)
{
if (L.isEmpty())
salida<<"Lista vacia"<<endl;
else
for (NodoLEG<E>*aux=L.primero;aux!=NULL;aux->getSiguiente())
salida<<aux->getDato()<<"\t";
return salida;

}
#endif

MAIN.CPP
#include "linked.h"
#include "supermercado.h"
void main()
{

LEG<cliente> C;
LEG<producto> P;
LEG<pedido> PED;
cliente *c1=new cliente(201, "Yanina Villegas", true);
C.insert(*(c1));
cliente *c2=new cliente(202, "Jhon Torres", true);
C.insert(*(c2));
cliente *c3=new cliente(203, "Juan Perez", true);
C.insert(*(c3));
producto *p1=new producto(100, "Cuaderno", 12.5 , 10);
P.insert(*(p1));

producto *p2=new producto(101, "Lapicero", 20.5 , 20);


P.insert(*(p2));
producto *p3=new producto(102, "Folder", 10.10 , 10);
P.insert(*(p3));
int opc=0;
int codcli,codpro;
string fecha,dirent,nomemp;
do
{

cout<<"Elija un modulo"<<endl;
cout<<"1) Clientes"<<endl;
cout<<"2) Productos"<<endl;
cout<<"3) Realizar Venta"<<endl;
cin >> opc;
if(opc==1)
{
cout << C;
}
if(opc==2)
{
cout << P;
}
if(opc==3)
{
cout << "Ingrese Codigo de Cliente" << endl;
cin >> codcli;
cout << "Ingrese Codigo de Producto" << endl;
cin >> codpro;
cout << "Ingrese Nombre de Empleado" << endl;
cin >> nomemp;
cout << "Ingrese Fecha" << endl;
cin >> fecha;
cout << "Ingrese Direccin de Entrega" << endl;
cin >> dirent;
pedido *pe=new pedido(codcli,codpro, fecha ,nomemp, dirent);
PED.insert(*(pe));
}

}while(opc<=0);
C.search(*(c1));
system("pause");
}