You are on page 1of 34

ALGORITMOS

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++

ETAPAS PARA LA ELABORACION DEETAPAS PARA LA ELABORACION DE


UN PROGRAMA UN PROGRAMA

El proceso de solucin de un problema en la computadora conduce a la escritura y la


ejecucin del programa en la misma. La elaboracin de un programa requiere un proceso
creativo. La solucin de un programa requiere las siguientes etapas: Anlisis del problema
Diseo del algoritmo Diagramas de flujo Pseudocodigo Codificacin del programa
Compilacin y ejecucin del programa Verificacin y depuracin del programa
Documentacin

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.

Compilacin (Proceso de Traduccin) Es el proceso mediante el cual se lleva un programa


escrito en lenguaje de alto nivel a lenguaje de mquina. Compilador Es un programa que se
encarga de la traduccin del lenguaje simblico al lenguaje de mquina.

ANALISIS DEL PROBLEMA

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?

ETAPAS PARA LA ELABORACION DEETAPAS PARA LA ELABORACION DE


UN PROGRAMA UN PROGRAMA DISEO DEL ALGORITMO

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)

ETAPAS PARA LA ELABORACION DEETAPAS PARA LA ELABORACION DE


UN PROGRAMA UN PROGRAMA CODIFICACION DEL PROGRAMA

La codificacin las acciones (sentencias) definidas en el algoritmo se deben convertir a


instrucciones (ordenes) a la computadora mediante un lenguaje de programacin de alto
nivel. Mediante este lenguaje de programacin el programador se comunica con la
computadora para indicarle las rdenes que debe realizar.

ETAPAS PARA LA ELABORACION DEETAPAS PARA LA ELABORACION DE


UN PROGRAMA UN PROGRAMA COMPILACIN Y EJECUCIN DEL
PROGRAMA

La compilacin es el proceso de traduccin del lenguaje de programacin de alto nivel


(cdigo fuente) al lenguaje de mquina mediante el COMPILADOR del lenguaje de
programacin. Durante el proceso de compilacin se determinan los errores de sintaxis del
programa informtico. Si hay errores es preciso corregir los errores y volver a compilar.
Luego se procede a vincular el cdigo objeto con las bibliotecas, creando el cdigo
ejecutable. Durante el proceso de ejecucin se determinan los errores de ejecucin del
programa. Estos errores se producen por instrucciones que la computadora puede
comprender pero no ejecutar (divisin entre cero).

ETAPAS PARA LA ELABORACION DEETAPAS PARA LA ELABORACION DE


UN PROGRAMAUN PROGRAMA VERIFICACION Y MANTENIMIENTO DEL
PROGRAMA

La etapa de la verificacin verifica el correcto funcionamiento del programa con una


amplia variedad de datos de entrada, llamados datos de prueba. Los datos de prueba deben
cubrir una amplia gama de posibilidades que incluye datos normales, datos extremos y
datos especiales. El mantenimiento de los programas consiste en la actualizacin o
correccin de los programas no detectados en las fases anteriores. El mantenimiento
pg. 7
consiste tambin en las modificaciones de los programas para ampliar o cambiar algunas
funcionalidades de los programas.

LENGUAJE DE PROGRAMACION C++LENGUAJE DE PROGRAMACION C++


El esquema de un programa en borland C++ se compone bsicamente de las siguientes
partes: Directivas definidas. Declaraciones y definiciones de funciones secundarias
declaradas por el usuario. Una funcin principal main()

Estructura bsica del Programa #include Directivas definidas #define Macros del
procesador void main() Funcin principal { declaraciones locales sentencias necesarias del
programa; }

Directivas Definidas Las directivas definidas son instrucciones especiales para el


compilador del borland C ++ Las directivas son generalmente #include y #define (indica al
compilador que incluya el contenido del archivo referenciado). Estos archivos se
denominan archivos de cabecera y tienen una extensin .h

#include<math.h> // incluye al archivo fuente C++ de las // libreras matemticas.


#include<conio.h> // incluye al archivo fuente el manejo de // pantalla.
#include<iostream.h> // proporciona al compilador C+ + // la informacin necesaria
sobre // las funciones de // biblioteca cin y cout

La directiva #define permite crear definiciones de macro. La sintaxis general para la


directiva #define es: #define nombreConstante Valor #define DIAS 7

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.

La sentencia: Una sentencia o instruccin le indica al compilador un tipos accin


especfica. De acuerdo a la sintaxis de C++, una sentencia puede consistir de una de las
siguientes formas: Una nica sentencia (sentencia simple) Un bloque de sentencias
(instrucciones encerradas entre llaves de bloque { } . Una sentencia nula (consta de slo un
punto y coma).

Signos de Puntuacin: Todas las sentencias de un programa en el lenguaje C++ deben


finalizar en punto y coma. Las llaves agrupan sentencias: { clrscr(); Cout<<suma=<<
resultado; getch(); } Las comas separan elementos iguales int x, m, n;

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 / * .

El resto de componentes de un programa en C++ son: identificadores, tipos de dato, las


variables, las constantes, caracteres y los operadores. Los Identificadores Los
pg. 8
identificadores son nombres usados para identificar a las variables, las constantes, tipos,
funciones y etiquetas en un programa, etc.

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.

Palabras reservadas de C + + asm, Double, Mutable, Struct, auto, else, namespace,


switch, bool, enum, new, template, break, explicit, operador, this, case, extern, private,
throw, char, for, public, typedef, class, friend, register, unin, const, goto, return, unsigned,
continue, if, short, virtual, default, inline, signed, void, delete, int, sizeof, volatile, do, long,
static, echar,_t, while.

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

Variable La variable es una localizacin en la memoria del computador que guarda


informacin para ser procesada por la computadora. Una variable tiene un nombre, un tipo,
un valor y una direccin. Representan a identificadores que cambian su valor durante la
ejecucin de un programa. Nombre especifica la posicin de memoria asignada tipo
especifica si la variable contiene un nmero entero, nmero real, carcter u otro tipo de
dato. Valor representa el contenido de la variable en un momento dado. Direccin
especifica el lugar donde se almacena la variable.
pg. 9
Declaracin de una variable Una variable antes de ser utilizada debe ser creada en la
memoria del computador mediante su declaracin. Declaracin de una variable:
tipo_de_dato nombreDeVariable; tipo_de_dato es una palabra reservada que indica el tipo
de dato que va almacenar una variable (char, int, float, etc). nombreDeVariable es el
nombre elegido para la variable.

Declaracin de una variable aa a b (a x b) Resultado

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.

Constantes Las constantes representan a identificadores que no cambian su valor en el


desarrollo de un programa. En C++ se pueden declarar las denominas constantes usando el
calificador const. Las constantes tambin se conocen como variables nombradas o variables
de slo lectura.

Declaracin de una constante const tipo_de_dato nombre = valor_constante;


Tipo_de_dato es el tipo de la variable (int, float, char, etc) Nombre es el nombre
identificado para la constante Valor_constante es el valor asignado a la constante const int
mes=30; const float pi=3.14; const char respuesta = S;

Directiva #define La directiva #define actualmente es poco usada en C++, en su lugar se


usa const para declarar las constantes que se van a utilizar en un programa. #define
nombreConstante valor #define pi 3.14 #define raya ------------ #define saludos Buenos
tardes

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 ;

TIPOS DE OPERADORES Operadores Aritmticos Operadores de Relacin Operadores


lgicas Operadores de Incremento y Decremento La asociacin de operadores aritmticos
con operandos permite crear expresiones aritmticas y la asociacin de operadores de
relacin lgicos con operandos permite crear expresiones lgicos.

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

suma = 3 + 7; diferencia = 15 - 6; conteo = contador + 1; total = total + 18.3; impuestos = .


06 * cantidad; peso = factor * peso; promedio = suma/ elementos; pendiente = (y2 y1) /
(x2 x1); Evaluacin de expresiones
pg. 10
Regla de jerarqua de operadores aritmticos ( ) Mayor Nivel * / % Multiplicacin, divisin
y resto de divisin entera + - Suma y resta

Reglas: Si existen parntesis anidados, se evala primero la expresin en el parntesis ms


interno. Si varios operadores estn en el mismo nivel de jerarqua, la evaluacin ser de
izquierda a derecha. Ejemplos: 10 % 3 respuesta 1 8 / 2 * 3 2 respuesta es 10 8 + 5 * 7 %
2 * 4 respuesta es 12

Operadores Incremento y Decremento Los casos en que una variable es incrementada o


disminuida en uno , C++ proporciona dos operadores unitario. Usando el operador de
incremento, ++, -- (operador) n = n + 1; se reemplaza por la expresin n++ ++n n = n - 1;
se reemplaza por la expresin n-- - -n numero = valor ++; // incrementa valor en 1

Sentencia de asignacin Las sentencias de asignacin permite a las variables almacenar el


valor de una expresin. La forma general de una sentencia de asignacin es: variable =
expresin; Variable es el nombre de la variable que recibe la asignacin. Expresin puede
ser tan simple como una constante o tan compleja como una combinacin de operadores
con datos evaluado para producir un valor.

45 12 57 Nombres de variable numero1 Totalnumero2 Direcciones de memoria Total =


numero1 + numero2;

suma = 3 + 7; diferencia = 15 - 6; conteo = contador + 1; total = total + 18.3; impuestos = .


06 * cantidad; peso = factor * peso; promedio = suma/ elementos; pendiente = (y2 y1) /
(x2 x1); Ejemplos de sentencias de asignacin

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

Variaciones de asignacin Las sentencias de asignacin, que usan la misma variable en


ambos lados del operador de asignacin, pueden escribirse usando los siguientes atajos de
operadores de asignacin. suma = suma + 10; es equivalente a suma += 10; precio = precio
* tasa; es equivalente precio *= tasa;

Operadores de Asignacin Operador Abreviatura Sentencia += a+=b a=a+b -= a- =b


a=a-b *= a*=b a= a*b /= a/=b a=a/b %= a%=b a=a%b

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;

La informacin que necesita el compilador sobre cin y cout se encuentra en el archivo de


cabecera iostream.h que debe incluirse en todo programa. #include <iostream.h> Es un
comando preprocesador que utiliza la palabra reservada include con un signo de nmero (#)
y ejecuta alguna accin antes que el compilador traduzca el programa fuente a cdigo de
mquina.

#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() ; }

Secuencia de escape Las secuencias de escape proporcionan un determinado significado al


enviar ciertos caracteres especiales a la pantalla, a un archivo en disco o a la impresora.
Todas las secuencias de escape comienzan con el carcter barra invertida . Son
ejemplos: cout << CALCULAR PROMEDIO DE NOTASn; //la secuencia de escape n
presenta el cursor en la siguiente lnea.

Tipo de datos extendidos Secuencias de escape Descripcin n r t a Nueva lnea. Coloca


el curso al principio de la siguiente lnea. Retorno de carro. Coloca el cursor al principio de
la lnea actual. Tabulador horizontal. Mueve el cursor al siguiente tabulador. Alerta hace
sonar la campana del sistema Imprime una comilla simple () Imprime una comilla doble
( ) Imprime una barra invertida ( )

Manipulacin y formato de los datos de salida Con la finalidad de mejorar el aspecto de


la salida de los programas debemos utilizar los manipulares de salida, por ejemplo si se
requiere especificar el nmero de decimales de un nmero real o ajustar los datos a un
ancho predeterminado. Los manipulares manipulan las salidas de los datos de la forma que
el usuario lo desee. Estos manipuladores se usan dentro del cout y debe incluir el archivo
iomanip.h en el programa.

Tabla de manipuladores de flujo E/S Manipulador Descripcin dec Ajusta la conversin


a base decimal hex Ajusta la conversin a base hexadecimal oct Ajusta la conversin base
octal. endl Inserta una nueva lnea y limpia el flujo ends Inserta un cero nulo al final de la
cadena flash Limpia un flujo de salida. setbase (int n) Ajusta la conversin a base a base n n
pg. 12
( 0 para decimal, que es el predeterminado, 8 para octal, 10 para decimal y 16 para
hexadecimal). resetiosflags (long f) Limpia el formato especificado por f. setiosflags (long
f) Pone el formato especificado por f, f es indicador de formato que se muestra en la
siguiente tabla. setfill (int c) Pone el carcter de relleno a c. setprecision (int n) Pone la
precisin de punto flotante a n. setw(int n) Pone el ancho de campo a n.

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.

La Funcin gotoxy() La funcin gotoxy (x,y) ubica el cursor en la posicin x, y de una


ventana de texto. La coordenada X indica la columna a desplazar, la coordenada Y nos
indica la fila hacia donde se desplazar el cursor. gotoxy(20,10); // desplaza el cursor a la
columna 20, fila 10 La informacin que necesita el compilador para procesar dicha
sentencia se encuentra en el archivo de cabecera conio.h

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;

//Estructura para la factura


struct
{
int numFactura;
char nombre[30];
char apellido[30];
int nit;
char direccion[70];
int telefono;
char fecha[12];
char vendedor [30];
double total;
} Facturas;

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

switch(opcion)//seleccion de en caso que respuesta se


{
case 1:
nuevaFactura();
break;//sea uno llama al procedimiento nuevaFactura arriba
case 2:
Buscar_Factura();
system("pause");
break;//llama ala funcion ver datos
case 3:
Buscar_Clientes();
system("pause");
break;//llama ala funcion ver datos
case 4:
BDFactura();
system("pause");
break;//llama ala funcion ver datos
case 5:
desarrolladores();
system("pause");
break;
case 6:
system("cls");
cout<<"\n\n\n\n\tQue tenga buenos dias\n\n\n";
system("pause");
exit(1);
break;//cierra el programa
default:
cout<<"\n\n numero incorrecto intente nuevamente!\n\n";
system("pause");
break;//lanza un mensaje y vuelve a mostrar los datos
}
}
while(opcion!=6);
system("pause");
return 0;
}

//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);

gotoxy(57,i); cin>> Detalle.precioUnitario[j]; //puede ser entero o


flotante hay que hacer validacion
Detalle.precioTotal[j]= Detalle.cantidad[j] * Detalle.precioUnitario[j];//calculo del
subtotal
gotoxy(70,i);printf("%5.2f",Detalle.precioTotal[j]);
Detalle.SubTotal= Detalle.precioTotal[j] + Detalle.SubTotal;//acumulo en SubTotal
los precios Totales
gotoxy(2,i+1);printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
");
gotoxy(8,i); printf("%c", 179);//lineas verticales del detalle
gotoxy(28,i); printf("%c", 179);
gotoxy(39,i); printf("%c", 179);
gotoxy(49,i); printf("%c", 179);
gotoxy(64,i); printf("%c", 179);
i=i+1; //contador para las posiciones de las lineas en pantalla
gotoxy(8,i); printf("%c", 179);//lineas verticales del detalle
gotoxy(28,i); printf("%c", 179);
gotoxy(39,i); printf("%c", 179);
gotoxy(49,i); printf("%c", 179);
gotoxy(64,i); printf("%c", 179);
i=i+1;
j=j+1; //acumulador para el numero de productos
}

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;
}

int Ingreso_Menu(char buffer[BUFSIZ])


{
int number;
unsigned n;
bool found_nondigit, valid;

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;
}

int demeNumero(int y,int x)


{
int t,valcomplex;
bool valida=false;
int digito=0,i=0,a=0;
do{
while ((t = getchar()) != '\n'){
if(isdigit(t)){
valcomplex=t-'0';
t=getchar();
digito++;

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;
}

bool ingreso_cadena(char letras[])


{
int i=0,abc=0;
while(letras[i]){
if (isalpha(letras[i])){
abc++;
}
i++;
}
if(i==abc){
return true; //esta bien ingresado el numero
}else{
return false;
}
}

bool ingreso_cadena_con_espacio(char letras2[])


{
int i=0,abc=0,blanco=0;
while(letras2[i]){
if (isalpha(letras2[i])){
abc++;
}else{
if(letras2[i]=' ');
blanco++;
}
i++;
}
if(blanco==0){
if(abc==i)
return true; //esta bien ingresado el numero
}else{

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.

Descripcion del programa


En el aeropuerto Guatemaya se solicito la creacion de un programa que factura la compra
de boletos y realizar los calculos de impuestos
Para guardar el historial de las reservas de los asientos, o de ser el caso la cancelacion de la
reserva.
Pasos para la utilizacion optima del programa.
Menu del prgrama

En esta parte se despliega un men de opciones ingrese el valor de la opcin seleccionada


por medio de nmeros.

pg. 26
1. Opcin 1
1.1Desplega la factura.
Donde se ingresarn los datos siguientes:
Fecha, numero de factura y cajero

1.2. Al ingresar los primeros datos solicita los siguientes datos:


Nombre, Apellido, Direccin, nit y telfono.

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.

Por ltimo, la factura se guarda automticamente.


2. opcin 2

pg. 28
Se realiza la bsqueda de una factura, si se encuentra la factura guardada desplegara la
siguiente pantalla.

De no encontrarse la factura desplegara el mensaje siguiente

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