Introducción A Visual C++

1
Introducción a dev C++

V
CONTENIDO
1. INTRODUCCIÓN 5
1.2. C++
1.3. ENTORNO DE DESARROLLO INTEGRADO
2. ASPECTOS BÁSICOS DE C++
2.1. ESTRUCTURA BÁSICA DEL CÓDIGO
2.2. LIBRERÍAS
2.3. VARIABLES 16
2.4. TIPOS DE DATOS 16

2.5. OPERADORES DE C++ 8
2.6. CARACTERES ASCII 20
3. PROGRAMACIÓN 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 22
3.2. INSTRUCCIÓN IF 23
3.3. INSTRUCCIÓN WHILE 27
3.5. INSTRUCCIONES ADICIONALES 31

3.5.1. DO-WHILE 32
3.5.2. FOR 34
3.5.3. SWITCH- CASE 36
4. SUBPROGRAMAS 39
4.1. CLASIFICACIÓN DE LOS SUBPROGRAMAS 40
4.1.1. PROCEDIMIENTOS O SUBRUTINAS 40
4.1.2. FUNCIONES 46
4.1.3. LIBRERÍAS 9
4.1.4 LIBRERÍA PARA VALIDAR Y CREAR CUADROS. 53
5. EXCEPCIONES 71
2
5.1. MANEJADOR DE EXCEPCIONES 71
5.1.1. TRY 72
5.1.2. THROW 72
5.1.3. CATCH 72
6. ARREGLOS 74
6.1. CLASIFICACIÓN DE LOS ARREGLOS 74
6.1.1. ARREGLOS DE UNA DIMENSIÓN O VECTORES 74
6.1.2. ARREGLOS DE DOS DIMENSIONES O MATRICES 88
7. REGISTROS 98
7.1. ARREGLO DE REGISTROS 100

8. ARCHIVOS 105
8.1. MANEJO DE ARCHIVOS DE DATOS 105
8.1.1. ARCHIVOS DE TEXTO 8
8.1.2. ARCHIVO DE DATOS 11
9. ANEXOS 17
9.1. TABLA CARACTERES ASCII 17
10. BIBLIOGRAFÍA Y CIBERGRAFÍA 18
10.1. BIBLIOGRAFÍA 18
10.2. CIBERGRAFÍA 18
3
PRESENTACIÓN
Este material se ha diseñado para ayudar a personas que necesitan asesoría específica para
desarrollar alguna aplicación 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 ingeniería o temas relacionados con las tecnologías de la información y
comunicación.
El texto explica la programación estructurada de una manera natural, partiendo de lo más

sencillo hacia lo más complejo, incrementando el nivel de complejidad en cada capítulo que se
avance. Esta versión no incluye la Programación Orientada a Objetos, tema que será incluido
en una próxima versión. La programación estructurada se ha proyectado en todas las ramas del
saber, fundamentalmente para aquellos lectores que no necesitan la programación objetual.
El texto es entonces de carácter práctico, enriquecido con la experiencia como docente

universitario de este tema por varios años. El contenido no supone -de ninguna manera- tener
algún conocimiento anterior sobre programación, ya que en forma didáctica, va guiando al
lector, incluso partiendo desde la definición de lo que es un lenguaje de programación y las
facilidades que brinda dev C++ para programar, cómo puede instalarse y las ventajas sobre
otras versiones de C++.
El lector encontrará todas las formas de representación de las instrucciones con formatos
explicados de forma sencilla y las estructuras de representación de datos tanto en memoria
como en medios externos.
El autor deja a disposición de los lectores la página web http://ingenieria.udea.edu.co/~eoviedo,

donde no sólo encontrará los ejercicios resueltos, sino los del libro: LÓGICA DE
PROGRAMACIÓN, que están resueltos en turbo C++ y en java.
Por último, el lector podrá resolver sus inquietudes, escribiéndo a mis correos:
efrainoviedo@gmail.com ó eoviedo@udea.edu.co.
El autor.
4
1. INTRODUCCIÓN
1.1. LENGUAJE DE PROGRAMACIÓN
Un lenguaje de programación es un conjunto de reglas de sintaxis diseñadas para representar

instrucciones que, escritas de la manera adecuada, pueden dar solución a un problema. Este conjunto
de instrucciones se llama programa fuente y es ejecutado a través de un computador.
Los programas creados por el usuario ejercen un control físico y lógico sobre la máquina o procesador, el
cual reconoce las instrucciones señaladas en el programa, gracias a otro programa llamado compilador.
El compilador se encarga de traducir las instrucciones del programa a un lenguaje de máquina binario,
creando un nuevo programa llamado programa objeto, el cual es llevado al procesador y es ejecutado
instrucción por instrucción.
1.2. C++
El lenguaje de programación C++ fue creado por Bjarne Stroustrup en los 80's. Su trabajo consistió en
llevar más allá, el ya famoso lenguaje de programación C, e implementar un lenguaje que permitiera la
manipulación de objetos, dejando el compilador de C. Los ficheros fuente de C++ tienen la extensión
*.cpp (de C plus, denominación en ingles del lenguaje).
1.3. ENTORNO DE DESARROLLO INTEGRADO
Para crear un programa usando un lenguaje, en esencia, sólo necesitamos un editor de texto, en el cual
escribimos las instrucciones que deseamos utilizar, sin embargo, una vez terminada la escritura de dicho
programa, ¿cómo podemos saber si el programa está correctamente escrito?, y ¿cómo 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).
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 máquina. Por lo anterior, un IDE es capaz de
indicarnos en qué parte del código que escribimos, se está violando alguna o algunas reglas de sintaxis e
5
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 código que escribimos.
6
2. ASPECTOS BÁSICOS DE C++
2.1. ESTRUCTURA BÁSICA DEL CÓDIGO
Todo programa en C++ debe tener una función principal main(), esta función contiene la rutina base del
programa y debe cumplir con la siguiente sintaxis:
int main () {
A partir de éste, podemos generar la estructura del código fuente necesaria para realizar una aplicación
mediante el lenguaje de programación C++ así:
● CABECERA: INCLUYE LIBRERÍAS A UTILIZAR

● DECLARACIÓN: DECLARACIÓN DE CLASES Y FUNCIONES
● PROGRAMA PRINCIPAL: MAIN
● FIN
2.2. LIBRERÍAS
Las librerías, en un lenguaje de programación, son códigos escritos previamente que definen funciones
que se utilizan frecuentemente en los programas. Estas funciones ya están diseñadas y las puede usar
uno directamente, sin necesidad de construír un conjunto de instrucciones que hagan lo que hacen las
funciones, son de gran ayuda en los programas ya que nos permiten ahorrar tiempo. Algunas de las
librerías más utilizadas son:
iostream
Permite utilizar funciones para entrada y salida de datos. Pertenece a la biblioteca estándar de C++,
Funciones: cout, cin, cerr, etc.
conio2
Es una librería que funciona en sistemas operativos con DOS como MS Windows. Permite utilizar
funciones de manejo avanzado de la consola. No pertenece a la biblioteca estándar de C++,
Funciones: getch( ), textcolor( ), textbackground( ), clrscr( ), etc.
math (se debe incluir, lo mismo la conio2)

Esta librería permite el uso de funciones matemáticas esenciales. Hace parte de la biblioteca estándar
de C++.
7
2.2.1 FUNCIONES DE BIBLIOTECA.
Una función es un pequeño programa ya escrito y que viene con el copmpilador y que están agrupadas
En librerías, el uso de ellas nos evita tener que elaborarlos nosotros.
NOMBRE TIPO LIBRERIA DESCRIPCION SINTAXIS
abs(i) Int Stdlib.h Devuelve el valor int abs(int i);
absoluto de i
acos(d) double Math.h Devuelve el coseno double acos(double d);
inverso de d
asin(d) double Math.h Devuelve el seno double asin(double d);
inverso de d
atan(d) double Math.h Devuelve la tangente double atan(double d);
inversa de d
atan(d1,d2) double Math.h Devuelve la tangente double atan (double d1,
inversa de d1/d2 double d2;)
atof(s) double Stdlib.h Convierte la cadena s double atof(const char
en una cantidad *cadena)
doublé (valor real)
atoi(s) int Stdlib.h Convierte la cadena s int atoi(const
a un entero char*cadena)
atol(s) long Stdlib.h Convierte la cadena s long atol(const
a un entero largo char*cadena)
calloc(n,s) Void alloc.h y Reserva memoria void *calloc ( size_t
(puntero) stdlib.h para una formación n;size_t s);
de n elementos, cada
uno de s bytes.
Devuelve un puntero
al principio del
espacio reservado.
ceil(d) double Math.h Devuelve un valor double ceil(double d);
redondeado al
siguiente entero
mayor
cos(d) double Math.h Devuelve el Coseno double cos(double d);
de d
cosh(d) double Math.h Devuelve el Coseno Double cosh(double d);
hiperbólico de d
difftime (l1,l2) double Time.h Devuelve la double difftime( time_t
diferencia en tiempo hora2, time_t hora1);
l1(hora 2)-l2(hora 1),
donde l1 y l2
representan el
tiempo transcurrido
después de un
tiempo base
exit(u) void Stdlib.h Cierra todos los void exit(int u)
archivos, buffers y u es el estado de
8
termina el programa terminación
exp(d) double Math.h Eleva e a la potencia double exp (double d);
d
fabs(d) double Math.h Devuelve el valor double fabs(double d)
absoluto de d
fclose(f) int Stdio.h Cierra el archivo f. int fclose (FILE *f);
devuelve el valor 0 si
el archivo e ha
cerrado con éxito.
feof(f) int Stdio.h Determina se ha int feof (FILE *f);
encontrado un fin de
archivo. Si es así,
devuelve un valor
distinto de cero, en
otro caso devuelve 0.
fgetc(f) int Stdio.h Lee un carácter del int fgetc (FILE *f);
archivo f
fgets(s,i,f) Char Stdio.h Lee una cadena s, char *fgets(char s,int s,
(puntero) con i caracteres, del FILE*f);
archivo f
floor(d) double Math.h Devuelve un valor double floor(double d);
redondeado al
entero menor más
cercano
fmod(d1,d2) double Math.h Devuelve el resto de double fmod(double d1,
d1/d2 double d2);
fopen(s1,s2) File (puntero) Stdio.h Abre un archivo FILE *fopen (const
llamado s1, del tipo char*s1,const char*s2);
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 añadir.
-“rb”: Archivo binario
para la lectura.
9
-“wb”: Archivo
binario para la
escritura.
-“ab”: Archivo
binario para añadir.
-“rb+”: Archivo
binario para la
lectura/escritura.
-“wb+”: Archivo
binario para la
lectura/escritura.
-“ab +”: Archivo
binario para lectura y
añadir.
fprintf(f,…) int Stdio.h Escribe datos en el int fprintf (FILE*f, const

archivo f char*formato [,arg,….]);
frexp(i,d) double Math.h Toma el numero i y double frexp(double
obtiene su notación num,double exp);
científica al
descomponerlo en
dos partes: la
mantisa, que es
retornada por la
función, y el
exponente, que es
colocado en d
fputc(c,f) int Stdio.h Escribe un carácter int fputc(int c, FILE*f);
en el archivo f
fputs(s,f) int Stdio.h Escribe una cadena int fputs(const char*cad,
de caracteres en el FILE*f);
archivo f
fread(s,i1,i2,f) int Stdio.h Lee i2 elementos, size_tfread(void*s,size_t
cada uno de tamaño i1,size_t i2, FILE*f);
i1 bytes, desde el
archivo f hasta la
cadena s)
free(p) void Stdio.h Libera un bloque de void
memoria reservada free(void*dir_memoria);
cuyo principio está
indicado por p
fseek(f,l,i) int Stdio.h Mueve el puntero al int fseek(FILE*f, long
archivo f una despla,int origen);
distancia de l bytes
desde la posición i, la
cual puede ser:
-SEEK_SET: Principio
10
de archivo
-SEEK_CUR: Posición
actual del puntero
-SEEK_END: Final del
archivo
ftell(f) Long int Stdio.h Devuelve la posición long int ftell(FILE*f);
actual del puntero
dentro del archivo f
fwrite(s,i1,i2,f) int Stdio.h Escribe i2 elementos, size_t fwrite(const
cada uno de tamaño void*s,size_t i1,size_t
i1, desde la cadena s i2,FILE*f);
hasta el archivo f
getc(f) int Stdio.h Lee un carácter del int getc(FILE*f);
archivo f
getchar() int Stdio.h Lee un carácter int getchar(void);
desde el dispositivo
de entrada estándar
gets(s) char Stdio.h Lee una cadena de char*gets(char*cad);
(puntero) caracteres desde el
dispositivo de
entrada estándar
isalnum(c) int Ctype.h Determina si el int isalnum(int c);
argumento es
alfanumérico.
Devuelve un valor
distinto de cero si es
cierto; en otro caso
devuelve 0,
isalpha(c) int Ctype.h Determina si el int isalpha(int c);
argumento es
alfabético. Devuelve
un valor distinto de
cero si es cierto; en
otro caso devuelve 0.
isascii(c) int Ctype.h Determina si el int isascii(int c);
argumento es un
carácter ASCII.
Devuelve un valor
devuelve 0
iscntrl(c) int Ctype.h Determina si el int iscntrl(int c);
argumento es un
carácter ASCII de
control. Devuelve un
valor distinto de cero
si es cierto; en otro
11
caso devuelve 0
isdigit(c) int Ctype.h Determina si el int isdigit(int c);
argumento es un
digito decimal.
Devuelve un valor
devuelve 0
isgraph(c) int Ctype.h Determina si el int isgraph(int c);
argumento es un
carácter ASCII grafico
(hex 0x21-0x7e; octal
041 -176). Devuelve
otro caso devuelve 0
islower(c) int Ctype.h Determina si el int islower(int c);
argumento es una
minúscula. Devuelve
isodigit(c) int Ctype.h Determina si el int isodigit(int c);
argumento es un
digito octal.
Devuelve un valor
devuelve 0
isprintf(c) int Ctype.h Determina si el int isprint(int c);
argumento es un
carácter ASCII
imprimible (hex
0x20-0x7e; octal 040
-176). Devuelve un
valor distinto de cero
si es cierto; en otro
caso devuelve 0
ispunct(c) int Ctype.h Determina si el int ispunct(int c);
argumento es un
carácter de
puntuación.
Devuelve un valor
devuelve 0
isspace(c) int Ctype.h Determina si el int isspace(int c);
12
argumento es un
espacio en blanco
Devuelve un valor
devuelve 0
isupper(c) int Ctype.h Determina si el int isupper(int c);
argumento es una
mayúscula. Devuelve
isxdigit(c) int Ctype.h Determina si el int isxdigit(int c);
argumento es un
digito hexadecimal.
Devuelve un valor
devuelve 0
labs(l) Long int Math.h Devuelve el valor long int labs(long int l)
absoluto de l
ldexp(i,d) double Math.h Toma dos números: double ldexp(double
una mantisa y un num, double exp);
exponente y calcula
el numero en punto
flotante o notación
científica
log(d) double Math.h Devuelve el double log(double d);
Logaritmo natural de
d
log10 double Math.h Devuelve el double log10(double d);
Logaritmo en base
10 de d
malloc(u) Void(puntero) Stdlib.h Reserva u bytes de void*malloc(size_t u);
memoria, devuelve
un puntero al
principio del espacio
reservado
modf(d,*iptr) double Math.h Retorna la parte double modf(double
decimal de d. guarda valor,double *iptr)
la parte entera en el
objeto apuntado por
iptr
pow(d1,d2) double Math.h Devuelve d1 elevado double pow(double
a la potencia de d2 d1,double d2);
printf(…) int Stdio.h Escribe datos en Int printf(const
dispositivo de salida char*formato
13
estándar. Según el [,argumento,]);
tipo de dato se debe
colocar:
-%c: Carácter
-%d:Entero decimal
-%e: Real
-%f: Punto flotante
-%s:Cadena de
caracteres
-%x: Hexadecimal sin
signo.
putc(c,f) Int Stdio.h Escribe un carácter int putc(int c,FILE*f);
en el archivo f
putchar(c) Int Stdio.h Escribe un carácter int putchar(int c);
en el dispositivo de
salida de estándar
puts(c) Int Stdio.h Escribe una cadena int puts(const char*cad);
de caracteres en el
dispositivo de salida
de estándar
rand() int Stdio.h Devuelve un entero int rand(void);
positivo aleatorio
rewind(f) void Stdio.h Mueve el puntero al void rewind(FILE*f);
principio del archivo
f
scanf(…) Int Stdio.h Lee datos en el int scanf(const
dispositivo de char*formato
entrada estándar. [,dirección,…]);
Estos datos pueden
ser de tipo:
-%c: Carácter
-%d:Entero decimal
-%e: Real
-%f: Punto flotante
-%s:Cadena de
caracteres
-%x: Hexadecimal sin
signo.
sin(d) double Math.h Devuelve el Seno de double sin (double d);
d
sinh(d) double Math.h Devuelve el Seno double sinh (double d);
hiperbólico de d
sqrt(d) double Math.h Devuelve la Raíz double sqrt(double d);
cuadrada de d
srand(u) void Stdlib.h Inicializa el void srand (unsigned u);
generador de
números aleatorios
14
strcmp(s1,s2) int String.h Compara dos int strcmp(const
cadenas de char*s1,const char*s2);
caracteres
lexicográficamente.
Devuelve un valor
negativo si s1<s2; 0
si s1 y s2 son
idénticas; y un valor
positivo si s1>s2
strcmpi(s1,s2) int String.h Compara dos int strcmpi(const
cadenas de char*s1,const char*s2);
caracteres
lexicográficamente,
sin diferenciar
mayúsculas de
minúsculas.
Devuelve un valor
negativo si s1<s2; 0
si s1 y s2 son
idénticas; y un valor
positivo si s1>s2
strcpy(s1,s2) char String.h Copia la cadena de int strcpy(const
caracteres s2 en la char*s1,const char*s2);
cadena s1
strlen(s) int String.h Devuelve el numero size_t strlen(const
de caracteres de una char*s);
cadena
strset(c,s) Char(puntero) String.h Pone todos los char*strset(char*cad,
caracteres de s a c int c);
(excluyendo el
carácter nulo del
final)
system(s) int String.h Pasa la orden al system(comd);
sistema operativo.
Devuelve cero si la
orden se ejecuta
correctamente, en
otro casi devuelve un
valor distinto
tan(d) double Math.h Devuelve la double tan(double d);
Tangente de d
tanh(d) double Math.h Devuelve la double tanh(double d);
Tangente hiperbólica
de d
time(p) Long int Time.h Devuelve el numero time_t time(time_t *h);
de segundos
transcurridos
15
después de un
tiempo base
designado
toascii (c) int Ctype.h Convierte el valor del int toascii (int c);
argumento a ASCII
tolower (c) int Ctype.h Convierte una letra a int tolower (int c);
minúscula
toupper (c) int Ctype.h Convierte una letra a int toupper(int c);
mayúscula
2.3. PALABRAS RESERVADAS.
Cada lenguaje de programación tiene un conjunto de palabras restringidas o reservadas, que no las
podemos utilizar como nombres de variables, ya que estas tienen un significado para el compilador y
este inmediatamente hace una determinada acción cada vez que las encuentra. Por ello debemos evitar
escoger estas palabras como nombres de campos variables, registros, nombres de archivo, etc. Además
de éstas, están todos los nombres de funciones de biblioteca que se encuentran en cada una de las
diferentes librerías del lenguaje.
auto break case char cin class clrscr const continue

cout default define do double else enum extern float
for goto if int long register return short signed
sizeof static struct switch typedef union unsigned void volatile
while.
2. 4 VARIABLES.
Una variable del lenguaje C++ conserva, en términos generales, las propiedades de una variable
matemática. Una variable es un elemento cuyo valor puede cambiar con el transcurso del tiempo o la
ocurrencia de determinado evento. Las variables deben iniciar con letra seguida de letras o dígitos,
incluido el carácter subrayado (guión bajo) y se aconseja que estén en minúscula, C++ determina
diferentes tipos de datos para la definición de variables. El valor de una variable, se almacena en la
memoria RAM.
2.5. TIPOS DE DATOS
Un tipo de dato le asigna a una variable: tamaño en memoria, tipo de valor que debe almacenar y forma
de almacenamiento.
Los tipos de datos primitivos más comunes de C++ son:
NOMBRE DESCRIPCIÓN TAMAÑO* RANGO*

Char Caracter o entero pequeño 1 byte Ver tabla ASCII al final del documento**
Unsigned char 2 bytes
16
Es técnicamente un arreglo (o vector) de
string Cadena de caracteres Variable
datos tipo char
short Entero corto 2 bytes -32768 a 32767
unsigned short Entero positivo 2 bytes 0 a 65535
Con signo de -2147483648 a 2147483647
int Entero 4 bytes
Sin signo de 0 a 4294967295
Con signo de -9223372036854775807 a
long long Entero largo 8 bytes 9223372036854775807 Sin signo de 0 a
18446744073709551615
bool Booleano (verdadero o falso) 1 byte true o false (1 o 0)
1.17e ^- 38..3.4 e^+38 (7 dígitos
float Número de punto flotante 4 bytes
decimales)
Número de punto flotante de 2.22 e^-308..1.79 e^+308 (15 dígitos
double 8 bytes
doble precisión decimales
Long de punto flotante de 3.4e ^-4932 ..1.18 e ^+4932(18 dígitos
long double 12 bytes
doble precisión 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 máquina típica de arquitectura 32 bits.
**Los caracteres se representan utilizando el tipo char, que tiene sólo 1 byte de tamaño. Este tipo se
utiliza para representar los 255 caracteres de la tabla de caracteres del sistema. El tipo char es también
un tipo entero, ya que puede tomar valores de 0 a 255.
(tabla de caracteres ASCII en anexos al final del documento)
Estructura de la definición de una variable:
int nombreDeLaVaiable;
//”int” es el tipo de la variable, en este caso es entero
Estructura de la asignación 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, expresión debe ser del mismo tipo que el
nombre de la variable, ejemplos:
int x; // Definimos la variable x de tipo entero

char y; // Definimos la variable y de tipo caracter
17
char z; // Definimos la variable z de tipo caracter
x = (10*5)+12; // Le asignamos el valor de la expresión matemática (10*5)+12
//a x, es decir, 62.
y = 'a'; // Le asignamos el valor de 'a' a y.
z = 65; // Le asignamos a z el valor del caracter en la posición 65 de
//la tabla ASCII (La 'A').
La definición y la asignación de una variable se pueden hacer en una sola línea así:
int nombreDeLaVariable = expresión;
NOTA: el punto y coma (;) al final de la instrucción 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 ejecución de un programa, se llega a una línea de código que incluya este caracter, se
emitirá un sonido de alerta (beep)
\n: el programa reconoce este símbolo como una nueva línea, así que -al encontrarlo- dejará de escribir
en la línea actual y saltará a la siguiente.
\t: significa espacio de tabulación y se reconoce como un salto en la misma línea igual al que se da
cuando se presiona la tecla TAB en un documento de texto.
\”: debido a que las comillas están reservadas para encerrar texto, este símbolo hará que el programa
reconozca las comillas como texto y no como principio o fin de texto.
\\: permite mostrar el caracter '\' en pantalla.
2.6. OPERADORES DE C++
Para las determinadas operaciones que se pueden realizar con las variables, C++ proporciona una serie
de operadores:
Asignación:
OPERADOR DESCRIPCIÓN
= Asignación
+= Asignación con suma
18
-= Asignación con resta
*= Asignación con multiplicación
/= Asignación con división
%= Asignación con módulo
<<= Asignación con desplazamiento
>>= Asignación con desplazamiento
&= Asignación con AND lógico
^= Asignación con XOR binario
|= Asignación con OR binario
Aritméticos:
* Multiplicación
+ Suma
- Resta
/ División
% Residuo de la operación o módulo
Comparación:
!= Diferente
== Igualdad
<= Menor o igual que
< Menor que
>= Mayor o igual que
> Mayor que
Booleanos:
&& Operación lógica AND
|| Operación lógica OR
^ Operación lógica XOR
! Operación lógica NOT
19
Otros Operadores
[] Arreglo
() Argumento de función o agrupación
++ Aumento en 1
-- Decremento en 1
2.7. CARACTERES ASCII
Los códigos ASCII son una forma de asignar un número binario de 8 o 16 bits a cada caracter del alfabeto
latino, de esta forma cada caracter tendría su propio código binario y puede ser identificado
unívocamente por la máquina. C++ permite mostrar por pantalla los caracteres ASCII que son
imprimibles, es decir, a partir del caracter 32 hasta el caracter 255. Ver apéndice al final.
3. PROGRAMACIÓN ESTRUCTURADA
La programación estructurada es una forma de escribir programas de computador (programación) de
manera clara. Para ello utiliza únicamente tres estructuras: secuencia, selección e iteración.
Estructura secuencial. Una estructura de programa es secuencial si se ejecuta una tras otra a modo de
secuencia, es decir, que una instrucción no se ejecuta hasta que finaliza la anterior.
Estructura selectiva o de selección. La estructura selectiva permite la realización de una instrucción u
otra según un criterio. Sólo una de estas instrucciones se ejecutará.
Estructura iterativa. Un bucle iterativo, o iteración de una secuencia de instrucciones, hace que se
repitan mientras se cumpla una condición, en un principio el número de iteraciones no tiene por qué
estar determinado.
El lenguaje C++ hereda de C las características de un lenguaje estructurado, así como le agrega
funcionalidades de la orientación a objetos. La estructura general del lenguaje es secuencial, es decir,
las instrucciones se ejecutan una seguida de las otras, pero, C++ provee además ciertas estructuras para
controlar el flujo secuencial de una aplicación, 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 instrucción cout. Su uso se hace de la
siguiente manera:
20
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 instrucción endl indica que lo que se escribe debe estar en la línea siguiente de la pantalla, es
parecido a un \n.
Ejemplo de su uso:
Ejemplo 1
#include <iostream>
using namespace std;
class Modulo{};
int main () {
int num=9, mod;
mod=num%2;
cout<<"El residuo de la division entre "<<num<<" y 2 es "<<mod;
system("pause");
}
En el anterior programa incluimos las librerías iostream y conio, declaramos las variables num y mod de
tipo int y el programa principal se encarga de calcular el residuo de la división 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 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>
class HolaMundo{};
int main (){
char nombre[10]="nombre";
int edad=10;
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
system("pause");
21
}
3.1.2. ENTRADA DE DATOS
Para la salida de datos por pantalla C++ nos provee con la instrucción cin la cual tiene varias formas de
uso, la más 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 múltiples espacios, se hace uso de lo siguiente:
cin>>ws;
cin.getline(cadena, número);
La primera instrucción elimina los espacios en blanco y los finales de página que se encuentren
almacenados en memoria.
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. Número es una variable entera que indica el
número de caracteres a leer, se debe hacer si la cadena de caracteres tiene espacios en blanco.
Ejemplo 3
#include<iostream>
class Nombre{};
int main(){
char nombre[50];
int edad;
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
//de la memoria
cin.getline(nombre,50); //Se indica que se van a leer
//máximo 59 caracteres que es el tamaño
//de la caden nombre.
cout<<"Su nombre es: "<<nombre<<"y su edad es: "<<edad<<endl;
system("pause");
}
22
3.2. INSTRUCCIÓN IF
Esta es una estructura de selección que permite elegir qué acción deberá seguir durante la ejecución del
programa, a partir de determinada condición.
Para utilizarla basta con escribir la palabra reservada “if” y, a continuación, la condición bajo la cual se
cumplirán las instrucciones que se encierran en unas llaves. Esas instrucciones se ejecutarán sólo
cuando la condición -dentro de las llaves- se haga verdadera. La estructura de la sentencia if es la
siguiente:
if(condición)}
{
Instrucciones que se ejecutan si la condición es verdadera;
}
Ejemplo
if(a>b)
cout<<a; //una sola instrucción
Si instrucciones es una sola, no necesita llaves si se necesita que pase algo; en caso contrario, a la
condición ponemos la palabra reservada “else”, justo después 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 ubicar las sentencias que se llevarán a cabo, en caso de que no se
cumpla la condición del if.
if(condición){
//Instrucciones para cuando la condición es verdadera
}
else{
//Instrucciones para cuando la condición es falsa.
}
La condición está conformada por una variable, un operador relacional y otra variable o constante, los
operadores que podemos utilizar son los siguientes:
Comparación:
!= Diferente
== Igualdad
<= Menor o igual que
< Menor que
>= Mayor o igual que
23
> Mayor que
Es posible componer una condición con 2 o más condiciones, basta con unirlas a través de operadores
lógicos “y” u “o”.
Es importante aclarar que, cuando solo se va a ejecutar una sola línea de código dentro de las llaves, es
posible no colocarlas; sin embargo, se recomienda ponerlas siempre, para aportar más claridad a la hora
de programar.
Estructura general
if(condición){
//Instrucciones para cuando la condición es verdadera
}
else {
if{
//Instrucciones.
}
else {
//Instrucciones.
}
}
La agrupación de instrucciones else if, y la instrucción else son opcionales, es decir, se pueden tener
además un conjunto de else if seguidos sin terminar en un else, o un solo else después del if, o solo tener
la instrucción if.
NOTA: La instrucción else SIEMPRE debe estar precedida por un if.
Ejemplo 4
A continuación veremos más a fondo el uso de la sentencia if Con el siguiente código fuente se debe
ingresar una cantidad m y otra n, se debe mostrar por pantalla cuál es qué con respecto a la otra la otra:
menor, menor o igual, mayor, mayor o igual o igual.
#include<iostream>
class MayorMenor{};
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"<<endl;
}else
if (n>m){
cout<<"m es menor que n"<<endl;
}else{
cout<<"m es igual a n"<<endl;
}
24
system("pause");
}
De esta manera vemos cómo se usa la sentencia if de manera anidada. Es conveniente detallar que el
último bloque no tiene una condición, 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 más básica del if, sin el else. Aquí, si el usuario ingresa
un número mayor a 5, se le indica que ganó:
#include<iostream>
class NumeroN{};
int main(){
int n;
cout<<"Ingrese n:"<<endl;
cin>>n;
if(n>5){
cout<<"Gano!!!";
}
system("pause");//Observe que el if se puede usar sin el else
}
Ampliando el anterior ejemplo, en el siguiente, si el usuario ingresa un número mayor a 5 se le indica

que ganó, en caso contrario, se le indica que perdió:
#include<iostream>
class NumeroN2{};
int main(){
int n;
cout<<"Ingrese n:"<<endl;
cin>>n;
if(n>5){
cout<<"Gano"<<endl;
} else{
cout<<"Perdio!!!"<<endl;
}
system("pause");
}
Ejemplo 6
Cierta universidad tiene un programa para estimular a los estudiantes con buen rendimiento académico,
así:
● Si el promedio es de 4,5 o más y el estudiante es de pregrado, entonces cursará 28 créditos y se
le hará un 25% de descuento.
25
● Si el promedio es mayor o igual a 4,0 pero menor que 4,5 y el estudiante es de pregrado,
entonces cursará 25 créditos 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 créditos y no
tendrá ningún descuento.
● Si el promedio es mayor o igual a 2,5 y menor que 3,5 y es de pregrado, cursará 15 créditos 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 créditos y se le hará un 20%
de descuento.
● Si el promedio es menor de 4,5 y es de posgrado cursará 10 créditos y no tendrá descuento.
Hacer un programa que determine cuánto debe pagar un estudiante y cuántos créditos registra si el
valor de cada crédito es de $50000 para pregrado y $300000 para posgrado.
#include<iostream>
class Matricula{};
int main()
{
//cs-clase de estudiante
//nc-número de créditos
//pe-promedio estudiante
//pdes-porcentaje de descuento
//vcred-valor crédito
//vsd-valor a pagar sin descuento
//des-descuento
//vt-valor total a pagar
cout.setf(ios::fixed); // Evita que la información salga en
// forma exponencial
cout.precision(2); // Saca la información 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) // Comparación 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;
26
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. INSTRUCCIÓN WHILE
Cuando necesitemos que una o un conjunto de instrucciones se repitan, podemos acudir a la instrucción
WHILE (mientras).
Su sintaxis es la siguiente:
while(condición)
{
//instrucciones que se ejecutan mientras se cumpla la condición
}
Funcionamiento: cuando el programa llega a la instrucción while, se evalúa la condición y, si ésta es

verdadera, entonces entra a la estructura; de pasar esto, las instrucciones dentro del while se ejecutan
y, al terminar dicha ejecución, la condición se vuelve a evaluar automáticamente; si sigue siendo
verdadera entonces se repite la ejecución de las instrucciones; es decir, el valor de verdad de la
condición le permite al algoritmo tomar la decisión de repetir o dejar de ejecutar el grupo de
instrucciones.
27
Tenga en cuenta que, dentro del grupo de instrucciones, debe haber -por lo menos- una instrucción que
modifique el valor de verdad de la condición; de no ser así, nunca se terminaría la repetición de la
ejecución de las instrucciones.
Ejemplo 7
Se desea sacar el promedio de una serie de 5 números positivos que ingresa el usuario.
#include<iostream>
class Promedio{};
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");
Ejemplo 8
Evaluar la siguiente función: y=x2-2, mostrando en una tabla el valor de la función evaluada desde x=0
hasta x=10, junto al valor de la x, es decir, la aplicación deberá mostrar algo como lo siguiente:
x y(x)
0 -2
1 -1
… …
#include<iostream>
#include<math.h>
class Potencia{};
int main()
{
float y,x;
x=0;
cout<<"funcion: y(x)=x^2-2"<<endl;
cout<<" x y(x)"<<endl;
28
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 cuántos números desea
ingresar; y para el segundo le solicitamos al usuario el valor inicial, valor final y el paso.
#include<iostream>
#include<math.h>
class Funcion{};
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)
{
y=pow(x,2)-2;
cout<<" "<<x;
cout<<" "<<y<<endl;
x=x+step;
i++;
}
cout<<endl<<endl;
system("pause");
}
Ejemplo 10
Encontrar el promedio de n números.
#include<iostream>
class PromedioNumeros{};
int main()
29
{
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 conocía el número de veces que se tenían que repetir las
instrucciones dentro del while, este tipo de solución se llama Esquema Cuantitativo y se implementa a
través de un contador.
Un contador es una variable que cuenta la cantidad de veces que se repiten las instrucciones del ciclo o
también 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 número 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 solución es el llamado Esquema Cualitativo: este esquema es utilizado cuando no se
conoce el número de veces que debe repetirse la secuencia de un determinado ciclo. En esta clase de
ciclo el usuario decide cuándo terminar con el proceso repetitivo sin importar cuántas 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 solución cualitativa del primer ejemplo seria:

Como se dijo que los números ingresados por el usuario debían ser positivos, aprovechemos este hecho
y determinemos que, cuando el usuario decida terminar de ingresar números, que simplemente digite
un cero o un número negativo (por facilidad de digitación seleccionamos cero).
Ejemplo 11
30
#include<iostream>
class Promedio{};
int main()
{
int numero,n=1;
suma=0;
cout<<"Digite el primer numero: "; //se lee el primer número
cin>>numero;
while(numero>0)
{
suma+=numero;
n++;
cin>>numero;
}
promedio=suma/n;
cout<<"El promedio de los numeros es: "<<promedio<<endl;
system("pause");
}
3.3. VARIABLES TIPO BANDERA
Otra forma de implementar esquemas cualitativos es a través 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
Hacer un programa que encuentre la suma de los valores de un conjunto de números, la cantidad de
valores negativos, positivos, iguales a cero y el total de números en el conjunto.
Como no se sabe cuántos números entrará el usuario, usamos un esquema cualitativo, controlado con la
bandera siga que vale S si el usuario tiene más números o N si no tiene más.
31
#include<iostream>
class OperacionNumeros{};
int main()
{
int valn=0, val0=0, valp=0,totaln;
char siga; siga='S';
float suma =0, num;
while(toupper(siga)=='S')
{ // La función toupper convierte una letra minúscula a mayúscula
system("cls");
cout<<"ENTRE NUMERO : ";
cin>>num;
suma+=num;
if(num > 0)
valp++;
else
if(num==0)
val0++;
else
valn++;
cout<<"HAY MÁS NUMEROS S/N? ";
cin>>siga;
}
totaln=valp+valn+val0;
cout<<"RESULTADOS: "<<endl<<endl;
cout<<"SUMA DE LOS NÚMEROS: "<<suma<<endl;
cout<<"NUMEROS NEGATIVOS: "<<valn<<endl;
cout<<"NUMEROS IGUALES A CERO: "<<val0<<endl;
cout<<"NUMEROS POSITIVOS: "<<valp<<endl;
cout<<"TOTAL DE NUMEROS: "<<totaln<<endl<<endl;
cout<<"PRESIONE TECLA PARA TERMINAR"<<endl;
system("pause");
}
3.5. INSTRUCCIONES ADICIONALES
Existen otras tres instrucciones alternativas a las mostradas anteriormente para la programación
estructurada, estas instrucciones son usadas algunas veces reemplazando las instrucciones básicas,
mejorando, acortando la programación o haciéndola más entendible. Lo que se hace con estas
instrucciones se puede hacer con las instrucciones básicas, más no lo contrario.
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 número 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 condición de repetición y está formada por
dos partes: las instrucciones que se desean repetir y, al final de ésta, la condición que controlará el
número de veces que se repetirán las instrucciones.
32
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 condición de repetición
y, en la estructura mientras, la condición de terminación 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 condición
}while(condición);
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 opción.
//El uso de do-while se hace necesario dado que se debe mostrar el menú
//mínimo en una ocasión
#include<iostream>
class Menu{};
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;
system("pause");
return 0;
}
//usando el ciclo while

#include<iostream>
class Menu{};
int main(){
int opcion;
cout<<"MENU"<<endl;
33
cin>>opcion;
while(opcion!=3){
cout<<"MENU"<<endl;
cin>>opcion;
}
cout<<"FIN DEL PROGRAMA..."<<endl;
system("pause");
return 0;
}
Como se puede observar en el ejemplo, el uso de do-while, ayuda a minimizar el número de instrucciones
a ejecutar dado que la condición se evalúa al final del bucle.
Ejemplo 14
Hacer un algoritmo que encuentre la suma de los primeros N números 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 LÍMITE DE LOS NÚMEROS: ");
gotoxy(48,12);
cin>>n;
do
{
suma+=num;
num++;
}while(num <= n);
clrscr();
textbackground(LIGHTRED); textcolor(WHITE);
gotoxy(30,12);
cprintf("LA SUMA ES: ");
gotoxy(41,12);
cout<<suma;
do
{
gotoxy(28,16);
cprintf("PRESIONE ESC PARA TERMINAR");
34
tecla=getch();
}while(tecla !=esc);
}
3.5.2. FOR
La estructura for permite que una o más instrucciones secuencia se repitan cero o más veces, mientras
los valores de una progresión aritmética -de razón 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 cómo se implementa esta clase de
ciclos y la estructura while, es que el for maneja la inicialización del contador y su incremento en forma
automática, es decir, lo hace la estructura.
Los valores de los parámetros que maneja este ciclo son controlados por la estructura y, una vez
establecidos sus valores o activado el ciclo, no es factible cambiarlos. Su implementación en C++ es la
siguiente:
for(variableDeControl=valor inicial; condición; incremento/decremento){

//instrucciones que se ejecutan mientras se cumpla la condición
}
Ejemplo 15
Leer n datos y calcular su promedio.
#include<iostream>
class PromedioUsandoFor{};
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;
system("pause");
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 número de iteraciones del ciclo, y puede ser declarada e inicializada dentro de la
35
declaración 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 función cout, no afecta el
valor de la variable cont, ya que no está siendo modificada mediante el operador de asignación (=), o
con el uso del operador de post o pre incremento (++).
Ejemplo 16
Otro ejemplo, calcular el factorial de un número n (Factorial de n=n*(n-1)*(n-2)*….*2*1)
#include<iostream>
class Factorial{};
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;
system("pause");
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 múltiple donde, de acuerdo con el valor que tenga el controlador, se realiza una
determinada tarea una sola vez, es decir, no repite la ejecución de la tarea o secuencia.
De acuerdo con el valor que tenga el selector el control de ejecución del programa, pasa a uno de varios
puntos de éste, evitando así una serie de preguntas (estructura decisión lógica o un anidamiento de las
mismas).
Su estructura es la siguiente:
switch(selector){
case valor 1:
instrucción 1;
instrucción 2;
instrucción n;
36
break;
case valor n:
instrucción 1;
instrucción 2;
instrucción n;
break;
default:
instrucción 1;
instrucción 2;
instrucción 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 instrucción break. Si lo que se desea es que sólo se ejecuten las instrucciones del caso
en el que se encuentra el selector, es necesario que se incluya la instrucción break. El caso default
agrupa aquellas opciones diferentes a las cubiertas dentro de la estructura, es decir, éste incluye las
instrucciones que se ejecutarán si el selector no asumió ninguno de los casos que incluye la estructura.
Ejemplo 17
En un programa deportivo se ha concluido que la duración de la sesión de práctica depende del peso de
la persona y de las condiciones que presenta en la revisión médica. La revisión médica califica a las
personas como de condición 3, 4, 5 ó 6. El tiempo de cada persona es igual al peso por una rata que se
basa en su condición; é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>
class Swithc{};
int main()
{
int iden,con;
float peso,r=0,t;
cout<<"Ingrese su identificacion o cero para salir: ";
cin>>iden;
while (iden > 0)
{
cout<<"Ingrese su peso: ";
cin>>peso;
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;
37
break;
case 6: r = 0.26;
break;
}
t = peso * r;
cout<<"su identificacion es: "<<iden<<endl;
cout<<"El tiempo de duración de su sesion es: "<< t<<endl;
cout<<"Ingrese otra identificación, o cero para salir: ";
cin>>iden;
}
}
Ejemplo 18
Leer el paso en el que se encuentra un conductor y mostrar los que aún le quedan por realizar, para salir
en su automóvil. Al no usarse break después de los casos 1-4, se efectúan 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>
class Auto{};
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 cinturón) 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;
}
system("pause");
return 0;
}
La instrucción break también puede ser usada en los ciclos para terminar su ejecución. Por ejemplo, en
los ciclos for y while que se muestran a continuación.
Ejemplo 19
38
//Uso de break en ciclos while
#include<iostream>
class Ciclo{};
int main(){
int cont=0;
while(true){ //ciclo que se repite infinitamente
cout<<"encerrado"<<endl;
cont++;
if(cont==10)break; //cuando el contador llegue a 10 se termina la
//ejecución del ciclo
}
system("pause");
return 0;
}
//Uso de break en ciclos for

#include<iostream>
class Break{};
int main(){
int cont=0;
for(;;){ //ciclo que se repite infinitamente
cout<<"Encerrado"<<endl;
cont++;
if(cont==10)break; //Rompe el ciclo
}
system("pause");
return 0;
}
En la programación estructurada no es recomendable usar la sentencia break como medio para hacer la
ruptura de un ciclo, ya que mediante técnicas estructuradas (por ejemplo cambiar el valor de la
condición de un ciclo), se puede efectuar la misma función que hace un break.
4. SUBPROGRAMAS
A lo largo del manual se han tratado los problemas como un todo, como si fuesen un solo módulo. Una
de las grandes ventajas que tiene la programación es la división de problemas grandes en subproblemas
y, a su vez, éstos también pueden dividirse en problemas más pequeños. Esta técnica permite dar más
claridad y facilidad en la construcción y corrección de los errores que se presentan en la solución de un
problema determinado. Cada una de las divisiones que se hacen para obtener la solución de un
problema se denomina módulo y cada módulo es implementado por medio de los subprogramas.
39
Un subprograma es un pequeño programa diseñado para efectuar una tarea particular, bajo la
dependencia de un programa u otro subprograma que lo utiliza. De esta manera, el subprograma es
diseñado para ser utilizado por otros procesos más amplios, dentro de los cuales existe un flujo de
recibo y entrega de información.
La utilización de subprogramas en la solución de problemas grandes tiene muchas ventajas. Por ejemplo,
para tareas que deban efectuarse más de una vez, la modularidad evita la necesidad de programación
redundante, esencialmente el mismo conjunto de instrucciones; en vez de ello, un módulo puede
construirse e invocarse cada vez que se necesite hacer la misma labor, por lo tanto, el uso de módulos
permite o hace que los programas sean más cortos. De igual manera, la fragmentación en módulos
individuales proporciona claridad, facilidad de distribución de trabajo en equipo y, por ser programas
cortos, son más fáciles de escribir, corregir y su estructura lógica es más clara que la de los programas
que no están divididos en módulos.
El subprograma, por ser un programa, debe cumplir con las mismas características de éste y hacer tareas
similares como aceptar datos, escribir datos y hacer cálculos; sin embargo, es utilizado para un propósito
específico. El subprograma recibe datos del programa o subprograma que lo invoca y éste le devuelve
resultados.
La comunicación que se establece entre el programa llamante y el subprograma se hace a través de
variables denominadas parámetros, que hacen las veces de recipiente, unas de recibo y otras de envío
de información.
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:
En el gráfico las flechas indican el flujo de ejecución del programa; observe que cuando se ejecuta una
instrucción de llamada a un subprograma, el algoritmo llamante se detiene, ya que no solamente le
transfiere información al subprograma, sino también el control de ejecución; esto hace que se active el
40
subprograma, se les dé valor a las variables que lo conforman y se ejecuten una a una las instrucciones.
Una vez que finaliza su ejecución, tiene la información requerida por el programa llamante; por lo tanto,
se la entrega y devuelve el control de ejecución a la instrucción siguiente o a la misma instrucción desde
donde fue llamado, dependiendo de la clase de subprograma.
En la figura también 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. CLASIFICACIÓN DE LOS SUBPROGRAMAS
La división de los subprogramas se hace con base en el número o cantidad de valores que el
subprograma le envía al programa o subprograma llamante.
4.1.1. PROCEDIMIENTOS O SUBRUTINAS
Son subprogramas que devuelven cero o más valores al programa o subprograma que lo invoca (utiliza)
y retornan el control de ejecución a la instrucción siguiente desde donde se llaman.
A. REPRESENTACIÓN
void Nombre (tipo de dato parámetro1, tipo de dato parámetro2, ...)

{
//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 más subprogramas con el mismo nombre en el mismo
programa).
Los Parámetros son una lista de campos variables separados por comas y son utilizados para establecer
la comunicación entre el módulo que lo activa y el subprograma. Unos parámetros serán de recibo
(almacenan la información que les envía el módulo que los invoca), y otros de envío de información (la
transfieren a quien invoca el subprograma).
Ejemplo 20
Hacer un subprograma que ordene tres números distintos en forma ascendente.
Análisis
Consiste en detectar cuáles son los parámetros de recibo, cuáles los de envío y el proceso que es
necesario hacer para llegar a los parámetros de envío, partiendo de los de recibo.
41
Parámetros de recibo
Son las variables que van a recibir información del módulo 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 información a
través de una instrucción de lectura y a los parámetros de recibo se les da información a través del
módulo que invoca el subprograma; es decir, que se asigna una información automática desde las
variables que envían información, desde el módulo llamante, hacia los parámetros de recibo del
subprograma. Estos parámetros son:
• Valor del primer número
• Valor del segundo número
• Valor del tercer número
Parámetros de envío
Son los parámetros que envían información al módulo que invoca al subprograma, semejante a los datos
de salida de los programas, con la diferencia de que los parámetros de envío le entregan la información
a las variables que la reciben, dentro del módulo llamante.
• Menor valor
• Valor medio
• Mayor valor
Proceso
Para determinar el orden ascendente de los tres números, primero se encuentra el menor de todos a
través 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.
Definición 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. ACTIVACIÓN DE UN PROCEDIMIENTO
El subprograma no inicia ni termina por sí mismo; por lo tanto, necesita ser activado (hacerlo funcionar)
desde un módulo externo. Esto se hace cuando el módulo llamante necesita la ayuda (para una labor
específica) que hace el módulo subordinado. La activación se hace a través de la siguiente instrucción.
42
Formato
Nombre (Argumentos)
Los argumentos son nombres de campos (valores, constantes, variables o expresiones) que usa el
módulo amplio y que tienen una correspondencia biunívoca con los parámetros con los cuales se
construyó el subprograma; por lo tanto, éstos deben ser iguales en número y en tipo de dato que los
parámetros, ya que a cada argumento le corresponde un parámetro o viceversa.
Los argumentos también son de dos clases: unos que envían información al subprograma y otros que
reciben información.
Cuando el subprograma es activado, los argumentos de envío son copiados en los parámetros de recibo,
(parámetros de recibo argumentos de envío). Y cuando el subprograma deja de ejecutarse los
parámetros de envío le asignan información a los argumentos de recibo. Por ejemplo, elaborar la
instrucción que active el procedimiento ORDEN. Este subprograma tiene 6 parámetros (tres de recibo y
tres de envío), por lo tanto, la instrucción que lo invoque debe tener 6 argumentos (tres de envío y tres
de recibo).
Si las variables a utilizar como argumentos son en su orden: N1, N2, N3, MEN, MED y MAY la instrucción
sería.
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 información)

MEN=MENOR
MED=MEDIO
MAY=MAYOR
Los subprogramas tienen tres formas de ubicarse dentro de un programa: antes de int main, después del
int main o estar dentro de una librería como lo veremos más adelante.
#include<iostream>
#include<conio2.h>
//CODIFICACIÓN DEL PROCEDIMIENTO ORDEN
43
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
{
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;
44
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 después 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()
{
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
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;
}
}
}
}
Ejemplo 21
Elaborar un programa que utilice un procedimiento que encuentre la suma y el promedio de N números.
#include<iostream>
#include<conio2.h>
/* Codificación del procedimiento, n parámetro de recibob
sum y prom parámetros de envío*/
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);
46
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 través de una variable, expresión o valor involucrados en una instrucción
return, dentro del conjunto de instrucciones, o en el nombre de ésta; por lo tanto, este tipo de
subprogramas en su encabezamiento (prototipo), sólo tiene parámetros de recibo. Las funciones
devuelven el control de ejecución a la misma instrucción desde donde se llaman.
Una función puede tener varios return, pero una vez que ejecuta uno, termina la función.
A. SINTAXIS
//Para definir (declarar) la función

tipo nombre(parámetros)
que retorna la función
{
Instrucciones
return valor;
}
//Para invocar (instanciar) la función

Variable = nombre(parametros);
Ejemplo 22
Elaborar un programa que utilice una función que encuentre el valor mayor en un conjunto de 3
números reales diferentes. La función debe retornar el mayor entre los tres números.
#include<iostream>
#include<conio2.h>
float mayor(float n1,float n2, float n3)//n1, n2, y n3 parámetros de recibo
{
float valmay;
if((n1>n2) && (n1>n3))
valmay=n1;
else
if(n2>n3)
valmay=n2;
else
47
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);
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 ó función).
Ejemplo 23
En un programa, utilizar la función 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;
48
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 función que determine si un número es primo o no.
#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 también con
una bandera o switche */
int main()
{
int num;
clrscr();
gotoxy(20,12); textcolor(6); textbackground(BLUE);
cprintf("ENTRE EL NÚMERO: ");
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. LIBRERÍAS
Una librería hecha por el programador está formada por subprogramas previamente diseñados, que
pueden ser utilizados por el programador para realizar las operaciones que hacen los subprogramas que
la conforman, sin que estos subprogramas estén 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
específico anexándole la extensión .h, por ejemplo entorno.h. Esta extensión la colocamos nosotros ya
que no se hace por defecto, por lo que una librería no se puede compilar.
49
Cuando la librería se coloque en el encabezado del programa, para diferenciarla de las librerías del
compilador, se coloca entre comillas dobles, colocando la ruta donde se encuentra almacenada la
librería, por ejemplo, si la librería llamada entorno1.h está guardada en el disco C, en la carpeta librerías,
el encabezado sería el siguiente:
#include”C:\librerias\entorno.h”, pero si la librería está guardada en la misma carpeta donde está el
programa que la utiliza, el encabezado simplemente sería:
#include”entorno.h”.
Ejemplo 25
Elaborar una librería que contenga los siguientes subprogramas: un procedimiento que elabore un
cuadro dentro en la pantalla, el procedimiento orden, el procedimiento sumprom y la función mayor.
Esta librería 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);
}
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)
{
{
50
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;
}
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 NÚMERO "<< i<<" ";
cin>>numero;
sum+=numero;
}
prom=sum/n;
}
//****************************************************************************
float mayor(float n1,float n2, float n3)//n1, n2, y n3 parámetros de recibo
51
{
float valmay;
if((n1>n2) && (n1>n3))
valmay=n1;
else
if(n2>n3)
valmay=n2;
else
valmay=n3;
return valmay;
}
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 NÚMEROS ORDENADOS";
gotoxy(21,12); cout<<"2: SUMA Y PROMEDIO DE N NÚMEROS";
gotoxy(21,13); cout<<"3: MAYOR ENTRE TRES NÚMEROS";
gotoxy(21,14); cout<<"4 SALIR DEL MENÚ";
gotoxy(21,16); cout<<"SELECCIONE LA OPCIÓN 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);
52
system("pause");
break;
case 2: system("cls");
gotoxy(20,12);
cout<<"DIGITE LA CANTIDAD DE NÚMEROS: ";
cin>>n;
sumprom(n,sum,prom);
gotoxy(20,12);
cout<<"LA SUMA ES: "<<sum<<" Y EL PROMEDIO: "<<prom;
gotoxy(20,16);
system("pause");
break;
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 LIBRERÍA PARA VALIDAR Y CREAR CUADROS
Se va a construir una librería que se llame ENTORNO.H y que haga dos cosas:
A. Que valide la información que debe entrar el usuario. Es muy común 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 ejecución 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 validación le permite al programador recojer los errores del usuario al máximo; 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 ejecución cometido lo saque del
programa. En el caso arriba mencionado, si el usuario digita K1, se le envia un mensaje diciendo
que sólo digite números y que vuelva a digitar. Los datos que ya haya digitado no se pierden, así
53
que continúa entrando más datos. La opción de volver a digitar se ha colocado al final de la
pantalla, para que no interumpa ningún cuadro que se esté utilizando.
A. Validación de números. Significa que el usuario solo puede digitar números o, en algunos
casos, el signo menos y/o el punto decimal, pero la validación permite que él digite
cualquier caracter, por eso hay que declarar dos variables para el número que se va a
validar: una de tipo carácter y otra de tipo numérica. Luego, a través de la función atold, se
convierte lo que se almacenó en la variable tipo caracter a números y con eso sigue
trabajando.
A.1 Validación de números enteros: short, int, long long. En este caso el usuario solo puede digitar
números positivos y negativos, si digita otro caracter inmediatamente se le enviará un mensaje al
usuario para que vuelva a digitar y continúe entrando más datos si los tiene. La función es la siguiente:
long long validarEntero(char numc[])
Aunque en el ejemplo 28 está la forma de uso, a continuación verá una demostración. Por ejemplo:
para validar la variable número 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
dígitos tenga el mayor número 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 función atold que convierte los caracteres almacenados en numestc a números y los almacene
en la variable numérica numest. Así:
char numestc[8]; /*significa que la cantidad de estudiantes no tiene más de 7

dígitos.*/
int numest;
cin>>numestc; // Se lee una variable de tipo char
numest=validarEntero(numestc); // numest queda con solo dígitos
SIGA TRABAJANDO………………………………………………………………………………………………………………………
Esto ocurre con la validación de números 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 conversión.
A.2 Validación de números reales: float, double o long double. En esta función el usuario sólo puede
digitar números, el signo menos y el punto decimal que puede estar al principio o intermedio de la hilera
de dígitos, no permite que se coloquen dos veces el punto decimal. La función es:
double validarReal(char numc[]). Su uso es similar al de vaidarEntero(numc[]), solo que aquí se define
como variable numérica una variable de cualquier tipo de los arriba mencionados. La función utiliza
strtod para la conversión de caracteres a dígitos con el punto decimal o sin él.
A.3 Validación de números reales positivos: float, doublé o long doublé. Su uso es igual que la anterior
54
pero no deja que se coloque el signo menos. El nombre de la función es:
double validarRealPositivo (char *numc) // El * es semejante a lo que hay entre paréntesis en las
funciones anteriores.
A.4 Validación de números enteros positivos: short, int, long long. Igual a la función validarEntero, pero
no admite números negativos. La función es:
long long validarEnteroPositivo(char numc[])
B. Validación de caracteres (letras). Es chequear que el usuario sólo digite letras, se puede hacer de tres
formas: que digite letras minúsculas y mayúsculas, que solo digite mayúsculas o minúsculas. Ejemplo:
Validar letras mayúsculas y minúsculas, digamos un nombre, donde cada nuevo nombre o apellido debe
iniciar con mayúscula.
char nombre[48];
clrscr();
cout<<”DIGITE EL NOMBRE “<<endl;
cin>>ws; 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 Validación de mayúsculas y minúsculas
Se hace mediante un procedimiento llamado validarCaracteres(char hilera[]), sólo admite que se digiten
letras minúsculas y mayúsculas.
B.2 Validación de mayúsculas. Sólo permite, para la variable de tipo caracter, que se digiten letras
mayúsculas.
Nombre: void validarMayusculas (char hilera[])
Uso: validarMayusculas(nombre);
C. Creación de cuadros en la pantalla. Para incluir textos internamente, por ejemplo cuando se crean
programas usando menús. Todos los cuadros están 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 línea 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);
55
El cuadro se construye a partir de la fila 5 columna 20 y finaliza en la fila 17 columna 55.
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
Librería entorno.h más adelante.
C.3 void cuadro2()
El procedimiento forma un cuadro con línea 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 línea 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 línea doble que se inicia a construir desde un cuadro pequeño 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 FUNCIÓN VALIDA UN NÚMERO ENTERO: SHORT, INT O LONG, DEVUELVE

EL NÚMERO DIGITADO VALIDADO O SEA, QUE SÓLO CONTENGA DÍGITOS Y/O EL SIGNO MENOS
RETORNA UN long long*/
long long validarEntero(char numc[])
56
{
cout.setf(ios::fixed);
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 SÓLO NÚMEROS ENTEROS, VUELVA A DIGITAR ";
cin>>ws;
cin.getline(numc,20);
gotoxy(10,24);
cout<<"
";
}
}
}
while(i<nc);
numeroEntero=atoll(numc);
return numeroEntero;
}
/*************************************************************************************
*****************************
/* ESTA FUNCIÓN VALIDA UN NÚMERO FLOAT O DOUBLE Y DEVUELVE
EL NÚMERO DIGITADO VALIDADO, ES DECIR, QUE SOLO CONTENGA DÍGITOS, UN PUNTO Y QUE
EL NÚMERO SEA POSITIVO
RETORNA UN double */
double validarRealPositivo(char *numc)

{
double numeroReal;
short nc,i;
do{
i=0;
char siga='S';
57
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 NÚMEROS POSITIVOS, VUELVA A DIGITAR ";cin>>ws;
gotoxy(10,24);
cout<<"
";
}
}
}
while(i<nc);
numeroReal=strtod(numc,'\0');
return numeroReal;
}
/
**************************************************************************************
*****************
/* ESTA FUNCIÓN VALIDA UN NÚMERO ENTERO: SHORT, INT O LONG, DEVUELVE
EL NÚMERO DIGITADO VALIDADO, ES DECIR, QUE SOLO CONTENGA DÍGITOS Y QUE EL NÚMERO
SEA POSITIVO
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++;
else{
58
siga='N';
//clrscr();
gotoxy(10,24);
cout<<"DIGITE NÚMEROS 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 SÓLO DIGITE LETRAS (MAYÚSCULAS O
MINÚSCULAS, 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<<"SÓLO DIGITE LETRAS, VUELVA A DIGITAR ";
cin>>ws;cin.getline(hilera,40);
gotoxy(4,24);
cout<<"
";
}
}
}
while(i<nc);
}
59
/**************************************************************
EL PROCEDIMIENTO validaMayusculas CHEQUEA QUE UNA VARIABLE TIPO CARACTER NO
ALMACENE SINO LETRAS MAYÚSCULAS. SI NO HAY ERRORES, SIGA TRABAJANDO QUE TODO ESTÁ
CORRECTO */
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 MAYÚSCULAS, VUELVA A DIGITAR ";
cin>>ws;cin.getline(hilera,40);
gotoxy(4,24);
cout<<"
";
}
}
}
while(i<nc);
}
//********************************************************************
/*ESTE PROCEDIMIENTO GENERA UN CUADRO CON LÍNEA 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*/
QUITAR
{
int i;
textbackground(0);
for(i=(ci+1);i<cf;i++){
gotoxy(i,fi);
gotoxy(i,ff);
}
for(i=fi+1;i<ff;i++){
60
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);
}
}
/****************************************************************
61
ESTE PROCEDIMIENTO FORMA UN CUADRO EN PANTALLA CON UN SUBCUADRO SUPERIOR CON
LÍNEA 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 LÍNEA DOBLE
quitR
int i;
for(i=(ci+1);i<cf;i++){
gotoxy(i,fi);
cout<<char(205); //caracter Í
gotoxy(i,ff);
cout<<char(205); //caracter Í
}
for(i=(fi+1);i<ff;i++){
gotoxy(ci,i);
cout<<char(205); // caracter Í
62
gotoxy(cf,i);
cout<<char(205); // caracter Í
}
for(i=fi+1;i<ff;i++){
gotoxy(ci,i);
cout<<char(186); // caracter º
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 È
gotoxy(cf,ff);
cout<<char(188); // caracter ¼
}
/*******************************************************************
ESTE PROCEDIMIENTO GENERA UN CUADRO, DESDE UN TAMAÑO PEQUEÑO HASTA LLEGAR A UNO MÁS
GRANDE.
LA POSICIÓN 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<<'Û';
}
for(i=v;i<=q;i++){
gotoxy(w,i);
cout<<'Û';
gotoxy(z,i);
cout<<'Û';
}
63
Sleep(450);
w=w-3;
v=v-1;
z=z+3;
q=q+1;
cont=cont+1;
}
}
/***********************************************************************************
Quitar
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;
gotoxy(15,7);
cprintf("±± ±± ±± ");cout<<endl;
gotoxy(15,8);
gotoxy(15,9);
gotoxy(15,10);
cprintf("±± ±±±±±±±±±±±±±±±± ±±±±±±±±±±±±±±±± ");cout<<endl;
gotoxy(15,11);
gotoxy(15,12);
gotoxy(15,13);
gotoxy(15,14);
gotoxy(15,15);
gotoxy(15,16);
gotoxy(15,17);
cprintf("±±±±±±±±±±±±± ±± ±± ");cout<<endl;
textbackground(3); textcolor(WHITE);
gotoxy(25,22);cprintf("PRESIONE TECLA PARA CONTINUAR ");
getch(); textbackground(0);
}//Fin entorno.h
64
//*******************************************************************
EJEMPLO 28
Validación de números enteros

Vamos a hace una demostración de validación de números enteros (short, int, long long, float, double y
long doublé), utilizando la librería anterior ENTORNO.H.
/* PROGRAMA QUE VALIDA NÚMEROS 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 VALIDACIÓN, PRUEBE ENTRANDO LETRAS U OTROS CARACTERES TENGA CUIDADO CON
EL RANGO DE short */
num=validarEntero(numc);/* Si se cometen errores corríjalos y si no siga trabajando
con num*/
//SIGA CON LAS DEMÁS 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);
cin>>numc; //Observe se lee un tipo char, usted va a trabajar con numi
EL RANGO DE int*/
numi=validarEntero(numc);/* Si se cometen errores corríjalos y si no siga
trabajando con numi*/
resultadoi=numi+50;
65
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 corríjalos 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*/
numf=validarReal(numfc);/* Si se cometen errores corríjalos y si no siga trabajando
con numf*/
resultadof=numf+50;
clrscr();
gotoxy(20,12); cout<<"EL RESULTADO ES :"<<resultadof<<endl;
system("pause");
/************************************************************************************
66
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 corríjalos 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 corríjalos y si no siga
trabajando con numf*/
resultadold=numld+50;
clrscr();
gotoxy(20,12); cout<<"EL RESULTADO ES :"<<resultadold<<endl;
system("pause");
/************************************************************************************/
/*VALIDAR REAL POSITIVO, FLOAT, DOUBLE O LONG DOUBLE*/
float numfp,resultadofp;
char numfcp[20];
clrscr();
67
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 corríjalos 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 corríjalos y si no siga
trabajando con numi*/
resultadoiP=numiP+50;
clrscr();
resultadoiP<<endl;
system("pause");
}
EJEMPLO 29
Programa que utilizando la librería entorno.h valida caracteres.
/* VALIDACIÓN DE CARACTERES */
#include"entorno.h"
int main()
{
/*VALIDA LETRAS MAYÚSCULAS O MINÚSCULAS*/
68
char hilera[50];
clrscr();
cout<<"DIGITE UNA HILERA DE CARACTERES: "; //DIGITE NOMBRES, CIUDAD ETC...
cin>>ws; cin.getline(hilera,40);/*PUEDE DIGITAR LETRAS MINÚSCULAS O MAYÚSCULAS

SOLAMENTE*/
validarCaracteres(hilera);//Si todo es correcto, NO SACÓ NINGÚN 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 MAYÚSCULAS */
char hileram[50];
clrscr();
cout<<"DIGITE UNA HILERA DE CARACTERES: "; //DIGITE NOMBRES, CIUDAD ETC...
cin>>ws; cin.getline(hileram,40);/*PUEDE DIGITAR LETRAS MAYÚSCULAS
SOLAMENTE*/
validarMayusculas(hileram);/*Si todo es correcto, NO SACÓ NINGÚN 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 están en la librería entorno.h uno por uno.
/* DEMOSTRACIÓN DE DIVERSOS CUADROS EN LA PANTALLA*/

#include"entorno.h"
int main()
{
/* USO cuadros(fi,ci,ff,cf);
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";
69
gotoxy(20,24);
system("pause");
/* USO cuadro1();
DIBUJA UN CUADRO CON LÍNEA 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 LÍNEA 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 LÍNEA DOBLE ENLA FILA fi, COLUMNA ci HASTA
LA FILA ff,
COLUMNA fc, con línea doble, LO DIBUJAMOS DESDE LA FILA 6, COLUMNA 20, HASTA
LA FILA 18, COLUMNA 60. RECUERDE QUE USTED PUEDE MODIFICAR EL TAMAÑO DEL
CUADRO Y SU POSICIÓN*/
clrscr();
cuadrod(6,20,18,60);
gotoxy(38,7);
cout<<"MENU";
gotoxy(22,8);
gotoxy(20,24);
system("pause");
70
/*Uso cuadroMenosAmas();
/* Este cuadro comienza a formarse desde un tamaño pequeñito 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 clásicos quebraderos de cabeza de la programación. 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 "Misión crítica"; digamos
por ejemplo, controlar los ordenadores de una central nuclear o de un sistema de control de tráfico
aéreo.
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 excepcionales que pueden ocurrir dentro del programa durante su ejecución. Por ejemplo,
que ocurra una división por cero, se agote la memoria disponible, etc., que requieren recursos
especiales para su control.
En este capítulo trataremos el manejador de excepciones C++; una serie de técnicas 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 ubicación y corregirlos.
5.1. MANEJADOR DE EXCEPCIONES
El manejo de excepciones C++ se basa en un mecanismo cuyo funcionamiento tiene tres etapas básicas:
71
1. Se intenta ejecutar un bloque de código y se decide qué hacer si se produce una circunstancia
excepcional durante su ejecución.
2. Se produce la circunstancia: se "lanza" una excepción (en caso contrario el programa sigue su
curso normal).
3. La ejecución del programa es desviada a un sitio específico donde la excepción es "capturada" y
se decide qué hacer al respecto.
¿Pero qué es eso de "lanzar" y "capturar" una excepción"? En general, la frase se usa con un doble
sentido: por un lado es un mecanismo de salto que transfiere la ejecución desde un punto (que "lanza"
la excepción), a otro dispuesto de antemano para tal fin (que "captura" la excepción). A este último se
le denomina manejador o "handler" de la excepción.
Además del salto -como un goto-, en el punto de lanzamiento de la excepción se crea un objeto, a modo
de mensajero, que es capturado por el "handler" (como una función 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 información necesaria para que el receptor sepa qué ha pasado; cuál es la naturaleza de
la circunstancia excepcional que ha "lanzado" la excepción.
Para las tres etapas anteriores existen tres palabras clave específicas: try, throw y catch.
5.1.1. TRY
En síntesis, cuando el programa se prepara para cierta acción, decimos que "lo intenta". Para ello se
especifica un bloque de código cuya ejecución se va a intentar ("try-block") utilizando la palabra clave
try.
try { // bloque de código-intento
...
}
El juego consiste en indicar al programa que, si existe un error durante el "intento", entonces debe
lanzar una excepción y transferir el control de ejecución al punto donde exista un manejador de
excepciones ("handler") que coincida con el tipo lanzado. Si no se produce ninguna excepción, el
programa sigue su curso normal.
De lo dicho se deduce inmediatamente que se pueden lanzar excepciones de varios tipos y que pueden
existir también receptores (manejadores) de varios tipos; incluso manejadores "universales", capaces de
hacerse cargo de cualquier tipo de excepción. A la inversa, puede ocurrir que se lance una excepción
para la que no existe manejador adecuado.
Así pues, try es una sentencia que, en cierta forma, es capaz de especificar el flujo de ejecución del
programa. Un bloque-intento debe ser seguido inmediatamente por el bloque manejador de la
excepción.
72
5.1.2. THROW
Si se detecta una circunstancia excepcional dentro del bloque-intento, se lanza una excepción mediante
la ejecución de una sentencia throw. Por ejemplo:
if (condicion) throw "overflow";
Es importante advertir que, salvo los casos en que la excepción es lanzada por las propias librerías C++
(como consecuencia de un error 1.6.1a), éstas no se lanzan espontáneamente. Es el programador el
que debe utilizar una sentencia (generalmente condicional) para, en su caso, lanzar la excepción.
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 información. Este objeto es creado y lanzado en el punto de la
sentencia throw y capturado donde está la sentencia catch. El tipo de información contenido en el
objeto es justamente el que nos gustaría 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
información desde el punto del error, hasta el sitio donde esta información puede ser analizada.
5.1.3. CATCH
Esta parte del programa se denomina manejador ("handler"). Se dice que el "handler" captura la
excepción. El handler es un bloque de código diseñado para manejar la excepción, precedido por la
palabra catch. El lenguaje C++ requiere que exista al menos un manejador inmediatamente después de
un bloque try, es decir, se requiere el siguiente esquema:
try { // bloque de código que se intenta
...
}
catch (...) { // bloque manejador de posibles excepciones
...
}
... // continúa la ejecución normal
El "handler" es el sitio donde continúa 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 opción 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 información
pertinente, que se guarda en disco con objeto de que pueda ser posteriormente analizado y corregido
en sucesivas versiones de la aplicación.
73
Llegados a este punto debemos recordar que, como veremos en los ejemplos, las excepciones
generadas pueden ser diversas (según el tipo de error), y que también pueden existir múltiples
manejadores. De hecho, se debe incluir el manejador correspondiente a cada excepción 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
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 subíndice que va después 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
expresión de tipo entero (sin decimales), que indica cuál de los elementos del arreglo queremos
relacionar. Siempre que se quiere trabajar o mencionar una componente es necesario adicionar el
índice al nombre genérico del arreglo; es éste el que hace independiente una de otra.
Ejemplos de índices:
1 I IND k+I I * jota - 1
6.1. CLASIFICACIÓN DE LOS ARREGLOS
6.1.1. ARREGLOS DE UNA DIMENSIÓN O VECTORES
74
Un vector es un arreglo donde los elementos que lo conforman están dispuestos bajo un mismo orden
de clasificación (fila o columna), es decir, los datos están organizados de una manera lineal, por lo que,
para referenciar un elemento del arreglo, es necesario un índice que indique la posición 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 capítulos anteriores se han venido tratando; por
lo tanto, puede estar involucrada en una expresión, en una entrada o salida de datos, o en una
asignación.
En C++ los arreglos inician con el índice 0 hasta n-1, si el arreglo tiene n elementos.
Definición 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 20 posiciones o elementos de tipo flotante.
float valores[20];
También se puede definir en una forma dinámica 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 posición cero, cada posición del arreglo
valores tiene un tamaño 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
tamaño de un byte. Es el tipo de dato del arreglo quien determina la cantidad de memoria asignada a
cada posición o elemento.
Gráficamente un vector puede ser representado en cualquiera de las siguientes formas:
75
Los arreglos pueden ser utilizados como acumuladores o contadores, inicializando cada uno de sus
elementos.
Ejemplo de asignación de valores

Llevar cero a cada uno de los elementos de un arreglo EDAD de 5 posiciones.
//Solución utilizando MIENTRAS

#include<iostream>
#include<conio2.h>
int main()
{
int indice=0;
int edad[5];
while(indice<5)
{
edad[indice]=0;
indice++;
}
}
//Solución 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
76
Elaborar un programa que encuentre la suma y el promedio de N valores que se almacenarán en un
vector.
n: número 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 máxima
de valores que se podrán 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 estarán llenas, las 45 restantes estarán
vacías.
#include<iostream>
#include<conio2.h>
int main()
{
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 POSICIÓN 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
77
Hacer un algoritmo que calcule el valor promedio, la varianza y la desviación típica 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 cálculo del promedio.
prom: promedio del grupo de datos
i: variable de control del ciclo PARA
suma2: sumatoria para calcular la varianza. Puede utilizarse la misma variable suma1?
var: varianza del grupo de valores
dt: desviación típica
#include<iostream>
#include<conio2.h>
#include<math.h>
int main()
{
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("DESVIACIÓN TÍPICA= ");
gotoxy(19,12); cout<<prom; //Escribe después de PROMEDIO
gotoxy(37,12); cout<<var; //Escribe después de VARIANZA
gotoxy(67,12); cout<<dt; //Escribe después de DESVIACIÓN TÍPICA
78
getch();
}
Ejemplo 34
Elaborar una función que encuentre la posición del mayor elemento de un vector de tamaño 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 envíen
{
//n tamaño del vector; vec: el vector; mayor: asume el valor mayorv del vector
//posm: posición 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;
}
int main()
{
//tv tamaño del vector; posmayor: posición 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 POSICIÓN: DEL VECTOR");
textbackground(0); gotoxy(50,12); cout<<posmayor;
textbackground(0); getch();
}
6.1.1.1 OPERACIONES BÁSICAS CON VECTORES
79
• Búsqueda
• Ordenación
• Inserción
• Borrado
Estas operaciones se implementarán en una librería de nombre: libVector, que se construye más
adelante. Esta librería contendrá los siguientes subprogramas: leerVector, imprimirVector,
ordenBurbuja, ordenSeleccion, insertar, busuedaSec, busquedaBin, borrar.
BÚSQUEDA
La búsqueda consiste en encontrar un determinado valor dentro de un conjunto de datos, para
recuperar alguna información asociada con el valor buscado.
Existen diferentes formas de hacer esta operación, en este manual implementamos las dos primeras:
secuencial y binaria.
• Búsqueda Secuencial o lineal
• Búsqueda Binaria
• Búsqueda HASH
• Árboles de búsqueda
Búsqueda secuencial. Es una técnica 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 posición donde se encuentra dicho elemento, de lo contrario se
enviará un mensaje que informe que el valor buscado no se encuentra dentro del arreglo.
Búsqueda binaria. Note que, en la búsqueda 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 tamaño del vector es muy grande. El método de búsqueda 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 búsqueda en cualquiera de las dos mitades. Se
coge la mitad donde posiblemente se encuentra el valor buscado y se repite la misma comparación
arriba mencionada. Con esta nueva comparación se elimina nuevamente la mitad de los datos que
quedaron. El proceso continúa hasta que se dé una coincidencia, o se pueda decir que el valor buscado
no está en el vector. Para poder hacer búsqueda binaria primero hay que ordenar el vector; si el vector
no está ordenado, no se puede determinar en cuál de las mitades se encuentra el valor que se desea
buscar.
ORDENACIÓN
La ordenación se refiere a la operación de organizar los elementos de un vector en algún orden dado:
ascendente o descendente. Si el ordenamiento es creciente o ascendente, significa que hay que
organizar sus elementos de tal manera que:
80
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 métodos más comunes son:
• Método Burbuja
• Método de Burbuja Mejorado
• Ordenación por Selección
• Inserción o Método de la Baraja
• Shell
• Binsort O por Urnas
• Por Monticulos o Heapsort
• Por Mezcla o Mergesort
• Método de la Sacudida o Shackersort
• Rapid Sort o Quick Sort
• Por Árboles
Vamos a implementar dos de los métodos de ordenamiento: burbuja y selección. Se invita al lector a
investigar los demás métodos.
Ordenación por burbuja. Es un método poco eficiente. Se basa en comparar elementos adyacentes del
vector e intercambiar sus valores, si están desordenados. Los valores más pequeños burbujean hacia el
inicio del vector (ordenación ascendente), mientras que los valores más grandes comienzan a subir hacia
la parte final del vector. Por ejemplo, se compara A[1| con A[2]; si están 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 exploración, comparando elementos consecutivos e intercambiando; pero esta vez el
elemento mayor no se compara (está en su posición correcta). El vector quedará ordenado cuando se
hayan hecho N-1 pasadas. Si los valores del vector son:
80 55 35 21 15 Vector original de tamaño 5 (N)
55 80 35 21 15
55 35 80 21 15
55 35 21 80 15
55 35 21 15 80
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
81
Tercera pasada:
21 35 15 55 80
21 15 35 55 80
Cuarta pasada:
15 1 35 55 80
En total se necesitaron cuatro pasadas para ordenar un vector de 5 elementos.
Ordenamiento por selección. Este método se basa en buscar el menor valor de todo el vector e
intercambiarlo con el elemento que se encuentra en la posición uno. Para encontrar este valor se
asume que el menor de todo del grupo es el que está en la posición cero, y se recorre todo el vector a
partir de la posición 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 posición uno, y se recorre todo el vector a partir de la posición dos en
adelante, haciendo el cambio respectivo cuando se encuentre un valor menor que él. Una vez
encontrado el segundo menor se intercambia con el valor ubicado en la posición uno del vector. El
proceso de búsqueda de menores se hace N-1 veces.
Por cada menor buscado hay que guardar en una variable la posición donde se encuentra ese menor.
Ejemplo. Si el vector a ordenar es: 10 20 1 3 0 sucedería lo que se muestra en el siguiente gráfico.
Note que, después del cuarto intercambio, el elemento ubicado en la posición cinco, de por sí queda
ordenado; además no hay más elementos con quien compararlo y se termina el proceso, después de
hacer N-1 intercambios, o buscado N-1 menores.
Ejemplo 35
Construir la librería libVector.h:
#include<iostream>
#include<conio2.h>
82
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]<<" ";
}
//******************************************************************
//FUNCIÓN QUE BUSCA UN VALOR EN UN VECTOR, USANDO EL MÉTODO DE
//BÚSQUEDA SECUENCIAL, RETORNA LA POSICIÓN 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
//******************************************************************
//FUNCIÓN QUE BUSCA UN VALOR EN UN VECTOR, USANDO EL MÉTODO DE

//BÚSQUEDA BINARIA, RETORNA LA POSICIÓN 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;
}
83
//**********************************************************************
//PROCEDIMIENTO QUE ORDENA UN VECTOR POR EL MÉTODO 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 MÉTODO DE SELECCIÓN
// 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];
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 DAÑAR 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];
84
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Á VACÍO");cout<<endl;
}
system("pause");
}//fin borrar
Ejemplo 36
Elaborar un programa que incluya la librería libVector y, mediante un MENÚ, hacer las siguientes
operaciones:
1. Leer un vector de tamaño N
2. Imprimir el vector
3. Ordenar el vector en forma ascendente por cualquiera de los métodos de ordenación expuestos.
4. Insertar un nuevo elemento sin dañar el ordenamiento.
5. Buscar un valor en el arreglo por el método de búsqueda 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 TAMAÑO 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(" ");
85
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);
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: ";
86
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;
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
Diseñar un subprograma que, dado un vector que pueda contener elementos duplicados diferentes de
cero, reemplace cada elemento repetido por un cero y encuentre el número 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++;
}
}
//************************************************************************
87
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();
}
6.1.2. ARREGLOS DE DOS DIMENSIONES O MATRICES
Las matrices son estructuras de datos que organizan su información en forma de tablas, es decir, los
elementos que la conforman están dispuestos bajo dos conceptos de clasificación (fila y columna). Para
poder indicar el lugar donde se encuentra un determinado elemento, es necesario utilizar dos índices:
uno para indicar el renglón o fila y otro para indicar la columna.
Puede mirarse una matriz como un vector de vectores, por lo tanto, es un conjunto de componentes en
el que se necesitan dos subíndices 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. Gráficamente se puede representar como una
tabla de valores. Si A es una matriz de 5 * 7 se representará así:
88
Column
Column
Colum
Colum
Colum
Colum
Colum
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 información 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;
2. La otra sería 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 información 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 sería:
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];
89
j = j+1;
}
i = i+1;
}*
Existen varios tipos de matrices.

•Matriz cuadrada. Una matriz es cuadrada cuando el número de filas es igual al número 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 también una matriz cuadrada donde los elementos que están ubicados en la
diagonal principal son 1 y, el resto de elementos, tienen un valor de 0.
•Matriz transpuesta. La matriz transpuesta AT de la matriz A de cualquier orden, es aquella en la cual las
filas de una matriz son las columnas de la otra.
•Matriz simétrica. La matriz simétrica debe cumplir la condición 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 * X–1 = 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.
#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++)
90
{
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 librería que contenga dos subprogramas: uno que lea una matriz (leerMatriz) y otro que
imprima los elementos de la matriz (imprimirMatriz).
Los dos subprogramas tendrán como parámetros el número de filas, el número de columnas y la matriz.
Es obligatorio, dentro de los subprogramas, colocar el número de columnas como una constante,
mientras que el número de filas se puede dejar vacío y recibirá cualquier valor que le envíe quien la
utilice.
//LIBRERÍA CON DOS SUBPROGRAMAS: leerMatriz e imprimirMatriz

#include<iostream>
#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;
}
}
91
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].
Si el contenido de MAT es:
Como se puede ver, se invierte el orden de la matriz, es decir, el número de filas de MAT es igual al
número de columnas de TMAT y el número de columnas se invierte, por el número 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 NÚMERO DE FILAS: ");
gotoxy(49,11); cin>>nf;
gotoxy(20,13); cprintf("DIGITE EL NÚMERO DE COLUMNAS: ");
gotoxy(49,13); cin>>nc; clrscr();
92
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]; //setw está en la librería iomanip
gotoxy(4,8+i);
}
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
continuación:
#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 NÚMERO DE FILAS: ");
gotoxy(49,11); cin>>nf;
textbackground(WHITE);
93
gotoxy(20,13); cprintf("DIGITE EL NÚMERO 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++)
{
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 número de fichas rojas: nfr
•El número de fichas negras: nfn
•El número total de fichas: tft
Para saber la clase de ficha que existe en un cajón 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, sería el siguiente:
F\C 1 2 3 4 5 6 7 8
1 0 0 1 1 0 0 0 0
2 2 0 1 0 0 0 0 1
3 0 0 0 0 0 0 0 0
4 2 2 0 0 0 2 0 1
5 0 0 0 0 0 0 0 0
94
6 0 0 0 2 0 0 1 0
7 0 0 0 0 1 0 0 0
8 2 0 0 2 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++)
{
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(" NÚMERO DE FICHAS ROJAS: ");
gotoxy(50,11); cout<<nfr; textcolor(BLACK);
gotoxy(25,13); cprintf(" NÚMERO DE FICHAS NEGRAS: ");
gotoxy(50,13); cout<<nfn; textcolor(6);
95
gotoxy(25,15); cprintf(" NÚMERO 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 selección múltiple. Cada pregunta, dentro de sus alternativas, sólo
tiene una respuesta correcta. Las respuestas correctas están 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 continuación, 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 calificación mínima de 60 puntos
para aprobar), y el número de estudiantes que lo perdieron.
Para almacenar la información 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 posición 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++)
96
{
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";
gotoxy(20,24); cout<<"NÚMERO DE PERDEDORES:"<<np;
gotoxy(20,25); system("pause");
}
Ejemplo 45
Elaborar un programa que lea, para un arreglo bidimensional, la información sobre ventas de NP
productos; grabando en la primera columnas el código del artículo y, en la siguiente, el número de
unidades vendidas cada mes (meses de 30 días).
Cada fila corresponde a los datos para un artículo. Utilizar las tres columnas siguientes para calcular:
promedio de ventas diarias, promedio de ventas en los días que las hubo y número de días que se
vendió; imprima la matriz.
Como el arreglo tiene, en la primera columna, el código del artículo, inicialmente tendrá 31 columnas
(una del código columna 0 y 30 correspondientes a las ventas hechas cada día del mes). En caso de que
en un día no se haga venta, esa posición tendrá valor de cero. La columna 31 del arreglo almacenará el
promedio de ventas diarias por artículo, que se calcula sumando cada fila desde la columna dos hasta la
treinta y uno, y dividiendo el resultado sobre los treinta días del mes, así:
El promedio de ventas en los días que las hubo (columna 32), se obtiene sumando las ventas del
producto y dividiendo por el número de días 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 diseñaría de la siguiente
manera:
97
#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++;
}
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: cédula, nombres,
deducción y salario, podemos representarlo de la siguiente forma:
32506321 SUSANA RESTREPO 40000 630000
Como puede notarse, dentro del registro sólo hay datos (información); es el programador quien le
coloca nombres a cada dato para poderlos almacenar en la memoria de la computadora.
Si la información 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 instrucción:
LEA: CC, NOM, DEDUC, SAL
La información de la empleada está dispersa en la memoria. La idea de usar registros es agrupar
toda la información en una misma área de memoria bajo un solo nombre. Si se toma la determinación
98
de que EMP1 es una variable de tipo registro, es decir, puede almacenar en el área asignada toda la
información de un empleado, gráficamente se puede mirar de la siguiente manera.
Para que EMP1 sea tomada como una variable tipo registro, el programador debe definirla como tal,
de acuerdo con el lenguaje de programación 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 definiría 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 haría de la siguiente forma:
empleado emp1, emp2;
En la anterior instrucción 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 explícita a cuál de las componentes del
registro se quiere uno referir. La cualificación se hace así: variables_tipo_registro.componente.
Por ejemplo:
emp1.cc hace referencia al valor de la cédula 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++
sería el quinto).
La instrucción:
99
LEA: emp1.cc, emp1.nom, emp1.deduc, emp1.sal, lleva información a la variable tipo p registro
emp1.
Si hay necesidad de mover la información de una variable tipo registro a otra, se puede hacer
componente a componente o moviendo toda la información al mismo tiempo. Por ejemplo:
emp2.cc = emp1.cc
emp2.nom = emp1.nom
emp2.deduc = emp1.deduc
emp2.sal = emp1.sal
sería lo mismo que tener: emp2 = emp1
EJEMPLO 46
Formar un registro con los campos: cédula, nombre, pago, luego pasarlo a otro registro e imprimir
la información.
Análisis
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(" ");
gotoxy(20,11); cout<<est2.cc; gotoxy(20,12); cout<<est2.nom;
100
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 programación de aplicaciones, ya que

muchas veces es deseable, desde el punto de vista de la lógica del programa en particular, mantener
disponible en memoria principal una serie de registros con información del mismo tipo para su proceso;
dichos registros no estarán dispersos; harán 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 máximo 100 registros donde cada elemento contenga: cédula, nombres y
pago, luego ordenarlo por el campo nombre, insertar un nuevo registro sin dañar el ordenamiento
e imprimirlo. Si el nombre del arreglo de registros es v, gráficamente se representaría así:
El problema se resolverá a través de módulos (subprogramas)
101
El subprograma LEER recibe la cantidad de elementos del arreglo (número de estudiantes) N y
envía el vector V.
IMPRIMIR Recibe N y V
ORDENAR Recibe N y V y envía V ordenado
INSERTAR Recibe N y V y envía N y V
Otras variables
I, K Variables de control de ciclos
MENOR Almacena el nombre menor en el ordenamiento
POS Almacena la posición donde está el nombre menor.
AUX Variable de tipo registro que guarda temporalmente un elemento
del vector mientras se hace el ordenamiento.
RI Registros a insertar
Estos subprogramas estarán dentro de la librería libvect.h

Datos de entrada
• La cantidad de elementos del vector
• La información del vector
• Cédula, nombre y pago a insertar.
Datos de salida
• La información del vector registro.
N Cantidad de elementos
A Nombre del arreglo
R Variable tipo registro
R.CCCédula a insertar
R.NOM Nombre a insertar
R.P Pago a insertar
OP Opción a seleccionar en el menú
SIGA Opción para insertar nuevos elementos
102
#include<iostream>
#include<conio2.h>
#include<iomanip>
#include<windows.h>
#include"entorno.h"
struct empleado
{
long long cc; char nom[36]; double p;
};
void leer(int n, empleado v[])/*Entra la información 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 CÉDULA: ");
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 EL PAGO: ");
gotoxy(38,13); cin>>v[k].p; textbackground(0);
}
}
void imprimir(int n,empleado v[])/* Imprime la información 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 información 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)
103
{
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[])
{
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;
104
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:
clrscr();
gotoxy(30,12); cprintf("FIN DEL PROGRAMA");
getch();
break;
}
}while(op !=5);
}
8. ARCHIVOS
Un archivo es un dispositivo lógico donde se pueden almacenar en forma permanente grandes
volúmenes de información, dividido en estructuras de datos (registros) todas del mismo tipo y
relacionadas.
El manejo de información a través de archivos es de gran utilidad en la programación, ya que permite la
captura de información almacenada en ellos para su posterior utilización en diversos programas,
evitando tener que entrar en forma manual la información que se quiere procesar; y almacenar gran
cantidad de información en espacios reducidos y con una alta precisión en el manejo de los datos.
En general los archivos se pueden agrupar en tres grandes categorías:
• Archivos de programa: son los programas fuentes que se escriben en un determinado lenguaje de
programación. Estos programas son guardados en medios magnéticos auxiliares para su posterior
utilización. Estos archivos se pueden cargar del medio magnético 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, párrafos y se suelen crear y mantener mediante
programas que procesan o editan texto.
• Archivos de datos: almacenan valores. Un archivo de datos contiene información que un programa
crea y posteriormente procesa; de igual forma, puede usarse para almacenar los resultados de la
ejecución de un programa.
105
8.1. MANEJO DE ARCHIVOS DE DATOS
C++ trae la librería biblioteca estándar 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>
Operaciones asociadas a archivos

– Abrir archivo
– Cerrar archivo
– Lectura y escritura
– Funciones de control
Los archivos se manejan a través de dos nombres: uno interno o nombre lógico (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 magnético donde se lleve.
Las operaciones se logran mediante la librería fstream. Esta librería permite guardar y cargar
información mediante archivos por medio de las clases ifstream y ofstream.
La operación de apertura de un archivo es desproteger el área del medio magnético donde residirá el
archivo, el apuntador se coloca al principio del archivo y se establecen buses de datos para transferir
información 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 información en
el archivo (creación 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 más registros
al final del archivo (indicador app).
Ifstream abre un archivo para leer la información 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 través de indicadores, como
los siguientes:
app: permite adicionar más registros al final del archivo. El apuntador de flujo de datos se colocará al
final del archivo antes de cada operación 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 serán 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.
106
out: permite operaciones de escritura en el archivo.
trunc: con este modo indicamos que el contenido actual será descartado.
close( )
Esta función permite desasociar el archivo que se tenga abierto actualmente con la aplicación, es decir
que se destruyen los medios de conexión entre la memoria y el medio magnético y el nombre lógico con
el nombre físico. Por seguridad, es buena práctica ejecutar esta función cuando ya no se desean realizar
más operaciones sobre el archivo, para proteger el área donde está el archivo. Al ejecutarse esta
operación, automáticamente al final del archivo, se adiciona un registro más (registro centinela) donde
se coloca una marca, llamada marca de fin de archivo, eof (end of file). Esto significa que nosotros
leemos información del archivo hasta que se detecte la marca de fin de archivo. Ejemplo:
While(!nombre lógico.eof())
{
nombre lógico.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 lógico.
ifstream <nombre lógico> (“ nombre físico ”, ios_base::in) ;
Nombre lógico debe ser un nombre de variable permitido y a través de este nos referiremos al archivo
(nombre físico) 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 lógico archT:
#include <fstream.h>
….
ifstream archT (“D:\nombres.txt”, ios_base::in);
Si el archivo nombres es un archivo de datos, la instrucción sería:
ifstream archT (“D:\datos.dat”, ios_base::in);
107
Par comprobar si un archivo fué abierto con éxito, hacemos la siguiente pregunta:
If(archT)
cout<< “ ¿FUE ABIERTO CON ÉXITO?”;
else
cout<<”NO SE PUDO ABRIR EL ARCHIVO”;
O también 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 físico), si no colocamos ruta
el archivo se guardará en la carpeta donde está el programa que lo crea.
Abrir un archivo para escritura (creación del archivo).

Si queremos crear el archivo nombres.txt lo debemos abrir para escribir datos, si el nombre lógico 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 números binarios que representan la información, sin embargo, estos archivos están
guardados en formato de texto '.txt', y los podrá leer cualquier aplicación que procese textos.
En este caso el nombre lógico actúa como si fuera un cin o un cout, o sea, para ingresar o leer datos
108
Lectura de un archivo de texto
#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: número y nombres, que muestre la
información del archivo y le adicione más registros.
#include<iostream>
#include<conio2.h>
#include<fstream>
int main()
{
109
char nom[40];
int i=0, opcion;
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");
110
}//else
}
if(opcion==3){
/* SE ABRE EL ARCHIVO PARA ADICIONAR REGISTROS AL FINAL*/
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);
}
8.1.2. ARCHIVO DE DATOS
Un archivo es un conjunto de datos relacionados entre sí, con una organización jerárquica, 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 información 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 demás llamado campo clave. Gráficamente
se puede mirar un archivo de datos de la siguiente forma:
111
Como se desprende del gráfico, los campos corresponden a las columnas y los registros a las filas.
El tamaño 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 información y de igual manera los registros deben estar relacionados con
la razón de ser del archivo.
Empleados
Cédula Depto Nombre Salario
114 01 Elías José 180 000
121 01 Graciela del Carmen 253 423
211 01 Luisa Berta 312 516
099 02 Guillermo Segundo 222 604
117 02 Albertina Isabel 191 221
212 02 Corina Francisca 823 514
119 03 Ruth de Jesús 119 325
118 03 Florencia Maria 425 000
311 04 Jairo Antonio 388 734
Fin del archivo
Como se puede ver, en un archivo de datos lo que se guarda es información, 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
Cédula Nombre Apellido Dirección Teléfono
14879563 Fredy Jaramillo Cra. 10 No. 10-17 2310145
47896321 LeonelOsorno Cll. 70 No. 11-18 4569874
65874123 Fabián Ríos Cll. 20 No. 12-9 5896201
73284562 Gisela Gil Cra. 43 No. 10-21 3214568
EOF
Inventario
Código Descripción Unidades Valor-unidad
702110 Bujía 200 7500
802010 Válvula 50 850
902110 Manguera 5 35750
. . . .
112
. . . .
. . . .
EOF
Libros
Código-libro Título Código-autor Unidades
502115 Antes del fin 8462148 12
602017 Doña Bárbara 7985621 21
902117 El túnel 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 cómo abrir un archivo de datos para lectura y escritura y adicionar datos al final.
Veamos cómo 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));/*Operación de escritura*/
.......
emp.close();
Veamos la instrucción de lectura:
ifstream a2("datos.dat", ios_base::in|ios_base::binary);/*apertura*/

.......
a2.read(( char*) &r,sizeof(r)); /*Operación de lectura*/
EJEMPLO 49
113
Vamos a crear un archivo con los datos: cédula, nombres y salario, lo leemos e imprimimos por pantalla
la información en él contenida, lo ordenamos por el campo nombre y buscamos la información por
cédula 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;
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();
}
}
/***************************************************************/
114
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()
{
115
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)
{
116
case 1: adicionar(); break;
case 2: Leer(); break;
case 3: ordenarPorNombre(); break;
case 4: buscarPorCedula();
case 5: "SALIR DEL MENU";
break;
}
}while(op !=5);
}
117
9. ANEXOS
9.1. TABLA CARACTERES ASCII
118
10. BIBLIOGRAFÍA Y CIBERGRAFÍA
10.1. BIBLIOGRAFÍA
PROGRAMACIÓN EN C++ PARA INGENIEROS. Fatos Xhafa y otros
LÓGICA DE PROGRAMACIÓN SEGUNDA EDICIÓN. Efraín M Oviedo Regino
10.2. CIBERGRAFÍA
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
Código C++ | Programas, Tareas y Ejemplos en C++

http://codigoc.org/143-bajar-dev-c-gratis-compilador-para-c
119

Introducción A Visual C++

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Introducción A Visual C++

Cargado por

Copyright:

Formatos disponibles

1

Introducción a dev C++

2.4. TIPOS DE DATOS 16

3.3. INSTRUCCIÓN WHILE 27

3.5. INSTRUCCIONES ADICIONALES 31

7.1. ARREGLO DE REGISTROS 100

El texto explica la programación estructurada de una manera natural, partiendo de lo más

El texto es entonces de carácter práctico, enriquecido con la experiencia como docente

El autor deja a disposición de los lectores la página web http://ingenieria.udea.edu.co/~eoviedo,

Un lenguaje de programación es un conjunto de reglas de sintaxis diseñadas para representar

1.3. ENTORNO DE DESARROLLO INTEGRADO

● CABECERA: INCLUYE LIBRERÍAS A UTILIZAR

math (se debe incluir, lo mismo la conio2)

fprintf(f,…) int Stdio.h Escribe datos en el int fprintf (FILE*f, const

2.3. PALABRAS RESERVADAS.

auto break case char cin class clrscr const continue

2.5. TIPOS DE DATOS

Los tipos de datos primitivos más comunes de C++ son:

NOMBRE DESCRIPCIÓN TAMAÑO* RANGO*

(tabla de caracteres ASCII en anexos al final del documento)

Estructura de la definición de una variable:

Estructura de la asignación de una variable:

int x; // Definimos la variable x de tipo entero

int nombreDeLaVariable = expresión;

\\: permite mostrar el caracter '\' en pantalla.

2.6. OPERADORES DE C++

2.7. CARACTERES ASCII

3.1. INSTRUCCIONES DE ENTRADA Y SALIDA DE DATOS

3.1.1. SALIDA DE DATOS

Vemos que el comando cout<< es para salida y cin>> para entrada.

cout<<"Hola mundo" <<endl; //Muestra Hola mundo en la pantalla

3.1.2. ENTRADA DE DATOS

Ampliando el anterior ejemplo, en el siguiente, si el usuario ingresa un número mayor a 5 se le indica

3.3. INSTRUCCIÓN WHILE

Funcionamiento: cuando el programa llega a la instrucción while, se evalúa la condición y, si ésta es

La solución cualitativa del primer ejemplo seria:

3.3. VARIABLES TIPO BANDERA

3.5. INSTRUCCIONES ADICIONALES

//usando el ciclo while

for(variableDeControl=valor inicial; condición; incremento/decremento){

3.5.3. SWITCH- CASE

//Uso de break en ciclos for

4.1. CLASIFICACIÓN DE LOS SUBPROGRAMAS

4.1.1. PROCEDIMIENTOS O SUBRUTINAS

void Nombre (tipo de dato parámetro1, tipo de dato parámetro2, ...)

Orden (N1, N2, N3, MEN, MED, MAY);

Lo que significa lo siguiente:

i. Cuando se activa el subprograma (empieza a ejecutarse).

ii. Cuando la ORDEN deja de ejecutarse (regresa información)

//Procedimiento codificado después del main

void orden(float pv, float sv, float tv, float &menor,

//Para definir (declarar) la función

//Para invocar (instanciar) la función

void cuadro(int fi, int ci, int ff, int cf)

void sumprom(int n, float &sum, float &prom)

4.1.4 LIBRERÍA PARA VALIDAR Y CREAR CUADROS

char numestc[8]; /*significa que la cantidad de estudiantes no tiene más de 7

B.1 Validación de mayúsculas y minúsculas

C.2 void cuadro1()

C.3 void cuadro2()

C.4 void cuadrod(int fi, int ci , int ff, int cf)

C.5 void cuadro Menos Amas()

C.6 void escribirCmasMas()

/VALIDAR UN LONG LONG/

/VALIDAR UN LONG DOUBLE/

/VALIDAR REAL POSITIVO, FLOAT, DOUBLE O LONG DOUBLE/

/VALIDAR ENTERO POSITIVO, SHORT, INT, LONG /

ifstream a2("datos.dat", ios_base::in|ios_base::binary);/apertura/