C++ Corre

UNIVERSIDAD NACIONAL DEL
CENTRO DEL PERU
TECNICAS DE PROGRAMACION
ESTRUCTURADA:
APLICACIONES CON C++
ABRAHAM GAMARRA MORENO
DANIEL GAMARRA MORENO
JUAN GAMARRA MORENO

CONTENIDO
INTRODUCCIÓN ................................................................................................................1
CAPITULO UNO
PROGRAMACIÓN DE COMPUTADORAS
1.1. Construcción de un programa de computadora ............................................3
1.1.1. Análisis del problema...........................................................................4
1.1.2. Proceso de solución.............................................................................4
1.1.3. Refinamiento del Programa ................................................................5
1.2. Características de los programas ....................................................................5
1.2.1. Claridad..................................................................................................5
1.2.2. Eficiencia ...............................................................................................5
1.2.3. Modularidad y estructuración.............................................................6
1.3. Objetos de un programa....................................................................................6
1.3.1. Constantes ............................................................................................6
1.3.2. Variables................................................................................................7
CAPITULO DOS
ALGORITMOS
2.1. Definiciones .........................................................................................................8
2.1.1. Algoritmo................................................................................................8
2.1.2. Programación modular ........................................................................9
2.1.3. Programación estructurada ................................................................9
2.2. Construcción de algoritmos ............................................................................11
2.3. Representación de algoritmos........................................................................11
2.3.1. Diagrama de Flujo ..............................................................................11

2.3.2. Diagrama N-S .....................................................................................12
2.3.3. Pseudocódigo .....................................................................................12
CAPITULO TRES
CARACTERISTICAS DEL C++
3.1. Características ..................................................................................................13
3.2. Identificadores...................................................................................................14
3.3. Palabras reservadas ........................................................................................14
3.4. Estructura de un programa .............................................................................15
3.5. Comentarios ......................................................................................................15
3.5.1. Comentario en más de una linea.....................................................15
3.5.2. comentario en una sola línea ...........................................................15
3.6. Bloques ..............................................................................................................16
3.7. Tipos de datos fundamentales .......................................................................16
3.7.1. Tipo char..............................................................................................16
3.7.2. Tipos enteros ......................................................................................16
3.7.3. Tipos de punto flotante ......................................................................17
3.7.4. Tipo void ..............................................................................................17
3.8. Modificadores de tipo.......................................................................................17
3.9. Constantes.........................................................................................................17
3.9.1. Constantes enteras ............................................................................17
3.9.2. Constante carácter (char) .................................................................18
3.9.3. Constante cadena ..............................................................................18
3.9.4. Constante de punto flotante .............................................................19
3.10. Definición de constantes .................................................................................19
3.10.1. La directiva #define ............................................................................19

3.10.2. Const ....................................................................................................19
3.11. Declaración de variables .................................................................................19
3.12. Expresiones .......................................................................................................19
3.13. Conversión de tipos..........................................................................................20
CAPITULO CUATRO
OPERADORES BÁSICOS
4.1. Operadores aritméticos ...................................................................................22
4.2. Operador de asignación ..................................................................................23
4.2.1. Igual (=) ................................................................................................24
4.2.2. Asignación múltiple ............................................................................24
4.2.3. Asignación relativa .............................................................................24
4.3. Operadores de relación ...................................................................................25
4.4. Operadores lógicos ..........................................................................................25
CAPITULO CINCO
SALIDA / ENTRADA ESTÁNDAR
5.1. Salida/entrada estándar en c++ .....................................................................26
5.1.1. Salida con cout ...................................................................................26
5.1.2. Entrada con cin...................................................................................27
CAPITULO SEIS
SENTENCIAS DE CONTROL
6.1. Sentencia if........................................................................................................29
6.2. Sentencia switch...............................................................................................36
6.3. Sentencias repetitivas o bucles......................................................................38
6.4. Sentencia while .................................................................................................39

6.5. Sentencia do while ...........................................................................................42
6.6. Sentencia for .....................................................................................................43
6.7. Sentencia break ................................................................................................46
6.8. Sentencia continue ...........................................................................................47
6.9. Sentencia goto ..................................................................................................47
6.10. Programas de aplicación.................................................................................48
CAPITULO SIETE
SUBPROGRAMAS
7.1. Subprogramas o subrutinas............................................................................62
7.2. ¿Cuándo utilizar un subprograma? ...............................................................62
7.3. Diseño descendente (Top Down) ..................................................................63
7.3.1. Ejemplo ................................................................................................63
7.4. Programación modular ....................................................................................66
7.4.1. Modulo .................................................................................................66
7.4.2. Criterios a considerar en programación modular ..........................67
7.4.3. Fases de la programación modular .................................................67
7.5. Definición de funciones ...................................................................................67
7.5.1. Declaración de prototipos .................................................................68
7.5.2. Llamada a una función: .....................................................................69
7.5.3. Parámetros por valor .........................................................................71
7.5.4. Parámetros por referencia ................................................................71
7.5.5. Ámbito de una variable ......................................................................73
7.5.6. Variables locales ................................................................................74
7.5.7. Párametros formales y reales ..........................................................74
7.5.8. Variables globales ..............................................................................74

7.6. Programas de aplicación.................................................................................77
7.7. Funciones del sistema .....................................................................................81
7.7.1. Utilizacion de la directiva #include...................................................81
CAPITULO OCHO
ESTRUCTURA DE DATOS: ARREGLOS
8.1. Arreglos unidimensionales: vectores.............................................................84
8.2. Arreglos bidimensionales: tablas / matrices.................................................90
CAPITULO NUEVE
REGISTROS
9.1. Representación de registros ...........................................................................96
9.2. Estructuras.........................................................................................................96
9.3. Uniones ..............................................................................................................98
9.4. Operaciones con estructuras....................................................................... 100
9.4.1. Paso de estructuras a funciones .................................................. 100
9.4.2. Anidamiento de estructuras ........................................................... 102
9.5. Arreglos de registros ..................................................................................... 104
9.6. Programas de aplicaciÓn............................................................................. 105
CAPITULO DIEZ
PUNTEROS
10.1. Conceptos basicos ........................................................................................ 110
10.2. Cadenas y caracteres ................................................................................... 112
10.3. Punteros a estructuras.................................................................................. 117
10.4. Listas enlazadas ............................................................................................ 117
10.5. Colas (fifo)....................................................................................................... 123

CAPITULO ONCE
ARCHIVOS
11.1. Organización de archivos............................................................................. 126
11.2. Escritura en archivos: ................................................................................... 129
11.3. Lectura de archivos: ...................................................................................... 129
11.4. Ubicación del puntero para acceso directo ............................................... 130
BIBLIOGRAFIA............................................................................................................... 137
INTRODUCCIÓN
La programación de computadoras en sus inicios fue concebida

como un arte donde la inspiración del programador era la base
para escribir programas. Con el objetivo de disminuir el
tiempo de elaboración de programas, disminuir el costo de
mantenimiento y mejorar el trabajo en equipo, se idearon
técnicas como la metodología estructurada que a su vez dio
origen al análisis y diseño estructurado. En la actualidad
existen nuevas técnicas como la metodología orientada a
objetos, pero que en la práctica es una metodología más
estructurada. Dentro de la diversidad de Lenguajes de
Programación el C/C++ sigue siendo un estándar universal por
su portabilidad, es así que muchos compiladores comerciales
han sido desarrollados en el C/C++.
La mayoría de la bibliografía del Lenguaje de Programación

C/C++ asume que el lector tiene conocimientos previos de
programación, lo que conlleva a una secuencia de aprendizaje
donde primero se estudian cursos introductorios como Pascal y
metodología de la programación estructurada, que forman las
bases y luego se estudia el Lenguaje de Programación C/C++.
Nuestra experiencia en la enseñanza de lenguajes de
programación no nos ha permitido recomendar un texto que
contenga la metodología y programación en C/C++. Es por eso
que el texto esta dirigido a lectores que necesitan mejorar
su metodología de programación y elaborar programas en C++,
encontrando en este texto ejercicios variados en forma y
TECNICAS DE PROGRAMACIÓN ESTRUCTURADA: Aplicaciones en C++ GamarraMorenoADJ 1

complejidad. El texto contiene técnicas de programación
estructurada con aplicaciones en Lenguaje C/C++.
En los capítulos I y II se desarrollan los conceptos básicos

sobre las técnicas de programación. Los capítulos III, IV y V
desarrollan las características del lenguaje de programación
C++. Las Sentencias de control, tratada en el capitulo VI, es
la parte medular de cualquier programa y son estas que la que
definen la secuencia de ejecución de las sentencias del
programa. En el capitulo VII, los programas grandes son
divididos en pequeños programas llamados subprogramas y
implementados como funciones, mediante las técnicas del
diseño descendente y la programación modular se consigue una
división optima del programa en subprogramas. Las estructuras
de datos como los registros (en C/C++ struct) y arreglos (en
inglés arrays) son desarrollados en el capitulo VIII. El
capitulo VIII y IX tratan sobre los punteros y el uso de
archivos de datos respectivamente.
Esperamos que este material sea de gran ayuda en su

aprendizaje en la programación de computadoras.
LOS AUTORES.

CAPITULO UNO
PROGRAMACIÓN DE COMPUTADORAS
1.1. CONSTRUCCIÓN DE UN PROGRAMA DE

COMPUTADORA
Cualquier tarea que involucre el enfrentarse a un
problema - no necesariamente la construcción de un
programa de computadora -, involucra el tener una
comprensión total del mismo y planear cuidadosamente
cada uno de los pasos que intervienen en su solución.
La aparición de la computadora se ha constituido como

un potente medio por el cual podemos resolver muchos
de nuestros problemas (cuando el problema lo permita),
pero, ¿cómo nos ayuda la computadora a resolver estos
problemas?. Para ello empleamos un conjunto de
instrucciones que pueda “entender” la computadora, a
este conjunto de instrucciones le llamamos programa de
computadora.
Estos programas pueden desarrollarse en alguno o

varios de los diferentes lenguajes de programación
existentes, también se pueden emplear una combinación
de estos.
Obviamente debemos conocer las particularidades de

cada lenguaje de programación y emplearlo
adecuadamente. En nuestro caso emplearemos el Lenguaje
de Programación C++ aplicado con Técnicas de
Programación Estructurada, ambos serán analizados con
más detalle en las secciones que siguen.
El desarrollo del Programa de Computadora implica el

seguimiento de varias etapas, los cuales pasamos a
describir:
1.1.1. ANÁLISIS DEL PROBLEMA

Aquí damos el primer paso para el desarrollo
de un Programa de Computadora, en esta parte
se describe detalladamente el problema,
determinando lo siguiente:
Datos de entrada
En el cual se especifica los datos
proporcionados por el problema en
cuestión. Algunas veces se tendrán que
seleccionar entre muchos datos, aquellos
datos importantes para obtener lo que se
requiere.
Datos de salida
El programa que se elabora para solucionar
el problema generará un resultado (lo que
requerimos), ¿qué resultado?.
Evidentemente, esto también lo
encontramos al analizar el problema, de
esta forma establecemos los datos que se
deben obtener al aplicar el programa.
1.1.2. PROCESO DE SOLUCIÓN

Luego del análisis estableceremos la relación
existente entre los datos de entrada y los
datos de salida.
Puesto que si el problema es factible de ser

solucionado recurriendo a un programa de
computadora, los datos de entrada deben
sustentar una relación con los datos de
salida a través de un algoritmo que será la
solución a nuestro problema. Un algoritmo es
simplemente el conjunto de acciones que se
deberán establecer para solucionar nuestro
problema. Este algoritmo - el Capítulo Dos
trata en detalle acerca de los algoritmos -
puede ser presentado de diversas maneras, una
de sus formas de presentación es a través de
código en un lenguaje de programación.
1.1.3. REFINAMIENTO DEL PROGRAMA

En esta etapa sometemos al programa a una
serie de pruebas para determinar que cambios
se podrían realizar al programa para mejorar
la funcionalidad del mismo, para este fin nos
valemos de un grupo de datos de prueba que en
muchas ocasiones nos permiten encontrar
ciertos detalles que habíamos dejado sueltos.
1.2. CARACTERÍSTICAS DE LOS PROGRAMAS

Para llegar a la solución de un problema podemos
utilizar varios métodos de solución, o lo que es lo
mismo, varios algoritmos. Para seleccionar el
algoritmo correcto debemos tener en cuenta ciertas
características inherentes a estos algoritmos, que
pueden estar representados en la forma de un programa
de computadora. He aquí algunas de las características
que podemos mencionar para este programa de
computadora.
1.2.1. CLARIDAD
Ha de ser fácil de leer y entender, en lo
posible se debe emplear el algoritmo más
simple, de entre las múltiples opciones
existentes.
Un modo de mejora en la claridad del

programa, es el de disponer comentarios en el
programa, esto permite adicionalmente; la
facilidad en el mantenimiento, las
modificaciones y actualizaciones cuando sea
necesario.
1.2.2. EFICIENCIA
Se busca hasta donde se pueda, emplear la
menor cantidad de acciones o instrucciones en
el programa, aprovechando los recursos que
pueda ofrecer el sistema y la computadora,
debe ser fácilmente adaptado a otro lenguaje
de programación.
1.2.3. MODULARIDAD Y ESTRUCTURACIÓN
Puede estar subdividido en bloques o módulos,
cada módulo realiza una parte del trabajo
total. Los módulos deben usar las técnicas de
la Programación Estructurada para facilitar
la verificación, depuración y mantenimiento
del programa.
1.3. OBJETOS DE UN PROGRAMA

Se consideran como objetos de un programa a aquellos
elementos que son utilizados para almacenar y
representar los datos ha emplearse en un programa,
tienen las siguientes características:
• Identificador: Es el nombre que identificara al

objeto. Ejemplo: suma, var1, pi, etc.
• Tipo: Es el conjunto de valores que puede tomar, el

C++ tiene varios tipos de datos, el tipo de dato
determina el conjunto de valores posibles para el
objeto.
• Valor: Dentro del conjunto de valores que puede

tomar se le asigna uno de ellos en un instante.
Ejemplo: a = 5.
Los objetos los podemos dividir en Constantes y

Variables.
1.3.1. CONSTANTES
Estos objetos tienen valores fijos y que no
pueden ser variados a lo largo de la
ejecución de un programa.
Se tiene aquellas que son predefinidas y

definitivamente sus valores no pueden ser
cambiados. Por ejemplo: __time__ significa la
hora en el que fue compilado el archivo
fuente.
En el C++ también existen lo que se ha dado

por llamar “variables constantes”, aunque
realmente sean las constantes que define el
propio programador.

1.3.2. VARIABLES
Son objetos cuyos valores tienen la
posibilidad de ser cambiados durante la
ejecución del programa. Ejemplo: int a;
declara una variable “a” de tipo int.

CAPITULO DOS
ALGORITMOS
2.1. DEFINICIONES
2.1.1. ALGORITMO
El algoritmo tal como lo vimos inicialmente,
es el conjunto de acciones que se deberán
realizar para resolver un problema. Si este
problema ha de ser resuelto por una
computadora, entonces el algoritmo es el
conjunto de instrucciones que deberán ser
realizados por la computadora.
El algoritmo empleado debe indicar el orden

de realización de cada instrucción, el número
de instrucciones será finito. Se debe obtener
los mismos resultados, cuando los datos de
entrada son los mismos.
Para la construcción de los algoritmos

emplearemos; la Programación Modular y una
Técnica de Programación Estructurada.

2.1.2. PROGRAMACIÓN MODULAR
Existe una “regla de oro” en la programación,
“divide y vencerás”. La Programación Modular
es la aplicación de esta regla, divide el
programa en módulos, en el caso del C++ estos
módulos están representados en la forma de
funciones, ya que el C++ es un lenguaje
funcional, es decir solamente emplea
funciones en la construcción de un programa.
Estos módulos reducen la complejidad de un

programa, al permitir que cada módulo pueda
ser analizado y perfeccionado casi
independientemente del resto de los módulos,
no totalmente independiente porque no se debe
perder la visión global del programa.
Los módulos son interdependientes entre sí;

uno de ellos, el módulo principal, controla
y relaciona los demás módulos. El módulo
principal, también es conocido como programa
principal; en el caso del C++ esta viene a
ser la función principal o función main(). El
resto de módulos se conocen como
procedimientos o subprogramas; en el caso del
C++ se denominan simplemente funciones.
Un módulo es un conjunto de instrucciones

ordenadas, los cuales pueden ser
referenciados empleando el nombre que se le
asigna al módulo.
Cabe mencionar que, si el programa no es muy

complejo no será necesario crear más de un
módulo, en este caso no se ha dividido el
programa.
2.1.3. PROGRAMACIÓN ESTRUCTURADA

Ya sea que el programa cuente con uno o
varios módulos, en nuestro caso del C++, con
una o más funciones, tendremos que emplear la
técnica de programación estructurada en el
módulo o los módulos.
La Programación Estructurada, es una técnica

de programación –existen otras- que emplea en
el diseño de los módulos: estructuras de
control, recursos abstractos y un diseño
descendente.
Estructuras de control
Son tres tipos de estructuras que al
utilizarse individualmente o en forma
combinada pueden resolver cualquier
problema de programación con un solo punto
de entrada y de salida.
Las estructuras son las siguientes:
• Estructura secuencial, el cual ejecuta
el conjunto de instrucciones
sucesivamente una a continuación de
otra, sin omitir ninguna.
• Estructuras selectivas, son aquellas
que seleccionan una alternativa –puede
ser una o varias instrucciones- a
realizar, la selección depende del
valor de una condición. Estas a su vez
se dividen en estructuras selectiva
simple, doble y múltiple.
• Estructuras repetitivas, son aquéllas
en le que una instrucción o conjunto de
instrucciones se repiten una cantidad
de veces determinada por una condición.
Tenemos las siguientes, estructura
repetitiva mientras, hacer - mientras,
desde – hasta (para).
Recursos abstractos
El conjunto de instrucciones a seguir es
un recurso abstracto, pues es
independiente del tipo de computadora a
emplear, así como también del lenguaje de
programación. Estas instrucciones deben
ser implementadas con pocos o casi ningún
cambio, en un lenguaje de programación
específico para cualquier tipo de
computadora.
Metodología Descendente de “Arriba hacia

Abajo”
Esta metodología conocida también como
“top_down” coloca las instrucciones en una
estructura jerárquica, teniendo que
algunas de estas instrucciones se
encuentren en niveles respecto a otros.
Dos instrucciones de niveles inmediatos se
TECNICAS DE PROGRAMACIÓN ESTRUCTURADA: Aplicaciones en C++ GamarraMorenoADJ10
relacionan a través de sus entradas y
salidas.
En cada nivel se detalla como se utilizan
los datos que permitirá la resolución del
problema planteado. Estos niveles muchas
veces representan módulos de programas.
2.2. CONSTRUCCIÓN DE ALGORITMOS
Con el conocimiento acerca de los datos de entrada y
salida, se puede iniciar la construcción del
algoritmo.
Para construir un algoritmo se emplea un diseño

descendente, por lo tanto el algoritmo puede emplear
módulos de programa que serán fáciles de analizar.
Cada uno de estos módulos pueden modificados

constantemente de tal manera que se ajusten cada vez
más a las necesidades de nuestro programa.
Luego es necesario representar el algoritmo a través

de algunas herramientas que mencionaremos en la
siguiente sección.
2.3. REPRESENTACIÓN DE ALGORITMOS

El algoritmo puede ser representado de diversas
maneras, para ello emplearemos algunas de las
denominadas herramientas de programación: Diagrama de
flujo, Diagrama N-S, Pseudocódigo. La representación
del algoritmo recurriendo al código de un Lenguaje de
Programación tal como el C++, hace que se tenga que
conocer necesariamente la sintaxis y características
de este, por ello en forma general e
independientemente del lenguaje de programación, es
mejor representarlo empleando algunas de estas
herramientas. En este libro orientaremos el diseño del
algoritmo para su representación en el C++.
2.3.1. DIAGRAMA DE FLUJO

Es una técnica que sirve para representar un
algoritmo a través de símbolos y representa
el orden de la secuencia de los algoritmos a
través de líneas de flujo, representadas como
flechas.

Existen unos pocos símbolos denominados
principales que permite representar un
algoritmo en forma general, pero además se
cuenta con un conjunto de símbolos
adicionales que se emplean para situaciones
especificas.
2.3.2. DIAGRAMA N-S

El diagrama Nassi – Schneiderman, para
abreviar diagrama N-S, cumple también la
función de representar un algoritmo, para
ello hace uso de cajas contiguas, dispuestas
uno tras de otros. Igual que el anterior,
permite representar todas las instrucciones
que deben ir en un programa.
2.3.3. PSEUDOCÓDIGO
Representa al algoritmo, en forma de palabras
y frases del lenguaje natural, en nuestro
caso el español. El Pseudocódigo a de estar
sujeto a ciertas reglas que mencionaremos
oportunamente, de tal manera que permitan
expresar nuestro algoritmo de manera fácil y
flexible.

CAPITULO TRES
CARACTERISTICAS DEL C++
3.1. CARACTERÍSTICAS
El lenguaje de programación C++ se emplea para
escribir sistemas de operativos, compiladores,
programas ensambladores, programas de bases de datos,
sistemas expertos, etc. Y sus características son:
• Es de propósito general;
• Es un lenguaje de alto nivel como: PASCAL, BASIC,

etc;
• Es un lenguaje estructurado, pues contiene las

estructuras básicas de composición, selección y
lazo o ciclo con entrada única;
• Se le considera lenguaje de nivel medio, esto es,

entre lenguaje ensamblador y de alto nivel, pues
permite el manejo de datos a nivel de bits, bytes y
direcciones;
• Permite la programación modular: se pueden escribir

programas independientes (módulos) constituyendo
librerías de programas para ser utilizados
posteriormente;

• Es transportable: los programas escritos en este
lenguaje pueden ser ejecutados bajo diferentes
plataformas (Sistemas Operativos).
3.2. IDENTIFICADORES
Un identificador es el nombre que se da a un programa,
variable, constantes, etiqueta, función, clase,
estructura, etc. Su longitud significativa por defecto
es de 32 caracteres y debe estar formado por:
• El primer carácter debe ser una letra o el carácter

subrayado (_),
• Los siguientes caracteres al primero pueden ser

letras, dígitos, o el carácter subrayado (no esta
permitido los espacios),
• El lenguaje C++ diferencia entre mayúsculas y

minúsculas en los identificadores, es decir los
identificadores AREA y area son diferentes, y
• No se deben usar como identificadores las palabras

reservadas por el lenguaje (ejemplo: break, case,
char, int, etc.)
3.3. PALABRAS RESERVADAS

Las palabras reservadas forman parte del lenguaje de
programación C++ y entre algunas de las palabras
reservadas tenemos:
Asm Auto Break case

cdecl Char Class const
continue _cs default delete
Do Double _ds else
enum _es Extern _export
far _fastcall float for
Friend Goto huge if
inline Int Interrupt _loadds
long Near new operator
Pascal Private protected public
register Return _saveregs _seg
short Signed sizeof _ss
static Struct switch template
this typedef union unsigned
virtual void volatile while

3.4. ESTRUCTURA DE UN PROGRAMA
El Lenguaje de programación C++ esta formado por
funciones y estos a su vez están formados por bloques,
la función main es la encargada de llamar a las otras
funciones.
// Directivas y declaraciones
main(){
//Directivas declaraciones
//Sentencias
}
función_1(){
//Directivas declaraciones
//Sentencias
}
//Más funciones
Las Directivas son orden de programa que no se

traducen a lenguaje de maquina porque es un mensaje
para el compilador (o preprocesador), algunas
directivas son: #include, #pragma, #define, #undef,
etc.
Las declaraciones son sentencias que especifican

atributos (identificador, tipo de datos, alcance,
tiempo de vida) de una variable o una función. La
declaración de una función se conoce como prototipo.
3.5. COMENTARIOS
Los comentarios son ignorados por el compilador y se
utilizan para autodocumentar los programas y C++
soporta dos tipos:
3.5.1. COMENTARIO EN MÁS DE UNA LINEA

/* Comentario */
El compilador ignora todo lo que se encuentra

entre /* y */.
3.5.2. COMENTARIO EN UNA SOLA LÍNEA

// Comentario

El compilador ignora todo lo que viene
después de // hasta el final de la línea.
3.6. BLOQUES
Cualquier grupo de instrucciones puede formar un
bloque y ser tratado como una instrucción simple, para
lo cual basta encerrarlo entre llaves.
{
//Sentencias
}
Se pueden anidar como se muestra a continuación
{//Comienzo de bloque
{//Comienzo de sub-bloque
..
} //Fin de sub-bloque
}//Fin de bloque
3.7. TIPOS DE DATOS FUNDAMENTALES
3.7.1. TIPO CHAR

Son datos de un byte de longitud. Las
variables de este tipo pueden tener signo
(por defecto) o no tener signo, su rango es
de -128 a 127 y de 0 a 255, respectivamente.
Puede almacenar codigos ASCII (de: letras,
digitos, signos de puntuacion, simbolos
especiales, etc.
Este tipo de dato internamente es tratado

como un número entero.
3.7.2. TIPOS ENTEROS

Guardan números enteros positivos o negativos
o cero, los tipos enteros son:
TIPO LONGITUD RANGO

Unsigned char 8 bits 0 a 255
Char 8 bits -128 a 127
Enum 16 bits -32,768 a 32,767
Unsigned int 16 bits 0 a 65,535
Short int 16 bits -32,768 a 32,767
Int 16 bits -32,768 a 32,767
Unsigned long 32 bits 0 a 4,294,967,295
TIPO LONGITUD RANGO
Long 32 bits -2,147,483,648 a 2,147,483,647
3.7.3. TIPOS DE PUNTO FLOTANTE

Guardan números positivos, negativos o cero
con parte fraccionaria o punto decimal.
TIPO LONGITUD RANGO

Float 32 bits 3.4*10-38 a 3.4*10 38)
Double 64 bits 1.7*10-308 ) a 1.7*10 308
Long double 80 bits 3.4*10-4932 a 1.1*10 4932
3.7.4. TIPO VOID

Es un tipo de dato que indica vacío (nulo).
Cuando una función no devuelve un valor la
función es de tipo void.
3.8. MODIFICADORES DE TIPO

Los modificadores de tipo son: signed, unsigned,
short, long. Alteran el rango del tipo. Todos los
modificadores son aplicables al tipo int.
Los modificadores signed, unsigned puede ser aplicado

al tipo char.
Cuando el tipo es omitido entonces int es asumido. El

modificador long puede ser aplicado al tipo double.
Ejemplos:
long x; /* long int */
unsigned char car; /* Caracter sin signo */
unsigned long int; /* Se puede omitir int, porque el

tipo por defecto es int */
3.9. CONSTANTES
Son valores numéricos, caracteres o cadenas que no
ocupa memoria fuera del código del programa.
3.9.1. CONSTANTES ENTERAS

Son constantes sin parte fraccionaria y puede
estar en sistema de numeración octal, decimal
o hexadecimal; por ejemplo en el sistema
decimal: 34, 5678.
Constante hexadecimal
Las constantes Hexadecimales y están
precedidas por 0x, utiliza los dígitos del
0..9 y las letras de A..F (para
representar valores del 10..15); por
ejemplo: 0xFF, 0x12.
Constante octal
Son constantes en el sistema de numeración
octal y están precedidos por 0 (cero),
utiliza los dígitos del 0..7; por ejemplo:
011, 004.
3.9.2. CONSTANTE CARÁCTER (CHAR)

Es una constante que esta formado por un solo
carácter encerrado entre comillas o una
secuencia de escape; por ejemplo: '\n','A'.
Las secuencias de escape que se pueden

utilizar son:
S.ESC CARACTER DE SALIDA

\a alerta (beep)
\b Retroceso
\f salto de pagina (alimentación)
\n salto de línea
\t tabulador horizontal
\" comillas dobles
\r retorno de carro
\\ Backslash
\? Signo de interrogación
\DDD Código octal de un carácter
\xHHH Código hexadecimal de un carácter
\0 carácter nulo
\' comilla simple
\v Tabulación vertical
3.9.3. CONSTANTE CADENA

La constante cadena es un conjunto de
caracteres y/o secuencias de escape que están
encerrados entre comillas dobles. "A" es una
cadena y 'A' es un carácter.

3.9.4. CONSTANTE DE PUNTO FLOTANTE
Son constantes numéricas con parte
fraccionaria; por ejemplo: 12.48, .24, -
4.3E+38.
3.10. DEFINICIÓN DE CONSTANTES

Una constante no puede cambiar su valor cuando el
programa esta en ejecución. Se define utilizando:
3.10.1. LA DIRECTIVA #DEFINE

#define <identificador> <Valor>
Ejemplo:
#define NOTA_MAX 20
#define ENTER 0x13
#define titulo "TURBO C"
3.10.2. CONST
const <identificador>=<Valor>;
Ejemplo:
const NOTA_MAX=20;
3.11. DECLARACIÓN DE VARIABLES
Toda variable para ser usada por un programa debe ser
antes declarada y el formato a utilizar es:
[<almacenamiento>] <tipo> <identificador> [<=valor>];
< almacenamiento>: auto, static, register, extern. Si

se omite asume auto.
<identificador>: Indica los nombres de las variables a

definir y están separados por comas.
Ejemplos:
int contador=0;
float sueldo, descuento, igv=0.18;
3.12. EXPRESIONES
Son valores, constantes, variables, llamada a una
función o una combinaciones de los anteriores. Cuando

se mezclan variables de diferentes tipos en una
expresión, C++ las convierte a un mismo tipo. C++
convertirá todos los operandos al tipo más grande
según:
Todos los tipos char, short int se convierten

a int. Todos los tipos float a double.
Para todo par de operandos, lo siguiente

ocurre en secuencia:
a) Si uno de los operandos es un long double

el otro se convierte a long double.
b) Si uno de los operandos es double el otro

se convierte a double.
c) Si uno de los operandos es long el otro

se convierte a long.
d) Si uno de los operandos es unsigned el

otro se convierte a unsigned.
EJEMPLO
char ch;
int i;
float f;
double d;
r=(ch / i) + (f * d) - (f + i);
int double double double

at
int double double
double
double
En la conversión, el tipo char ch es convertido a int

y el float f es convertido a double. Luego según los
operandos se van modificando los tipos hasta obtener
double.
3.13. CONVERSIÓN DE TIPOS

Para forzar el tipo de una expresión utilice:
(tipo) <expresión>

Ejemplo:
float res;
int num=13;
i=(float) num/2; /* i toma el valor de 6.5 */
/* Primero num se cambia al tipo float y

luego efectua la operación */

CAPITULO CUATRO
OPERADORES BÁSICOS
4.1. OPERADORES ARITMÉTICOS

Los operandos de mayor precedencia se ejecutan antes
que los de menor precedencia. Por ejemplo:
4+5*2à14
Los operandos con igual precedencia se ejecutan de

izquierda a derecha. Por ejemplo:
5*4/2/2à5
OPERADOR DESCRIPCION EJEMPLO OBSERV. PRECEDENCIA

( ) Agrupación (3+5) 1
- Menos unitario -3 2
+ Más unitario +3 2
++ Incremento a++ a=a+1 2
-- Decremento a-- a=a-1 2
* Multiplicación 4*3 3
/ División 4/3 3
% Modulo 4%3 3
+ Suma 4+3 5
- Resta 4-3 5
Cuando el operador de división se aplica a un operando

de tipo entero el resultado es de tipo entero, ejemplo
3/2 es igual a 1. Para obtener la parte fraccionaria
es necesario que uno de los operandos sea de tipo
flotante, ejemplo 3/2.0 ó 3.0/2 es igual a 1.5.
El operador modulo es equivalente a decir el residuo

de dividir el primer operando entre el segundo,
ejemplo 5%2 es igual a 1. Sólo es aplicado a datos de
tipo entero.
El operador ++ o -- puede ir delante o después del

operando. Cuando va delante del operando primero
incrementa o decrementa y luego utiliza el nuevo valor
del operando. Cuando va después del operando primero
utiliza el valor del operando y luego lo incrementa o
decrementa.
Ejemplo del uso de ++ antes del operando:
a=3;
x=++a+3;
“a” toma el valor de 4, a este nuevo valor se

le suma 3, por lo tanto x=7. Es línea es
equivalente a:
 a = a + 1;
x = + + a + 3; 
 x = a + 3;
Ejemplo del uso de ++ después del operando:
a=3;
y=a+++2; //
“y” toma el valor del resultado de a

(utilizando su valor 3) + 2 igual a 5, luego
“a” toma el valor de 4. Su equivalencia es:
 y = a + 2;
y = a + + + 2; 
 a = a + 1;
4.2. OPERADOR DE ASIGNACIÓN

Estos operadores son utilizados para asignar un valor
a una variable y pueden ser:

4.2.1. IGUAL (=)
Variable = <Valor>;
El valor puede ser una constante, una
variable o una expresión.
Ejemplos:
saldo = 567.89;
car = ‘A’;
edad = 20;
4.2.2. ASIGNACIÓN MÚLTIPLE

Permite asignar un valor o expresión a más de
una variable.
variable_1=variable_2=…=variable_N=expresión;
Ejemplo:
x=y=3*2;
4.2.3. ASIGNACIÓN RELATIVA
variable <operador> = Expresión
El operador puede ser cualquier operador

aritmético y es equivalente a:
variable = variable operador expresión;
OPERADOR EJEMPLO OBSERVACIONES

+= x+=5; x=x+5;
-= x-=5; x=x-5;
*= x*=5; x=x*5;
/= x/=5; x=x/5;
%= x%=5; x=x%5;
Ejemplo:
x += 5; //Equivalente a x=x+5;
y -= 3; //Equivalente a y=y+3;
z = 2; //Equivalente a z=z*2;

4.3. OPERADORES DE RELACIÓN
Los operadores relacionales dan como resultado
verdadero o falso. En "C++" todo numero diferente de
cero es verdadero, y cero es equivalente a falso.
OPERADOR DESCRIPCION EJEMPLO PRECEDENCIA

> mayor que 4>12 1
>= mayor o igual que 4>=12 1
< menor que 4<12 1
<= menor o igual que 4<=12 1
== igual que 4==12 2
!= diferente de 4!=12 2
4.4. OPERADORES LÓGICOS

Los operadores lógicos dan como resultado verdadero o
falso. Recuerde que en "C++" todo numero diferente de
cero es verdadero y cero es falso.
OPERADOR DESCRIPCION EJEMPLO PRECEDENCIA

! No lógico !(4>12) 1
&& y lógico (4>12)&&(8>12) 2
|| o lógico (4>12)||(8>12) 3
El resultado de los operadores lógicos se resume en la

siguiente tabla:
p q !p !q p&&q p||q
1 1 0 0 1 1
1 0 0 1 0 1
0 1 1 0 0 1
0 0 1 1 0 0

CAPITULO CINCO
SALIDA / ENTRADA ESTÁNDAR
5.1. SALIDA/ENTRADA ESTÁNDAR EN C++
5.1.1. SALIDA CON cout

El flujo de salida se representa por el
identificador cout, que es en realidad un
objeto. El operador << se denomina operador
de inserción o de “poner en”. Dirige el
contenido de la variable situada a su derecha
al objeto situado a su izquierda. Su formato
es:
cout << expr_1<< expr_2<< ... << expr_n;

Ejemplo 1:
//Permite usar el cout

#include <iostream.h>
main()
{
cout<< "primer programa";

//lee un carácter del teclado

Ejemplo 2
//programa que suma dos nùmeros

main()
{ int x=1,y=3,suma;
suma=x+y;
cout<< "\n la suma de "<< x << " mas "
<<y << " es " << suma;
}
5.1.2. ENTRADA CON CIN

El C++ permite la entrada de datos a través
del flujo de entrada cin. El objeto cin es un
objeto predefinido en C++ que corresponde al
flujo de entrada estándar. Este flujo
representa datos que proceden del teclado. El
operador >> se denomina también de extracción
o de lectura de. Toma el valor del objeto
flujo de su izquierda y lo sitúa a en la
variable situada a su derecha. Su formato es:
cin >>variable_1>>variable_2>>…>>variable_n;
Ejemplo 1:
/* Programa que suma dos nùmeros leidos del

teclado */
main()
{ int x,y,suma;
cout << "Ingrese dos nùmeros : ";

cin >> x >> y;
suma=x+y;
cout<< "\n la suma de "<< x <<" mas "
<<y <<" es " <<suma;
}

Ejemplo 2:
/* Programa que suma convierte de Farenheit a

Celsius */
main()
{ int f,c;
cout << "Ingrese temperatura farenheit : ";

cin >> f;
c=(f-32)*5/9;
cout<< "Su equivalente en celsius es "<< c;

CAPITULO SEIS
SENTENCIAS DE CONTROL
Las sentencias de control son una parte imprescindible dentro

de un lenguaje de programación. Son aquellas que determinan
secuencia de las sentencias a ejecutar.
6.1. SENTENCIA if
Expr
SI
N0
Sentencia
Si la expresión es diferente de CERO ejecuta la

sentencia y continua con la sentencia que sigue a if.
if (expresión) sentencia;
Ejemplo 1 : El siguiente programa determina el

número mayor de dos números ingresados
por el teclado.

void main(){
float num1,num2,mayor;
cout <<"Ingrese dos números : ";

cin >> num1 >> num2;
mayor=num1;
if(num2>num1) mayor=num2;
cout <<"El mayor es : "<<mayor<<endl;
}
Explicación
Después del ingreso de los dos números se asume

que el mayor es num1, pero la condición de la
sentencia if evalúa si num2 es mayor que num1 y
si la condición es verdadera el mayor es num2.
Ejemplo 2 : El siguiente programa determina el

valor absoluto.
void main(){
float num;
cout <<"Ingrese el número : ";

cin >> num;
if(num<0) num=-num;
cout <<"El valor absoluto : "<<num<<endl;
}
Explicación
El numero ingresado se evalúa para determinar

si es negativo, un numero es negativo si es
menor que cero. Si es negativo se le cambia de
signo para obtener su valor absoluto.
Ejemplo 3 : Programa que imprime en orden

ascendente los tres números ingresados.
void main(){
int a,b,c,t;
cout<<"Tres números enteros : ";

cin >> a >> b >> c;
if (a>b) { t=a; a=b; b=t;}
if (b>c) { t=b; b=c; c=t;}
if (a>b) { t=a; a=b; b=t;}
cout <<a<<”\t”<<b<<”\t”<<c;
}
Explicación

Los números ingresados son a, b y c. Utilizando
el algoritmo de la burbuja para tres números,
que consiste:
En comparar si el primer numero es mayor que el
segundo numero, si el segundo numero es mayor
que el tercer numero, y finalmente, si el
primer numero es mayor que el segundo numero.
Si se cumple la condición se intercambian sus
valores. Al final a, b y c contienen los
valores ordenados ascendentemente de los
números ingresados.
Para intercambiar los valores de num1 y num2 se

utiliza el siguiente algoritmo:
t=num1;
num1=num2;
num2=t;
Usando la variable t (temporal) se consigue que

no se pierda el valor de num1. Si los números
son: num1=10 y num2=5; la prueba de escritorio
es:
//t toma el valor de num1 (10)

t=10;
//num1 toma el valor de num2 (5)
num1=5;
//num2 toma el de t (10)
num2=10;
Al finalizar la ejecución de las tres

sentencias se tiene: num1=5 y num=10; lo que
nos confirma que el algoritmo ha intercambiado
sus valores originales.
Note que en el programa las tres sentencias que
realizan el intercambio están encerrado entre
llaves formando un bloque de sentencias.
SI Expr NO
Sentencia_1 Sentencia_2
Si la expresión es diferente de CERO ejecuta la

sentencia_1, sino ejecuta la sentencia_2. En ambos
casos continua con el flujo del programa.

if (expresión) sentencia_1;
else sentencia_2;
Ejemplo 1 : Programa que determine el salario

semanal a pagar a un trabajador. Por
trabajar más de 40 horas durante la
semana se hace acreedor a una pago
extraordinario que consiste: en pagar
por cada hora extra 50% mas que una
hora normal. En este programa se
ingresan: el numero de horas trabajadas
y el pago por hora normal.
void main(){
int horas;
float pago,p_h;
cout<<"Numero de horas trabajadas:";

cin>>horas;
cout<<"Pago por hora normal:";
cin>>p_h;
if(horas>40)
pago=(horas-40)*1.5*p_h+40*p_h;
else
pago=horas*p_h;
cout<<"\n\nPago semanal:"<<pago;
cout<<endl;
}
Explicación
La sentencia if evalúa si el trabajador tiene

mas de 40 horas (horas>40) para determinar si
tiene horas extras. Si tiene horas extras
calcula su pago debido a las horas extras
((horas-40)*1.5*p_h) y su pago normal por las
40 horas (40*p_h). Si no tiene horas extras
para calcular su pago se multiplica simplemente
el número de horas trabajas por pago por hora
(horas*p_h).
Ejemplo 2 : Programa que determina si un año es

bisiesto. Un año es bisiesto si es
múltiplo de 4. Los años múltiplos de
100 no son bisiestos salvo que lo sean
también de 400; por ejemplo: 1984 y
2000 son bisiestos, pero 1800 no es
bisiesto.
void main(){
int anno,sw=0;
cout<<"Año : ";
cin>>anno;
if(anno % 4==0){
sw=1;
if(anno%100==0&&anno%400!=0)
sw=0;
}
if(sw) cout <<"Año bisiesto";
else cout<<"Año no bisiesto";
cout<<endl;
}
Explicación:
En el programa sw=0 significa que el año no es

bisiesto y sw=1 significa año bisiesto.
Se asume que el año es no bisiesto (sw=0) y si

es múltiplo de cuatro (anno % 4==0) sw cambia a
1, lo que significa que el año es bisiesto. Los
años múltiplos de 100 también son múltiplos de
cuatro, pero no son bisiestos. Por esa razón,
cuando los años son múltiplos de 100 y no lo
son de cuatrocientos (anno%100==0 &&
anno%400!=0) sw cambia a 0, lo significa que no
es bisiesto.
Ejemplo 3 : Programa que calcula el perímetro de un

triángulo si se ingresan las medidas
sus tres lados a, b y c. Para que los
tres lados del triángulo cierren se
debe cumplir: a<b+c, b<a+c y c<a+b.
void main(){
float a,b,c,p;
cout <<"Ingrese los lados : ";

cin >> a >> b >> c;
if(a<b+c && b<a+c && c<a+b){
p=a+b+c;
cout << "Perimetro= " << p;
}
else {
cout<< "No forman un triangulo";
}
}
Explicación:
Antes de calcular el perímetro se evalúa si los

tres lados forman el triángulo.

expr==const_1 SI
NO Sentencia_1
expr==const_2 SI
NO Sentencia_2
expr==const_3 SI
Sentencia_3
...
...
...
expr==const_N SI
Sentencia_N
NO
Sentencia_x
if (expresión_1) sentencia_1;
else if (expresión_2) sentencia_2;
else if (expresión_3) sentencia_3;
...
...
else if (expresión_n) sentencia_n;
[else sentencia_x;]
Ejemplo 1 : La comisión sobre las ventas totales de

un empleado es como sigue:
• Si ventas < 50.00 unidades monetarias (u.m.) entonces no hay comisión.

• Si esta entre 50.00 u.m. y 500.00 u.m. incluidos, entonces la comisión
es 10% de las ventas.
• Si las Ventas > 500.00, entonces la comisión es 50.00 u.m. mas 8% de
las ventas superiores a 500.00.
El programa calcula la comisión cuando se

ingresa las ventas.

void main(){
float ventas,comision;
cout<<"Ventas totales : ";

cin>>ventas;
if(ventas<50) comision=0;
else if(ventas>=50&&ventas<=500)
comision=ventas*0.10;
else if(ventas>500)
comision=50+(ventas-500)*0.08;
cout<<"Comisión: " << comision<<endl;
}
Ejemplo 2 : Programa que calcula el monto a pagar

por el consumo de energía eléctrica, si
durante su ejecución se ingresa el
consumo y el tipo de tarifa. Las
tarifas son:
TIPO DE COSTO
TARIFA (U.M./Kw-h)
1 2.30
2 8.25
3 6.42
4 5.80
5 9.65
void main(){
float consumo,tarifa,monto;
int tipo;
cout<<"Consumo (kw-h):";
cin>>consumo;
cout<<"Tipo de tarifa(1 al 5): ";
cin<<tipo;
if (tipo==1) tarifa=2.30;
else if (tipo==2) tarifa=8.25;
else tarifa=0;
if(tarifa){
monto=cons*tarifa;
cout<<"\nMonto a pagar: "<<monto;
}
else cout<<"\nLa tarifa no existe";
}
Explicación:
En el programa según el tipo de tarifa se

determina la tarifa correspondiente y al
multiplicar el tipo de tarifa por el consumo se
obtiene el monto a pagar. Además, si el tipo de
tarifa es diferente de 1 a 5 se le asigna a la
variable tarifa cero, lo que significa que la
tarifa no existe, sólo si la tarifa existe se
calcula e imprime el monto a pagar, caso
contrario se imprime “La tarifa no existe”.
6.2. SENTENCIA switch
Expr
Constante_1 Constante_2 Constante_n default
Sentencia_1 Sentencia_2 ..... Sentencia_n Sentencia_x
El switch es una forma sencilla de evitar largos,

tediosos y confusos anidamientos de else-if, esta
sentencia proporciona una estructura lógica y clara
para bifurcación múltiple.
switch(expresión){
case constante_1 : sentencia_1; break;
.
.
case constante_n : sentencia_n; break;
[default : sentencia_x;]
}
La sentencia switch evalúa el valor de la expresión y

según ese valor determina el flujo del programa. Si el
valor de la expresión es igual a la constante_1
ejecuta la sentencia_1, si el valor es igual a la
constante_2 ejecuta la sentencia_2, así sucesivamente.
Si el valor de la expresión es diferente a las

constantes indicadas en la sentencia switch ejecuta la
sentencia_x correspondiente a default.
Si al final de cada case no se incluye break esto

ocasionaría que todas las sentencias que están debajo
de la constante que tome el valor de la expresión se
ejecuten hasta encontrar un break o el final de
switch; por ejemplo: si la expresión es igual a la
constante_2 se ejecutarían la sentencia_2, la
sentencia_3, así sucesivamente hasta encontrar un
break o el final de la sentencia switch.
Ejemplo 1 : Programa que calcula el monto a pagar

por el consumo de energía eléctrica, si
durante su ejecución se ingresa el
consumo y el tipo de tarifa. Las
tarifas son:
TIPO DE COSTO
TARIFA (U.M./Kw-h)
1 2.30
2 8.25
3 6.42
4 5.80
5 9.65
void main(){
float consumo,tarifa,monto;
int tipo;
cout<<"Consumo:";
cin>>consumo;
cout<< "Tipo de tarifa(1 al 5):";
cin>>tipo;
switch(tipo){
case 1:tarifa=2.30;break;
default:tarifa=0;
}
if(tarifa){
monto=consumo*tarifa;
cout<<"\nMonto a pagar:"<<monto;
}
else cout<<"\nTarifa incorrecta"<<endl;
}
Ejemplo 2 : Programa donde se ingresan el sueldo de

un trabajador, su categoría (A,B,C) y
su año de ingreso. Luego calcula su
nuevo sueldo, según:
• Categoría "A": 15% para los que ingresaron

antes de 1980 y 12% para el resto.

• Categoría "B": 20% para los que ingresaron
• Categoría "C": 25% para los que ingresaron
void main(){
int anno;
float sueldo;
char cat;
cout<<"Ingrese Sueldo:”;
cin>>sueldo;
cout<<"Ingrese Año:”;
cin>>anno;
cout<<"Ingrese Categoría:”;
cin>>cat;
switch(cat){
case 'A':
case 'a':
if(anno>1980)
sueldo=1.15*sueldo;
else
sueldo=1.12*sueldo;
break;
case 'B':
case 'b':
if(anno>1980)
sueldo=1.20*sueldo;
else
sueldo=1.17*sueldo;
break;
case 'C':
case 'c':
if(anno>1980)
sueldo=1.25*sueldo;
else
sueldo=1.22*sueldo;
break;
}
cout<<"Nuevo sueldo: "<<sueldo<<endl;
}
6.3. SENTENCIAS REPETITIVAS O BUCLES

Una sentencia repetitiva o bucle permite ejecutar
repetidamente una sentencia o un bloque de sentencias
mientras se cumple una determinada condición, pero si
el bucle se ejecuta indefinidamente se forma un bucle
infinito. Un bucle infinito se forma generalmente por
un error lógico de programación.
Las sentencias repetitivas en C++ son: while, do while

y for.

6.4. SENTENCIA while
Expr
SI
N0
Sentencia
Primero evalúa la expresión (expr), si la condición es

verdadera (diferente de cero) entonces la sentencia es
ejecutada, caso contrario pasa el control a la
sentencia que sigue a la sentencia while.
Después de la ejecución de la sentencia la condición

nuevamente es evaluada y se procede como en el caso
anterior.
Para que la sentencia se ejecute por lo menos una vez

la condición por lo menos una vez debe ser verdadera.
while (expresión) sentencia;
Ejemplo 1 : Programa que imprime los n números

consecutivos.
void main(){
int n,i;
cout<<"Ingrese el valor de n: ";

cin >> n;
i=0;
while (n>i){
i++;
cout<<i<<"\n";
}
}
Explicación:
Para comprender el funcionamiento del programa

es conveniente hacer la prueba de escritorio,
para lo cual hacemos n=3.
• Ingresar el valor de n=3
• Hacer i=0
• La condición de while n>i, ó 3>0 se cumple
por lo:
• Hacer i=1
• Imprimir el valor de i=1 y un cambio de
línea
por lo:
• Hacer i=2
línea
por lo:
• Hacer i=3
línea
• La condición de while n>i, ó 3>3 no se
cumple
• Fin del programa
Ejemplo 2 : Programa que imprime los divisores de

un numero natural
void main(){
int n,i;
cout<<"Ingrese un numero entero : ";

cin >> n;
i=1;
while (n/2>=i){
if (n % i==0) cout<<i<<"\n";
i++;
}
}
Explicación:
Para determinar los divisores de n: se divide n

entre los números consecutivos de 1 hasta
aproximadamente la mitad de n. Si al dividir n
entre uno de los números consecutivos el
residuo es cero significa que este numero
consecutivo es divisor de n. Es decir por cada
numero consecutivo se debe determinar si es
divisor de n.
En el programa en la variable i se generan los

números consecutivos y con la sentencia if
(n%i==0) se determina si i es divisor, la
condición determina si n entre i tiene residuo
cero.
Ejemplo 3 : Programa que determina si un numero

natural es primo. Un numero es primo si
sólo es divisible por la unidad y por
si mismo.
void main(){
int n,d;
cout <<"Numero natural : ";

cin >> n;
d=2;
while(d*d<n && n%d!=0) d++;
if (d*d>n)
cout<< "Es primo"<<endl;
else
cout<< "No es primo"<<endl;
}
Ejemplo 4 : Programa que imprime los factores

primos de un numero natural.
void main(){
int n,d=2;
cout<<"Ingrese un numero entero : ";

cin >> n;
while (n>=d){
while (n%d!=0) d++;
cout<<d<<"\n";
n/=d;
}
}
Ejemplo 5 : Programa que imprime la cantidad de

números primos indicados comenzando de
1. El valor de n es ingresado.
void main(){
int n,d,i,cant;
cout<<"Cantidad de números primos:";

cin>>cant;
n=i=0;
while (cant>i) {
n++;
d=2;
while(d*d<n && n % d !=0) d++;
if (d*d>n){
cout<< n << " ";
i++;
}
}
}

6.5. SENTENCIA do while
Sentencia
SI
Expr
NO
La sentencia se ejecuta mientras la expresión sea

verdadera (diferente de cero). La expresión es
evaluada después que se ejecuta la sentencia. La
diferencia fundamental entre while y do while es que
la segunda se ejecuta por lo menos una vez, sea cual
sea el resultado de expresión.
do sentencia while(expr);
Ejemplo 1 : Programa que obtiene el producto de dos

números enteros positivos mediante
sumas.
void main(){
int n1,n2,acum=0;
cout<<"Primer entero positivo:";

cin>>n1;
cout<<"Segundo entero positivo:";
cin>>n2;
do{
acum=acum+n2;
n1=n1-1;
}while(n1);
cout<<"Producto=”<<acum<<endl;
}
Ejemplo 2 : Programa que calcula el Máximo Común

Divisor (MCD) de dos números naturales
utilizando el algoritmo de euclides.
El algoritmo consiste: los números a dividir se
ubican en la parte central, el cociente se
ubica en la parte superior y el residuo en la
parte inferior. Se dividen los dos números si

el residuo es diferente de cero, el divisor
pasa a ser el dividendo y el residuo viene a
ser el divisor, se continua con este proceso
hasta que el residuo sea cero. El máximo común
divisor es igual al último divisor, por
ejemplo:
MCD(70,12)=2 MCD(60,36)=12
5 1 5 1 1 2
70 12 10 60 36 24 12 0
10 2 0 14 12 0
void main(){
int n1,n2,mcd,res;
cout<<"Ingrese 2 números enteros: ";

cin>>n1>>n2;
do{
res=n1%n2;
n1=n2;
n2=res;
}while(n2);
mcd=n1;
cout<< "El MCD es "<<mcd<<endl;
}
6.6. SENTENCIA for
Expr_1
Expr_2
SI
Sentencia
N0
Expr_3
La sentencia for se ejecuta repetidamente hasta que el

valor de la expr_2 sea falso (CERO). Generalmente la
exp_1 es el valor inicial del bucle, y es evaluado
antes de la primera ejecución de la sentencia. La
expr_3 es comúnmente el contador del bucle y es
ejecutado después de la ejecución de la sentencia.
Tanto expr_1, expr_2 y expr_3 pueden contener más de
una expresión separados por comas.
for(expr_1;expr_2;expr_3) sentencia;
No es imprescindible indicar las TODAS las expresiones

dentro del paréntesis del for, pudiendose dejar en
blanco algunas de ellas, por ejemplo:
for (;expr_2;expr_3) sentencia; ó
for (expr_1; ; ) sentencia; ó
for ( ; ; ) sentencia;
La sintaxis de las dos últimas sentencias producen

bucles infinitos.
Ejemplo 1 : Programa que calcule la suma de los n

términos de:
1 2 3
s= + + + ...
2 3 4
void main(){
int i,n;
float s;
cout<<"Cantidad de términos: ";

cin>>n;
s=0;
for(i=1;i<=n;i++) s=s+i/(i+1.0);
cout<<"Suma =”<<s<<endl;
}
Ejemplo 2 : Programa que calcula la suma de:
1 1 1 1
s = 1+ + + + ...
2 3 4 n
void main(){
int n,i;
float s;

cin>>n;
s=0;
for(i=1;i<=n;i++) s=s+1.0/i;
cout<<"Suma="<<s<<endl;

Ejemplo 3 : Programa que calcula la suma de los n
términos de:
1 1 1
s = 1− + − + ...
2 3 4
#include <stdio.h>
#include <conio.h>
void main(){
int n,i;
float s,t;
clrscr();
cin>>n;
s=0;
t=-1.0;
for(i=1;i<=n;i++){
t=-t;
s=s+t/i;
}
cout<< "Suma ="<<s;
getch();
}
Ejemplo 4 : Programa que calcula la suma de:
1 1 1 1
s= + + + ...
1 + A 1 + 2 A 1 + 3A 1+ n* A
void main(){
int n,i;
float s,t,a;

cin>>n;
cout<<"Valor de A: ";
cin>>a;
s=0;
for(i=1;i<=n;i++){
t=1/(1+i*a);
s=s+t;
}
cout<< "Suma = "<<s<<endl;
}
Ejemplo 5 : Programa que imprime los términos de la

serie de fibbonacci menores que n.
Los términos de la serie de fibbonacci se
obtienen sumando los dos términos que le
antecedentes así: 1, 2, 3, 5, 8, 13, ... Los
términos 1 y 2 son los números iniciales y
partir de ellos se calculan los demás términos.

void main(){
long int n,p,s,fib;
cout<<"Limite : ";
cin>>n;
fib=1;
for(p=0,s=1;n>=fib;){
cout<<fib<<”\t”;
p=s;
s=fib;
fib=p+s;
}
}
6.7. SENTENCIA break
for(expr1;expr2;expr3){
sentencia_1;
sentencia_2;
...
break;
sentencia_n;
}
sentencia_siguiente;
La sentencia break es usada dentro de un bloque while

o do while o for o switch, y fuerza la finalización de
la sentencia donde es usada.
Ejemplo : Programa que lee un número de punto

flotante y lo imprime redondeado a dos
decimales. El usuario decide si quiere
continuar.
void main(){
double num;
char resp;
while(1){
cout<<"Numero : ";
cin>>num;
num=((long int) (num*100+0.5))/100.0;
cout<<"Numero Redondeado:"<<num;
cout<<"\nContinuar (S/N)?\n";
cin>>resp;
if ((resp=='N') || (resp=='n'))
break;
}
}

6.8. SENTENCIA continue
for(expr1 ;expr2 ;expr3){

sentencia_1;
sentencia_2;
...
continue;
sentencia_n;
}
sentencia_siguiente;
La sentencia continue es usada dentro de un bloque

While o do while o for, y fuerza el flujo del programa
al inicio de la sentencia donde es usada.
Ejemplo : Programa que imprime los números pares

comprendidos de 1 a 20.
void main(){
int i;
for( i=1 ; i <=20 ; i++ ){

if (i % 2) continue;
cout<<i<<”\t”;
}
}
6.9. SENTENCIA goto

La sentencia goto transfiere el flujo del programa a
una sentencia precedida por una etiqueta seguida de
dos puntos (:) dentro de un mismo bloque.
goto etiqueta;
La etiqueta tiene las mismas restricciones que un

identificador. Esta sentencia esta en desuso en la
programación estructurada.
Ejemplo : Programa que suma los números

ingresados, el ingreso termina cuando
el ingreso es cero.

void main(){
int n,s=0;
inicio:
cout<<"Ingrese un número : ";
cin>>n;
s+=n;
if(n) goto inicio;
cout<<"La suma es: "<<s<<endl;
}
Explicación:
Si n!=0 (verdadero) vuelve a ejecutar la

sentencia a la etiqueta inicio.
6.10. PROGRAMAS DE APLICACIÓN
Ejemplo 1 : Programa que lee 3 números y los

imprime en orden descendente.
void main(){
int a,b,c;
cout<<"Ingrese 3 números enteros:";

cin>>a>>b>>c;
if (a>b)
if (a>c)
if (b>c)
cout<<a<<”\t”<<b<<”\t”<<c;
else
cout<<a<<”\t”<<c<<”\t”<<b;
else cout<<c<<”\t”<<a<<”\t”<<b;
else
if (b>c)
if (a>c)
cout<<b<<”\t”<<a<<”\t”<<c;
else
cout<<b<<”\t”<<c<<”\t”<<a;
else cout<<c<<”\t”<<b<<”\t”<<a;
}
Ejemplo 2 : Programa que resuelve una ecuación de

segundo grado de la forma:
ax 2 + bx + c = 0
La discriminante es:
d = b 2 − 4ac
Si la discriminante es mayor o igual que cero
(d>=0) tiene raíces reales, caso contrario

tiene raíces complejas. Las raíces se obtienen
con:
− b ± b 2 − 4ac
x=
2a
#include <math.h>
void main(){
float a,b,c,r,r1,r2,d;
cout<<"Ingrese a, b y c: ";
cin>>a>>b>>c;
d=b*b-4*a*c;
r=sqrt(abs(d));
if (d>=0){
r1=(-b+r)/(2*a);
r2=(-b-r)/(2*a);
cout<<"r1=”<<r1<<”\n”;
cout<<"r2=”<<r2<<”\n”;
}
else {
cout<<”r1=”<<-b/(2*a)<<”+”
<<r/(2*a)<<”i\n”;
cout<<”r1=”<<-b/(2*a)<<”-”
<<r/(2*a)<<”i\n”;
}
cout<<endl;
}
Ejemplo 3 : Programa que permita jugar a las

adivinanzas. El usuario tiene que
elegir un entero de un solo dígito. El
programa tiene que pedir si el numero
es par o impar (0 o 1), y el resto
cuando el numero se divide entre 5. A
partir de esa información se debe
determinar el número.
void main(){
int numa,par,res;
cout<<"Piense en un numero de\n”;

cout<<”una sola cifra\n\n”;
cout<<"Ingrese:\n”;
cout<<"1 si el numero es par\n”;
cout<<"2 si el numero es impar\n”;
cin>>par;
cout<<"Ingrese el residuo de\n”;
cout<<" dividir el numero\n”;
cout<<”pensado entre 5:\n”;
cin>>res;
if(par==1){
if(res % 2) numa=res+5;
else numa=res;
}
else {

if(res % 2) numa=res;
else numa=res+5;
}
cout<<"El numero pensado es:"<<numa<<endl;
}
Ejemplo 4 : Un profesor ha establecido la siguiente

calificación entre sus alumnos:
• Notas de 14 a 20 BUENO
• Notas de 07 a 13 REGULAR
• Notas 00 a 06 DESAPROBADO
ALGORITMO: Si se divide la nota entre 7 se

deduce: Nota de 00 a 06 cociente 0, Nota de 07
a 13 cociente 1, Nota de 14 a 20 cociente 2.
void main(){
int nota,cociente;
cout<<"Ingrese nota de 0 a 20 :";
cin>>nota;
/*Si la nota es positiva realiza
calificacion */
if (nota>=0){
/* divide la nota entre 7 */
cociente=nota / 7;
switch(cociente){
case 0:
cout<<"DESAPROBRADO";
break;
case 1:
cout<<"REGULAR";
break;
case 2:
cout<<"BUENO";
break;
default:
cout<<"NOTA INCORRECTA";
}
}
cout<<endl;
}
Ejemplo 5 : Programa que verifica si una fecha

(dd/mm/aaaa) es correcta.
void main(){
int anno,mes,dia,ok=0,bisiesto=0;
cout<<"Fecha (dd mm aaaa):";

cin>>dia>>mes>>anno;
//Determina si el año es bisiesto
if(anno % 4==0){
bisiesto=1;
if(anno%100==0&&anno%400!=400)

bisiesto=0;
}
//En función al mes verifica si el
//numero de días es correcto
switch(mes){
case 1: case 3: case 5:
case 12:
if(dia>=1&&dia<=31) ok=1;
break;
case 11:
break;
case 2:
if(bisiesto){
}
else if(dia>=1&&dia<=28) ok=1;
break;
}
if(ok) cout<<"\nFecha Correcta"<<endl;
else cout<<"\nFecha incorrecta"<<endl;
}
Ejemplo 6 : Programa que imprima los enteros

positivos desde 1 hasta 300, de manera
que en la salida aparezcan tres números
en un línea, así:
1 2 3
4 5 6
...
...
97 98 99
void main(){
int i;
for(i=1;i<=99;i++){
cout<<i<<”\t”;
if(!(i%3)) cout<<"\n";
}
}
Ejemplo 7 : Programa donde se ingresa un numero del

1 al 99 y luego lo imprima en letras.
#include <string.h>
#include <stdlib.h>
void main(){
int numero;
int unidad,decena;
char dec_le[9],uni_le[6];

cout <<"Numero (1..99):";
cin >> numero;
unidad=numero%10;
decena=numero/10;
switch (decena) {
case 0:
strcpy(dec_le,"");break;
case 1:
strcpy(dec_le,"diez");break;
case 2:
strcpy(dec_le,"veinte");break;
case 3:
strcpy(dec_le,"treinta");
break;
case 4:
strcpy(dec_le,"cuarenta");
break;
case 5:
strcpy(dec_le,"cincuenta");
break;
case 6:
strcpy(dec_le,"sesenta");
break;
case 7:
strcpy(dec_le,"setenta");
break;
case 8:
strcpy(dec_le,"ochenta");
break;
case 9:
strcpy(dec_le,"noventa");
break;
default:
cout << "Fuera de rango"<<endl;
exit(0);
}
if(decena==1){
strcpy(dec_le,"");
switch(unidad){
case 0:
strcpy(uni_le,"");
break;
case 1:
strcpy(uni_le,"once");
break;
case 2:
strcpy(uni_le,"doce");
break;
case 3:
strcpy(uni_le,"trece");
break;
case 4:
strcpy(uni_le,"catorce");
break;
case 5:
strcpy(uni_le,"quince");
break;
}
}
else{
if (decena) strcat(dec_le," y ");
switch(unidad){
case 0:
strcpy(uni_le,"");break;
case 1:
strcpy(uni_le,"uno");break;
case 2:
strcpy(uni_le,"dos");break;
case 3:
strcpy(uni_le,"tres");
break;
case 4:
strcpy(uni_le,"cuatro");
break;
case 5:
strcpy(uni_le,"cinco");
break;
}
}
switch (unidad) {
case 6:
strcpy(uni_le,"seis");break;
case 7:
strcpy(uni_le,"siete");break;
case 8:
strcpy(uni_le,"ocho");break;
case 9:
strcpy(uni_le,"nueve");break;
}
strcat(dec_le,uni_le);
cout << dec_le<<endl;
}
Ejemplo 8 : Programa que imprima las poblaciones de

las ciudades A y B hasta que la
población A sea mayor que B, si sus
tasas de crecimiento son: 6% y 4%
respectivamente. En la actualidad, las
ciudades A y B tiene 85 millones y 45
millones de habitantes respectivamente.
void main(){
float pa,pb,ta,tb;
int i;
//Poblacion A
pa=52e+6;
//Poblacion B
pb=85e+6;
//Tasa de crecimiento A
ta=0.06;
//Tasa de crecimiento B
tb=0.04;
i=0;
while (pa<=pb) {

i++;
pa=pa*(1+ta);
pb=pb*(1+tb);
cout <<i<<"\t"<<pa/1000<<"\t"
<<pb/1000<<"\n";
}
}
Ejemplo 9 : Programa donde se ingresa un número en

base 2 y luego imprima su equivalente
en decimal. Durante el ingreso solo se
lee los dígitos 0 y 1, otro dígito es
ignorado.
void main(){
long int n,n_ok=0,nc=0;
int digito,factor=1,res;
//Ingreso del numero binario

do{
cout<<"Numero en base 2: ";
cin>>n;
}while(n>2147483647||n<0);
while (n>=10){
digito=n%10;
if (digito>=0 && digito<=1){
n_ok+=(digito*factor);
factor*=10;
}
n/=10;
}
if (n>=0 && n<=1)
n_ok+=(n*factor);
//Numero correcto n_ok
//Conversión a base 10 en nc
factor=1;
//Guarda el valor de n_ok
n=n_ok;
while(n>=10){
res=n % 10;
nc+=(res*factor);
n/=10;
factor*=2;
}
nc+=(n*factor);
cout<<"En base 2 : "<<n_ok<<"\n";
cout<<"En base 10: "<<nc<<"\n";
}
Ejemplo 10 : Programa que imprime los “n” primeros

números perfectos, si “n” es ingresado.
Un numero perfecto es un entero
positivo que es igual a la suma de sus
divisores, excluido si mismo.

void main(){
long int i=1,d,suma;
int c=0,n;
cout<<"Cantidad de numeros: ";

cin >> n;
i=0;
while(n>c){
i++;
d=1;
suma=0;
while (i>d){
if (i % d==0) suma+=d;
d++;
}
if(suma==i){
cout<<i<<"\n";
c++;
}
}
}
Ejemplo 11 : Programa donde se ingresa la fecha

actual y la fecha de nacimiento de una
persona; luego calcula y visualiza la
edad del individuo en años, meses y
días.
void main(){
int dia_n,mes_n,anno_n,dia_a,mes_a;
int anno_a,bisiesto,diam,edad_a;
int edad_m,edad_d;
cout<<"Hoy es (dd mm aaaa):";

cin>>dia_a>>mes_a>>anno_a;
cout<<"Nació el (dd mm aaaa):";
cin>>dia_n>>mes_n>>anno_n;
if(mes_a>=mes_n){
if(dia_a>=dia_n){
edad_a=anno_a-anno_n;
edad_m=mes_a-mes_n;
edad_d=dia_a-dia_n;
}else{
edad_a=anno_a-anno_n;
edad_m=mes_a-mes_n;
if(anno_n%4==0){
bisiesto=1;
if(anno_n%100==0 &&
anno_n%400!=0)
bisiesto=0;
}
switch(mes_n) {
case 12:
diam=31; break;
case 11:
diam=30; break;
case 2 :
if(bisiesto) diam=29;
else diam=28;
break;
}
edad_d=dia_a+diam-dia_n;
}
}else{
if(dia_a>=dia_n){
edad_a=anno_a-anno_n-1;
edad_m=12+mes_a-mes_n;
edad_d=dia_a-dia_n;
}
else{
edad_a=anno_a-anno_n-1;
edad_m=12+mes_a-mes_n-1;
if(anno_a%4==0){
bisiesto=1;
if(anno_a%100==0 &&
anno_a%400!=0)
bisiesto=0;
}
switch(mes_a-1) {
case 12:
diam=31; break;
case 11:
diam=30; break;
case 2 :
if(bisiesto) diam=29;
else diam=28;
break;
}
edad_d=dia_a+diam-dia_n;
}
}
if (edad_a>=0 && edad_m>=0
&& edad_d>=0){
cout<<"Tiene "<<edad_a<<" años";
cout <<" y "<<edad_m<<" meses";
cout <<" y "<<edad_d<<" dias\n";
}
else
cout<<"Error en el ingreso\n";
}
Ejemplo 12 : Programa que imprime todos los números

de tres dígitos CDU, tales que si se
invierte el orden de sus cifras
aumentan en 297.

void main(){
int num,num_i,n;
for(num=100;num<=999;num++){
num_i=0;
n=num;
while(n>=10){
num_i=num_i*10+n%10;
n/=10;
}
num_i=num_i*10+n;
if(num_i-num==297)
cout << num <<"\t";
}
}
Ejemplo 13 : En una reunión hubo 820 apretones de

mano. Sabiendo que cada persona saluda
a otra sola una vez y a todas las
demás. Este programa determina cuantas
personas asistieron a la reunión.
void main(){
int s,i;
s=0;
i=0;
do
s+=++i;
while(s!=820);
cout<<"Asistieron:"<<i+1<<endl;
}
Ejemplo 14 : Programa que lee un numero entero y

luego lo imprime sin los dígitos
mayores a 5. Por ejemplo, si se ingresa
456712 se imprime 4512.
void main(){
long int n,n_ok=0;
int digito,factor=1;
do{
cout<<"Numero: ";
cin>>n;
}while(n>2147483647||n<0);
while (n>=10){
digito=n%10;
if (digito>=0 && digito<=5){
n_ok+=(digito*factor);
factor*=10;
}
n/=10;
}
if (n>=0 && n<=5)
n_ok+=(n*factor);
cout<<"El numero depurado es:”;
cout<<n_ok<<"\n";
}
Ejemplo 15 : En una cuenta de ahorros se deposita un

capital a una tasa de interés compuesto
por un tiempo de "n" años. Cada "x"
años se deposita un mismo monto de
dinero ”p” y cada "y" años se retira un
mismo monto de dinero “q”. Tanto el
deposito como el retiro se realizaran
al finalizar el año. Programa que
imprime el año y el capital acumulado
al final del año considerando el
deposito y/o retiro efectuado.
void main(){
int i,n,per_dep,per_ret;
float capital,tasa,deposito,retiro;
cout<<"Capital :";
cin>>capital;
cout<<"Tasa :";
cin>>tasa;
cout<<"Tiempo (annos):";
cin>>n;
cout<<"Deposito:";
cin>>deposito;
do{
cout<<"Periodo del deposito :";
cin>>per_dep;
}while(per_dep>n || per_dep<1);
cout<<"Retiro:";
cin>>retiro;
do{
cout<<"Periodo del retiro :";
cin>>per_ret;
}while(per_ret>n || per_ret<1);
cout<<"\n\nAnno\tCapital\n";
for(i=1;i<=n;i++){
capital+=capital*tasa;
if (i%per_dep==0)
capital+=deposito;
if (i%per_ret==0)
capital-=retiro;
cout<<i<<"\t"<<capital<<"\n";
}
}
Ejemplo 16 : Programa que imprime los números

capicúas comprendidos entre 0 y 1000.
Un numero es capicúa si al invertir sus
cifras sigue siendo el mismo numero.

Por ejemplo, 121 es capicúa porque al
invertir sus cifras sigue siendo 121.
void main(){
int num,num_i,n;
for(num=1;num<=1000;num++){
num_i=0;
n=num;
while(n>=10){
num_i=num_i*10+n%10;
n/=10;
}
num_i=num_i*10+n;
if(num_i==num) cout<<num<<"\t";
}
}
Ejemplo 17 : Programa que calcula el producto de dos

números enteros positivos mediante el
"algoritmo ruso del producto". El
algoritmo consiste en duplicar el
primer factor y tomar la parte entera
del cociente del segundo factor entre
2, si el segundo factor es impar se
acumula el primer factor donde se va
obtener el resultado. El proceso
termina cuando el segundo factor se
hace CERO. por ejemplo para multiplicar
30 por 12:
primer segundo acumulador

factor factor
30 12 0
60 6 0
120 3 120
240 1 360
480 0 360
void main(){
int f1,f2,producto=0;
cout << "Ingrese dos numeros: ";

cin >> f1 >> f2;
while(f2){
if(f2 % 2) producto+=f1;
f1*=2;
f2/=2;
}
cout << "Producto=" << producto<<endl;
}

Ejemplo 18 : Programa que visualiza el cuadrado
mágico de orden impar n, comprendido
entre 3 y 17. Un cuadrado mágico se
compone de números enteros comprendidos
entre 1 y n2. La suma de los números
que figura en cada línea, cada columna
y cada diagonal son idénticas.
Regla de construcción:
• El número 1 se coloca en la casilla central
de la primera fila.
• Cada número siguiente se coloca en la fila
anterior y columna siguiente.
• Después de ubicar un número múltiplo de “N”
no se aplica la regla anterior, sino se
coloca en la fila siguiente y misma
columna.
• Se considera que la fila anterior a la
primera es la ultima, y la columna
posterior a la ultima es la primera.
17 24 1 8 15
23 5 7 14 16
4 6 13 20 22
10 12 19 21 3
11 18 25 2 9
void main(){
int i,n,x,y;
do{
cout<<"Dimensión impar y <=17:";
cin>>n;
} while(n % 2==0 || n>17 || n<0);
clrscr();
i=0;
x=n / 2+1;
y=1;
while(i<n*n){
i++;
gotoxy(5*x,y);
cout<<i;
if(i % n){
if(y==1) y=n;
else y--;
if(x==n) x=1;
else x++;
} else y++;
if(x>n) x=1;
if(y<1) y=n;
}
}

Ejemplo 19 : Programa donde se ingresan los tres
lados de un triángulo y determina el
tipo de triángulo.
#include <math.h>
#define ERROR 0.1
void main(){
float a,b,c,p;
cout <<"Ingrese los lados: ";

cin >> a >> b >> c;
if(a<b+c && b<a+c && c<a+b){
cout << "El triángulo es ";
if(a==b && b==c)
cout << "equilátero";
else {
if (a==b || a==c || b==c)
cout<<"isósceles";
else cout<<"escaleno";
if(abs(a*a-(b*b+c*c))<=ERROR||
abs(b*b-(a*a+c*c))<=ERROR||
abs(c*c-(a*a+b*b))<=ERROR)
cout<<" y rectángulo \n";
else cout<<"\n";
}
}
else {
cout<< "No forman un triángulo";
}
cout<<endl;
}

CAPITULO SIETE
SUBPROGRAMAS
7.1. SUBPROGRAMAS O SUBRUTINAS

Un subprograma es un conjunto de sentencias cuya
ejecución se invoca mediante su nombre. En la mayoría
de los lenguajes de programación se dividen en:
procedimientos y funciones, pero en el lenguaje C++
sólo esta permitido las funciones. Al conjunto de
subprogramas que vienen definidos en las librerías del
compilador, se les conoce como subprogramas del
sistema. Los programadores pueden crear sus propios
subprogramas según sean sus necesidades, a estos se
les conoce como subprogramas definidos por el usuario.
Este capitulo, trata principalmente sobre las técnicas
utilizadas en la construcción de funciones y sobre las
funciones definidas por el usuario.
7.2. ¿CUÁNDO UTILIZAR UN SUBPROGRAMA?

Existen dos razones importantes porque se deben
utilizar estas funciones, ellas son:
a) En un programa, una parte del mismo se

repite varias veces o varias partes
tienen sentencias muy similares. Si este
es el caso las partes repetidas o
similares se reemplazan por una llamada
al subprograma y se crea un subprograma
con las sentencias repetidas o similares.
b) En un programa, una parte se encarga de

un trabajo específico. Esto se consigue
aplicando las técnicas Diseño descendente
y programación modular, que se tratan más
adelante.
7.3. DISEÑO DESCENDENTE (TOP DOWN)
Problema
Subproblema 1 Subproblema 2 Subproblema 3
Subproblema Subproblema
2.1 2.2
El diseño descendente, también es conocido como diseño

TOP DOWN, consiste en dividir un problema1 en
subproblemas y estos en otros subproblemas que sean
fáciles de solucionar. Una vez resuelto cada parte se
integran para obtener la solución de todo el problema.
En este método se analiza de las características
generales a características específicas
(descomposición jerárquica). A cada nivel o paso de
refinamiento se le conoce como stepwise. El diseño
descendente es utilizado en la solución de problemas
de gran complejidad.
Para descomponer el problema, para cada subprograma se

debe contestar: ¿Qué hace? y ¿Cómo lo hace?. Los
niveles de descomposición dependen de la complejidad
del problema. Se recomienda parar la descomposición
cuando el subproblema se refiere a la solución de algo
específico o es fácil de solucionar, el programador
conforme se va familiarizando con el problema
encontrará la descomposición óptima.
7.3.1. EJEMPLO
Elaborar el diseño descendente para calcular
el sueldo a pagar a un trabajador de la
Empresa "Horizonte", si el trabajador percibe
las siguientes bonificaciones:
1
En este caso la solución del problema será mediante la elaboración del problema.
a) Por cada hora extra se le paga 25% más
que una hora normal.
b) Bonificación por movilidad (movil) igual

a 1000.
c) Bonificación suplementaria (b_sup) igual

al 3% del sueldo básico (sueldo).
d) La bonificación total (bonif) es la suma

de todas las bonificaciones que percibe.
Asimismo, el trabajador esta sujeto a los

siguientes descuentos:
e) Las tardanzas y faltas se descuentan con

respecto a remuneración computable. La
remuneración computable es igual al
sueldo básico más la suma de todas las
bonificaciones excepto la bonificación
por horas extras.
f) El total de descuentos (descuentos) se

obtiene sumando todos los descuentos.
ALGORITMO GENERAL
I. Ingreso de datos
II. Cálculo el sueldo a pagar
III. Imprime boleta de pago.
PRIMER REFINAMIENTO
I. Ingreso de datos
I.1. Ingreso del nombre del

trabajador (nombre) y sueldo
básico (sueldo).
I.2. Ingreso de días de faltas

(dias_falta) y minutos de
tardanzas (minutos).
I.3. Ingreso de horas extras

(h_extras).
II. Cálculo el sueldo a pagar
II.1. Cálculo de bonificaciones

(bonif)
II.2. Cálculo de descuentos
(descuentos)
II.3. s_neto=sueldo+bonif+descuentos
III. Imprimir boleta de pago.
SEGUNDO REFINAMIENTO
II.1. CALCULO DE BONIFICACIONES:
II.1.1. Pago por horas extras

(p_h_extras):
1.25*h_extras*sueldo/30/8
Para incrementar 25% a X, es

suficiente multiplicar a la
cantidad por 1.25 porque
100% de X + 25% de X es 125%
de X que a su vez es igual a
1.25*X.
El pago por una hora normal

es igual al resultado de
sueldo/30/8, donde sueldo es
el sueldo básico. Note que
el sueldo básico corresponde
al mes y esta dividido entre
30 días que tiene el mes y
este resultado es dividido
entre 8 que es la cantidad
de horas que se trabaja
durante un día.
II.1.2. movil=10000
II.1.3. b_sup=0.03*sueldo
II.1.4. bonif=movil+b_sup+p_h_extras
II.1.5. Remuneración computable

(r_computable):
sueldo+movil+b_sup
II.2. CALCULO DE DESCUENTOS:
II.2.1. r_minima=sueldo+bonif

II.2.2. faltas=r_computable/30*
dias_falta.
Para obtener el descuento

por falta: la remuneración
computable se divide entre
la cantidad de días que
tiene el mes, note que el
mes comercial tiene 30 días.
II.2.3. tardanzas=r_computable/
30/8/60*minutos. Para
obtener el descuento por la
tardanza: la remuneración
computable se divide
secuencialmente entre la
cantidad de días que tiene
el mes, entre la cantidad de
horas trabajadas por día y
entre la cantidad de minutos
que tiene una hora.
II.2.4. descuentos=faltas+tardanzas
Aquí paramos la descomposición del problema.
7.4. PROGRAMACIÓN MODULAR

La programación modular se toma muchas veces como
complemento del diseño descendente. La programación
modular consiste en dividir un programa en módulos
independientes, buscando un sólo punto de entrada y
uno de salida. Como complemento del diseño descendente
proporciona módulos funcionales (todos los elementos
contribuyen a una sola tarea) y están organizados en
niveles de jerarquía.
7.4.1. MODULO
Es una parte de un programa (subprograma) que
cumple con una función especifica, para un
usuario un modulo debe ser como una caja
negra donde ingrese datos y obtiene
resultados, sin importarle cuales fueron las
tareas que hizo el módulo para lograr su
propósito.

Un módulo en el Lenguaje de Programación
Pascal o en Foxpro puede ser un procedimiento
o una función y en Lenguaje C++ es una
función. En resumen, un módulo puede ser un
subprograma.
7.4.2. CRITERIOS A CONSIDERAR EN PROGRAMACIÓN

MODULAR
a) Debe tener una sola entrada y una sola

salida.
b) Debe realizar un trabajo específico.
c) Debe tener la máxima independencia y la

máxima cohesión (todo lo suficiente para
realizar su trabajo).
d) Debe estar separados las funciones de

entrada y/o salida de las de cálculo.
7.4.3. FASES DE LA PROGRAMACIÓN MODULAR
a) Dividir el problema utilizando el diseño

descendente (TOP-DOWN).
b) Analizar los parámetros a ser enviados y

ha ser devueltos.
c) Diseñar el módulo.
d) Montaje en el sistema en forma ascendente

(BOTTOM-UP).
7.5. DEFINICIÓN DE FUNCIONES
Se compone de la cabecera de la función (prototipo de
una función) seguido por el cuerpo de la función. Cuyo
formato es:
<Tipo> Nombre_f (t1 p1, t2 p2,…,tk pk)

{
<cuerpo de la función>
}
Donde:
<tipo> Es el tipo de valor que ha de

devolver la función. Si la

función no retorna ningún valor
entonces el tipo es void.
Nombre_f Es el nombre de la función.
t1, t2, …, tk Son los tipos de datos de los

parámetros.
p1, p2, .., pk Son los parámetros. Un

parámetro es una variable
utilizado para enviar y/o
recibir datos.
Si la función devuelve un valor debe utilizarse la

sentencia return cuyo formato es:
return (expresión)
return puede situarse en cualquier punto del cuerpo de

la función y provoca la salida inmediata de la función
retornando el valor evaluado en la expresión. Si se
omite la expresión, return retorna a la función que lo
llamo y no devuelve ningún valor.
7.5.1. DECLARACIÓN DE PROTOTIPOS

El prototipo de una función tiene por
finalidad indicar al compilador el tipo de
valor que devuelve, así como el número y tipo
de sus parámetros. En C++ por cada función
definida por el usuario es necesario declarar
su prototipo. Uno de sus formatos es:
<Tipo> Nombre_f (t1 p1, t2 p2,…,tk pk);
o
<Tipo> Nombre_f (t1,t2,…,tk);
Donde:
<tipo> Es el tipo de valor que

ha de devolver la
función. Si la función
no retorna ningún valor
entonces el tipo es
void.
Nombre_f Es el nombre de la
función.

t1, t2, …, tk Son los tipos de datos
de los parámetros.
p1, p2, .., pk Son los parámetros.
OBSERVACIONES:
a) Si en la definición o el prototipo de una

función se omite el tipo de dato que
retorna entonces por defecto el
compilador asume el tipo int.
b) Si la función no retorna un valor se

define como tipo retornado al tipo void y
la función no necesita usar la sentencia
return.
c) Si no se usa la sentencia return la

función se ejecuta todo el cuerpo de la
función y retorna a la siguiente línea de
donde fue llamado.
7.5.2. LLAMADA A UNA FUNCIÓN:

En cualquier lugar del programa se puede
llamar a la función, incluso puede llamarse a
si mismo. Para llamar a una función se
utiliza el siguiente formato:
Nombre_f(E1, E2,…, Ek)
Donde:
E1, E2, …,Ek Son expresiones que

proporcionan los valores a los
parámetros, en el orden
indicado.
La lista de parámetros debe estar de acuerdo

al tipo y cantidad de parámetros definidos en
la función. El primer parámetro de la lista
corresponde al primer parámetro de la
definición, el segundo parámetro de la lista
al segundo parámetro de la definición, así
sucesivamente.
Ejemplo 1 : Programa que imprime los números primos

que existen desde 1 hasta 100.

//declaracion de prototipos
primo(int n);
void main(){
//función principal
int n;
for(n=1;n<=100;n++)
if (primo(n)) cout<<n<<" es primo \n";
}
primo(int n){
int r,d=2,flag=1/*se supone que es primo*/;
if (n==1) return 1;
if (n==2) return 1;
while (1){
r=n%d;//halla el resto de n entre d
if(r==0){
flag=0;
break;
}
if ((n-1)==d) break;
d++;
}
if (flag) return 1;
else return 0;
}
Ejemplo 2 : Programa que utiliza a la función

hipotenusa para calcular la hipotenusa
de un triángulo rectángulo si se
proporcionan como parámetros los
catetos.
#include <math.h>
float hipotenusa(float ,float );
void main(){
float x,y,h;
cout<<"ingrese los 2 catetos ";cin>>x>>y;

h= hipotenusa(x,y);
cout<<"hipotenusa= "<<h<<endl;
}
float hipotenusa(float a,float b){

float hi;
hi=sqrt(a*a+b*b);
return (hi);
}

7.5.3. PARÁMETROS POR VALOR
Hasta al momento solo se han utilizado
parámetros por valor. Se dice que los
parámetros son pasados por valor si estos son
usados para suministrar datos de entrada.
Esto significa que los cambios que se hacen a
las variables utilizadas como parámetros que
son pasados por valor solo pueden cambiar su
valor momentáneamente dentro de la función y
a la salida de la función recuperan su valor
de entrada. Cuando un parámetro es pasado por
valor la función copia su valor y lo utiliza
dentro de la función.
Un parámetro pasado por valor puede ser una

constante, una expresión, una llamada a una
función o una variable.
7.5.4. PARÁMETROS POR REFERENCIA

Se dice que los parámetros son pasados por
referencia si estos se utilizan para
suministrar datos de entrada y/o salida
indistintamente. Esto significa que la
función puede alterar el valor de entrada de
las variables que son pasados por referencia.
Por lo tanto, si la función debe modificar el
valor de la variable pasada como parámetro y
que esta modificación retorne a la función
llamadora, entonces el parámetro debe ser
pasado por referencia.
En este método, el compilador no pasa una

copia del valor del argumento; en su lugar,
pasa una referencia, que indica a la función
donde existe la variable en memoria. La
referencia que una función recibe es la
dirección de la variable. Es decir, pasar un
argumento o parámetro por referencia es,
simplemente, indicarle al compilador que “que
pase la dirección del argumento”.
Una referencia se indica por el operador de

dirección &.
Un parámetro pasado por referencia siempre

tiene que ser una variable.

Ejemplo : El siguiente programa intenta cambiar
el valor de dos números si el primero
es mayor que el segundo, pero fracasa
porque el parámetro pasado es por
valor.
void intercambiar(int x,int y);
void main(){
int x,y;
cout<<"ingrese 2 números: ";cin>>x>>y;

if (x>y) intercambiar(x,y);
cout<<" x= "<<x<<" y= "<<y<<endl;
}
void intercambiar(int a,int b){

int aux;
aux=a; a=b; b=aux;
}
La corrida del programa es:
ingrese 2 números: 5 3↵
x= 5 y= 3
El siguiente programa si logra

intercambiar los valores de las dos
variables. Observe su implementación de
la función intercambiar.
void intercambiar(int &x,int &y);
void main(){
int x,y;
cout<<"ingrese 2 nùmeros ";cin>>x>>y;

if (x>y) intercambiar(x,y);
cout<<" x= "<<x<<" y= "<<y<<endl;
}
void intercambiar(int &a,int &b){

int aux;
aux=a; a=b; b=aux;

}
La corrida del programa es:
ingrese 2 números: 5 3↵
x= 3 y= 5

7.5.5. ÁMBITO DE UNA VARIABLE
El ámbito de una variable son los lugares
donde una variable es conocida. En C++ el
ámbito esta definido por los bloques y la
ubicación de las declaraciones.
Ejemplo : Programa que permite sumar los n

números ingresados.
void main(){
int n;
cout<<”Nro de elementos : “;
cin>>n;
if (n>0){
int i,num,s=0;
for(i=1;i<=n;i++){
cout<<”Elemento “<<i<<”: “;
cin>>num;
s+=num;
}
cout<<"La suma es :"<<s<<endl;
}
else cout<<"Error: Sin ingresos";
}
En el programa se ha definido una variable

"n" de tipo int, que puede ser utilizada por
cualquier bloque de la función main(), pero
en el siguiente bloque:
if (n>0){
int i,num,s=0;
for(i=1;i<=n;i++){
cout<<”Elemento<<i<<”: “;
cin>>num;
s+=num;
}
cout<<"La suma es :"<<s;
}
else cout<<"Error: Sin ingresos";
se ha definido tres variables: i, num y s;

que sólo pueden ser usadas dentro de este
bloque. En conclusión el ámbito de "n" es
toda la función main(), el ámbito de i, num y
s es sólo el bloque de la sentencia if.

7.5.6. VARIABLES LOCALES
Se dice que un variable es local cuando sólo
es conocido en un bloque determinado. Un
bloque comienza con { y termina con }.
7.5.7. PÁRAMETROS FORMALES Y REALES

Los parámetros formales son variables locales
usadas para definir de la función; por
ejemplo: en la función máximo los parámetros
formales son las variables a, b y c.
int maximo(int a,int b,int c);
void main(){
int n1,n2,n3;
cout<<"Ingrese tres números:";

cin>>n1>>n2>>n3;
cout<<"Máximo : " << maximo(n1,n2,n3);
}
int maximo(int a,int b,int c)

{
int max;
if(a>b) max=a;
else max=b;
if(c>max) max=c;
return max;
}
Los parámetros reales son los datos que son

enviados a la función y son utilizados en la
llamada a la función; por ejemplo: en la
llamada a la función máximo los parámetros
reales son n1, n2 y n3.
Los parámetros reales tienen que coincidir

con el número y el tipo de los parámetros
formales, correspondiendo el primer parámetro
real al primer parámetro formal, el segundo
parámetro real al segundo parámetro formal,
así sucesivamente.
7.5.8. VARIABLES GLOBALES

Se dice que una variable es global cuando es
conocido en más de dos funciones. Es
recomendable minimizar el uso de variables
globales porque accidentalmente puede ser
modificado por una función produciendo
resultados inesperados.
Ejemplo : El programa solicita un ángulo en

grados sexagesimales en forma
decimal, luego llama a la función
radian() que convierte el ángulo a
radianes y llama a la función
sexag() que convierte la forma
decimal del ángulo a grados,
minutos y segundos sexagesimales.
Función radian()
Para la conversion se utiliza la

siguiente relacion:
radianes=sexagesimales*(3.1416/180)
Función sexag()
Se separa la parte entera y la parte

fraccionaria del ángulo que esta forma
decimal.
La parte entera corresponde a los

grados.
Multiplicando la parte fraccionaria del

ángulo por 60. Y separando en parte
entera y fraccionaria de este producto,
la parte entera corresponde a los
minutos.
Los segundos se obtienen multiplicando

la parte fraccionaria obtenida en paso
anterior por 60.
Para el angulo 48.789 en sexagesimales:
Separando el ángulo, parte entera 48 y

parte fraccionaria 0.789.
Grados=48

Multiplicando la parte fraccionaria por
60: 0.789*60=47.34; separando el
resultado en parte entera (47) y parte
fraccionaria (0.34).
Minutos=47
Multiplicando la parte fraccionaria

(0.34) por 60: 0.34*60=20.4
Segundos=20.4
Por lo tanto 48.789 es igual a 48º 47'

20.4"
#include <math.h>
void sexag(void);
void radian(void);
// Variable global
float angulo;
void main(){
// Variables locales a main()
char resp;
do{
cout<<"Angulo (en sexagesimales): ";
cin>>angulo;
radian();
sexag();
cout<<"¿Continuar? (S/N)\n";
cin>>resp;
}while(resp!='N' && resp!='n');
}
void radian(void)
{
// Variable local a radian()
float rad;
rad=3.1416/180*angulo;
cout<<"En radianes es:”<<rad<<”\n”;
}
void sexag(void)
{
// Variables locales a sexag()
double frac,grad,min,seg;
frac=modf(angulo,&grad);
frac=modf(frac*60,&min);
seg=frac*60;
cout<<”Tambien en Sexageximal es:\n”;
cout<<”Grados :”<<grad<<”\n”;
cout<<”Minutos :”<<min<<”\n”;

cout<<”Segundos:”<<seg<<”\n”;
}
Ejemplo 1 : Programa que halla la hipotenusa de un

triángulo.
#include <math.h>
void hipotenusa(float a,float b,float &hi);
main(){
float x,y,h;
cout<<"ingrese los 2 catetos ";cin>>x>>y;

hipotenusa(x,y,h);
cout<<" hipotenusa= "<<h<<endl;
}
// a y b son parámetros pasados por valor

// y hi es pasado por referencia
void hipotenusa(float a,float b,float &hi)

{
hi=sqrt(a*a+b*b);
}
Ejemplo 2 : La función distancia() calcula la

distancia de dos puntos cuyas
coordenadas son (x1,y1) y (x2,y2). La
distancia es igual a:
( x1 − x 2 )2 + ( x1 − x 2 )2
#include <math.h>
double distancia(double,double,double,double);
main(){
double a1,a2,b1,b2;
cout<<“Coordenadas del primer punto :”;

cin>>a1>>b1;
cout<<”Coordenadas del segundo punto :”;
cin>>a2>>b2;
cout<<”La distancia es: “;
cout<<distancia(a1,b1,a2,b2)<<endl;
}
double distancia(double x1, double y1,
double x2, double y2){
double x;
x=sqrt(pow(x1-x2,2)+pow(y1-y2,2));
return(x);
}
Ejemplo 3 : Programa que llama a la función
raiz_cub e imprime la raíz cúbica de
los números del 1 al 10. La función
raiz_cub() calcula la raíz cúbica de un
número entero y a esta a su vez llama a
la función abs que se encarga de
devolver el valor absoluto de un número
de tipo double.
Algoritmo Newton-Raphson para calcular

la raíz cubica de n:
Hacer x=n/10
Mientras valor_absoluto(x*x*x-n)>0.0001 hacer
n − x3
x = x+
3x 2
x es el valor de la raíz cúbica de "n"
double raiz_cub(double);
double abs(double);
#include<iostream.h>
#include<math.h>
double abs(double);
/* Función Principal */
void main(){
double i;
cout<<”NUMERO\t\tR.CUBICA\n”;
for(i=1;i<=10;i++)
cout<<i<<”\t\t”<<raiz_cub(i)<<”\n”;
}
double raiz_cub(double n){

double x;
x=n/10.0;
while(abs(x*x*x-n)>0.0001)
x=x+(n-x*x*x)/(3.0*x*x);
return x;
}
double abs(double n){

if (n>=0) return n;
else return -n;
}
Ejemplo 4 : Programa que permita verificar si una

fecha (dd/mm/aaaa) es correcta
#include <stdio.h>
int bisiesto(int);
int fechaok(int,int,int);
void main(){
int aa,mm,dd;
do{
printf("Fecha (dd/mm/aaaa)");
scanf("%d/%d/%d",&dd,&mm,&aa);
}while(fechaok(dd,mm,aa)!=0);
printf("Error Fecha: %d/%d/%d\n",dd,mm,aa);
}
int bisiesto(int anno)

{
int si=0;
if(anno % 4==0){
si=1;
if(anno%100==0&&anno%400!=400) si=0;
}
return si;
}
int fechaok(int dia,int mes,int anno)

{ int ok=0;
switch(mes){
case 12:if(dia>=1&&dia<=31) ok=1;
break;
case 11:if(dia>=1&&dia<=30) ok=1;
break;
case 2: if(bisiesto(anno)==1)
else if(dia>=1&&dia<=28)
ok=1;
break;
}
return(ok);
}
Ejemplo 5 : Programa que lee tres números y los

ordena ascendentemente.
void cambiar(int &a,int &b);

void main(){
int n1,n2,n3;
cout<<"Ingrese tres números :";

cin>>n1>>n2>>n3;
if(n1>n2) cambiar(n1,n2);
cout<<”Ordenados:”<<n1<<”\t”<<n2<<”\t”<<n3;
cout<<endl;
}
void cambiar(int &a,int &b){

int t;
t=a;

a=b;
b=t;
}
Ejemplo 6 : Programa que lee un número en base de 2

al 9 y lo convierte a otra base de 2 al
9.
#include <stdio.h>
long cnto10(long numero,int base);

long c10ton(long numero,int base);
long ingbasen(int base);
long cxtoy(long numero,int base1,int base2);
void main(){
long n;
int b1,b2;
printf("Base origen : ");

scanf(“%d”,b1);
cout<<"Base destino : ";
scanf(“%d”,b2);
n=ingbasen(b1);
if(n){
n=cxtoy(n,b1,b2);
printf("Numero convertido %d\n",n);
}
}
long ingbasen(int base){

long n;
char c,car;
if (base>=2 && base<=10){

car=48+base;
n=0;
printf("Numero en base %d :",base);
do{
do
c=getch();
while((c<'0' || c>=car)&&c!='\r');
//printf(“%c”,c);
if(c!='\r') n=n*10+c-48;
}while(c!='\r');
printf("\n");
return n;
}
else{
printf(”Base mayor que 9 o base “);
printf(”menor que 2 no esta permitido");
return 0;
}
}
long cnto10(long numero,int base){

long n=0,factor=1,res;

while(numero>=10){
res=numero % 10;
numero/=10;
n+=(res*factor);
factor*=base;
}
n+=(numero*factor);
return n;
}
long c10ton(long numero,int base){

long n=0,factor=1,res;
while(numero>=base){
res=numero % base;
numero/=base;
n+=(res*factor);
factor*=10;
}
n+=(numero*factor);
return n;
}
long cxtoy(long numero,int base1,int base2){

numero=cnto10(numero,base1);
numero=c10ton(numero,base2);
return numero;
}
7.7. FUNCIONES DEL SISTEMA

Las funciones proporcionadas por las librerías del
lenguaje C++ utilizan los archivos de cabecera
(archivos con extensión H) el cual es insertado al
programa con la directiva #include.
7.7.1. UTILIZACION DE LA DIRECTIVA #include

Esta directiva hace que le compilador incluya
el archivo cabecera en el código fuente del
programa, su extensión es h (de header,
cabecera en inglés). Cuyo formatos son:
#include <ruta\nomfich.h>. Hace que el

archivo cabecera sea buscado sólo ruta
indicada, si lo encuentra lo inserta, caso
contrario genera un mensaje de error.
#include <nomfich.h>.- Hace que el archivo

cabecera sea buscado en los directorio
especificado para los archivos cabeceras,
generalmente es el directorio es llamado
include. Si lo encuentra inserta; caso
contrario genera un mensaje de error.
#include "ruta\nomfich.h".- Hace que el

archivo cabecera sea buscado
secuencialamente en: la ruta especificada,
en el directorio activo, en el directorio
especificado para las cabeceras. El
archivo cabecera que es encontrado primero
es insertado y finaliza la búsqueda, sino
lo encuentra en ninguno de los directorios
genera un mensaje de error.
Para llamar a una función de la librería del

c++ es necesario utilizar la directiva
#include con el nombre del archivo de la
cabecera que le corresponde. Para las
funciones matemáticas se usa #include
<math.h>, para las funciones de cadena se usa
#include <string.h>, etc. Para mayor
información recurra al manual del lenguaje de
programación.

CAPITULO OCHO
ESTRUCTURA DE DATOS: ARREGLOS
En los capítulos anteriores se ha definido y utilizado los

tipos de datos fundamentales con los cuales se podía manejar
datos enteros, de punto flotante o carácter. Imagínese ahora
la necesidad de obtener el promedio de la temperatura
ambiente de esta semana en la ciudad. Si usamos tipos de
datos fundamentales necesitamos por lo menos definir 7
variables; pero si la necesidad es conocer el promedio de la
temperatura ambiente de todo el mes, tendríamos que definir
por lo menos 30 variables. Ampliando la situación anterior
supongamos el caso en que se necesite conocer el promedio de
la temperatura ambiente durante 5 años (aproximadamente 1825
días), y de acuerdo al razonamiento anterior, tendríamos que
utilizar una variable por día para lo cual se necesita
definir 1825 variables. Ampliando su imaginación suponga que
usted comienza con la definición de las variables dentro de
su programa, utilizará demasiado tiempo en definir y escribir
y utilizar sus variables; por supuesto esto es inadmisible.
La estructura de datos arreglo solucionaría el caso
anterior.
Un arreglo (array) es una colección de variables del mismo

tipo. Usted puede trabajar con un arreglo de enteros, un
arreglo con valores de punto flotante, o un arreglo de
caracteres.

8.1. ARREGLOS UNIDIMENSIONALES: VECTORES
Un arreglo unidimensional, o simplemente un arreglo,
de N variables de algún tipo de dato se declara en la
forma:
Tipo_de_dato identificador[N];
Donde:
Tipo_de_dato : Es el tipo de dato usado en el arreglo.
Identificador: Es el nombre del arreglo.
N : Es el tamaño del arreglo o la cantidad

de elementos(variables) que se
utilizará en el arreglo.
Ejemplo:
int A[100]
El arreglo A consiste de la colección de variables

A[0],…A[99] de tipo int, que son referidas por el
nombre del arreglo y el correspondiente subíndice
entre corchetes. 100 es la dimensión del arreglo –
cantidad de elementos- y debe ser un entero positivo
constante. El arreglo A se puede representar:
A[0] A[1] A[2] A[3] ... A[96] A[97] A[98] A[99]
Los arreglos en C++ comienzan con el índice cero,

siendo el último índice unidad menor al tamaño del
arreglo (N-1).

Indicaciones sobre arreglos:
Los datos de las variables componentes A[0],..,

A[99], se almacenan unos a continuación de otros.
Para acceder a un elemento del arreglo utilizar el

siguiente formato
Identificador [indíce del arreglo]
Ejemplo:
En el arreglo A, para almacenar el valor 5 en el

índice 3 usar:
A[3]=5;
Para escribir el valor almacenado anteriormente

usar:
cout<<A[3];
El nombre del arreglo es igual a la dirección de la

primera variable del arreglo A[0]. Así A tiene el
valor &A[0].
La dirección de cada componente A[i], dada por &A[i],

también puede ser expresada por A+i

Ejemplo 1 : Programa que lee e imprime el contenido
de un vector.
#define N 5 // N es la cantidad de elementos

// del arreglo
void main()
{ int A[N]; // definimos el arreglo A
//de enteros para 5 elementos
int i; //índice del arreglo
//lectura del vector

for(i=0;i<N;i++)
{ cout<<"Ingrese elemento : "; cin>>A[i]; }
//imprime el vector
cout<<"El contenido del arreglo es :\n";
for(i=0;i<N;i++)
cout<<A[i]<<"\n";
}
Explicación:
Para la lectura del vector se debe recorrer

cada una de las celdas por lo cual se hace una
referencia a cada celda a través de sus índices
(se usa la variable i), que toman valores de 0
a 4 a través de la sentencia for. Para la
impresión de los elementos se debe recorrer
también cada una de las celdas en forma similar
a la lectura.
Ejemplo 2 : Programa que lee el contenido de un

arreglo e imprime el promedio de sus
elementos.
#define N 5 //N es la cantidad de elementos
//del arreglo
void main()
{ int A[N]; // definimos el arreglo A de
// enteros para 5 elementos
int i; //índice del arreglo
float prom;int s=0;
// lee el vector y a la vez calcula
// la suma de los elementos
for(i=0;i<N;i++)
{ cout<<"Ingrese elemento : "; cin>>A[i];
s=s+A[i]; // s acumula la suma de
// los elementos

}
// calcula e imprime promedio

prom=1.0*s/N; // multiplicar por 1.0 para
//obtener la división como
//punto flotante
cout<<"El promedio del vector es : "<<prom;
cout<<endl;
}
Explicación:
En la lectura del vector se agrega el

acumulador s para guardar la suma de los
elementos del arreglo.
Para hallar el promedio se divide la suma
acumulada en s entre la constante N; pero se
debe multiplicar por 1.0 para obtener una
división en punto flotante.

arreglo y determina el mayor y el menor
elemento y cuantas veces se repiten
ambos.
#define N 10 // N es la cantidad de elementos
// del arreglo
void leer_vector(int V[N]);

void hallar_mayor_y_menor(int V[N], int
&may,int &men);
int existe(int V[N], int valor);
void main()
{ int A[N];// definimos el arreglo A de enteros
// para 10 elementos
int ma,me; // ma es el mayor elemento
// me es el menor elemento
leer_vector(A);
hallar_mayor_y_menor(A,ma,me);
cout<<"El mayor elemento es "<<ma;
cout<<" y existe "<<existe(A,ma)<<" veces\n";
cout<<"El menor elemento es "<<me;
cout<<" y existe "<<existe(A,me)<<" veces\n";
}
void leer_vector(int V[N])

{ // lee el vector
int i; //indice del arreglo
for(i=0;i<N;i++)
{ cout<<"Ingrese elemento : "; cin>>V[i];}
}

// función que devuelve el mayor y el menor
// para numeros entre -10000 y 10000
void hallar_mayor_y_menor(int V[N], int
&may,int &men)
{ int i; //indice del arreglo
may=-10000; // inicializamos con un valor
// pequeño para el mayor
men= 10000; // inicializamos con un valor
// grande para el menor
for(i=0;i<N;i++)
{ if (may<V[i]) //si el mayor es menor que
//algún elemento
may=V[i]; // del arreglo se toma ese
//elemento como mayor
if (men>V[i]) //si el menor es mayor que

// algún elemento
men=V[i]; // del arreglo se toma ese
// elemento como menor
}
}// fin de la funcion hallar_mayor_y_menor
// función que calcula cuantas veces existe un

// valor en un vector
int existe(int V[N], int valor)
{ int i,veces=0;// veces almacena la cantidad
// de veces que existe
//el valor buscado
for(i=0;i<N;i++)
if (valor==V[i]) //si el valor es igual a
//algún elemento del
veces++; //arreglo se incrementa
// veces
return(veces);
}
Explicación:
Para determinar el mayor y menor elemento del

vector utilizamos las variables ma que contiene
al mayor elemento y me que contiene al menor
elemento.
En la función main() se realiza la lectura del
contenido del vector a través de la función
leer_vector(A), donde se envía la variable
arreglo A como un parámetro por referencia.
Para calcular el mayor y menor elemento usamos
la función hallar_mayor_y_menor(A, ma, me) que
envía el arreglo A y las variables enteras ma y
me, siendo estas dos últimas las que deben
obtener el mayor y menor elemento al retornar
del llamado a está función. Además se envía el
arreglo A y un valor a la función existe que
permitirá obtener cuantas veces se repite el
valor en el vector.
La función leer_vector(int V[N]), recepciona el

arreglo A a través de la variable arreglo V
como un parámetro por referencia, debe notarse
que no se necesita &, para tratar a V como un
parámetro por referencia; porque es un arreglo
y basta mencionar su nombre para tener la
dirección del primer elemento. La lectura de
los elementos se realiza en la instrucción for
para lo cual utilizamos el índice del arreglo i
definido como una variable local.
En la función void hallar_mayor_y_menor(int

V[N], int &may, int &men), la variable V
recepciona al arreglo A, la variable may recibe
a ma y men recibe a me como parámetros por
referencia por lo que debe de utilizarse el &.
En la función inicializamos may con –10000 para
que tenga un valor pequeño de tal forma que se
compare con los elementos del arreglo y si
algún valor es mayor que may se almacena este
valor en may. Al final del recorrido del
vector, may almacena al mayor elemento. De la
misma forma inicializamos men con 10000 para
que tenga un valor grande de tal forma que se
compare con los elementos del arreglo y si
algún valor es menor que men se almacena este
valor en men. Al final del recorrido del
vector, men almacena al menor elemento. Los
valores del mayor y menor se devuelven a través
de may y men que serán los mismos que ma y me
respectivamente porque han sido pasados como
referencia.
En la función int existe(int V[N], int valor),V

recibe al vector y la variable valor es el
valor buscado. Para encontrar cuantas veces
existe el valor buscado se compara la variable
valor con cada elemento del arreglo
incrementando el contador veces si son iguales.
Ejemplo 4 : Programa que permite ingresar los n

elementos de un arreglo unidimensional
sin que se repita ningún elemento. El
arreglo almacena datos enteros y de
dimensión MAX (definido como
constante).
#define MAX 20
int ingreso(int a[MAX]);
void reporte(int a[MAX],int n);
int repetido(int a[MAX],int n,int x);
void main(){
int x=0,vector[MAX];
x=ingreso(vector);
reporte(vector,x);
}

int ingreso(int a[MAX]){
int i,cant;
do{
cout<<"Cuantos elementos : ";
cin>>cant;
} while(cant<1 || cant>MAX);
for(i=0;cant>i;i++){
do{
cout<<"elemento "<<i<<":";
cin>>a[i];
}while(repetido(a,i,a[i]));
}
return cant;
}
int repetido(int a[MAX],int n,int x){

int i,sw=0;
for(i=0;n>i;i++)
if(a[i]==x){
sw=1;
break;
}
return sw;
}
void reporte(int a[MAX],int n){

int i;
if(n){
for(i=0;n>i;i++) cout<<a[i]<<" ";
cout<<"\n";
}
else cout<<"Esta Vacio\n";
}
8.2. ARREGLOS BIDIMENSIONALES: TABLAS /

MATRICES
Es un conjunto de elementos, todos del mismo tipo, y
se necesita especificar dos subíndices para poder
identificar a cada elemento del arreglo. La
representación de un arreglo bidimensional utiliza
filas y columnas como se ilustra en la siguiente
figura:
Representamos el arreglo bidimensional M que tiene 4

filas y 5 columnas.

Columna 0 ?
Columna 1 ?
Columna 2 ?
Columna 3 ?
Columna 4 ?
Fila 0 ? M[0][0] M[0][1] M[0][2] M[0][3] M[0][4]
Fila 1 ? M[1][0] M[1][1] M[1][2] M[1][3] M[1][4]
Fila 2 ? M[2][0] M[2][1] M[2][2] M[2][3] M[2][4]
Fila 3 ? M[3][0] M[3][1] M[3][2] M[3][3] M[3][4]
En las celdas del arreglo se muestra el uso de los

subíndices, donde el primer subíndice representa a la
fila y el segundo subíndice representa a la columna y
M es el nombre del arreglo.
Para acceder a un elemento del arreglo utilizar el

siguiente formato:
Identificador [fila][columna]
Ejemplo:
En el arreglo M, para almacenar el valor 5 en la

fila 2 y la columna 3 usar:
M[2][3]=5;
Para escribir el valor almacenado anteriormente

usar:
Cout<< M[2][3];
Para almacenar/recuperar los elementos de un arreglo

bidimensional tenemos dos formas:

Recorrido por filas:
M[0][0] M[0][1] M[0][2] M[0][3]
M[1][0] M[1][1] M[1][2] M[1][3]
Recorrido por columnas:
M[0][0] M[0][1] M[0][2] M[0][3]
M[1][0] M[1][1] M[1][2] M[1][3]
Ejemplo1 : Programa que lee e imprime el contenido

de un arreglo bidimensional.
#define NF 2 //cant. de filas
#define NC 3 //cant. de columnas
void leer(int m[NF][NC]);
void escribir(int m[NF][NC]);
void main()
{ int a[NF][NC];//arreglo bidimensional
leer(a);
escribir(a);
}
void leer(int m[NF][NC])

{ int f,c;
for(f=0;f<NF;f++)
for(c=0;c<NC;c++)
{ cout<<"ingrese elemento : ";
cin>>m[f][c];
}
}
void escribir(int m[NF][NC])

{ int f,c;
for(f=0;f<NF;f++)
{ for(c=0;c<NC;c++)
cout<<m[f][c]<<" ";
cout<<"\n";
}
}

Ejemplo 2 : Programa que almacena en un arreglo el
cuadrado latino de orden "N". Un
cuadrado latino de orden "N" es una
matriz cuadrada en que la primera fila
contiene los "N" primeros números
naturales y cada una de las siguientes
contiene la rotación de la fila
anterior un lugar a la derecha. A
continuación se muestra un cuadrado
latino de orden 4 (N = 4).
1 2 3 4
4 1 2 3
3 4 1 2
2 3 4 1
#define max 15 //cant. max de filas y columnas
void cuadrado_latino(int a[max][max],int n);
void escribir(int a[max][max], int n);
void main()
{ int a[max][max];//arreglo bidimensional para
//el cuadrado latino
int n;
cout<<"Ingrese orden : ";cin>>n;
cuadrado_latino(a,n);//almacena los valores
//del cuadrado latino
escribir(a,n);
}
void cuadrado_latino(int a[max][max],int n)

{ int f,c;//fila y columna respectivamente
int val=1;//valor a guardar en el arreglo
for(f=0;f<n;f++)
{ if (f>=1)
val=n-(f-1);//calcula el valor inicial de
//la columna cero
for(c=0;c<n;c++)
{ a[f][c]=val;
if (val==n)//si val es igual al grado n
//entonces val es cero
val=0;
val++; //incrementa val
}
}
}
void escribir(int a[max][max], int n)

{ int f,c;
for(f=0;f<n;f++)
{ for(c=0;c<n;c++)
cout<<a[f][c]<<" ";
cout<<"\n";
}
}

Ejemplo 3 : Programa que suma dos matrices.de 2x3.
#define NF 2 //cant. de filas
#define NC 3 //cant. de columnas
void leer(int m[NF][NC]);
void escribir(int m[NF][NC]);
void sumar(int x[NF][NC],int y[NF][NC],int
z[NF][NC]);
void main()
{ //arreglo bidimensionales
int a[NF][NC],b[NF][NC],s[NF][NC];
//lectura de las matrices
leer(a);leer(b);
//obtener suma en el arreglo s
sumar(a,b,s);
//Escribir el contenido de los arreglos
cout<<"\n Las matrices leidas son:\n";
escribir(a);escribir(b);
cout<<"\n La suma de las matrices es:\n";
escribir(s);
}
void leer(int m[NF][NC])

{ int f,c;
cout<<"\n ingrese elementos de la matriz:\n";
for(f=0;f<NF;f++)
for(c=0;c<NC;c++)
{ cout<<"ingrese elemento : ";
cin>>m[f][c];
}
}
void escribir(int m[NF][NC])

{ int f,c;
cout<< "\n Contenido de la matriz:\n";
for(f=0;f<NF;f++)
{ for(c=0;c<NC;c++)
cout<<m[f][c]<<" ";
cout<<"\n";
}
}
void sumar(int x[NF][NC],int y[NF][NC],int

z[NF][NC])
{ int f,c;
for(f=0;f<NF;f++)
for(c=0;c<NC;c++)
z[f][c]=x[f][c]+y[f][c];
}

CAPITULO NUEVE
REGISTROS
Frecuentemente en nuestras actividades diarias empleamos

datos que guardan alguna relación entre ellos, por ejemplo si
soy un vendedor y tengo la necesidad de ubicar a un cliente
determinado entre los tantos que pueda tener para ofrecerle
algún producto, me importaría determinar quién es mi cliente,
lo puedo hacer a través de su nombre, si le asigné un código
también podría identificarlo a través de este, para visitarlo
necesito su dirección y si deseo llamarlo pues necesito su
número telefónico; adicionalmente podría también tener otros
datos relativos a este cliente, como podría ser la fecha de
su cumpleaños para enviarle una tarjeta, etcétera. Al juntar
todos los datos de este cliente, pues se tiene un conjunto de
datos de este cliente, se ha registrado a este cliente. De
igual forma se puede registrar a otros clientes.
Un registro es una colección de datos o campos (código,

nombre, dirección, número telefónico, fecha de nacimiento,
etc.) acerca de una entidad (cliente), estos en conjunto
pueden ser tratados como una unidad de información. Cada dato
de un cliente (por ejemplo el nombre) es un campo.
Los registros en conjunto, uno por cada cliente hace una

tabla de datos de la entidad cliente. Si manejamos
adicionalmente tablas de datos acerca de los vendedores,
productos, etcétera, tenemos una Base de Datos.

9.1. REPRESENTACIÓN DE REGISTROS
En el C++ para representar los registros empleamos en
muchas ocasiones las estructuras y las uniones. La
estructura es básica para la representación de los
registros de una tabla de una base de datos y las
uniones en una celda de una hoja de cálculo.
Una estructura a diferencia de un array o arreglo

permite mantener datos de distintos tipos. Así para
mantener los registros acerca de los alumnos de una
clase donde queramos mantener su nombre, edad en años
y talla; es necesario un arreglo de caracteres para su
nombre, un dato tipo entero para su edad y un dato
tipo real para su talla.
char Nombre[20];
int Edad;
float talla;
Una unión permite almacenar diferentes tipos de datos

en una misma posición de memoria. Si por ejemplo
tenemos cierto componente electrónico que podamos
identificarlo a través de un número que tiene asignado
o a través de su color (para cada color existe un
equivalente numérico), entonces sería lo mismo
identificarlo por su color o por su equivalente
numérico (sería ilógico hacerlo por ambos); en
consecuencia se puede utilizar una unión para ello,
donde empleamos alternadamente el equivalente numérico
o su color, pero no ambos.
9.2. ESTRUCTURAS
La estructura es una unidad que agrupa a una o más
variables del mismo tipo o de tipos diferentes.
La sintaxis para crear una estructura es la siguiente
struct identificador{
tipo1 miembro1;
tipo2 miembro2;
.
.
tipoN miembroN;
};

Como se puede observar para definir una estructura
disponemos de la palabra reservada struct, y entre
llaves se definen todos los miembros de la estructura.
Para hacer referencia a un miembro de una estructura
se emplea el punto (.).
Ejemplo : Desarrolle un programa que permita

almacenar un registro en una
estructura, acerca de un alumno de una
clase donde se almacene el nombre, edad
en años y talla de este alumno. Luego
el programa debe mostrar los datos de
dicho alumno.
//Registra a un alumno empleando una
//estructura
#include<stdio.h>
struct estalumno{
char nombre[38];
int edad;
float talla;
};
void main()
{
struct estalumno alumno;
printf("Ingrese el nombre: ");

gets(alumno.nombre);
printf("\nIngrese la edad (años): ");
scanf("%d",&alumno.edad);
printf("\nIngrese la talla (metros): " );
scanf("%f",&alumno.talla);
printf("\n");
printf("El alumno %s tiene ", alumno.nombre);
printf(" %d años de edad ", alumno.edad);
printf(" y mide %5.2f metros\n",alumno.talla);
El lector debe advertir que a pesar de haber definido

la estructura, a la variable alumno se le asigna el
tipo estructura estalumno empleando la palabra struct,
así tenemos:
Si ingresamos los siguientes datos al programa:
Ingrese el nombre: Fidel Fernández

Ingrese la edad (años): 20
Ingrese la talla (metros): 1.78
La salida será:
El alumno Fidel Fernández tiene 20 años de edad y mide 1.78
metros.
Note que para ingresar la cadena empleamos la función

gets(). Esta función permite ingresar una cadena de
caracteres hasta que se ingrese el equivalente a nueva
línea (retorno de carro).
9.3. UNIONES
La unión en una misma posición de memoria de memoria
puede almacenar diferentes tipos de datos, pero en un
momento dado puede ser de un solo tipo, el tamaño de
la unión es el mismo que se tiene para el tipo de dato
mayor entre los diferentes tipos de la unión.
La sintaxis para crear una unión es la siguiente
union identificador{
tipo1 ide1;
tipo2 ide2;
.
.
tipoN ideN;
};
Como podemos observar, para definir la unión

disponemos de la palabra reservada union, y entre las
llaves se definen todos los tipos alternativos de la
unión.
Ejemplo : Desarrolle un programa que demuestre

que una unión puede manejar un solo
tipo de dato a la vez. Tome como base
para este programa el registro de un
componente electrónico que se puede
identificar a través de un número que
tiene asignado o a través de su color
(para cada color existe un equivalente
numérico), es lo mismo identificarlo

por su color o por su equivalente
numérico.
//Registra la identificación de un
//componente empleando una unión
#include<stdio.h>
union unicomp{
char color[20];
int numero;
};
main()
{
union unicomp componente;
printf("Ingrese color del componente: ");

gets(componente.color);
printf("\nColor del componente: %s",
componente.color);
printf("\nNúmero del componente: %d",
componente.numero);
printf("\n\nIngrese número del componente: ");

scanf("%d", &componente.numero);
printf("\nColor del componente: %s",
componente.color);
printf("\nNúmero del componente: %d\n",
componente.numero);
return 0;
}
La forma de definir una unión es similar a la de una

estructura. Si al programa ingresamos los siguiente
datos tenemos:
Ingrese color del componente: AZUL
Color del componente: AZUL

Número del componente: 23105
Ingrese número del componente: 560
Color del componente: 0 UL

Número del componente: 560
A la primera petición de ingreso acerca del color del

componente respondemos con la palabra AZUL, en este
caso tenemos la salida correcta para el color y en el
caso del número obtenemos un valor no predecible.
A la segunda petición de ingreso acerca del número del

componente respondemos con el número 560, ahora
tenemos la salida correcta para el número y en el caso
del color obtenemos un valor no predecible.
Esto es debido a que en un momento dado solo podemos
emplear uno de los tipos propuestos para esta
variable.
9.4. OPERACIONES CON ESTRUCTURAS
9.4.1. PASO DE ESTRUCTURAS A FUNCIONES

El paso de las estructuras lo podemos hacer
de 2 formas, por valor y por variable (o
referencia).
El paso de parámetros por valor se tiene en

la definición de la función la siguiente
forma:
nom_funcion(struct tipo_estru par_var);
donde nom_function es el nombre que le damos

a la función, struct es la palabra reservada
para las estructuras, tipo_estru es variable
tipo estructura que hemos creado y par_valor
es un parámetro que se pasa por valor.
Para llamar a la función se aplica:
nom_funcion(var_estru);
donde var_estru es la variable tipo

estructura que se pasa por valor.
Ejemplo : Desarrolle un programa que permita

almacenar un registro en una
estructura, acerca de un alumno de una
clase donde se almacene el nombre, edad
en años y talla de este alumno. Luego
el programa debe mostrar los datos de
dicho alumno empleando para ello una
función.
//Registra a un alumno empleando
//una estructura y la pasa a
//una función para su salida
#include<stdio.h>

struct estalumno{
char nombre[38];
int edad;
float talla;
};
void impr_alu(struct estalumno cual_alu);
void main()
{

gets(alumno.nombre);
scanf("%d",&alumno.edad);
printf("\nIngrese la talla (metros): ");
scanf("%f",&alumno.talla);
impr_alu(alumno);
}
void impr_alu (struct estalumno cual_alu)

{
printf("El alumno %s",cual_alu.nombre);
printf(" tiene %d",cual_alu.edad);
printf(" años de edad y ");
printf("mide %5.2f",cual_alu.talla);
printf(" metros\n");
}
Para el paso de parámetros por variable o
referencia se tiene en la definición de la
función la siguiente forma:
nom_funcion(struct tipo_estru &par_ref);
donde nom_function es el nombre que le damos

a la función, struct es la palabra reservada
para las estructuras, tipo_estru es variable
tipo estructura que hemos creado y par_ref es
un parámetro que se pasa por referencia.
Para llamar a la función se aplica:
nom_funcion(var_estru);
donde var_estru es la variable tipo

estructura que se pasa por valor.
Ejemplo : Modifique el ejemplo anterior de tal

manera que el almacenamiento del

registro se haga a través de una
función.
//Registra a un alumno empleando
//una estructura en una función
//y la pasa a otra función para su salida
#include<stdio.h>
struct estalumno{
char nombre[38];
int edad;
float talla;
};
void ingr_alu(struct estalumno &cual_alu);
void impr_alu(struct estalumno cual_alu);
void main()
{
ingr_alu(alumno);
printf("\n\n");
impr_alu(alumno);
}
void ingr_alu(struct estalumno &cual_alu)

{
gets(cual_alu.nombre);
scanf("%d",&cual_alu.edad);
printf("\nIngrese la talla (metros): ");
scanf("%f",&cual_alu.talla);
}
void impr_alu(struct estalumno cual_alu)

{
printf("El alumno %s",cual_alu.nombre);
printf(" tiene %d",cual_alu.edad);
printf(" años de edad y ");
printf("mide %5.2f",cual_alu.talla);
printf(" metros\n");
}
9.4.2. ANIDAMIENTO DE ESTRUCTURAS

El anidamiento de una estructura significa
que una estructura forma parte de otra
estructura.

Ejemplo : Defina un algoritmo que permita
registrar la fecha y hora de nacimiento
de una persona. Respecto a la fecha se
desea saber el día, mes y año de
nacimiento. Sobre la hora se desea
registrar la hora, los minutos y los
segundos.
//Almacena fecha y hora de nacimiento
//en una estructura anidada
#include<iostream.h>
struct estruFecha {
int dia;
int mes;
int anno;
};
struct estruTiempo {
int hora;
int minuto;
int segundo;
};
struct fechaTiempo{
struct estruFecha LaFecha;
struct estruTiempo ElTiempo;
};
main()
{
struct fechaTiempo Nacimiento;
cout<<"Ingrese dia de nacimiento: ";

cin>>Nacimiento.LaFecha.dia;
cout<<"Ingrese mes de nacimiento: ";
cin>>Nacimiento.LaFecha.mes;
cout<<"Ingrese año de nacimiento: ";
cin>>Nacimiento.LaFecha.anno;
cout<<
"Ingrese durante que hora nacio: ";
cin>>Nacimiento.ElTiempo.hora;
cout<<"Cuantos minutos? ";
cin>>Nacimiento.ElTiempo.minuto;
cout<<"Cuantos segundos? ";
cin>>Nacimiento.ElTiempo.segundo;
cout<<"\n\n";
cout<<
"La fecha de nacimiento es el dia "
<<Nacimiento.LaFecha.dia<<"/"
<<Nacimiento.LaFecha.mes<<"/"
<<Nacimiento.LaFecha.anno;
cout<<"\nLa hora de nacimiento es: "
<<Nacimiento.ElTiempo.hora
<<" horas, "
<<Nacimiento.ElTiempo.minuto

<<" minutos y "
<<Nacimiento.ElTiempo.segundo
<<" segundos\n";
return 0;
}
9.5. ARREGLOS DE REGISTROS

La forma más adecuada de aprovechar las estructuras es
empleándolo dentro de arreglos
Para un arreglo de estructuras, se define la variable

estructura como un arreglo. Así por ejemplo tenemos
struct persona
{ char[10] nom;
float sueldo;
};
main()
{ struct persona empleado[10];
//arreglo de estructuras
//empleado de 10
elementos
.............
}
Se accede a un elemento del arreglo de estructuras

usando el índice del arreglo para la variable empleado
y el operador punto (.)
empleado[indice].sueldo=500;
Ejemplo : Desarrolle un programa que permita leer

el nombre y la edad de 10 empleado y
luego imprima los datos ingresados
//Programa que lee e imprime el
//contenido de un arreglo de
//estructuras
#include <stdio.h>
#define max 10
struct datos
{ char nomb[20]; //nombre
int edad;
};
void leer(struct datos pe[max]);

void escribir(struct datos pe[max]);
void main()
{
struct datos p[max];
leer(p);
escribir(p);
}
void leer(struct datos pe[max])

{
int i;
for(i=0;i<max;i++)
{
flushall();
printf("Ingrese nombre:==> ");
gets(pe[i].nomb);
printf("Ingrese edad ==> ");
scanf("%d",&pe[i].edad);
}
}
void escribir(struct datos pe[max])

{
int i;
for(i=0;i<max;i++)
{ printf("Nombre ==> %s \n",pe[i].nomb);
printf("Edad ==> %d \n",pe[i].edad);
}
}
Advierta como en este programa se leen los registros,
como es un arreglo por defecto se tiene que el paso de
parámetros es por variable o referencia.
EJEMPLO 1 : Escribir un programa que permite

realizar operaciones con números
racionales. Un numero racional (p,q)
donde p es el numerador y q ≠ 0 es el
denominador.
Igualdad de números racionales:

(p, q) = (p’, q’) ⇔ p q’ = p’ q
Adición en los racionales:

(p, q) + (p’, q’) = (p q’ + p’q , q q’)
Multiplicación de racionales
(p, q) (p’, q’) = (p p’, q q’)

struct racional
{ int num;
int den;
};
void leer(struct racional &x);

void escribir(struct racional x);
void sumar(struct racional x,
struct racional y,
struct racional &su);
void multiplicar(struct racional x,
struct racional y,
struct racional &mu);
void simplificar(struct racional &s);
void main(){
struct racional a,b,s,m;
cout<<"ingrese primer racional\n";

leer(a);
cout<<"ingrese segundo racional\n";
leer(b);
sumar(a,b,s);
multiplicar(a,b,m);
cout<<
"contenido del 1er racional \n";
escribir(a);
cout<<
"contenido del 2do racional \n";
escribir(b);
cout<<"La suma es:\n";
escribir(s);
cout<<"La multiplicación es:\n";
escribir(m);
}
void leer(struct racional &x){

cout<<"ingrese numerador ";
cin>>x.num;
cout<<"ingrese denominador ";
cin>>x.den;
}
void escribir(struct racional x){

if (x.num==x.den)
cout<<x.num/x.den<<"\n";
else
cout<<x.num<<"/"<<x.den<<"\n";
}
void sumar(struct racional x,

struct racional y,
struct racional &su){

su.num=x.num*y.den+x.den*y.num;
su.den=x.den*y.den;
simplificar(su);
}
void multiplicar(struct racional x,

struct racional y,
struct racional &mu){
mu.num=x.num*y.num;
mu.den=x.den*y.den;
simplificar(mu);
}
void simplificar(struct racional &s){

int d; //d divisor común usado
// para simplificar
if (s.num>s.den) d=s.num;
else d=s.den;
//simplifica la fracción
while(1){
if ( (s.num%d)==0 && (s.den%d)==0 ){
s.num=s.num/d; s.den=s.den/d;}
else d--;
if (d==2) break;//divisor = 2
}
}
EJEMPLO 2 : Escribir un programa que permita

registrar a las personas que visitan
una empresa. Se debe registrar el
nombre y la edad de la persona; el día,
mes y año de la visita, así como
también la hora, minuto y segundos en
la que se realizó la visita. El
programa debe mostrar luego un reporte
de las visitas.
#include <stdio.h>
#define max 2
struct estruFecha {
int dia;
int mes;
int anno;
};
struct estruTiempo {
int hora;
int minuto;
int segundo;
};
struct datos
{ char nomb[20]; //nombre

int edad;
struct estruFecha LaFecha;
struct estruTiempo ElTiempo;
};
void leer(struct datos pe[max]);
void escribir(struct datos pe[max]);
void main()
{
struct datos p[max];
leer(p);
escribir(p);
}
void leer(struct datos pe[max])

{
int i;
for(i=0;i<max;i++)
{
flushall(); //limpia el buffer
//del teclado
printf("Ingrese nombre: ");
gets(pe[i].nomb);
printf("Ingrese edad: ");
scanf("%d",&pe[i].edad);
printf("Ingrese dia: ");
scanf("%d",&pe[i].LaFecha.dia);
printf("Ingrese mes: ");
scanf("%d",&pe[i].LaFecha.mes);
printf("Ingrese año: ");
scanf("%d",&pe[i].LaFecha.anno);
printf("Ingrese la hora: ");
scanf("%d",&pe[i].ElTiempo.hora);
printf("minutos? ");
scanf("%d",&pe[i].ElTiempo.minuto);
printf("segundos? ");
scanf("%d",&pe[i].ElTiempo.segundo);
printf("\n");
}
}
void escribir(struct datos pe[max])

{
int i;
for(i=0;i<max;i++)
{
printf("%s",pe[i].nomb);
printf(" de %d años \n",pe[i].edad);
printf("visitó la empresa el dia ");
printf("%d/",pe[i].LaFecha.dia);
printf("%d/",pe[i].LaFecha.mes);
printf("%d\n",pe[i].LaFecha.anno);
printf("a las: ");
printf("%d horas, ",pe[i].ElTiempo.hora);
printf("%d minutos y ",
pe[i].ElTiempo.minuto);
printf("%d segundos",
pe[i].ElTiempo.segundo);
printf("\n\n\n");
}
}

CAPITULO DIEZ
PUNTEROS
En este capítulo analizamos una de las características más

poderosas del C++, el puntero (o apuntador), que son las
capacidades más difíciles de dominar. Los punteros permiten
simular las llamadas por referencia (uso de parámetros por
referencia), crear y manipular estructuras de datos como son
las listas enlazadas, colas, pilas y árboles; utilizando la
asignación dinámica de la memoria.
10.1. CONCEPTOS BASICOS

Un puntero o apuntador es una variable que contiene la
dirección de otra variable.
Puesto que un puntero contiene la dirección de un

objeto, se puede acceder al objeto, "indirectamente" a
través de él. Si x es una variable de tipo int, y px
es un apuntador. El operador unario de dirección &
devuelve la dirección de un objeto, por lo que la
proposición
px = &x ;
asigna la dirección de x a la variable px y se dice

que px "apunta a" x. El operador & sólo se puede
aplicar a variables y a elementos de un arreglo.

px = &x; se puede representar de la siguiente forma:
px Variable x
direc de x valor
o en forma simplificada
px Variable x
valor
El operador unario de indirección * toma su operando

como una dirección y accesa a esa dirección para
obtener su contenido.
Para realizar que la proposición px = &x, es necesario

declarar las variables que intervienen en el ejemplo
como se muestra a continuación.
int x;
int *px;
La declaración de x ya la hemos visto anteriormente.

La declaración del apuntador px es nueva
int *px;
significa que px es una variable que contiene la

dirección de una variable entera.
Ejemplo 1 : Uso de una variable puntero.

#include <conio.h>
void main()
{ int *px,x;
cout <<"x=5\n";
cout <<"px=&x\n";
x=5;
px=&x;
cout <<"*px es "<<*px;
cout << " y x es "<<x<<"\n\n";

cout <<"*px=10\n";
*px=10;
cout <<"*px es ";
cout <<*px<< " y x es "<<x<<"\n\n";
cout <<"px es ";

cout <<px<< " y &x es "<<&x<<"\n";
Explicación:
Las instrucciones:
x=5;
px=&x;
se representan de la siguiente manera:
Variable x
px dir x 5
donde px "apunta a" x

y *px es 5.
10.2. CADENAS Y CARACTERES

En C++ una cadena es un arreglo de caracteres que
termina con el carácter nulo (‘\0’). En la memoria los
caracteres de una cadena son almacenados uno detrás
del otro como se muestra en la figura:
La siguiente proposición
char cad[10]=”Mi Perú”;
genera el siguiente arreglo de caracteres.
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]
‘M’ ‘i’ ‘P’ ‘e’ ‘r’ ‘ú’ ‘\0’
Caracteres Nulo Sin usar
Para acceder a sus elementos se realiza como se hizo

con un vector; pero se debe tener en cuenta que el
contenido de cada elemento es un carácter.

Ejemplo 1 : Escribir un programa donde se ingrese
un texto y luego determine el número de
palabras con longitud es par.
#include <string.h>
#include <stdio.h>
#include <ctype.h>
void main(){
char texto[80];
int cpal,i,lpal;
printf("Ingrese texto: ");

gets(texto);
cpal=0;i=0;
while(texto[i]!='\0'){
lpal=0;
while (isalpha(texto[i]) &&
texto[i]!='\0'){
lpal++;
i++;
}
if (lpal % 2==0 && lpal) cpal++;
while (!isalpha(texto[i]) &&
texto[i]!='\0') i++;
}
printf("Cantidad de palabras: %d\n",cpal);
}
Ejemplo 2 : Escribir un programa donde se ingrese

un texto y luego imprima todas las
palabras que inicien en una vocal y su
longitud sea impar.
#include <stdio.h>
#include <ctype.h>
int esvocal(int c);
void main(){
char texto[80],palabra[80];
int i,lpal;
printf("Ingrese texto: ");

gets(texto);
i=0;
while(texto[i]!='\0'){
lpal=0;
palabra[lpal]='\0';
while (isalpha(texto[i]) &&
texto[i]!='\0'){
lpal++;

palabra[lpal-1]=texto[i];
palabra[lpal]='\0';
i++;
}
if (lpal % 2!=0 &&
esvocal(palabra[0]))
printf("%s\n",palabra);
while (!isalpha(texto[i]) &&
texto[i]!='\0') i++;
}
}
int esvocal(int c){

if(islower(c)) c-=32;
if (c=='A') return 1;
else if (c=='E') return 1;
else if (c=='I') return 1;
else if (c=='O') return 1;
else if (c=='U') return 1;
else return 0;
}
Otro forma de declarar una cadena es:
Char cad[]=”Mi Perú”;
char *cad=”Mi Perú”;
char cad[]={‘M’,’i’,’ ’,’P’,’e’,’r’,’ú’,’\0’};
que genera el siguiente arreglo de caracteres.
[0] [1] [2] [3] [4] [5] [6] [7]
‘M’ ‘i’ ‘P’ ‘e’ ‘r’ ‘ú’ ‘\0’
Caracteres Nulo
La diferencia de estas tres declaraciones con:
char cad[10]=”Mi Perú”;
es que el tamaño del arreglo se ajusta a la cantidad

de caracteres de la cadena más el carácter nulo.
En C++ es apropiado decir que una cadena es un
puntero, de hecho es un puntero al primer carácter de
una cadena.
Ejemplo 3 : Escribir un programa donde se ingresen

dos textos, luego imprima cuantas veces
se encuentra el contenido del segundo
texto en el primer texto. Por ejemplo:
Si el primer texto es “Sistemas
operativos modernos” y el segundo es
“os” el resultado es 2.
#include <stdio.h>
int contarsub(char *cad,char *sub);
void main(){
char cadena[80],subcad[80];
printf("Ingrese la cadena: ");

gets(cadena);
printf("Ingrese la subcadena: ");
gets(subcad);
printf("Numero de veces contenida: %d\n"
,contarsub(cadena,subcad));
}
int contarsub(char *cad,char *sub){

int i,j,k,c=0;
for(i=0;cad[i]!='\0';i++)
for(j=i,k=0;sub[k]==cad[j];k++,j++)
if(sub[k+1]=='\0'){
c++;
break;
}
return c;
}
Ejemplo 4 : Programa que imprime una cadena usando

un puntero.
void main()
{ char x[]="hola amigo",*p;int i;
i=0;
p=x;
while(*(p+i)!= 0)
{cout<<*(p+i);
i++;
}cout<<"\n";
}
Ejemplo 5 : Se tiene una cadena de caracteres se
pide hacer un programa para contar
cuantas palabras en total existen,
además el programa debe calcular
cuantos caracteres tiene la palabra más
grande y la más corta. Para hacer el
recorrido deberá usar sólo punteros a
arreglos. Por ejemplo
Si se tiene la cadena :
"AQUÍ UNA CADENA CORTA ESTA PRESENTE"
El programa imprimirá que existen 6 palabras en
total, la palabra más corta consta de 3
caracteres y la más grande consta de 8
caracteres.
void contar(char *c,int &can,int &may,

int &men);
void main()
{ int veces=0;//cuantas palabras hay
int ma=0,me=10000;//caract de mayor y menor
//respectivamente
char cad1[45]="AQUI UNA CADENA CORTA ESTA
PRESENTE";
contar(cad1,veces,ma,me);
cout<<"La cadena "<<cad1<<" tiene
\n"<<veces;
cout<<" palabras, la palabra mayor tiene
"<<ma<<" caracteres\n";
cout<<"y la palabra menor tiene "<<me<<"
caracteres"<<endl;
}
void contar(char *c, int &can, int &may,

int &men)
{
int cont=1;//contador de caracteres
//de cada palabra
while(*c!=0)
{
if (*c==' ')
{ can++;
if (may<cont-1) may=cont-1;
if (men>cont-1) men=cont-1;
cont=0;
}
c++;cont++;
}
can++;//la ultima palabra no acaba
//en espacio
if (may<cont-1) may=cont-1;
if (men>cont-1) men=cont-1;
}

10.3. PUNTEROS A ESTRUCTURAS
Dada la declaración
struct ns { T1 C1;
.....
TK CK;
} *p, q;
si p=&q; especifica que p es una variable apuntador a

la variable de estructura q, que se representa de la
siguiente manera:
Variable q
dir q C1 ... CK
p
Para acceder al campo de una variable estructura a

través del puntero a estructura usar:
p->C1, ... , p->CK
El uso más difundido de una variable puntero a

estructura es en las estructuras de datos con
asignación dinámica de la memoria los cuales se
estudian en los siguientes items.
10.4. LISTAS ENLAZADAS

Una lista enlazada es una colección lineal de
estructuras autorreferenciadas llamadas nodos,
conectadas por enlaces de punteros, por lo que se le
llama lista “enlazada”. Se tiene el acceso a una lista
enlazada vía un puntero al primer nodo de la lista. Se
puede tener acceso a los nodos subsecuentes vía el
puntero de enlace almacenado en cada nodo. Para marcar
el fin de la lista, el puntero de enlace del último
nodo apunta a NULL(0).

L
NULL
Nodos
La estructura de datos en C++ usada puede ser:
struct nodo
{ int info;//guarda la información del nodo
struct nodo *sig; //puntero que apunta al siguiente
// nodo
};
Si definimos una lista como elementos de un conjunto

E. Se tiene que:
Una lista sobre E es una secuencia ordenada L de cero

o más elementos de E:
a1, a2, ...., an
Si n=0, L no tiene elementos y será llamada la lista

nula o vacía.
Si n>=1, L tiene n elementos y diremos que su

longitud es n.
a1 es el primer elemento de L y an es el último

elemento de L.
Para i= 1, 2, … , n-1, ai precede a ai+1
Para i= 2, 3, … , n, ai sigue a ai-1
El orden en la secuencia determina la posición de

cada elemento.
Ahora se mencionan las características de algunas

operaciones que vamos a implementar para la lista
enlazada con punteros.
Operaciones básicas con una lista

Suponemos que L es una lista. Además conviene postular
la existencia de una posición especial: FIN(L), la
cual sigue a la posición del último elemento de L que
es (NULL).
ANULA(L) : Función que convierte a L en la lista

vacía o nula y retorna la posición FIN(L).
LOCALIZA(x,L) : Función que retorna la posición

del primer elemento de L que es igual a x o
FIN(L), si tal elemento no existe.
RECUPERA(p,L) : Función que retorna al elemento

que está en la posición p en L. No esta definida si
p=FIN(L) o si no hay una posición p en L.
SUPRIME(p,L) : Función que suprime al elemento de la

posición p en L; esto es, si L es a1, …, ap-
1, ap, ap+1, …,an antes; después L es a1, …, ap-1,
ap+1, …,an. El resultado no esta definido si
p=FIN(L) o si no hay una posición p en L.
INSERTA(x,L) Función que inserta x en forma ordenada

en la lista L.

Ejemplo 1 : Programa que ejecuta las operaciones de
una lista enlazada.
//programa que realiza la implementación de la
//lista con punteros.
#include <alloc.h>
#define nulo 0
struct nodo
{ int info;
struct nodo *sig;
};
#define TAM sizeof(struct nodo)

struct nodo * anula(struct nodo *top);
struct nodo * inserta(int x,struct nodo *top);
void contenido(struct nodo *top);
struct nodo * suprime(int p, struct nodo *top);
int localiza(int x, struct nodo *top );
int recupera(int pos,struct nodo *top);
struct nodo * FIN(struct nodo *top);
main()
{ int op,x,p;struct nodo *L;
do
{
cout<<"MENU DE OPERACIONES DE UNA”;
cout<<"LISTA ENLAZADA \n";
cout<<"1. ANULA LISTA \n";
cout<<"2. SUPRIME \n";
cout<<"3. INSERTA \n";
cout<<"4. CONTENIDO DE LA LISTA \n";
cout<<"5. LOCALIZA ELEMENTO \n";
cout<<"6. RECUPERA ELEMENTO \n";
cout<<"7. SALIR \n";
cout<<"Ingrese una opción (1-7)==>
";cin>>op;
switch (op)
{ case 1 : L=anula(L);break;
case 2 : cout<<"Digite posición a
suprimir ==> ";cin>>p;
L=suprime(p,L);break;
case 3 : cout<<"Digite valor a insertar
==> ";cin>>x;
L=inserta(x,L);break;
case 4 : contenido(L);break;
case 5 : cout<<"Digite valor a localizar
==> ";cin>>x;
p=localiza(x,L);
if (p==-1)
cout<<"no existe valor ";
else
cout<<"la posición es "<<p;
getch();break;

case 6 : cout<<"Digite posición a
mostrar ==> ";cin>>p;
x=recupera(p,L);
if (x==-1)
cout<<"no existe posición";
else
cout<<"el valor es "<<x;
getch();break;
case 7 : break;
default : cout<<" ingrese valor del 1 al
7";getch();
}
} while (op!=7);
}
struct nodo * anula(struct nodo *top)

{ top=NULL; return(top);
}
struct nodo * inserta(int x,struct nodo *top)

{ struct nodo *comienzo, *nuevo, *p, *q;
/*01*/ comienzo=top;
/*02*/ /*crear nuevo dato*/
/*03*/ nuevo=(struct nodo *) malloc(TAM);
/*04*/ nuevo->info=x;
/*05*/ /* primer dato*/
/*06*/ if (comienzo==NULL)
/*07*/ { comienzo=nuevo;nuevo->sig=NULL;}
/*08*/ /* valor antes de comienzo*/
/*09*/ else
/*10*/ if (x<comienzo->info)
/*11*/ { nuevo-
>sig=comienzo;comienzo=nuevo;}
/*12*/ else
/*13*/ { /*nuevo se halla entre p y q;
/*14*/ /*luego enlazarlos*/
/*15*/ q=comienzo;
/*16*/ while (q!=NULL && (x>=q-
>info))
/*17*/ {p=q; q=q->sig;}
/*18*/ p->sig=nuevo;nuevo->sig=q;
/*19*/ }
return(comienzo);
}
int recupera(int pos,struct nodo *top)

{ struct nodo *p;int i=1;
p=top;
while(p!=FIN(top) && i!=pos)
{p=p->sig;i++;}
if(p==FIN(top))
return(-1); //no hay posición pos
else
return (p->info);
}
struct nodo * FIN(struct nodo *top)

// Esta implementación de fin(L) es ineficiente
(se recorre
// toda la lista). Si se usa con mucha
frecuencia es preferible
// modificar un poco la estructura de la lista
y/o el programa
{ struct nodo *p;
p=top;
while(p!=NULL)
{p=p->sig;}
return(p);
}
void contenido(struct nodo *top)

{ struct nodo *p;
cout<<"impresión de la lista \n";
p=top;
while(p!=NULL)
{cout<<p->info<<" ";p=p->sig;
}
cout<<"\n";
getch();
}
struct nodo * suprime(int pos, struct nodo

*top)
{struct nodo *q,*p,*comienzo;int i=1;
comienzo=top;q=comienzo;
if (pos==1) //la posición es al inicio
{ comienzo=q->sig;free(q);}
else
{ while (q!=FIN(comienzo) && pos!=i)
{p=q; q=q->sig;i++;}
if (q==FIN(comienzo))
{cout<<"posición no encontrado o lista
vacía \n";getch();}
else
{p->sig=q->sig;
free(q);/*libera la memoria asignada al
puntero q*/
}
}
return (comienzo);
}
int localiza(int x, struct nodo *top )

{ struct nodo *p,*comienzo;int true,i=1;
p=top;
while(p!=FIN(top))
{ if (x==p->info) return(i);
else {p=p->sig;i++;}
} /*fin de while*/
if (p==FIN(top))
return(-1);
}

10.5. COLAS (FIFO)
Una cola es otro tipo especial de lista, en la cual
los elementos se insertan por un extremo llamado FINAL
y se suprime por el otro llamado FRENTE:
a b c d e
Frente Final
Esto ocasiona que el primer elemento en entrar es el

primero en salir; de aquí el nombre de lista fifo
(first in, first out) que también se le da a una cola.
Las operaciones básicas que caracterizan a una cola

son las siguientes:
ANULA(C) : Función que convierte a la cola C en la

cola vacia.
VACIA(C) : Función que retorna 1 si la cola esta

vacía y 0 en caso contrario.
FRENTE(C) : Función que retorna el 1er. elemento de

la cola C. Esta función no está definida si la cola
es vacia.
INSERTA_COLA(x,C) : Función que inserta al elemento

x en el final de C.
SUPRIME_COLA(C) : Función que suprime el elemento del

frente de la cola C. No se realiza si la cola es
vacia.
Ejemplo 1 : Realizar la implementación con

punteros de las operaciones de una
cola.
Cola
5 6
NULL
Frente Final

#include <conio.h>
#include <alloc.h>
struct nodo
{ int info;
struct nodo *sig;
};
#define TAM sizeof(struct nodo)

struct nodo * anula(struct nodo *top);
struct nodo * inserta_cola(int x,struct nodo
*top);
void contenido(struct nodo *top);
int frente(struct nodo *top);
struct nodo * suprime_cola(struct nodo *top);
main()
{ int op,x,p;struct nodo *L;
do
{ clrscr();
cout<<"MENU DE OPERACIONES DE COLA \n";
cout<<"1. ANULA COLA \n";
cout<<"2. INSERTA COLA \n";
cout<<"3. CONTENIDO DE LA COLA \n";
cout<<"4. SUPRIME COLA \n";
cout<<"5. FRENTE \n";
cout<<"6. SALIR \n";
cout<<"Ingrese una opción (1-6)==>
";cin>>op;
switch (op)
{ case 1 : L=anula(L);break;
case 2 : cout<<"Digite valor a insertar
==> ";cin>>x;
L=inserta_cola(x,L);break;
case 3 : contenido(L);break;
case 4 : L=suprime_cola(L);break;
case 5 : x=frente(L);
if(x!=-1)
cout<<"el valor es "<<x;
getch();break;
case 6 : break;
default : cout<<" ingrese valor del 1 al
6";getch();
}
} while (op!=6);
}
struct nodo * anula(struct nodo *top)

{ struct nodo *p;
p=top; p=NULL; return(p);
}
struct nodo * inserta_cola(int x,struct nodo

*top)
//inserta x al final de la cola
{ struct nodo *comienzo, *nuevo, *p, *q;
/*01*/ comienzo=top;
/*02*/ /*crear nuevo dato*/
/*03*/ nuevo=(struct nodo *) malloc(TAM);
/*04*/ nuevo->info=x;
/*05*/ /* primer dato*/
/*06*/ if (comienzo==NULL)//si es vacia la
cola
/*07*/ { comienzo=nuevo;nuevo->sig=NULL;}
/*09*/ else
/*13*/ { /*nuevo se pone al final de la
cola*/
/*15*/ q=comienzo;
/*16*/ while (q!=NULL)
/*17*/ {p=q; q=q->sig;}
/*18*/ p->sig=nuevo;nuevo->sig=q;
/*19*/ }
return(comienzo);
}
struct nodo * suprime_cola(struct nodo *top)

//suprime el 1er elemento
{ struct nodo *comienzo, *p, *q;
comienzo=top;
p=comienzo;
if (p==NULL)
{ cout<<"cola vacia";
getch();
}
else
{ q=p->sig;
comienzo=q;
free(p);
}
return(comienzo);
}
int frente(struct nodo *top)

{ struct nodo *p;
p=top;
if (p==NULL)
{cout<<"cola vacia";getch();
return(-1);
}
else
return (p->info);
}
void contenido(struct nodo *top)

{ struct nodo *p;
cout<<"impresion de la lista \n";
p=top;
while(p!=NULL)
{cout<<p->info<<" ";p=p->sig;
}
cout<<"\n";
getch();
}

CAPITULO ONCE
ARCHIVOS
En el capítulo de registros al utilizar los arreglos de

estructuras se da la desventaja que los datos de los
registros existen, mientras el programa este en ejecución,
perdiéndose cuando el programa finaliza. Para salvar esta
situación se puede guardar los datos al disco utilizando los
archivos que se dan en C++, recuperandolos cuando se desee
usar en alguna otra oportunidad.
11.1. ORGANIZACIÓN DE ARCHIVOS
Un archivo es una colección de datos que con un título

o nombre se almacenan o graban en dispositivos tales
como discos, disquetes, cintas magnéticas, etc. Los
datos de un archivo pueden ser leídos y utilizados por
otros medios.
Las operaciones básicas con un archivo son:
Apertura del archivo empleando un nombre para

identificarlo
Escritura de datos en el archivo
Lectura de datos del archivo

Cierre del archivo
Los datos de un archivo son simplemente bytes o

caracteres almacenados uno a continuación de otro que
son enumerados con 0, 1,...
0 1 2 3 4 5 6 7 8
Archivo
comienzo apuntador apunta

a componente 8
Es necesario abrir un archivo antes de proceder a

hacer operaciones de escritura o de lectura en él.
Cuando se abre un archivo usualmente queda listo para
acceder al componente 0, lo que suele decirse que el
archivo apunta al comienzo.
Después de cada operación de escritura o de lectura,

el archivo apunta al componente que sigue al grupo de
datos escritos o leídos: Acceso secuencial.
También es posible desplazar el apuntador a un

componente particular dentro del archivo, empleando
funciones de movimiento del apuntador: Acceso directo.
Se debe cerrar un archivo cuando ya no se desee

trabajar con él.
Para borrar o eliminar un archivo se emplea la

función unlink(). Por ejemplo, mediante
unlink(“DATOS”);
se borra el archivo de nombre DATOS.
FUNCIONES DE ALTO NIVEL
Para utilizar este grupo de funciones se debe incluir

la cabecera stdio.h

El uso de las funciones requiere la declaración de una
variable puntero del tipo predefinido FILE en la
forma:
FILE *arch;
en donde arch es un nombre o identificador .
Para abrir un archivo usar la función fopen(), con el

siguiente formato:
arch = fopen(“NOMBRE DE ARCHIVO” , modo);
donde modo puede ser:
“r” Abre para solo lectura
“w” Crea para escritura. Si el archivo

existe, este se sobreescribe
“a” Abre para escribir al final del

archivo o crea para escribir si el
archivo no existe.
“r+” Abre un archivo existente para

actualizar (lectura y escritura).
“w+ “ Crea un nuevo archivo para actualizar

(lectura y escritura). Si el archivo
existe, este se sobreescribe
“a+” Abre para añadir, abre para actualizar

en el final del archivo, o crea este
si no existe.
Para especificar que un archivo esta siendo abierto o

creado en el modo texto añadir “t” a la cadena (rt,
w+t, etc.)
Para especificar el modo binario, añadir “b” a la

cadena (wb, a+b, etc.)

Nota:
Si se tiene la cadena “r+t” es equivalente a “rt+”,

sucede lo mismo con las demás combinaciones.
La función fopen() devuelve la dirección 0 (cero o

NULL) si la operación de apertura falla, o un valor
(dirección) distinto si es correcta.
Si la operación es correcta, a partir de ese instante

el archivo queda referido por el apuntador arch hasta
el momento en que se cierra con fclose mediante:
fclose (arch);
11.2. ESCRITURA EN ARCHIVOS:
Para escribir en un archivo (abierto en los modos “w”

o “a”) se pueden utilizar las funciones:
fputc(c , arch): Escribe un carácter c en arch.
fwrite(s, m, n, arch): Escribe en arch n datos de

tamaño o longitud m (igual a m*n bytes) ubicados a
partir de la dirección s.
11.3. LECTURA DE ARCHIVOS:
fgetc(arch) : Devuelve el siguiente carácter leído en

arch.
fread(s, m, n, arch): Lee en arch n datos de tamaño o

longitud m (igual a m*n bytes) y los almacena a
partir de la dirección s.
feof(arch) : Sirve para comprobar si está en el final

del archivo (valor distinto de cero) o nó (valor
cero).
NOTA:

fputc() y fgetc() devuelven un valor de tipo int igual
al carácter escrito o leído o el valor EOF(-1) en caso
de error. Se devuelve EOF si se llegó al final del
archivo.
fwrite() y fread() devuelven un valor de tipo igual al

número de datos escritos o leídos. Así fwrite()
devuelve el número de n datos especificados o un valor
menor en caso de error. Y fread() devuelve el valor n
o un número menor, por ejemplo 0 si está en el final
del archivo.
11.4. UBICACIÓN DEL PUNTERO PARA ACCESO

DIRECTO
Usar : fseek (arch, desp, orig);
La función pone o ubica el puntero del archivo en el

componente cuya posición es dada por des (tipo long) y
orig, siendo desp el desplazamiento respecto del lugar
indicado por el origen orig, cuyos valores son-.
0 = comienzo del archivo

1 = posición actual
2 = final del archivo
fseek() devuelve el valor 0 si el movimiento ha tenido

lugar, o distinto de 0 en caso de error.

archivo de texto.
#include <string.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
FILE *stream;
char ch;
/* open a file for update */
stream = fopen("TEXTO.TXT", "r");

clrscr();
do
{ /* read a char from the file */
ch = fgetc(stream);
/* display the character */
putchar(ch);
} while (ch != EOF);
fclose(stream);
getch();
return 0;
}
Ejemplo 2 : Programa que copia el contenido de un

archivo de texto en otro.
#include <string.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
FILE *p,*q;
char
ch,nombarch1[12]="texto.txt",nombarch2[12]="tex
to1.txt";
// Copia un archivo en otro
p = fopen(nombarch1, "r");
q = fopen(nombarch2, "w");
clrscr();
do
{/* read a char from the file */
ch = fgetc(p);
/*escribe ch en q*/
fputc(ch,q);
fclose(p);fclose(q);
clrscr();
//escribe el contenido de los archivos
p = fopen(nombarch1, "r");
cout<<"contenido archivo "<<nombarch1<<"\n";
do
{
/* read a char from the file */
ch = fgetc(p);
/*escribe ch en pantalla*/
putchar(ch);
fclose(p);
cout<<"contenido archivo "<<nombarch2<<"\n";

q = fopen(nombarch2, "r");
do
{
/* read a char from the file */
ch = fgetc(q);
/*escribe ch en pantalla*/

putchar(ch);
fclose(q);
getch();
return 0;
}
Ejemplo 3 : Programa que administra archivos

binarios
#include <iomanip.h>
#include <conio.h>
#include <stdio.h>
#include <string.h>
#include <process.h>
struct alumno{
char nombre[20];
int edad;
};
void crear();
void anadir();
void reporte();
void consulta();
void modificacion();
void eliminacion();
void ordenar();
void main(){
char resp;
do{
clrscr();
cout<<"0. Salir\n";
cout<<"1. Crear\n";
cout<<"2. Anadir\n";
cout<<"3. Reporte\n";
cout<<"4. Consulta\n";
cout<<"5. Modificacion\n";
cout<<"6. Eliminacion\n";
cout<<"7. Ordenar\n";
cout<<"Ingrese Opcion :\n";
resp=getch();
switch(resp){
case '1':crear();break;
case '2':anadir();break;
case '3':reporte();break;
case '4':consulta();break;
case '5':modificacion();break;
case '6':eliminacion();break;
case '7':ordenar();break;
}
}while(resp!='0');
}

void crear(){
FILE *f;
struct alumno r;
if((f=fopen("alumnos.dat","wb"))==
NULL){
cout<<"No se puede abrir \n";
exit(0);
}
cout<<"Nombre : ";
gets(r.nombre);
while(r.nombre[0]!='\0'){
cout<<"Edad : ";
cin>>r.edad;
fwrite(&r,sizeof(r),1,f);
cout<<"Nombre : ";
gets(r.nombre);
}
fclose(f);
}
void anadir(){
FILE *f;
struct alumno r;
if((f=fopen("alumnos.dat","ab"))==
NULL){
exit(0);
}
cout<<"Nombre : ";
gets(r.nombre);
while(r.nombre[0]!='\0'){
cout<<"Edad : ";
cin>>r.edad;
fwrite(&r,sizeof(r),1,f);
cout<<"Nombre : ";
gets(r.nombre);
}
fclose(f);
}
void reporte(){
FILE *f;
struct alumno r;
if((f=fopen("alumnos.dat","rb"))==
NULL){
exit(0);
}
cout<<setw(20)<<"Nombre"
<<setw(10)<<"Edad\n";
while(fread(&r,sizeof(r),1,f)!=0){
cout<<setw(20)<<r.nombre
<<setw(10)<<r.edad<<"\n";
}
fclose(f);
getch();
}

void ordenar(){
FILE *f;
long pos,pos1,pos2,nreg,i,j;
struct alumno r,r1,r2;
if((f=fopen("alumnos.dat","rb+"))==
NULL){
exit(0);
}
fseek(f,0L,2);
fgetpos(f,&pos);
nreg=pos/sizeof(r);
for(i=nreg-1;i>=1;i--)
for(j=1;j<=i;j++){
pos1=(j-1)*sizeof(r);
pos2=(j)*sizeof(r);
fseek(f,(long)(pos1),0);
fread(&r1,sizeof(r),1,f);
fread(&r2,sizeof(r),1,f);
if(strcmp(r1.nombre,r2.nombre)>0){
fwrite(&r1,sizeof(r),1,f);
}
}
fclose(f);
cout<<"Ordenado Ascendentemente."
"Pulse una tecla para continuar\n";
getch();
}
void consulta(){
FILE *f;
struct alumno r;
char nombrec[20];
NULL){
exit(0);
}
cout<<"Ingrese nombre a consultar : ";
gets(nombrec);
if(!strcmp(r.nombre,nombrec)){
break;
}
}
if(strcmp(r.nombre,nombrec)){
cout<<"No existe ese nombre \n";
getch();
}
fclose(f);
getch();
}
void modificacion(){
FILE *f;
struct alumno r,r1;
char nombrec[20],resp;
long creg=0;
if((f=fopen("alumnos.dat","rb+"))==
NULL){
exit(0);
}
cout<<"Nombre a modificar:";
gets(nombrec);
creg++;
break;
}
}
cout<<"NUEVO REGISTRO\n";
cout<<"Nombre : ";
gets(r1.nombre);
cout<<"Edad : ";
cin>>r1.edad;
cout<<"Grabar modificaci¢n? (S/N)";
resp=getche();
if(resp=='S' || resp=='s'){
fseek(f,(creg-1)*sizeof(r),0);
}
}
else{
getch();
}
fclose(f);
}
void eliminacion(){
FILE *f,*f1;
struct alumno r;
char nombrec[20],resp;
int sw=0;
NULL){
exit(0);
}
f1=fopen("tmpfich.dat","wb");
cout<<"Nombre a eliminar: ";
gets(nombrec);
cout<<"Eliminar ? (S/N)\n";
resp=getch();
sw=1;
if(resp=='S' || resp=='s')
cout<<"Eliminado\n";
else fwrite(&r,sizeof(r),1,f1);
}
else fwrite(&r,sizeof(r),1,f1);
}
if (sw==0){
getch();
}
fclose(f);
fclose(f1);
remove("alumnos.dat");
rename("tmpfich.dat","alumnos.dat");
}

BIBLIOGRAFIA
1. Swan, Tom. (1995). Borland C++ 4.5. Editorial Sams

Premier.
2. Deitel, H. M. Y Deitel, P.J. (1994). Como Programar en

C/C++. Editorial Prentice Hall.
3. Gottfried, Byron S. (1991). Programación en C. Editorial

Mc Graw-Hill.
4. Joyanes Aguilar, Luis. (1988). Fundamentos de Programación

Algoritmos y Estructura de Datos. Editorial McGraw-Hill.
5. Alcalde, Eduardo Y Garcia, Miguel. (1987). Metodología de

la Programación. Editorial McGraw – Hill.

C++ Corre

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

C++ Corre

Enviado por

Direitos autorais:

Formatos disponíveis

UNIVERSIDAD NACIONAL DEL

CENTRO DEL PERU

ABRAHAM GAMARRA MORENO

DANIEL GAMARRA MORENO

JUAN GAMARRA MORENO

1.1. Construcción de un programa de computadora ............................................3

1.1.1. Análisis del problema...........................................................................4

1.1.2. Proceso de solución.............................................................................4

1.1.3. Refinamiento del Programa ................................................................5

1.2. Características de los programas ....................................................................5

1.2.2. Eficiencia ...............................................................................................5

1.2.3. Modularidad y estructuración.............................................................6

1.3. Objetos de un programa....................................................................................6

1.3.1. Constantes ............................................................................................6

2.1. Definiciones .........................................................................................................8

2.1.2. Programación modular ........................................................................9

2.1.3. Programación estructurada ................................................................9

2.2. Construcción de algoritmos ............................................................................11

2.3. Representación de algoritmos........................................................................11

2.3.1. Diagrama de Flujo ..............................................................................11

2.3.3. Pseudocódigo .....................................................................................12

3.1. Características ..................................................................................................13

3.3. Palabras reservadas ........................................................................................14

3.4. Estructura de un programa .............................................................................15

3.5. Comentarios ......................................................................................................15

3.5.1. Comentario en más de una linea.....................................................15

3.5.2. comentario en una sola línea ...........................................................15

3.6. Bloques ..............................................................................................................16

3.7. Tipos de datos fundamentales .......................................................................16

3.7.1. Tipo char..............................................................................................16

3.7.2. Tipos enteros ......................................................................................16

3.7.3. Tipos de punto flotante ......................................................................17

3.7.4. Tipo void ..............................................................................................17

3.8. Modificadores de tipo.......................................................................................17

3.9.1. Constantes enteras ............................................................................17

3.9.2. Constante carácter (char) .................................................................18

3.9.3. Constante cadena ..............................................................................18

3.9.4. Constante de punto flotante .............................................................19

3.10. Definición de constantes .................................................................................19

3.10.1. La directiva #define ............................................................................19

3.11. Declaración de variables .................................................................................19

3.12. Expresiones .......................................................................................................19

3.13. Conversión de tipos..........................................................................................20

4.1. Operadores aritméticos ...................................................................................22

4.2. Operador de asignación ..................................................................................23

4.2.1. Igual (=) ................................................................................................24

4.2.2. Asignación múltiple ............................................................................24

4.2.3. Asignación relativa .............................................................................24

4.3. Operadores de relación ...................................................................................25

4.4. Operadores lógicos ..........................................................................................25

5.1. Salida/entrada estándar en c++ .....................................................................26

5.1.1. Salida con cout ...................................................................................26

5.1.2. Entrada con cin...................................................................................27

6.1. Sentencia if........................................................................................................29

6.2. Sentencia switch...............................................................................................36

6.3. Sentencias repetitivas o bucles......................................................................38

6.4. Sentencia while .................................................................................................39

6.6. Sentencia for .....................................................................................................43

6.7. Sentencia break ................................................................................................46

6.8. Sentencia continue ...........................................................................................47

6.9. Sentencia goto ..................................................................................................47

6.10. Programas de aplicación.................................................................................48

7.1. Subprogramas o subrutinas............................................................................62