Introducción A Dev C++

V
CONTENIDO
1. INTRODUCCIN 5
1.2. C++
1.3. ENTORNO DE DESARROLLO INTEGRADO 5

1.4. DEV-C++
2. ASPECTOS BSICOS DE C++ 7

2.1. ESTRUCTURA BSICA DEL CDIGO7
2.2. LIBRERAS
2.3. VARIABLES
16
2.4. TIPOS DE DATOS
16
2.5. OPERADORES DE C++

2.6. CARACTERES ASCII
18
20
3. PROGRAMACIN ESTRUCTURADA
20
3.1. INSTRUCCIONES DE ENTRADA Y SALIDA DE DATOS
20
3.1.1. SALIDA DE DATOS 20

3.1.2. ENTRADA DE DATOS
3.2. INSTRUCCIN IF
22
23
3.3. INSTRUCCIN WHILE 27

3.5. INSTRUCCIONES ADICIONALES
3.5.1. DO-WHILE
3.5.2. FOR
31
32
34
3.5.3. SWITCH- CASE
36
4. SUBPROGRAMAS 39
4.1. CLASIFICACIN DE LOS SUBPROGRAMAS 40
4.1.1. PROCEDIMIENTOS O SUBRUTINAS
40
4.1.2. FUNCIONES 46
4.1.3. LIBRERAS
49
4.1.4 LIBRERA PARA VALIDAR Y CREAR CUADROS.

5. EXCEPCIONES
53
71
5.1. MANEJADOR DE EXCEPCIONES
71
2
Introduccin a dev C++
5.1.1. TRY
72
5.1.2. THROW
72
5.1.3. CATCH72
6. ARREGLOS
74
6.1. CLASIFICACIN DE LOS ARREGLOS74

6.1.1. ARREGLOS DE UNA DIMENSIN O VECTORES 74
6.1.2. ARREGLOS DE DOS DIMENSIONES O MATRICES
7. REGISTROS
88
98
7.1. ARREGLO DE REGISTROS
100
8. ARCHIVOS 105
8.1. MANEJO DE ARCHIVOS DE DATOS 105
9. ANEXOS
8.1.1. ARCHIVOS DE TEXTO
108
8.1.2. ARCHIVO DE DATOS
111
117
9.1. TABLA CARACTERES ASCII
117
10. BIBLIOGRAFA Y CIBERGRAFA

10.1. BIBLIOGRAFA
118
118
10.2. CIBERGRAFA 118
3
PRESENTACIN
Este material se ha diseado para ayudar a personas que necesitan asesora
especfica para desarrollar alguna aplicacin en su actividad como
estudiante o profesional.
De esta manera, el texto est dirigido a
estudiantes y profesores de cualquier rea, fundamentalmente a estudiantes
de ingeniera o temas relacionados con las tecnologas de la informacin y
comunicacin.
El texto explica la programacin estructurada de una manera natural,
partiendo de lo ms sencillo hacia lo ms complejo, incrementando el nivel
de complejidad en cada captulo que se avance. Esta versin no incluye la
Programacin Orientada a Objetos, tema que ser incluido en una prxima
versin. La programacin estructurada se ha proyectado en todas las ramas
del saber, fundamentalmente para aquellos lectores que no necesitan la
programacin objetual.
El texto es entonces de carcter prctico, enriquecido con la experiencia
como docente universitario de este tema por varios aos. El contenido no
supone -de ninguna manera- tener algn conocimiento anterior sobre
programacin, ya que en forma didctica, va guiando al lector, incluso
partiendo desde la definicin de lo que es un lenguaje de programacin y las
facilidades que brinda dev C++ para programar, cmo puede instalarse y las
ventajas sobre otras versiones de C++.
El lector encontrar todas las formas de representacin de las instrucciones
con formatos explicados de forma sencilla y las estructuras de
representacin de datos tanto en memoria como en medios externos.
El
autor
deja
disposicin
de los lectores la pgina web

http://ingenieria.udea.edu.co/~eoviedo , donde no slo encontrar los ejercicios
resueltos, sino los del libro: LGICA DE PROGRAMACIN, que estn resueltos
en turbo C++ y en java.
Por ltimo, el lector podr resolver sus inquietudes, escribindo a mis
correos: efrainoviedo@gmail.com eoviedo@udea.edu.co.
El autor.
4
1. INTRODUCCIN
1.1. LENGUAJE DE PROGRAMACIN
Un lenguaje de programacin es un conjunto de reglas de sintaxis diseadas para
representar instrucciones que, escritas de la manera adecuada, pueden dar solucin
a un problema. Este conjunto de instrucciones se llama programa fuente y es
ejecutado a travs de un computador.
Los programas creados por el usuario ejercen un control fsico y lgico sobre la
mquina o procesador, el cual reconoce las instrucciones sealadas en el programa,
gracias a otro programa llamado compilador. El compilador se encarga de traducir
las instrucciones del programa a un lenguaje de mquina binario, creando un nuevo
programa llamado programa objeto, el cual es llevado al procesador y es
ejecutado instruccin por instruccin.
1.2. C++
El lenguaje de programacin C++ fue creado por Bjarne Stroustrup en los 80's.
Su trabajo consisti en llevar ms all, el ya famoso lenguaje de programacin C, e
implementar un lenguaje que permitiera la manipulacin de objetos, dejando el
compilador de C. Los ficheros fuente de C++ tienen la extensin *.cpp (de C plus,
denominacin en ingles del lenguaje).
1.3. ENTORNO DE DESARROLLO INTEGRADO

Para crear un programa usando un lenguaje, en esencia, slo necesitamos un editor
de texto, en el cual escribimos las instrucciones que deseamos utilizar, sin
embargo, una vez terminada la escritura de dicho programa, cmo podemos saber
si el programa est correctamente escrito?, y cmo saber si ste soluciona
correctamente el problema?
Para responder lo anterior, necesitamos una
herramienta que verifique la sintaxis del programa y sea capaz de ejecutarlo sobre
el computador; dicha herramienta es un Entorno de Desarrollo Integrado (IDE).
5
Un IDE es un programa bastante complejo que, aparte de tener las reglas de

sintaxis del lenguaje, posee un compilador el cual traduce el programa a lenguaje
de mquina. Por lo anterior, un IDE es capaz de indicarnos en qu parte del cdigo
que escribimos, se est violando alguna o algunas reglas de sintaxis e incluso
mostrarnos un mensaje de error que nos dice qu est mal. Una vez revisada la
sintaxis, el IDE puede compilar y ejecutar el programa y as podemos verificar la
validez del cdigo que escribimos.
1.4. DEV-C++
Dev-C++ es un IDE para el lenguaje de programacin C++, es un programa libre
publicado bajo la licencia pblica GNU y se basa en GCC (GNU Compiler Colection)
como compilador. Se puede obtener gratis en la pgina web de los creadores
(http://www.bloodshed.net/devcpp.html).
6
2. ASPECTOS BSICOS DE C++

2.1. ESTRUCTURA BSICA DEL CDIGO
Todo programa en C++ debe tener una funcin principal main(), esta funcin
contiene la rutina base del programa y debe cumplir con la siguiente sintaxis:
int main () {
}
A partir de ste, podemos generar la estructura del cdigo fuente necesaria para
realizar una aplicacin mediante el lenguaje de programacin C++ as:
CABECERA: INCLUYE LIBRERAS A UTILIZAR

DECLARACIN: DECLARACIN DE CLASES Y FUNCIONES
PROGRAMA PRINCIPAL: MAIN
FIN
2.2. LIBRERAS
Las libreras, en un lenguaje de programacin, son cdigos escritos previamente
que definen funciones que se utilizan frecuentemente en los programas. Algunas
de las libreras ms utilizadas son:
iostream
Permite utilizar funciones para entrada y salida de datos. Pertenece a la biblioteca
estndar de C++,
Funciones: cout, cin, cerr, etc.
conio2
Es una librera que funciona en sistemas operativos con DOS como MS Windows.
Permite utilizar funciones de manejo avanzado de la consola. No pertenece a la
biblioteca estndar de C++,
Funciones: getch( ), textcolor( ), textbackground( ), clrscr( ), etc.
math (se debe incluir, lo mismo la conio2)
Esta librera permite el uso de funciones matemticas esenciales. Hace parte de la
biblioteca estndar de C++. Algunas de sus funciones son:
7
NOMBRE
abs(i)
TIPO
Int
LIBRERIA
Stdlib.h
acos(d)
double
Math.h
asin(d)
double
Math.h
atan(d)
double
Math.h
atan(d1,d2)
double
Math.h
atof(s)
double
Stdlib.h
atoi(s)
int
Stdlib.h
atol(s)
long
Stdlib.h
calloc(n,s)
Void
(puntero)
alloc.h y
stdlib.h
ceil(d)
double
Math.h
cos(d)
double
Math.h
cosh(d)
double
Math.h
difftime
double
Time.h
DESCRIPCION
Devuelve el
valor absoluto de
i
Devuelve el
coseno inverso
de d
Devuelve el
seno inverso de
d
Devuelve la
tangente inversa
de d
Devuelve la
tangente inversa
de d1/d2
Convierte la
cadena s en una
cantidad doubl
(valor real)
Convierte la
cadena s a un
entero
Convierte la
cadena s a un
entero largo
Reserva
memoria para
una formacin
de n elementos,
cada uno de s
bytes. Devuelve
un puntero al
principio del
espacio
reservado.
Devuelve un
valor
redondeado al
siguiente entero
mayor
Devuelve el
Coseno de d
Devuelve el
Coseno
hiperblico de d
Devuelve la
SINTAXIS
Int abs(int i);
Double acos(double
d);
Double asin(double
d);
Double atan(double
d);
Double atan
(double d1, double
d2;)
Double atof(const
char *cadena)
Int atoi(const
char*cadena)
Long atol(const
char*cadena)
Void *calloc ( size_t
n;size_t s);
Double ceil(double
d);
Double cos(double
d);
Double cosh(double
d);
Double
8
(l1,l2)
exit(u)
void
Stdlib.h
exp(d)
double
Math.h
fabs(d)
double
Math.h
fclose(f)
int
Stdio.h
feof(f)
int
Stdio.h
fgetc(f)
int
Stdio.h
fgets(s,i,f)
Char
(puntero)
Stdio.h
floor(d)
double
Math.h
fmod(d1,d2)
double
Math.h
diferencia en
tiempo l1(hora
2)-l2(hora 1),
donde l1 y l2
representan el
tiempo
transcurrido
despus de un
tiempo base
Cierra todos los
archivos, buffers
y termina el
programa
Eleva e a la
potencia d
Devuelve el
valor absoluto de
d
Cierra el archivo
f. devuelve el
valor 0 si el
archivo e ha
cerrado con
xito.
Determina se ha
encontrado un
fin de archivo. Si
es as, devuelve
un valor distinto
de cero, en otro
caso devuelve 0.
Lee un carcter
del archivo f
Lee una cadena
s, con i
caracteres, del
archivo f
Devuelve un
valor
redondeado al
entero menor
ms cercano
Devuelve el
resto de d1/d2
difftime( time_t
hora2, time_t
hora1);
Void exit(int u)
u es el estado de
terminacin
Double exp (double
d);
Double fabs(double
d)
Int fclose (FILE *f);
Int feof (FILE *f);
Int fgetc (FILE *f);

Char *fgets(char
s,int s, FILE*f);
Double floor(double
d);
Double
fmod(double d1,
double d2);
9
fopen(s1,s2)
File
(puntero)
Stdio.h
Abre un archivo
llamado s1, del
tipo s2.
Devuelve un
puntero al
archivo. S2
puede ser:
-r: Archivo
para la lectura.
-w: Archivo
vacio para la
escritura.
-a: Archivo
para escritura al
final de este.
-r+: Archivo
para
lectura/escritura.
-w+: Archivo
vacio para
lectura/escritura
-a+: Archivo
para lectura y
aadir.
-rb: Archivo
binario para la
lectura.
-wb: Archivo
binario para la
escritura.
-ab: Archivo
binario para
aadir.
-rb+: Archivo
binario para la
lectura/escritura.
-wb+: Archivo
binario para la
lectura/escritura.
-ab +: Archivo
binario para
lectura y aadir.
FILE *fopen (const

char*s1,const
char*s2);
fprintf(f,)
int
Stdio.h
Escribe datos en
el archivo f
frexp(i,d)
double
Math.h
Toma el numero i
y obtiene su
notacin
cientfica al
Int fprintf (FILE*f,

const char*formato
[,arg,.]);
Double
frexp(double
num,double exp);
10
fputc(c,f)
int
Stdio.h
fputs(s,f)
int
Stdio.h
fread(s,i1,i2,f
int
Stdio.h
free(p)
void
Stdio.h
fseek(f,l,i)
int
Stdio.h
ftell(f)
Long int
Stdio.h
fwrite(s,i1,i2,
int
Stdio.h
f)
descomponerlo
en dos partes: la
mantisa, que es
retornada por la
funcin, y el
exponente, que
es colocado en d
Escribe un
carcter en el
archivo f
Escribe una
cadena de
caracteres en el
archivo f
Lee i2
elementos, cada
uno de tamao
i1 bytes, desde
el archivo f hasta
la cadena s)
Libera un bloque
de memoria
reservada cuyo
principio est
indicado por p
Mueve el
puntero al
archivo f una
distancia de l
bytes desde la
posicin i, la cual
puede ser:
-SEEK_SET:
Principio de
archivo
-SEEK_CUR:
Posicin actual
del puntero
-SEEK_END: Final
del archivo
Devuelve la
posicin actual
del puntero
dentro del
archivo f
Escribe i2
elementos, cada
uno de tamao
i1, desde la
cadena s hasta
Int fputc(int c,
FILE*f);
Int fputs(const
char*cad, FILE*f);
Size_tfread(void*s,s
ize_t i1,size_t i2,
FILE*f);
Void
free(void*dir_memo
ria);
Int fseek(FILE*f,
long despla,int
origen);
Long int
ftell(FILE*f);
Size_t fwrite(const
void*s,size_t
i1,size_t i2,FILE*f);
11
getc(f)
int
Stdio.h
getchar()
int
Stdio.h
gets(s)
char
(puntero)
Stdio.h
isalnum(c)
int
Ctype.h
isalpha(c)
int
Ctype.h
isascii(c)
int
Ctype.h
iscntrl(c)
int
Ctype.h
isdigit(c)
int
Ctype.h
el archivo f
Lee un carcter
del archivo f
Lee un carcter
desde el
dispositivo de
entrada estndar
Lee una cadena
de caracteres
desde el
dispositivo de
entrada estndar
Determina si el
argumento es
alfanumrico.
Devuelve un
valor distinto de
cero si es cierto;
en otro caso
devuelve 0,
Determina si el
argumento es
alfabtico.
Devuelve un
valor distinto de
cero si es cierto;
en otro caso
devuelve 0.
Determina si el
argumento es un
carcter ASCII.
Devuelve un
valor distinto de
cero si es cierto;
en otro caso
devuelve 0
Determina si el
argumento es un
carcter ASCII de
control.
Devuelve un
valor distinto de
cero si es cierto;
en otro caso
devuelve 0
Determina si el
argumento es un
digito decimal.
Devuelve un
valor distinto de
Int getc(FILE*f);
Int getchar(void);
Char*gets(char*cad
);
Int isalnum(int c);
Int isalpha(int c);
Int isascii(int c);
Int iscntrl(int c);
Int isdigit(int c);
12
isgraph(c)
int
Ctype.h
islower(c)
int
Ctype.h
isodigit(c)
int
Ctype.h
isprintf(c)
int
Ctype.h
ispunct(c)
int
Ctype.h
cero si es cierto;
en otro caso
devuelve 0
Determina si el
argumento es un
carcter ASCII
grafico (hex
0x21-0x7e; octal
041 -176).
Devuelve un
valor distinto de
cero si es cierto;
en otro caso
devuelve 0
Determina si el
argumento es
una minscula.
Devuelve un
valor distinto de
cero si es cierto;
en otro caso
devuelve 0
Determina si el
argumento es un
digito octal.
Devuelve un
valor distinto de
cero si es cierto;
en otro caso
devuelve 0
Determina si el
argumento es un
carcter ASCII
imprimible (hex
0x20-0x7e; octal
040 -176).
Devuelve un
valor distinto de
cero si es cierto;
en otro caso
devuelve 0
Determina si el
argumento es un
carcter de
puntuacin.
Devuelve un
valor distinto de
cero si es cierto;
en otro caso
devuelve 0
Int isgraph(int c);
Int islower(int c);
Int isodigit(int c);
Int isprint(int c);
Int ispunct(int c);
13
isspace(c)
int
Ctype.h
isupper(c)
int
Ctype.h
isxdigit(c)
int
Ctype.h
labs(l)
Long int
Math.h
ldexp(i,d)
double
Math.h
log(d)
double
Math.h
log10
double
Math.h
malloc(u)
Void(punte
ro)
Stdlib.h
Determina si el
argumento es un
espacio en
blanco Devuelve
un valor distinto
de cero si es
cierto; en otro
caso devuelve 0
Determina si el
argumento es
una mayscula.
Devuelve un
valor distinto de
cero si es cierto;
en otro caso
devuelve 0
Determina si el
argumento es un
digito
hexadecimal.
Devuelve un
valor distinto de
cero si es cierto;
en otro caso
devuelve 0
Devuelve el
valor absoluto de
l
Toma dos
nmeros: una
mantisa y un
exponente y
calcula el
numero en punto
flotante o
notacin
cientfica
Devuelve el
Logaritmo
natural de d
Devuelve el
Logaritmo en
base 10 de d
Reserva u bytes
de memoria,
devuelve un
puntero al
principio del
espacio
reservado
Int isspace(int c);
Int isupper(int c);
Int isxdigit(int c);
Long int labs(long

int l)
Double
ldexp(double num,
double exp);
Double log(double
d);
Double
log10(double d);
Void*malloc(size_t
u);
14
modf(d,*iptr)
double
Math.h
pow(d1,d2)
double
Math.h
printf()
int
Stdio.h
putc(c,f)
Int
Stdio.h
putchar(c)
Int
Stdio.h
puts(c)
Int
Stdio.h
rand()
int
Stdio.h
rewind(f)
void
Stdio.h
scanf()
Int
Stdio.h
Retorna la parte
decimal de d.
guarda la parte
entera en el
objeto apuntado
por iptr
Devuelve d1
elevado a la
potencia de d2
Escribe datos en
dispositivo de
salida estndar.
Segn el tipo de
dato se debe
colocar:
-%c: Carcter
-%d:Entero
decimal
-%e: Real
-%f: Punto
flotante
-%s:Cadena de
caracteres
-%x:
Hexadecimal sin
signo.
Escribe un
carcter en el
archivo f
Escribe un
carcter en el
dispositivo de
salida de
estndar
Escribe una
cadena de
caracteres en el
dispositivo de
salida de
estndar
Devuelve un
entero positivo
aleatorio
Mueve el
puntero al
principio del
archivo f
Lee datos en el
dispositivo de
entrada
Double
modf(double
valor,double *iptr)
Double pow(double
d1,double d2);
Int printf(const
char*formato
[,argumento,]);
Int putc(int
c,FILE*f);
Int putchar(int c);
Int puts(const
char*cad);
Int rand(void);
Void rewind(FILE*f);
Int scanf(const
char*formato
[,direccin,]);
15
sin(d)
double
Math.h
sinh(d)
double
Math.h
sqrt(d)
double
Math.h
srand(u)
void
Stdlib.h
strcmp(s1,s2
int
String.h
int
String.h
char
String.h
strcmpi(s1,s
2)
strcpy(s1,s2)
estndar. Estos
datos pueden
ser de tipo:
-%c: Carcter
-%d:Entero
decimal
-%e: Real
-%f: Punto
flotante
-%s:Cadena de
caracteres
-%x:
Hexadecimal sin
signo.
Devuelve el
Seno de d
Devuelve el
Seno hiperblico
de d
Devuelve la Raz
cuadrada de d
Inicializa el
generador de
nmeros
aleatorios
Compara dos
cadenas de
caracteres
lexicogrficamen
te. Devuelve un
valor negativo si
s1<s2; 0 si s1 y
s2 son idnticas;
y un valor
positivo si s1>s2
Compara dos
cadenas de
caracteres
lexicogrficamen
te, sin
diferenciar
maysculas de
minsculas.
Devuelve un
valor negativo si
s1<s2; 0 si s1 y
s2 son idnticas;
y un valor
positivo si s1>s2
Copia la cadena
Double sin (double

d);
Double sinh (double
d);
Double sqrt(double
d);
Void srand
(unsigned u);
Int strcmp(const
char*s1,const
char*s2);
Int strcmpi(const
char*s1,const
char*s2);
Int strcpy(const
16
strlen(s)
int
String.h
strset(c,s)
Char(punte
ro)
String.h
system(s)
int
String.h
tan(d)
double
Math.h
tanh(d)
double
Math.h
time(p)
Long int
Time.h
toascii (c)
int
Ctype.h
tolower (c)
int
Ctype.h
toupper (c)
int
Ctype.h
de caracteres s2
en la cadena s1
Devuelve el
numero de
caracteres de
una cadena
Pone todos los
caracteres de s a
c (excluyendo el
carcter nulo del
final)
Pasa la orden al
sistema
operativo.
Devuelve cero si
la orden se
ejecuta
correctamente,
en otro casi
devuelve un
valor distinto
Devuelve la
Tangente de d
Devuelve la
Tangente
hiperblica de d
Devuelve el
numero de
segundos
transcurridos
despus de un
tiempo base
designado
Convierte el
valor del
argumento a
ASCII
Convierte una
letra a minscula
Convierte una
letra a
mayscula
char*s1,const
char*s2);
Size_t strlen(const
char*s);
Char*strset(char*ca
d, int c);
System(comd);
Double tan(double
d);
Double tanh(double
d);
Time_t time(time_t
*h);
Int toascii (int c);
Int tolower (int c);

Int toupper(int c);
2.3. VARIABLES
Una variable del lenguaje C++ conserva, en trminos generales, las propiedades de
una variable matemtica. Una variable es un elemento cuyo valor puede cambiar
17
con el transcurso del tiempo o la ocurrencia de determinado evento. Las variables

deben iniciar con letra seguida de letras o dgitos, incluido el carcter subrayado
(guin bajo) y se aconseja que estn en minscula, C++ determina diferentes tipos
de datos para la definicin de variables. El valor de una variable, se almacena en la
memoria RAM.
2.4. TIPOS DE DATOS

Un tipo de dato le asigna a una variable: tamao en memoria, tipo de valor que
debe almacenar y forma de almacenamiento.
Los tipos de datos primitivos ms comunes de C++ son:
NOMBRE
Char
Unsigned char
string
short int
unsigned short
int
long long
bool
float
double
long double
DESCRIPCIN
Caracter o entero
pequeo
TAMA
O*
1 byte
2 bytes
Cadena de caracteres
Variable
Entero corto
Entero positivo
2 bytes
2 bytes
Entero
4 bytes
Entero largo
Booleano (verdadero o
falso)
Nmero de punto
flotante
Nmero de punto
flotante de doble
precisin
Long de punto flotante
de doble precisin
8
bytes
RANGO*
Ver tabla ASCII al final del
documento**
Es tcnicamente un arreglo (o
vector) de datos tipo char
-32768 a 32767
0 a 65535
Con signo de -2147483648 a
2147483647
Sin signo de 0 a 4294967295
Con signo de -9223372036854775807
a 9223372036854775807 Sin signo de
0 a 18446744073709551615
1 byte
true o false (1 o 0)
4 bytes
1.17e ^- 38..3.4 e^+38 (7 dgitos

decimales)
8 bytes
2.22 e^-308..1.79 e^+308 (15

dgitos decimales
12 bytes
3.4e ^-4932 ..1.18 e ^+4932(18

dgitos decimales)
Tabla 1, Tipos de datos en C++
* Los valores dependen de la arquitectura utilizada. Los mostrados son los que
generalmente se encuentran en una mquina tpica de arquitectura 32 bits.
**Los caracteres se representan utilizando el tipo char, que tiene slo 1 byte de
tamao. Este tipo se utiliza para representar los 255 caracteres de la tabla de
caracteres del sistema. El tipo char es tambin un tipo entero, ya que puede tomar
valores de 0 a 255.
(tabla de caracteres ASCII en anexos al final del documento)
18
Estructura de la definicin de una variable:
int nombreDeLaVaiable;
//int es el tipo de la variable, en este caso es entero
Estructura de la asignacin de una variable:
nombreDeLaVariable = expresion;
//ver nota *
*. expresion puede ser un valor puntual o un conjunto de operaciones que, luego

de ser evaluadas, devuelvan un nico valor, pero en cualquiera de los dos casos,
expresin debe ser del mismo tipo que el nombre de la variable, ejemplos:
int x;
char y;
char z;
x = (10*5)+12;
y = 'a';
z = 65;
// Definimos la variable x de tipo entero

// Definimos la variable y de tipo caracter
// Definimos la variable z de tipo caracter
// Le asignamos el valor de la expresin matemtica (10*5)+12
//a x, es decir, 62.
// Le asignamos el valor de 'a' a y.
// Le asignamos a z el valor del caracter en la posicin 65 de
//la tabla ASCII (La 'A').
La definicin y la asignacin de una variable se pueden hacer en una sola lnea as:
int nombreDeLaVariable = expresin;
NOTA: el punto y coma (;) al final de la instruccin es obligatorio, si no se incluye,

el compilador indicar que hay error de sintaxis.
CARACTERES ESPECIALES
En las instrucciones de salida se pueden usar cualquiera de los siguientes
caracteres especiales:
\a: cuando, en la ejecucin de un programa, se llega a una lnea de cdigo que
incluya este caracter, se emitir un sonido de alerta (beep)
\n: el programa reconoce este smbolo como una nueva lnea, as que -al
encontrarlo- dejar de escribir en la lnea actual y saltar a la siguiente.
\t: significa espacio de tabulacin y se reconoce como un salto en la misma lnea
igual al que se da cuando se presiona la tecla TAB en un documento de texto.
19
\: debido a que las comillas estn reservadas para encerrar texto, este smbolo
har que el programa reconozca las comillas como texto y no como principio o fin
de texto.
\\: permite mostrar el caracter '\' en pantalla.
2.5. OPERADORES DE C++

Para las determinadas operaciones que se pueden realizar con las variables, C++
proporciona una serie de operadores:
Asignacin:
OPERADOR
=
+=
-=
*=
/=
%=
<<=
>>=
&=
^=
|=
DESCRIPCIN
Asignacin
Asignacin con suma
Asignacin con resta
Asignacin con multiplicacin
Asignacin con divisin
Asignacin con mdulo
Asignacin con desplazamiento
Asignacin con desplazamiento
Asignacin con AND lgico
Asignacin con XOR binario
Asignacin con OR binario
Aritmticos:
OPERADOR
*
+
/
%
DESCRIPCIN
Multiplicacin
Suma
Resta
Divisin
Residuo de la operacin o mdulo
Comparacin:
OPERADOR
!=
==
<=
<
>=
>
DESCRIPCIN
Diferente
Igualdad
Menor o igual que
Menor que
Mayor o igual que
Mayor que
Booleanos:
20
OPERADOR
&&
||
^
!
DESCRIPCIN
Operacin lgica
Operacin lgica
Operacin lgica
Operacin lgica
AND
OR
XOR
NOT
Otros Operadores
OPERADOR
[]
()
++
--
DESCRIPCIN
Arreglo
Argumento de funcin o agrupacin
Aumento en 1
Decremento en 1
2.6. CARACTERES ASCII

Los cdigos ASCII son una forma de asignar un nmero binario de 8 o 16 bits a cada
caracter del alfabeto latino, de esta forma cada caracter tendra su propio cdigo
binario y puede ser identificado unvocamente por la mquina. C++ permite
mostrar por pantalla los caracteres ASCII que son imprimibles, es decir, a partir del
caracter 32 hasta el caracter 255. Ver apndice al final.
3.
PROGRAMACIN
ESTRUCTURADA
La programacin estructurada es una forma de escribir programas de computador
(programacin) de manera clara. Para ello utiliza nicamente tres estructuras:
secuencia, seleccin e iteracin.
Estructura secuencial. Una estructura de programa es secuencial si se ejecuta
una tras otra a modo de secuencia, es decir, que una instruccin no se ejecuta
hasta que finaliza la anterior.
Estructura selectiva o de seleccin.
La estructura selectiva permite la
realizacin de una instruccin u otra segn un criterio. Slo una de estas
instrucciones se ejecutar.
21
Estructura iterativa.
Un bucle iterativo, o iteracin de una secuencia de
instrucciones, hace que se repitan mientras se cumpla una condicin, en un
principio el nmero de iteraciones no tiene por qu estar determinado.
El lenguaje C++ hereda de C las caractersticas de un lenguaje estructurado, as
como le agrega funcionalidades de la orientacin a objetos. La estructura general
del lenguaje es secuencial, es decir, las instrucciones se ejecutan una seguida de
las otras, pero, C++ provee adems ciertas estructuras para controlar el flujo
secuencial de una aplicacin, para volverla iterativa, o selectiva, stas son:
3.1. INSTRUCCIONES DE ENTRADA Y SALIDA DE DATOS

3.1.1. SALIDA DE DATOS
Para la salida de datos por pantalla C++ nos provee con la instruccin cout. Su uso
se hace de la siguiente manera:
cout<<Mensaje que se desea mostrar<<endl; y variables
El mensaje que se desea mostrar puede componerse de varias partes, por ejemplo,
cout<<esto<< es un mensaje<<endl;, vemos que este mensaje tiene 2 partes
esto y es un mensaje.
La instruccin endl indica que lo que se escribe debe estar en la lnea siguiente de
la pantalla, es parecido a un \n.
Ejemplo de su uso:
Ejemplo 1
#include <iostream>
#include <conio2.h>
using namespace std;
int num=9, mod;
int main () {
mod=num%2;
cout<<"El residuo de la division entre "<<num<<" y 2 es "<<mod;
getch();
}
En el anterior programa incluimos las libreras iostream y conio, declaramos las

variables num y mod de tipo int y el programa principal se encarga de calcular el
residuo de la divisin entre num y 2. El resultado es almacenado en la variable mod
y se muestra en pantalla.
Podemos usar otras instrucciones antes de una salida de datos, como: clrscr ();
Borra la pantalla y coloca el cursor en la esquina superior izquierda. gotoxy(col, fil);
Coloca el cursor en la columna col, fila fil. La columna aparece primero por que la
22
pantalla en el plano cartesiano est dibujada del punto (0,0) hacia abajo.
textbackground(color); Le coloca color de fondo donde va un texto. textcolor (color);
Le da color al texto del mensaje.
Vemos que el comando cout<< es para salida y cin>> para entrada.
Ejemplo 2
#include <iostream>
#include <conio2.h>
char nombre[10]="nombre";
int edad=10;
main (){
cout<<"Hola mundo" <<endl;
//Muestra Hola mundo en la pantalla
cout<<"La edad es: "<<edad<<endl;
//Muestra La edad es 10
cout<<"Su nombre es: " <<nombre<<" y su edad es: "<<edad<<endl;
//Muestra Su nombre es: nombre y su edad
//es 10
getch();
}
3.1.2. ENTRADA DE DATOS

Para la salida de datos por pantalla C++ nos provee con la instruccin cin la cual
tiene varias formas de uso, la ms sencilla es:
cin>>variable;
sta permite leer lo que el usuario ingresa en la pantalla y lo almacena en la
variable, es decir, que lo que ingrese el usuario ser el valor asignado a variable. El
nico problema de esta forma de lectura, es que no permite que se ingresen
espacios, es decir, el usuario no puede ingresar Nombre Apellido ya que hay un
espacio entre nombre y apellido, lo que hace cin es leer hasta que encuentra un
espacio o un enter, lo que siga a stos ser guardado en otro espacio en memoria
para su posterior lectura.
Para la lectura de datos con uno o mltiples espacios, se hace uso de lo siguiente:
cin>>ws;
cin.getline(cadena, nmero);
La primera instruccin elimina los espacios en blanco y los finales de pgina que se
encuentren almacenados en memoria.
23
La segunda es la que permite leer cadenas con espacios, cadena es una variable
de tipo char[] y es ah donde se guardar el texto ingresado por el usuario. Nmero
es una variable entera que indica el nmero de caracteres a leer, se debe hacer si
la cadena de caracteres tiene espacios en blanco.
Ejemplo 3
#include <iostream>
#include <conio2.h>
char nombre[50]; //cadena de texto
int edad;
main (){
cout<<"Ingrese su edad: ";
//Muestra Ingrese su edad:
cin>>edad;
//lee la edad que el usuario ingresa
cout<<"Ingrese su nombre: "; //Muestra Ingrese su nombre:
cin>>ws;
//Se eliminan espacios y enteres en la
// memoria.
cin.getline(nombre,50);
// Se indica que se van a leer como
// mximo 50 caracteres que es el tamao
// de la cadena nombre.
cout<<"Su nombre es: " <<nombre<<" y su edad es: "<<edad<<endl;
getch();
}
3.2. INSTRUCCIN IF
Esta es una estructura de seleccin que permite elegir qu accin deber seguir
durante la ejecucin del programa, a partir de determinada condicin.
Para utilizarla basta con escribir la palabra reservada if y, a continuacin, la
condicin bajo la cual se cumplirn las instrucciones que se encierran en unas
llaves. Esas instrucciones se ejecutarn slo cuando la condicin -dentro de las
llaves- se haga verdadera. La estructura de la sentencia if es la siguiente:
if(condicin)}
{
Instrucciones que se ejecutan si la condicin es verdadera;
}
Ejemplo
if(a>b)
cout<<a; //una sola instruccin
Si instrucciones es una sola, no necesita llaves si se necesita que pase algo; en caso
contrario, a la condicin ponemos la palabra reservada else, justo despus de
cerrar las llaves que contienen las instrucciones que se encuentran entre las llaves
que encierra if; procedemos entonces a abrir nuevamente un par de llaves para
24
ubicar las sentencias que se llevarn a cabo, en caso de que no se cumpla la

condicin del if.
if(condicin){
//Instrucciones para cuando la condicin es verdadera
}
else{
//Instrucciones para cuando la condicin es falsa.
}
La condicin est conformada por una variable, un operador relacional y otra

variable o constante, los operadores que podemos utilizar son los siguientes:
Comparacin:
OPERADOR
!=
==
<=
<
>=
>
DESCRIPCIN
Diferente
Igualdad
Menor o igual que
Menor que
Mayor o igual que
Mayor que
Es posible componer una condicin con 2 o ms condiciones, basta con unirlas a

travs de operadores lgicos y u o.
Es importante aclarar que, cuando solo se va a ejecutar una sola lnea de cdigo
dentro de las llaves, es posible no colocarlas; sin embargo, se recomienda ponerlas
siempre, para aportar ms claridad a la hora de programar.
Estructura general
if(condicin){
//Instrucciones para cuando la condicin es verdadera
}
else {
if{
//Instrucciones.
}
else {
//Instrucciones.
}
}
La agrupacin de instrucciones else if, y la instruccin else son opcionales, es

decir, se pueden tener adems un conjunto de else if seguidos sin terminar en un
else, o un solo else despus del if, o solo tener la instruccin if.
25
NOTA: La instruccin else SIEMPRE debe estar precedida por un if.

Ejemplo 4
A continuacin veremos ms a fondo el uso de la sentencia if Con el siguiente
cdigo fuente se debe ingresar una cantidad m y otra n, se debe mostrar por
pantalla cul es qu con respecto a la otra la otra: menor, menor o igual, mayor,
mayor o igual o igual.
#include<iostream>
#include<conio2.h>
int main(){
int m,n;
cout<<"Ingrese m:"<<endl;
cin>>m;
cout<<"Ingrese n:"<<endl;
cin>>n;
if(n<m){
cout<<"m es mayor que n";
} else
if(n>m){
cout<<"m es menor que n";
} else{
cout<<"m es igual a n";
}
getch();
}
De esta manera vemos cmo se usa la sentencia if de manera anidada. Es

conveniente detallar que el ltimo bloque no tiene una condicin, y es porque este
bloque se va a ejecutar cuando no se cumplan ninguna de las condiciones que lo
preceden.
Ejemplo 5
En el siguiente ejemplo se muestra la estructura ms bsica del if, sin el else. Aqu,
si el usuario ingresa un nmero mayor a 5, se le indica que gan:
#include<conio2.h>
#include<iostream>
int main(){
int n;
cin>>n;
if(n>5){
cout<<"Gano!!!";
}
getch();//Observe que el if se puede usar sin el else
}
26
Ampliando el anterior ejemplo, en el siguiente, si el usuario ingresa un nmero

mayor a 5 se le indica que gan, en caso contrario, se le indica que perdi:
#include<conio2.h>
#include<iostream>
int main(){
int n;
cin>>n;
if(n>5){
} else{
cout<<"Perdio!!!";
}
getch();
}
Ejemplo 6
Cierta universidad tiene un programa para estimular a los estudiantes con buen
rendimiento acadmico, as:
Si el promedio es de 4,5 o ms y el estudiante es de pregrado, entonces

cursar 28 crditos y se le har un 25% de descuento.
Si el promedio es mayor o igual a 4,0 pero menor que 4,5 y el estudiante es
de pregrado, entonces cursar 25 crditos y se le har un 10% de descuento.
Si el promedio es mayor que 3,5 y menor que 4,0 y es de pregrado, cursar
20 crditos y no tendr ningn descuento.
Si el promedio es mayor o igual a 2,5 y menor que 3,5 y es de pregrado,
cursar 15 crditos y no tendr descuento.
Si el promedio es menor de 2,5 y es de pregrado, no podr matricularse.
Si el promedio es mayor o igual a 4,5 y es de posgrado, cursar 20 crditos y
se le har un 20% de descuento.
Si el promedio es menor de 4,5 y es de posgrado cursar 10 crditos y no
tendr descuento.
Hacer un programa que determine cunto debe pagar un estudiante y cuntos

crditos registra si el valor de cada crdito es de $50000 para pregrado y $300000
para posgrado.
#include<iostream>
#include<conio2.h>
int main()
{
//cs-clase de estudiante
//nc-nmero de crditos
//pe-promedio estudiante
//pdes-porcentaje de descuento
//vcred-valor crdito
//vsd-valor a pagar sin descuento
//des-descuento
27
//vt-valor total a pagar

cout.setf(ios::fixed);
// Evita que la informacin salga en
// forma exponencial
cout.precision(2);
// Saca la informacin con dos decimales
char cs[10];
int nc;
float pdes, vcred, pe, vsd, des, vt;
cout<<"digite clase de estudiante: ";
cin>>cs;
cout<<"digite valor promedio: ";
cin>>pe;
if(strcmpi(cs,"pregrado")==0)
// Comparacin de variables tipo caracter
{
if(pe>=4.5)
{pdes=25;
nc=28;
}
else
{ if(pe>=4.0)
{pdes=10;
nc=25; }
else
{
if(pe>=3.5)
{pdes=0;
nc=20; }
else
{
if(pe>=2.5)
{pdes=0;
nc=15; }
else
{cout<<" Adios pues "<<endl;;
nc=0;
pdes=0; }
}
}
}
//}
vcred=50000;
}
else
{ if(pe>=2.5)
{pdes=0;
nc=15; }
else
{ nc=10;
pdes=0; }
}
vcred=300000;
vsd=nc*vcred;
des=vsd*pdes/100;
vt=vsd-des;
cout<<"el estudiante de: "<<cs;
cout<<" pagara: "<<vt;
cout<<" y cursara: "<<nc<<" creditos"<<endl;
system("pause");
}
3.3. INSTRUCCIN WHILE

28
Cuando necesitemos que una o un conjunto de instrucciones se repitan, podemos

acudir a la instruccin WHILE (mientras).
Su sintaxis es la siguiente:
while(condicin)
{
//instrucciones que se ejecutan mientras se cumpla la condicin
}
Funcionamiento: cuando el programa llega a la instruccin while, se evala la

condicin y, si sta es verdadera, entonces entra a la estructura; de pasar esto, las
instrucciones dentro del while se ejecutan y, al terminar dicha ejecucin, la
condicin se vuelve a evaluar automticamente; si sigue siendo verdadera entonces
se repite la ejecucin de las instrucciones; es decir, el valor de verdad de la
condicin le permite al algoritmo tomar la decisin de repetir o dejar de ejecutar el
grupo de instrucciones.
Tenga en cuenta que, dentro del grupo de instrucciones, debe haber -por lo menosuna instruccin que modifique el valor de verdad de la condicin; de no ser as,
nunca se terminara la repeticin de la ejecucin de las instrucciones.
Ejemplo 7
Se desea sacar el promedio de una serie de 5 nmeros positivos que ingresa el
usuario.
#include<iostream>
int main()
{
float suma,promedio;
int numero;
int i=1;
suma=0;
while(i<=5)
{
cout<<"Digite un numero:"<<endl;
cin>>numero;
suma+=numero;
i++;
//incrementando i
}
promedio=suma/5;
cout<<"El promedio de los numeros es: "<<promedio<<endl;
system("pause");
}
29
Ejemplo 8
Evaluar la siguiente funcin: y=x2-2, mostrando en una tabla el valor de la funcin
evaluada desde x=0 hasta x=10, junto al valor de la x, es decir, la aplicacin
deber mostrar algo como lo siguiente:
x
y(x)
-2
-1
#include<iostream>
#include<math.h>
int main()
{
float y,x;
x=0;
cout<<"funcion: y(x)=x^2-2"<<endl;
cout<<" x y(x)"<<endl;
while(x<=10)
{
y=pow(x,2)-2;
cout<<" "<<x<<" "<<y<<endl;
x++;
}
system("pause");
}
Ejemplo 9
Repasemos los ejemplos anteriores. Para el primero le preguntamos al usuario
cuntos nmeros desea ingresar; y para el segundo le solicitamos al usuario el valor
inicial, valor final y el paso.
#include<iostream>
#include<conio2.h>
#include<math.h>
int main()
{
int i=0;
float y,x,n,step;
x=0;
cout<<"funcion: y(x)=x^2-2"<<endl;
cout<<"valor inicial:";
cin>>x;
cout<<"valor final:";
cin>>n;
cout<<"Unidades que aumentara x en cada iteracion:";
cin>>step;
cout<<" x "<<"y(x)"<<endl;
while(x<=n)
{
30
y=pow(x,2)-2;
gotoxy(3,8+i);
gotoxy(8,8+i);
x=x+step;
i++;
cout<<x;
cout<<y;
}
cout<<endl<<endl;
getch();
}
Ejemplo 10
Encontrar el promedio de n nmeros.
#include<iostream>
int main()
{
int numero;
int i=1, n;
suma=0;
cout<<"Ingrese la cantidad de numeros a los cuales desea sacar el
promedio:"<<endl;
cin>>n;
while(i<=n)
{
cin>>numero;
suma+=numero;
i++;
//incrementando i
}
promedio=suma/n;
cout<<"El promedio de los numeros es: "<<promedio<<endl<<endl;
system("pause");
return 0;
}
Note que, en los ejemplos anteriores, se conoca el nmero de veces que se tenan
que repetir las instrucciones dentro del while, este tipo de solucin se llama
Esquema Cuantitativo y se implementa a travs de un contador.
Un contador es una variable que cuenta la cantidad de veces que se repiten las
instrucciones del ciclo o tambin puede usarse para contar cualquier tipo de
actividad. Antes de usarse debe tener un valor inicial y el valor en que se
incrementa es un valor constante.
Observe que, en el ejercicio anterior, cada vez que se lee un nmero se totaliza en
la variable suma. A este tipo de variables se les denomina acumulador, parecidas a
los contadores pero el valor en que se incrementan es un valor variable, es decir,
totalizan actividades; desde luego, como la variable aparece al lado izquierdo y al
lado derecho, antes de usarse se le debe asignar un valor inicial.
Otro tipo de solucin es el llamado Esquema Cualitativo: este esquema es
utilizado cuando no se conoce el nmero de veces que debe repetirse la secuencia
31
de un determinado ciclo. En esta clase de ciclo el usuario decide cundo terminar

con el proceso repetitivo sin importar cuntas iteraciones se hayan efectuado.
El esquema cualitativo se implementa seleccionando un campo y escogiendo un
valor no permitido para el proceso y el ciclo se implementa comparando el campo
con el valor escogido.
La solucin cualitativa del primer ejemplo seria:
Como se dijo que los nmeros ingresados por el usuario deban ser positivos,
aprovechemos este hecho y determinemos que, cuando el usuario decida terminar
de ingresar nmeros, que simplemente digite un cero o un nmero negativo (por
facilidad de digitacin seleccionamos cero).
Ejemplo 11
#include<iostream>
#include<conio2.h>
int main()
{
int numero,n=1;
suma=0;
cout<<"Digite el primer numero: ";
cin>>numero;
while(numero>0)
{
//se lee el primer nmero
suma+=numero;
n++;
cin>>numero;
}
promedio=suma/n;
cout<<"El promedio de los numeros es: "<<promedio<<endl;
getch();
}
3.4. ESTRUCTURAS ADICIONALES

Otra forma de implementar esquemas cualitativos es a travs de variables tipo
bandera, stas almacenan uno de dos posibles valores seleccionados por el
programador, antes de usarse debe estar inicializada en uno de esos valores. La
pareja de valores puede ser de cualquier tipo de dato, por ejemplo 1 y 0, son, true o
false etc.
Ejemplo 12
32
Hacer un programa que encuentre la suma de los valores de un conjunto de

nmeros, la cantidad de valores negativos, positivos, iguales a cero y el total de
nmeros en el conjunto.
Como no se sabe cuntos nmeros entrar el usuario, usamos un esquema
cualitativo, controlado con la bandera siga que vale S si el usuario tiene ms
nmeros o N si no tiene ms.
#include<iostream>
#include<conio2.h>
int main()
{
int valn=0, val0=0, valp=0,totaln;
char siga; siga='S';
float suma =0, num;
while(toupper(siga)=='S')
{
// La funcin toupper convierte una letra minscula a mayscula
system("cls");
textcolor(WHITE);
textbackground(MAGENTA);
gotoxy(27,12);
cprintf("ENTRE NUMERO : ");
cin>>num;
suma+=num;
if(num > 0)
valp++;
else
if(num==0)
val0++;
else
valn++;
gotoxy(27,14);
cout<<"HAY MS NUMEROS S/N? ";
cin>>siga;
}
totaln=valp+valn+val0;
textcolor(2);
gotoxy(33,9);
cout<<"RESULTADOS";
gotoxy(27,11); cout<<"SUMA DE LOS NMEROS: "<<suma;
gotoxy(27,12); cout<<"NUMEROS NEGATIVOS:
"<<valn;
gotoxy(27,13); cout<<"NUMEROS IGUALES A CERO: "<<val0;
gotoxy(27,14); cout<<"NUMEROS POSITIVOS:
"<<valp;
gotoxy(27,15); cout<<"TOTAL DE NUMEROS:
"<<totaln;
gotoxy(27,17); cout<<"PRESIONE TECLA PARA TERMINAR";
getch();
}
3.5. INSTRUCCIONES ADICIONALES

Existen otras tres instrucciones alternativas a las mostradas anteriormente para la
programacin estructurada, estas instrucciones son usadas algunas veces
reemplazando las instrucciones bsicas, mejorando, acortando la programacin o
hacindola ms entendible. Lo que se hace con estas instrucciones se puede hacer
con las instrucciones bsicas, ms no lo contrario.
33
3.5.1. DO-WHILE
Esta es otra estructura repetitiva de control que es implementada para efectuar un
ciclo, es decir, un conjunto de instrucciones que se ejecutan un determinado
nmero de veces. Es parecida a la estructura while y en algunos aspectos se
complementan. Se utiliza en situaciones en las que se desea que una secuencia se
repita, al menos una vez, antes de comprobar la condicin de repeticin y est
formada por dos partes: las instrucciones que se desean repetir y, al final de sta, la
condicin que controlar el nmero de veces que se repetirn las instrucciones.
La diferencia especial entre la estructura repetir y la estructura mientras es que,
en la primera la secuencia de instrucciones se ejecuta por lo menos una vez, antes
de evaluar la condicin de repeticin y, en la estructura mientras, la condicin de
terminacin es evaluada primero y, por lo tanto, el grupo de instrucciones o campo
de la sentencia puede ser o no ejecutado.
Su estructura es la siguiente:
do{
// instrucciones que se ejecutan una vez y mientras se
// cumpla la condicin
}while(condicin);
Observe que antes del while hay una llave y termina con punto y coma, para
diferenciarlo del while general. Esto quiere decir que el while cierra el do.
Para ejemplificar el uso del ciclo do-while, se puede observar el siguiente problema:
Ejemplo 13
Mostrar un men y pedir una opcin.
//El uso de do-while se hace necesario dado que se debe mostrar el men
//mnimo en una ocasin
#include<iostream>
#include<conio2.h>
int main(){
int opcion;
do{
cout<<"MENU"<<endl;
cout<<"1. OPCION 1"<<endl;
cout<<"3. SALIR"<<endl;
cout<<"INGRESE LA OPCION: ";
cin>>opcion;
}while(opcion!=3);
cout<<"FIN DEL PROGRAMA..."<<endl;
getch();
return 0;
}
34
//usando el ciclo while

#include<iostream>
#include<conio2.h>
int main(){
int opcion;
cout<<"MENU"<<endl;
cin>>opcion;
while(opcion!=3){
cout<<"MENU"<<endl;
cin>>opcion;
}
cout<<"FIN DEL PROGRAMA..."<<endl;
getch();
return 0;
}
Como se puede observar en el ejemplo, el uso de do-while, ayuda a minimizar el

nmero de instrucciones a ejecutar dado que la condicin se evala al final del
bucle.
Ejemplo 14
Hacer un algoritmo que encuentre la suma de los primeros N nmeros naturales,
mediante la estructura do while.
Este programa solo termina si se presiona la tecla Esc.
#include<iostream>
#include<conio2.h>
int main()
{
int n um=1, n; char esc=27,tecla;
long suma=0;
clrscr();
textbackground(WHITE); textcolor(RED);
gotoxy(20,12);
cprintf("ENTRE LMITE DE LOS NMEROS:
");
gotoxy(48,12);
cin>>n;
do
{
suma+=num;
num++;
}while(num <= n);
clrscr();
textbackground(LIGHTRED); textcolor(WHITE);
gotoxy(30,12);
35
cprintf("LA SUMA ES:

");
gotoxy(41,12);
cout<<suma;
do
{
gotoxy(28,16);
cprintf("PRESIONE ESC PARA TERMINAR");
tecla=getch();
}while(tecla !=esc);
}
3.5.2. FOR
La estructura for permite que una o ms instrucciones secuencia se repitan cero o
ms veces, mientras los valores de una progresin aritmtica -de razn creciente o
decreciente-, se vayan asignando a una variable denominada variable de control del
ciclo PARA.
Esta estructura es usada cuando se tiene un esquema cuantitativo y el contador
que controla el ciclo se incrementa o disminuye en un valor constante. La
diferencia entre cmo se implementa esta clase de ciclos y la estructura while, es
que el for maneja la inicializacin del contador y su incremento en forma
automtica, es decir, lo hace la estructura.
Los valores de los parmetros que maneja este ciclo son controlados por la
estructura y, una vez establecidos sus valores o activado el ciclo, no es factible
cambiarlos. Su implementacin en C++ es la siguiente:
for(variableDeControl=valor inicial; condicin; incremento/decremento){

//instrucciones que se ejecutan mientras se cumpla la condicin
}
Ejemplo 15
Leer n datos y calcular su promedio.
#include<iostream>
#include<conio2.h>
int main(){
int numDatos,cont;
double suma=0,promedio,dato;
cout<<"Ingrese el numero de datos a procesar: "<<endl;
cin>>numDatos;
for(cont=0;cont<numDatos;cont++){
cout<<"Ingrese el dato No. "<<cont+1<<endl;
cin>>dato;
suma+=dato;
}
promedio=suma/numDatos;
cout<<"El promedio de los "<<numDatos<<" datos, es: "<<promedio<<endl;
getch();
36
return 0;
}
En el ejemplo anterior, la variable cont es la denominada variable de control para el

ciclo for, la cual se encarga de controlar el nmero de iteraciones del ciclo, y puede
ser declarada e inicializada dentro de la declaracin del ciclo for for(int
cont=0;cont<numDatos;cont++), o como cualquier variable, sea global o local.
Un aspecto importante de este ejemplo es que, el uso de cont+1 dentro de la
funcin cout, no afecta el valor de la variable cont, ya que no est siendo
modificada mediante el operador de asignacin (=), o con el uso del operador de
post o pre incremento (++).
Ejemplo 16
Otro ejemplo, calcular el factorial de un nmero n (Factorial de n=n*(n-1)*(n2)*.*2*1)
#include<iostream>
#include<conio2.h>
int main(){
int n,total=1, cont;
cout<<"Ingrese el numero al cual se le calculara el factorial: "<<endl;
cin>>n;
for(cont=2;cont<=n;cont++){
total*=cont;
}
cout<<"El factorial de "<<n<<" es: "<<total<<endl;
getch();
return 0;
}
3.5.3. SWITCH- CASE

Esta estructura permite seleccionar una alternativa, dentro de un conjunto de ellas,
con base en el valor almacenado en un campo variable denominado selector o
campo controlador de la estructura. Es una estructura selectiva mltiple donde, de
acuerdo con el valor que tenga el controlador, se realiza una determinada tarea una
sola vez, es decir, no repite la ejecucin de la tarea o secuencia.
De acuerdo con el valor que tenga el selector el control de ejecucin del programa,
pasa a uno de varios puntos de ste, evitando as una serie de preguntas
(estructura decisin lgica o un anidamiento de las mismas).
Su estructura es la siguiente:
37
switch(selector){
case valor 1:
instruccin 1;
instruccin 2;
instruccin n;
break;
case valor n:
instruccin 1;
instruccin 2;
instruccin n;
break;
default:
instruccin 1;
instruccin 2;
instruccin n;
break;
}
El valor del selector debe ser una constante de tipo entera (short, int, long o de tipo
caracter). Si al ejecutarse las instrucciones de un caso determinado, se necesita
que se ejecuten los casos siguientes, se omite el uso de la instruccin break. Si lo
que se desea es que slo se ejecuten las instrucciones del caso en el que se
encuentra el selector, es necesario que se incluya la instruccin break. El caso
default agrupa aquellas opciones diferentes a las cubiertas dentro de la estructura,
es decir, ste incluye las instrucciones que se ejecutarn si el selector no asumi
ninguno de los casos que incluye la estructura.
Ejemplo 17
En un programa deportivo se ha concluido que la duracin de la sesin de prctica
depende del peso de la persona y de las condiciones que presenta en la revisin
mdica. La revisin mdica califica a las personas como de condicin 3, 4, 5 6. El
tiempo de cada persona es igual al peso por una rata que se basa en su condicin;
sta es respectivamente: 0.15, 0.21, 0.22 y 0.26. Elaborar un algoritmo que calcule
las duraciones para las sesiones individuales.
#include<iostream>
int main()
{
int iden,con;
float peso,r,t;
cout<<"Ingrese su identificacion o cero para salir:
cin>>iden;
while (iden > 0)
{
cout<<"Ingrese su peso: ";
cin>>peso;
";
38
cout<<"Ingrese su condicion: ";

cin>>con;
switch(con)
{
case 3: r = 0.15;
break;
case 4: r = 0.21;
break;
case 5: r = 0.22;
break;
case 6: r = 0.26;
break;
}
t = peso * r;
cout<<"su identificacion es: "<<iden<<endl;
cou<<El tiempo de duracin de su sesion es: "<< t<<endl;
cout<<"Ingrese otra identificacin, o cero para salir: ";
cin>>iden;
}
}
Ejemplo 18
Leer el paso en el que se encuentra un conductor y mostrar los que an le quedan
por realizar, para salir en su automvil. Al no usarse break despus de los casos 14, se efectan los siguientes a cada uno de stos, es decir, si el usuario ingresa el
paso 1, en la estructura switch se evaluar el caso 1 y los casos siguientes a ste.
#include<iostream>
#include<conio2.h>
int main(){
short paso;
cout<<"Ingrese el paso en el que ha quedado: ";
cin>>paso;
switch(paso)
{
case 1 : cout<<"Paso 1 (ponerse comodo) sin finalizar."<<endl;
case 2 : cout<<"Paso 2 (regular espejos) sin finalizar."<<endl;
case 3 : cout<<"Paso 3 (abrochar cinturn) sin finalizar."<<endl;
case 4 : cout<<"Paso 4 (arrancar motor) sin finalizar."<<endl;
break;
case 5 : cout<<"Tarea finalizada."<<endl;
break;
default: cout<<"Paso incorrecto"<<endl;
break;
}
getch();
return 0;
}
39
La instruccin break tambin puede ser usada en los ciclos para terminar su
ejecucin. Por ejemplo, en los ciclos for y while que se muestran a continuacin.
Ejemplo 19
//Uso de break en ciclos while
#include<iostream>
#include<conio2.h>
int main(){
int cont=0;
while(true){
cout<<"encerrado"<<endl;
cont++;
if(cont==10)break;
//ciclo que se repite infinitamente

//cuando el contador llegue a 10 se termina la
//ejecucin del ciclo
}
getch();
return 0;
}
//Uso de break en ciclos for

#include<iostream>
#include<conio2.h>
int main(){
int cont=0;
for(;;){
cout<<"Encerrado"<<endl;
cont++;
if(cont==10)break;
}
getch();
return 0;
}
//ciclo que se repite infinitamente

//Rompe el ciclo
En la programacin estructurada no es recomendable usar la sentencia break como

medio para hacer la ruptura de un ciclo, ya que mediante tcnicas estructuradas
(por ejemplo cambiar el valor de la condicin de un ciclo), se puede efectuar la
misma funcin que hace un break.
4. SUBPROGRAMAS
A lo largo del manual se han tratado los problemas como un todo, como si fuesen
un solo mdulo. Una de las grandes ventajas que tiene la programacin es la
divisin de problemas grandes en subproblemas y, a su vez, stos tambin pueden
dividirse en problemas ms pequeos. Esta tcnica permite dar ms claridad y
40
facilidad en la construccin y correccin de los errores que se presentan en la

solucin de un problema determinado. Cada una de las divisiones que se hacen
para obtener la solucin de un problema se denomina mdulo y cada mdulo es
implementado por medio de los subprogramas.
Un subprograma es un pequeo programa diseado para efectuar una tarea
particular, bajo la dependencia de un programa u otro subprograma que lo utiliza.
De esta manera, el subprograma es diseado para ser utilizado por otros procesos
ms amplios, dentro de los cuales existe un flujo de recibo y entrega de
informacin.
La utilizacin de subprogramas en la solucin de problemas grandes tiene muchas
ventajas. Por ejemplo, para tareas que deban efectuarse ms de una vez, la
modularidad evita la necesidad de programacin redundante, esencialmente el
mismo conjunto de instrucciones; en vez de ello, un mdulo puede construirse e
invocarse cada vez que se necesite hacer la misma labor, por lo tanto, el uso de
mdulos permite o hace que los programas sean ms cortos. De igual
manera, la fragmentacin en mdulos individuales proporciona claridad, facilidad de
distribucin de trabajo en equipo y, por ser programas cortos, son ms fciles de
escribir, corregir y su estructura lgica es ms clara que la de los programas que no
estn divididos en mdulos.
El subprograma, por ser un programa, debe cumplir con las mismas caractersticas
de ste y hacer tareas similares como aceptar datos, escribir datos y hacer clculos;
sin embargo, es utilizado para un propsito especfico. El subprograma recibe datos
del programa o subprograma que lo invoca y ste le devuelve resultados.
La comunicacin que se establece entre el programa llamante y el subprograma se
hace a travs de variables denominadas parmetros, que hacen las veces de
recipiente, unas de recibo y otras de envo de informacin.
Un subprograma puede ser invocado tantas veces como se necesite y, a su vez, los
subprogramas pueden invocar a otros subprogramas, como puede verse en la figura
siguiente:
41
< In s tr u c c io n e s 1 >
< L la m a d a u n o a A >
< I n s t r u c c i n 3 >
Pasa
in f o r m a c i n
c e d e c o n tro l
R e to rn a
c o n tr o l e
in fo rm a c i n
S u b p ro g ra m a
A
< In s tr u c c io n e s >
Pasa
in f o r m a c i n
c e d e c o n tro l
< L la m a d a u n o a B >
< I n s t r u c c i n i>
R e to rn a
c o n tr o l e
in fo rm a c i n
Pasa
in f o r m a c i n
c e d e c o n tro l
< L la m a d a d o s a A >
< I n s t r u c c i n k >
R e to rn a
c o n tr o l e
in fo rm a c i n
S u b p ro g ra m a
B
L la m a d a a C
< In s tr u c c i n i>
C e d e c o n tr o l
R e to r n a
c o n tro l
S u b p ro g ra m a
C
S u b p ro g ra m a
A
< I n s t r u c c i n n >
En el grfico las flechas indican el flujo de ejecucin del programa; observe que
cuando se ejecuta una instruccin de llamada a un subprograma, el algoritmo
llamante se detiene, ya que no solamente le transfiere informacin al subprograma,
sino tambin el control de ejecucin; esto hace que se active el subprograma, se les
d valor a las variables que lo conforman y se ejecuten una a una las instrucciones.
Una vez que finaliza su ejecucin, tiene la informacin requerida por el programa
llamante; por lo tanto, se la entrega y devuelve el control de ejecucin a la
instruccin siguiente o a la misma instruccin desde donde fue llamado,
dependiendo de la clase de subprograma.
En la figura tambin se muestra que un algoritmo puede invocar las veces que sea
necesario al mismo subprograma y que un subprograma puede, a su vez, invocar a
otros subalgoritmos.
4.1. CLASIFICACIN DE LOS SUBPROGRAMAS

La divisin de los subprogramas se hace con base en el nmero o cantidad de
valores que el subprograma le enva al programa o subprograma llamante.
4.1.1. PROCEDIMIENTOS O SUBRUTINAS

Son subprogramas que devuelven cero o ms valores al programa o subprograma
que lo invoca (utiliza) y retornan el control de ejecucin a la instruccin siguiente
desde donde se llaman.
42
A. REPRESENTACIN
void
{
Nombre (tipo de dato parmetro1, tipo de dato parmetro2, ...)

//Instrucciones
El Nombre dado al subprograma debe cumplir con las normas para conformar
nombres de variables y debe ser nico (no pueden existir dos o ms subprogramas
con el mismo nombre en el mismo programa).
Los Parmetros son una lista de campos variables separados por comas y son
utilizados para establecer la comunicacin entre el mdulo que lo activa y el
subprograma. Unos parmetros sern de recibo (almacenan la informacin que les
enva el mdulo que los invoca), y otros de envo de informacin (la transfieren a
quien invoca el subprograma).
Ejemplo 20
Hacer un subprograma que ordene tres nmeros distintos en forma ascendente.
Anlisis
Consiste en detectar cules son los parmetros de recibo, cules los de envo y el
proceso que es necesario hacer para llegar a los parmetros de envo, partiendo de
los de recibo.
Parmetros de recibo
Son las variables que van a recibir informacin del mdulo que los invoca, similares
a los datos de entrada de un programa, con la diferencia de que a los datos de
entrada se les transfiere informacin a travs de una instruccin de lectura y a los
parmetros de recibo se les da informacin a travs del mdulo que invoca el
subprograma; es decir, que se asigna una informacin automtica desde las
variables que envan informacin, desde el mdulo llamante, hacia los parmetros
de recibo del subprograma. Estos parmetros son:
Valor del primer nmero
Valor del segundo nmero
Valor del tercer nmero
Parmetros de envo
Son los parmetros que envan informacin al mdulo que invoca al subprograma,
semejante a los datos de salida de los programas, con la diferencia de que los
parmetros de envo le entregan la informacin a las variables que la reciben,
dentro del mdulo llamante.
43
Menor valor
Valor medio
Mayor valor
Proceso
Para determinar el orden ascendente de los tres nmeros, primero se encuentra el
menor de todos a travs de comparaciones entre s y se asigna al menor valor,
luego se encuentra el segundo menor y se asigna al valor medio y el restante, por
defecto, es el valor mayor.
Definicin de variables
ORDEN:
Nombre del procedimiento
PV:
Primer valor
SV:
Segundo valor
TV:
Tercer valor
MENOR:
Valor menor
MEDIO:
Valor medio
MAYOR:
Valor mayor
B. ACTIVACIN DE UN PROCEDIMIENTO
El subprograma no inicia ni termina por s mismo; por lo tanto, necesita ser activado
(hacerlo funcionar) desde un mdulo externo. Esto se hace cuando el mdulo
llamante necesita la ayuda (para una labor especfica) que hace el mdulo
subordinado. La activacin se hace a travs de la siguiente instruccin.
Formato
Nombre (Argumentos)
Los argumentos son nombres de campos (valores, constantes, variables o
expresiones) que usa el mdulo amplio y que tienen una correspondencia biunvoca
con los parmetros con los cuales se construy el subprograma; por lo tanto, stos
deben ser iguales en nmero y en tipo de dato que los parmetros, ya que a cada
argumento le corresponde un parmetro o viceversa.
Los argumentos tambin son de dos clases: unos que envan informacin al
subprograma y otros que reciben informacin.
Cuando el subprograma es activado, los argumentos de envo son copiados en los
parmetros de recibo, (parmetros de recibo argumentos de envo). Y cuando
el subprograma deja de ejecutarse los parmetros de envo le asignan informacin
a los argumentos de recibo. Por ejemplo, elaborar la instruccin que active el
procedimiento ORDEN. Este subprograma tiene 6 parmetros (tres de recibo y tres
44
de envo), por lo tanto, la instruccin que lo invoque debe tener 6 argumentos (tres
de envo y tres de recibo).
Si las variables a utilizar como argumentos son en su orden: N1, N2, N3, MEN, MED
y MAY la instruccin sera.
Orden (N1, N2, N3, MEN, MED, MAY);
Lo que significa lo siguiente:
i. Cuando se activa el subprograma (empieza a ejecutarse).
PV=N1
SV=N2
TV=N3
Por lo tanto N1, N2 y N3 deben tener valor.
ii. Cuando la ORDEN deja de ejecutarse (regresa informacin)
MEN=MENOR
MED=MEDIO
MAY=MAYOR
Los subprogramas tienen tres formas de ubicarse dentro de un programa: antes de
int main, despus del int main o estar dentro de una librera como lo veremos ms
adelante.
#include<iostream>
#include<conio2.h>
//CODIFICACIN DEL PROCEDIMIENTO ORDEN
void orden(float pv, float sv, float tv, float &menor, float &medio, float &mayor)
{
if((pv<sv) && (pv<tv))
{
menor=pv;
if(sv<tv)
{
medio=sv;
mayor=tv;
}
else
{
medio=tv;
mayor=tv;
}
}
else
{
45
if(sv<tv)
{
menor=sv;
if(pv<tv)
{
medio=pv;
mayor=tv;
}
}
else
{
menor=tv;
if(pv<sv)
{
medio=pv;
mayor=sv;
}
else
{
medio=sv;
mayor=pv;
}
}
}
}
//PROGRAMA QUE INVOCA AL PROCEDIMIENTO ORDEN
int main()
{
float n1,n2,n3,men,med,may; int i;//n1,n2 y n3,men,med y may son los argumentos
textbackground(0);
textcolor(YELLOW);
gotoxy(8,8);
cout<<"ENTRE EL PRIMER VALOR: "; cin>>n1;
gotoxy(8,10);
cout<<"ENTRE EL SEGUNDO VALOR:"; cin>>n2;
gotoxy(8,12);
cout<<"ENTRE EL TERCER VALOR: "; cin>>n3;
orden(n1,n2,n3,men,med,may);
clrscr();
textcolor(RED);
gotoxy(6,7);
cout<<"VALORES ORDENADOS EN ORDEN ASCENDENTE";
gotoxy(7,10);
cout<<"VALOR MENOR:"; cout<<men;
gotoxy(7,11); cprintf("VALOR MEDIO:"); cout<<med;
textcolor(5);
gotoxy(7,12); cprintf("VALOR MAYOR:");cout<<may<<endl;
textcolor(6);
system("pause");
}
//Procedimiento codificado despus del main

#include<iostream>
#include<conio2.h>
//Prototipo del subprograma, ste est codificado al final del main
void orden(float pv, float sv, float tv, float &menor,
float &medio, float &mayor);
int main()
46
{
float n1,n2,n3,men,med,may; int i;//n1,n2 y n3,men,med y may son los argumentos
textbackground(0);
textcolor(YELLOW);
gotoxy(8,8);
cout<<"ENTRE EL PRIMER VALOR: "; cin>>n1;
gotoxy(8,10);
cout<<"ENTRE EL SEGUNDO VALOR:"; cin>>n2;
gotoxy(8,12);
cout<<"ENTRE EL TERCER VALOR: "; cin>>n3;
orden(n1,n2,n3,men,med,may);
clrscr();
textcolor(RED);
gotoxy(6,7);
cout<<"VALORES ORDENADOS EN ORDEN ASCENDENTE";
gotoxy(7,10);
cout<<"VALOR MENOR:"; cout<<men;
gotoxy(7,11); cprintf("VALOR MEDIO:"); cout<<med;
textcolor(5);
gotoxy(7,12); cprintf("VALOR MAYOR:");cout<<may<<endl;
textcolor(6);
system("pause");
}//FIN MAIN
float &medio, float &mayor)
{
{
menor=pv;
if(sv<tv)
{
medio=sv;
mayor=tv;
}
else
{
medio=tv;
mayor=tv;
}
}
else
{
if(sv<tv)
{
menor=sv;
if(pv<tv)
{
medio=pv;
mayor=tv;
}
}
else
{
menor=tv;
if(pv<sv)
{
medio=pv;
mayor=sv;
}
47
else
{
medio=sv;
mayor=pv;
}
}
}
}
Ejemplo 21
Elaborar un programa que utilice un procedimiento que encuentre la suma y el
promedio de N nmeros.
#include<iostream>
#include<conio2.h>
/* Codificacin del procedimiento, n parmetro de recibob
sum y prom parmetros de envo*/
void sumprom(int n, float &sum, float &prom)
{
int i;
float numero;
sum=0;
clrscr();
textcolor(WHITE);
textbackground(RED);
for (i=1;i<=n;i++)
{
gotoxy(20,4+i);
cout<<"DIGITE EL NUMERO "<< i<<": ";
cin>>numero;
sum+=numero;
}
prom=sum/n;
}
int main()
{
int num;
float suma, promedio;
system("cls");
gotoxy(20,12);
cout<<"DIGITE LA CANTIDAD DE NUMEROS: ";
cin>>num;
sumprom(num,suma,promedio);
clrscr();
gotoxy(20,12);
cout<<"LA SUMA ES: "<<suma<<"
Y EL PROMEDIO: "<<promedio;
gotoxy(20,14);
system("pause");
}
4.1.2. FUNCIONES
Son subprogramas que le devuelven al programa o subprograma que los invoca un
nico valor. El valor que stas devuelven se hace a travs de una variable,
48
expresin o valor involucrados en una instruccin return, dentro del conjunto de

instrucciones, o en el nombre de sta; por lo tanto, este tipo de subprogramas en su
encabezamiento (prototipo), slo tiene parmetros de recibo.
Las funciones
devuelven el control de ejecucin a la misma instruccin desde donde se llaman.
Una funcin puede tener varios return, pero una vez que ejecuta uno, termina la
funcin.
A. SINTAXIS
//Para definir (declarar) la funcin

tipo nombre(parmetros)
que retorna la funcin
{
Instrucciones
return valor;
}
//Para invocar (instanciar) la funcin
Variable = nombre(parametros);
Ejemplo 22
Elaborar un programa que utilice una funcin que encuentre el valor mayor en un
conjunto de 3 nmeros reales diferentes. La funcin debe retornar el mayor entre
los tres nmeros.
#include<iostream>
#include<conio2.h>
float mayor(float n1,float n2, float n3)//n1, n2, y n3 parmetros de recibo
{
float valmay;
if((n1>n2) && (n1>n3))
valmay=n1;
else
if(n2>n3)
valmay=n2;
else
valmay=n3;
return valmay;
}
int main()
{
float NUM1,NUM2,NUM3,NUM_MAYOR;
clrscr();
gotoxy(25,10); textcolor(YELLOW);
cprintf("ENTRE EL PRIMER VALOR :"); cin>>NUM1;
gotoxy(25,12); textcolor(LIGHTBLUE);
cprintf("ENTRE EL SEGUNDO VALOR:"); cin>>NUM2;
gotoxy(25,14); textcolor(LIGHTRED);
cprintf("ENTRE EL TERCER VALOR :"); cin>>NUM3;
NUM_MAYOR=mayor(NUM1,NUM2,NUM3);
clrscr();
gotoxy(10,12);
49
cout<<"EL VALOR MAYOR ENTRE: "<<NUM1<<","<<NUM2<<" Y "<<

NUM3<<" ES: "<<NUM_MAYOR; textcolor(6);
gotoxy(20,20);cout<<"PRESIONE TECLA PARA TERMINAR";
getch();
}
Una ventaja de las funciones es que pueden estar involucradas en expresiones,

como se muestra en el siguiente algoritmo.
En algunos casos particulares, cuando el programa lo requiera, se pueden enviar
valores constantes como argumentos, cuando se invoca un subprograma
(procedimiento funcin).
Ejemplo 23
En un programa, utilizar la funcin MAYOR para encontrar el valor mayor entre 90.5
y dos valores que entrar el usuario.
#include<iostream>
#include<conio2.h>
float mayor(float N1,float N2, float N3)
{
float VALMAY;
if((N1>N2) && (N1>N3))
VALMAY=N1;
else
if(N2>N3)
VALMAY=N2;
else
VALMAY=N3;
return VALMAY;
}
int main()
{
float NUM1,NUM2;
cout.precision(2);
cout.setf(ios::fixed,ios::floatfield);
cout.setf(ios::showpoint);
clrscr();
gotoxy(25,10); textcolor(YELLOW);
cprintf("ENTRE EL PRIMER VALOR :"); cin>>NUM1;
cprintf("ENTRE EL SEGUNDO VALOR:"); cin>>NUM2;
clrscr();
gotoxy(10,12);
cout<<"EL VALOR MAYOR ENTRE: "<<NUM1<<" , "<<NUM2
<<" Y 90.5 ES: "<<mayor(NUM1,NUM2,90.5); textcolor(6);
getch();
}
Ejemplo 24
Elaborar un programa que utilice una funcin que determine si un nmero es primo
o no.
50
#include<iostream>
#include<conio2.h>
char primo(int n)
{
int mitad=n/2,i=2;
char res='N';
while((i<=mitad) && (n % i !=0))
i++;
if(i > mitad)
res='S';
return res;
}
/*Observe que el ciclo se rompe cuando n% i es igual a cero, es decir, se le encontr
un divisor a n. A esto se le denomina rompimiento de ciclos. Puede hacerse tambin con
una bandera o switche */
int main()
{
int num;
clrscr();
gotoxy(20,12); textcolor(6); textbackground(BLUE);
cprintf("ENTRE EL NMERO:
");
gotoxy(36,12); cin>>num; clrscr();
if(primo(num) =='S')
cout<<num<<" ES PRIMO";
else
cout<<num<<" NO ES PRIMO";
gotoxy(20,20); cout<<"PRESIONE TECLA PARA TERMINAR";
getch();
}
4.1.3. LIBRERAS
Una librera hecha por el programador est formada por subprogramas previamente
diseados, que pueden ser utilizados por el programador para realizar las
operaciones que hacen los subprogramas que la conforman, sin que estos
subprogramas estn en el programa principal que las invoca.
Son como un archivo amplio llamado archivo de cabecera que se crea y se
guarda con un nombre especfico anexndole la extensin .h, por ejemplo
entorno.h. Esta extensin la colocamos nosotros ya que no se hace por defecto, por
lo que una librera no se puede compilar.
Cuando la librera se coloque en el encabezado del programa, para diferenciarla de
las libreras del compilador, se coloca entre comillas dobles, colocando la ruta
donde se encuentra almacenada la librera, por ejemplo, si la librera llamada
entorno1.h est guardada en el disco C, en la carpeta libreras, el encabezado sera
el siguiente:
#includeC:\librerias\entorno.h, pero si la librera est guardada en la misma
carpeta donde est el programa que la utiliza, el encabezado simplemente sera:
#includeentorno.h.
Ejemplo 25
51
Elaborar una librera que contenga los siguientes subprogramas: un procedimiento

que elabore un cuadro dentro en la pantalla, el procedimiento orden, el
procedimiento sumprom y la funcin mayor. Esta librera la vamos a llamar
"milibreria" y la guardamos en la misma carpeta donde est el programa que usar
sus subprogramas. Por lo tanto el nombre con que la vamos a guardar debe ser
milibreria.h.
#include<iostream>
#include<conio2.h>
#include<windows.h>
void cuadro(int fi, int ci, int ff, int cf)
{
/* fi: fila inicial donde inicia el cuadro, ci columna inicial
ff fila final donde finaliza el cuadro, cf columna final*/
int i;
clrscr();
for(i=(ci+1);i<cf;i++)
{
gotoxy(i,fi);
cout<<char(196);
//caracter
gotoxy(i,ff);
cout<<char(196);
//caracter
}
for(i=fi+1;i<ff;i++)
{
gotoxy(ci,i);
cout<<char(179);
// caracter
gotoxy(cf,i);
cout<<char(179);
//caracter
}
gotoxy(ci,fi);
cout<<char(218); //Esquina superior izquierda caracter
gotoxy(cf,fi);
cout<<char(191); //Esquina superior derecha
caracter
gotoxy(ci,ff);
cout<<char(192); //Esquina inferior izquierda caracter
gotoxy(cf,ff);
cout<<char(217); //Esquina inferior derecha
caracter
}
//***************************************************************************
float &medio, float &mayor)
{
{
menor=pv;
if(sv<tv)
{
medio=sv;
mayor=tv;
}
else
{
medio=tv;
mayor=tv;
}
52
}
else
{
if(sv<tv)
{
menor=sv;
if(pv<tv)
{
medio=pv;
mayor=tv;
}
}
else
{
menor=tv;
if(pv<sv)
{
medio=pv;
mayor=sv;
}
else
{
medio=sv;
mayor=pv;
}
}
}
}
//*********************************************************************************
void sumprom(int n, float &sum, float &prom)
{
int i;
float numero;
sum=0;
clrscr();
textcolor(WHITE);
for (i=1;i<=n;i++)
{
gotoxy(20,4+i);
cout<<"DIGITE EL NMERO "<< i<<" ";
cin>>numero;
sum+=numero;
}
prom=sum/n;
}
//****************************************************************************
float mayor(float n1,float n2, float n3)//n1, n2, y n3 parmetros de recibo
{
float valmay;
if((n1>n2) && (n1>n3))
valmay=n1;
else
if(n2>n3)
valmay=n2;
else
valmay=n3;
return valmay;
}
53
Ejemplo 26
Programa que hace uso de los subprogramas que contiene milibreria.h.
#include "milibreria.h"
int main()
{
float pv, sv, tv, menor, medio ,mayor1,sum, prom, n1,n2,n3,valmay;
int opcion,n;
do
{
clrscr();
textbackground(WHITE); textcolor(BLUE);
cuadro(7,19, 19, 62);
gotoxy(36,9); cout<<"MEN";
gotoxy(21,11); cout<<"1: TRES NMEROS ORDENADOS";
gotoxy(21,12); cout<<"2: SUMA Y PROMEDIO DE N NMEROS";
gotoxy(21,13); cout<<"3: MAYOR ENTRE TRES NMEROS";
gotoxy(21,14); cout<<"4 SALIR DEL MEN";
gotoxy(21,16); cout<<"SELECCIONE LA OPCIN DESEADA: ";
cin>>opcion;
switch(opcion)
{
case 1: clrscr();
textbackground(WHITE);
textcolor(MAGENTA);
gotoxy(8,8);
cprintf("ENTRE EL PRIMER VALOR: "); cin>>pv;
gotoxy(8,10);
cprintf("ENTRE EL SEGUNDO VALOR:"); cin>>sv;
gotoxy(8,12);
cprintf("ENTRE EL TERCER VALOR: "); cin>>tv;
orden(pv,sv,tv, menor,medio,mayor1);
clrscr();
textcolor(RED);
gotoxy(6,7);
cprintf("VALORES ORDENADOS EN ORDEN ASCENDENTE");
gotoxy(7,10);
cprintf("VALOR MENOR:"); cout<<menor;
gotoxy(7,11); cprintf("VALOR MEDIO:"); cout<<medio;
textcolor(5);
gotoxy(7,12); cprintf("VALOR MAYOR:");cout<<mayor1<<endl;
textcolor(6);
system("pause");
break;
case 2: system("cls");
gotoxy(20,12);
cout<<"DIGITE LA CANTIDAD DE NMEROS: ";
cin>>n;
sumprom(n,sum,prom);
gotoxy(20,12);
cout<<"LA SUMA ES: "<<sum<<"
Y EL PROMEDIO: "<<prom;
gotoxy(20,16);
system("pause");
break;
54
case 3: clrscr();
gotoxy(25,10); textcolor(CYAN);
cprintf("ENTRE EL PRIMER VALOR :"); cin>>n1;
cprintf("ENTRE EL SEGUNDO VALOR:"); cin>>n2;
cprintf("ENTRE EL TERCER VALOR :"); cin>>n3;
valmay=mayor(n1,n2,n3);
clrscr();
gotoxy(10,12);
cout<<"EL VALOR MAYOR ENTRE: "<<n1<<" , "<<n2<<" Y "<<
n3<<" ES: "<<valmay; textcolor(6);
getch();
break;
case 4: system("cls");
gotoxy(20,12);
cout<<"GRACIAS POR USAR EL PROGRAMA";
Sleep(2000);
break;
} //fin casos
}while (opcion !=4);
}
4.1.4 LIBRERA PARA VALIDAR Y CREAR CUADROS

Se va a construir una librera que se llame ENTORNO.H y que haga
dos cosas:
A. Que valide la informacin que debe entrar el usuario. Es muy comn que el
usuario se equivoque cuando digita un dato de cualquier tipo, por ejemplo, si el
dato a entrar es un int y este digita k1 por el programa aborta, se detiene la
ejecucin y se retorna al programa fuente, si ya se ha digitado 5 datos se
deben volver a digitar. Lo que hace que para el usuario sea engorroso.
La validacin le permite al programador recojer los errores del usuario al
mximo; si el usuario digita un dato mal, se le enviar un mensaje en el que
se le comunique el error que ha cometido y se le permita volver a digitar el
dato, sin que el error de ejecucin cometido lo saque del programa. En el
caso arriba mencionado, si el usuario digita K1, se le envia un mensaje
diciendo que slo digite nmeros y que vuelva a digitar. Los datos que ya
haya digitado no se pierden, as que contina entrando ms datos. La opcin
de volver a digitar se ha colocado al final de la pantalla, para que no
interumpa ningn cuadro que se est utilizando.
A. Validacin de nmeros. Significa que el usuario solo puede digitar
nmeros o, en algunos casos, el signo menos y/o el punto decimal, pero la
validacin permite que l digite cualquier caracter, por eso hay que
declarar dos variables para el nmero que se va a validar: una de tipo
carcter y otra de tipo numrica. Luego, a travs de la funcin atold, se
55
convierte lo que se almacen en la variable tipo caracter a nmeros y con

eso sigue trabajando.
A.1 Validacin de nmeros enteros: short, int, long long. En este caso el
usuario solo puede digitar nmeros positivos y negativos, si digita otro caracter
inmediatamente se le enviar un mensaje al usuario para que vuelva a digitar y
contine entrando ms datos si los tiene. La funcin es la siguiente: long long
validarEntero(char numc[])
Aunque en el ejemplo 28 est la forma de uso, a continuacin ver una
demostracin.
Por ejemplo: para validar la variable nmero de estudiantes,
tendremos la variable numestc de tipo caracter, que al leerla el usuario puede
digitar cualquier caracter, a esta variable se le deben colocar tantos bytes como
dgitos tenga el mayor nmero a entrar, en este caso la cantidad de estudiantes y
otra variable numest de tipo int, que es la variable con la que realmente usted
seguir trabajando.
Dentro de validarEntero(), se usa la funcin atold que
convierte los caracteres almacenados en numestc a nmeros y los almacene en la
variable numrica numest. As:
char numestc[8];
dgitos.*/
/*significa que la cantidad de estudiantes no tiene ms de 7
int numest;
cin>>numestc;
// Se lee una variable de tipo char
numest=validarEntero(numestc); // numest queda con solo dgitos

SIGA TRABAJANDO
Esto ocurre con la validacin de nmeros de cualquier tipo. En las variables de tipo
caracter, solo es necesaria la variable de tipo caracter, es decir, no tenemos
necesidad de hacer una conversin.
A.2 Validacin de nmeros reales: float, double o long double. En esta
funcin el usuario slo puede digitar nmeros, el signo menos y el punto decimal
que puede estar al principio o intermedio de la hilera de dgitos, no permite que se
coloquen dos veces el punto decimal. La funcin es:
double validarReal(char numc[]). Su uso es similar al de
vaidarEntero(numc[]), solo que aqu se define como variable numrica una variable
de cualquier tipo de los arriba mencionados. La funcin utiliza
strtod para la conversin de caracteres a dgitos con el punto decimal o sin l.
A.3 Validacin de nmeros reales positivos: float, doubl o long doubl.
Su uso es igual que la anterior
pero no deja que se coloque el signo menos. El nombre de la funcin es:
56
double validarRealPositivo (char *numc) // El * es semejante a lo que hay

entre parntesis en las funciones anteriores.
A.4 Validacin de nmeros enteros positivos: short, int, long long. Igual a la
funcin validarEntero, pero no admite nmeros negativos. La funcin es:
long long validarEnteroPositivo(char numc[])
B. Validacin de caracteres (letras). Es chequear que el usuario slo digite letras,
se puede hacer de tres formas: que digite letras minsculas y maysculas, que solo
digite maysculas o minsculas. Ejemplo:
Validar letras maysculas y minsculas, digamos un nombre, donde cada nuevo
nombre o apellido debe iniciar con mayscula.
char nombre[48];
clrscr();
cout<<DIGITE EL NOMBRE
cin>>ws;
<<endl;
cin.getline(nombre,48);
validarCaracteres(nombre); /*Observe que el subprograma es un procedimiento y por la

tanto se llama de una manera diferente que las anteriores que son funciones*/
Si no hay errores siga trabajando.
B.1 Validacin de maysculas y minsculas

Se hace mediante un procedimiento llamado validarCaracteres(char hilera[]), slo
admite que se digiten letras minsculas y maysculas.
B.2 Validacin de maysculas. Slo permite, para la variable de tipo caracter, que
se digiten letras maysculas.
Nombre: void validarMayusculas (char hilera[])
Uso: validarMayusculas(nombre);
C. Creacin de cuadros en la pantalla. Para incluir textos internamente, por
ejemplo cuando se crean programas usando mens. Todos los cuadros estn hechos
como procedimientos.
C.1
void cuadros(int fi, int ci, int ff, int ff)
Donde fi=fila inicial; ci= columna inicial; ff=fila final y cf = columna final
Este procedimiento genera un cuadro con lnea sencilla iniciando en la fila fi,
columna ci y finalizando en la fila ff y columna cf. Usted puede colocar el cuadro en
cualquier lugar de la pantalla y con el ancho y largo que desee. Ejemplo: cuadros(5,
20, 17,55);
El cuadro se construye a partir de la fila 5 columna 20 y finaliza en la fila 17
columna 55.
57
C.2
void cuadro1()
Este procedimiento forma un cuadro en pantalla con cuadro internos,

el
procedimiento ubica el cuadro en un lugar fijo en la pantalla, desde luego usted
puede modificar el procedimiento que estar en la Librera entorno.h ms adelante.
C.3 void cuadro2()
El procedimiento forma un cuadro con lnea doble con un subcuadro en la parte
suprior. El cuadro se construye en un lugar fijo en la pantalla.
C.4 void cuadrod(int fi, int ci , int ff, int cf)
Genera un cuadro con lnea doble en la pantalla, iniciando en la fila fi columna ci y
termina en la fila fi
Columna cf.
C.5 void cuadro Menos Amas()
Genera un cuadro con lnea doble que se inicia a construir desde un cuadro
pequeo y va aumentando hasta llegar a formar el cuadro completo dentro de la
pantalla y sus coordenadas son fijas en la pantalla.
C.6 void escribirCmasMas()
Este procedimiento escribe el texto C++, dentro del cuadro MenosAmas y est
ubicado en un lugar fijo en la pantalla
EJEMPLO 27
/* LIBRERIA ENTORNO.H*/
#include<iostream>
#include<conio2.h>
#include<windows.h>
#include<iomanip>
/* ESTA FUNCIN VALIDA UN NMERO ENTERO: SHORT, INT O LONG, DEVUELVE
EL NMERO DIGITADO VALIDADO O SEA, QUE SLO CONTENGA DGITOS Y/O EL SIGNO MENOS
RETORNA UN long long*/
long long validarEntero(char numc[])
58
{
short nc,i;
long long numeroEntero;
do{
char siga='S';
i=0;
nc=strlen(numc);
if((numc[0]=='-')&&(nc>1))
i++;
while((i<nc)&&(siga=='S')){
if(isdigit(numc[i]) !=0)
i++;
else{
siga='N';
// clrscr();
gotoxy(10,24);
cout<<"DIGITE SLO NMEROS ENTEROS, VUELVA A DIGITAR ";
cin>>ws;
cin.getline(numc,20);
gotoxy(10,24);
cout<<"
";
}
}
}
while(i<nc);
numeroEntero=atoll(numc);
return numeroEntero;
}
/*************************************************************************************
*****************************
/* ESTA FUNCIN VALIDA UN NMERO FLOAT O DOUBLE Y DEVUELVE
EL NMERO DIGITADO VALIDADO, ES DECIR,
EL NMERO SEA POSITIVO
QUE SOLO CONTENGA DGITOS, UN PUNTO Y QUE
RETORNA UN double */
double validarRealPositivo(char *numc)

{
double numeroReal;
short nc,i;
do{
i=0;
59
char siga='S';
int p=0;
nc=strlen(numc);
if(strcmpi(numc,".")==0)
numc[i]='N';
if((isdigit(numc[i]) !=0) || ((numc[i]=='.')&&(p==0))){
i++;
if(numc[i-1]=='.')
p++;
}
else{
siga='N';
//clrscr();
gotoxy(10,24);
cout<<"DIGITE NMEROS POSITIVOS, VUELVA A DIGITAR ";cin>>ws;
gotoxy(10,24);
cout<<"
";
}
}
}
while(i<nc);
numeroReal=strtod(numc,'\0');
return numeroReal;
}
/
**************************************************************************************
*****************
/* ESTA FUNCIN VALIDA UN NMERO ENTERO: SHORT, INT O LONG, DEVUELVE
EL NMERO DIGITADO VALIDADO, ES DECIR,
SEA POSITIVO
QUE SOLO CONTENGA DGITOS Y QUE EL NMERO
RETORNA UN long long*/

long long validarEnteroPositivo(char numc[])
{
short nc,i;
long long
numeroEntero;
do{
char siga='S';
i=0;
nc=strlen(numc);
if(isdigit(numc[i]) !=0)
i++;
60
else{
siga='N';
//clrscr();
gotoxy(10,24);
cout<<"DIGITE NMEROS ENTEROS POSITIVOS, VUELVA A DIGITAR ";cin>>ws;
gotoxy(10,24);
cout<<"
";
}
}
}
while(i<nc);
numeroEntero=atoll(numc);
return numeroEntero;
}
/
*/************************************************************************************
**************************
ESTE PROCEDIMIENTO CONTROLA QUE EL USUARIO SLO DIGITE LETRAS (MAYSCULAS O
MINSCULAS, SI NO HAY ERRORES SIGA TRABAJANDO NORMALMENTE*/
void validarCaracteres(char hilera[])

{
int nc,i;
char siga;
do{
i=0;
nc=strlen(hilera);
siga='S';
if((isalpha(hilera[i]) !=0) ||(isspace(hilera[i]) != 0))
i++;
else{
siga='N';
gotoxy(4,24);
cout<<"SLO DIGITE LETRAS, VUELVA A DIGITAR ";
cin>>ws;cin.getline(hilera,40);
gotoxy(4,24);
cout<<"
";
}
}
}
while(i<nc);
61
}
/**************************************************************
EL PROCEDIMIENTO validaMayusculas CHEQUEA QUE UNA VARIABLE TIPO CARACTER NO
ALMACENE SINO LETRAS MAYSCULAS.
CORRECTO */
SI NO HAY ERRORES, SIGA TRABAJANDO QUE TODO EST
void validarMayusculas (char hilera[])

{
int nc,i;
char siga;
do{
i=0;
nc=strlen(hilera);
siga='S';
if((isupper(hilera[i]) !=0) ||(isspace(hilera[i]) != 0))
i++;
else{
siga='N';
gotoxy(4,24);
cout<<"SOLO DIGITE LETRAS MAYSCULAS, VUELVA A DIGITAR ";
cin>>ws;cin.getline(hilera,40);
gotoxy(4,24);
cout<<"
";
}
}
}
while(i<nc);
}
//********************************************************************
/*ESTE PROCEDIMIENTO GENERA UN CUADRO CON LNEA SENCILLA INICIANDO EN LA FILA FI,
COLUMNA CI Y FINALIZANDO EN LA FILA FF Y COLUMNA CF. USTED PUEDE COLOCAR EL CUADRO EN
CUALQUIER LUGAR DE LA PANTALLA Y CON EL ANCHO Y LARGO QUE DESEE*/
void cuadros(int fi,int ci,int ff,int cf)
{
int i;
textbackground(0);
for(i=(ci+1);i<cf;i++){
gotoxy(i,fi);
cout<<char(196);
//caracter
gotoxy(i,ff);
cout<<char(196);
//caracter
62
}
for(i=fi+1;i<ff;i++){
gotoxy(ci,i);
cout<<char(179);
//
caracter
gotoxy(cf,i);
cout<<char(179);
//caracter
}
gotoxy(ci,fi);
cout<<char(218); //Esquina superior izquierda caracter
gotoxy(cf,fi);
cout<<char(191); //Esquina superior derecha
caracter
gotoxy(ci,ff);
cout<<char(192); //Esquina inferior izquierda caracter
gotoxy(cf,ff);
cout<<char(217); //Esquina inferior derecha
caracter
}
//****************************************************************
/* ESTE PROCEDIMIENTO FORMA UN CUADRO EN PANTALLA CON CUADROS INTERNOS. EL
PROCEDIMIENTO INSERTA EL CUADRO EN UN LUGAR PREDETERMINADO EN LA PANTALLA*/
void cuadro1()
{
int i;
for(i=1;i<=49;i++){
gotoxy(15+i,5);
cout<<char(178);
gotoxy(15+i,22);
cout<<char(178);
gotoxy(15+i,9);
cout<<char(178); Sleep(100);
}
for(i=1;i<=18;i++){
gotoxy(16,4+i);
cout<<char(177);
gotoxy(65,4+i);
cout<<char(177); Sleep(100);
}
for(i=1;i<=3;i++){
gotoxy(33,5+i);
cout<<char(177);
gotoxy(47,5+i);
cout<<char(177);
}
63
}
/****************************************************************
ESTE PROCEDIMIENTO FORMA UN CUADRO EN PANTALLA CON UN SUBCUADRO SUPERIOR CON
LNEA DOBLE*/
void cuadro2()
{
int i;
for (i=1;i<=70;i++){
gotoxy(5+i,5);
cout<<char(205);
gotoxy(5+i,19);
cout<<char(205);
}
for(i=1;i<=13;i++){
gotoxy(5,5+i);
cout<<char(186);
gotoxy(76,5+i);
cout<<char(186);
}
gotoxy(5,19);
cout<<char(200);
gotoxy(5,5);
cout<<char(201);
gotoxy(76,5);
cout<<char(187);
gotoxy(76,19);
cout<<char(188);
for(i=1;i<=70;i++){
gotoxy(5+i,7);
cout<<char(205);
}
}
//*****************************************************************
//CUADRO CON LNEA DOBLE
void cuadrod(int fi,int ci,int ff,int cf)
{
int i;
for(i=(ci+1);i<cf;i++){
gotoxy(i,fi);
cout<<char(205);
//caracter
gotoxy(i,ff);
64
cout<<char(205);
//caracter
}
for(i=(fi+1);i<ff;i++){
gotoxy(ci,i);
cout<<char(205);
// caracter
gotoxy(cf,i);
cout<<char(205);
//
caracter
//
caracter
}
for(i=fi+1;i<ff;i++){
gotoxy(ci,i);
cout<<char(186);
gotoxy(cf,i);
cout<<char(186);
//caracter
}
gotoxy(ci,fi);
cout<<char(201);
//caracter
gotoxy(cf,fi);
cout<<char(187);
// caracter
gotoxy(ci,ff);
cout<<char(200);
//
caracter
//
caracter
gotoxy(cf,ff);
cout<<char(188);
}
/*******************************************************************
ESTE PROCEDIMIENTO GENERA UN CUADRO, DESDE UN TAMAO PEQUEO HASTA LLEGAR A UNO MS
GRANDE.
LA POSICIN DEL CUADRO ES FIJA EN LA PANTALLA*/
void cuadroMenosAmas()
{
int v,q,w,z,cont,i;
v=12;
q=12;
w=40;
z=40;
cont=1;
while(cont <=12){
clrscr();
for(i=w;i<=z;i++){
gotoxy(i,v);
cout<<'';
gotoxy(i,q);
cout<<'';
}
65
for(i=v;i<=q;i++){
gotoxy(w,i);
cout<<'';
gotoxy(z,i);
cout<<'';
}
Sleep(450);
w=w-3;
v=v-1;
z=z+3;
q=q+1;
cont=cont+1;
}
}
/***********************************************************************************
ESTE PROCEDIMIENTO COLOCA LOS CARACTERES C++, DENTRO DEL CUADRO CUADROMENOSAMAS*/
void escribeCmasMas()
{
cuadroMenosAmas();
textbackground(3);textcolor(BLUE);
gotoxy(31,4);cprintf("P R A C T I C A
1 ");
gotoxy(15,6);textcolor(LIGHTGREEN); textbackground(0);
cprintf("
");cout<<endl;
");cout<<endl;
");cout<<endl;
");cout<<endl;
gotoxy(15,7);
cprintf("
gotoxy(15,8);
cprintf("
gotoxy(15,9);
cprintf("
gotoxy(15,10);
cprintf("
");cout<<endl;
gotoxy(15,11);
cprintf("
");cout<<endl;
");cout<<endl;
");cout<<endl;
");cout<<endl;
");cout<<endl;
");cout<<endl;
gotoxy(15,12);
cprintf("
gotoxy(15,13);
cprintf("
gotoxy(15,14);
cprintf("
gotoxy(15,15);
cprintf("
gotoxy(15,16);
cprintf("
66
gotoxy(15,17);
cprintf("
");cout<<endl;
textbackground(3); textcolor(WHITE);
gotoxy(25,22);cprintf("PRESIONE TECLA PARA CONTINUAR ");
getch();
textbackground(0);
}//Fin entorno.h
//*******************************************************************
EJEMPLO 28
Validacin de nmeros enteros
Vamos a hace una demostracin de validacin de nmeros enteros (short, int, long
long, float, double y long doubl), utilizando la librera anterior ENTORNO.H.
/* PROGRAMA QUE VALIDA NMEROS ENTEROS Y REALES*/
#include"entorno.h"
int main()
{
// VALIDAR UN SHORT
Short,
num, resultado; char numc[8];
clrscr();
gotoxy(10,8);
cout<<"DIGITE UN ENTERO PARA ALMACENAR EN 16 BITS ";
cin>>numc; //Observe se lee un tipo char, usted va a trabajar con num
/*VIENE LA VALIDACIN, PRUEBE ENTRANDO LETRAS U OTROS CARACTERES
EL RANGO DE short */
TENGA CUIDADO CON
num=validarEntero(numc);/* Si se cometen errores corrjalos y si no siga trabajando

con num*/
//SIGA CON LAS DEMS INSTRUCCIONES DE SU PROGRAMA
resultado=num+50;
clrscr();
gotoxy(20,12); cout<<"EL RESULTADO ES :"<<
resultado<<endl;
system("pause");
/*************************************************************************************
*****/
/*VALIDAR UN INT*/
int numi, resultadoi;
char numci[16];
clrscr();
gotoxy(10,8);
67

cin>>numc; //Observe se lee un tipo char, usted va a trabajar con numi
/*VIENE LA VALIDACIN, PRUEBE ENTRANDO LETRAS U OTROS CARACTERES TENGA CUIDADO CON
EL RANGO DE int*/
numi=validarEntero(numc);/* Si se cometen errores corrjalos y si no siga
trabajando con numi*/
resultadoi=numi+50;
clrscr();
resultadoi<<endl;
system("pause");
/*************************************************************************************
******/
/*VALIDAR UN LONG LONG*/
long long
numl,resultadol;
char numlc[20];
clrscr();
gotoxy(10,8);
cin>>numlc; //Observe se lee un tipo char, usted va a trabajar con numl
EL
RANGO DE long*/
numl=validarEntero(numlc);/* Si se cometen errores corrjalos y si no siga

trabajando con numl*/
resultadol=numl+50;
clrscr();
gotoxy(20,12); cout<<"EL RESULTADO ES :"<<resultadol<<endl;
system("pause");
/*************************************************************************************
******/
/* VALIDAR UN FLOAT*/
float numf,resultadof;
char numfc[20];
clrscr();
gotoxy(10,8);
cout<<"DIGITE UN REAL PARA ALMACENAR EN 32 BITS ";
cin>>numfc; //Observe se lee un tipo char, usted va a trabajar con numf
EL
RANGO DE float*/
68
numf=validarReal(numfc);/* Si se cometen errores corrjalos y si no siga trabajando

con numf*/
resultadof=numf+50;
clrscr();
gotoxy(20,12); cout<<"EL RESULTADO ES :"<<resultadof<<endl;
system("pause");
/************************************************************************************
VALIDAR UN DOUBLE*/
double numd,resultadod;
char numdc[20];
clrscr();
gotoxy(10,8);
cin>>numdc; //Observe se lee un tipo char, usted va a trabajar con numd
EL
RANGO DE double*/
numd=validarReal(numdc);/* Si se cometen errores corrjalos y si no siga trabajando

con numf*/
resultadod=numd+50;
clrscr();
gotoxy(20,12); cout<<"EL RESULTADO ES :"<<resultadod<<endl;
system("pause");
/
**************************************************************************************
**/
/*VALIDAR UN LONG DOUBLE*/
long
double numld,resultadold;
char numdlc[20];
clrscr();
gotoxy(10,8);
cin>>numdlc; //Observe se lee un tipo char, usted va a trabajar con numld
EL
RANGO DE long double*/
numld=validarReal(numdlc);/* Si se cometen errores corrjalos y si no siga

trabajando con numf*/
resultadold=numld+50;
clrscr();
gotoxy(20,12); cout<<"EL RESULTADO ES :"<<resultadold<<endl;
69
system("pause");
/************************************************************************************/
/*VALIDAR REAL POSITIVO, FLOAT, DOUBLE O LONG DOUBLE*/
float numfp,resultadofp;
char numfcp[20];
clrscr();
gotoxy(10,8);
cout<<"DIGITE UN REAL POSITIVO (FLOAT) ";
cin>>numfcp; //Observe se lee un tipo char, usted va a trabajar con numfp
EL RANGO DE float*/
numfp=validarRealPositivo(numfcp);/* Si se cometen errores corrjalos y si no siga
trabajando con numf*/
resultadofp=numfp+50;
clrscr();
gotoxy(20,12); cout<<"EL RESULTADO ES :"<<resultadofp<<endl;
system("pause");
/
**************************************************************************************
***/
/*VALIDAR ENTERO POSITIVO, SHORT, INT, LONG */
int numiP, resultadoiP;
char numcP[16];
clrscr();
gotoxy(10,8);
cout<<"DIGITE UN ENTERO POSITIVO
";
cin>>numcP; //Observe se lee un tipo char, usted va a trabajar con numi

EL
RANGO DE int*/
numiP=validarEnteroPositivo(numcP);/* Si se cometen errores corrjalos y si no siga

trabajando con numi*/
resultadoiP=numiP+50;
clrscr();
resultadoiP<<endl;
system("pause");
}
EJEMPLO 29
70
Programa que utilizando la librera entorno.h valida caracteres.

/* VALIDACIN DE CARACTERES */
#include"entorno.h"
int main()
{
/*VALIDA LETRAS MAYSCULAS O MINSCULAS*/
char hilera[50];
clrscr();
cout<<"DIGITE UNA HILERA DE CARACTERES:
"; //DIGITE NOMBRES, CIUDAD ETC...
cin>>ws; cin.getline(hilera,40);/*PUEDE DIGITAR LETRAS MINSCULAS O MAYSCULAS

SOLAMENTE*/
validarCaracteres(hilera);//Si todo es correcto, NO SAC NINGN ERROR, siga
trabajando
cout<<"\n\n USTED DIGITO "<<hilera<<endl;/* Nota: esto no es necesario en su
programa*/
system("pause");
/*********************************************************************************
VALIDA QUE LAS LETRAS SOLO SEAN MAYSCULAS */
char hileram[50];
clrscr();
cout<<"DIGITE UNA HILERA DE CARACTERES:
"; //DIGITE NOMBRES, CIUDAD ETC...
cin>>ws; cin.getline(hileram,40);/*PUEDE DIGITAR LETRAS
MAYSCULAS
SOLAMENTE*/
validarMayusculas(hileram);/*Si todo es correcto, NO SAC NINGN ERROR, siga
trabajando*/
cout<<"\n\n USTED DIGITO "<<hileram<<endl;/* Nota: esto no es necesario en su
programa*/
system("pause");
}
EJEMPLO 30
Ejemplo que muestra los cuadros que estn en la librera entorno.h uno por uno.
/* DEMOSTRACIN DE DIVERSOS CUADROS EN LA PANTALLA*/
#include"entorno.h"
int main()
{
/* USO cuadros(fi,ci,ff,cf);
71
CUADRO QUE INICIA EN LA FILA 6, COLUMNA 20 Y FINALIZA EN LA FILA 18, COLUMNA 60

OBSERVE QUE ESTOS VALORES LOS PUEDE VARIAR USTED*/
clrscr();
cuadros(6,20,18,60);
gotoxy(38,7);
cout<<"MENU";
gotoxy(22,8);
cout<<"1: DEMOSTRACION";
gotoxy(20,24);
system("pause");
/* USO
cuadro1();
DIBUJA UN CUADRO CON LNEA SENCILLA EN LA PANTALLA CON COORDENADAS FIJAS*/

clrscr();
cuadro1();
gotoxy(18,7);
cout<<"SEPTIEMBRE";
gotoxy(41,7);
cout<<"20";
gotoxy(54,7);
cout<<"2011";
gotoxy(39,10); cout<<"MENU";
gotoxy(20,24);
system("pause");
/***********************************************************************************
USO cuadro1();
DIBUJA UN CUADRO CON COORDENADAS FIJAS EN LA PANTALLA, CON LNEA DOBLE*/
clrscr();
cuadro2();
gotoxy(8,6);
cout<<" PROGRAMA QUE CALCULA UNA FACTURA";
gotoxy(41,7);
gotoxy(39,8); cout<<"MENU";
gotoxy(20,24);
system("pause");
/******************************************************************************
USO cuadrod(fi,ci,ff,cf);
CUADRO QUE SE DIBUJA EN LA PANTALLA CON LNEA DOBLE ENLA FILA fi, COLUMNA ci HASTA
LA FILA ff,
COLUMNA fc, con lnea doble, LO DIBUJAMOS DESDE LA FILA 6, COLUMNA 20, HASTA
LA FILA 18, COLUMNA 60. RECUERDE QUE USTED PUEDE MODIFICAR EL
TAMAO DEL
CUADRO Y SU POSICIN*/
72
clrscr();
cuadrod(6,20,18,60);
gotoxy(38,7);
cout<<"MENU";
gotoxy(22,8);
gotoxy(20,24);
system("pause");
/*Uso cuadroMenosAmas();
/* Este cuadro comienza a formarse desde un tamao pequeito y va creciendo hasta
formarse el cuadro total*/
clrscr();
cuadroMenosAmas();
gotoxy(38,3);
cout<<"MENU";
gotoxy(10,6);
gotoxy(20,24);
system("pause");
/* Este procedimiento coloca las letras C++, dentro del cuadroMenosAmas()*/
clrscr();
escribeCmasMas();
}
5. EXCEPCIONES
El problema de la seguridad es uno de los clsicos quebraderos de cabeza de la
programacin. Los diversos lenguajes han tenido siempre que lidiar con el mismo
problema: qu hacer cuando se presenta una circunstancia verdaderamente
imprevista? (por ejemplo un error). El asunto es especialmente importante si se
trata de lenguajes para escribir programas de "Misin crtica"; digamos por ejemplo,
controlar los ordenadores de una central nuclear o de un sistema de control de
trfico areo.
Antes que nada, digamos que (en el lenguaje de los programadores C++) estas
"circunstancias imprevistas" reciben el nombre de excepciones, por lo que el
sistema que implementa C++ para resolver estos problemas recibe el nombre de
manejador de excepciones.
As pues, las excepciones son condiciones
73
excepcionales que pueden ocurrir dentro del programa durante su ejecucin. Por
ejemplo, que ocurra una divisin por cero, se agote la memoria disponible, etc., que
requieren recursos especiales para su control.
En este captulo trataremos el manejador de excepciones C++; una serie de
tcnicas que permiten formas normalizadas de manejar los errores, intentando
anticiparse a los problemas potenciales previstos e imprevistos; as como permitir
al programador reconocerlos, fijar su ubicacin y corregirlos.
5.1. MANEJADOR DE EXCEPCIONES

El manejo de excepciones C++ se basa en un mecanismo cuyo funcionamiento
tiene tres etapas bsicas:
1. Se intenta ejecutar un bloque de cdigo y se decide qu hacer si se produce
una circunstancia excepcional durante su ejecucin.
2. Se produce la circunstancia: se "lanza" una excepcin (en caso contrario el
programa sigue su curso normal).
3. La ejecucin del programa es desviada a un sitio especfico donde la
excepcin es "capturada" y se decide qu hacer al respecto.
Pero qu es eso de "lanzar" y "capturar" una excepcin"? En general, la frase se
usa con un doble sentido: por un lado es un mecanismo de salto que transfiere la
ejecucin desde un punto (que "lanza" la excepcin), a otro dispuesto de antemano
para tal fin (que "captura" la excepcin). A este ltimo se le denomina manejador o
"handler" de la excepcin.
Adems del salto -como un goto-, en el punto de lanzamiento de la excepcin se
crea un objeto, a modo de mensajero, que es capturado por el "handler" (como una
funcin que recibe un argumento). El objeto puede ser cualquiera, pero lo normal
es que pertenezca a una clase especial definida al efecto, que contiene la
informacin necesaria para que el receptor sepa qu ha pasado; cul es la
naturaleza de la circunstancia excepcional que ha "lanzado" la excepcin.
Para las tres etapas anteriores existen tres palabras clave especficas: try, throw y
catch.
5.1.1. TRY
En sntesis, cuando el programa se prepara para cierta accin, decimos que "lo
intenta". Para ello se especifica un bloque de cdigo cuya ejecucin se va a intentar
("try-block") utilizando la palabra clave try.
try {
...
}
// bloque de cdigo-intento
74
El juego consiste en indicar al programa que, si existe un error durante el "intento",

entonces debe lanzar una excepcin y transferir el control de ejecucin al punto
donde exista un manejador de excepciones ("handler") que coincida con el tipo
lanzado. Si no se produce ninguna excepcin, el programa sigue su curso normal.
De lo dicho se deduce inmediatamente que se pueden lanzar excepciones de varios
tipos y que pueden existir tambin receptores (manejadores) de varios tipos;
incluso manejadores "universales", capaces de hacerse cargo de cualquier tipo de
excepcin. A la inversa, puede ocurrir que se lance una excepcin para la que no
existe manejador adecuado.
As pues, try es una sentencia que, en cierta forma, es capaz de especificar el flujo
de ejecucin del programa. Un bloque-intento debe ser seguido inmediatamente
por el bloque manejador de la excepcin.
5.1.2. THROW
Si se detecta una circunstancia excepcional dentro del bloque-intento, se lanza una
excepcin mediante la ejecucin de una sentencia throw. Por ejemplo:
if (condicion) throw "overflow";
Es importante advertir que, salvo los casos en que la excepcin es lanzada por las
propias libreras C++ (como consecuencia de un error 1.6.1a), stas no se lanzan
espontneamente.
Es el programador el que debe utilizar una sentencia
(generalmente condicional) para, en su caso, lanzar la excepcin.
El lenguaje C++ especifica que todas las excepciones deben ser lanzadas desde el
interior de un bloque-intento y permite que sean de cualquier tipo. Como se ha
apuntado antes, generalmente son un objeto (instancia de una clase) que contiene
informacin. Este objeto es creado y lanzado en el punto de la sentencia throw y
capturado donde est la sentencia catch. El tipo de informacin contenido en el
objeto es justamente el que nos gustara tener para saber qu tipo de error se ha
producido. En este sentido puede pensarse en las excepciones como en una
especie de correos que transportan informacin desde el punto del error, hasta el
sitio donde esta informacin puede ser analizada.
5.1.3. CATCH
Esta parte del programa se denomina manejador ("handler"). Se dice que el
"handler" captura la excepcin. El handler es un bloque de cdigo diseado para
manejar la excepcin, precedido por la palabra catch. El lenguaje C++ requiere
75
que exista al menos un manejador inmediatamente despus de un bloque try, es

decir, se requiere el siguiente esquema:
try {
// bloque de cdigo que se intenta
...
}
catch (...) { // bloque manejador de posibles excepciones
...
}
...
// contina la ejecucin normal
El "handler" es el sitio donde contina el programa en caso de que ocurra la

circunstancia excepcional (generalmente un error) y donde se decide qu hacer. A
este respecto, las estrategias pueden ser muy variadas (no es lo mismo el programa
de control de un reactor nuclear, que un humilde programa de contabilidad). En
ltimo extremo, en caso de errores absolutamente irrecuperables, la opcin
adoptada suele consistir en mostrar un mensaje explicando el error. Puede incluir el
consabido "Avise al proveedor del programa" o bien generar un fichero texto (por
ejemplo: error.txt) con la informacin pertinente, que se guarda en disco con objeto
de que pueda ser posteriormente analizado y corregido en sucesivas versiones de la
aplicacin.
Llegados a este punto debemos recordar que, como veremos en los ejemplos, las
excepciones generadas pueden ser diversas (segn el tipo de error), y que tambin
pueden existir mltiples manejadores. De hecho, se debe incluir el manejador
correspondiente a cada excepcin que se pueda generar.
EJEMPLO 31
#include <iostream>
int main() {
try {
throw 'a'; // valor de tipo char
}
catch(char c) {
cout << "El valor de c es: " << c << endl;
}
catch(int n) {
cout << "El valor de n es: " << n << endl;
}
system("pause");
return 0;
}
6. ARREGLOS
76
Un arreglo es un conjunto de datos finitos que se almacenan en memoria de

manera contigua con el mismo nombre y todos con el mismo tipo de datos y que se
diferencian unos de otros, de acuerdo con un ndice o subndice que va despus del
nombre del arreglo, encerrado entre corchetes.
Los valores pertenecientes a un arreglo se almacenan en la memoria principal, por
lo tanto su almacenamiento es temporal.
Para manejar en forma independiente cada componente del arreglo, se usa un
ndice, que es una expresin de tipo entero (sin decimales), que indica cul de los
elementos del arreglo queremos relacionar. Siempre que se quiere trabajar o
mencionar una componente es necesario adicionar el ndice al nombre genrico del
arreglo; es ste el que hace independiente una de otra.
Ejemplos de ndices:
1
IND
k+I
I * jota - 1
6.1. CLASIFICACIN DE LOS ARREGLOS

6.1.1. ARREGLOS DE UNA DIMENSIN O VECTORES
Un vector es un arreglo donde los elementos que lo conforman estn dispuestos
bajo un mismo orden de clasificacin (fila o columna), es decir, los datos estn
organizados de una manera lineal, por lo que, para referenciar un elemento del
arreglo, es necesario un ndice que indique la posicin relativa del elemento en el
arreglo.
Cuando al nombre del arreglo se le adiciona el ndice, la componente a la cual hace
referencia el ndice es tomada como una variable simple, igual a las que en
captulos anteriores se han venido tratando; por lo tanto, puede estar involucrada
en una expresin, en una entrada o salida de datos, o en una asignacin.
En C++ los arreglos
elementos.
inician con el ndice 0 hasta n-1, si el arreglo tiene n
Definicin de un vector
Sintaxis:
Tipo de dato Nombre del arreglo[cantidad de elementos a separar en memoria];
Por ejemplo definir un vector que pueda almacenar hasta
elementos de tipo flotante.
20 posiciones o
float valores[20];
77
Tambin se puede definir en una forma dinmica y, en este caso, puede almacenar
cualquier cantidad de elementos, es decir, no se tiene la limitante de memoria
separada y se define as:
float *valores;
Donde valores es un nombre general y, para tener acceso a su contenido, hay que
hacerlo elemento a elemento.
Donde valores[0] hace referencia al valor almacenado en la posicin cero, cada
posicin del arreglo valores tiene un tamao de 4 bytes (cantidad de memoria que
asigna el tipo de dato).
char nombre[48];
Define el arreglo nombre, donde se pueden almacenar hasta 48 caracteres.

En este caso, nombre[5] hace referencia al caracter 6 almacenado en el vector
nombre y tendr un tamao de un byte. Es el tipo de dato del arreglo quien
determina la cantidad de memoria asignada a cada posicin o elemento.
Grficamente un vector puede ser representado en cualquiera de las siguientes
formas:
Los arreglos pueden ser utilizados como acumuladores o contadores, inicializando

cada uno de sus elementos.
Ejemplo de asignacin de valores
Llevar cero a cada uno de los elementos de un arreglo EDAD de 5 posiciones.
//Solucin utilizando MIENTRAS

#include<iostream>
78
#include<conio2.h>
int main()
{
int indice=0;
int edad[5];
while(indice<5)
{
edad[indice]=0;
indice++;
}
}
//Solucin utilizando PARA

#include<iostream>
#include<conio2.h>
int main()
{
int indice;
int edad[5];
for(indice=0;indice<5;indice++)
{
edad[indice]=0;
}
}
Ejemplo 32
Elaborar un programa que encuentre la suma y el promedio de N valores que se
almacenarn en un vector.
n:
nmero de elementos del arreglo
k:
variable de tipo contador, utilizada como controladora de los

ciclos PARA y MIENTRAS.
v:
nombre del vector
suma:
sumatoria de los elementos impares del arreglo V
prom:
promedio de los elementos impares
Observe que, en el programa, separamos 50 posiciones para el vector v y sta ser

la cantidad mxima de valores que se podrn almacenar; pero si el usuario, cuando
se le pidan la cantidad de valores que l tiene nos dice que 5, solo las primeras 5
posiciones del vector estarn llenas, las 45 restantes estarn vacas.
#include<iostream>
#include<conio2.h>
int main()
79
{
int n, k,; float v[50], suma=0, prom;
clrscr(); textbackground(0);
textbackground(WHITE); textcolor(6); gotoxy(20,12);
cprintf("ENTRE LA CANTIDAD DE ELEMENTOS:
");
gotoxy(51,12); cin>>n; textbackground(0);
for(k=0; k<n; k++) //C++ ALMACENA LOS ARREGLOS DESDE LA POSICIN 0
{
textbackground(0);
clrscr(); textbackground(WHITE); textcolor(RED);
gotoxy(20,12);
cout<<"ENTRE EL ELEMENTO: " <<k+1<<" DEL VECTOR:
";
cin>>v[k];
suma+=v[k];
}
prom=suma/n;
textcolor(YELLOW);
gotoxy(30,11); cout.precision(2); cout.setf(ios::fixed);
//coloca dos decimales y obliga a que se pongan los ceros, si no hay decimales
cprintf("LA SUMA ES:
"); gotoxy(41,11); cout<<suma;
gotoxy(30,13);
cprintf("Y EL PROMEDIO ES:
"); gotoxy(47,13); cout<<prom;
gotoxy(30,24); cprintf("PRESIONE TECLA PARA TERMINAR");
getch();
}
Ejemplo 33
Hacer un algoritmo que calcule el valor promedio, la varianza y la desviacin tpica
de un grupo de datos enteros positivos, dispuestos de a uno, por registro.
dato:
cada uno de los valores del grupo.
n:
contador de valores e ndice del vector, que al final del ciclo cualitativo
de entrada de datos, tendr almacenado la cantidad de elementos
almacenados en el vector.
x:
nombre del vector
suma1:
sumatoria de los valores para el clculo del promedio.
prom:
promedio del grupo de datos
i:
variable de control del ciclo PARA
suma2:
variable suma1?
sumatoria para calcular la varianza. Puede utilizarse la misma
var:
varianza del grupo de valores
dt:
desviacin tpica
#include<iostream>
#include<conio2.h>
#include<math.h>
int main()
80
{
int dato, n=-1, i; long suma1=0;
int x[50]; float var, prom, dt,suma2=0;
gotoxy(20,12); textcolor(LIGHTGREEN);
cprintf("ENTRE UN DATO O CERO PARA TERMINAR:
");
gotoxy(55,12); cin>>dato;
while(dato !=0)
{
suma1+=dato;
n++;
x[n]=dato;textbackground(0);
clrscr();
gotoxy(20,12); textcolor(LIGHTGREEN); textbackground(6);
cprintf("ENTRE UN DATO O CERO PARA TERMINAR:
");
textbackground(0); gotoxy(55,12); cin>>dato;
}
n++;
prom=float (suma1)/(n);
for(i=0; i<n; i++)
suma2+=pow(x[i] - prom,2);
var=float(suma2)/(n-1);
dt=sqrt(var); cout.precision(2);
clrscr(); textbackground(WHITE);
textcolor(RED);
gotoxy(10,12);
cprintf("PROMEDIO=
VARIANZA=
");
cprintf("DESVIACIN TPICA=
");
gotoxy(19,12); cout<<prom;
//Escribe despus de PROMEDIO
gotoxy(37,12); cout<<var;
//Escribe despus de VARIANZA
gotoxy(67,12); cout<<dt;
//Escribe despus de DESVIACIN TPICA
getch();
}
Ejemplo 34
Elaborar una funcin que encuentre la posicin del mayor elemento de un vector de
tamao N y el programa que la invoque;
#include<iostream>
#include<conio2.h>
int posmay(int n, float vec[])
//vec toma cualquier cantidad de elementos que

//se le enven
{
//n tamao del vector; vec: el vector; mayor: asume el valor mayorv del vector
//posm: posicin dentro del vector donde est el valor mayor
int i, posm=0; float mayor;
mayor=vec[0];
for(i=1; i<n; i++)
if(mayor < vec[i])
{
mayor=vec[i];
posm=i;
}
return posm;
}
81
6.1.1.1 OPERACIONES BSICAS CON VECTORES

int
{
main()
//tv tamao del vector; posmayor: posicin donde est el valor mayor: a: el
//vector
int tv,i,posmayor; float a[50];
clrscr();
textbackground(0); textcolor(LIGHTGREEN); textbackground(CYAN);
gotoxy(20,12);
cprintf("ENTRE LA CANTIDAD DE ELEMENTOS:
");
textbackground(0); gotoxy(51,12); cin>>tv;
for(i=0; i<tv; i++)
{
clrscr(); gotoxy(20,12); textbackground(RED);
cout<<"ENTRE EL ELEMENTO: "<<i+1<<" DEL VECTOR: ";
cin>>a[i]; textbackground(0);
}
textbackground(0);
posmayor=posmay(tv,a); clrscr();
clrscr(); gotoxy(15,12);
cprintf("EL VALOR MAYOR EST EN LA POSICIN:
DEL VECTOR");
textbackground(0); gotoxy(50,12); cout<<posmayor;
textbackground(0); getch();
Bsqueda
Ordenacin
Insercin
Borrado
Estas operaciones se implementarn en una librera de nombre: libVector, que se

construye ms adelante. Esta librera contendr los siguientes subprogramas:
leerVector, imprimirVector, ordenBurbuja, ordenSeleccion, insertar, busuedaSec,
busquedaBin, borrar.
BSQUEDA
La bsqueda consiste en encontrar un determinado valor dentro de un conjunto de
datos, para recuperar alguna informacin asociada con el valor buscado.
Existen diferentes formas de hacer esta operacin, en este manual implementamos
las dos primeras: secuencial y binaria.
Bsqueda Secuencial o lineal
Bsqueda Binaria
Bsqueda HASH
rboles de bsqueda
82
Bsqueda secuencial. Es una tcnica sencilla para buscar un elemento dentro de

un arreglo y consiste en recorrer todo el vector, elemento a elemento, desde el
primero hasta el ltimo. Si se encuentra el valor buscado, el proceso devolver la
posicin donde se encuentra dicho elemento, de lo contrario se enviar un mensaje
que informe que el valor buscado no se encuentra dentro del arreglo.
Bsqueda binaria. Note que, en la bsqueda secuencial, cuando no se encuentra
el valor buscado, en el peor de los casos, hay que recorrer todo el vector. Esto hace
que el proceso no tenga gran eficiencia, sobre todo cuando el tamao del vector es
muy grande. El mtodo de bsqueda binaria consiste en dividir el vector en dos
partes y comparar el valor buscado con el elemento que est en la mitad del
arreglo; si no hay coincidencia, entonces se determina si el valor buscado est en la
primera mitad del arreglo o en la segunda mitad, eliminando con ello la bsqueda
en cualquiera de las dos mitades. Se coge la mitad donde posiblemente se
encuentra el valor buscado y se repite la misma comparacin arriba mencionada.
Con esta nueva comparacin se elimina nuevamente la mitad de los datos que
quedaron. El proceso contina hasta que se d una coincidencia, o se pueda decir
que el valor buscado no est en el vector. Para poder hacer bsqueda binaria
primero hay que ordenar el vector; si el vector no est ordenado, no se puede
determinar en cul de las mitades se encuentra el valor que se desea buscar.
ORDENACIN
La ordenacin se refiere a la operacin de organizar los elementos de un vector en
algn orden dado: ascendente o descendente. Si el ordenamiento es creciente o
ascendente, significa que hay que organizar sus elementos de tal manera que:
A[0] < A[1] < A[2] < A[3] ..........< A[N-1].
Si el ordenamiento es ascendente significa que:
A[0] > A[1] > A[2] > A[3] ..........> A[N-1].
Existen diferentes modelos para organizar los elementos de un arreglo:
Los mtodos ms comunes son:
Mtodo Burbuja
Mtodo de Burbuja Mejorado
Ordenacin por Seleccin
Insercin o Mtodo de la Baraja
Shell
Binsort O por Urnas
Por Monticulos o Heapsort
Por Mezcla o Mergesort
Mtodo de la Sacudida o Shackersort
Rapid Sort o Quick Sort
Por rboles
83
Vamos a implementar dos de los mtodos de ordenamiento: burbuja y seleccin. Se

invita al lector a investigar los dems mtodos.
Ordenacin por burbuja. Es un mtodo poco eficiente. Se basa en comparar
elementos adyacentes del vector e intercambiar sus valores, si estn desordenados.
Los valores ms pequeos burbujean hacia el inicio del vector (ordenacin
ascendente), mientras que los valores ms grandes comienzan a subir hacia la
parte final del vector.
Por ejemplo, se compara A[1| con A[2]; si estn
desordenados se intercambian A[1] con A[2] y as sucesivamente a lo largo del
vector. Al terminar la primera pasada, el elemento mayor se encuentra al final y el
menor ha ido descendiendo hacia el principio del vector. Se vuelve a hacer una
nueva exploracin, comparando elementos consecutivos e intercambiando; pero
esta vez el elemento mayor no se compara (est en su posicin correcta). El vector
quedar ordenado cuando se hayan hecho N-1 pasadas. Si los valores del vector
son:
80
55
35
21
15
55
80
35
21
15
55
35
80
21
15
55
35
21
80
15
55
35
21
15
80
Vector original de tamao 5 (N)
Se necesitaron 4 comparaciones (N-1) para colocar el valor mayor de ltimo.

En la segunda pasada ocurrir lo siguiente:
35
55
21
15
80
35
21
55
15
80
35
21
15
55
80
Tercera pasada:
21
35
15
55
80
21
15
35
55
80
55
80
Cuarta pasada:
15
35
En total se necesitaron cuatro pasadas para ordenar un vector de 5 elementos.

Ordenamiento por seleccin. Este mtodo se basa en buscar el menor valor de
todo el vector e intercambiarlo con el elemento que se encuentra en la posicin
uno. Para encontrar este valor se asume que el menor de todo del grupo es el que
est en la posicin cero, y se recorre todo el vector a partir de la posicin uno en
adelante; cuando se encuentre un valor menor que l, se le cambia el valor a la
variable donde se ha guardado el supuesto menor. Luego se busca el segundo
menor asumiendo que es el elemento ubicado en la posicin uno, y se recorre todo
el vector a partir de la posicin dos en adelante, haciendo el cambio respectivo
cuando se encuentre un valor menor que l. Una vez encontrado el segundo menor
84
se intercambia con el valor ubicado en la posicin uno del vector. El proceso de

bsqueda de menores se hace N-1 veces.
Por cada menor buscado hay que guardar en una variable la posicin donde se
encuentra ese menor.
Ejemplo. Si el vector a ordenar es: 10 20 1 3 0 sucedera lo que se muestra en el
siguiente grfico.
Note que, despus del cuarto intercambio, el elemento ubicado en la posicin cinco,
de por s queda ordenado; adems no hay ms elementos con quien compararlo y
se termina el proceso, despus de hacer N-1 intercambios, o buscado N-1 menores.
Ejemplo 35
Construir la librera libVector.h:
#include<iostream>
#include<conio2.h>
void leerVector(int n, float vec[])
{
int i;
for(i=0; i<n;i++)
{
cout<<"DIGITE EL ELEMENTO. "<<i+1<<" ";
cin>>vec[i];
}
}
//**************************************************************************
void imprimirVector(int n, float vec[])
{
int i;
clrscr();
gotoxy(15,5);
cout<<"ELEMENTOS DEL VECTOR ";
for(i=0;i<n;i++)
cout<<vec[i]<<" ";
}
//******************************************************************
85
//FUNCIN QUE BUSCA UN VALOR EN UN VECTOR, USANDO EL MTODO DE

//BSQUEDA SECUENCIAL, RETORNA LA POSICIN DONDE SE ENCUENTRA EL
//VALOR BUSCADO O, -1 SI NO LO ENCUENTRA
int busquedaSec(int n, float vec[], float valorb)
{
//valorb: valor a buscar dentro del vector
int i=0;
while((i < n) && (valorb != vec[i]))
i++;
if(i < n)
return i;
else
return -1;
}//FIN BUSQUEDASEC
//******************************************************************
//FUNCIN QUE BUSCA UN VALOR EN UN VECTOR, USANDO EL MTODO DE
//BSQUEDA BINARIA, RETORNA LA POSICIN DONDE EST EL VALOR BUSCADO
// O -1 SI NO LO ENCUENTRA.
//**********************************************************************
int busquedaBin(int n, float a[], float valorbuscado)
{
int p=0, u=n-1, sw=0, mitad;
while((p <= u) && (sw==0))
{
mitad=(p + u)/2;
if(a[mitad] == valorbuscado)
sw=1;
else
if(valorbuscado < a[mitad])
u=mitad-1;
else
p=mitad+1;
}
if(valorbuscado==a[mitad])
return mitad;
else
return -1;
}
//**********************************************************************
//PROCEDIMIENTO QUE ORDENA UN VECTOR POR EL MTODO DE BURBUJA
void ordenBurbuja(int n, float a[])
{
int i, j; float aux;
for(i=0; i< (n-1); i++)
for(j=0; j < (n-(i+1)); j++)
if(a[j] > a[j+1])
{
aux=a[j];
a[j]=a[j+1];
a[j+1]=aux;
}
}
//PROCEDIMIENTO QUE ORDENA UN VECTOR POR EL MTODO DE SELECCIN
//
SE LE PUEDE ENVIAR UN ARGUMENTO LONG O DOUBLE
void ordenSeleccion(int n, float a[])
{
int i, k, pos; float aux,menor;
for(i=0; i< n-1; i++)
{
menor=a[i];
86
pos=i;
for(k=i+1; k<n; k++)
if(menor > a[k])
{
menor=a[k];
pos=k;
}
aux=a[i];
a[i]=menor;
a[pos]=aux;
}
}
//****************************************************************
//*****************************************************************
//PROCEDIMIENTO QUE INSERTA UN VALOR EN UN VECTOR ORDENADO
//SIN DAAR EL ORDENAMIENTO
void insertar(int &tv, float a[], float valin)//valin: valor a insertar
{
int i=0, k;
while((i< tv) && (valin > a[i]))
i++;
tv++;
for(k=(tv-1); k > i; k--)
a[k]=a[k-1];
a[i]=valin;
}
//**************************************************************
//PROCEDIMIENTO QUE BORRA UN VALOR EN UN VECTOR
void borrar(int &tv, float a[], float valorb)//valorb: valor a borrar
{
int i=0, k;
if(tv > 0)
{
while((i < tv) && (valorb != a[i]))
i++;
if(i < tv)
{
for(k=i; k < (tv-1); k++)
a[k]=a[k+1];
tv--;
}
else
{
clrscr();
textcolor(WHITE); textbackground(RED);
gotoxy(20,12); cout<<valorb;
cprintf(" NO EST EN EL ARREGLO");textbackground(0);
}
}
else
{
clrscr();
textcolor(WHITE); textbackground(RED);
gotoxy(20,12);
cprintf(" EL VECTOR EST VACO");cout<<endl;
}
system("pause");
}//fin borrar
Ejemplo 36
87
Elaborar un programa que incluya la librera libVector y, mediante un MEN, hacer

las siguientes operaciones:
1. Leer un vector de tamao N
2. Imprimir el vector
3. Ordenar el vector en forma ascendente por cualquiera de los mtodos de
ordenacin expuestos.
4. Insertar un nuevo elemento sin daar el ordenamiento.
5. Buscar un valor en el arreglo por el mtodo de bsqueda binaria.
6. Borrar un elemento del vector
#include"libVector.h"
#include<windows.h>
int main()
{
int n,opcion, opcion1,resp;
float a[100],valbus,valbo,valin; //valbus:Valor a buscar; valbo:Valor a borrar
char siga; //valin:Valor a insertar
textcolor(CYAN); clrscr();
gotoxy(20,12);textbackground(RED);
cprintf("ENTRE EL TAMAO DEL VECTOR:
");
do
{
clrscr();
textcolor(RED); textbackground(WHITE);
gotoxy(38,7); cprintf("MENU"); Sleep(100);
gotoxy(29,11); cprintf(" 1: LEER
EL
VECTOR");Sleep(100);
gotoxy(29,12); cprintf(" 2: IMPRIMIR EL VECTOR");Sleep(100);
gotoxy(29,13); cprintf(" 3: ORDENAR
EL VECTOR");Sleep(100);
gotoxy(29,14); cprintf(" 4: INSERTAR
ORDENADO");Sleep(100);
gotoxy(29,15); cprintf(" 5: BUSCAR
UN
VALOR");Sleep(100);
gotoxy(29,16); cprintf(" 6: BORRAR UN ELEMENTO");Sleep(100);
gotoxy(29,17); cprintf(" 7: SALIR DEL PROGRAMA");Sleep(100);
gotoxy(27,20); cprintf("ELIJA SU OPCION ENTRE 1 Y 7");
gotoxy(56,20); cprintf(" ");
gotoxy(56,20);cin>>opcion;
switch (opcion)
{
case 1:
clrscr();
leerVector(n,a);
break;
case 2:
clrscr();
imprimirVector(n,a);
cout<<"\n\n\n";
system("pause");
break;
case 3:
do
{
clrscr();
textcolor(RED);
gotoxy(38,7);cprintf("MENU"); Sleep(100);
gotoxy(29,11);
cprintf(" 1: BURBUJA");Sleep(100);
88
gotoxy(29,12);
cprintf(" 2: SELECCION");Sleep(100);
gotoxy(29,13);
cprintf(" 3: VOLVER AL MENU PPAL");Sleep(100);
gotoxy(29,16);
cout<<"ELIJA SU OPCION ENTRE 1 Y 3 ";
cin>>opcion1;
switch (opcion1)
{
case 1:
ordenBurbuja(n,a);
break;
case 2:
ordenSeleccion(n,a);
break;
case 3:
gotoxy(20,12);
cprintf("REGRESA AL MENU PRINCIPAL");Sleep(500);
textbackground(0);
break;
} //FIN CASOS 2
}while(opcion1 !=3);
break;
case 4:
gotoxy(20,12); textbackground(RED);
cout<<"ENTRE EL VALOR A INSERTAR: ";
cin>>valin;
insertar(n,a,valin);
break;
case 5:
gotoxy(20,12); textbackground(WHITE);
cout<<"ENTRE EL VALOR A BUSCAR: ";
cin>>valbus;
resp=busquedaBin(n,a,valbus);
if(resp !=-1)
{
gotoxy(20,12); textbackground(WHITE);
cout<<valbus<<" ESTA EN LA POSICION "<<
resp<<" DEL VECTOR:"; textbackground(0);
}
else
{
textcolor(CYAN);
gotoxy(20,12);
cout<<valbus<<" NO ESTA EN EL VECTOR"<<endl;
}
cout<<"\n\n\n";
system("pause");
break;
case 6:
gotoxy(20,12); textbackground(RED);
cout<<"ENTRE EL VALOR A BORRAR: ";
cin>>valbo;
89
borrar(n,a,valbo);
break;
case 7:
cout<<"ESTA SEGURO QUE DESEA SALIR S/N? ";
cin>>siga;
if(toupper(siga)=='N')
opcion=1;
break;
}
}while(opcion!=7);
}
Ejemplo 37
Disear un subprograma que, dado un vector que pueda contener elementos
duplicados diferentes de cero, reemplace cada elemento repetido por un cero y
encuentre el nmero de modificaciones realizadas.
#include<iostream>
#include<conio2.h>
#include"libVector.h"
void cambio(int n, float vec[],int &nm)
{
int k,l; nm=0;
for(k=0; k< (n-1); k++)
for(l=k+1; l< n; l++)
if((vec[k]==vec[l]) && (vec[k]!=0))
{
vec[l]=0; nm++;
}
}
//************************************************************************
int main()
{
int n, nummod; float a[100];
textbackground(0); textcolor(LIGHTRED);
cprintf("DIGITE LA CANTIDAD DE ELEMENTOS DEL VECTOR:
");
gotoxy(58,12); cin>>n; clrscr();
leerVector(n,a);
cambio(n,a,nummod);
cout<<"\n\n NUEVOS ELEMENTOS DEL VECTOR"<<endl<<endl;
imprimirVector(n,a);
cout<<"\n\n\n";
system("pause");
clrscr();
textbackground(CYAN); textcolor(LIGHTRED);
gotoxy(20,12);
cprintf("EL NUMERO DE MODIFICACIONES FUE:
");
gotoxy(52,12); cout<<nummod;
getch();
}
90
6.1.2. ARREGLOS DE DOS DIMENSIONES O MATRICES

Las matrices son estructuras de datos que organizan su informacin en
tablas, es decir, los elementos que la conforman estn dispuestos
conceptos de clasificacin (fila y columna). Para poder indicar el lugar
encuentra un determinado elemento, es necesario utilizar dos ndices:
indicar el rengln o fila y otro para indicar la columna.
forma de
bajo dos
donde se
uno para
Puede mirarse una matriz como un vector de vectores, por lo tanto, es un conjunto
de componentes en el que se necesitan dos subndices para identificar un elemento
que pertenezca al arreglo.
Un arreglo bidimensional N * M tiene N filas y M columnas, por lo tanto, tiene N * M
elementos dispuestos interiormente en memoria en forma sucesiva. Grficamente
se puede representar como una tabla de valores. Si A es una matriz de 5 * 7 se
representar as:
Columna 6
Columna 5
Columna 4
Columna 3
Columna 2
Columna 1
Columna 0
El arreglo anterior tiene 35 elementos, todos ellos con el nombre A y se diferencian

entre s, por dos ndices; el primero indica la fila donde est ubicado el elemento y
el segundo la columna. El elemento A[2, 4] hace referencia al contenido del
elemento ubicado en la fila 2 columna 4.
En general, se puede decir que el elemento i, j de un arreglo bidimensional hace
referencia al contenido del elemento ubicado en la fila i, columna j. Para llevar
informacin a todo el arreglo, se puede hacer de dos formas:
1. Una ser llenando primero la fila cero, luego la fila 1, hasta la fila N-1;
91
2. La otra sera llenando primero la columna cero, luego la uno y as

sucesivamente hasta llenar la columna M-1; todo depender de la forma
como se encuentren dispuestos los datos en el archivo de entrada. Por
ejemplo: llevar informacin a una matriz A de 3 * 2, por filas.
Para resolver el problema se necesitan dos ciclos, uno externo que controle las filas
y otro interno que, por cada valor que tome la variable de control del ciclo externo,
recorra todas las columnas.
El algoritmo sera:
for(i=0; i <3; i++)

for(j = 0; j<2; j++)
cin>> A[I][J];
Si se utiliza el ciclo for, o el siguiente si se utiliza el ciclo while.

i = 0;
while (I <3 )
{
j = 0;
while(J <2)
{
cin>> A[i][j];
j = j+1;
}
i = i+1;
}*
Existen varios tipos de matrices.

Matriz cuadrada. Una matriz es cuadrada cuando el nmero de filas es igual al
nmero de columnas. Por lo tanto, los elementos ubicados en la diagonal principal,
cumplen que la fila es igual a la columna.
Matriz identidad (I). Es tambin una matriz cuadrada donde los elementos que
estn ubicados en la diagonal principal son 1 y, el resto de elementos, tienen un
valor de 0.
Matriz transpuesta. La matriz transpuesta A T de la matriz A de cualquier orden, es
aquella en la cual las filas de una matriz son las columnas de la otra.
Matriz simtrica. La matriz simtrica debe cumplir la condicin de que el elemento
X[I][ K] = X[K][ I] para una matriz N * M .
Matriz inversa. Es una matriz A que se representa por A -1 y tal que X * X1 = I,
donde I es la matriz identidad.
Ejemplo 38
Elaborar un programa que ingrese los elementos por columnas de una matriz A de
orden N y luego encuentre la suma de los elementos ubicados en la diagonal
principal y la suma de los elementos ubicados en la diagonal secundaria.
92
#include<iostream>
#include<conio2.h>
int main()
{
int n, k,i; float a[50][50], sumap,sumas;
clrscr();
textcolor(MAGENTA); textbackground(WHITE);
gotoxy(20,12); cprintf("DIGITE EL ORDEN DE LA MATRIZ:
");
gotoxy(48,12); cin>>n;
for(k=0;k<n; k++)
for(i=0; i<n; i=i+1)
{
clrscr();
gotoxy(20,12);
cout<<"DIGITE EL ELEMENTO: "<<k+1<<','<<i+1<< " DE LA MATIZ: ";
cin>>a[i][k];
}
sumap=0; sumas=0;
for(i=0; i<n; i++)
{
sumap+=a[i][i];
sumas+=a[i][n-(i+1)];
}
clrscr();
textbackground(WHITE); textcolor(6);
gotoxy(20,11); cout<<"SUMA DE ELEMENTOS DE LA DIAGONAL PRINCIPAL:";
cout<<sumap; gotoxy(20,13);
cout<<"SUMA DE ELEMENTOS DE LA DIAGONAL SECUNDARIA:";
cout<<sumas;
gotoxy(34,25); cout<<"PRESIONE TECLA";
getch();
}
Ejemplo 39
Construir una librera que contenga dos subprogramas: uno que lea una matriz
(leerMatriz) y otro que imprima los elementos de la matriz (imprimirMatriz).
Los dos subprogramas tendrn como parmetros el nmero de filas, el nmero

de columnas y la matriz. Es obligatorio, dentro de los subprogramas, colocar el
nmero de columnas como una constante, mientras que el nmero de filas se
puede dejar vaco y recibir cualquier valor que le enve quien la utilice.
//LIBRERA CON DOS SUBPROGRAMAS: leerMatriz e imprimirMatriz
#include<iostream>
93
#include<conio2.h>
void leerMatriz(int nf, int nc, float mat[][50])
{
int f,c;
for(f=0;f<nf;f++)
{
clrscr();
for(c=0;c<nc;c++)
{
gotoxy(20,5+c);
cout<<"DIGITE EL ELEMENTO:["<<f+1<<"]["<<c+1<<"] ";
cin>>mat[f][c];
}
}
}
//************************************************************************
void imprimirMatriz(int nf, int nc, float mat[][50])
{
int f,c;
clrscr();
cout<<"\n\n\n
ELEMENTOS DE LA MATRIZ"<<endl<<endl;
for(f=0;f<nf;f++)
{
for(c=0;c<nc;c++)
cout<<mat[f][c]<<" ";
cout<<endl;
}
}
Ejemplo 40
Elaborar un programa que lea una matriz de nf filas y nc columnas y la
imprima.
#include"libMatriz.h"
int main()
{
int nf,nc; float mat[50][50];
clrscr();
cout<<"DIGITE EL NUMERO DE FILAS: ";
cin>>nf;
cout<<"DIGITE EL NUMERO DE COLUMNAS: ";
cin>>nc;
leerMatriz(nf,nc,mat);
imprimirMatriz(nf,nc,mat);
cout<<endl;
system("pause");
}
Ejemplo 41
Hacer un programa que encuentre e imprima la matriz transpuesta de una matriz
MAT.
La matriz transpuesta de la matriz MAT se encuentra intercambiando las filas por las
columnas y las columnas por las filas. Si TMAT es la matriz transpuesta de MAT,
implica entonces que TMAT [J, I] MAT [I, J].
94
Si el contenido de MAT es:

MAT =
TMAT =
15
11
16
15
16
11
Como se puede ver, se invierte el orden de la matriz, es decir, el nmero de filas de

MAT es igual al nmero de columnas de TMAT y el nmero de columnas se invierte,
por el nmero de filas de TMAT.
#include<iomanip>
int main()
{
int nf,nc,i,j;
float mat[50][50], tmat[50][50];
clrscr(); textbackground(WHITE); textcolor(MAGENTA);
gotoxy(20,11); cprintf("DIGITE EL NMERO DE FILAS:
gotoxy(49,11); cin>>nf;
gotoxy(20,13); cprintf("DIGITE EL NMERO DE COLUMNAS:
gotoxy(49,13); cin>>nc; clrscr();
for(i=0; i<nf; i++)
for(j=0; j<nc; j++)
tmat[j][i]=mat[i][j];
clrscr();
gotoxy(10,5); textcolor(MAGENTA);
cprintf("MATRIZ
TRANSPUESTA");
gotoxy(4,7);
for(i=0; i<nc; i++)
{
");
");
for(j=0; j< nf; j++)

cout<<setw(6)<<tmat[i][j];
gotoxy(4,8+i);
//setw est en la librera iomanip
}
gotoxy(20,25); cprintf("PRESIONE TECLA");
getch();
}
Ejemplo 42
Hacer un programa que lea una matriz de NF filas y NC columnas y calcule la suma
de las filas y de las columnas, dejando los resultados en dos vectores, uno con las
sumas de las filas y otro con la suma de las columnas; imprima los dos vectores.
La matriz es MAT y tiene los siguientes elementos, los contenidos de los vectores se
muestran a continuacin:
95
#include"LibMatriz.h"
int main()
{
int nf,nc,i,k; float mat[30][50], sumaf=0,vc[50],vf[30];
clrscr(); textbackground(WHITE); textcolor(MAGENTA);
gotoxy(20,11); cprintf("DIGITE EL NMERO DE FILAS:
");
gotoxy(49,11); cin>>nf;
textbackground(WHITE);
gotoxy(20,13); cprintf("DIGITE EL NMERO DE COLUMNAS:
");
gotoxy(49,13); cin>>nc; clrscr();
for(i=0; i< nf; i++)
{
sumaf=0;
for(k=0; k< nc; k++)
sumaf+=mat[i][k];
vf[i]=sumaf;
}
clrscr(); textcolor(MAGENTA);
gotoxy(20,5); cprintf("
SUMA DE CADA COLUMNA ");
for(k=0; k<nc; k++)
{
vc[k]=0;
for(i=0; i<nf; i++)
vc[k]+=mat[i][k];
gotoxy(25,k+7);
cout<<"COLUMNA "<<k+1<<" = "<<vc[k];
}
gotoxy(20,25); textcolor(MAGENTA);
cprintf("PRESIONE TECLA PARA CONTINUAR");
getch();
clrscr(); textcolor(GREEN);
gotoxy(20,5); cprintf("
SUMA DE CADA FILA ");
for(i=0; i< nf; i++)
{
96
gotoxy(25,i+7);
cout<<"FILA "<<i+1<<" = "<<vf[i];
}
getch();
}
Ejemplo 43
Un tablero de damas es un arreglo de 8 filas por 8 columnas. Un uno (1) representa
la presencia de una ficha roja en el tablero, un dos (2) representa la presencia de
una ficha negra en el tablero y un cero (0) representa la ausencia de ficha. Hacer un
algoritmo que calcule:
El nmero de fichas rojas:
nfr
El nmero de fichas negras:
nfn
El nmero total de fichas:
tft
Para saber la clase de ficha que existe en un cajn del tablero se compara el estado
de cada elemento con 1, 2 0 y, de acuerdo con el resultado, se incrementa el
contador escogido para cada caso. Un posible estado del tablero de damas, sera el
siguiente:
F\C
1
2
3
4
5
6
7
8
1
0
2
0
2
0
0
0
2
2
0
0
0
2
0
0
0
0
3
1
1
0
0
0
0
0
0
4
1
0
0
0
0
2
0
2
5
0
0
0
0
0
0
1
0
6
0
0
0
2
0
0
0
0
7
0
0
0
0
0
1
0
0
8
0
1
0
1
0
0
0
2
Donde existen siete (7) fichas rojas y 8 fichas negras para un total de 15 fichas en
el tablero.
#include<iostream>
#include<conio2.h>
int main()
{
short tab[8][8]; int i,k,nfr=0,nfn=0,tft,f=5,c=28;
clrscr(); textbackground(0);textcolor(6);
cprintf("DIGITE 0, 1 O 2 Y PRESIONE ENTER PARA LLENAR LA MATRIZ ");
for(i=0;i<=8; i++)
{
for(k=1;k<=24; k++)
{
gotoxy(27+k,f); cout<<char(205);
}
f+=2;
}
for(i=0;i<=8; i++)
97
{
for(k=1;k<=17; k++)
{
gotoxy(c,4+k); cout<<char(186);
}
c+=3;
}
c=29; f=6;
for(i=0;i<8;i++)
{
for(k=0;k<8;k++)
{
do
{
gotoxy(c,f); cin>>tab[i][k];
if((tab[i][k] < 0) || (tab[i][k] > 2))
{
gotoxy(c,f); cout<<" ";
}
}while((tab[i][k]< 0) || (tab[i][k] > 2));
if(tab[i][k]==1)
nfr++;
else
if(tab[i][k]==2)
nfn++;
c+=3;
}
c=29; f+=2;
}
gotoxy(33,25); cprintf("PRESIONE TECLA"); getch();
tft=nfr+nfn;
clrscr();
textbackground(WHITE); textcolor(RED);
gotoxy(25,11); cprintf(" NMERO DE FICHAS ROJAS:
gotoxy(50,11); cout<<nfr; textcolor(BLACK);
gotoxy(25,13); cprintf(" NMERO DE FICHAS NEGRAS:
gotoxy(50,13); cout<<nfn; textcolor(6);
");
");
gotoxy(25,15); cprintf(" NMERO TOTAL DE FICHAS:

");
gotoxy(50,15); cout<<tft; textcolor(5);
gotoxy(25,25); cprintf(" PRESIONE TECLA PARA TERMINAR");
getch();
}
Ejemplo 44
Un examen tiene 100 preguntas de seleccin mltiple. Cada pregunta, dentro de
sus alternativas, slo tiene una respuesta correcta. Las respuestas correctas estn
en un vector VCR de 100 posiciones, donde VCR[K] representa la respuesta correcta
de la pregunta K.
Por cada estudiante se elabora un registro que contiene: nombre del estudiante y, a
continuacin, 100 valores que corresponden a las respuestas dadas por el
estudiante, para cada una de las 100 preguntas.
Elaborar un programa que, entre el vector de respuestas correctas, forme un vector
con los nombres de los estudiantes, forme una matriz de N * 100 con las respuestas
dadas por los estudiantes e imprima los nombres de los estudiantes que aprobaron
el examen (se requiere una calificacin mnima de 60 puntos para aprobar), y el
nmero de estudiantes que lo perdieron.
98
Para almacenar la informacin requerida en el proceso se necesitan tres arreglos.

Un vector de 100 posiciones que contiene las respuestas correctas del examen, un
vector de N posiciones con los nombres de los estudiantes y la matriz que
representa las respuestas dadas por los N estudiantes a las 100 preguntas del
examen.
Para obtener el puntaje de un estudiante se compara la respuesta dada a la
pregunta K con la posicin K del vector de respuestas correctas y, si coinciden, se
incrementa en uno el contador de respuestas correctas.
/*IMPORTANTE: USTED PUEDE CAMBIAR LA CANTIDAD DE RESPUESTAS VARIANDO
EL VALOR DE LA CONSTANTE NRESP y el puntaje para ganar es 4.*/
#define NRESP 5 //CANTIDAD DE RESPUESTAS DEL EXAMEN
#include<iostream>
#include<conio2.h>
int main()
{
float vrc[30], mr[30][30];
int n,pun, np=0, l,k; char nom[30][36];
for(k=0; k< NRESP; k++)
{
clrscr(); textcolor(6); gotoxy(20,12);
cout<<"ENTRE LA RESPUESTA CORRECTA No: "<<k+1<<' ';
cin>>vrc[k];
}
clrscr();
gotoxy(20,12); textcolor(RED);
cprintf("DIGITE LA CANTIDAD DE ESTUDIANTES:
");
gotoxy(54,12); textbackground(0); cin>>n;
for(l=0; l<n;l++)
{
clrscr(); textcolor(MAGENTA);
gotoxy(20,11); cprintf("ENTRE EL NOMBRE DEL ESTUDIANTE:");
gotoxy(51,11); cout<<l+1<<' '; cin>>ws;
gotoxy(55,11); cin.getline(nom[l],35); textbackground(0);
for(k=0; k<NRESP; k++)
{
clrscr();
gotoxy(20,12);
cout<<"DIGITE LA RESPUESTA: "<<k+1<<" DEL ESTUDIANTE:"<<
l+1<<' ';
cin>>mr[l][k];
}
}
cout<<"
NOMBRE DE LOS GANADORES\n\n\a";
for(l=0; l<n; l++)
{
pun=0;
for(k=0; k<NRESP;k++)
if(mr[l][k] ==vrc[k])
pun++;
if(pun>=4)
cout<<"
"<<nom[l]<<endl;
else
np++;
}
cout<<"\n\n\a
PRESIONE TECLA";
99
gotoxy(20,24); cout<<"NMERO DE PERDEDORES:"<<np;

gotoxy(20,25); system("pause");
}
Ejemplo 45
Elaborar un programa que lea, para un arreglo bidimensional, la informacin sobre
ventas de NP productos; grabando en la primera columnas el cdigo del artculo y,
en la siguiente, el nmero de unidades vendidas cada mes (meses de 30 das).
Cada fila corresponde a los datos para un artculo. Utilizar las tres columnas
siguientes para calcular: promedio de ventas diarias, promedio de ventas en los
das que las hubo y nmero de das que se vendi; imprima la matriz.
Como el arreglo tiene, en la primera columna, el cdigo del artculo, inicialmente
tendr 31 columnas (una del cdigo columna 0 y 30 correspondientes a las ventas
hechas cada da del mes). En caso de que en un da no se haga venta, esa posicin
tendr valor de cero. La columna 31 del arreglo almacenar el promedio de ventas
diarias por artculo, que se calcula sumando cada fila desde la columna dos hasta la
treinta y uno, y dividiendo el resultado sobre los treinta das del mes, as:
El promedio de ventas en los das que las hubo (columna 32), se obtiene sumando
las ventas del producto y dividiendo por el nmero de das en que hubo ventas, es
decir, la cantidad de ventas diferentes de cero.
Cada registro de entrada corresponde a una fila de la matriz inicial, y ste se
diseara de la siguiente manera:
#include<iostream>
#include<conio2.h>
int main()
{
int np,i,k,ndhv; float ven[50][50], suma;
clrscr(); textcolor(LIGHTRED); textbackground(0);
gotoxy(20,12); cprintf("DIGITE CANTIDAD DE PRODUCTOS:
");
gotoxy(49,12); cin>>np;clrscr(); textbackground(0);
gotoxy(20,12);
cprintf("EL PRIMER ELEMENTO DE CADA FILA ES EL CODIGO");
gotoxy(20,15); cprintf("PRESIONE TECLA"); getch(); clrscr();
leerMatriz(np,31,ven);
for(i=0;i<np;i++)
{
suma=0; ndhv=0;
for(k=1;k<31; k++)
{
suma+=ven[i][k];
if(ven[i][k]!=0)
ndhv++;
100
}
ven[i][31]=suma/30;
ven[i][32]=suma/ndhv;
}
imprimirMatriz(np,33,ven);
cout<<endl;
system("pause");
}
7. REGISTROS
Un registro es una estructura de datos compuesta. Se puede decir que un registro
es un conjunto de campos variables relacionadas que, en general, pueden
pertenecer a tipos de datos diferentes, llamadas componentes del tipo registro,
donde todas las componentes pueden manipularse bajo un solo nombre de variable.
Por ejemplo, si se tiene un registro de datos compuesto por los campos: cdula,
nombres, deduccin y salario, podemos representarlo de la siguiente forma:
32506321 SUSANA RESTREPO
40000
630000
Como puede notarse, dentro del registro slo hay datos (informacin); es el
programador quien le coloca nombres a cada dato para poderlos almacenar en la
memoria de la computadora.
Si la informacin del empleado se fuera a tratar en forma individual y los
nombres de variables seleccionados para cada campo fueran: CC, NOM, DEDUC y
SAL, al ejecutarse la instruccin:
LEA: CC, NOM, DEDUC, SAL
La informacin de la empleada est dispersa en la memoria. La idea de usar
registros es agrupar toda la informacin en una misma rea de memoria bajo un
solo nombre. Si se toma la determinacin de que EMP1 es una variable de tipo
registro, es decir, puede almacenar en el rea asignada toda la informacin de un
empleado, grficamente se puede mirar de la siguiente manera.
EMP1
< cdula >

< nombres >
< deduccin >
< salarios >
memoria
101
Para que EMP1 sea tomada como una variable tipo registro, el programador debe
definirla como tal, de acuerdo con el lenguaje de programacin que est utilizando;
es decir, el tipo de dato registro no est predefinido, ya que sus componentes van a
depender de cada programa en especial. A modo de ejemplo, el anterior registro en
C++ se definira as:
struct empleado
{
long cc;
char nom[36];
double deduc;
double sal;
};
Lo anterior quiere decir que el programador ha definido un tipo de dato registro
llamado empleado y que a cualquier variable que se le asigne el tipo de dato
empleado, puede almacenar los valores de las componentes: cc, nom, deduc y sal.
En C++ se hara de la siguiente forma:
empleado emp1, emp2;
En la anterior instruccin se define a emp1 y emp2 como variables tipo registro, por
lo tanto, pueden almacenar todos los valores de los campos que conforman al tipo
de dato empleado.
Las variables tipo registro emp1 y emp2 son variables compuestas; para referenciar
a cada una de sus componentes hay que cualificarlas, o sea, expresar en forma
explcita a cul de las componentes del registro se quiere uno referir.
La
cualificacin se hace as: variables_tipo_registro.componente.
Por ejemplo:
emp1.cc
hace referencia al valor de la cdula almacenada en el rea de datos
(registro) emp1.
emp2.nom
hace referencia al nombre que hay en el rea de dato emp2.
emp1.nom[4]
referencia al caracter cuarto del nombre almacenado en el rea
de datos emp1, (en C++ sera el quinto).
La instruccin:
LEA: emp1.cc, emp1.nom, emp1.deduc, emp1.sal, lleva informacin a la variable
tipo p registro emp1.
Si hay necesidad de mover la informacin de una variable tipo registro a otra, se
puede hacer componente a componente o moviendo toda la informacin al mismo
tiempo. Por ejemplo:
emp2.cc = emp1.cc
emp2.nom = emp1.nom
emp2.deduc = emp1.deduc
emp2.sal = emp1.sal
102
sera lo mismo que tener: emp2 = emp1
EJEMPLO 46
Formar un registro con los campos: cdula, nombre, pago, luego pasarlo a otro
registro e imprimir la informacin.
Anlisis
Hay que definir las dos variables tipo registro est1 y est2, se leen los valores
de las componentes est1, luego se pasa a est2 y se imprimen.
#include<iostream>
#include<conio2.h>
int main()
{
struct estudiante
{
double cc;
char nom[36];
double pago;
};
typedef estudiante es;/* Se redefine el nombre del registro si Ud. quiere*/
es est1,est2; //estudiante est1,est2
clrscr(); textbackground(7); textcolor(MAGENTA);
gotoxy(20,11); cprintf("DIGITE LA CEDULA:
");
gotoxy(37,11); cin>>est1.cc; gotoxy(20,12);

cprintf("DIGITE EL NOMBRE:
");
gotoxy(37,12); cin>>ws; cin.getline(est1.nom,35);

gotoxy(20,13); cprintf("DIGITE EL PAGO:
");
gotoxy(36,13); cin>>est1.pago; textbackground(0);

est2=est1; textbackground(0); textcolor(WHITE); cprintf("
clrscr();
");
textbackground(5);
gotoxy(20,11); cout<<est2.cc; gotoxy(20,12); cout<<est2.nom;

gotoxy(20,13); cout<<est2.pago;
gotoxy(20,20); cprintf("PRESIONE TECLA"); getch();textbackground(0);
}
7.1. ARREGLO DE REGISTROS
Es una estructura de datos de gran utilidad e importancia en la programacin de

aplicaciones, ya que muchas veces es deseable, desde el punto de vista de la lgica
del programa en particular, mantener disponible en memoria principal una serie de
103
registros con informacin del mismo tipo para su proceso; dichos registros no
estarn dispersos; harn parte de un arreglo, lo que facilita su manejo.
Un arreglo de registros es muy parecido a un archivo de datos, se diferencian en
que los arreglos de registros residen en memoria principal y los archivos en
memoria auxiliar, por lo tanto, estos ltimos tiene existencia permanente.
Otra importancia que tienen los arreglos de registro es que cada uno de sus
elementos est formado por varios campos pertenecientes a diferentes tipos de
datos, a diferencia de los otros tipos de arreglos donde sus elementos son de un
solo tipo.
EJEMPLO 47
Formar un arreglo de mximo 100 registros donde cada elemento contenga:
cdula, nombres y pago, luego ordenarlo por el campo nombre, insertar un
nuevo registro sin daar el ordenamiento e imprimirlo. Si el nombre del
arreglo de registros es v, grficamente se representara as:
V
V[1]
V[1].cc
V[1].
nom
V[2]
V[1].p
V[2].cc
V[2].
nom
V{2].p
V[100]
V[100]. V[100]. V[100].
cc
nom
p
El problema se resolver a travs de mdulos (subprogramas)
ALGORITMO
LEER
IMPRIMIR
ORDENAR
INSERTAR
El subprograma LEER recibe la cantidad de elementos del arreglo (nmero de

estudiantes) N y enva el vector V.
104
IMPRIMIR
Recibe N y V
ORDENAR
Recibe N y V y enva V ordenado
INSERTAR
Recibe N y V y enva N y V
Otras variables
I, K
Variables de control de ciclos
MENOR
Almacena el nombre menor en el ordenamiento
POS
Almacena la posicin donde est el nombre menor.
AUX
elemento
ordenamiento.
Variable de tipo registro que guarda temporalmente un

del
vector
mientras
se
hace
el
RI
Registros a insertar
Estos subprogramas estarn dentro de la librera libvect.h

Datos de entrada
La cantidad de elementos del vector
La informacin del vector
Cdula, nombre y pago a insertar.
Datos de salida
La informacin del vector registro.
N
Cantidad de elementos
Nombre del arreglo
Variable tipo registro
R.CC
Cdula a insertar
R.NOM
Nombre a insertar
R.P
Pago a insertar
OP
Opcin a seleccionar en el men
SIGA
Opcin para insertar nuevos elementos
#include<iostream>
#include<conio2.h>
#include<iomanip>
#include<windows.h>
#include"entorno.h"
struct empleado
{
long long cc; char nom[36]; double p;
};
105
void leer(int n, empleado v[])/*Entra la informacin del empleado*/

{
int i,k,nc;
textbackground(0);
for(k=0; k<n;k++)
{
clrscr(); textcolor(MAGENTA); textbackground(CYAN);
gotoxy(20,11); cprintf("DIGITE LA CDULA:
");
gotoxy(38,11); cin>>v[k].cc; gotoxy(20,12); textbackground(CYAN);

cprintf("ENTRE APELLIDO NOMBRE:
");
textbackground(0);
gotoxy(42,12); cin>>ws; cin.getline(v[k].nom,35);
nc=strlen(v[k].nom);
for(i=nc;i<36;i++)
v[k].nom[i]=' ';
v[k].nom[36]='\0'; textbackground(CYAN);
gotoxy(20,13); cprintf("ENTRE
gotoxy(38,13); cin>>v[k].p;
EL
PAGO:
");
textbackground(0);
}
}
void imprimir(int n,empleado v[])/* Imprime la informacin del empleado*/
{
int i; clrscr();
for(i=0; i< n; i++)
cout<<setw(18)<<v[i].cc<<setw(40)<<v[i].nom<<setw(10)<<v[i].p<<endl;
gotoxy(20,25); cprintf("PRESIONE TECLA"); getch();
}
void ordenarPorNombre(int n, empleado v[])/* Ordena la informacin por nombre*/
{
int i,k,pos; empleado aux; char menor[36];
for(i=0; i<n-1; i++)
{
strcpy(menor,v[i].nom); pos=i;
for(k=i+1; k<n; k++)
if(strcmpi(menor,v[k].nom) >0)
{
strcpy(menor,v[k].nom); pos=k;
}
aux=v[i]; v[i]=v[pos]; v[pos]=aux;
}
clrscr(); textcolor(CYAN);
gotoxy(20,12); cprintf("EL VECTOR FUE ORDENADO"); Sleep(1000);
}
void insertar(int &n, empleado v[], empleado ri[])
{
106
int i=0,k;
while((i < n) && (strcmpi(ri[0].nom,v[i].nom) > 0))
i++;
n++;
for(k=n-1; k>(i); k--)
v[k]=v[k-1];
v[i]=ri[0];
}
/***********************************************************************************/
int
main()
{
empleado a[50],r[1]; int n,op;
char sw;
cout<<setprecision(2); textbackground(0);
clrscr(); textbackground(CYAN); textcolor(LIGHTRED);
gotoxy(20,12); cprintf("DIGITE CANTIDAD DE EMPLEADOS:
");

do
{
clrscr();
cuadros(7,20,18,60);
textcolor(CYAN); gotoxy(38,8); cprintf("MENU");
textbackground(0);
gotoxy(30,10);
cprintf("1: INGRESE LOS DATOS");
gotoxy(30,11); cprintf("2: IMPRIMIR LOS DATOS");

gotoxy(30,12); cprintf("3: ORDENAR LOS DATOS ");
gotoxy(30,13); cprintf("4: INSERTAR NUEVO DATO");
gotoxy(30,14); cprintf("5: TERMINAR PROGRAMA");
gotoxy(33,16); cprintf("DIGITE OPCION:
");
gotoxy(48,16); cin>>op; textbackground(0);

switch (op)
{
case 1: leer(n,a); break;
case 2: imprimir(n,a); break;
case 3: ordenarPorNombre(n,a); break;
case 4: sw='S';
while(toupper(sw)=='S')
{
clrscr();leer(1,r); insertar(n,a,r);
cprintf("HAY MAS EMPLEADOS PARA ADICIONAR S/N?
");
gotoxy(57,12); cin>>sw;
}
break;
case 5:
107
clrscr();
gotoxy(30,12); cprintf("FIN DEL PROGRAMA");
getch();
break;
}
}while(op !=5);
}
8. ARCHIVOS
Un archivo es un dispositivo lgico donde se pueden almacenar en forma
permanente grandes volmenes de informacin, dividido en estructuras de datos
(registros) todas del mismo tipo y relacionadas.
El manejo de informacin a travs de archivos es de gran utilidad en la
programacin, ya que permite la captura de informacin almacenada en ellos para
su posterior utilizacin en diversos programas, evitando tener que entrar en forma
manual la informacin que se quiere procesar; y almacenar gran cantidad de
informacin en espacios reducidos y con una alta precisin en el manejo de los
datos.
En general los archivos se pueden agrupar en tres grandes categoras:
Archivos de programa: son los programas fuentes que se escriben en un
determinado lenguaje de programacin. Estos programas son guardados en
medios magnticos auxiliares para su posterior utilizacin. Estos archivos se
pueden cargar del medio magntico a memoria, compilarlos, ejecutarlos, imprimirlos y volverlos a guardar donde estaban o en otro medio de almacenamiento
distinto.
Archivos de texto: almacenan letras, palabras, frases, prrafos y se suelen crear
y mantener mediante programas que procesan o editan texto.
Archivos de datos: almacenan valores. Un archivo de datos contiene informacin
que un programa crea y posteriormente procesa; de igual forma, puede usarse
para almacenar los resultados de la ejecucin de un programa.
8.1. MANEJO DE ARCHIVOS DE DATOS

C++ trae la librera biblioteca estndar fstream (file stream) donde se encuentran
las funciones para abrir y cerrar archivos, as como para realizar las operaciones de
lectura y escritura de datos en archivos.
# include <fstream.h>
108
Operaciones asociadas a archivos

Abrir archivo
Cerrar archivo
Lectura y escritura
Funciones de control
Los archivos se manejan a travs de dos nombres: uno interno o nombre lgico
(nombre de flujo), que es el nombre con que se manipula el archivo en el programa
y otro externo, que es el nombre bajo el cual queda guardado el archivo en el
medio magntico donde se lleve.
Las operaciones se logran mediante la librera fstream. Esta librera permite
guardar y cargar informacin mediante archivos por medio de las clases ifstream y
ofstream.
La operacin de apertura de un archivo es desproteger el rea del medio magntico
donde residir el archivo, el apuntador se coloca al principio del archivo y se
establecen buses de datos para transferir informacin desde el buffer creado en la
memoria RAM, al lugar donde reside el archivo.
Donde ofstream se usa para abrir un archivo de salida (write), o sea que vamos a
escribir informacin en el archivo (creacin del archivo), hay que tener en cuenta
que, si abrimos un archivo para escritura con el indicador out y el archivo existe,
ste ser destruido a no ser que se abra para adicionar ms registros al final del
archivo (indicador app).
Ifstream abre un archivo para leer la informacin que est almacenada en l, es
decir, desprotege el rea donde reside el archivo y se establecen los conductos con
el medio externo y memoria.
fstream abre un archivo para escritura y lectura al mismo tiempo.
Cuando se abre un archivo hay que indicar para qu se abre, esto se hace a travs
de indicadores, como los siguientes:
app: permite adicionar ms registros al final del archivo. El apuntador de flujo de
datos se colocar al final del archivo antes de cada operacin de escritura.
ate: similar al anterior, el apuntador se pondr al final del archivo una sola vez, al
momento de abrirlo.
Con estos dos modos de apertura, los datos sern
almacenados al final del archivo.
binary: indica que los datos del archivo son binarios sin formato.
in: este modo permite operaciones de lectura en el archivo.
out: permite operaciones de escritura en el archivo.
trunc: con este modo indicamos que el contenido actual ser descartado.
109
close( )
Esta funcin permite desasociar el archivo que se tenga abierto actualmente con la
aplicacin, es decir que se destruyen los medios de conexin entre la memoria y el
medio magntico y el nombre lgico con el nombre fsico. Por seguridad, es buena
prctica ejecutar esta funcin cuando ya no se desean realizar ms operaciones
sobre el archivo, para proteger el rea donde est el archivo. Al ejecutarse esta
operacin, automticamente al final del archivo, se adiciona un registro ms
(registro centinela) donde se coloca una marca, llamada marca de fin de archivo,
eof (end of file). Esto significa que nosotros leemos informacin del archivo hasta
que se detecte la marca de fin de archivo. Ejemplo:
While(!nombre lgico.eof())
{
}
nombre lgico.close();
Abrir el archivo para lectura o entrada
Es definir un flujo de archivo de entrada igual a cin>>.

En el programa nos referiremos al archivo utilizando el nombre lgico.
ifstream <nombre lgico> ( nombre fsico , ios_base::in) ;
Nombre lgico debe ser un nombre de variable permitido y a travs de este nos
referiremos al archivo (nombre fsico) en el programa.
Supongamos que queremos abrir un archivo que se llama nombres.txt que se
encuentra en la unidad de disco D Si le colocamos como nombre lgico archT:
#include <fstream.h>
.
ifstream archT (D:\nombres.txt, ios_base::in);
Si el archivo nombres es un archivo de datos, la instruccin sera:

ifstream archT (D:\datos.dat, ios_base::in);
Par comprobar si un archivo fu abierto con xito, hacemos la siguiente pregunta:

If(archT)
110
cout<< FUE ABIERTO CON XITO?;

else
cout<<NO SE PUDO ABRIR EL ARCHIVO;
O tambin se puede negar la pregunta:

If(!archT)
cout<<NO SEPUDO ABRIR EL ARCHIVO;
else
cout<<EL ARCHIVO ESTA ABIERTO;
Donde nombres.txt es el nombre con el cual queda grabado el archivo (nombre fsico),
si no colocamos ruta el archivo se guardar en la carpeta donde est el programa que
lo crea.
Abrir un archivo para escritura (creacin del archivo).

Si queremos crear el archivo nombres.txt lo debemos abrir para escribir datos, si el
nombre lgico es Escritura.
#include <fstream.h>
.
ofstream Escritura (D:\nombres.txt, ios_base::out);
ofstream Escritura (D:\datos.datt, ios_base::out);
Abrir un archivo para adicionar registros al final.

Ofstream Agregar(D:\nombres.txt,ios_base::app);
Ofstream Agregar(D:\nombres.dat, ios_base::app;
8.1.1. ARCHIVOS DE TEXTO

Son una serie de nmeros binarios que representan la informacin, sin embargo,
estos archivos estn guardados en formato de texto '.txt', y los podr leer cualquier
aplicacin que procese textos.
En este caso el nombre lgico acta como si fuera un cin o un cout, o sea, para
ingresar o leer datos
Lectura de un archivo de texto
111
#include<fstream>
Ifstream Lectura(nombres.txt, ios_base::in);

If(!Lectura)
cout<<NO SE PUDO ABRIR EL ARCHIVO ;
else{
Lectura>> numero;
Lectura>>ws; Lectura.getline(nombre,40);
}
Lectura.close();
El operador >> lee hasta un blanco y omite los blancos.
Ahora vamos a leer el archivo que se ley antes..

#include<fstream>
ofstream Escritura(nombres.txt, ios_base::out);

If(!Escritura)
cout<<NO SE PUDO ABRIR EL ARCHIVO ;
else{
Escritura<< numero<< ;
Escritura<<nombre
}
Escritura.close();
EJEMPLO 48
Hacer un programa que genere un archivo de texto con los campos: nmero y
nombres, que muestre la informacin del archivo y le adicione ms registros.
#include<iostream>
#include<conio2.h>
#include<fstream>
int main()
{
char nom[40];
int i=0, opcion;
112
char sw='S',sw1;
long long cedula;
do
{
clrscr();
cout<<" 1: CEAR EL ARCHIVO "<<endl;
cout<<" 2. IMPRIMIR CONTENIDO DEL ARCHIVO "<<endl;
cout<<" 3: ADICIONAR UN REGISTRO AL FINAL"<<endl;
cout<<" 4: SALIR DEL MENU ";
cout<<"DIGIITE OPCION: "; cin>>opcion;
if(opcion==1)
{
clrscr();
cout<<"OJO SI EL ARCHIVO YA ESTA CREADO SERA DESTRUIDO "<<endl;
cout<<"EL ARCHIVO EST CREADO S/N? ";
cin>>sw1;
if(toupper(sw1)=='N'){ //1
ofstream Escribir("nombres.txt",ios_base::out);/*SE ABRE PARA ESCRITURA*/
if(Escribir){ //2 SI EL ARCHIVO SE ABRI CON XITO
cout<<"DIGITE LA CEDULA ";
cin>>cedula;
while(cedula !=0)
{
cout<<"DIGITE EL NOMBRE "<<i+1<<" ";
cin>>ws; cin.getline(nom,40);
Escribir<<cedula<<' '<<nom<<endl;
clrscr();
cout<<"DIGITE CEDULA O CERO PARA TERMINAR: ";
cin>>cedula;
i++;
}//while
} //2
Escribir.close(); /*CERRAR EL ARCHIVO*/
}//1
else
{
clrscr();
cout<<"EL ARCHIVO NO SE PUDO ABRIR"<<endl;
system("pause");
}//fin else
}
if(opcion==2){
ifstream Lectura("nombres.txt",ios_base::in);/*SE ABRE PARA LECTURA*/
if(!Lectura)/*SI EL ARCHIVO NO SE PUDO ABRIR*/
{
cout<<"EL ARCHIVO NO SE PUDO ABRIR PARA LECTURA "<<endl;
exit(0);
}
else
{
clrscr();
cout<<"DATOS ALMACENADOS EN EL ARCHIVO nombres.txt"<<endl<<endl;
Lectura>>cedula; Lectura>>ws; Lectura.getline(nom,40);
while(!Lectura.eof())
{
cout<<cedula<<"
"<<nom<<endl;
Lectura>>cedula; Lectura>>ws; Lectura.getline(nom,40);
}//while
Lectura.close();
cout<<endl<<endl<<endl;
system("pause");
}//else
113
}
if(opcion==3){
/* SE ABRE EL ARCHIVO PARA
ofstream Agregar("nombres.txt", ios_base::app);
if(Agregar){
clrscr();
cout<<"DIGITE LA CEDULA ";
cin>>cedula;
cout<<"DIGITE UN NOMBRE ";
cin>>ws; cin.getline(nom,40);
Agregar<<cedula<<' '<<nom<<endl;
Agregar.close();
}
}
}while(opcion !=4);
}
ADICIONAR
REGISTROS
AL
FINAL*/
8.1.2. ARCHIVO DE DATOS

Un archivo es un conjunto de datos relacionados entre s, con una organizacin
jerrquica, de modo que cada archivo est formado por un conjunto de registros y
stos, a su vez, formados por una serie de campos. Un registro es la unidad de
medida de un archivo, que contiene la informacin que se utiliza en los diferentes
programas y son tratados de manera independiente.
Un registro puede contener dentro del conjunto de campos que lo conforman, uno
que hace que el registro en particular sea nico, es decir, lo diferencie de los dems
llamado campo clave. Grficamente se puede mirar un archivo de datos de la
siguiente forma:
114
Como se desprende del grfico, los campos corresponden a las columnas y los
registros a las filas.
El tamao o longitud de un registro se mide en bytes y ser la resultante de sumar
las longitudes de los campos que lo conforman. Es importante tener en cuenta que
los campos que conforman un registro deben referenciar una misma informacin y
de igual manera los registros deben estar relacionados con la razn de ser del
archivo.
Empleados
Cdula
114
01
Depto
Elas Jos
Nombre
Salario
121
01
Graciela del Carmen
211
01
Luisa Berta
312 516
099
02
Guillermo Segundo
222 604
117
02
Albertina Isabel
212
02
Corina Francisca
119
03
Ruth de Jess
119 325
118
03
Florencia Maria
425 000
311
04
Jairo Antonio
Fin del archivo
180 000
253 423
191 221
823 514
388 734
Como se puede ver, en un archivo de datos lo que se guarda es informacin, es el

programador quien decide qu nombre le coloca al registro (struct) y a cada uno de
los campos individuales que integran el registro. Otros ejemplos:
Clientes
Cdula Nombre Apellido Direccin
14879563 Fredy
Jaramillo
47896321 Leonel
Osorno
Telfono
Cra. 10 No. 10-17
2310145
Cll. 70 No. 11-184569874
65874123 Fabin
Ros Cll. 20 No. 12-9
73284562 Gisela
Gil
5896201
Cra. 43 No. 10-21 3214568
EOF
Inventario
Cdigo
702110
Descripcin
Buja
200
Unidades Valor-unidad
7500
802010
Vlvula
50
850
115
902110
Manguera
35750
EOF
Libros
Cdigo-libro
502115
Ttulo
Antes del fin
Cdigo-autor Unidades
8462148
12
602017
Doa Brbara
7985621
21
902117
El tnel
4568932
32
EOF
EOF significa End Of File (Fin del Archivo), es un indicador que aparece luego del
ltimo registro del archivo, denotando el final del mismo.
Ya vimos cmo abrir un archivo de datos para lectura y escritura y adicionar datos
al final.
Veamos cmo escribir (crear) en un archivo de datos secuencial, si tenemos:
struct empleado
{
long long cc;
char nom[40];
float salario;
};
empleado r; /* r Variable tipo registro*
.......
ofstream emp ("datos.dat",ios_base::out|ios_base::binary);
.......
emp.write((char*) &r,sizeof(r));/*Operacin de escritura*/
.......
emp.close();
Veamos la instruccin de lectura:

ifstream a2("datos.dat", ios_base::in|ios_base::binary);/*apertura*/
.......
a2.read(( char*) &r,sizeof(r)); /*Operacin de lectura*/
116
EJEMPLO 49
Vamos a crear un archivo con los datos: cdula, nombres y salario, lo leemos e
imprimimos por pantalla la informacin en l contenida, lo ordenamos por el campo
nombre y buscamos la informacin por cdula de un empleado.
/*********************************************************************/
#include<iostream>
#include<conio2.h>
#include<fstream>
#include<iomanip>
struct empleado
{
long long cc;
char nom[40];
float salario;
};
empleado r;
void adicionar()
{ //1
long codigoad;
char sw;
clrscr();
gotoxy(20,11);
cout<<"EL ARCHIVO EST CREADO S/N: ";cin>>sw;
if(toupper(sw)=='N')
{ //2
cout<<"ASI EL ARCHIVO EST CREADO SERA DESTRUIDO ";
gotoxy(20,14);cout<<"\EL ARCHIVO ESTA CREADO S/N: ";cin>>sw;
} //2
if(toupper(sw)=='N')
{ //3
ofstream emp ("datos.dat",ios_base::out|ios_base::binary);
if(!emp)
{ //4
clrscr();
cout<<"NO SE PUEDE ABRIR EL ARCHIVO PARA ADICIONAR";
getch(); exit(1);
} //4
cout<<"DIGITE LA CEDULA : ";
cin>>codigoad;
while(codigoad !=0){
r.cc=codigoad;
gotoxy(20,12);
cout<<"DIGITE EL NOMBRE: ";
cin>>ws; cin.getline(r.nom,40);
gotoxy(20,13);
cout<<"DIGITE EL SALARIO: ";
cin>>r.salario;
emp.write((char*) &r,sizeof(r));
cout<<"DIGITE NUEVA CEDULA O CERO PARA TERMINAR: ";
cin>>codigoad;
}
emp.close();
}
}
117
/***************************************************************/
void Leer()
{
int i=5;
ifstream a2("datos.dat", ios_base::in|ios_base::binary);
if(!a2)
{
clrscr();
cout<<"NO SE PUEDE ABRIR EL ARCHIVO PARA IMPRIMIR";
getch(); exit(1);
}
clrscr(); textcolor(MAGENTA); gotoxy(30,2);
cprintf("D A T O S D E L A R C H I V O");
a2.read(( char*) &r,sizeof(r));
while(!a2.eof())
{
gotoxy(10,i+1);
cout<<setw(12)<<r.cc<<setw(40)<<r.nom<<setw(14)<<r.salario;
i++;
a2.read(( char*) &r,sizeof(r));
}
gotoxy(10,i+3);
system("pause");
a2.close();
}
//***********************************************************/
void buscarPorCedula()
{
char sw='N';
long long cedulaBuscar;
ifstream arch("datos.dat",ios_base::in);
if(!arch)
{
clrscr();
cout<<"NO SE PUEDE ABRIR EL ARCHIVO PARA IMPRIMIR";
getch(); exit(1);
}
else
{
clrscr();
cout<<"DIGITE LA CEDULA A BUSCAR: ";
cin>>cedulaBuscar;
arch.read(( char*) &r,sizeof(r));
while((!arch.eof())&&(sw=='N'))
{
if(r.cc==cedulaBuscar)
sw='S';
else
arch.read(( char*) &r,sizeof(r));
}
clrscr();
gotoxy(20,12);
if(sw=='S')
cout<<"EL EMPLEADO CON CEDULA "<<cedulaBuscar<<" SI ESTA"<<endl;
else
cout<<"EL EMPLEADO CON CEDULA "<<cedulaBuscar<<" NO ESTA";
gotoxy (20,24);
system("pause");
arch.close();
}
}
/***********************************************************/
void ordenarPorNombre()
118
{
empleado est1,est2;
char nomen[40];
long n=0,i,pos,k;
fstream a4("datos.dat",ios_base::in|ios_base::out|ios_base::binary);
if(!a4)
{
clrscr();
cout<<"NO SE PUEDE ABRIR EL ARCHIVO PARA ORDENAR";
getch(); exit(1);
}
a4.read(( char*) &est1,sizeof(est1));
while(!a4.eof())
{
n++;
}
a4.close();
fstream a5("datos.dat",ios_base::in|ios_base::out|ios_base::binary);
for(i=0;i<(n-1);i++)
{
a5.seekp(i*sizeof(est1),ios::beg);
pos=i; strcpy(nomen,est1.nom);
for(k=i+1;k<n;k++)
{
a5.seekg(k*sizeof(est2),ios::beg);
if(strcmpi(nomen,est2.nom) > 0)
{
pos=k; strcpy(nomen,est2.nom);
}
}
a5.seekg(pos*sizeof(est2),ios::beg);
a5.seekg(i*sizeof(est1),ios::beg);
a5.write(( char*) &est2,sizeof(est2));
a5.seekg(pos*sizeof(est1),ios::beg);
a5.write((char*) &est1,sizeof(est1));
}
a5.close();
clrscr();
textcolor(RED);
gotoxy(30,12);cprintf("EL ARCHIVO FUE ORDENADO");
gotoxy(30,14);cprintf("
PRESIONE TECLA ");
getch();
}
int main()
{
int op,n,sw;
do
{
clrscr(); textbackground(WHITE);textcolor(LIGHTRED);
cout<<"\n
MENU\n";
cout<<"\n 1: ADICIONAR";
cout<<"\n 2: IMPRIMIR";
cout<<"\n 3: ORDENAR EL ARCHIVO POR NOMBRE";
cout<<"\n 4: BUSCAR POR CEDULA";
cout<<"\n 5:SALIR DEL MENU";
cout<<"\n DIGITE OPCION ";
cin>>op;
switch (op)
119
{
case
case
case
case
case 5:
1: adicionar(); break;
2: Leer();
break;
3: ordenarPorNombre();
4: buscarPorCedula();
"SALIR DEL MENU";
break;
break;
}
}while(op !=5);
}
120
9. ANEXOS
9.1. TABLA CARACTERES ASCII
121
10.
BIBLIOGRAFA
CIBERGRAFA
10.1. BIBLIOGRAFA
PROGRAMACIN EN C++ PARA INGENIEROS. Fatos Xhafa y otros
LGICA DE PROGRAMACIN SEGUNDA EDICIN. Efran M Oviedo Regino
10.2. CIBERGRAFA
cplusplus.com - The C++ Resources Network
http://www.cplusplus.com/
BloodshedSoftware - Providing Free Software to the internet community
http://www.bloodshed.net/devcpp.html
Wikipedia, la enciclopedia de contenido libre
http://es.wikipedia.org/wiki/Dev-C%2B%2B
Cdigo C++ | Programas, Tareas y Ejemplos en C++
http://codigoc.org/143-bajar-dev-c-gratis-compilador-para-c
122

Introducción A Dev C++

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Introducción A Dev C++

Загружено:

Авторское право:

Доступные форматы

V

1.3. ENTORNO DE DESARROLLO INTEGRADO 5

2. ASPECTOS BSICOS DE C++ 7

2.4. TIPOS DE DATOS

2.5. OPERADORES DE C++

3.1. INSTRUCCIONES DE ENTRADA Y SALIDA DE DATOS

3.1.1. SALIDA DE DATOS 20

3.3. INSTRUCCIN WHILE 27

3.5.3. SWITCH- CASE

4.1.4 LIBRERA PARA VALIDAR Y CREAR CUADROS.

5.1. MANEJADOR DE EXCEPCIONES

Introduccin a dev C++

6.1. CLASIFICACIN DE LOS ARREGLOS74

7.1. ARREGLO DE REGISTROS

8.1.1. ARCHIVOS DE TEXTO

8.1.2. ARCHIVO DE DATOS

9.1. TABLA CARACTERES ASCII

10. BIBLIOGRAFA Y CIBERGRAFA

10.2. CIBERGRAFA 118

de los lectores la pgina web

1.3. ENTORNO DE DESARROLLO INTEGRADO

Un IDE es un programa bastante complejo que, aparte de tener las reglas de

2. ASPECTOS BSICOS DE C++

CABECERA: INCLUYE LIBRERAS A UTILIZAR

Introduccin a dev C++

Int feof (FILE *f);

Int fgetc (FILE *f);

FILE *fopen (const

Int fprintf (FILE*f,

Int isalnum(int c);

Int isalpha(int c);

Int isascii(int c);

Int iscntrl(int c);

Int isdigit(int c);

Int isgraph(int c);

Int islower(int c);

Int isodigit(int c);

Int isprint(int c);

Int ispunct(int c);

Int isspace(int c);

Int isupper(int c);

Int isxdigit(int c);

Long int labs(long

Introduccin a dev C++

Double sin (double

Introduccin a dev C++

Int toascii (int c);

Int tolower (int c);

con el transcurso del tiempo o la ocurrencia de determinado evento. Las variables

2.4. TIPOS DE DATOS

1.17e ^- 38..3.4 e^+38 (7 dgitos

2.22 e^-308..1.79 e^+308 (15

3.4e ^-4932 ..1.18 e ^+4932(18

Tabla 1, Tipos de datos en C++

Estructura de la definicin de una variable:

Estructura de la asignacin de una variable:

*. expresion puede ser un valor puntual o un conjunto de operaciones que, luego

// Definimos la variable x de tipo entero

int nombreDeLaVariable = expresin;

NOTA: el punto y coma (;) al final de la instruccin es obligatorio, si no se incluye,

2.5. OPERADORES DE C++

2.6. CARACTERES ASCII

3.1. INSTRUCCIONES DE ENTRADA Y SALIDA DE DATOS

double validarRealPositivo (char numc) // El es semejante a lo que hay