Datos de Identificación

Asignatura Programación I
Código 3154
Semestre Tercero
Área Programación
Programa Ingeniería en Informática
Departamento Sistemas
Fecha de Elaboración 08/03/2012
Fecha Última actualización 04/07/2014
Una compañía de seguros desea procesar
cierta información de los contratos de
seguros que los corredores de seguros han
vendido, con el propósito de determinar
para cada uno, su comisión mensual y la
cantidad total vendida en el mes de cada
tipo de seguro.
A manera de información, el contrato de
seguro es el acuerdo por el cual una de las
partes, el asegurador (compañía de seguro), está
obligado a pagar una suma de dinero por un
daño a la otra parte, tomador o contratante
(persona que compra el seguro), al comprobarse
que ha ocurrido el suceso previsto (daño) en el
contrato.

Para que la compañía de seguros

pueda cancelar el daño ocurrido, el
tomador debe pagar una prima
(monto bsf.) por el seguro adquirido.
 La compañía de seguros tiene a su
disposición una lista de los corredores de
seguros. De estas personas se conoce: Cédula,
nombre, dirección, teléfono.
También tiene definido por cada tipo de
seguro la siguiente información: Tipo de
seguro (nro. del 1 al 9), descripción del tipo de
seguro y porcentaje de comisión que se
aplicará sobre la prima del contrato del seguro,
para el pago de comisiones de los corredores
de seguros.
A continuación se presenta un ejemplo de la
información correspondiente a los tipos de
seguro:
Tipo de Porcentaje de
Descripción
Seguro Comisión
1 Seguro de Automóviles 5
Seguro de Obligaciones y/o
2 22
Responsabilidad
3 Seguro de Transporte 20
Seguro de Hospitalización
4 12.5
Cirugía y Maternidad
5 Seguro de Enfermedad 18
6 Seguro de Vida 28
Seguro por Daños
7 30
(incendios, terremotos)
8 Seguro de Accidentes 25
9 Seguros Funerarios 24
Funcionamiento del Programa:
Cuando se ejecuta el programa, se debe presentar
el siguiente menú de opciones:

1. Cargar datos de los archivos maestros

2. Procesar contratos de seguros vendidos
3. Reporte corredores que superaron meta de venta
de un tipo de seguro
4. Consultar la cantidad de contratos de
seguros vendidos de un tipo de seguro
5. Reporte comisiones corredores de
seguros
6. Finalizar
Opción 1 Cargar datos de los archivos maestros

Esta opción permite que se almacene en

memoria principal la información de los
corredores de seguros y la información de los
tipos de seguros, utilizando las estructuras de
datos adecuadas. Los datos deben ser
recuperados desde archivos de texto.
Opción 2
Procesar Contratos de Seguros Vendidos
Esta opción permite procesar ciertos datos,
que se encuentra en los contratos de seguros
vendidos por los corredores de seguros, lo
que permitirá obtener para cada uno: la
comisión mensual que se le debe pagar y la
cantidad total vendida en el mes, de cada
tipo de seguro.
Los datos que se tienen de cada contrato a ser
procesado son: Cédula del corredor de
seguros, tipo de seguro vendido y prima del
contrato (es el monto que se pagará por el
seguro).
Opción 3
Reporte corredores que superaron meta de venta de
un tipo de seguro
Solicita un tipo de seguro (valor 1 al 9) y la meta de
venta establecida por la empresa, para mostrar solo
las cédulas de los corredores que superaron la meta
de venta establecida de ese tipo de seguro.
Nota: La meta se refiere a cantidad de seguros vendidos de
un tipo de seguro.
Opción 4
Consultar cantidad de contratos de seguros vendidos
de un tipo de seguro
Solicita el dato tipo de seguro (valor 1 al 9) y
muestra la cantidad total de contratos de seguros
que se vendieron de ese tipo.
Opción 5
Reporte comisiones corredores de seguros
Esta opción muestra a nivel de pantalla, un
listado que contiene la siguiente
información: Cédula del corredor de
seguros, nombre y su comisión mensual.

Opción 6
Finalizar
Termina el programa.
 MPersona
MContrato
MCorredor

MTipoSeguro

MCompannia

Controlador

VCorredor VCompannia
VGeneral

VTipoSeguro VContrato
#ifndef MTIPOSEGURO_H_
#define MTIPOSEGURO_H_
#include <string>
using namespace std;
class MTipoSeguro
{ private:
string descripcion;
float porc_comi;
public:
MTipoSeguro();
void SetDescripcion(string d);
void SetPorcComi(float porc);
string GetDescripcion();
float GetPorcComi();
};
#endif /* SEGURO_H_ */
#ifndef MCONTRATO_H_
#define MCONTRATO_H_
#include <string>
using namespace std;
class MContrato
{ private:
string cedula;
int tipo_seguro;
float prima_contrato;
public:
MContrato();
void SetCedula(string c);
void SetTipoSeguro(int s);
void SetPrimaContrato(float p);
string GetCedula();
int GetTipoSeguro();
float GetPrimaContrato();
}; #endif /* MCONTRATO_H_ */
#ifndef MCORREDOR_H_
#define MCORREDOR_H_
#include <vector>
#include "MPersona.h”

class MCorredor : public MPersona

{ private:
float comision_mensual;
vector<int> cant_tipo_seguros;
public:
MCorredor();
void SetComisionMensual(float m);
void IncluirCantTipoSeguro(int cant);
void SetCantUnTipoSeguro(int i, int cant);
float GetComsionMensual();
int GetCantUnTipoSeguro(int i);
int CantCantTipoSeguros();
void ActualizarCorredor(int tiposeg, float montoprima, float porcomi);
};
#endif /* CORREDOR_H_ */
MCorredor :: MCorredor()
{
comision_mensual = 0;
for (int i=0; i<9; ++i)
IncluirCantTipoSeguro(0); // También se puede
// usar cat_tipo_seguros.push_back(0);
}

void MCorredor:: IncluirCantTipoSeguro(int cant)

{ cant_tipo_seguros.push_back(cant); }

void MCorredor::SetCantUnTipoSeguro(int i,
int cant)
{ cant_tipo_seguros[i] = cant; }
void MCorredor::GetCantUnTipoSeguro(int i)
{ return cant_tipo_seguros[i]; }

int MCorredor::CantCantTipoSeguros( )
{ return cant_tipo_seguros.size(); }
/* Se le actualiza al corredor de seguros la cantidad
total vendida en el mes, del tipo de seguro del contrato
que se esta procesando y su comisión mensual*/

void MCorredor :: ActualizarCorredor(int tiposeg,

float montoprima,
float porcomi)
{
++cant_tipo_seguros[tiposeg -1];
comision_mensual += montoprima * porcomi / 100;
}
#ifndef MCOMPANNIA_H_
#define MCOMPANNIA_H_
#include "MCorredor.h"
#include "MContrato.h"
#include "MTipoSeguro.h“
class MCompannia
{ private:
vector<MCorredor> corredores;
vector<MTipoSeguro> tipos_seguros;
public:
MCompannia();
void IncluirUnCorredor(MCorredor cs);
void IncluirUnSeguro(MTipoSeguro ts);
MCorredor GetCorredor(int i);
MTipoSeguro GetTipoSeguro(int i);
//… cotinuación MCompannia.h
void SetCorredor(int i,MCorredor cs);
void SetTipoSeguro(int i,MTipoSeguro ts);
int CantCorredores();
int CantTiposSeguros();
int BusquedaCorredor(string ced);
void ProcesarContratoCorredor(MContrato contrato,
int pos);
vector<string> CorredoresQueSuperaronMetaVenta
(int tiposeg, int meta);
int CantidadContratosSegurosVendidosDeUnTipoSeguro
(int tiposeg);
};
#endif /* COMPANNIA_H_ */
int MCompannia::BusquedaCorredor(string ced)
{
for (int i=0; i<CantCorredores();++i)
if (corredores[i].GetCedula() == ced)
return i;
return -1;
}
void MCompannia :: ProcesarContratoCorredor(MContrato contrato,
int pos)
{
/*Instruccion que permite activar el método que le actualiza al corredor
de seguros que se está procesando, la cantidad total vendida en el mes
del tipo de seguro del contrato que se esta procesando y su comisión*/

corredores[pos].ActualizarCorredor(contrato.GetTipoSeguro(),
contrato.GetPrimaContrato(),
tipos_seguros[contrato.GetTipoSeguro()-1].GetPorcComi());
}

vector<string> MCompannia :: CorredoresQueSuperaronMetaVenta

(int tiposeg, int meta)
{ vector<string> auxced;
for (int i=0;i< CantCorredores();++i)
if (corredores[i].GetCantUnTipoSeguro(tiposeg - 1) > meta)
auxced.push_back(corredores[i].GetCedula());
return auxced;
}
int MCompannia ::
CantidadContratosSegurosVendidosDeUnTipoSeguro(int tipo)
{
int acum = 0;
for (int i=0; i< CantCorredores(); ++i)
acum += corredores[i].GetCantUnTipoSeguro(tipo - 1);
return acum;
}
#ifndef VCOMPANNIA_H_
#define VCOMPANNIA_H_
#include <vector>
#include "VGeneral.h"
class VCompannia : public VGeneral
{
public:
VCompannia();
void ReporteCorredores(vector<string> auxced,
vector<string> auxnom,
vector<float> auxcomi);
void ReporteCorredoresSuperaronMeta(vector<string> auxced);
};
#endif /* VCOMPANNIA_H_ */
void VCompannia :: ReporteCorredores(vector<string> auxced,
vector<string> auxnom,
vector<float> auxcomi)
{ Limpiar();
ImprimirStringJustificado("LISTADO CORR DE SEGUROS",46);
ImprimirLineasBlanco(1);
ImprimirStringJustificado("==========================",46);
ImprimirLineasBlanco(2);
ImprimirStringJustificado("CEDULA",12);
ImprimirStringJustificado("NOMBRE",25);
ImprimirStringJustificado("COMISION MENSUAL",20);
ImprimirLineasBlanco(1);
/* Inst. que imprimen la cédula, nombre y comisión mensual
de los corredores */
for(unsigned int i=0; i<auxced.size(); i++)
{ ImprimirStringJustificado(auxced[i],12);
ImprimirStringJustificado(auxnom[i],25);
ImprimirNroDecimalJustificado(auxcomi[i],20);
ImprimirLineasBlanco(1); }
ImprimirLineasBlanco(1);
Pausa(); }
void VCompannia :: ReporteCorredoresSuperaronMeta
(vector<string> auxced)
{ if (auxced.size()!=0)
{ Limpiar();
ImprimirEncabezado("LISTADO CORR.. SUPERARON META
VENTA","==============================");
ImprimirMensaje("CEDULAS");
ImprimirLineasBlanco(1);
/*Instrucciones que imprimen las cédulas de los corredores que
superaron la meta establecida para un tipo de seguro*/
for(unsigned int i=0; i<auxced.size(); i++)
{ ImprimirString("",auxced[i]);
ImprimirLineasBlanco(1);
} // fin del for
ImprimirLineasBlanco(1); Pausa();
return;
} // fin del if
Limpiar();
ImprimirMensaje("\n\n NO EXISTEN CORREDORES QUE HAYAN
SUPERADO LA META\n\n");
Pausa();
} // fin del metodo
#ifndef CONTROLADOR_H_
#define CONTROLADOR_H_
#include "MCompannia.h"
#include "VCompannia.h“
#include “VContrato.h”
class Controlador
{ private:
MCompannia mc;
VCompannia vc;
bool chequeocarga, chequeoproceso;
public:
Controlador();
void CargarArchivos();
void ProcesarContratos();
void ReporteCorredoresSuperaronMetaVenta();
void ConsultaTipoSeguro();
void ReporteCorredores();
};
#endif /* CONTROLADOR_H_ */
Para visualizar de manera efectiva
la programación del .cpp del
Controlador, se sugiere revisar
directamente en el aula virtual, el
proyecto ProyectoSeguro
#include "Controlador.h"
int main()
{ int opc;
VGeneral vg;
Controlador c;
do
{ vg.Limpiar();
vg.ImprimirLineasBlanco(2);
vg.Limpiar();
vg.ImprimirEncabezado("\n M E N U O P C I O N E S \n",
" ======= ============");
vg.ImprimirMensaje("1. CARGAR DATOS DE LOS ARCHIVOS
MAESTROS\N ");
vg.ImprimirMensaje(“2. PROCESAR CONTRATOS DE
SEGUROS VENDIDOS \n");
vg.ImprimirMensaje(“3. REPORTE CORREDORES QUE
SUPERARON META DE VENTA DE UN TIPO DE SEGURO \n");
vg.ImprimirMensaje(“4. CONSULTAR CANTIDAD DE
CONTRATOS DE SEGUROS VENDIDOS
POR UN TIPO DE SEGURO \n");
vg.ImprimirMensaje(“5. REPORTE COMISIONES
CORREDORES DE SEGUROS\n");
vg.ImprimirMensaje(“6. FINALIZAR \n\n");
// …continuación del main

opc = vg.LeerValidarNro("SELECCIONE SU OPCION : ",1,6);

switch (opc)
{ case 1: c.CargarArchivos();
break;
case 2: c.ProcesarContratos();
break;
case 3: c.ReporteCorredoresSuperaronMetaVenta();
break;
case 4: c.ConsultaTipoSeguro();
break;
case 5: c.ReporteCorredores();
break;
} // fin del case
} // Ffn del while
while(opc != 6);
return 0;
}