C++ Cursos y Tutoriales - WWW - Descarga-Tareas - Blogspot

Hecho en México por Rodolfo Panduro Rivera
2010
www.descarga-tareas.blogspot.com
PRESENTA
En este PDF podrás encontrar todos los tutoriales
de la sección de C++ de la página web Descarga
Tareas, para poder utilizarlo como apuntes o
compartirlo en otras comunidades siempre y
cuando tengas como fin compartir el conocimiento
y recalcando a los respectivos autores de los temas.
Página 1 de 104
¡Muchas gracias por utilizar este PDF!

2010
Temario – Índice
Contenido
Apartado 1 - Elementos Básicos en C++ ..................................................................................... 4
C++ - Introducción a Elementos Básicos en C++ .................................................................... 4
C++ - Modelo De Solución .......................................................................................................... 5
C++ - Constantes, Variables e Identificadores ......................................................................... 9
C++ - Tipos De Datos ................................................................................................................. 10
C++ - Operadores Aritméticos.................................................................................................. 11
C++ - Operador Cast .................................................................................................................. 12
C++ - Jerarquía De Operaciones .............................................................................................. 14
C++ - Compilador/Editor de C++ ............................................................................................ 15
C++ - Aplicaciones ..................................................................................................................... 16
C++ - Otras Funciones De Entrada/Salida ............................................................................. 19
C++ - Formato De Pantalla ....................................................................................................... 22
C++ - Palabras Reservadas De C++ ......................................................................................... 23
C++ - Funciones C++ ................................................................................................................. 26
Apartado 2 - Instrucciones De Control De Programa en C++ ..................................................... 27
C++ - Introducción a Instrucciones De Control De Programa en C++............................... 27
C++ - Instrucciones Condicionales .......................................................................................... 27
C++ - Condiciones Simples ....................................................................................................... 29
C++ - Instrucción If.................................................................................................................... 30
C++ - Condiciones Compuestas ............................................................................................... 32
C++ - Instrucción Switch ()....................................................................................................... 35
C++ - Ciclo For............................................................................................................................ 38
C++ - Ciclo While ....................................................................................................................... 40
Página 2 de 104
C++ - Ciclo Do... While .............................................................................................................. 42

C++ - Conclusiones Acerca De Ciclos ...................................................................................... 43
Apartado 3 - Arreglos en C++ .................................................................................................. 44
C++ - Introducción a Arreglos en C++ .................................................................................... 44
C++ - Arreglos En C++ .............................................................................................................. 45
2010
C++ - Arreglos Tipo Listas ........................................................................................................ 46
C++ - String ................................................................................................................................. 48
C++ - Listas De String................................................................................................................ 50
C++ - Sorteos U Ordenamientos .............................................................................................. 52
C++ - Arreglos Tipo Tabla ......................................................................................................... 53
C++ - Inicialización De Arreglos .............................................................................................. 56
Apartado 4 - Procedimientos Y Funciones de C++..................................................................... 57
C++ - Procedimientos ................................................................................................................ 57
C++ - Parámetros ....................................................................................................................... 59
C++ - Variables Locales Y Globales ......................................................................................... 62
C++ - Funciones ......................................................................................................................... 64
C++ - Arreglos como Parámetros ............................................................................................. 66
Apartado 5 - Registros Y Archivos Secuenciales de C++ ............................................................ 68
C++ - Introducción a Registros Y Archivos Secuenciales de C++ ....................................... 68
C++ - Estructuras O Registros .................................................................................................. 69
C++ - Archivos ............................................................................................................................ 71
C++ - Creación Archivos............................................................................................................ 75
C++ - Grabación Y Lectura Disco ............................................................................................. 77
C++ - Búsqueda En Archivo Directo........................................................................................ 81
C++ - Filtros O Condiciones ..................................................................................................... 83
C++ - Baja O Eliminación ......................................................................................................... 85
C++ - Operaciones Con Campos .............................................................................................. 86
C++ - Edición O Modificación Registros ................................................................................. 88
Apartado 7 - Variables Apuntadores ....................................................................................... 90
C++ - Introducción a Variables Apuntadores......................................................................... 90
C++ - Apuntadores A Escalares ................................................................................................ 91
C++ - Apuntadores A Strings .................................................................................................... 93
Página 3 de 104
C++ - Apuntadores A Arreglos ................................................................................................. 95

C++ - Apuntadores A Tablas ..................................................................................................... 97
Apartado 8 - Programación Orientada A Objetos .................................................................... 99
C++ - Introducción a Programación Orientada A Objetos ................................................... 99
2010
Apartado 1 - Elementos Básicos en C++
C++ - Introducción a Elementos Básicos en C++
Los nuevos sistemas de información son costosos en tiempos y recursos, la solución
moderna de sistemas de información exigen nuevas herramientas y metodologías para
resolver rápida, económica y eficiente los problemas de información planteados por las
organizaciones.
Aun más el pleno potencial del hardware no es aprovechado plenamente y existe un
considerable retraso con el software y sus aplicaciones, generando lo que se conoce
como “crisis del software”.
En programación tradicional, modular o estructurada un programa describe una serie
de pasos a ser realizados para la solución de un problema, es decir es un algoritmo, en
particular este modelo de programación se usó mucho para generar programas o
aplicaciones en ambientes PC y con consolas, es decir el programa se ejecutaba en una
consola de ms dos por ejemplo, y el programa o aplicación se tenía que portar
físicamente a otras PC, al final de su ciclo de vida de este modelo se había mejorado y
ya era posible que se ejecutara en alguna ventana-consola de ambientes Windows, con
mejor interface como Font, colores, background, etc.
En programación orientada a objetos ( OOP ) un programa es considerado como un
sistema de objetos interactuando entre sí, ambientes de desarrollo visuales facilitan
aun más la construcción de programas y solución de problemas, porque permiten
abstraer al ingeniero de software de todo el GUI (interface gráfica) del problema, que
constituye más del 60% del código normal de un programa, en general este ambiente
permitió una mejora en la interface del programa con el usuario de la aplicación ya que
en este caso solo se manejaban formas o ventanas llenas de componentes o controles
especializados en alguna tarea específica.
A este modelo de programación o construcción de programas los compiladores
modernos se adaptaron rápidamente y tenemos aplicaciones fantásticas, en donde
alguna forma o ventana está llena de controles visibles e invisibles que realizan
muchas tareas donde además de los componentes o controles que proporciona
directamente el compilador cuando se instala, existen miles de controles o
componentes extras en muchas partes del mundo realizados por programadores
talentosos y que enriquecen el contenido de nuestros programas y aplicaciones
visuales.
Al principio estas aplicaciones, se construían pensando en que se ejecutaban en una PC
con ambiente grafico o en una serie de PC próximas físicamente sin embargo el rápido
avance de las redes dentro de las empresas u organizaciones conllevan a que los
fabricantes de compiladores cada vez incluyeran mas y mas controles o componentes
Página 4 de 104
que permitan ejecutar el programa o aplicación simultáneamente en una red de PC.

Sin embargo cuando se habla de redes actuales estamos hablando de la red de redes
(internet) y si en redes internas o intranets el retraso en el tiempo de comunicación
entre sus PC internas y la cantidad de información a trasmitir entre las mismas no es
algo muy importante o inmanejable, este problema de tiempo de trasmisión y cantidad
de información, si es un factor muy importante cuando se pretende construir
programas o aplicaciones PC que deban compartirse o usarse por muchas conectadas
a internet, desgraciadamente como factor externo que es, no está bajo control de la
2010
empresa o del programador. C o C++, son los compiladores que permiten usar
cualquiera de los tres enfoques en la solución de problemas de información que puedan
y deban ser resueltos empleando el computador y el lenguaje aunque se repite este
curso está enfocado al primer modelo.
Fuente
C++ - Modelo De Solución

En general un problema de información es posible entenderlo, analizarlo y
descomponerlo en todos sus componentes o partes que de una u otra manera
intervienen tanto en su planteamiento como en su solución.
Una herramienta rápida que nos permite descomponer en partes un problema para su
solución, es el llamado modelo de solución, este consiste de una pequeña caja que
contiene los tres elementos más básicos en que se puede descomponer cualquier
problema sencillo de información, estas tres partes son:
1. LA PRIMERA PARTE: son todos los datos que el computador ocupa para resolver
el problema, estos datos son almacenados internamente en la memoria del
computador en las llamadas variables de entrada.
2. LA SEGUNDA PARTE: son todas las operaciones generalmente algebraicas

necesarias para solucionar el problema, generalmente esta parte del modelo es una
formula (o igualdad matemática, ej. X= y + 5).
3. LA TERCERA PARTE: es el resultado o solución del problema que generalmente se

obtiene de la parte de operaciones del modelo y dichos datos están almacenados en
las llamadas variables de salida.
En resumen para todo problema sencillo de información es necesario plantearse las

siguientes preguntas:
¿Qué datos ocupa conocer el computador para resolver el problema y en cuales variables de entrada se van a
almacenar?
Página 5 de 104
¿Qué procesos u operaciones debe realizar el computador para resolver el problema planteado?
¿Qué información o variables de salida se van a desplegar en pantalla para responder al problema planteado
originalmente?
Nota: No confundir los términos datos, variables e información.

2010
Datos: Se refiere a información en bruto, no procesada ni catalogada.
Por ejemplo: Tijuana, Calle Primera # 213, 15 años, $2,520.00.
Variables: Es el nombre de una localidad o dirección interna en la memoria del

computador donde se almacenan los datos,
Por ejemplo: Ciudad, Dirección, Edad, Sueldo.
Información: Son datos ya procesados que resuelven un problema planteado.
Ejemplos/Ejercicios De Modelo De Solución en C++
1. 1. Construir un modelo de solución que resuelva el problema de calcular el área de un

triángulo con la formula área igual a base por altura sobre dos.
Variable(s) de Entrada Proceso u Operación Variable(s) de Salida
BASE AREA= BASE * ALTURA / 2 AREA
ALTURA
2. 2. Convertir la edad en años de una persona a meses.
3. 3. Convertir pesos a dólares.
4. 4. Calcular el área de un circulo con la formula: Área = PI * Radio2
5. 5. Evaluar la función Y = 5x2 – 3x + 2 para cualquier valor de x. Página 6 de 104
NOTAS:
En los ejemplos anteriores, observar para el caso de constantes fijas o conocidas (PI) no se debe dar como
dato de entrada su valor, en cambio colocar directamente su valor dentro de la formula, en la parte de
operaciones del problema.
Pero recordar también que existirán problemas sencillos donde: No se ocupan entradas o no se ocupan
operaciones, pero todos ocupan salida.
2010
Una formula grande o muy compleja puede ser más segura y fácil de resolver, si es descompuesta y resuelta
en partes, juntando al final los parciales para obtener el resultado final.
Un problema puede tener más de una solución correcta.
El problema no está suficientemente explicado o enunciado, entonces, estudiarlo, analizarlo y construirlo de

manera genérica.
Tarea – Hacer los siguientes programas en C++
P1. Convertir millas a kilómetros.
P2. Convertir 125 metros a centímetros.
P3. Si calculamos que en promedio hay 4.7 nidos en cada árbol, también se cree que en cada nido existen un
promedio de 5.8 pájaros, Calcular la cantidad total de nidos y de pájaros en 227 árboles en total.
P4. La Sra. López y sus 8 hijos solo compran una vez al mes su mandado en el supermercado, donde el kilogramo
de frijol cuesta $8.75, el paquete de tortillas cuesta $3.55 y el frasco de café vale $14.25, si solo compran de estos
tres productos para su mandado, calcular su gasto total.
P5. Capturar y desplegar el nombre, número de control, grupo, calcular el promedio, desplegar los datos del alumno
y su promedio en pantalla.
P6. La distancia entre Tijuana y Ensenada es de 110 kilómetros. Si un automóvil la recorre a una velocidad
constante de 30 millas por hora, teniendo en cuenta que 1 milla son 1.609 Km. ¿cuánto tiempo tarda en llegar?
P7. Evaluar la función y = 3x2 + 2x – 5 para cualquier valor de x.
P8. Evaluar la función y = -5x3 – 3x2 + 8 para cuando x vale 4.
P9. Evaluar el factorial de cualquier numero usando la formula: n!=n!-1.
P10. La distancia que recorre un auto es de 50 Km y su velocidad es de 30 millas por hora. ¿Cuánto tiempo tardara
en llegar?
P11. Encontrar la derivada de x para cualquier valor con la formula (d/dx(x)=1)
P12. Calcular el interés que gana un capital de x pesos a una tasa de interés del 15% anual en un periodo de n
años.
P13. Que aceleración tiene un tren que parte de Tijuana a 10 km/h y pasa por ensenada una hora después a 50
Página 7 de 104
km/h.
P14. Calcular el número de aulas en una escuela que tiene 10 edificios y cada edificio 3 pisos y cada piso 5 aulas,
excepto un edificio que solo tiene dos pisos.
P15. Si en una escuela hay 30 maestros y 15 son hombres que atienden a 10 alumnos cada uno. ¿Cuántas
maestras hay?
P16. Calcular la corriente de un circuito con un voltaje de 15v y una resistencia de 6 ohm. Formula (I= V/R)
2010
P17. Calcular la normal estandar (z) dados los datos por el usuario: X=dato, µ=media, d=desviación. Formula (Z =
X-M / d)
P18. Dado un numero(N) cualesquiera obtener su raíz y potencia cuadrada.
P19. Determinar la media de 5 números diferentes.
P20. Determinar la velocidad v requerida para recorrer una distancia d en un tiempo t. Formula (V = d * t)
P21. Determinar la pendiente de una recta. Formula (y = m x + b)
P22. Calcular la función de y= x² + 8x + 3 para cualquier x
P23. Convertir minutos a horas.
P24. Aplicar la formula general para a=1, b=2, c=3.
P25. Se desea instalar un cable de red, el cliente pide 30 pies, considerando que se venden en metros,
¿cuántos deberá comprar?
P26. Un campesino siembra trigo en un área cuadrada de 25m., ¿cuál es el largo del cerco frontal en cm?
P27. Resolver x² + 15x - 8 para cualquier variable (X).
P28. Convertir °C a °F.
P29. Si cada salón de la escuela tiene 40 alumnos y son 30 salones ¿Cuantos alumnos son en toda la
escuela?
P30. Si Juan trabaja 5 días a la semana y descansa 2 ¿Cuantos días trabajo en 4 años?
P31. Si en una oficina se procesan 20 facturas cada 10 minutos ¿cuántas se procesaran si se trabajan 5
horas?
P32. Si una empresa tiene __ de activo y un pasivo de __ ¿Cual es su capital? Formula (C = A-P)
P33. Calcule el voltaje de un circuito dada una intensidad I y una resistencia R. Formula (V=IR)
P34. Calcule la frecuencia de una onda que circula con un tiempo t. Formula (F=1/t)
P35. Calcule la potencia de un circuito con un voltaje V y una intensidad I. Formula (f = VI)
P36. Calcule el total que tendrá que pagar una persona que va al cine dependiendo del no. de boletos a
comprar y el precio.
P37. Calcule las anualidades que tendrá que pagar una persona que pidió un préstamo. Dependiendo del
tiempo que el elija y el interés por año. Formula (Anualidad= (Préstamo/Tiempo)+interés)
Página 8 de 104
P38. Determinar cuánto ganara una persona en base a las horas trabajadas. Tomando en cuenta el pago por
hora.
P39. Convertir horas a segundos.
P40. Calcular la fuerza. Formula (fuerza = trabajo / tiempo)
Fuente
2010
C++ - Constantes, Variables e Identificadores

Los algoritmos y programas de PC tienen algunos valores que no deben cambiar
durante la ejecución del programa. Esos valores son conocidos como constantes.
Existen otros valores que van a cambiar durante la ejecución del programa o la prueba
del algoritmo (prueba de escritorio) ; a estos valores se les llama variables.
Por lo tanto:
CONSTANTES: Son datos que permanecen sin cambios durante todo el desarrollo del
algoritmo o ejecución del programa. Por ejemplo, si tenemos la fórmula para resolver
el área de un triangulo.
A = (b * h)/2;
Independientemente de los valores que tengan la base y la altura, la formula nos dice
que se tiene que dividir entre dos, ese numero dos nunca cambiara de valor, por lo
tanto es una constante.
VARIABLES: Son un objeto de partida de datos cuyo valor puede cambiar en el

desarrollo del algoritmo o ejecución del programa. Usando el ejemplo de la fórmula del
área del triangulo, si las dimensiones de este cambian, entonces la base (b) y la altura
(h) van a cambiar de valor, por eso decimos que ambas son variables.
IDENTIFICADORES: Son los nombres que reciben las variables y algunas constantes,
están formados de caracteres alfanuméricos, de los cuales el primero tiene que ser una
letra.
Reglas Para Asignar Identificadores
 Siempre tienen que iniciar con una letra.

 Pueden tener letras y números.
 No se permiten caracteres especiales a excepción de “_”.
 No debe haber espacios en blanco.
 Deben ser significativos y tener relación con el objeto que representan.
Página 9 de 104
Ejemplos
B236 - NOMBRE - DIRECCION - NO_CONTROL - PRECIO
· NOMBRE: Puede representar el nombre una persona.

· NO_CONTROL: Puede representar el número de control de un alumno.
2010
· PRECIO: Puede representar el precio de un artículo.
Se puede asignar nombre a algunas constantes de uso común en cálculos

matemáticos, financieros, etc. Como nombre para el valor de ∏, Pi = 3.1416.
Para concluir, imaginemos que la siguiente figura es la memoria principal de la PC y

que en ella se encuentran almacenadas diferentes direcciones, las variables A, b, h y la
constante Pi:
C++ - Tipos De Datos

El objetivo principal de toda computadora es el manejo de datos. Estos datos pueden
ser calificaciones de una clase o las cifras de ventas de una empresa. Un dato es la
expresión general que describe los objetos con los cuales opera una PC. La mayoría de
las PC trabajan con varios tipos (modos) de datos. Los algoritmos/programas
correspondientes trabajan sobre esos datos.
La acción de las instrucciones ejecutables de las computadoras se ve en cambios en los

valores de las partidas de datos. Los datos de entrada se transforman por el algoritmo,
después de las etapas intermedias, en datos de salida.
En el proceso de solución de problemas, el diseño de la estructura de datos es tan

importante como el diseño del algoritmo.
Página 10 de 104
Los tipos de datos son:

 Numéricos (Enteros y reales).
 Lógicos (Booleanos).
 Carácter.
2010
DATOS NUMERICOS: El dato numérico es el conjunto de los valores numéricos. Se
manejan de dos formas distintas:
ENTEROS: Es un subconjunto finito de los números enteros. Los enteros son números
completos, no tienen componentes fraccionarios o decimales y pueden ser
negativos/positivos. Los números enteros máximos de una PC suelen ser valores entre
(-32, 768, +32, 767). Los números fuera de este rango son conocidos como números
reales.
REALES: Subconjunto de los números enteros. Siempre tienen un punto decimal y
también pueden ser positivos/negativos. Un número real consta de un entero y una
parte decimal.
Nota: Cada lenguaje de programación tiene diferentes formas de manejar datos numéricos/alfanuméricos.
DATOS LÓGICOS (BOOLEANOS): Aquel tipo de dato solo puede tomar uno de dos
valores: cierto (true) y falso (false). Este tipo de datos se usa para representar
alternativas (Si/No) a ciertas condiciones. Por ejemplo, cuando se pide si un valor
entero es par, la respuesta va a ser cierta o falsa, dependiendo la respuesta.
DATOS CARÁCTER: Es el conjunto finito y ordenado de caracteres que la

computadora reconoce. La mayoría de las PC reconocen los siguientes:
 Caracteres alfabéticos: (A, B, C, …, Z) (a, b, c, …, z)
 Caracteres numéricos: (1, 2, …, 9, 0)
 Caracteres especiales: (+, -, *, /, ^, ., ;, <, >, $, …)
Resumiendo:
C++ - Operadores Aritméticos
Permiten la realización de operaciones matemáticas con los valores
(variables/constantes). Pueden ser usados con datos enteros o reales.
Página 11 de 104
2010
C++ - Operador Cast
Se puede forzar un dato, variable o una expresión a convertirse o cambiarse a un

nuevo tipo de dato.
El operador cast realiza este proceso, es decir convierte datos, variables o expresiones
a un nuevo tipo de dato, su formato es: nvotipo (dato , var, exp);
Ejemplo:
// declaración
int alfa;
// Asignación
alfa=20;
// Cambio de tipo
float (alfa);
Ejemplo: int (3.1416);
En este ejemplo se está convirtiendo un valor float a uno int, recordar que en este
caso ya no se tendrán los decimales.
Como nota importante este operador resuelve los dos problemas pendientes:
Página 12 de 104
1. El de la división entre enteros.
2. El tipo de dato especifico que requieren las funciones.
Ejemplos:
a) // Declaración
float alfa;
2010
// Operación
alfa = float (23)/5;
// Pero en estos casos es preferible
alfa=23/5.0;
En toda división recordar agregar a uno de los dos valores el (.0), solo que los dos
elementos sean variables entonces usar el operador cast con una de ellas.
b)// Declaración
double potencia;
// Operación
potencia = pow ( double (5), double (3));
Como se observa en el ejemplo, se puede usar pow(), directamente con los datos,
argumentos o parámetros requeridos , si estos son numéricos, pero transformándolos
con el operador cast.
Esto también va a permitir evaluar expresiones matemáticas de manera mas directa y
sencilla, solo recordando usar un pow() por cada potencia y cada raíz de la ecuación,
ejemplo:
Sea y = 3x3 - 3√x + 4x2 dentro de un programa esto se resuelve con lo siguiente... Página 13 de 104
// área de declaración de variables
double y, x;
// área de captura de datos
capturar el valor de x;
2010
// área de operaciones
y = 3 * pow(x, double (3)) - pow(x, (1/3.0)) + 4 * pow(x, double(2) );
// área de despliegue de resultados
desplegar x, y
Realizar los siguientes programas en C++ utilizando la funcion Pow
1. y = 4x3 – 3x2 + 2x -5
2. y = 53 √x + 4x2 + 6
3. y = -85 √x3 – 3x3 + 6x2 - 7
Fuente
C++ - Jerarquía De Operaciones

El problema de no tomar en cuenta la jerarquía de los operadores al plantear y
resolver una operación casi siempre conduce a resultados muchas veces equivocados
como estos.
Ejemplos:
2+ 3* 4 = 20 (incorrecto)
= 14 (correcto)
Si calif1=60 y calif2=80 y si entonces en programa se usa la siguiente fórmula:

Promedio=calif1 + calif2/2
El programa daría como resultado promedio = 100
Se debe recordar siempre que antes de plantear una formula en un programa se

deberá evaluar con el siguiente apartado.
Página 14 de 104
Jerarquía de operaciones
1.- Paréntesis
2.- Potencias y raíces
3.- Multiplicaciones y divisiones
4.- Sumas y restas
5.- Dos o más de la misma jerarquía u orden, entonces resolver de izquierda a derecha
Nota1: Si se quiere alterar el orden normal de operaciones, entonces usar paréntesis.

2010
Nota2: Tampoco es bueno usar paréntesis de mas en una operación, esto solo indica que no se evalúo bien
la formula, como en el siguiente ejemplo: área = (base*altura) / 2.0. Aquí los paréntesis están de más,
porque por orden de operaciones, multiplicación y división tienen la misma jerarquía y entonces se resuelven
de izquierda a derecha, en otras palabras ni que falten paréntesis ni que sobren paréntesis.
C++ - Compilador/Editor de C++

Para poder generar programas/aplicaciones vamos a utilizar el compilador turbo c++ el
cual vamos a poder descargar de la siguiente dirección.
Descarga Aquí Turbo C++
Una descripción del software: Turbo C es un entorno de desarrollo

integrado y compilador desarrollado por Borland para programar en lenguaje C. Su
primera versión salió en el año 1987, a la que siguieron las versiones 1.5 y 2.0,
publicadas en el año 1989. Fue el compilador más popular para desarrollar en C en
entornos MS-DOS. Se le considera el primer IDE para C disponible para dicha
plataforma. Fue sustituido por Turbo C++ en 1990.
¿Cómo Instalar?
1. Descargar
2. Descomprimir (usando WinRar)
3. Dentro de la carpeta ejecutamos el archivo INSTALL.EXE (Ver Imágen)
4. En el instalador vemos las notas de instalación del Turbo C++, solo damos clic en
skip.
5. Vemos la lista con el el/los disco(s) duro(s) de nuestra PC, no movemos nada, y
Página 15 de 104
damos clic en Continue.
6. En esta pantalla vemos donde se instalara en el disco duro, que

es C:\TCWIN45 solo den clic a Continue.
7. Damos Clic en Install, y veremos como el instalador hace su trabajo.

2010
8. Dan clic a los siguientes continues/ok que les aparezcan, y tienen un plazo de 15
días para registrarlo.
9. Vamos a Mi Pc, abrimos el disco local C, abrimos la carpeta TCWIN45, luego abrimos
la carpeta BIN, buscamos dentro de esta el archivo TCW.EXE. Ejecutenlo, si lograron
llegar hasta aqui, esto será lo que les aparecera en su ventana. (Ver Imágen)
10. Listo, este será el compilador que usaremos para realizar nuestros ejemplos.
C++ - Aplicaciones
Reglas para escribir un programa en Turbo C++:

a) Comienza con las instrucciones #include y cada una de ellas es una librería de
instrucciones especializadas en tareas especificas.
b) Todas las palabras reservadas del lenguaje deben ser minúsculas: main, include,
printf.
c) Todo programa comienza con una función llamada void main().
d) El cuerpo de instrucciones del programa deberá encerrarse entre llaves.
e) Todas las instrucciones ejecutables terminan con punto y coma.
f) Los comentarios se ponen encerrados entre /* comentario */ ó //comentario
g) La declaración de variables ocupa la primera posición.
h) Se utiliza una instrucción llamada printf(); para desplegar mensajes u otros
elementos en el dispositivo de salida estándar(pantalla).
i) Se utiliza una instrucción llamada scanf(); para capturar datos desde el dispositivo
de entrada estándar (teclado).
j) Se usa una instrucción getchar(); al final para detener la pantalla hasta que el
usuario pulse cualquier tecla para continuar, porque si no el programa responde tan
aprisa que no se alcanza a ver y se regresa al editor.
k) C++ es un lenguaje case-sensitive, es decir trata a mayúsculas y minúsculas
como caracteres diferentes.
l) Ya creadas y cargadas las variables normales se efectúan los procesos u operaciones
normales con ellas y al final se construye una página normal HTML con los resultados.
Especificaciones de C++
Página 16 de 104
Instrucción printf(); : Es una de las más poderosas herramientas de despliegue de

datos que posee el lenguaje.
Su formato completo es: printf (“string de control”, lista de variables);
Donde string de control puede ser:

2010
a).- Mensaje o texto
printf(“¡Hola! Mi nombre es Rodolfo.”);
printf(”%d”, variable-int);
printf(” Los datos son: %d, %f, %s ”,variable-int, variable-float, variable-string)
Nota: No se recomienda usar más de 70 caracteres por despliegue.
b).- Secuencias de escape: Estas instrucciones proveen de mecanismos de control

para diversas tareas, existe una gran variedad de secuencias de escape, las mas
usuales son las siguientes.
\n nuevo renglón
\t tabulador horizontal
\b retroceso
\r primera posición de línea
\a campanilla
\” despliega comillas
\` despliega apóstrofe
c).- Códigos de formato: Estos códigos de formatos dentro de la string de control le

indican al compilador que deber sustituir en esa posición el valor de la variable
indicada, además se deberá recordar que existe un código de formato apropiado para
cada tipo de dato existente.
Código de tipo de salida de datos:
%d Valor entero enteros con signo
%u Valor entero sin signo
%f Valor con decimales
%e Valor con notación exponencial e

Página 17 de 104
%E Valor con notación exponencial E
%g En este caso el compilador decide si usa %f ó %e
%G En este caso el compilador decide si usa %f o %E
%c Valor de un solo carácter

2010
%s Valor que se conforma por un conjunto de caracteres.
Nota: Para el caso de estos códigos porcientos también es posible agregar la cantidad de entero y decimales
que se quiere que se despliegue en la salida con el siguiente formato: %cantidad-entero.cantidad-decimal
carácter apropiado.
Instrucción scanf(); : Esta instrucción permite que el dato entrado desde el teclado
sea capturado y almacenado en la variable correspondiente.
Su formato completo es: scanf(“string de control”, lista de variables);
En los códigos de formato (%) podemos observar que a diferencia de la

instrucciónprintf(), scanf() solo puede llevar los códigos % , dentro de las comillas ” ”.
En el caso más sencillo dentro del string de control se pone el porciento con el carácter
apropiado al tipo de dato y en la lista de variables una variable ya declarada de ese
mismo tipo. Se deberá tener en cuenta siempre lo siguiente:
a) La cantidad de variables de lista de variables debe ser igual en cantidad que los códigos porciento %.
b) Todas las variables de tipo numérico dentro de scanf, no de printf, deberán ser precedidas del signo
ampersand (&). Ejemplo: scanf(”%d”, &area);
c) %s en scanf solo alcanza a capturar de la string hasta el primer espacio en blanco.
d) El formato por ciento en scanf y printf para tipos long int sera %ld.
e) El formato por ciento para tipos doubles en scanf y printf es %lf.
El siguiente programa se deberá crear usando el editor del Turbo C++ y grabarlo como
prog1.cpp en el folder de su preferencia, para ejecutarlo usar la opción Debug-
>Run del propio editor. Aquí podemos ver la ejecución de este mismo:
Programa en C++ que calcula el área de un rectangulo.

Código fuente
Página 18 de 104
#include <stdio.h>
void main()
{
//Aqui se van a declarar las variables
int base1, altura; float area;
//Aqui vamos a pedirle los datos al usuario
printf("Progrma que calcula el area de un rectangulo\n");
2010
printf("Por Favor Ingrese el valor de la base: ");
scanf("%d",&base1);
printf("Por Favor Ingrese el valor de la altura: ");
scanf("%d",&altura);
//En esta seccion la computadora hara los calculos
area=base1 * altura / 2.0;
//Aqui vamos a desplegarle al usuario en pantalla el resultado final
printf("El area del rectangulo es: %0.2f.",area);
getchar();getchar();
}
Captura de Pantalla
DESCARGA PROGRAMA AQUI
Fuente
C++ - Otras Funciones De Entrada/Salida
Captura:
Getchar();
Getch();
Página 19 de 104
Getche();
Estas tres instrucciones están especializadas en captura de un solo carácter y
sustituyen a scanf y a %c en situaciones especiales. Estas funciones trabajan por
igualación, es decir para usarse de la siguiente manera: varchar=getchar();
Ejemplo:
char vocal;
vocal= getchar();
Nota: Dependiendo del sistema operativo en ocasiones un getchar() no atrapa el carácter a la primera vez,
2010
en este caso usar más de un getchar en forma continua. En este caso poner mas getchar(); después del
primer getchar(); hasta que capture el carácter o también para detener la corrida.
Getchar es una macro que lee un caracter de el teclado y regresa el caracter leido.
La diferencia es que getchar y getche devuelven el carácter leído a la pantalla y
el getchno devuelve el carácter a la pantalla. Estas instrucciones deberán usarse en las
siguientes situaciones:
a) Cuando la captura es de un solo carácter
b) También para retener pantallas en este caso sin igualdad
c) Para evitar los saltos en capturas, cuando se captura un entero y una string después, es este caso es
conveniente usar una serie de getchar(); para quitar el carácter de return del teclado, en particular es
conveniente usar un getchar después de un scanf(entero).
gets();
Esta función es la alternativa para captura de strings que tengan espacios en blanco
intermedios cosa que scanf (%s) no puede hacer. Su formato completo es:
gets(variable string);
Despliegue:
Putch();
Putchar();
Estas instrucciones despliegan directamente un carácter en el dispositivo de salida
estándar. A diferencia de getchar, getch y getche, estas instrucciones si llevan un
argumento. Por ejemplo:
putchar(alfa);
putchar('\n');
putchar('\064');
puts(variable string);
Es la función complemento de gets esta función despliega una string en el dispositivo
de salida estándar y debe llevar el argumento o parámetro. Por ejemplo:
puts(nombre);
puts(“pato”);
Programa en C++ que usa Funciones de Entrada/Salida

Código Fuente
Página 20 de 104
#include <stdio.h>
void main()
//declaracion de variables
2010
int var1, var2,var3;
char var4[15], var5[15];
/* Capturar y Observar en que parte se ponen getchars unos

para limpiar return y otros para para parar la pantalla */
printf("Ingrese valor entero: ");
scanf("%d",&var1);getchar();
printf("Ingrese valor caracter: ");
scanf("%s",&var4);
scanf("%d",&var2);
scanf("%d",&var3); getchar();
printf("Ingrese valor caracter: ");
gets(var5);
//despliegue
printf("\n\nPrimer entero: %d \n",var1);
printf("Primer caracter: %s \n",var4);

Página 21 de 104
printf("Segundo entero: %d \n" ,var2);
printf("Tercer entero: %d \n",var3);
printf("Segundo caracter: %s \n",var5);
getchar();
2010
Captura de Pantalla
Fuente
C++ - Formato De Pantalla
Para poder utilizar el comando para limpiar la pantalla, usaremos la

librería#include<conio.h>
1.- clrscr();
Limpia pantalla - Esta instrucción no ocupa aclaración.
Página 22 de 104
2.- gotoxy(numero de columna, numero de renglón);

Posiciona cursor en lugar indicado - Recordar que una consola normal tiene 24 renglones y 80 columnas.
Nota1: Usar el comando clrscr(); después de capturar los datos y antes de desplegar
los resultados.
Nota2: En particular poner un gotoxy(); antes de cada printf(); en el programa.
2010
Fuente
C++ - Palabras Reservadas De C++

Int: Un tipo de dato entero con signo de 16, 32 ó 64 bits, dependiendo del compilador. En sistemas de 16
bits su rango de valores es de -32763 a 32762. Para sistemas de 32 bits el rango se de -2147483648 a
2147483647. En sistemas de 64 bits el rango será de 1.7+/-308. Actualmente son muy pocos los
compiladores con capacidad de manejar datos de tipo int de 64 bits, lo usual son sistemas de 16 ó 32 bits.
Un número real de 32 bits cuyo rango vá de 3.4+/-38. Generalmente su precisión es de 7 dígitos.
Long: Un número entero de 32 bits de rango igual a -2147483648 a 2147483647.
Double: Un número de 64 bits y de rango igual a 1.7+/-308 con una precisión en general de 15 dígitos.
Short: Un número de 16 bits de rango igual a -32763 a 32762.
Char: Un tipo de dato específico para manejo de caracteres de 8 bits de rango igual a -128 a 127.
Unsigned: Modificador que se aplica a los tipos de datos enlistados arriba, su efecto es eliminar el signo a el
tipo de dato aplicado, por ejemplo, para un tipo de dato int podemos especificar unsigned int en cuyo caso el
rango para el tipo de dato int cambia de ser -2147483648 a 2147483647, por éste nuevo rango: 0 a
4294967295.
Signed: Modificador que forza al compilador a utilizar un tipo de dato con signo si antes se declaró como de
tipo unsigned.
Volatile: Especifica una variable que almacena datos cuyo contenido puede cambiar en cualquier momento
sea por la acción del programa ó como reacción de la interacción del usuario con el programa.
Const: Especifica una variable cuyo contenido no puede cambiar bajo ninguna circunstancia.
Enum: Especifica un conjunto de variables que toman valores en un orden específico

y consecutivo.
Static: Especifica una variable que sólo puede cambiar por efecto del programa.
Typedef: Define un tipo de dato para fácil manejo del programador basado en los datos definidos por el
compilador. Muy útil cuando se programa en lenguajes diferentes al inglés.
Sizeof: Función que devuelve el tamaño en bytes del tipo de dato al que se aplica.
If: Instrucción condicional.
Else: Se utiliza conjuntamente con la instrucción if.
Switch: Estructura condicional.
Case: Define los elementos de una estructura condicional switch.
Default: Define las acciones a ejecutar no especificadas por una instrucción case dentro de una estructura
condicional switch.
Break: Obliga a salir de una estructura condicional switch.
Página 23 de 104
For: Bucle que se ejecuta tantas veces como se cumplan las condiciones especificadas dentro del paréntesis
de la instrucción.
While: Bucle condicional que se ejecuta conforme la condición entre el paréntesis sea cierta.
Do: Bucle condicional que se ejecuta en conjunto con la instrucción while.

Continue: Instrucción para suspender un ciclo de un bucle.
Goto: Instrucción que ejecuta un salto a otra parte del código.
Struct: Define una estructura.
Return: Especifica el dato que devuelve una función.
2010
Union: Un tipo de dato compuesto de otros datos definidos, consulte Estructuras en C
Register: Permite almacenar un dato en el registro del sistema.
Extern: Especifica una variable ó función que se encuentra en un archivo fuente diferente.
Void: Especifica que una función no devuelve valor alguno.
Auto: Una de las cuatro clases de almacenamiento de datos, auto es la opción por defecto, las otras tres son
register, static y extern.
Stream: flujo de datos.
Cin: entrada estándar.
Cout: salida estándar
Cerr: salida de mensajes de error.

Streambuf: operación de I/O a bajo nivel.
Istream: operación de I/O a alto nivel.
Ostream: operación de I/O a alto nivel.
Iostream: operación de I/O a alto nivel.
Ios: clase para el manejo de la I/O a alto nivel.
Setf(): método de la clase ios para inicializar los indic de formato.
Flags(): metodo de la clase ios para inicializar los indic de formato.
Unsetf(): metodo de la clase ios para desactivar los indic de formato.
Width(): función declarada en las clases istream, ostream e iostream.
Precision(): función declarada en las clases istream, ostream e iostream.
Fill(): función declarada en las clases istream, ostream e iostream.

Endl: manipulador sin argumentos definidos en iomanip.h
Flush: manipulador sin argumentos definidos en iomanip.h
<< ó >>: operadores de inserción o extracción de flujo.
Ifstream: Clase necesaria para la inserción de flujo de datos en fichs.

Página 24 de 104
Ofstream: Clase necesaria para la extracción de flujo de datos en fichs.
Fstream: Clase necesaria para la I/O de flujo de datos en fichs.
Fstream.h: Librería para poder leer o escribir desde ficheros.
dec, hex y oct: establecen base para enteros ws: se saltan los blancos iníciales.
Endl: se imprime un „n‟ y se vacía el buffer de salida.

2010
Flush: se vacía el buffer de salida.
Setw(int w): establece la anchura mínima de campo.
Setprecision(int p): establece el número de cifras.

Setfill(char ch): establece el carácter de relleno.
Setiosflag(long i): equivale al indicador setf();
Unsetiosflag(long i): equivale a unsetf();
Skipws: descartan los blancos iníciales a la entrada.
Left: la salida se alinea a la izquierda.
Rigth: la salida se alinea a la derecha.
Internal: alinea el signo y los caracteres indicativos de la base por la izquierda y las cifras por la derecha.
Dec: salida decimal para enteros (defecto)
Oct: salida octal para enteros.
Hex: salida hexadecimal al para enteros.
Show: base se muestra la base de los valores numéricos.
Showpoint: se muestra el punto decimal.
Uppercase: los caracteres de formato aparecen en mayúsculas.
Showpos: se muestra el signo (+) en los valores positivos.
Scientific: notación científica para coma flotante.
Fixed: notación normal para coma flotante.
Unitbuf: salida sin buffer (se vuelca cada operación)
Adjustfield: es una combinación excluyente de left, rigth e internal.
Basefield: una combinación excluyente de dec, oct e hex.
Floatfield: es una combinación excluyente scientific y fixed.
Bcstring: Cadena híbrida BSTR-C-C++, aprovecha las bondades de los tres tipos de cadenas y las
proporciona en una sola clase.
Amvutils1: Plantillas para comparación de cadenas estilo C y de apuntadores a objetos.
Application: Base para aplicaciones que se invocan en main()
Shell: Base para aplicaciones que se invocan en main() y funcionan como intérprete de órdenes.
Página 25 de 104
ChessServer: Permite a dos personas jugar ajedrez.
MagicSquare: Código fuente del programa anterior.
Sorting: Código fuente del algoritmo de ordenamiento quicksort.
Encoder: Código fuente del algoritmo de cifrado XOR.
Maps: Ejemplo de uso de mapas.

2010
Book: Crea un libro desde un archivo de texto y permite explorarlo sección por sección
cpp.txt
Algorithm: Algoritmos útiles para contenedores STL.

Allocator: Similar a la clase allocator de la STL.
Amvdefs: Alias para tipos del espacio de nombres std.
BinaryTree: Árbol binario.
Bitarray: Arreglo de bits (útil para valores booleanos).
Complex: Permite manejar números complejos en forma binómica o polar.
Converters: Convertidores de archivos.
RemoveComments(...): Quita los comentarios de un archivo CPP.
Cpp2html(...): Convierte un archivo CPP a formato HTML, con las palabras reservadas de color azul, los
comentarios en verde, las cadenas de caracteres en gris y el resto del
código en negro.
html2html(...): Convierte el código fuente de un archivo HTML a un formato para
ser presentado como texto dentro de otro archivo HTML.
FloatBCD: Tipo para el manejo de números BCD de punto flotante.
Function: Clase para funciones usadas por la clase expression.
Matrix: Tipo para manipular matrices.

MemoryAMV: Funciones para manejo de memoria.
Pointer e ipointer: Tipos para manejo de apuntadores en contenedores.
REEvaluator: Evaluador de expresiones regulares por medio de autómatas finitos no
deterministas (AFNs).
Stack: Similar a la clase stack de la STL.
Streambufw: Permite el acceso al búfer de un streambuf.
String: Tipo para el manejo de cadenas de caracteres.

Tree: Árbol con N nodos hijos y M niveles de profundidad.
Fuente
C++ - Funciones C++
Las funciones son subprogramas o módulos que realizan una tarea específica y que
pueden ser invocados desde cualquier parte del programa enviando valores por medio
de parámetros, y que tienen la capacidad de devolver valores explícitos.
La función es una estructura autónoma. La diferencia radica en que la función se

relaciona especificando su nombre en una expresión, como si fuera una variable
ordinaria de tipo simple. Las funciones se dividen en estándares por el usuario.
Página 26 de 104
Funciones definidas por el usuario

Son funciones que puede definirlas el programador con el propósito de ejecutar alguna
función específica, y que por lo general se usan cuando se trata de hacer algún cálculo
que será requerido en varias ocasiones en la parte principal del algoritmo.
El nombre de la función puede estar seguido de uno o más parámetros actuales

encerrados entre paréntesis. Por lo general transfieren datos a parámetros tipo valor.
2010
Apartado 2 - Instrucciones De Control De Programa en C++

C++ - Introducción a Instrucciones De Control De Programa
en C++
Las instrucciones de control de programa permiten alterar la secuencia normal de
ejecución de un programa.
Estas instrucciones se dividen en tres grandes categorías:
Instrucciones Condicionales:
En C++ se implementan con las instrucciones if() y switch().
Instrucciones de ciclos:
En C++ se implementan con las instrucciones for, while, do-while.
Instrucción de salto incondicional goto.
C++ - Instrucciones Condicionales
Una de las más poderosas características de cualquier computador es la capacidad que

tiene de tomar decisiones.
Es decir al comparar dos alternativas diferentes el computador puede tomar una

decisión, basándose en la evaluación que hace de alguna condición.
Sintaxis de instrucciones condicionales:
Página 27 de 104
2010
Ejemplos:
Si Edad >= 18 Entonces
Imprimir “Mayor de Edad.”
Si no
Imprimir “Menor de Edad.”
Fin si
En el ejemplo pudimos observar que de las dos opciones disponibles que el

computador tiene, su elección dependerá de la evaluación que el computador hace con
y de la condición. Todo lenguaje de programación debe tener instrucciones que
permitan formar condiciones e instrucciones que pueden evaluar esas condiciones.
Como se observa son cuatro partes bien diferenciadas entre sí.
 La propia instrucción condicional en si

 La condición
 El grupo cierto de instrucciones
 El grupo falso de instrucciones
Cuando el computador evalúa una condición, el resultado de esa evaluación solo es
evaluado de dos maneras o la condición es CIERTA o la condición es FALSA.
Esto dependerá del valor que tenga asignado o que se haya capturado para la variable
que está en la condición, por ejemplo si se capturo 18 en la edad del ejemplo,
entonces el computador indicaría que la condición es CIERTA, pero en otro caso, si a la
variable sueldo primero se le asigno un valor de 17 o menos entonces el computador
indicaría que la condición es FALSA.
Página 28 de 104
Ya dependiendo del resultado de la evaluación, el computador ejecuta las instrucciones

contenidas en la parte CIERTA o en la parte FALSA de la condición.
2010
C++ - Condiciones Simples
Una condición o decisión indica operaciones lógicas, o de comparación entre datos
(normalmente dos) y en función del resultado de la misma determina cual de los
distintos cambios alternativos del programa se debe seguir, normalmente tiene dos
salidas (respuesta SI o NO).
Operadores Relacionales
Condición Selectiva Simple
Son aquellas que solamente tienen una condición para evaluar y el resultado de la
evaluación solamente un verdadero. Su sintaxis es la siguiente:
<Valor o variable> <Operador Relacional> <Valor o variable>
Por ejemplo:
A <- 8
B <- 6
A > 13 Falso
6 <= B Verdadero
A = B Falso
Página 29 de 104
8 <> 6 Verdadero
2010
C++ - Instrucción If
Es la instrucción condicional más usada en los diversos lenguajes de programación, su
formato completo y de trabajo en C++ es:
If (<condición>) <instrucción>; if(<condición>)
{<instrucción1>;
<instrucción2>;}
Programa en C++ que utiliza el ciclo If

Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
// Declaracion de variables
int edad;
char ciudad[30];
// Limpiar Pantalla
clrscr();
// Capturar datos
gotoxy(5,1);printf("Ingresa la edad: ");
scanf("%d",&edad);getchar();
gotoxy(5,2);printf("Ingresa la ciudad: ");
Página 30 de 104
gets(ciudad);
// Ciclo If para la edad

if( edad>=18)
{ gotoxy(5,5);puts("Eres mayor de edad."); }
else{ gotoxy(5,5);puts("Eres menor de edad."); };
// Ciclo If para la ciudad

2010
if( strcmp(ciudad,"Tijuana")==0)
{ gotoxy(5,6);puts("Eres de Tijuana."); }
else
{gotoxy(5,6); puts("No eres de Tijuana.");};
getchar();
}
Captura de Pantalla
Práctica - Realizar los siguientes programas en C++

P1. Capturar un número cualesquiera e informar si es o no es mayor de 100.
P2.Capturar un numero entero cualesquiera e informar si es o no es múltiplo de 4 (recordar el operador mod(%),

Página 31 de 104
analizado en el tema de operadores aritméticos).
P3. Capturar los cinco datos más importantes de un Empleado, incluyendo el sueldo diario y los días trabajados ,
desplegarle su cheque semanal solo si ganó más de $500.00 en la semana, en caso contrario desplegarle un bono
de despensa semanal de $150.00 .
P4. Capturar los datos más importantes de un estudiante incluyendo tres calificaciones, una página que contiene
una boleta de calificaciones es llamada si el estudiante es de la carrera de medicina, en caso contrario otra pagina
despliega un oficio citando a los padres del estudiante a una plática amistosa con los maestros de la escuela.
2010
P5. Capturar los datos más importantes de una mercancía cualquiera, incluyendo cantidad, precio, etc., desplegar
una orden de compra, solo si el producto es de origen nacional, en caso contrario no hacer nada.
Fuente
C++ - Condiciones Compuestas

Son aquellas que evalúan más de una condición en una sola expresión, para esto
hacen uso de los operadores lógicos.
Tabla de Verdad de los operadores lógicos
La tabla de verdad es la misma en C++ y los operadores serían:
Página 32 de 104
2010
Sintaxis de una condición compuesta
<condición 1> <operador lógico> <condición 2>
Por ejemplo:
A <- 8
B <-6
A>13 o B=6
F V = V
A>13 y B=6
F V = F
No A>B
V = F
Sintaxis para la estructura de una Condición Compuesta
Si <condición 1> <operador lógico> <condición 2> Entonces
<bloque de instrucciones 1>
Si no

Página 33 de 104
Fin Si
2010
Sintaxis para las condiciones en C++ cuando hay una o más instrucciones a
ejecutar
P1. Construir un programa que capture un número cualesquiera e informe si es o no es mayor de
50 y múltiplo de tres. (Solo escribir el mensaje de respuesta de manera muy clara y esto resuelve
el problema)
P2.Construir un programa que indique si un numero es un par positivo.
P3. Capturar los datos de una mercancía cualquiera incluyendo su cantidad en

Página 34 de 104
existencia, desplegar una orden de compra si la cantidad en existencia del producto es

menor que el punto de reorden, o si el origen del producto es nacional.
P4. Construir un programa que capture los datos de un empleado, desplegar su cheque
semanal si gana más de $500.00 y si esta en el departamento de producción, en caso
contrario desplegarle un bono de despensa del 25% de su sueldo semanal.
2010
Fuente
C++ - Instrucción Switch ()

Cuando se llega a tener una gran cantidad de condiciones el programa se vuelve muy
confuso, de manera que tenemos que hacer uso de otra estructura que facilite la
solución de un problema con estas características. Es así como aparece la estructura
de decisión múltiple que permite evaluar diferentes casos por medio de un selector, en
este caso la variable que almacena el valor que se busca, que buscando rastreando de
la lista de caso, identifica cual mes el que coincide y cuando lo encuentra ejecuta el
bloque de instrucciones correspondiente.
Sintaxis para la estructura de Decisión Múltiple
Seleccionar Caso <selector>
Caso <valor_1>
Caso <valor_2>
Caso <valor_N-1>
<bloque de instrucciones N-1>
Si no
<bloque de instrucciones N>
Fin_Caso
Ejecutara el bloque de instrucciones del caso que coincida con el selector que esta
buscando. Si no coincide ninguno de los casos con el selector ejecuta la parte del Si
Página 35 de 104
no.
Sintaxis para la estructura de Decision Multiple en C++
switch (<selector>)
{
2010
Case expresión:
[instrucción 1;]
[instrucción 2;]
[break;]
Default:
[instrucción 1;]
[instrucción 2;]
Programa en C++ que utiliza el ciclo switch

Código fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
char letra;
// Limpiar pantalla
clrscr();
Página 36 de 104
// Captura de datos
gotoxy(2,1);printf("Ingresa una letra: ");
letra=getchar();getchar();
// Uso de condicion switch()

switch(letra)
{
2010
// Uso de los casos
case 'a': gotoxy(3,2);puts("Abaco");break;
case 'b': gotoxy(2,2);puts("Bueno");break;
case 'c': gotoxy(2,2);puts("Correr");
default:gotoxy(2,2);puts("No hay palabras disponibles...");
}
getchar();
}
Captura de Pantalla
DESCARGA AQUI
P1. Construir un programa en C++ que contenga el siguiente menú
1. Conversión de pesos a dólares
2. Conversión de libras a kilogramos
3. Conversión de kilómetros a millas
4. Fin de menú
P2. Construir un programa que capture un deporte y despliegue dos implementos

deportivos apropiados.
Página 37 de 104
P3. Programa que evalué el área de las siguientes figuras
1. Cuadrado
2. Rectángulo
3. Triangulo
4. Circulo
2010
5. Fin del menú
C++ - Ciclo For

Son un conjunto de instrucciones para ciclos, las cuales resuelven el problema de
repetir todo el programa o cierta parte del programa más de una vez.
Este ciclo es uno de los más usados para repetir una secuencia de instrucciones, sobre
todo cuando se conoce la cantidad exacta de veces que se quiere que se ejecute una
instrucción simple o compuesta.
Su formato general es:
for (inicialización; condición; incremento)
{ instrucciones; };
 La condición es una expresión relacional que evalúa la variable de control de

ciclo contra un valor final o de parada que determina cuando debe acabar el
ciclo.
 El incremento define la manera en que la variable de control de ciclo debe
cambiar cada vez que el computador repite un ciclo.
 Se deben separar esos 3 argumentos con punto y coma (;)
Programa en C++ que utiliza el ciclo for

Código fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
Página 38 de 104
void main()
{
// Limpiar pantalla
clrscr();
int x;
2010
// Instruccion for
for(x=1;x<=10;x=x+1)
{gotoxy(1, x+2); printf("%d http://descarga-tareas.blogspot.com/",x);};
getchar();
}
Captura de pantalla
DESCARGA AQUI
P1. Construir un programa que despliegue los números del 20 al 30.
P2. Desplegar los enteros entre 50 y 30 acompañados de su potencia cuadrada y raíz

cubica respectiva.
P3. Desplegar los múltiplos de 5, entre 10 y 50, acompañados de su factorial y

logaritmo respectivo.
P4. Desplegar la tabla de multiplicar que el usuario indique.

Página 39 de 104
P5. Evaluar la función y=5x^2 + 3x + 8 cuando x–> -3 -> 10.
Fuente
2010
C++ - Ciclo While
En este ciclo el cuerpo de instrucciones se ejecuta mientras una condición permanezca
como verdadera. Sin embargo, en el momento en que la condición se convierte en
falsa el ciclo termina.
Cargar o inicializar variable de condición;
while(condición)
Grupo cierto de instrucciones;
Instrucción(es) para salir del ciclo;
};
Nota: Un error muy común con el uso del ciclo while, es poner un punto y coma(;)
después de la (condición) ejemplo while(condición); ←-esto es y causa un error.
Programa en C++ que utiliza el ciclo while
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
Página 40 de 104
// Limpiar pantalla
clrscr();
2010
int x=1;
// Uso del ciclo while
while(x<=10)
{ gotoxy(2, x+2); printf("%d ¡Descarga Tareas - Visítanos!",x); x++;};
getchar();
Captura de Pantalla
DESCARGA AQUI
P1. Desplegar enteros entre 50 y 80.
P2. Desplegar múltiplos de 4 entre 60 y 20 acompañados de su logaritmos de base 10

y base e respectivos.
P3. Construir la tabla de dividir que el usuario indique.
P4. Evaluar la función y = x2 + 2x + x para el rango de valores de x de -3 a +5

Página 41 de 104
Fuente
2010
C++ - Ciclo Do... While
Su diferencia básica con el ciclo while es que la prueba de condición es hecha al
finalizar el ciclo, es decir las instrucciones se ejecutan cuando menos una vez porque
primero ejecuta las instrucciones y al final evalúa la condición; también se le conoce
por esta razón como ciclo de condición de salida.
Cargar o inicializar variable de condición;
do {
Grupo cierto de instrucción(es);
Instrucción(es) de rompimiento de ciclo;
} while (condición);
Programa en C++ que utiliza el ciclo do..while
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
clrscr();
int x=1;
Página 42 de 104
// Uso del ciclo do...while

do{
gotoxy(1, x+1);
printf("%d Descarga Tareas",x);
x++; } while(x<=10);
getchar();
}
2010
Captura de Pantalla
DESCARGA AQUI

P1. Programa en C++ que use ciclo Do...While que despliegue el mensaje Hola Mundo
10 veces.
Fuente
C++ - Conclusiones Acerca De Ciclos
A manera de resumen, algunas de las conclusiones a las que llegamos con este
apartado son, que dado un problema cualquiera, debemos saber cual(es) ciclo(s) se
debe(n) usar para resolverse. A continuación las conclusiones del apartado.
 Si se conoce la cantidad exacta de veces que se quiere que se ejecute el ciclo o

si el programa de alguna manera puede calcularla. Usar el ciclo for.
 Si se desconoce la cantidad de veces a repetir el ciclo o se quiere mayor control
sobre la salida o terminación del mismo. Usar el ciclo while.
Página 43 de 104
 Si se quiere que al menos una vez se ejecute el ciclo. Usar el ciclo do…while.
Fuente
2010
Apartado 3 - Arreglos en C++
C++ - Introducción a Arreglos en C++
Uno de los problemas más comunes en los diversos sistemas de información es el
tratamiento o procesamiento de un gran volumen de datos o de información. Las
variables manejadas hasta ahora no pueden ayudar a resolver este problema, esto es
debido a que las variables usadas hasta ahora reciben propiamente el nombre
de variables escalares, porque solo permiten almacenar o procesar un dato a la vez.
No tenemos que confundir esto con el tipo de dato o rango de datos que una variable
tiene la capacidad de almacenar.
Por ejemplo si se quiere almacenar nombre y edad de 15 personas con el método

tradicional se ocuparan 30 variables y esto solo es nombre y edad de 15 personas,
agreguen más datos y más personas y ya es tiempo de empezar a analizar otro tipo de
variables. Se ocupan entonces variables que sean capaces de almacenar y manipular
conjuntos de datos a la vez. Las variables de tipo arreglo permiten almacenar y
procesar conjuntos de datos del mismo tipo a la vez.
Cada dato dentro del arreglo se conoce como elemento del arreglo, se simboliza y
procesa (captura, operación, despliegue) usando el nombre del respectivo arreglo y un
subíndice indicando la posición relativa del elemento con respecto a los demás
elementos del arreglo, debemos tener en cuenta que en C++ la primera posición,
elemento o renglón es el 0 (cero).
Ejemplo de Arreglos:
Arreglo nombres
Juan →nombres (0)

Página 44 de 104
Pedro → nombres (1)
Rosa → nombres (2)
José → nombres (3)

2010
Nota: Como podemos ver, los arreglos tienen problemas similares a los de variables normales es decir hay
que declararlos, capturarlos, hacer operaciones con ellos, desplegarlos, compararlos, etc.
Fuente
C++ - Arreglos En C++

En la programación tradicional siempre se manejan dos tipos de arreglos: los arreglos
tipo listas (vectores o unidimensionales) y los arreglos tipo tablas (matrices o
bidimensionales) en ambos casos son variables que permiten almacenar un conjunto
de datos del mismo tipo a la vez, su diferencia es en la cantidad de columnas que cada
uno de estos tipos contiene, como en los siguientes ejemplos:
Como se observa la diferencia principal entre un arreglo tipo lista y un arreglo tipo
tabla son las cantidades de columnas que contienen.
Nota: Los conceptos manejados aquí están enfocados a los sistemas de información contables financieros
administrativos. En algebra matricial, si son importantes los conceptos de vectores y matrices, pero las
Página 45 de 104
operaciones y métodos son precisamente los del algebra matricial.
Fuente
2010
C++ - Arreglos Tipo Listas
Un arreglo tipo lista se define como una variable que permite almacenar un conjunto
de datos del mismo tipo organizados en una sola columna y uno o más renglones.
También reciben el nombre de vectores en álgebra o arreglos unidimensionales en
programación. Los procesos normales con una lista o con sus elementos incluyen
declarar toda la lista, capturar sus elementos, desplegarlos, realizar operaciones con
ellos, desplegarlos, etc.
Para declarar una lista se usa el siguiente formato:
tipo de dato nombre lista [cantidad de elementos o renglones];
Ejemplos de arreglos tipo lista:
int edades[12];
float sueldos[10];
char carreras[10];
Para crear e inicializar en C++ una lista usar el siguiente formato:
Tipo dato nombre lista [cantidad renglones] = {elementos};
Ejemplo de arreglo tipo lista:
Int edad[5] = { 12,18,20,23,30 };
Float sueldo[3] = { 1.36, 23.67, 77.90 };
Strcpy(carrers[0],”informatica”);strcpy(carreras[1],”sistemas”);
Nota: Recordar que la primera posición o renglón en una lista es la posición o renglón 0 (cero).
Página 46 de 104
Programa en C++ que utiliza un arreglo tipo lista

Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
2010
void main()
{
clrscr();
// Declaracion de arreglos tipo lista

char nombre[3][20]; int edad[3];
// Capturando valores
for (int r=0; r<=2; r++)
{ gotoxy(5, r*2+2); printf(" Ingresa nombre %d: ",r);
gets(nombre[r]);
gotoxy(5, r*2+3); printf("Ingresa edad %d: ",r);
scanf("%d",&edad[r]);
getchar();
};
// Operando
for ( r=0; r<=2; r++) edad[r]=edad[r] *12;
// Desplegando
for ( r=0; r<=2; r++)
{ gotoxy(5, r*2+9); printf("NOMBRE:= %s", nombre[r]);
gotoxy(5, r*2+10); printf("EDAD:=%d",edad[r]);
};
getchar();
}
Captura de Pantalla
Página 47 de 104
DESCARGA AQUI
2010
Nota 1: Captura este procedimiento es similar para despliegue.
Nota 2: Se deberá usar siempre un ciclo for con una variable de control llamada renglón, misma que
también se usa como índice del arreglo.
Nota 3: Recordar que el primer renglón o índice en C++ es el renglón 0.
Nota 4: Siempre que se use un elemento de una lista en C++ con cualquier proceso (captura, despliegue,
operaciones) deberá acompañarse de su índice respectivo.
Nota 5: Para procesar (hacer operaciones con ellos, o comparaciones, etc.) los elementos de la lista, se
deberá usar un ciclo for con una variable de control llamada renglón, misma que se usara también como
índice de la lista.
Nota 6: Para desplegar los elementos de la lista, también se usa un ciclo for con su variable de control
renglón, tal como se muestra en el ejemplo.
Nota 7: El mismo ciclo de proceso o despliegue se puede utilizar para procesar o desplegar los elementos de
más de una lista, siempre y cuando las listas sean del mismo tamaño.
Práctica – Realizar los siguientes programas en C++

P1. Capturar y desplegar 5 precios de productos cualesquiera.
P2.- Capturar 4 sueldos y desplegarlos aumentados en un 25%
Fuente
C++ - String
Las variables string no son más que un caso especial de arreglo de caracteres y como
tales presentan ciertas peculiaridades que no son posibles resolver con métodos
tradicionales. Por ejemplo no es válido usar simples sentencias de asignación o
comparación.
Ejemplo
1.- char nombre [30], copia [nombre]; Esto es válido en C++
copia = nombre; Esto no es válido en C++
2.- if (opción==´si´) Tampoco es válido en C++

Página 48 de 104
Para casos como estos se deberán usar ciertas funciones de manipulación de variables
string que provee el lenguaje C++, estas funciones son:
Librería en Turbo C++: #include <string.h>

2010
 STRCPY(string destino, string original);
Se utiliza para copiar el contenido de un string original en un string de destino.
Ejemplo:
char nombre[30],copia[30];
nombre= getstring(“nombre”);
strcpy(copia,nombre);
strcpy(nombre,”pato”);
 STRCAT(string1,string2);
Encadena o agrega al final de la string1 la string2.
Ejemplo:
char nombre[30],copia[30];
strcpy(nombre,”pepe”);
strcat(nombre,”lopez”);
 STRCMP (string1, string2);
Se utiliza para comparar 2 variables string, esta función regresa cero si ambas string
son iguales, regresa un número mayor que cero si string 1 es mayor que string 2 y
regresa un número menor que cero si string 1 es menor alfabéticamente que string 2.
Ejemplo:
char opcion[3];
strcmp(opcion,”si”);
Página 49 de 104
if(strcmp(opcion,”si”)==0)
 STRLEN (string);
Esta función regresa la cantidad de caracteres que tiene la string.

2010
Ejemplo:
char nombre[30];
strcpy(nombre,”juan”);
printf(”%d”,sizeof(nombre)); →REGRESA 30
printf”%d”,strlen(nombre)); →REGRESA 4
Fuente
C++ - Listas De String
Las listas de valores string en C++ también dependerán del tipo de string que se esté
usando, es decir como un arreglo de caracteres o como una lista de valores string, en
cada caso se ocupara sus propias instrucciones o métodos de tratamiento de valores
string.
Como arreglo de caracteres:
Rosa
Juan
José
María
Se deberá usar un arreglo bidimensional de valores char donde el primer subíndice

referenciara la cantidad de valores string que tendrá el arreglo y el segundo subíndice
indicara el tamaño máximo de cada valor string.
Ejemplo:
char nombres[4][30];
Para efectuar cualquier proceso (captura, comparación, despliegue), se deberá usar el

Página 50 de 104
nombre de la lista y nada más el primer subíndice.
Programa en C++ que utiliza Listas de variables String

Código Fuente
#include <stdio.h>
#include <conio.h>
2010
#include <string.h>
void main()
{
char nombres[4][30];
int ren;
clrscr();
// capturar o inicializar los elementos
for(ren=0;ren<=3;ren++)
{
printf("Ingresa Nombre %d: ",ren);
gets(nombres[ren]);
}
printf("\n");
// despliegue
for(ren=0;ren<=3;ren++)
{
printf("Nombre %d: %s",ren, nombres[ren]);
printf("\n");
}
Captura de Pantalla
Página 51 de 104
DESCARGA AQUI
2010
P1. Capturar los datos de 5 productos comprados en una tienda, incluyendo nombre,
precio y cantidad en sus 3 listas respectivas, después calcular una cuarta lista con el
gasto total por cada producto desplegarlo todo incluyendo también el gran total.
P2. Capturar en sus listas respectivas los datos de 6 alumnos, pero solo desplegar los
que sean de la carrera de sistemas.
Fuente
C++ - Sorteos U Ordenamientos
Un proceso muy común en C++ con listas es el llamado sorteo u ordenamiento. Este
proceso consiste en reacomodar los elementos de la lista en un nuevo orden, de
acuerdo a algún criterio.
Existen muchos métodos u algoritmos de sorteos, el mas común de ellos, es el

denominado sorteo de burbuja que se basa en el siguiente programa en C++.
Programa en C++ que utiliza Sorteos U Ordenamientos
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
clrscr();
Página 52 de 104
// Area de ordenamiento
// Cantidad de elementos de la lista

int n = 5, k, lista[5], temp, renglon = 0;
for(k=1;k<=n-1;k++)
{while(renglon< n-k)
2010
{
if(lista[renglon]>lista[renglon+1])
{
temp=lista[renglon];
lista[renglon]=lista[renglon+1];
lista[renglon+1]=temp;
};
renglon=renglon+1;
printf("%d",lista[renglon]);
printf("\n");
};
};
}
Captra de Pantalla
DESCARGA AQUI
C++ - Arreglos Tipo Tabla
Un arreglo tipo tabla se define como un conjunto de datos del mismo tipo organizados
Página 53 de 104
en dos o más columnas y uno o más renglones. Para procesar (Operaciones y

comparaciones) internamente todos los elementos de la tabla se ocupan dos ciclos for
() uno externo para controlar renglón y uno interno para controlar columna. Los
elementos de la tabla se deberán simbolizar con el nombre de la tabla y 2 subíndices,
el primer subíndice referencia al renglón y el siguiente subíndice referencia la columna.
La declaración de una tabla será de acuerdo al siguiente formato:
2010
Tipo nombre tabla[cantidad de renglones][cantidad de columnas];
En C++ la sintaxis sería la siguiente:
int calif[3][4];
long int ingresos [3][4];
Para efectuar procesos tales como operaciones despliegue con todos los elementos de
la tabla se deberán usar 2 ciclos un for externo para controlar renglón y un for interno
para controlar columna.
Programa en C++ que utiliza Arreglos Tipo Tabla

Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
clrscr();
// Declaracion de arreglo tipo tabla
int calif[3][4];
int r,c,nc=5;
// Captura
printf("Ingrese un numero cualquiera en un Arreglo de Tablas: \n");
for (r=0; r<=2; r++)
Página 54 de 104
{ for(c=0;c<=3;c++)
{ gotoxy(nc,r+2); printf("%d %d: ",r,c);
scanf("%d",&calif[r][c]);getchar();
nc=nc+10; };
nc=5; };
// Procesando
clrscr();
2010
printf("A cada elemento del arreglo se le sumo 10: \n");
for ( r=0; r<=2; r++)
for(c=0;c<=3;c++)calif[r][c]=calif[r][c]+10;
// Desplegando
for (r=0; r<=2; r++)
{ for(c=0;c<=3;c++)
{ gotoxy(nc,r+6); printf("%d ",calif[r][c]);
nc=nc+10; };
nc=5; };
getchar();
}
Captura de Pantalla
DESCARGA AQUI
P1. Construir un cuadro que contenga los costos fijos de cuatro productos
cualesquiera, que se producen en tres plantas diferentes de una empresa maquiladora.
P2. Construir un cuadro que contenga los ingresos mensuales por ventas durante los
tres primeros meses del año de cuatro sucursales de una cadena de auto refacciones,
agregar al final una lista que muestre los ingresos mensuales totales por meses y una
Página 55 de 104
segunda lista que muestre los ingresos mensuales totales por sucursal.
P3. Construir un cuadro que contenga las comisiones ganadas por tres vendedores, de
los 5 tipos de línea blanca de conocida mueblería, además listas de comisiones totales
y promedios ganadas por los vendedores, así como listas de comisiones totales y
promedios por tipo de línea blanca.
Fuente
2010
C++ - Inicialización De Arreglos
En C++ se le permite al programador la posibilidad de inicializar arreglos, para esto
debemos tener en cuenta el siguiente formato:
static tipo nombre arreglo[cantidad de elementos]={valores};
Programa en C++ que utiliza Inicialización de Arreglos
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
clrscr();
// Inicializacion de Arreglo
static int edades[4]={18,20,19,17};
static long int tablanum[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
int r, i, nc = 1;
//Despliegue de Arreglo
for(i =0; i<=3; i++)
{ gotoxy(nc, i+1); printf("%d",edades[i]); };
for (r=0; r<=2; r++)

{ for(i = 0; i<=3; i++)
{ gotoxy (nc, r+6); printf("%d",tablanum[r][i]);
nc=nc+3; };
nc = 1; } ;
}
Captura de Pantalla
Página 56 de 104
DESCARGA AQUI
2010
P1. Inicializar una lista de 8 sueldos y desplegar la lista original y una segunda lista
aumentada en 25%
P2. Inicializar una lista de 9 ciudades, ordenarlas y desplegarlas.
Fuente
Apartado 4 - Procedimientos Y Funciones de C++

C++ - Procedimientos
Un camino para dividir un gran programa en partes más pequeñas es el uso de los
llamados procedimientos. Un procedimiento es un grupo de instrucciones, variables,
constantes, etc., que están diseñados con un propósito particular y tiene su nombre
propio. Es decir un procedimiento es un modulo de un programa que realiza tareas
especificas y que no puede regresar valores a la parte principal del programa u otro
procedimiento que lo esté invocando. Después de escribir un procedimiento se usa su
propio nombre como una sola instrucción o llamada al procedimiento. Los
procedimientos se podrán escribir después del cuerpo principal del programa utilizando
el formato:
void Nombre Procedimiento(){instrucciones;};
Pero también los procedimientos deberán declararse antes del main como lo muestra
el programa ejemplo de más abajo. Sin embargo el procedimiento se construye antes
del main() entonces no hay necesidad de declararlo antes. Un programa puede tener
tantos procedimientos como se deseen para hacer una llamada o invocación al
procedimiento durante la ejecución de un programa solo se deberá escribir el nombre
del procedimiento y los paréntesis en blanco.
Programa en C++ que utiliza Procedimientos
Código Fuente
Página 57 de 104
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{ clrscr();
// Siempre se debe declarar primero el
// procedimiento y funciones
2010
void proc1();
// Llamada al procedimiento
proc1(); }
// Fin del main
void proc1()
{
float base1,altura, area;
// Captura de datos
printf("Ingresa el valor de la base: ");
scanf("%f",&base1);
printf("Ingresa el valor de la altura: ");
scanf("%f",&altura);
// Calculo
area = base1*altura/2;
// Despliegue
printf("El area es igual a: %0.2f",area);
getchar();getchar();
}
Captura de Pantalla
Página 58 de 104
DESCARGA AQUI
Nota 1: Recordar que se pueden crear el procedimiento o los procedimientos (aunque realmente es una
función) arriba o abajo de la parte principal del programa.
2010
Nota 2: Recordar también que un programa puede tener muchos procedimientos, y estos pueden llamarse o
invocarse entre sí.
Nota 3: MUCHO OJO con la nota anterior, es válido que un procedimiento se llame o invoque o se active a si
mismo o usando una referencia circular, por ejemplo proc1, activa proc2 que a su vez llama a proc1 esto se
llama recursión y si no se controla con una instrucción if(condición)break o exit(no me acuerdo cual de las
dos) se va a obtener un hermoso ciclo infinito, muy divertido cuando le pasa a los programas de los
compañeros, están avisados.
Nota 4: Como se observa un procedimiento puede ser un programa completo.
P1. Convertir $800.00 Pesos a dólares.
P2. Calcular el área de un triangulo de base=20 y altura=30.
P3. Desplegar una Boleta de calificaciones.
Fuente
C++ - Parámetros
Un parámetro en C++ es una variable que puede pasar su valor a un procedimiento
desde el principal o desde otro procedimiento. Existen ocasiones en que es necesario
mandar al procedimiento ciertos valores para que los use en algún proceso. Estos
valores que se pasan del cuerpo principal del programa o de un procedimiento a otros
procedimientos se llaman parámetros. Entonces la declaración completa de un
procedimiento es:
Void Nombre Procedimiento(Lista de parametros)
{ cuerpo de instrucciones;};
Donde lista de parámetros es una o más variables separadas por coma, como lo
muestra el programa ejemplo. Y no olvidar declarar el procedimiento antes del main ()
incluyendo sus parámetros como lo muestra el ejemplo. Recordar también que se
pueden mandar como parámetros, datos, variables y expresiones algebraicas (no
formulas o ecuaciones algebraicas). Observar que en el procedimiento los parámetros
son dos variables locales es decir variables que solo se pueden usar dentro del
procedimiento estas variables son quienes reciben los datos o valores.
Página 59 de 104
REGLAS PARA EL USO DE PARAMETROS
 Cuando se usan variables como parámetros, la variable que se manda debe ser
declarada dentro del principal o del procedimiento de donde se está enviando.
2010
 La variable que se manda tiene un nombre, la que se recibe puede tener otro
nombre o el mismo nombre por claridad de programa, pero recordar que
internamente en la memoria del computador existirán dos variables diferentes.
 La cantidad de variables que se envían deben ser iguales en cantidad, orden y
tipo a las variables que reciben.
 La variable que se recibe tiene un ámbito local dentro del procedimiento, es
decir solo la puede usar ese procedimiento.
 Se puede mandar a un procedimiento un dato, una variable (como lo muestran
los ejemplos) o una expresión algebraica (no ecuación o formula, pero siempre
se deberán recibir en una variable.
Programa en C++ que utiliza Parámetros
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
// procedimiento y funciones.
// Observar como se pasa como parametro

// una variable string.
void proc1(char nom[], int suma);
void main()
{
clrscr();
// Llamada procedimiento
// Enviando dos parametros, uno string
proc1("Rodolfo Panduro", 3 + 4);
}
// Fin del main
Página 60 de 104
void proc1(char nom[], int suma)

{
int edad;
// Captura
printf("Ingresa la edad: ");
scanf("%d",&edad);
2010
// Operaciones
edad = edad + suma;
// Despliegue
printf("\nNombre: %s \n",nom);
printf("Edad + 7 = %d", edad);
getchar();
getchar();
}
Captura de Pantalla
DESCARGA AQUI
P1. Programa que captura 3 calificaciones en principal, calcular promedio en

procedimiento uno e imprimir nombre y promedio en un segundo procedimiento.
Página 61 de 104
P2. Construir una tabla de multiplicar que el usuario indique captura y control de ciclo
en principal, cálculo y despliegue en un procedimiento.
P3. Construir un procedimiento que reciba un número entero y que mande llamar a un
segundo procedimiento pasando el letrero “PAR O IMPAR”
Fuente
2010
C++ - Variables Locales Y Globales
El lugar donde sea declarada una variable afectara el uso que el programa quiera hacer
de esa variable. Las reglas básicas que determinan como una variable puede ser usada
dependen de 3 lugares donde se puede declarar una variable. En primer lugar es
dentro de cualquier función o procedimiento a estas se les llama variables locales y
solo pueden ser usadas por instrucciones que estén dentro de esa función o
procedimiento. En segundo lugar es como parámetro de una función donde después de
haber recibido el valor podrá actuar como variable local en esa función o
procedimiento. En esencia una variable local solo es conocida por el código de esa
función o procedimiento y es desconocida por otras funciones o procedimientos. En
tercer lugar es fuera de todas los procedimiento o funciones a este tipo de variables se
les llama variables globales y podrán ser usadas por cualquier función o procedimiento
del programa, sin embargo hay que agregarle la palabra reservada STATIC y a partir
del momento en que se declara, acompañada de dicha palabra reservada static se
considera y puede usarse como variable global. En programación en serio no es
acostumbrado usar muchas variables globales por varias razones, una de ellas es que
variables globales están vivas todo el tiempo de ejecución del programa y si una global
solo la ocupan unos cuantos procedimientos no tiene caso que este viva para todo el
resto, otra razón es que es peligroso tener variables globales porque todo el conjunto
de procedimiento y funciones que componen un programa tienen acceso o comparten
su valor y se corre el riesgo de que inadvertidamente alguno de ellos modifique su
valor.
Programa en C++ que utiliza Variables Locales Y Globales
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>

void proc1();
// Variables globales
Página 62 de 104
float base, altura, area;
void main()
{ clrscr();
// Capturando
printf("Ingrese la base: ");
scanf("%f",&base);
2010
printf("Ingrese la altura: ");
scanf("%f",&altura);
// Llamada procedimiento
proc1(); }
void proc1()
{
// Operaciones
area = base * altura / 2;
// Despliegue
printf("El area es: %0.2f",area);
getchar();
getchar();
}
Captura de Pantalla
DESCARGA AQUI
Página 63 de 104
Nota 1: Es muy agradable trabajar sin parámetros pero recordar la nota de arriba que no es muy bueno usar
muchas variables globales.
2010
P1. Boleta de calificaciones y solo usar dos variables globales.
P2. Una tabla de multiplicar y solo usar una variable global.
Fuente
C++ - Funciones
Una función es un modulo de un programa separado del cuerpo principal, que realiza
una tarea específica y que puede regresar un valor a la parte principal del programa u
otra función o procedimiento que la invoque. La forma general de una función es:
Tipo Dato Nombre funcion(parametros)
{ cuerpo de instrucciones;
return [dato,var,expresion]; }
**Tipo Dato especifica el tipo de dato que regresara la función.
La instrucción RETURN es quien regresa un y solo un dato a la parte del programa que
la este llamando o invocando, sin embargo es de considerar que return puede regresar
un dato, una variable o una expresión algebraica (no ecuación o formula) como lo
muestran los siguientes ejemplos:
* return 3.1416;
* return area;
* return x + 15/2;
La lista de parámetros formales es una lista de variables separadas por comas (,) que
almacenaran los valores que reciba la función, estas variables actúan como locales
dentro del cuerpo de la función. Aunque no se ocupen parámetros los paréntesis son
Página 64 de 104
requeridos.
Instrucción return
Dentro del cuerpo de la función deber haber una instrucción return cuando menos para
regresar el valor, esta instrucción permite regresar datos. Recordar además que
cuando se llame una función deberá haber una variable que reciba el valor que
2010
regresara la función, es decir generalmente se llama una función mediante una
sentencia de asignación, por ejemplo resultado=función (5, 3.1416);
Programa en C++ que utiliza Funciones
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>

float fun1(float b, float a);
void main()
{ clrscr();
int base,altura;
float area;
// Captura de datos
printf("Ingresa el valor de la base: ");
scanf("%d",&base);
printf("Ingresa el valor de la altura: ");
scanf("%d",&altura);
// Llamada a la funcion
area= fun1(base, altura);
// Despliegue
printf("El area es igual a: %0.2f",area);
getchar();
Página 65 de 104
getchar(); }
float fun1(float b, float a)

{ return b * a / 2; }
2010
Captura de Pantalla
DESCARGA AQUI
P1. Capturar 3 calificaciones y nombre en un procedimiento, calcular promedio en una
función, desplegar en otro procedimiento.
P2. Crear una tabla de multiplicar, captura y control de ciclo en el principal,

operaciones en una función, despliegue en el principal.
C++ - Arreglos como Parámetros

Para pasar un arreglo completo como parámetro a un procedimiento a una función solo
se manda el nombre del arreglo sin corchetes e índices, en el procedimiento o función
Página 66 de 104
que recibe solo se declara un arreglo del mismo tipo y se puede usar el mismo o
diferente nombre del arreglo sin corchetes e índices. Sin embargo es conveniente
aclarar, que a diferencia de variables escalares normales, C++ no genera una nueva
variable en memoria ni tampoco copia los datos al arreglo que recibe, en su lugar C++
sigue usando los datos que están en el arreglo original, es por esta razón que cambios
que se le hagan a los datos del arreglo que recibe realmente se está haciendo al
arreglo original como lo muestra el siguiente ejemplo:
2010
Programa en C++ que utiliza Arreglos como Parametros
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
void proc1(int vector[]);

void main()
{ clrscr();
// Creacion y carga del arreglo

int lista[5]= {10,11,12,13,14};
// Enviando arreglo a procedimiento

// Recordar como se envia sin utilizar []
proc1(lista);
// Despliegue arreglo[lista]
for(int reng=0; reng<=4; reng++)
printf("%d \n",lista[reng]);
getchar();
}
// Fin del main
void proc1(int vector[])

{
// Suma 50 al valor que se tenia en arreglo lista
for(int reng=0; reng<=4; reng++)
vector[reng]=vector[reng]+ 50;
// Observar que el procedimiento no utiliza return
}
// Fin del procedimiento
Página 67 de 104
2010
Captura de Pantalla
DESCARGA AQUI
P1. Inicializar 10 edades en el principal mandar la lista a un procedimiento que la

convierte a meses, desplegar en principal.
P2. Capturar un arreglo de 7 ciudades en principal, sortear u ordenar o alfabetizar
(sorteo burbuja) en un procedimiento y desplegar en otro procedimiento tanto la lista
original como la lista ordenada.
Fuente
Apartado 5 - Registros Y Archivos Secuenciales de C++

C++ - Introducción a Registros Y Archivos Secuenciales de C++
Como introducción cabe decir que el alumno debe estudiar intensivamente todos los
Página 68 de 104
temas de esta unidad antes de empezar a programar para evitar cualquier tipo de
confusión. A continuación, un ejemplo de dos problemas.
Problema A: Variables que puedan almacenar un conjunto de valores y no

necesariamente del mismo tipo.
Problema B: Resolver el problema de almacenar en forma permanente los datos que se

generan dentro de un programa ya sea por captura, proceso, etc.
2010
El Problema A se resuelve usando el concepto de estructuras o registros el Problema
B se resuelve usando el concepto de archivos.
Fuente
C++ - Estructuras O Registros

En este tema exploramos en C la estructura más común de representación de datos la
llamada estructura. Las variables simples o escalares pueden almacenar un gran
número de datos de información y arreglos pueden almacenar conjuntos de ellos del
mismo tipo y al mismo tiempo, estos dos mecanismos pueden manejar una gran
variedad de situaciones pero a menudo se necesita trabajar sobre datos de diversos
tipos en este caso ni variables escalares ni arreglos son adecuados. Para resolver este
problema C provee de un tipo de dato especial llamado estructura. Los elementos
individuales de una variable estructura reciben el nombre de campos. Por ejemplo:
struct alumno
nombre → campo1
direccion → campo2
edad → campo3
Formato general de una estructura
tipo de almacenamiento struct
{
tipo campo1;
tipo campo2;
}lista de variables;
Página 69 de 104
Es el registro completo quien se declara en cualquiera de los lugares adecuados para

ello. Son los campos del registro a quienes se les va a asignar, inicializar, capturar,
etc. y de esta manera a los campos se les considera como variables normales. Para
indicar a C++ durante cualquier proceso que la variable a utilizar es un campo de una
estructura se utiliza el siguiente formato:
nomregistro.nombredelcampo
2010
Programa en C++ que utiliza Estructuras O Registros
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int matricula;
char nombre[30];
int edad;}
alumno;
void main()
{ clrscr();
// Captura
printf("Ingresa la matricula: ");
scanf("%d",&alumno.matricula);
getchar();
printf("Ingresa el nombre: ");
gets(alumno.nombre);
scanf("%d",&alumno.edad);
// Operaciones
alumno.edad = alumno.edad * 12;
// Despliegue
printf("La matricula es: %d \n",alumno.matricula);
printf("El nombre es: %s \n",alumno.nombre);
printf("La edad en meses es: %d \n",alumno.edad);
getchar();
getchar();
}
Página 70 de 104
2010
Captura de Pantalla
DESCARGA AQUI
P1. Crear un registro de alumno con 3 calificaciones.
P2. Declarar un registro de empleado capturar y desplegar un número indeterminado

de veces.
P3. Capturar un registro local de un producto en el principal, mandarlo como

parámetro a un procedimiento y desplegarlo.
P4. Capturar un registro local en el principal, mandar el sueldo a una función que le
aumente el 25% y desplegar en el principal.
P5. Capturar en principal un registro local de cuentas por cobrar, mandar a un

procedimiento e imprimir un aviso si el saldo está atrasado.
Fuente
Página 71 de 104
C++ - Archivos
Si bien es cierto que ya se pueden manejar gran cantidad de datos del mismo y
diferente tipo al mismo tiempo el problema es que al terminar de ejecutarse el
programa los datos se pierden.
De esta situación nace el concepto de archivos que son medios que facilita el lenguaje
para almacenar los datos en forma permanente, normalmente en los dispositivos de
almacenamiento estándar.
2010
En general es necesario entender algunos conceptos elementales de sistemas de

archivos tradicionales.
Como nota a tomar en cuenta los datos que se van almacenando en un archivo de
disco, se almacenan en renglones consecutivos y cada renglón en disco, se conoce
como registro del archivo, favor de no confundir el concepto de registro de archivo y
registro o estructura como variable ya analizada, son dos cosas totalmente diferentes
aunque desafortunadamente se llamen igual.
Operaciones con archivos
Escribir o grabar: Es la operación mas elemental con un archivo, consiste en tomar un

o unos datos en variables de cualquier tipo (escalar, mezcla de datos, arreglos,
estructuras) y almacenarlas en un archivo de datos en disco.
Leer: Operación consistente en sacar los datos del archivo en disco y mandarlos o
cargar la variable respectiva.
Organización de archivos
En general existen dos tipos de archivos:
Archivos Secuenciales: En este caso los datos se almacenan en forma consecutiva y no

es posible leer (recuerdan que significa esta operación) ningún registro (recuerdan la
nota de arriba) directamente, es decir para leer el registro n se deberá recorrer o
acceder los n-1 registros anteriores.
Archivos Directos o Random: Para este caso si se puede acceder o leer un renglón n
cualquiera.
Tipo de archivos
Página 72 de 104
En general existen tantos tipos de archivos como tipos de datos existen, es decir: El
paquete estándar de entrada/salida de C++, hace disponible 4 métodos o maneras
diferentes de leer y escribir los datos a disco. Tres de ellas corresponden exactamente
a lo aprendido de leer y escribir datos desde el teclado hacia la pantalla.
Datos a ser grabados o leídos como un carácter a la vez, se utilizaran funciones

análogas a getchar y putchar.
2010
Datos que pueden ser leídos o grabados como una string se usaran funciones análogas
a gets y puts.
Datos que se capturen o desplieguen con formatos parecidos a los usados por scanf y
printf se usaran funciones similares, es decir serán problemas que involucran mezclas
de strings, caracteres, floats, etc.
También se podrán leer y escribir datos de tipo arreglo y registros utilizando

instrucciones apropiadas, en resumen:
Leer
getc()
fgets()
fscanf()
fread()
Escribir
putc()
fputs()
fprintf()
fwrite()
Nota: Ya que se decide utilizar algún archivo especifico de datos (caracteres, strings, formateados, registros
o arreglos) solo utilizar las funciones de escritura y lectura de ese tipo de archivo, por ningún motivo mezcle
funciones de lectura y escritura de otro tipo de archivos.
Página 73 de 104
Almacenamiento en archivos
Modo Texto: en este caso los datos son almacenados usando ASCII y por tanto son
plenamente visibles usando cualquier editor.
Modo Binario: en este caso los datos son almacenados en notación hexadecimal y por
tanto se ocupa un editor binario para reconocerlos, sin embargo un archivo binario es
más compacto que un archivo texto.
2010
Existen muchas operaciones asociadas a archivos en C++, las más elementales son:
Creación de Archivo: En este proceso se pretende solamente crear un archivo nuevo en

disco con su nombre tipo y especialidad de almacenamiento de datos apropiado.
Apertura de Archivos: En este caso se pretende abrir un archivo ya existente en disco

para procesarlo ya sea para cargar o grabar estructuras en sus registros o leer algún
registro en especial para mandarlo a una variable de cualquier tipo.
Nota: No confundir creación con apertura, creación es un proceso que solo se ejecuta una sola vez en la
vida de un archivo, mientras que apertura, siempre se está realizando por los programas especializados en
algún proceso.
Cierre de archivos: Es la operación más importante en cualquier programa que maneje

archivos, o se cierra el archivo como ultima instrucción del programa o se verá el
anuncio ABORT, RETRY, FAIL.
Altas en archivo: En este proceso se captura una estructura en memoria con sus datos
pertinentes y después se graba la estructura al archivo en disco.
Lectura de archivo: En este proceso se abre el archivo, se manda el registro de disco a

una estructura en memoria para su procesamiento.
Consulta de archivos: En este proceso se pretende desplegar todos los registros del
archivo en disco a la pantalla ya sea consola o mejor aún, a una página HTML.
Búsqueda en archivos: Una de las operaciones más comunes consiste en que el

usuario pide toda la información de algún renglón en disco proporcionando la
información de algún campo generalmente el campo clave de la estructura.
Filtros: En este proceso el usuario está interesado en algún conjunto de renglones con
características comunes (condición), por ejemplo todos los alumnos de “sistemas” o
todos los empleados que ganen más de $500.00 pesos, o todos los clientes que sean
de “Tijuana”, etc.
Modificaciones de registros o archivos: Un problema muy común, donde los datos

originales ya grabados se tienen que cambiar o actualizar, por ejemplo el nombre no
era “Juan” es “Juana”, o la calificación no es 100 es 20, etc.
Página 74 de 104
Bajas de registros: También muy común este proceso, por ejemplo el alumno ya
egreso, el cliente huyo, etc.
Fuente 01
Fuente 02
2010
C++ - Creación Archivos
En este proceso se pretende solamente crear un archivo secuencial en disco. Recordar
que la estructura que se uso para crear el archivo se deberá usar siempre y con el
mismo orden cuando se acceda al archivo con los procesos u operaciones
anteriormente mencionados. Lo primero que se crea es una variable de tipo puntero o
apuntador a un archivo a disco (instrucción FILE y debe ser en mayusculas) llamada
archdisco (muy original).
Las variables apuntadores son tipos especiales de variables que tienen la capacidad de
almacenar no datos, pero si direcciones ya sean de la memoria del computador o como
en este caso de una dirección física del disco. En C++ una variable apuntador se
declara anteponiendo un asterisco antes del nombre.
En el programa se está creando una variable apuntador bautizada con el nombre de

archdisco que almacenara la dirección física de el archivo en disco, en algún cilindro,
track, sector deberá quedar el archivo.
Como segundo paso se abre el archivo con la instrucción fopen(): archdisco =

fopen(“cpp:\\ac\\alumnos.dat”,”w”);
Nota 1: Observar que path es la dirección física de tu sitio en tú PC.
Nota 2: Observar el doble diagonal (\\) en el parámetro.
La función fopen() cuando realiza el trabajo de abrir un archivo, regresa la dirección

física donde crea o graba el archivo en disco.
El primer parámetro o argumento en esta función es la unidad de disco y el nombre del

archivo.
El segundo parámetro o argumento es llamado modo y es una de los varios modos que
podemos usar.
“r” → Lectura.
“w” → Escritura.
“a” → Append, si el archivo ya existe append empieza a añadir los nuevos datos al final
del archivo ya existente.
“r+” → Lectura y escritura, ya debe existir el archivo.

Página 75 de 104
“w+” → Crea para lectura y escritura y si ya existe, sobrescribe.
“a+” → Crea o abre para lectura y append, sino existe el archivo será creado.
2010
En adición a los valores listados también es permitido agregar uno de los siguientes
caracteres, pero insertándolo antes del signo + modo significado.
“t” lo abre en modo texto.
“b” lo abre en modo binario.
Cuando se ha finalizado de escribir al archivo se debe cerrar y esto se hace con la

instrucción: fclose(archdisco);
Programa en C++ que utiliza Creación Archivos
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int matricula;
char nombre[30];
int edad;}
alumno;
void main()
{ clrscr();
// Creando y cerrando el archivo en el disco duro

FILE *archdisco;
archdisco = fopen("cpp:\\ac\\datos.dat","w");
fclose(archdisco);
printf("ARCHIVO CREADO");
getchar();
getchar(); }
Página 76 de 104
2010
Captura de Pantalla
DESCARGA AQUI
Fuente
C++ - Grabación Y Lectura Disco

Como ya se menciono grabar y lectura de registros o estructuras a renglones o
registros de archivos en disco. Estos dos procesos son los casos más comunes y
frecuentes que se pueden realizar con un archivo de disco.
Grabación de una estructura a un archivo en disco
La única instrucción nueva es:
fwrite(&persona,sizeof(alumno),1,archdisco);
Página 77 de 104
Programa en C++ que utiliza Grabación Y Lectura Disco
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
2010
struct
{ int matricula;
char nombre;
int edad; }
alumno;
void main()
{ clrscr();
// Captura
printf("Ingresa la matricula: ");
scanf("%d",&alumno.matricula); getchar();
printf("Ingresa el nombre: ");
scanf("%s",&alumno.nombre); getchar();
scanf("%d",&alumno.edad); getchar();
// Grabando a disco
FILE *archdisco;
archdisco = fopen("cpp:\\ac\\alumnos.dat","at+");
fwrite(&alumno,sizeof(alumno),1,archdisco);
fclose(archdisco);
// Avisa al usuario
printf("El alumno ha sido insertado");
getchar(); getchar(); }
Captura de Pantalla
Página 78 de 104
DESCARGA AQUI
2010
Como se observa ocupa 4 parámetros que son: Con apuntadores se manejan dos
operadores diferentes que son (* y &) el asterisco como ya se indico se usa para crear
una variable apuntador, es decir variables que almacenaran direcciones físicas de
algún lugar de la memoria del computador.
Por supuesto también que en ese espacio o bodega en memoria se almacenaran datos
o información, es el operador & (ampersand) quien se usa para acceder a esos datos.
Por ejemplo:
Float *pi: Aquí se crea una variable apuntador que guardara la dirección donde se
almacenara un valor de tipo float. Si en ese programa, se usa: pi= 3.1416, el
compilador protesta porque se está pretendiendo almacenar un valor float en una
variable que solo puede almacenar direcciones de memoria. Pero si es válido
&pi=3.1416, es decir cuando usamos el operador ampersand estamos trabajando con
el contenido de una dirección de memoria, es por eso que:
Primer parámetro: fwrite() ocupa primero conocer cuales datos va a almacenar en

disco, aquí se le está indicando que es el dato que se tiene en la dirección de memoria
donde está el registro “alumno”.
Segundo parámetro: fwrite(), ocupa conocer cuántos bytes de información debe

grabar, para esto se tienen dos opciones o se le da el valor exacto por ejemplo 64
bytes o 39 bytes o mas fácil aun se usa sizeof() que regresa el tamaño del dato.
Tercer parámetro: fwrite(), necesita conocer también cuantas estructuras o registros a
la vez debe grabar por lo general es un solo registro, pero más adelante estudiaran
que es posible grabar más de un registro a la vez y esto es de mucho provecho,
porque por ejemplo si en un sistema se ocupa grabar 1000 registros y usamos fwrite()
de uno en uno, quiere decir que habría mil accesos a disco.
Cuarto parámetro: fwrite() también ocupa conocer exactamente en que clúster, sector
y byte exacto del disco duro debe grabar el registro, la primera opción sería desarmar
Página 79 de 104
el disco duro y ver donde hay lugar para poner el archivo J o mejor aun usar la
variable archdisco que ya tiene esa dirección física del archivo en disco.
2010
Programa en C++ que utiliza Lectura de Registros
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct { int matricula;

char nombre[30];
int edad;}
alumno;
void main()
{ clrscr();
// Leyendo disco
FILE *archdisco;
archdisco = fopen("cpp:\\ac\\alumnos.dat","at+");
// Aqui siempre debe empezar el ciclo de lectura y fread()

// regresa siempre cuantas estructuras leyo
while(fread(&alumno,sizeof(alumno),1,archdisco)==1)
{
// desplegando estructuras
printf("La matricula es: %d ",alumno.matricula);
printf("El nombre es: %s ",alumno.nombre);
printf("La edad en meses es: %d ",alumno.edad); printf("\n"); };
// aqui termina while
// no olvidar cerrar archivo y siempre fuera de while
fclose(archdisco);
getchar();getchar(); }
Página 80 de 104
2010
Captura de Pantalla
DESCARGA AQUI
Nota: En fopen() se uso modo “a+”. En lugar de fwrite(), se usa fread() con los mismos cuatro parámetros.
También recordar que fread(), nos regresa la cantidad de registros que leyó del disco, por eso el ciclo while
se convierte en falso cuando fread() regresa 0 y esto indica que se llego al fin del archivo. Y sería bueno que
el despliegue fuese en una tabla pero esto queda de tarea.
P1. Crear, cargar y leer un archivo C++ de mercancías y otro de empleados y agregar
un ciclo para el proceso de captura y no tener que estar ejecutando el programa de
captura un montón de veces.
Fuente
C++ - Búsqueda En Archivo Directo

En este proceso el usuario del programa quiere que se despliegue un y solo un registro
de información proporcionando un dato de búsqueda generalmente la clave del
Página 81 de 104
registro.
2010
Programa en C++ que utiliza Búsqueda En Archivo Directo
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int matricula;
char nombre[30];
int edad;}
alumno;
void main()
{ clrscr();
// Cargando clave a buscar

printf("Ingresa la matricula a buscar: ");
int clave; scanf("%d",&clave);getchar();
// Abriendo, leyendo y cargando el archivo

FILE *archdisco;
archdisco = fopen("cpp:\\ac\\datos.dat","at+");
// Aqui siempre debe empezar el ciclo de lectura

// y fread() regresa siempre cuantas estructuras leyo
while(fread(&alumno,sizeof(alumno),1,archdisco)==1)
{
// Desplegando estructura buscada
if ( clave == alumno.matricula)
{ printf("Matricula: %d ",alumno.matricula);
printf("Nombre: %s ",alumno.nombre);
printf("Meses: %d ",alumno.edad);
printf("\n");};};
// Aqui termina el ciclo while
// No olvidar cerrar archivo fuera de while

Página 82 de 104
fclose(archdisco);
getchar();
}
2010
Captura de Pantalla
DESCARGA AQUI
Nota: Recordar que la característica principal de un archivo secuencial de C++ es que no es posible acceder
o acceder a un registro o renglón especifico o determinado sino que se deberá recorrer todos los n-1
renglones anteriores.
Esta situación se da porque al construir un registro cualquiera con un montón de campos strings a la hora de
almacenar dichos registros, estos registros tendrán tamaños diferentes, esta es la razón principal por la cual
al buscar un registro específico se tiene que recorrer y validar todos los registros anteriores.
En el programa ejemplo se está usando un ciclo while fread para recorrer todos los registros del archivo, por
supuesto que si se tiene un archivo con 5000 registro y el buscado es el 4500 al menos se tendrá que
recorrer todos los 4499 registros anteriores.
P1. Construirles programas de búsquedas a los programas de C++ ya construidos.
Fuente
C++ - Filtros O Condiciones

Página 83 de 104
Un problema que se presenta a menudo en la programación es el de filtros, es decir en

muchas ocasiones es necesario obtener información acerca de un subconjunto de
renglones del archivo. Por ejemplo todos los estudiantes que sean mayores de 17
años, o todos los clientes que sean de Tijuana, entre otros, a esto le llamamos filtros o
condiciones.
2010
También se resuelve de manera similar a los de archivos secuenciales es decir usando
un ciclo de lectura de todo el archivo e ir desplegando todos los registros que cumplan
la condición.
Programa en C++ que utiliza Filtros o Condiciones
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct
{ int clave;
char nombre[30];
int edad;} animalito;
void main()
{ clrscr();
// Carga de la variable condicion

printf("Ingresa la edad mayor o igual al valor que desees: ");
int edad; scanf("%d",&edad);getchar();
// Abriendo, leyendo y cargando estructura

FILE *archdisco;
archdisco = fopen("cpp:\\ac\\archivo1.dat","at+");
// Aqui siempre debe empezar el ciclo de lectura
// y fread() regresa siempre cuantas estructuras leyo
while(fread(&animalito,sizeof(animalito),1,archdisco)==1)
{
// Desplegando estructuras buscadas

if (animalito. edad >= edad)
{ printf("%d ",animalito.clave);
printf(" %s ",animalito.nombre);
printf(" %d ",animalito.edad);
printf("\n");};
Página 84 de 104
}; // Aqui termina el ciclo while

// no olvidar cerrar archivo y siempre fuera de while
fclose(archdisco);
getchar(); }
2010
Captura de Pantalla
DESCARGA AQUI

P1. Hacerles programas de filtrado a los archivos C++ anteriores.
Fuente
C++ - Baja O Eliminación
Eliminación o bajas es el proceso por medio del cual algunos registros del archivo son
purgados del archivo, existen dos maneras por las cuales se puede realizar ese
proceso. En la primera manera de la cual se proporciona el ejemplo correspondiente se
usaran dos archivos, el archivo original y un archivo temporal, el procedimiento o
algoritmo es muy sencillo, se lee el registro del archivo original y si no es el registro a
eliminar entonces se almacena en el archivo temporal, cuando se termina de procesar
todo el archivo original, el archivo temporal solo contendrá todos los registros que no
se quisieron eliminar, ya con estos dos archivo se procede a eliminar o borrar usando
Página 85 de 104
la instrucción remove de el archivo original y se procede a renombrar usando la

instrucción rename de el archivo temporal como nuevo archivo original.
Sin embargo en archivos directos no se puede ni se debe eliminar físicamente registros

de los archivos porque recordar que la clave del registro esta enlazada directamente a
la posición que dicho registro tiene en disco y no sería muy conveniente estarle
cambiando la matricula al alumno cada rato o el número de serie al auto, etc.
2010
Aparte de que con esta manera de eliminar incluso físicamente los registros del archivo
es que no hay manera de recuperar esa información posteriormente. Es por eso que
otra técnica común de eliminación es incluir un campo de estado, status o bandera o
semáforo en el registro y conforme se va cargando el registro y antes de mandarlo a
disco se le agrega a dicho campo el carácter 'A' → alta, así que cuando se quiera una
baja solo se pondría dicho campo en 'B' y todos los programas de lectura, búsqueda y
filtros deberán revisar esta campo de estado antes de hacer algo con el registro.
P1. Construir programas de eliminación usando el segundo método (bajas lógicas como
se indica en el último párrafo) para los archivos construidos y no olvidar reconstruir los
programas anteriores para que incluyan y tomen en cuenta el nuevo campo.
Fuente
C++ - Operaciones Con Campos

En este tema se analiza la manera de poder realizar operaciones o procesos con los
campos de los registros en el archivo directo, lo único importante a considerar es que
los campos del registro son en cierta medida igual que variables normales y por tanto
se pueden procesar de manera normal como lo muestra el ejemplo.
Programa en C++ que utiliza Operaciones Con Campos
Código Fuente
#include <stdio.h>
#include <io.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
Página 86 de 104
void main() {
clrscr();
FILE *arch1;
long r=0;
arch1 = fopen("cpp:\\ac\\archivo1.dat","rb+");
while (fread(&animalito,sizeof(animalito),1,arch1)==1)
2010
{
// Sumando 100 a edad
animalito.edad = animalito.edad + 100 ;
// Como ya se leyo se regresa el apuntador al principio del registro
fseek(arch1,r*sizeof(animalito),0 );
// Se escribe el registro modificado al archivo
fwrite(&animalito,sizeof(animalito),1,arch1);
r=r+1;
// Turbo C++ no permite i/o archivos sin un rewind, fseek, etc
fseek(arch1,r*sizeof(animalito),0); }; // Aqui termina el ciclo for
//cerrando archivo
fclose(arch1);
// Avisando al Usuario
puts("Edades + 100");
Captura de Pantalla
DESCARGA AQUI www.descarga-tareas.blogspot.com

Página 87 de 104
Como se observa la solución es muy sencilla solo se ocupa:
 Leer fread() el registro, esto mueve el apuntador al siguiente registro.

 Modificar registro.
 Regresar a posición anterior con fseek ()
 Grabar fwrite() el registro corregido.
2010
 Volver a usar un fseek () porque turbo C++ no acepta i/o sin rewind, fseek, etc
ver ayuda del compilador.
 No se ocupan los dos archivos como en el caso secuencial.
P1. Construirles programas que procesen algunos campos de los archivos

ejemplos que ya tienen construidos.
Fuente
C++ - Edición O Modificación Registros

Modificar o editar un registro es uno de los procesos más comunes con archivos en
disco, generalmente después de un fuerte proceso de captura de registros, una
revisión o consulta general muestra muchos de ellos con errores de captura. Vamos a
editar el segundo registro.
Programa en C++ que utiliza Edición O Modificación Registros
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
void main() {
clrscr();
// Cargando clave a buscar
printf("Ingresa clave a editar: ");
int claveb; scanf("%d",&claveb);
// Abriendo, leyendo y cargando estructura
Página 88 de 104
FILE *archdisco;
archdisco = fopen("cpp:\\ac\\archivo1.dat","rb+");
// Usar fseek() para posicionarse al principio de registro buscado
fseek (archdisco, (long)(claveb)* sizeof(animalito), 0 );
// Lectura de registro
fread(&animalito,sizeof(animalito),1,archdisco);
// Desplegando estructura y asegurandose
printf("%d ",animalito.clave);
2010
printf("%s ",animalito.nombre);
printf("%d ",animalito.edad);
printf("\n");getchar();
// Recapturando los nuevos datos
printf("dame nuevo nombre :");gets(animalito.nombre);
printf("dame nueva edad :");scanf("%d",&animalito.edad);
// Regresando a apuntador para regrabar
fseek (archdisco, (long)(claveb)* sizeof(animalito), 0 );
fwrite(&animalito,sizeof(animalito),1,archdisco);
// No olvidar cerrar archivo
fclose(archdisco);
// Avisando al usuario
printf("REGISTRO EDITADO");
Captura de Pantalla
DESCARGA AQUI
Nota: Observar que es el programa normal de búsqueda pero ya desplegado el registro se piden los nuevos datos,
Página 89 de 104
posteriormente se regresa el apuntador de registros a la posición original para volverse a reagravar el registro pero
con los datos ya editados.
P1. Construir programas de edición para sus archivos.

2010
Apartado 7 - Variables Apuntadores
C++ - Introducción a Variables Apuntadores

Todas las variables se almacenan en una dirección predeterminada en memoria. El
monto del área de memoria es determinada por el tipo de variable, es decir; una
variable int ocupa 2 bytes, un float 4 bytes, un arreglo ocupara el tipo del arreglo
multiplicado por la cantidad de elementos, una estructura es igual a la suma de los
campos. En C++ existe una nueva clase de variables llamadas apuntadores o
punteros, que permiten almacenar la dirección de memoria de alguna otra variable
normal.
En el caso de variables apuntadores a string o arreglos esta variable solo poder

almacenar lo posición más relevante del arreglo es decir la ocupada por el primer
elemento del arreglo, mismo caso para estructuras. La utilidad principal de los
apuntadores es la facilidad que tienen para acceder y manipular datos estructurados
más rápidamente, también son muy útiles para permitir pasar y recibir valores en
funciones. Para declarar una variable de tipo apuntador se usa:
tipo *variable_apuntador;
Donde tipo especifica el tipo de dato al que apuntara la variable. Existen dos
operadores específicos que se utilizan para manejar variables apuntadores, estos son:
* → Sirve para crear y manipular el valor hexadecimal que representa esa dirección.
& → Se utiliza para procesar directamente el dato que se encuentra en dicha dirección.
Programa en C++ que utiliza Inicialización de Arreglos
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
Página 90 de 104
main()
{
int x = 7;
float y = 4.5;
int *x1;
float *y1;
printf("%d",x1);
printf("\n");
2010
printf("%f",y1);
getchar();
getchar();
}
Captura de Pantalla
DESCARGA AQUI
En resumen en C++ con el operador (*) se crea la variable apuntador o puntero y con
el operador (&) se procesa el dato que está dentro de esa dirección, o que creen que
hace el ampersand en los scanf().
Fuente
C++ - Apuntadores A Escalares

Las variables apuntador deben ser siempre inicializadas y recordar que ellas almacenan
direcciones físicas de memoria RAM. Existen 2 métodos:
Página 91 de 104
Programa en C++ que utiliza el método inicializar con la dirección de una

variable escalar existente.
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
2010
main()
{
int x,*y;
y = &x;
scanf("%d",&x);
printf("%d %d %d",x,*y,*y+30);
printf("\n");
scanf("%d",y);
*y = *y+x-8;
}
Captura de Pantalla
DESCARGA AQUI
Programa en C++ que utiliza el método malloc() para reservar un espacio

determinado en memoria, aqui solo se inicializa con la direccion reservada y
devuelta por el compilador.
Página 92 de 104
Código Fuente
#include <stdlib.h>
main()
{
float *y = malloc(sizeof(float));
*y = 3.14159;
2010
printf("%f",*y);
free(y);
}
Captura de Pantalla
DESCARGA AQUI
P1. Calcular el área de un triangulo usando apuntadores.
P2. Capturar/Desplegar 3 boletas de alumno con matricula y promedio.
Nota: El tipo float no permite captura.
Fuente
C++ - Apuntadores A Strings

De nuevo, en los apuntadores string se tienen dos tipos de casos.
Programa en C++ que inicializa una variable char

Página 93 de 104
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
main()
{
char nombre[30];
2010
char *ch;
ch = nombre;
printf("Ingresa un nombre: ");
gets(nombre);
printf("\n El nombre es: ");
puts(ch);
}
Captura de Pantalla
DESCARGA AQUI
Programa en C++ que utiliza malloc() para capturar/desplegar nombres
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <stdlib.h>
main()
{
char *nombre = malloc(30);
gets(nombre);
puts(nombre);
Página 94 de 104
free(nombre);
}
2010
Captura de Pantalla
DESCARGA AQUI
P1. Capturar los datos de 5 alumnos y desplegar solo los de informática y con
promedio aprobatorio todos los variables apuntadores.
P2. Capturar los datos de indeterminada cantidad de mercancías o productos de

inventario y emitir cheque solo a los importados o con saldo mayor de 1000.
Fuente
C++ - Apuntadores A Arreglos
De nuevo, en los apuntadores a arreglos se tienen dos tipos de casos.
Programa en C++ que inicializa un apuntador sencillo

Código Fuente
#include <stdio.h>
Página 95 de 104
#include <conio.h>
#include <string.h>
#include <stdlib.h>
main()
{ int x[5]={1,2,3,4,5};
int *y,renglon;
y = x;
2010
printf("%d %d %d",x[1],*y,*(y+1));
for(renglon =0; renglon <= 4; renglon ++)
printf("%d",*(y+renglon));}
Captura de Pantalla
DESCARGA AQUI
Programa en C++ que utiliza malloc() para desplegar numeros
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <stdlib.h>
main()
{ int reng;
float *x = malloc(5*sizeof(float));
*(x+2) = 3.14159;
printf("%f",*(x+2);
Página 96 de 104
for(reng = 0; reng <=4; reng ++)

printf("%f",*x++);
free(x); }
2010
Captura de Pantalla
DESCARGA AQUI
P1. Capturar en arreglos matriculas y 3 calificaciones de 6 alumnos, calcular arreglo

promedio, imprimir matricula y promedios aprobatorios, apuntadores y malloc.
P2. Inicializar una lista de apuntadores float, sortear ascendentemente, desplegar

original y copia.
Fuente
C++ - Apuntadores A Tablas
De nuevo, en los apuntadores a tablas se tienen dos tipos de casos.
Programa en C++ que inicializa una tabla sencilla

Código Fuente
Página 97 de 104
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <stdlib.h>
main()
{ int x[3][5],*y;
y = x;
2010
*(y+8) = 20;
printf("%d %d",*(y+8),x[1][3]); }
Captura de Pantalla
DESCARGA AQUI
Programa en C++ para desplegar numeros
Código Fuente
#include <stdio.h>
#include <conio.h>
#include <string.h>
main()
{ char *nombre[6];
int reng;
for(reng = 0; reng <= 5; reng++)
gets(nombre[reng]);
puts(*(nombre+1)); }
Página 98 de 104
2010
Captura de Pantalla
DESCARGA AQUI
P1. Construir una tabla que muestre los ingresos durante los tres primeros meses de
las cuatro sucursales de pinturas corona en la ciudad.
P2. Desplegar la tabla y además los ingresos por sucursales y por mes, apuntadores y
malloc.
Fuente
Apartado 8 - Programación Orientada A Objetos
C++ - Introducción a Programación Orientada A Objetos
Podemos decir que en C++ un objeto es una estructura de datos (colección de datos
organizados eficientemente para su fácil manipulación en memoria), este objeto
contiene los llamados campos, como en registros, campos que pueden ser de diferente
tipo.
Para declarar y trabajar normalmente con los elementos o campos del objeto se usaran
Página 99 de 104
las reglas ampliamente aprendidas para los campos de los tipos registros.
Programa en C++ - Programación Orientada a Objetos
Código Fuente
#include <iostream.h>
#include <stdio.h>
#include <conio.h>
2010
#include <string.h>
class { public :
char nombre[30];
}obj;
main()
{ clrscr();
printf("Ingresa tu nombre: ");
gets(obj.nombre);
printf("\nEl nombre es: ");
puts(obj.nombre);
return 0; }
Captura de Pantalla
DESCARGA AQUI
En adición los objetos pueden contener campos especiales llamados métodos. Los
métodos son procedimientos o funciones que representan simples campos dentro del
objeto.
Código Fuente
Página 100 de 104
class{publicpp:
int x;
char nombre[30];
int proc1(void)
}obj;
void main(void)
2010
{
obj.proc1();
}
Captura de Pantalla
DESCARGA AQUI
Un método podrá recibir parámetros, también podrá acceder a los otros campos del
objeto, incluso a otros métodos.
Código Fuente
class { publicpp:
int x;
void proc(int y)
{ for( x = 1; x <= y; x++)
printf("Pato"); } }obj;
Página 101 de 104
void main(void)
{ obj.proc(5); };
2010
Captura de Pantalla
DESCARGA AQUI
El real poder de la POO es la habilidad que tienen para heredar mucha de su

naturaleza a otro objeto. Por ejemplo: Pueden utilizar los elementos o campos del
objeto del cual descienden, a esta propiedad se le llama herencia.
Código Fuente
#include <stdio.h>
class papa { public :
int x; };
class hijo : public papa {
int z;};
void main(void)
{ hijo hijo1;
hijo1.x = 5;
printf("%d",hijo1.x); }
Página 102 de 104
2010
Captura de Pantalla
DESCARGA AQUI
También puede pasar parámetros al objeto del cual desciende.
Captura de Pantalla
DESCARGA AQUI
Si el método del padre es una función podrá recibir dicho valor.

Página 103 de 104
Código Fuente
#include <stdio.h>
#include <conio.h>
class papa { public :
int funcion(int n)
{ return n+5; } };
2010
class hijo : public papa
{ int z;};
void main(void)
{ hijo hijo1;
char nombre[30];
int parametro;
clrscr();
printf("Ingresa tu nombre: ");
scanf ("%s",&nombre);
printf("Ingresa el parametro: ");
scanf ("%d",&parametro);
hijo.z = hijo.funcion(parametro);
printf("\n");
printf("el nombre es: %s",nombre);
printf("la funcion de regreso es: ",hijo.z);
getch();
};
Captura de Pantalla
DESCARGA AQUI
P1. Construir algunos programas de prueba usando objetos de C++
Fuente
Página 104 de 104

C++ Cursos y Tutoriales - WWW - Descarga-Tareas - Blogspot

Загружено:

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

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

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

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

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

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

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

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

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

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

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

C++ Cursos y Tutoriales - WWW - Descarga-Tareas - Blogspot

Загружено:

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

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

Hecho en México por Rodolfo Panduro Rivera

En este PDF podrás encontrar todos los tutoriales

¡Muchas gracias por utilizar este PDF!

C++ - Ciclo Do... While .............................................................................................................. 42

C++ - Apuntadores A Arreglos ................................................................................................. 95

que permitan ejecutar el programa o aplicación simultáneamente en una red de PC.

C++ - Modelo De Solución

2. LA SEGUNDA PARTE: son todas las operaciones generalmente algebraicas

3. LA TERCERA PARTE: es el resultado o solución del problema que generalmente se

En resumen para todo problema sencillo de información es necesario plantearse las

Nota: No confundir los términos datos, variables e información.

Datos: Se refiere a información en bruto, no procesada ni catalogada.

Por ejemplo: Tijuana, Calle Primera # 213, 15 años, $2,520.00.

Variables: Es el nombre de una localidad o dirección interna en la memoria del

Por ejemplo: Ciudad, Dirección, Edad, Sueldo.

Información: Son datos ya procesados que resuelven un problema planteado.

Ejemplos/Ejercicios De Modelo De Solución en C++

1. 1. Construir un modelo de solución que resuelva el problema de calcular el área de un

Variable(s) de Entrada Proceso u Operación Variable(s) de Salida

BASE AREA= BASE * ALTURA / 2 AREA

3. 3. Convertir pesos a dólares.

4. 4. Calcular el área de un circulo con la formula: Área = PI * Radio2

5. 5. Evaluar la función Y = 5x2 – 3x + 2 para cualquier valor de x. Página 6 de 104

Un problema puede tener más de una solución correcta.

El problema no está suficientemente explicado o enunciado, entonces, estudiarlo, analizarlo y construirlo de

Tarea – Hacer los siguientes programas en C++

P1. Convertir millas a kilómetros.

P2. Convertir 125 metros a centímetros.

P7. Evaluar la función y = 3x2 + 2x – 5 para cualquier valor de x.

P9. Evaluar el factorial de cualquier numero usando la formula: n!=n!-1.

P11. Encontrar la derivada de x para cualquier valor con la formula (d/dx(x)=1)

P18. Dado un numero(N) cualesquiera obtener su raíz y potencia cuadrada.

P19. Determinar la media de 5 números diferentes.

P21. Determinar la pendiente de una recta. Formula (y = m x + b)

P22. Calcular la función de y= x² + 8x + 3 para cualquier x

P23. Convertir minutos a horas.

P24. Aplicar la formula general para a=1, b=2, c=3.

P27. Resolver x² + 15x - 8 para cualquier variable (X).

P28. Convertir °C a °F.

P39. Convertir horas a segundos.

P40. Calcular la fuerza. Formula (fuerza = trabajo / tiempo)

C++ - Constantes, Variables e Identificadores

VARIABLES: Son un objeto de partida de datos cuyo valor puede cambiar en el

 Siempre tienen que iniciar con una letra.

B236 - NOMBRE - DIRECCION - NO_CONTROL - PRECIO

· NOMBRE: Puede representar el nombre una persona.

Se puede asignar nombre a algunas constantes de uso común en cálculos

Para concluir, imaginemos que la siguiente figura es la memoria principal de la PC y

C++ - Tipos De Datos

La acción de las instrucciones ejecutables de las computadoras se ve en cambios en los

En el proceso de solución de problemas, el diseño de la estructura de datos es tan

Los tipos de datos son:

DATOS CARÁCTER: Es el conjunto finito y ordenado de caracteres que la

C++ - Operador Cast

Se puede forzar un dato, variable o una expresión a convertirse o cambiarse a un

1. El de la división entre enteros.

2. El tipo de dato especifico que requieren las funciones.

alfa = float (23)/5;

// Pero en estos casos es preferible

potencia = pow ( double (5), double (3));

// área de declaración de variables

// área de captura de datos

y = 3 * pow(x, double (3)) - pow(x, (1/3.0)) + 4 * pow(x, double(2) );