Professional Documents
Culture Documents
MANUAL TECNICO
PROYECTO FINAL
ndice
Contenido
ndice.................................................................................................................. 1
Introduccin........................................................................................................ 2
Diagrama de Flujos............................................................................................. 4
Borland c++....................................................................................................... 6
Cdigo Fuente................................................................................................... 13
Manual de Usuario............................................................................................ 26
Glosario............................................................................................................. 31
pg. 1
Introduccin
pg. 2
pg. 3
Diagrama de Flujos
pg. 4
pg. 5
Borland c++
Las dos primeras etapas conducen a un diseo detallado escrito en forma de algoritmo. La
tercera etapa (codificacin) se implementa el algoritmo en un cdigo escrito en un lenguaje
de programacin, reflejando las ideas desarrolladas en las fases de anlisis y diseo. La
compilacin y ejecucin traduce y ejecuta el programa. En la etapa de verificacin y
depuracin el programador busca errores de las etapas anteriores y los elimina. Por ltimo
se realiza la documentacin del programa.
pg. 6
Identificar los requerimientos internos y externos del problema: Requerimientos Internos
(gestin de datos) Qu debe hacer el programa? Qu datos de entrada y de salida
intervienen en el proceso? Requerimientos Externos (interaccin con el usuario y con otras
aplicaciones) En qu mquina y sistema operativo se debe ejecutar el programa? Quin
ser el usuario de la aplicacin?
Buscar una solucin informtica del problema planteado La solucin determinar Cmo se
va a resolver el problema Uso del diseo modular o descendente (Top-down) Dividir el
problema en partes, abstraccin y encapsulacin Uso de algoritmos Establece de manera
genrica la secuencia de pasos o acciones que resuelve un problema determinado Uso de
herramientas para el diseo de algoritmos Diagramas de flujo (ordinogramas)
Pseudocdigo (lenguaje intermedio)
Estructura bsica del Programa #include Directivas definidas #define Macros del
procesador void main() Funcin principal { declaraciones locales sentencias necesarias del
programa; }
La Funcin principal main() Los programas de C++ contienen una funcin main() la cual es
llamada funcin principal y es el punto inicial de entrada al programa. Las sentencias
incluidas entre las llaves { } se denominan bloque y en el caso de la Funcion main() estas
sentencias se denominan cuerpo del programa.
Los Comentarios: Los comentarios no generan cdigo de mquina y son ignorados por el
compilador. Con fines de documentacin se pueden aadir comentarios a un programa. Se
consideran como comentarios: Al texto que sigue a los caracteres // hasta el final de la
lnea. Al texto de una o ms lneas encerrado entre / * y / * .
Reglas para construir identificadores vlidos: Primer carcter debe ser una letra o el
carcter subrayado, los caracteres siguientes pueden ser letras, nmeros o smbolo de
subrayado. No se permiten espacios en blanco. La longitud mxima es de 32 caracteres
(estndar). El nombre del identificador no puede ser una palabra reservada. Las letras
maysculas y las letras minsculas se consideran como diferentes.
Una palabra reservada son palabras seleccionadas por el lenguaje de programacin para un
propsito especial y slo puede usarse en una forma especfica. Las palabras reservadas del
C++ se escriben en letras minscula, motivo por el cual podemos definir como
identificadores de variables a las siguientes palabras: DO, IF, FOR, CHAR, CASE, WHILE
No son palabras reservadas ya que se encuentran escritas en mayscula.
Tipos de Datos en C++ El objetivo de todos los programas es procesar datos, sean
numricos, alfabticos o audio. Es fundamental para este objetivo la clasificacin de los
datos en tipos especficos. Tipo de dato se define como un conjunto de valores y un
conjunto de operaciones que pueden aplicarse a estos valores. Los tipos de datos ms
comunes son: entero (int), real (float) y carcter (char), los tipos de datos son usados para
definir el tipo de variables, de constantes, etc.
Tipo de datos bsicos Tipo Tamao Rango char 8 bits -128 a 127 Int 32 bits -2,147, 483,
648 a 2,147,483,647 Iong 32 bits -2,147, 483, 648 a 2,147,483,647 float 32 bits 3.4 x 10-38
a 3.4 x 10+38
Tipo de datos extendidos Tipo Tamao Rango unsigned Char 8 bits 0 a 255 char 8 bits
-128 a 127 short int 16 bits -32,768 a 32,767 unsigned int 32 bits 0 a 4,294,967,295
unsigned int 32 bits 0 a 4,294,967,295 int 32 bits -2,147,483,648 a 2,147, 483, 647
unsigned long 32 bits 0 a 4,294,967,295 enum 16 bits -2,147,483,648 a 2,147, 483, 647
long 32 bits -2,147,483,648 a 2,147, 483, 647 float 32 bits 3.4 x 10-38 a 3.4 x 10 + 38
double 64 bits 1.7 x 10-308 a 1.7 x 10+308 long double 80 bits 3.4 x 10-4932 a 1.1 x 10 +
4932
Declaremos tres variables una entera h, una de tipo char respuesta y una de tipo float
denominada rea. int h; char respuesta; float area; Una variable tambin puede ser
inicializada al momento de su declaracin tipo_de_dato nombreDeVariable = valor_inicial;
Si las variables son del mismo tipo se pueden declarar en simultaneo pero separadas por
una coma.
Declaracin de Variables de cadena de caracteres char cadena [tamao]; char nombre [35];
cadena es el nombre arbitrario elegido para la variable de cadena. Tamao es el tamao de
la cadena (debe ser uno o ms que el nmero total de caracteres). Una cadena tambin
puede ser inicializada al momento de su declaracin as: char cadena [5] = cobre ;
Operadores Aritmticos Operador Significado Ejemplo + Suma a+b - Resta a-b * Producto
a*b / Cociente de divisin a/b % Resto de divisin entera a%b ++ Incremento --
Decremento
Funciones Comunes de C+ + abs (a) Valor absoluto pow (a1,a2) a1 elevado a la potencia
a2 sqrt (a) Raz cuadrada de un nmero real sin (a) Seno de a en radianes cos (a) Coseno de
a en radianes tan (a) Tangente de a en radianes
log (a) logaritmo natural de a log10 (a) logaritmo comn (base 10) de a exp (a) e elevado a
la potencia a Ejemplos: sqrt (25.) valor devuelto 5 abs (-7.362) valor devuelto 7.362 pow
(10,3) valor devuelto 1000
4 *sqrt ( 4.5 * 10.0 9.0 ) - 2.0 = 4 * sqrt (36.0) 2.0 = 4 * 6.0 2.0 = 24.0 2.0 = 22
Usos y transmisin de datos a una funcin
pg. 11
Entradas y salidas bsicas La entrada y salida (input / output) en C++ se realiza utilizando
los flujos cin y cout. El flujo cout, cuyo nombre deriva de Console OUTput, es un objeto de
salida que enva datos introducidos en l al dispositivo estndar de salida, este dispositivo
de salida es generalmente una pantalla de video. La forma ms simple de salida se efecta
mediante el smbolo de insercin: << ( enviar a ) cout << constante; cout << Hola
Amigos;
El flujo cin, se usa para introducir datos en un programa mientras se est ejecutando, cin es
un flujo de datos que conecta el teclado con el programa. Cualquier entrada desde el teclado
es enviada primero al flujo cin, luego el programa puede extraer (leer) datos desde este
flujo. La forma ms simple de leer se efecta mediante el smbolo de extraccin: >>
(obtener de) cin >> variable; cin >> nota;
#include <iostream.h> #include <conio.h> void main () { int a,b,suma, resta, producto;
clrscr (); cout<<"ingrese a:" ; cin>>a; cout<<"ingrese b:" ; cin>>b ; suma = a+b ; resta = a-
b ; producto = a*b ; cout <<"La suma es:" << suma << n; cout << "La resta es:" << resta
<< n ; cout << "El producto es:" << producto << n; getch() ; }
Tabla de indicadores de formato para usarse con setiosflag Indicador Accin ios::left
Justifica la salida a la izquierda dentro del ancho de setw (). ios::right Justifica la salida a la
derecha dentro del ancho de setw() ios::scientific Muestra nmeros de comas flotantes en
notacin cientfica. ios::fixed Muestra en formato de punto fijo los nmeros de coma
flotante. ios::dec Formatea los nmeros en base 10 ios::hex Formatea los nmeros en base
16. ios::oct Formatea los nmeros en base 8. ios::uppercase Formatea los caracteres de
valores a maysculas en la notacin hexadecimal y cientfica ios::showbase Imprime el
prefijo inicial de base numrica (ya sea 0x para hexadecimal 0 para octal). ios::showpos
Imprime un signo mas cuando se trata de nmeros positivos. ios::showpoint Despliega
ceros a la derecha cuando se necesitan para la cantidad de decimales especificada.
Cdigo Fuente
#include <ctype.h> // isdigit
#include <stdlib.h> // atoi
#include <string.h> // strlen
#include <stdio.h> // printf, fgets, stdin, BUFSIZ
#include<iostream> //cout, cin
#include<fstream>
#include<stdlib> //system()
#include<stdio>
pg. 13
#include<conio> //gotoxy
#include<cstring>
//funciones
int nuevaFactura();
void menu();
int BDFactura();
int Buscar_Factura();
int Buscar_Clientes();
int Ingreso_Menu(char buffer[BUFSIZ]);
int demeNumero(int y,int x);
bool ingreso_cadena_con_espacio(char letras2[]);
bool ingreso_cadena(char letras[]);
void desarrolladores();
//Estructura para el detalle
struct
{
int nProducto[30];//es el numero de producto osea Num.
int numFactura; //numero de la factura
int cantidad[30];//se puede almacenar hasta 30 cantidades
char nomProducto[30][30]; //almaceno caracteres con espacio; es el nombre del
producto
char medida[10][30]; //almaceno caracteres con espacio; es la medida del
producto
int numProductos; //es cuantos productos voy a ingresar
double precioUnitario[30];
double precioTotal[30];
double SubTotal;
double IVA;
double Total;
} Detalle;
int main(void)
{
int opcion;
do //ciclo repetir asta que
{
system("cls");//borrar pantalla
menu();//menu de opciones
char buffer[BUFSIZ];//hacemos el nuevaFactura numerico con buffer
pg. 14
opcion=Ingreso_Menu(buffer);//en la funcion Ingreso_Menu(buffer) se hace el
nuevaFactura
system("cls");//borrar pantalla
//Menu
void menu()
{
//menu para que el usuario se guie.
gotoxy(19,19);printf("%c", 201);//esquina superior izquierda
gotoxy(61,19);printf("%c", 187);//esquina superior derecha
gotoxy(19,39);printf("%c", 200);//esquina inferior izquierda
gotoxy(61,39);printf("%c", 188);//esquina inferior derecha
for(int k=20; k<61; k++){//dibujamos las lineas horizontales
gotoxy(k,19);printf("%c", 205);
gotoxy(k,39);printf("%c", 205);
}
pg. 15
for(int k=20; k<39; k++){//dijumos las lineas verticales
gotoxy(19,k);printf("%c", 186);
gotoxy(61,k);printf("%c", 186);
}
gotoxy(22,22);cout<<" * GUATEMAYA S.A. * ";
for(int k=20; k<61; k++){//dibujamos linea horizontal
gotoxy(k,24);printf("%c", 205);
}
gotoxy(24,26);cout<<" FACTURACION ";
gotoxy(20,27);cout<<"_________________________________________";
gotoxy(26,30);cout<<"1 - Nueva Factura ";
gotoxy(26,31);cout<<"2 - Buscar numero de factura ";
gotoxy(26,32);cout<<"3 - Buscar apellido de Cliente";
gotoxy(26,33);cout<<"4 - Base de datos ";
gotoxy(26,33);cout<<"5 - Desarrolladores ";
gotoxy(26,34);cout<<"6 - Exit ";
gotoxy(27,36);printf("Ingrese opcion %c ", 175 );//solicitud de su respuesta
}
//opcion 1
int nuevaFactura()
{
char numero[10];
system("cls");//borrar pantalla
gotoxy(1,1); printf("%c", 201);//esquina superior izquierda
gotoxy(80,1); printf("%c", 187);//esquina superior derecha
gotoxy(1,44); printf("%c", 200);//esquina inferior izquierda
gotoxy(80,44);printf("%c", 188);//esquina inferior derecha
for(int k=2; k<80; k++)//dibujamos las lineas horizontales
{
gotoxy(k,1); printf("%c", 205);
gotoxy(k,6); printf("%c", 205);
gotoxy(k,44);printf("%c", 205);
gotoxy(k,9); printf("_");
gotoxy(k,14);printf("_");
}
for(int k=2; k<44; k++)//dijumos las lineas verticales
{
gotoxy(1,k); printf("%c", 186);
gotoxy(80,k);printf("%c", 186);
}
gotoxy(25,4);cout<<" * Aeropuerto GT S.A. * ";
gotoxy(34,8);cout<<" NUEVA FACTURA ";
// captura de campos
gotoxy(10,12);cout << "Fecha : ";
gotoxy(37,12);cout << "Cajero : ";
gotoxy(10,13);cout << "Factura No: ";
gotoxy(18,12);cin >> Facturas.fecha;
char letras[10];
do{
gotoxy(48,12);gets(letras);
if(ingreso_cadena_con_espacio(letras)==true){
strcpy(Facturas.vendedor,letras);
}else{
pg. 16
gotoxy(48,12);clreol();
}
}while(ingreso_cadena_con_espacio(letras)==false);
gotoxy(22,13);Facturas.numFactura=demeNumero(22,13);
gotoxy(30,14);cout << " DATOS DEL CLIENTE ";
gotoxy(10,16);cout << "Nombre : ";
gotoxy(37,16);cout << "Apellido : ";
gotoxy(37,17);cout << "nit : " ;
gotoxy(10,17);cout << "Direccion : ";
gotoxy(10,18);cout << "Telefono : ";
do{
gotoxy(19,16);gets(letras);
if(ingreso_cadena(letras)==true){
strcpy(Facturas.nombre,letras);
}else{
gotoxy(19,16);clreol();
gotoxy(37,16);cout << "Apellido : ";
}
}while(ingreso_cadena(letras)==false);
do{
gotoxy(48,16);gets(letras);
if(ingreso_cadena(letras)==true){
strcpy(Facturas.apellido,letras);
}else{
gotoxy(48,16);clreol();
}
}while(ingreso_cadena(letras)==false);
do{
gotoxy(22,17);gets(letras);
if(ingreso_cadena_con_espacio(letras)==true){
strcpy(Facturas.direccion,letras);
}else{
gotoxy(22,17);clreol();
gotoxy(37,17);cout << "nit : " ;
}
}while(ingreso_cadena_con_espacio(letras)==false);
gotoxy(46,17);Facturas.nit=demeNumero(46,17);
gotoxy(21,18);Facturas.telefono=demeNumero(21,18);
Detalle.numFactura = Facturas.numFactura;
gotoxy(3,21);printf("Ingrese el numero de pasajeros: ");
gotoxy(35,21);Detalle.numProductos=demeNumero(35,21);
//aqui estan las lineas del nembrete del detalle
gotoxy(2,22);
printf("______________________________________________________________________________");
gotoxy(2,25);
printf("______________________________________________________________________________");
//dibujo las lineas verticales del nembrete del detalle
for(int i=0; i<4; i++)
{
gotoxy(8,23+i); printf("%c", 179);
pg. 17
gotoxy(28,23+i);printf("%c", 179);
gotoxy(39,23+i);printf("%c", 179);
gotoxy(49,23+i);printf("%c", 179);
gotoxy(64,23+i);printf("%c", 179);//espacio para P. Total
}
//ubicamos en pantalla los rotulos del detalle
gotoxy(3,24);printf("Num.");
gotoxy(10,24);cout << "DETALLE del Avion";
gotoxy(30,24);cout << "CANTIDAD";
gotoxy(40,24);cout << "Asiento";
gotoxy(52,24);cout << "P. Unitario";
gotoxy(67,24);cout << "P. Total";
int i=27,j=0;//posiciones en pantalla
Detalle.SubTotal= Detalle.nProducto[j];//acumula el preciototal
while(j<Detalle.numProductos)
{
gotoxy(3,i);printf(" %d ",j+1); Detalle.nProducto[j]=j+1;//numero de
articulo
char nombreProducto[30];
gotoxy(11,i);gets(nombreProducto);strcpy(Detalle.nomProducto[j],nombreProducto);
gotoxy(33,i);Detalle.cantidad[j]=demeNumero(33,i);
do{
gotoxy(44,i);gets(letras);
if(ingreso_cadena(letras)==true){
strcpy(Detalle.medida[j],letras);
}else{
gotoxy(44,i);clreol();
}
}while(ingreso_cadena(letras)==false);
pg. 18
gotoxy(2,i-
1);printf("______________________________________________________________________________
");
i=i+2;
Detalle.IVA=Detalle.SubTotal*0.12;
Detalle.Total= Detalle.SubTotal+Detalle.IVA;
Facturas.total=Detalle.Total;
gotoxy(52,i); printf("Subtotal : $ %5.2f",Detalle.SubTotal);
gotoxy(52,i+2);cout <<"IVA. 12% : ";printf("$ %5.2f",Detalle.IVA);
gotoxy(52,i+4);printf("- - - - - - - - - -\n");
gotoxy(52,i+6); printf(" Total -> $ %5.2f",Detalle.Total);
gotoxy(2,i+8);printf("__________________________________________________________________
____________");
getch();
//Grabamos a disco la estructura factura
FILE *archdisco_factura;
archdisco_factura = fopen("factura.txt","at+");
if(archdisco_factura==NULL)
{
cout<<"no se pudo abrir el archivo";
exit(1);
}
fwrite(&Facturas,sizeof(Facturas),1,archdisco_factura);
fclose(archdisco_factura);
//avisando usuario
// cout << "\n\n\tfactura insertada " << endl;
//Grabamos a disco la estructura detalle
FILE *archdisco_detalle;
archdisco_detalle = fopen("detalle.txt","at+");
fwrite(&Detalle,sizeof(Detalle),1,archdisco_detalle);
fclose(archdisco_detalle);
//avisando usuario
cout << "\tFactura guardada con exito \n" << endl;
system("pause");
return 0;
}
//opcion 2
int Buscar_Factura()
{
int factura;
cout << "\n\nIngrese numero de factura a buscar: ";
gotoxy(37,3);factura=demeNumero(37,3);
//abrimos el archivo que contiene la estructura
FILE *archdisco_open_detalles;
archdisco_open_detalles = fopen("detalle.txt","r");
//leemos el archivo de datos
bool encontrado = false;
cout << "\n"<< endl;
while(fread(&Detalle,sizeof(Detalle),1,archdisco_open_detalles)==1)
{
if (factura == Detalle.numFactura)
{
pg. 19
cout << "|| Factura No = " << Detalle.numFactura << endl;
for(int j=0; j <Detalle.nProducto[j]; j++){
cout << "|| Num." << Detalle.nProducto[j] << endl;
cout << "|| "<<endl;
cout << "|| Producto = " << Detalle.nomProducto[j] <<
endl;
cout << "|| Cantidad = " << Detalle.cantidad[j] << endl;
cout << "|| Medida = " << Detalle.medida[j] << endl;
printf("|| P. Unit. = %5.2f",Detalle.precioUnitario[j]);
printf("\n");
printf("|| P. Total = %5.2f",Detalle.precioUnitario[j]);
printf("\n");
}
cout << "||"<<endl;
cout << "|| SUBTOTAL = " << Detalle.SubTotal << endl;
cout << "|| IVA. 12% = ";printf("$ %5.2f",Detalle.IVA);
printf("\n");
printf("|| TOTAL -> $ %5.2f",Detalle.Total);
cout <<
"\n________________________________________________________\n" << endl;
encontrado = true;
}
};
if (encontrado==false)
{
cout <<"\n\nLa factura: " << factura << " no fue hallada" << endl;
}
//Cerramos el archivo.
fclose(archdisco_open_detalles);
return 0;
}
//opcion 3
int Buscar_Clientes()
{
char apellido_a_buscar[30];
char * pch;
int caracter;
bool encontrado = false;
char texto_a_buscar[30];
cout << "\n\nIngrese parte del Apellido a buscar: ";
do{
gotoxy(38,3);gets(texto_a_buscar);
if(ingreso_cadena(texto_a_buscar)==false){
gotoxy(38,3);clreol();
}
}while(ingreso_cadena(texto_a_buscar)==false);
//abrimos el archivo que contiene la estructura
FILE *archdisco_open_Facturas;
archdisco_open_Facturas = fopen("factura.txt","r");
//leemos el archivo de datos e informamos
while(fread(&Facturas,sizeof(Facturas),1,archdisco_open_Facturas)==1)
{
strcpy (apellido_a_buscar, Facturas.apellido);
pch = strstr (apellido_a_buscar, texto_a_buscar);
pg. 20
caracter = pch - apellido_a_buscar + 1;
if (caracter >= 0)
{
cout << " \n\nApellido : " << texto_a_buscar << " fue encontrado..." << endl;
cout << "\n________________________________________________________\n" << endl;
cout << "|| - Fecha = " << Facturas.fecha << endl;
cout << "|| Fact. No = " << Facturas.numFactura << endl;
cout << "|| Apellido = " << Facturas.apellido << endl;
cout << "|| Nombre = " << Facturas.nombre << endl;
cout << "|| nit " << Facturas.nit << endl;
cout << "|| Direccion = " << Facturas.direccion << endl;
cout << "|| Telefono = " << Facturas.telefono << endl;
cout << "|| "<<endl;
printf(" || TOTAL -> $ %5.2f",Facturas.total);
cout << "\n________________________________________________________\n" << endl;
encontrado=true;
}
};
if (encontrado==false)
{
cout <<"\n\nEl apellido buscado: " << texto_a_buscar << " no fue encontrado"
<< endl;
}
//Cerramos el archivo.
fclose(archdisco_open_Facturas);
return 0;
}
//opcion 4
int BDFactura()
{
int cantidad = 0;
//abrimos el archivo que contiene la estructura
FILE *archdisco_open_Facturas;
archdisco_open_Facturas = fopen("factura.txt","r");
//verificamos el numero de elementos de la misma.
while(fread(&Facturas,sizeof(Facturas),1,archdisco_open_Facturas)==1)
{
cantidad++;
};
//Lo informamos al usuario
cout << "\n\n" << endl;
printf("La base de datos contiene %d facturas\n", cantidad);
cout << "\n\n" << endl;
system("pause");
rewind(archdisco_open_Facturas);
//volvemos a leer el archivo de datos e informamos
while(fread(&Facturas,sizeof(Facturas),1,archdisco_open_Facturas)==1)
{
cout << "|| - Fecha = " << Facturas.fecha << endl;
cout << "|| Fact. No = " << Facturas.numFactura << endl;
cout << "|| Nombre = " << Facturas.nombre << endl;
cout << "|| Apellido = " << Facturas.apellido << endl;
cout << "|| nit = " << Facturas.nit << endl;
cout << "|| Direccion = " << Facturas.direccion << endl;
pg. 21
cout << "|| Telefono = " << Facturas.telefono << endl;
cout << "|| Vendedor = " << Facturas.vendedor << endl;
cout << "||"<<endl;
printf("|| Total -> $ %5.2f",Facturas.total);
cout << "\n________________________________________________________\n" << endl;
};
//Cerramos el archivo.
fclose(archdisco_open_Facturas);
return 0;
}
valid = false;
while (!valid) {
//printf ( "Enter an integer: " );
if (fgets (buffer, sizeof buffer, stdin) != NULL) {
buffer[strlen(buffer)-1] = '\0';
found_nondigit = false;
if (strlen(buffer) == 0)
found_nondigit = true;
for (n=0; n<strlen(buffer); n++)
if (!isdigit(buffer[n]))
found_nondigit = true;
if (!found_nondigit) {
number = atoi(buffer);
//printf ("%d\n", number);
valid = true;
} else{
system("cls");//borrar pantalla
menu();
gotoxy(26,36);
cout<< "Re-ingrese numero -> ";
}
}
}
// system("pause");
return number;
}
pg. 22
while(isdigit(t)){
valcomplex=valcomplex*10+t-'0';
t=getchar();
digito++;
i++;
}
ungetc(t,stdin);
}
i++;
}
if(i==digito){
valida =true;
}else{
digito=0;
i=0;
valida =false;
gotoxy(y,x);
clreol();
}
}while(valida==false);
return valcomplex;
}
pg. 23
if(blanco==1){
if(i==(blanco+abc))
return true; //esta bien ingresado el numero
}else{
return false;
}
}
}
void desarrolladores(){
cout<<"\n\n\n\t\t\tAlumno Carne\n\n";
cout<<"\t\t\tJose Roberto Perez Soto 0900-16-
11476\n";
cout<<"\t\t\tFranklyn Neftali Ramirez Vealsquez 0900-16-16315\n";
cout<<"\t\t\tYlario de Jesus Rivera 0900-13-62\n";
cout<<"\t\t\tBryan Usiel Samayoa Cotufa 0900-16-2963\n";
cout<<"\t\t\tPedro Xavier zuleta Rodriguez 0900-16-18266\n";
cout<<"\n\t\tTodo contenido visto en este SOFTWARE pertenecen a los
desarrolladores mencionados anteriormete\n";
cout <<"\t\t\t\t\tCopyright 2016-2016 GUATEMAYA version 5.10";
getwchar();
return;
}
pg. 24
MANUAL DE USUARIO
PROYECTO FINAL
ALGORITMOS
pg. 25
Manual de Usuario
Introduccion
en la seleccin de asientos de un avion se puede realizar el proceso por medio de funciones,
utilizando a sus vez manejo de archivos para la generacion de un archivo.txt, en el que se
guardaran los registros de las reservaciones de los asientos que se generen en los aviones
disponibles de una aerolinea y la consulta se pueda realizar en un txt para realizar consultas
en linea aplicando conceptos como lo son insumo de datos, salida de datos, archivo, switch
case para operar las funciones.
Para asi llevar un registro de todas las reservaciones a manera que se queden regitrados los
datos.
Asi como un sistema de facturacion que realice los calculos y que se guarde los datos por
medio del numero de factura asi como por apellido del cliente.
pg. 26
1. Opcin 1
1.1Desplega la factura.
Donde se ingresarn los datos siguientes:
Fecha, numero de factura y cajero
Nota el nombre del cliente no puede ser igual al del cajero, no dejara ingresar el dato.
1.3. ingrese el nmero de pasajeros
pg. 27
1.4. luego de indicar el nmero de pasajeros solicita los siguientes datos
Numero: correlativo
Detalle del avin: qu tipo de avin se solicit el servicio, comercial o privado.
Cantidad: cantidad de pasajeros que pueden ir en el avin.
Asiento: nmero de asiento.
Precio unitario: precio de un boleto.
Precio total: precio de la cantidad de pasajeros por el precio unitario
Luego de ingresar los datos se realiza el clculo total con IVA.
pg. 28
Se realiza la bsqueda de una factura, si se encuentra la factura guardada desplegara la
siguiente pantalla.
3. opcin 3
Bsqueda por apellido de cliente
Si el cliente se localiza dentro del archivo mostrara la siguiente pantalla
pg. 29
De lo contrario desplegara el siguiente mensaje
4. opcin 4
Especifica una base de datos de las facturas que se han ingresado y las muestra.
5. opcin 5
Muestra los nombres de las personas que desarrollaron el programa.
pg. 30
Glosario
Abstraccin
Habilidad de tomar algo como un todo, sin tener en cuenta los detalles. El propsito de la
abstraccin es entender algo sin basarse en su estructura interna. La programacin orientada
a objetos se basa en la abstraccin tanto de datos como funcional.
Abstraccin de datos
Posibilidad de ocultar detalles especficos de la implementacin de un tipo de datos. El C++
permite definir nuevos tipos de datos por medio de clases, abstrayendo su implementacin.
Abstraccin funcional
Permite considerar una funcin, procedimiento o mtodo por sus entradas, sus salidas y lo
que realiza, sin tener que conocer los algoritmos que usa. Si funciona correctamente no se
necesita saber cmo est realmente implementada sino solamente cmo utilizarla.
Algoritmo
Procedimiento complejo para resolver un problema.
Atributo
Miembro de datos de una clase. Define una caracterstica para cada objeto de la clase.
Atributo de clase
Atributo cuyo valor es comn a todos los objetos de una clase. En C++ son los miembros
estticos.
Cadena
Secuencia de caracteres de texto (en ingls string).
Campo
Vase mbito.
Caso de uso (UML)
Descripcin de un conjunto de secuencias de acciones, incluyendo variantes, que ejecuta un
sistema para producir un resultado observable.
Clase
Definicin de un tipo de objetos que tienen unas caractersticas comunes. Una clase es un
patrn para crear nuevos objetos. Una clase contiene tanto atributos como mtodos.
Compilacin
Traduccin de un cdigo fuente a su cdigo objeto (cdigo mquina generalmente) listo
para el enlazado.
Composicin (UML)
Forma de agregacin con fuerte pertenencia y que designa una relacin en la que un
elemento se compone de otro u otros.
Constructor
En C++ una operacin que inicializa el objeto al crearse.
Contenedor
Objeto que existe para contener otros objetos y que proporciona operaciones para acceder o
iterar sobre los elementos que contiene.
Conversin
Accin de transformar un tipo en otro distinto.
Correccin
Un programa es correcto si cumple las especificaciones requeridas.
pg. 31
Declaracin
Una declaracin introduce nombres y sus tipos dentro del programa sin que necesariamente
se defina un objeto o funcin asociado. Sin embargo, muchas declaraciones sirven como
definiciones.
Definiciones
Una definicin proporciona informacin que permite al compilador reservar memoria para
objetos o generar cdigo para funciones.
Excepcin
Es una situacin anmala o error que se puede presentar durante la ejecucin de un
programa. Elevar una excepcin es abandonar la ejecucin normal de un programa para
indicar que el error ha tenido lugar. El manejador de excepciones se encargar de su
tratamiento.
Exportar
Hacer visible un elemento externamente a un mdulo o paquete.
Extensibilidad
Propiedad del software por la cual algunos objetos o funcionalidades pueden aadirse a un
sistema con poca o ninguna modificacin del cdigo existente.
Funcin
Relacin operacional entre varias entidades. Se suelen representar como una
correspondencia entre unos argumentos (entrada) y un resultado (salida).
Interfaz
Coleccin de operaciones que se utiliza para especificar un servicio de una clase o
componente.
Iterador
Mecanismo que permite recorrer una estructura que contiene muchos objetos como, por
ejemplo, un contenedor.
Jerarqua de clases
Cuando unas clases heredan de otras se forma una estructura arbrea que se denomina
jerarqua. Se puede pensar una jerarqua de clases como un rbol de familia, en el que las
clases derivadas son las hijas de las clases base (madres).
Mtodo
Define una operacin sobre un objeto. Es la implementacin de un mensaje para una clase.
Cuando se enva un mensaje a un objeto, se ejecuta el mtodo definido por la clase del objeto. En
C++ los mtodos son funciones miembros de las clases que se invocan de la misma forma que las
funciones. .
Mdulo
Subconjunto coherente del sistema conteniendo un grupo de funciones, clases y sus relaciones.
Name-mangling
Es la conversin que hace el compilador de C++ de una funcin definida en C++ a un identificador
nico para ser enlazada.
Objeto
Es la instancia de una clase. Un objeto es una entidad que tiene un estado y un conjunto definido de
operaciones (mtodos) que operan sobre este estado. El estado se representa por un conjunto de
atributos del objeto. Las operaciones asociadas con el objeto dan servicio a otros objetos (clientes)
que piden estos servicios cuando se necesita alguna operacin (por medio de mensajes).
pg. 32
Operador
Funcin que tiene un nombre, generalmente no alfanumrico, y que se invoca sin parntesis y en
distintas posiciones (prefijo, postfijo o infijo).
Referencia
Variable o atributo de un objeto que contiene una referencia implcita a otro que no requiere realizar
una indireccin para acceder al objeto referenciado.
Relacin (UML)
Conexin semntica entre elementos.
Stream
Estructura de datos que permite el flujo, generalmente secuencial, de objetos a travs de l.
Utilizado para la E/S en C++.
Subclase
Ver clase derivada.
Subsistema
Componente importante de un sistema organizado de una forma coherente. Un sistema puede ser
dividido en subsistemas usando particiones o niveles.
this
En C++ designa un puntero al objeto sobre el que opera un mtodo.
Variable
Entidad que puede cambiar de estado. En C++ una variable es un dato de un tipo fundamental o
derivado (por ejemplo int, float, punteros), en contraposicin a los objetos que son instancias de una
clase.
Verificabilidad
Capacidad que tiene un programa para demostrar que funciona correctamente.
Visibilidad
Se dice que un identificador es visible en un punto dado del cdigo fuente de un programa si el
compilador le puede asociar el elemento que denota el identificador.
pg. 33