Manual programación lenguaje c

INDICE
UNIDAD 1: C++ ELEMENTOS BASICOS
1.- INTRODUCCION
2.- MODELO DE SOLUCION
3.- VARIABLES
4.- TIPOS DE DATOS
5.- OPERADORES ARITMETICOS
6.- OPERADOR CAST
7.- JERARQUIA DE OPERACIONES
8.- COMPILADOR-EDITOR C C++
9.- APLICACIONES
10.- OTRAS FUNCIONES DE ENTRADA/SALIDA
11.- FORMATO DE PANTALLA
APENDICE A) PALABRAS RESERVADAS DE C++
APENDICE B) FUNCIONES C++
UNIDAD 2: C++ INSTRUCCIONES DE CONTROL DE PROGRAMA
1.- INTRODUCCION
2.- INSTRUCCIONES CONDICIONALES
3.- CONDICIONES SIMPLES
4.- INSTRUCCION IF
5.- CONDICIONES COMPUESTAS
6.- INSTRUCCION SWITCH()
7.- CICLO FOR
8.- CICLO WHILE
9.- CICLO DO-WHILE
10.- CONCLUSIONES ACERCA DE CICLOS
UNIDAD 3: C++ ARREGLOS
1.- INTRODUCCION
2.- ARREGLOS EN C++
3.- ARREGLOS TIPO LISTAS(1)
3.- LISTAS(2)
4.- STRING
5.- LISTAS DE STRING
6.- SORTEOS U ORDENAMIENTOS
7.- ARREGLOS TIPO TABLA
8.- INICIALIZACION DE ARREGLOS
UNIDAD 4: C++ PROCEDIMIENTOS Y FUNCIONES
1.- PROCEDIMIENTOS
2.- PARAMETROS

3.- VARIABLES LOCALES Y GLOBALES
4.- FUNCIONES
5.- ARREGLOS COMO PARAMETROS
UNIDAD 5: C++ REGISTROS Y ARCHIVOS SECUENCIALES
1.- INTRODUCCION
2.- ESTRUCTURAS O REGISTROS
3.- ARCHIVOS (1)
4.- ARCHIVOS (2)
5.- CREACION ARCHIVOS
6.- GRABACION Y LECTURA DISCO
7.- BUSQUEDA EN ARCHIVO DIRECTO
8.- FILTROS o CONDICIONES
9.- BAJA o ELIMINACION
10.- OPERACIONES CON CAMPOS
11.- EDICION o MODIFICACION REGISTROS
UNIDAD 6: REGISTROS Y ARCHIVOS DIRECTOS
1.- INTRODUCCION ARCHIVOS DIRECTOS
2- CREACION ARCHIVOS
3.- GRABACION Y LECTURA DISCO
4.- BUSQUEDA EN ARCHIVO DIRECTO
5.- FILTROS o CONDICIONES
6.- BAJA o ELIMINACION
7.- OPERACIONES CON CAMPOS
8.- EDICION o MODIFICACION REGISTROS
UNIDAD 7.- VARIABLES APUNTADORES
1.- INTRODUCCION
2.- APUNTADORES A ESCALARES
3.- APUNTADORES A STRINGS
4.- APUNTADORES A ARREGLOS
5.- APUNTADORES A TABLAS
UNIDAD 8.- PROGRAMACION ORIENTADA A OBJETOS
1.- INTRODUCCION

Programación Lenguaje C++
UNIDAD 1: C++ ELEMENTOS BASICOS:
Introducción
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.
Aún 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's y con consolas, es decir el programa se ejecutaba en una
consola de msdos por ejemplo, y el programa o aplicación se tenía que portar físicamente
a otras pc's, 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 fonts, 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 aún
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's 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 que
permitan ejecutar el programa o aplicación simultáneamente en una red de pc's.
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's 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 que deban compartirse o usarse por muchas pc's conectadas a internet,
desgraciadamente como factor externo que es, no está bajo control de la 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.
MODELO DE SOLUCION
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?
• ¿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?
• ¿Cómo nota importante 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”, etc.?

Variables es el nombre de una localidad o dirección interna en la memoria del computador
donde se almacenan los datos, ejemplo de variables para los casos del inciso anterior,
CIUDAD, DIRECCION, EDAD, SUELDO, ETC.
Información son datos ya procesados que resuelven un problema planteado.
EJEMPLO DE MODELO DE SOLUCIÓN
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.
o Variable(s) de Entrada Proceso u Operación Variable(s) de Salida
o BASE AREA= BASE * ALTURA / 2 AREA
o ALTURA
VARIABLES
Identificadores son conjuntos de letras y/o números que se utilizan para simbolizar todos
los elementos que en un programa, son definibles por el usuario (programador o
ingeniero de software) del mismo, como son las variables donde se almacenan datos,
funciones (pequeños módulos con código), etiquetas, clases, objetos, etc.
En C++ un identificador es una palabra compuesta de letras y/o números de hasta 32
caracteres significativos, empezando siempre con una letra.
Una variable se define como un identificador que se utiliza para almacenar todos los datos
generados durante la ejecución de un programa.
Existen ciertas reglas en cuanto a variables:
• Claras y con referencia directa al problema.
• No espacios en blanco, ni símbolos extraños en ellas.
• Se pueden usar abreviaturas, pero solo de carácter general.
• No deben ser palabras reservadas del lenguaje.
• Ejemplos de buenas variables:
• Nombre, Edad, SdoDiario, IngMensual, Perímetro, Calif1, etc.
TIPOS DE DATOS
A toda variable que se use en un programa, se le debe asociar (generalmente al principio
del programa) un tipo de dato específico.
Un tipo de dato define todo el posible rango de valores que una variable puede tomar al
momento de ejecución del programa y a lo largo de toda la vida útil del propio programa.

Los tipos de datos más comunes en C++ son:
TIPO DATO ESPACIO MEMORIA RANGO
unsigned char 8 bits 0 a 255
char 8 bits -128 a 127
short int 16 bits -32,768 a 32,767
unsigned int 32 bits 0 a 4,294,967,295
int 32 bits -2,147,483,648 a 2,147,483,647
unsigned long 32 bits 0 a 4,294,967,295
enum 16 bits -2,147,483,648 a 2,147,483,647
long 32 bits -2,147,483,648 a 2,147,483,647
float 32 bits 3.4 x 10-38 a 3.4 x 10+38(6 dec)
double 64 bits 1.7 x 10-308 a 1.7*10+308(15 dec)
long double 80 bits 3.4 x 10-4932 a 1.1 x 10+4932
void sin valor
Para manejar cadenas de caracteres (strings), se deberá usar un arreglo de caracteres
con el siguiente formato.
Char nombre_string[cant de elementos];
Ejemplo:
• Char nombre[30];
• Char ciudad[20];
Para cargar con un dato se usa el siguiente codigo;
strcpy(carrera,”ing sistemas”);
Variables arreglos de caracteres, tienen que usar sus funciones de manipulación que
vienen en la libreria string.h, algunas de estas funciones son: strcpy(), strcat(),
strcmp(), strlen(), etc.
OPERADORES ARITMETICOS
Un operador es un símbolo especial que indica al compilador que debe efectuar una
operación matemática o lógica.
C++ reconoce los siguientes operadores aritméticos:
Operador Operación
+ SUMA
- RESTA
* MULTIPLICACION
/ DIVISION
% MODULO O RESIDUO

Como notas importantes a recordar siempre;
En problemas de división entre enteros, C++ trunca la parte residual, es decir;
</code> área de declaración de variables float a; área de operaciones
a = 10 / 4;
área de despliegue de resultados desplegar a; → En pantalla sale ( 2.000000 ) </code>
El problema no es el tipo float, sino que por definición de la división entre enteros C++
siempre trunca la parte residual, más adelante se indica cómo se resolverá este problema.
El operador (%) devuelve el residuo entero de una división entre enteros, ejemplo:
<code> área de declaración
int alfa;
área de operaciones alfa = 23 % 4; área de despliegue
desplegar alfa; → El resultado en pantalla es 3
Otro ejemplo;
alfa = 108 % 10;
desplegar alfa; → El resultado en pantalla es 8
</code>
Para resolver los problemas de potencias y raíces, se usan ciertas instrucciones especiales
que proporciona el lenguaje, llamadas funciones matemáticas, en C++ existe toda una
librería de instrucciones o funciones matemáticas.
Recordar que todas las funciones reciben uno o más datos o valores y regresan siempre un
resultado, una de estas funciones matemáticas es:
#include <math.h>
double pow(double base, double exp);
Esta función ocupa dos valores o datos (base y exponente) ambos de tipo double, y
regresa un resultado también de tipo doublé.
Ejemplo;
Resolver el problema de calcular 53
#include <math.h>
// área de declaración de variables
double base, exponente, potencia;
// área de asignación o carga o inicialización de
// variables
base=5;
exponente=3;
// área de operaciones
potencia =pow( base, exponente);
// Despliegue
desplegar potencia; -> El resultado en pantalla es 125.000000000

Para resolver el problema de raíces, se aprovecha una de las más elementales y conocida
de las leyes de exponentes que dice:
Es decir una raíz cualquiera se puede transformar a una potencia con un exponente
fraccionario.
Ejemplo:
El problema <m> y = 3sqrt{x} </m> esto es equivalente a entonces
usando función pow
y= 3*pow(x, 0.5);
En este ejemplo se está dando por supuesto que no interesa el tipo de dato que requiere
la función pow() para trabajar correctamente
RESUMEN: En C++ se pueden resolver con la ayuda de estos operadores toda clase de
problemas, ya sean financieros, algebraicos de negocios, contables, etc.
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 float a int, recordar que en este caso ya no se
tendrán los decimales.
Como nota importante este operador resuelve los dos problemas pendientes:
1. El de la división entre enteros.
2. El tipo de dato especifico que requieren las funciones.

Ejemplos:
a) // Declaración
float alfa;
// 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 más directa y
sencilla, solo recordando usar un pow() por cada potencia y cada raíz de la ecuación,
ejemplo:
Sea dentro de un programa esto se resuelve con;
// área de declaración de variables
double y, x;
// área de captura de datos
capturar el valor de x;
y = 3 * pow(x, double (3)) - pow(x, (1/3.0)) + 4 * pow(x, double(2)
);
// área de despliegue de resultados
desplegar x, y
JERARQUIA 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)
b) si calif1=60 y calif2=80 y si entonces en programa se usa
promedio = calif1 + calif2/2
la pc daría como resultado promedio = 100
Recordar siempre, que antes de plantear una formula en un programa se deberá evaluar
contra el siguiente:
Orden 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
Nota: Si se quiere alterar el orden normal de operaciones, entonces usar paréntesis.
Tampoco es bueno usar paréntesis de más en una operación, esto solo indica que no se
evalúo bien la formula, como en el siguiente ejemplo;
En el ejemplo 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.
COMPILADOR
Para poder construir programas o aplicaciones se usara el compilador turboc++ que se
encuentra en la siguiente dirección de internet: http://community.borland.com/museum/
El compilador tiene el nombre de: Antique Software - Turbo C++ versión 1.01
Bajarlo, descomprimirlo en un folder o subdirectorio temporal, dentro se encontraran tres
folders llamados disk1, disk2, disk3, copiar el contenido de disk2 y disk3 al folder disk1,
luego correr un programa llamado install, esto creara un nuevo folder en el disco duro
llamado tc, que ya contendrá nuestro compilador a usar.
Para correr el compilador y el editor de programas que trae integrado, solo abrir una
sesión de msdos prompt en la barra de start de windows y luego navegar al directorio
tcbin con la orden:
cpp:CD TCBIN
Luego cargar el compilador con la orden:
cpp:TCBINTC
Deberá mostrarse la siguiente pantalla con el editor:

Recordar que dentro de este compilador no funciona el ratón o mouse, todas las opciones
se cargan con la tecla ALT y la letra en rojo correspondiente, también se podrán usar las
teclas de flechas del teclado para navegar por las opciones de los menús.
APLICACIONES
Prog1.cpp
</code>
#include <stdio.h>
void main()
{
//area declaracion variables
int base1, altura; float area;
//area captura de datos
printf(“dame base:”);
scanf(”%d”,&base1);
printf(“dame altura:”);
scanf(”%d”,&altura);
//area de operaciones
area=base1 * altura / 2.0;
//area despliegue
printf(“el area es =%0.2f”,area);
getchar();getchar();
}
</code>

Reglas para escribir un programa en CPP:
a) Comienza con las instrucciones #include y cada una de ellas es una librería de
instrucciones especializadas en tareas específicas.
b) Todas las palabras reservadas del lenguaje deben ser minúsculas. (main, include,
printf, etc.)
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 */
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 la tecla “any key” para continuar o el programa responde tan aprisa
que no se alcanza a ver y se regresa al editor.
k) C es case-sensitive, es decir trata a mayúsculas y minúsculas como caracteres
diferentes. 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. Este programa se debera crear usando el editor del turboc y
grabarlo como prog1.cpp en el folder de su preferencia, para ejecutarlo usar la
opción RUN del propio editor.
Corrida:
INSTRUCCION 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:
a) Mensaje o texto
b) Secuencias de escape
c) Codigos de formato

d) Combinación de los tres ejemplos;
I. MENSAJE O TEXTO: Printf(“pato”) Printf(”%d”,
varentera); Printf(” los datos son %d %0.f %s
”,varent,varfloat,varstring); → ver programa ejemplo.
Nota: Se recomienda no más de 70 caracteres.
II. SECUENCIAS DE ESCAPE: Estas instrucciones proveen de mecanismos
de control para diversas tareas, existe una gran variedad de secuencias
de escape, las más usuales son:
n nuevo renglón
t tabulador horizontal
b backspace o retroceso
r carriage return
a campanilla
” despliega comillas
` despliega apóstrofe
despliega diagonal inversa
a Alarma
f avance de pagina
v tabulación vertical
III. CODIGOS 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.
IV. CODIGO TIPO DE DATO SALIDA:
%d entero enteros con signo
%u Unsignedint (enteros sin signo)
%f Float y double (parte entera y decimal)
%e Float y double (notación exponencial usando e
minúscula)
%E Float y double (notación exponencial usando E
mayúscula)
%g ”
”
el compilador decide si usa f o e
%G ”
”
el compilador decide si usa f o E
%c Char un solo caracter
%s variable string conjunto de caracteres

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:
%cantentero.cantdecimal caracter apropiado
V. INSTRUCCION 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); los códigos de formato o
códigos %.Observar que a diferencia de printf(), 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
caracter 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); –>ver programa ejemplo.
c) %s en scanf solo alcanza a capturar de la string hasta el
primer espacio en blanco.
d) El formato porciento (%) en scanf y printf para tipos long
int sera (%ld).
e) El formato porciento (%) para tipos doubles en scanf y
printf es (%lf).
OTRAS FUNCIONES DE ENTRADA Y SALIDA (I/O)
CAPTURA:
Getchar(); Getch(); Getche();
Estas tres instrucciones están especializadas en captura de un solo carácter y sustituyen a
scanf %c en situaciones especiales.
Estas funciones trabajan por igualación, es decir para usarse
varchar=getchar();
ejemplo;
char vocal;
vocal=getchar();

NOTA: DEPENDIENDO DEL SISTEMA OPERATIVO EN OCACIONES UN GETCHAR() NO
ATRAPA EL CARACTER A LA PRIMERA VEZ, EN ESTE CASO USAR MAS DE UN GETCHAR EN
FORMA CONTINUA.
En este caso poner más getchar(); después de getchar() hasta que capture el
caracter o también para detener la corrida.
A. Getchar es una macro que lee un caracter del teclado y regresa el caracter leído.
La diferencia es que getchar y getche devuelven el caracter leído a la pantalla y
el getch no devuelve el caracter a la pantalla. Estas instrucciones deberán usarse
en las siguientes situaciones:
a) Cuando la captura es de un solo caracter
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
caracter de return del teclado, en particular es conveniente usar un getchar
después de un scanf(entero) como lo muestra el ejemplo de abajo prog2.cpp
B. 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:
a) Putch(); Putchar();
Estas instruciones despliegan directamente un caracter en el dispositivo de salida
standar.
A diferencia de getchar, getch y getche, estas instrucciones si llevan un
argumento.
Ejemplo;
putchar(alfa);
putchar('n');
putchar('064');
b) Puts(variable string); Es la función complemento de gets esta función
despliega una string en el dispositivo de salida standar y debe llevar el argumento
o parametro.
puts(nombre);
puts(“pato”);

PROG2.CPP
#include <stdio.h>
void main()
{
//declaracion
int var1, var2,var3;
char var4[15], var5[15];
//captura y observar donde se ponen getchars
//unos para limpiar return y otros para parar la pantalla
printf("dame entero1:");
scanf("%d",&var1);getchar();
printf("dame string1:");
scanf("%s",&var4);
printf("dame string2:");
scanf("%d",&var2);
scanf("%d",&var3); getchar();
gets(var5);
//despliegue
printf("entero1 %d n",var1);
printf("string1 %s n",var4);
printf("entero2 %d n" ,var2);
printf("entero3 %d n",var3);
printf("string2 %s n",var5);
getchar();
}
Recordar que scanf(”%s”) no quiere espacios en blanco, por eso es mejor usar
gets(var string).
Observar que después de un scanf(entero) que este antes de un gets(varstring)
deberán usar un getchar() para quitar el return del teclado o la pc no va a capturar la
string sino que va a saltarse.
El último getchar es para parar o detener la pantalla.

Corrida:
FORMATO PANTALLA PROGRAMACION C++
#include<conio.h> Libreria a usar
1. clrscr(); Limpia pantalla
ESTA INSTRUCCION NO OCUPA ACLARACION
2. gotoxy(#de col,#de ren); posiciona cursor en lugar indicado
RECORDAR QUE UNA CONSOLA NORMAL TIENE 24 RENGLONES Y 80 COLUMNAS
En particular poner un gotoxy(); antes de cada printf() en el programa.
PALABRAS RESERVADAS EN C++
auto double int struct
break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while
Algunas de las palabras clave en C tienen significados nuevos o se han reemplazado en el
mundo de C + +, la siguiente lista muestra las palabras clave que han cambiado.
struct const
static enum
La siguiente lista muestra las palabras clave que se han añadido a C + +.
bool inline protected
catch new public
class namespace tempate
delete operator this
friend private throw
try template

FUNCIONES C++
abort() Abort Process and Return
Error
farcoreleft() Return Measure of
Unused Memory in Far Heap
int86x() Set Segment Registers
and Execute Software Interrupt
rewind() Reposition File Pointer to
Beginning of Stream
abs() Calculate Absolute Value of
Integer
farfree() Free a Block from Far
Heap
intdos() Invoke DOS Function,
Long Form
rmdir() Remove a Directory
absread() Read Disk Sectors farmalloc() Allocate Memory from
Far Heap
intdosx() Set Seg Regs and Invoke
DOS Function, Long Form
sbrk() Reset Break Value for
Calling Process
abswrite() Write Disk Sectors farrealloc() Adjust Allocated Block
in Far Heap
ioctl() Control I/O Device scanf() Read Formatted Data from
Stdin
access() Check File Permission
Setting
fclose() Close a Stream isalnum() Test for Alphanumeric
Character (Macro)
searchpath() Search the DOS Path
acos() Calculate Arc Cosine fcloseall() Close All Open Streams isalpha() Test for Alphabetic
Character (Macro)
segread() Return Current Values
of Segment Registers
alloca() Allocate Memory Block on
Stack
fcvt() Convert Double to String isascii() Test for ASCII Character
(Macro)
setblock() Modify Size of DOS
Memory Segment
allocmem() Allocate DOS Memory
Segment
fdopen() Open a Stream Using a
Handle
isatty() Check for Character
Device
setbuf() Control Stream Buffering
asctime() Convert Time from
Structure to String
feof() Detect Stream End-of-File
(Macro)
iscntrl() Test for Control Character setcbrk() Set Control-Break
Setting
asin() Calculate Arc Sine ferror() Test for Error on a Stream
(Macro)
isdigit() Test for Digit setdate() Set MS-DOS Date
assert() Diagnostic Message
Generator
fflush() Flush a Stream isgraph() Test for Printable
Character Except Space
setdisk() Set Current Disk Drive
atan() Calculate Arc Tangent fgetc() Read a Character from a
Stream
islower() Test for Lowercase setdta() Set Disk Transfer Address
atan2() Calculate Arc Tangent of
y/x
fgetchar() Read a Character from
Stdin
isprint() Test for Printable
Character
setftime() Set File Date and Time
atexit() Register Exit Function fgets() Read a String from Stream ispunct() Test for Punctuation
Character
setjmp() Save Program State
atof() Convert String to Double filelength() Return File Length isspace() Test for White-Space
Character
setmem() Assign a Value to
Memory

atoi() Convert String to Integer fileno() Get File Handle
Associated with Stream (Macro)
isupper() Test for Uppercase setmode() Set File-Translation
Mode
atol() Convert String to Long findfirst() Search Disk Directory isxdigit() Test for Hexadecimal
Digit
settime() Set System Time
bdos() Invoke DOS Function, Short
Form
findnext() Fetch Files That Match
findfirst()
itoa() Convert Integer to String setvbuf() Control Stream
Buffering and Buffer Size
bdosptr() MS-DOS System Call floor() Calculate Floor of Value kbhit() Check Keyboard Input
Buffer for Character Waiting
setvect() Set Interrupt Vector
Entry
bioscom() Communications I/O flushall() Flush All Streams and
Clear All Buffers
keep() Exit and Remain Resident setverify() Set Verify State
biosdisk() Hard Disk / Floppy I/O fmod() Calculate Floating-Point
Remainder
labs() Calculate Absolute Value of
Long Integer
sin() Calculate Sine
biosequip() Check Equipment fnmerge() Make New File Name ldexp() Convert Mantissa and
Exponent to Floating Point
sinh() Calculate Hyperbolic Sine
bioskey() Keyboard Interface fnsplit() Split a Full Path Name
into Its Components
lfind() Linear Search for Key sleep() Suspend Execution for
Interval
biosmemory() Return Memory
Size
fopen() Open a File localtime() Convert Time from Int
to Structure–Local Correction
spawn…() An Overview of the
Eight Spawn Functions
biosprint() Printer I/O FP_OFF() Get or Set Offset Portion
of a Far Pointer (Macro)
lock() Set File Sharing Locks spawnl() Execute Program Using:
Arg List
biostime() Return the Time of Day FP_SEG() Get or Set Segment
Portion of a Far Pointer (Macro)
log() Calculate Natural Logarithm spawnle() Execute Program Using:
Arg List, Environment
brk() Change Data-Segment Space
Allocation
_fpreset() Reinitialize Floating-
Point Math Package
log10() Calculate Base 10
Logarithm
spawnlp() Execute Program Using
Arg List, PATH
bsearch() Perform Binary Search fprintf() Write Formatted Data to
Stream
longjmp() Restore Program State spawnlpe() Execute Program
Using Arg List, PATH, Environment
cabs() Calculate Absolute Value of
Complex Number
fputc() Write a Character to a
Stream
lsearch() Linear Search for Key;
Add Key If Not Found
spawnv() Execute Program Using
Arg Array
calloc() Allocate and Zero
Memory
fputs() Write a String to Stream lseek() Reposition File Pointer to
Specified Location
spawnve() Execute Program Using
Arg Array, Environment
ceil() Calculate Ceiling of Value fread() Read Unformatted Data
from Stream
ltoa() Convert Long to String spawnvp() Execute Program Using
Arg Array, PATH

cgets() Get a Character String
from the Console
free() Deallocate Memory Block malloc() Allocate Memory Block spawnvpe() Execute Program
Using Arg Array, PATH,
Environment
chdir() Change Current Working
Directory
freemem() Free a Previously
Allocated DOS Memory Block
matherr() Handle Math Error sprintf() Write Formatted Data to
String
chmod() Change File Permission
Setting
freopen() Reassign a File Pointer _matherr() Floating-Point Error
Handling Routine
sqrt() Calculate Square Root
_chmod() Change Access Mode of
File
frexp() Get Mantissa and
Exponent of Floating-Point Value
memccpy() Copy Characters from
Buffer
srand() Set Random Starting Point
_clear87() Get and Clear
8087/80287 Status Word
fscanf() Read Formatted Data
from Screen
memchr() Find Character in Buffer sscanf() Read Formatted Data
from String
clearerr() Clear Error Indicator for
a Stream
fseek() Reposition File Pointer to
Given Location
memcmp() Compare Characters
from Two Buffers
ssignal() Implement Software
Signals
close() Close File fstat() Get Information about
Open File
memcpy() Copy Characters
between Buffers
stackavail() Return Size of
Available Stack Memory
_close() Close a File Handle ftell() Get Current File Pointer
Position
memicmp() Compare Characters
in Two Buffers
stat() Get File-Status Information
on Named File
coreleft() Return a Measure of
Unused Memory
fwrite() Write Unformatted Data
to Stream
memmove() Move a Block of
Bytes
_status87() Get 8087/80287
Floating-Point Status Word
cos() Calculate Cosine gcvt() Convert Double to String memset() Initialize Buffer stime() Set Time
cosh() Calculate Hyperbolic
Cosine
geninterrupt() Generate Software
Interrupt
mkdir() Create a New Directory strcat() Append a String
country() Return Country-
Dependent Information
getc() Read a Character from a
Stream (Macro)
MK_FP() Make a Far Pointer strchr() Find a Character in a
String
cprintf() Formatted Write to
Console
getchar() Read a Character from
'Stdin'
mktemp() Create a Unique File
Name
strcmp() Compare Two Strings,
Case Sensitive
cputs() Write a String to the
Console
getch() Get a Character from the
Console without Echo
modf() Split Floating Point into
Mantissa and Exponent
strcmpi() Compare Two Strings,
Case Insensitive
creat() Create a New File getche() Get a Character from
Console with Echo
movedata() Copy Characters to a
Different Segment
stricmp() Compare Two Strings,
Case Insensitive
_creat() Create a New File getcwd() Get Path Name of
Current Working Directory
movmem() Move a Block of Bytes strcpy() Copy One String to
Another

creatnew() Create a New File getenv() Get a Value from the
Environment Table
open() Open a File strcspn() Scan One String for
Another
creattemp() Create a New File or
Rewrite an Existing One
getpid() Get Process ID _open() Open a File For Reading
or Writing
strdup() Duplicate String
cscanf() Read Formatted Data
from Console
getcbrk() Get Control-Break
Setting
outport() Output to a Hardware
Port
strerror() Save System Error
Message
ctime() Convert Time from Long
Integer to String
getcurdir() Get Current Directory outportb() Output to a Hardware
Port
strlen() Get String Length
ctrlbrk() Set Control-Break
Handler
getdate() Get Date parsfnm() Parse File Name strlwr() Convert String to Lower
Case
difftime() Find the Difference
between Two Times
getdfree() Get Disk Free Space peek() Examine Memory Location strncat() Append Specified
Number of Characters to a String
disable() Disable Interrupts getdisk() Get Current Drive peekb() Examine Memory
Location
strncmp() Compare n Characters
of Two Strings, Case Sensitive
dosexterr() Get DOS Extended
Error Values
getdta() Get Disk Transfer Address perror() Print Error Message strnicmp() Compare n Characters
of Strings, Case Insensitive
dostounix() Convert Date and
Time to UNIX Time Format
getfat() Get File Allocation Table
Information
poke() Store Value at a Given
Memory Location
strncpy() Copy a Specified
Number of Characters
dup() Create Second Handle for
Open File
getfatd() Get File Allocation Table
Information
pokeb() Store Value at a Given
Memory Location
strnset() Initialize n Characters of
String
dup2() Reassign a File Handle getftime() Get File Date and Time poly() Generate a Polynomial
from Arguments
strpbrk() Scan String for Character
from Character Set
ecvt() Convert Double to String getpass() Read a Password pow() Calculate X Raised to the
Yth Power
strrchr() Scan String for Last
Occurrence of Character
enable() Enable Interrupts getpsp() Get the Program
Segment Prefix
pow10() Power Function strrev() Reverse Characters in
String
eof() Test for End of File gets() Read a Line from 'Stdin' printf() Write Formatted String to
Stdout
strset() Set All Characters in String
exec…() An Overview of the Eight
Exec Functions
gettime() Get System Time putc() Write a Character to
Stream
strspn() Find First Substring
execl() Execute Program Using:
Arg List
getvect() Get Interrupt Vector
Entry
putchar() Write a Character to
Stdout
strstr() Find Substring

execle() Execute Program Using:
Arg List, Environment
getverify() Get Verify State putch() Write a Character to the
Console
strtod() Convert String to Double
execlp() Execute Program Using:
Arg List, PATH
getw() Read an Integer from a
Stream
putenv() Create New Environment
Variables
strtol() Convert String to Long
Decimal Integer
execlpe() Execute Program Using:
Arg List, PATH, Environment
gmtime() Convert Time from Long
Integer to Structure
puts() Write String to Stdout strtok() Finds Next Token in String
execv() Execute Program Using:
Arg Array
gsignal() Software Signals putw() Write an Integer to Stream strupr() Convert String to
Uppercase
execve() Execute Program Using:
Arg Array, Environment
harderr() Establish a Hardware
Error Handler
qsort() Perform Quick Sort swab() Swap Bytes
execvp() Execute Program Using:
Arg Array, PATH
hardresume() Hardware Error
Handler Function
rand() Get Pseudorandom Integer system() Execute DOS Command
execvpe() Execute Program Using:
Arg Array, PATH, Environment
hardretn() Hardware Error
Handler Function
randbrd() Random Block Read tan() Calculate Tangent
exit() Terminate Process after
Cleanup
hypot() Calculate the Hypotenuse
of a Right Triangle
randbwr() Random Block Write tanh() Calculate Hyperbolic
Tangent
_exit() Terminate Process without
Cleanup
inport() Input from Hardware Port read() Read Data from File tell() Get Current File Pointer
Position
exp() Calculate Exponential inportb() Input from Hardware
Port
_read() Read Data from a File time() Get Current System Time
as Long Integer
fabs() Calculate Absolute Value of
Floating-Point
intr() Alternate 8086 Software
Interrupt Interface
realloc() Reallocate Memory Block toascii() Convert 'c' to ASCII
Character
farcalloc() Allocate Memory from
Far Heap
int86() Execute 8086 Software
Interrupt
rename() Rename a File or
Directory
tolower() Convert 'c' To
Lowercase, If Appropriate

_tolower() Convert 'c' to Lowercase
toupper() Convert 'c' to Uppercase, If Appropriate
_toupper() Convert 'c' to Uppercase
tzset() Set External Time Variables, Environment Variables
ultoa() Convert Unsigned Long to String
ungetc() Push Character Back onto the Stream
ungetch() Push Back the Last Character Read from the Console
unixtodos() Convert Date and Time to DOS Format
unlink() Delete a File
unlock() Release File-Sharing Locks
va_arg() Access Variable Number of Arguments, ANSI C Style
vfprintf() Write Formatted Data to Stream
vfscanf() Perform Formatted Input from a Stream
vprintf() Write Formatted Data to Stdout
vscanf() Perform Formatted Input from Stdin
vsprintf() Write Formatted Data to String
vsscanf() Perform Formatted Input from String
write() Write Data to a File
_write() Write Data to a File

OPERADORES C++
Operador Función
( ) llamada a función
[ ] subíndice de un arreglo
. Punto. Acceso a miembro de una estructura.
-> Flecha. Apunta a miembro " " "
! Inversor Lógico
- Resta
-- Decremento en uno
++ Incremento en uno
& Obtener la dirección de memoria
* Obtiene la indirección (contenido de)
/ división
% modulo (resto de la división)
+ suma
< menor que
> mayor que
<= menor igual
>= mayor igual
== igualdad de comparación
!= desigualdad
&& operador lógico AND
|| operador lógico OR
?: condicional evalúa dos expresiones
= asignación
,
separador de variables, constantes y expresiones dentro de funciones, estructuras de
control, etc.
sizeof Determina el tamaño de una variable o una estructura.

UNIDAD 2: C++ INSTRUCCIONES DE CONTROL DE
PROGRAMA
INTRODUCCION
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 que en C++ CPP se implementan con las instrucciones if() y
switch().
Instrucciones de ciclos con: for, while, do-while.
Instrucción de salto incondicional goto.
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.
Ejemplo de instrucciones condicionales;
a) si sueldo > 3000
desplegar “rico”
si no
desplegar “pobre”
fin-si
b) si sexo = 'm'
imprime mujer
si no
imprime hombre
fin-si
De los ejemplos observar que los caminos por el computador dependerán de la evaluación
que el computador hace de la condición.
Todo lenguaje de programación debe tener instrucciones que permitan formar
condiciones e instrucciones que pueden evaluar esas condiciones.
El formato general de una instrucción condicional es:

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 6000 en sueldo en el ejemplo a), entonces
el computador indicaría que la condición es CIERTA, pero en otro caso, si a la variable
sueldo primero se le asignó un valor de 250 entonces el computador indicaría que la
condición es FALSA.
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.
Empezaremos el análisis por la CONDICION.
CONDICIONES SIMPLES
En general todas las condiciones simples se forman con:
variables operadores relaciónales constante o var.
sexo = 'm'
sueldo > 300000
Una condición siempre se define como el conjunto de variables y/o constantes unidas por
los llamados operadores relaciónales.
Los operadores relaciónales que reconoce el lenguaje CPP son:
OPERADOR SIGNIFICADO
' == ' Igual que
' > ' Mayor que
' < ' Menor que
' >= ' Mayor o igual que
' <= ' Menor o igual que
' != ' No es igual que o es diferente que
Observar y tener cuidado sobre todo con el operador de igualdad y el operador relacional
de comparación por igualdad, es decir;
sueldo = 500; Se está pidiendo cargar o asignar la variable sueldo con el valor 500
sueldo == 500; Se está pidiendo que se compare el valor o dato que se encuentra en
la variable sueldo, contra el numero 500.
Solo este último formato es válido dentro de una condición en una instrucción
condicional.

NOTA IMPORTANTE, Para el caso de objetos de tipo string, los operadores
mencionados arriba funcionan, es decir es válido usar la siguiente condición:
string carrera;
if (carrera==“informatica) etc, etc, etc,
PERO para el caso de arreglos de caracteres, se tendra que usar la función
strcmp(str1,str2) que regresa cero si str1=str2, regresa un positivo si
str1>str2 y regresa un negativo si str1<str2, el mismo ejemplo:
char carrera[20];
if ( strcmp(carrera,”informatica”)== 0 ) etc, etc, etc.
INSTRUCCION IF
Es la instrucción condicional más usada en los diversos lenguajes de programación, su
formato completo y de trabajo en CPP es:
Cargar o asignar la variable de condición;
if (condición) - { grupo cierto de instrucciones;}
else - { grupo falso de instrucciones; };
Primero.- Observar donde van y donde no van los puntos y comas;
Secundo.- La condición va entre paréntesis;
Tercero.- Si un if no ocupa un grupo falso de instrucciones, entonces no se pone el
else, y la llave antes del else si terminaría con punto y coma.
PROG4.CPP
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
// declaracion variables
int edad;
char ciudad[30];
//capturando
clrscr();
gotoxy(10,5);printf("dame edad : ");
scanf("%d",&edad);getchar();
gotoxy(10,7);printf("dame ciudad : ");
gets(ciudad);
//comparando
if( edad>20)
{ gotoxy(30,5);puts("mayor de 20"); }
else{ gotoxy(30,5);puts("menor de 20"); };
if( strcmp(ciudad,"tijuana")==0)
{ gotoxy(35,7);puts("es de tijuana"); };
getchar();
}

CORRIDA:
CONDICIONES COMPUESTAS
En muchas ocasiones es necesario presentar más de una condición para su evaluación al
computador.
Por ejemplo que el computador muestre la boleta de un alumno, si este estudia la carrera
de medicina y su promedio de calificaciones es mayor de 70.
Una condición compuesta se define como dos o más condiciones simples unidas por los
llamados operadores lógicos.
Los operadores lógicos que CPP reconoce son:
OPERADOR SIGNIFICADO TIPO
&& “Y” LOGICO
! “NO” NEGACION
Ejemplo:
if ( (sueldo> 700) && ( sexo=='m') ) etc, etc, etc.
Notas: Observar que cada condición simple lleva sus propios paréntesis.
Si la variable es de tipo string el dato va entre comillas (” ”), pero si la variable es de
tipo char el dato va entre apostrofes (').
Recordar además que para comparar arreglos de chars se deberá usar strcmp().
Para que el computador evalúe como CIERTA una condición compuesta que contiene el
operador lógico “y”, las dos condiciones simples deben ser ciertas.
Para que el computador evalúe como CIERTA una condición compuesta que contiene el
operador lógico “o”, basta con que una de las condiciones simples sea cierta.
La cantidad total de casos posibles cuando se unen dos o más condiciones simples está
dada por la relación donde n = cantidad de condiciones, la primera mitad de ellos
ciertos y la segunda mitad falsos.
Ejemplo, si formamos una condiciona compuesta con dos condiciones simples y el
operador lógico “y”, la cantidad total de casos posibles serian y se puede construir
la siguiente tabla de verdad.

Tabla de verdad con “y”
1RA COND SIMPLE 2DA COND SIMPLE
EVALUACION
C F
C C
C F
C F
F F
F F
C F
C C
C F
C F
F F
F F
C F
La evaluación final se obtiene usando la regla anteriormente descrita para una condición
compuesta que contiene el operador “y”.
Esta tabla significa lo siguiente;
1.- Cualquiera que san la cantidad de datos procesados, siempre caerá en uno de estos
cuatro posibles casos.
La tabla de verdad para una condición compuesta con “O” es la siguiente;
La tabla de verdad con “O”
1RA COND SIMPLE 2DA COND SIMPLE
EVALUACION
C F
C C
C C
C F
F F
C F
C F
C C
C C
C F
F F
C F
C F
Como se observa, una condición compuesta con “O”, es menos restrictiva, o el 75% de los
casos terminarían ejecutando el grupo CIERTO de instrucciones de la instrucción
condicional.

Construir una tabla de verdad para una condición compuesta de tres o más condiciones
simples, es también tarea sencilla, solo recordar que;
1.- La cantidad posible de casos posibles es la mitad empiezan con cierto y la otra
mitad empiezan con falso.
2.- Para evaluar esta condición triple, primero se evalúan las dos primeras incluyendo su
operador bajo las reglas ya descritas y luego se evalúa el resultado parcial contra la última
condición y el ultimo operador para obtener la evaluación final.
Ejemplo una condición compuesta de tres condiciones simples, donde el primer operador
lógico es el “y” y el segundo operador lógico es el “O”, daría la siguiente tabla de verdad.
tabla de verdad para una condición compuesta de tres o más condiciones simples
1ra cond 2da cond 3ra cond
Evaluación 1a Y 2a Evaluación eval O 3ra
C C F
C C F
C F F
C F F
C F F
C F C
C F C
C C F
F F F
C C F
C C F
F F F
F C
C F
En la práctica cada condición simple debe ir encerrada en su propio paréntesis y las dos
condiciones simples también deben encerrarse entre sus propios paréntesis, como en el
siguiente ejemplo;
if((sueldo> 500)%%(strcmp(departamento,”VENTAS”)==0 )
{aquí se construye la página que despliega su cheque semanal} else {aquí se
construye y despliega la página del bono de despensa o un oficio de motivación} ;
• Recordar, cada condición simple debe estar entre paréntesis y las dos condiciones
simples también deben estar entre paréntesis.
• Observar donde se deben incluir los puntos y comas y donde no se deben incluir
los puntos y comas.

INSTRUCCION SWITCH
También existen ocasiones o programas donde se exige evaluar muchas condiciones a la
vez, en estos casos o se usa una condición compuesta muy grande o se debe intentar
convertir el problema a uno que se pueda resolver usando la instrucción switch();
La instrucción switch() es una instrucción de decisión múltiple, donde el compilador
prueba o busca el valor contenido en una variable contra una lista de constantes ints o
chars, cuando el computador encuentra el valor de igualdad entre variable y constante,
entonces ejecuta el grupo de instrucciones asociados a dicha constante, si no encuentra el
valor de igualdad entre variable y constante, entonces ejecuta un grupo de instrucciones
asociados a un default, aunque este ultimo es opcional.
El formato de esta instrucción es el siguiente;
capturar o asignar variable de condición;
switch(var int o char)
{
case const1: instrucción(es);
break;
break;
break; ………………
default: instrucción(es);
};
Ejemplo práctico:
Prog5.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
char letra;
//capturando
clrscr();
gotoxy(10,5);printf("dame una letra : ");
letra=getchar();getchar();
//empieza switch()
switch(letra)

{
case 'a': gotoxy(30,5);puts("aguila");break;
case 'b': case 'B': gotoxy(30,5);puts("baca");break;
case 'c': gotoxy(30,5);puts("caballo ");puts("camello");break;
default:gotoxy(30,5);puts("no hay");
}
getchar();
}
Corrida:
Notas:
1. Solo se puede usar como variable de condición una variable entera o variable
char.
2. Las constantes que estamos buscando y comparando son de tipo char, por eso se
deben encerrar entre apóstrofes ( ').
3. Si se quiere resolver el problema de mayúsculas o minúsculas en el teclado,
observar que se usan dos case, pero con un solo break;
4. Recordar que switch() solo trabaja con constantes y variables de tipo char o
int, en este último caso, solo usar una variable de opción de tipo entero y en los
case poner la constante numérica, sin apóstrofes decir por ejemplo
case 5: instrucciones; break;
En particular, instrucciones de tipo switch() se usan para construir programas de
selección de menús, donde al usuario se le plantean dos o tres problemas distintos
y el propio usuario seleccionaba cuál de ellos se ejecuta .
CICLO FOR
Instrucciones para ciclos 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)
{ instrucción(es); };
Ejemplo:
for(x=1;x⇐10;x=x+1)
{ puts(” MAMA ”); };
En su forma simple la inicialización es una instrucción de asignación que carga la variable
de control de ciclo con un valor inicial.
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 (;)
Codigo prog6.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
clrscr();
int x;
// instruccion for
for(x=1;x<=10;x=x+1)
{ gotoxy(10, x+4); printf("%d MAMA",x); };
getchar();
}

Corrida:
Casos Particulares del ciclo for;
1. El ciclo comienza en uno y se incrementa de uno en uno este es el caso mas
general.
2. Pero el valor inicial puede se diferente de uno, ejemplo;
for(x=5;x⇐15;x=x+1){ etc.};
3. Incluso el valor inicial puede ser negativo, ejemplo;
for (x = -3 ;x⇐ 8; x=x+1) { etc.};
4. Los incrementos también pueden ser diferentes al de uno en uno, ej.;
for (x=1; x⇐ 20; x=x+3){ etc. };
5. Incluso pueden ser decrementos, solo que en este caso, recordar;
5.1 el valor inicial de la variable debe ser mayor que el valor final.
5.2 cambiar el sentido de la condición.
Ejemplo;
for (x= 50 ; x >= 10; x= x-4 ) { etcétera };
6. Solo para los casos de incrementos y decrementos de una en una
UNIDAD sustituir en el for:
el x = x + 1 por x++
el x = x - 1 por x–
CICLO WHILE
En este ciclo el cuerpo de instrucciones se ejecuta mientras una condición permanezca
como verdadera 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;
};

Un error muy común con el while, es poner un punto y coma (;) después de la
(condición) ejemplo while(condicion); ←-esto es y causa un error.
Prog7.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
clrscr();
int x=1;
// instruccion while
while(x<=10)
{ gotoxy(10, x+3); printf("%d PATO",x); x++; };
getchar();
}
Corrida:
While puede llevar dos condiciones en este caso inicializar 2 variables de condición y
cuidar que existan 2 de rompimiento o terminación de ciclo.
El grupo cierto de instrucciones puede ser una sola instrucción o todo un grupo de
instrucciones.
La condición puede ser simple o compuesta.
Los casos generales de for también se aplican a while.

A este ciclo también se le conoce también como ciclo de condición de entrada o prueba
por arriba porque este ciclo evalúa primero la condición y posteriormente ejecuta las
instrucciones.
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);
prog8.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
clrscr();
int x=1;
// instruccion do while
do{
gotoxy(10, x+3); printf("%d GATO",x);
x++; } while(x<=10);
getchar();
}

Corrida prog
Otra diferencia básica con el ciclo while es que, aunque la condición sea falsa desde un
principio el cuerpo de instrucciones se ejecutara por lo menos una vez.
CONCLUSIONES ACERCA DE CICLOS EN C++
El problema, de un problema dado, cualesquiera cual ciclo se debe usar se resuelve con:
1. 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 for.
2. Si se desconoce la cantidad de veces a repetir el ciclo o se quiere mayor control
sobre la salida o terminación del mismo entonces usar while.
3. Si se quiere que al menos una vez se ejecute el ciclo entonces usar do while.

UNIDAD 3: C++ ARREGLOS
INTRODUCCION ARREGLOS
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.
Las variables usadas hasta ahora reciben propiamente el nombre de variables escalares,
porque solo permiten almacenar o procesar un dato a la vez.
No 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.
Variables de tipo arreglo si permiten almacenar y procesar conjuntos de datos del mismo
tipo a la vez.
Cada dato dentro del arreglo se le conoce como elemento del arreglo y se simboliza y
procesa (captura, operación, despliegue ) usando el nombre del arreglo respectivo y un
subíndice indicando la posición relativa del elemento con respecto a los demás elementos
del arreglo, solo recordar que en cpp la primera posición, elemento o renglón es el 0
(cero), ejemplo:
NOMBRES
Juan →nombres(0)
Pedro → nombres(1)
Rosa → nombres(2)
Jose → nombres(3)
Sin embargo sus problemas son similares a los de variables normales es decir hay que
declararlos, capturarlos, hacer operaciones con ellos, desplegarlos, compararlos, etc.

ARREGLOS
En programación tradicional siempre se manejan dos tipos de arreglos los arreglos tipo
listas, vectores o unidimensionales y los arreglos tipo tablas, cuadros, concentrados,
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:
a. LISTAS
EDAD
• 18
• 34
• 22
• 15
b. TABLAS
CIA ACME
INGRESOS MENSUALES VENTAS (MILES DE $)
MES SUC A SUC B SUC D
ENE 10 50 90
FEB 20 60 100
MAR 30 70 110
ABR 40 80 120
MAY 50 90 130
Como se observa la diferencia principal entre un arreglo tipo lista y un arreglo tipo tabla
son las cantidades de columnas que contienen.
NOTA IMPORTANTE.- LOS CONCEPTOS MANEJADOS AQUI ESTAN ENFOCADOS A LOS
SISTEMAS DE INFORMACION CONTABLES FINANCIEROS ADMINISTRATIVOS
EN ALGEBRA MATRICIAL, SI SON IMPORTANTES LOS CONCEPTOS DE VECTORES Y
MATRICES, PERO LAS OPERACIONES Y METODOS SON PRECISAMENTE LOS DEL ALGEBRA
MATRICIAL.
ARREGLO TIPO LISTA
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;
tipodato nomlista[cant de elementos o renglones];

Ejemplos;
int edades[12];
float sueldos[10];
Char carreras[10][30];
Para crear e inicializar una lista usar el siguiente formato:
Tipodato nomlista[cant reng]={elementos};
Ejemplo:
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”);etc;
etc.
Recordar que la primera posición o renglón en una lista es la posición o renglón 0 (cero).
LISTAS
Prog9.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
clrscr();
// declaracion listas
char nombre[3][20];
int edad[3];
// capturando
for (int r=0; r<=2; r++)
{ gotoxy(5, r*2+2);
printf("%d NOMBRE: ",r);
gets(nombre[r]);
gotoxy(5, r*2+3);
printf("%d EDAD: ",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();
}
Corrida:
Captura este procedimiento es similar para despliegue.
Se deberá usar siempre un ciclo for con una variable de control llamada renglon, misma
que también se usa como índice del arreglo.
Recordar que el primer renglon o índice en CPP es el renglon 0.
Siempre que se use un elemento de una lista en Cpp con cualquier proceso (captura,
despliegue, operaciones) deberá acompañarse de su índice respectivo.
Para procesar (hacer operaciones con ellos, o comparaciones, etc.) los elementos de la
lista, se deberán usar un ciclo for con una variable de control llamada renglón, misma
que se usara también como índice de la lista.
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.
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.
STRING
STRING COMO ARREGLO DE CARACTERES
Las strings no son más que un caso especial de arreglo de caracteres y como tales
presentan ciertas peculiaridades que no son posibles de resolver con métodos
tradicionales.
Por ejemplo no es válido usar simples sentencias de asignación o comparación.
1. char nombre [30],copia[nombre];
copia = nombre; esto no es válido en CPP
2. if(opcion==`si`) Tampoco es válido en CPP

Para casos como estos se deberán usar ciertas funciones de manipulación de strings
que provee el lenguaje C, estas funciones son:
#include <string.h>
a) 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”);
b) 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”);
c) STRCMP(string1,string2);
Se utiliza para comparar 2 strings, esta función regresa cero si ambas strings
son iguales, regresa un número mayor que cero si string1 es mayor que
string2 y regresa un número menor que cero si string1 es menor
alfabéticamente que string2.
Ejemplo: char opcion[3];
strcmp(opcion,”si”);
if(strcmp(opcion,”si”)==0)
d) STRLEN(string);
Esta función regresa la cantidad de caracteres que tiene la string.
Ejemplo: char nombre[30];
strcpy(nombre,”juan”);
printf(”%d”,sizeof(nombre)); REGRESA 30
printf”%d”,strlen(nombre)); REGRESA 4
LISTAS DE STRINGS
Las listas de strings 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 strings, en cada
caso se ocupara sus propias instrucciones o métodos de tratamiento de strings:
1. Como arreglo de caracteres:
• rosa
• juan
• jose
• maria

Se deberá usar un arreglo bidimensional de chars donde el primer subíndice
referenciara la cantidad de strings que tendrá el arreglo y el segundo subíndice indicara
el tamaño máximo de cada string.
Ejemplo:
char nombres[4][30];
Para efectuar cualquier proceso (captura, comparación, despliegue), se deberá usar el
nombre de la lista y nada más el primer subíndice.
Ejemplo:
char nombres[4][30];
int ren;
// capturar o inicializar los elementos
// despliegue
for(ren=0;ren<=3;ren++)
printf("%s",nombres[reng]);
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.
Lista original Orden crece - Orden decrece
• 15 2 15
• 2 8 10
• 10 10 8
• 8 15 3
Existen muchos métodos u algoritmos de sorteos, el más común de ellos, es el
denominado sorteo de burbuja que se basa en el siguiente algoritmo:
/*area de ordenamiento*/
n=cantidad de elementos de la lista;
for(k=1;k<=n-1;k++)
{ renglon=0;
while(renglon< n-k)

{ if(lista[renglon]>lista[renglon+1])
{ temp=lista[renglon];
lista[renglon]=lista[renglon+1];
lista[renglon+1]=temp; };
renglon=renglon+1;
};
};
Las notas a considerar con respecto al algoritmo son:
- Las variables n, k, renglón, son variables de control y deberán ser declaradas de
tipo int.
- La variable temp, deberá ser declarada de acuerdo al tipo de dato de los
elementos de la lista.
- Todas las referencias a LISTA, deberán ser cambiadas por el nombre verdadero de
la lista real.
- Es el símbolo del if, quien determina el tipo de sorteo, es decir, ascendente (>),
descendente (<).
- Para el caso de listas de strings, la comparación en el if y el intercambio en la
parte cierta de abajo se deberá hacer usando las instrucciones o métodos que se
analizaron en el tema de strings.
ARREGLOS TIPO TABLA
Un arreglo tipo tabla se define como un conjunto de datos del mismo tipo organizados en
dos o más columnas y uno o más renglones.
Para procesar (recordar solo 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 renglon y el siguiente subíndice referencia la columna.
La declaración de una tabla será de acuerdo al siguiente formato.
tipo nomtabla[cant ren][cant col];
Ejemplo:
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 renglon y un for interno
para controlar columna.
prog10.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
clrscr();
// declaracion tabla
int calif[3][4];
int r,c,nc=5;
// capturando
printf("CALIFICACIONES n");
for (r=0; r<=2; r++)
{
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;
};
//operando
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();
}

Corrida:
INICIALIZACION DE ARREGLOS
Se permite la inicialización de arreglos en C++ de acuerdo al siguiente formato:
static tipo numarreglo[cant de elementos]={valores};
Ejemplo: static int edades[5]={18,20,19,17,23};
static long int tabla num[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
static char nombres [3][30]={“juan”, “jose”, “rosa”};

UNIDAD 4: C++ PROCEDIMIENTOS Y FUNCIONES
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 módulo de un programa que realiza tareas específicas 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 NomProc(){instrucciones;};
Pero también los procedimientos deberán declararse antes del main como lo muestra el
programa ejemplo.
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.
Prog11.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main()
{
clrscr();
// recordar declarar primero proc y funciones
void proc1();
//llamando o activando procedimiento
proc1();
} // fin del main

void proc1()
{
// area de declaracion de variables y captura de datos
int base1,altura; float area;
//area de captura
printf("dame base: ");
scanf("%d",&base1);
printf("dame altura: ");
scanf("%d",&altura);
// area de operaciones
area = base1 * altura / 2;
// area de despliegue
printf("area=%0.2f",area);
getchar();
getchar();
}
// fin proc
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.
Recordar también que un programa puede tener muchos procedimientos, y estos pueden
llamarse o invocarse entre sí.
MUCHO OJO con la nota anterior, es válido que un procedimiento se llame o invoque o se
active a sí 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; se va a obtener un hermoso ciclo infinito, muy divertido cuando le
pasa a los programas de los compañeros, están avisados.
Como se observa un procedimiento puede ser un programa completo.
PARAMETROS EN C++
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 Nom_Proc(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.
prog12.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
// y observar como se pasa como parametro una string
void proc1(char nom[], int suma);
void main()
{
clrscr();
//llamando o activando procedimiento
// y pasando dos parametros uno de ellos string
proc1("juan perez", 3 + 4);
} //fin main
// ya se fijaron como se pasa la string
void proc1(char nom[], int suma)
{
//declarando variables
int edad;
// capturando
printf("dame edad: ");
scanf("%d",&edad);
// operaciones sumando parametro
edad = edad + suma;
//construyendo y desplegando la pagina de salida
printf("%s n",nom);
printf("EDAD= %d", edad);
getchar();
getchar();
}
// fin proc

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)
Corrida:
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.
REGLAS PARA EL USO DE PARAMETROS
1. 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.
2. 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.
3. La cantidad de variables que se envían deben ser igual en cantidad, orden y tipo a
las variables que reciben.
4. La variable que se recibe tiene un ámbito local dentro del procedimiento, es decir
solo la puede usar ese procedimiento.
5. 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.
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
modifiquen su valor.
prog13.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
void proc1();
// variables globales
float base, altura, area;
void main() {
clrscr();
//capturando datos
printf("dame base: ");scanf("%f",&base);
printf("dame altura: ");scanf("%f",&altura);
//llamando procedimiento
proc1();
}
void proc1(){
// area de operaciones
area = base * altura / 2;
// área de construcción de página de salida
printf(" area =%0.2f",area);
}
Es muy agradable trabajar sin parámetros pero recordar la nota de arriba que no es muy
bueno usar muchas variables globales. Corrida:

FUNCIONES
Una función es un módulo 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:
Tipodato Nomfun(parametros)
{
cuerpo de instrucciones;
return [dato,var,expresion];
}
Donde tipodato 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
esté 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;
a) return 3.1416;
b) return area;
c) 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 requeridos.
INSTRUCCION 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 regresara la función, es decir generalmente se llama una función mediante
una sentencia de asignación, por ejemplo resultado=funcion(5, 3.1416);
prog14.cpp
<code>
#include <stdio.h>
#include <conio.h>
#include <string.h>
//todos los proc y funciones deben declararse antes del main
float fun1(float b, float, a); void main() { clrscr();
//capturando datos
//area de declaracion de variables y captura de datos
int base, altura; float area;

//area de captura
printf(“dame base: ”);scanf(”%d”,&base);
printf(“dame altura: ”);scanf(”%d”,&altura);
//llamando o invocando la funcion fun1
area= fun1(base, altura);
//desplegando
printf(” area =%0.2f”,area);
}
float fun1(float b, float a)
{
return b * a / 2;
}
</code
Corrida:
Usar de preferencia solo int y double como parámetros.
Es permitido poner más de un return en el cuerpo de instrucciones sobre todo en
condiciones, pero solo un return se ejecutara, ejemplo;
if (suma >= 10)
{ return 10; }
else
{ return 20; }
EXISTEN 3 CLASES USUALES DE FUNCIONES.
• Las primeras son de tipo computacional que son diseñadas para realizar
operaciones con los argumentos y regresan un valor basado en el resultado de esa
operación.
• Las segundas funciones son aquellas que manipulan información y regresan un
valor que indican la terminación o la falla de esa manipulación.
• Las terceras son aquellas que no regresan ningún valor, es decir son estrictamente
procedurales.
Esto quiere decir que en general toda operación o calculo en un programa deberá
convertirse a una o muchas funciones y el resto deberán ser procedimientos.

ARREGLOS COMO PARAMETROS
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 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 cpp 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:
Prog15.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
void proc1(int vector[]);
void main() {
clrscr();
//creando arreglo y cargandolo
int lista[5]= {10,11,12,13,14};
// mandandolo a procedimiento recordar como se manda sin []
proc1(lista);
// desplegando arreglo lista y observar que datos salen
for(int reng=0; reng<=4; reng++)
printf("%d n",lista[reng]);
getchar();
} // termina main
void proc1(int vector[])
{
// sumandole 50 a lo que se tenia en arreglo lista
// es decir vector queda cargado con 60,61,62,63,64
for(int reng=0; reng<=4; reng++)
vector[reng]=vector[reng]+ 50;
// observar que no se regresa nada
} //termina proc1

Corrida:
Es de recordar que los cambios que le hagan al arreglo dentro de la función se reflejaran
en el arreglo original, es por esto que si se quiere modificar un arreglo en una función no
hay necesidad de regresar ningún valor.

UNIDAD 5: C++ REGISTROS Y ARCHIVOS SECUENCIALES
INTRODUCCION
Antes de empezar a programar en serio se estudian en esta UNIDAD 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.
El problema (A) se resuelve usando el concepto de estructuras o registros el problema (B)
se resuelve usando el concepto de archivos.
ESTRUCTURAS O REGISTROS
En este tema exploramos en C la estructura más común de representación de datos la
llamada estructura.
Variables simples o escalares pueden almacenar un datum 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.
Ejemplo:
struct alumno
nombre campo1
direccion campo2
edad campo3
etc.
EL FORMATO GENERAL DE UNA ESTRUCTURA ES:
tipo de almacenamiento struct
{
tipo campo1;
tipo campo2;
}lista de variables;
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
Ejemplo.
prog16.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int matricula;
char nombre[30];
int edad;}alumno;
void main() {
clrscr();
// captura de campos
printf("dame matricula:");scanf("%d",&alumno.matricula);getchar();
printf("dame nombre :");gets(alumno.nombre);
printf("dame edad :");scanf("%d",&alumno.edad);
alumno.edad = alumno.edad * 12;
// área de salida
printf("MATRICULA =%d n",alumno.matricula);
printf("NOMBRE =%s n",alumno.nombre);
printf("MESES =%d n",alumno.edad);
}
Corrida:
Las operaciones más elementales con los campos de una estructura incluyen captura e
inicialización.

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.
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.
Primero: Operaciones con archivos
• ESCRIBIR O GRABAR: Es la operación más 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
Segundo: 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 acezar los n-1 registros anteriores.
• Archivos Directos o Random.- Para este caso si se puede acceder o leer un renglón
n cualquiera.
Tercero: Tipo de archivos
En general existen tantos tipos de archivos como tipos de datos existen, es decir:
El paquete estándar de input/output 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.
1. Datos a ser grabados o leídos como un caracter a la vez, se utilizaran funciones
análogas a getchar y putchar.

2. Datos que pueden ser leídos o grabados como una string se usaran funciones
análogas a gets y puts.
3. 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.
4. También se podrán leer y escribir datos de tipo arreglo y registros utilizando
instrucciones apropiadas, en resumen:
caracter
string
Formateado
Registros y arreglos
Leer Escribir
getc() putc()
fgets() fputs()
fscanf() fprintf()
fread() fwrite()
ATENCION: 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.
Cuarto: 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.
ARCHIVOS DISCO
Existen muchas operaciones asociadas a archivos en C++, las más elementales son:
1. 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.
2. 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.
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.
3. 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.
Windows 98, /s, scandisk

4. 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.
5. Lectura de archivo.- En este proceso se abre el archivo, se manda el registro de
disco a una estructura en memoria para su procesamiento.
6. 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
7. 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.
8. 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.
9. Modificaciones de registros o archivos: 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.
10. Bajas de registros: también muy común este proceso, por ejemplo el alumno ya
egreso, el cliente huyo, etc.
CREACION ARCHIVOS SECUENCIAL DISCO
En este proceso se pretende solamente crear un archivo secuencial en disco.
Prog17.cpp
#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 disco
FILE *archdisco;
archdisco = fopen("cpp:acalumnos.dat","w");
fclose(archdisco);
printf("ARCHIVO CREADO");
}

CORRIDA:
Recordar que la estructura que se usó 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).
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 del archivo en disco, en algún cilindro,
track , sector deberá quedar el archivo no es verdad??.
Como segundo paso se abre el archivo con la instrucción fopen():
archdisco = fopen(“cpp:acalumnos.dat”,”w”);
Observar que el path es la dirección física de tu sitio en TU PC.
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.
“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.
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);

GRABACION Y LECTURA DISCO
Como ya se mencionó 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.
GRABACION DE UNA ESTRUCTURA A UN ARCHIVO EN DISCO
prog18.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int matricula;
char nombre[30];
int edad;} alumno;
void main() {
clrscr();
printf("dame matricula :");
scanf("%d",&alumno.matricula);
getchar();
printf("dame nombre :");
gets(alumno.nombre);
printf("dame edad :");
scanf("%d",&alumno.edad);
// grabando a disco
FILE *archdisco;
archdisco = fopen("cpp:acalumnos.dat","at+");
fwrite(&alumno,sizeof(alumno),1,archdisco);
fclose(archdisco);
//avisando usuario
printf("alumno insertado");
getchar();
getchar();
}

Corrida:
La primera observación es que se está usando el “fopen()” en modo “at+” en lugar de
modo “w” pero es para matar dos pájaros de un tiro, reestudiar la clase anterior de modos
de apertura.
La única instrucción nueva es:
fwrite(&persona,sizeof(alumno),1,archdisco);
Como se observa ocupa 4 parámetros que son:
Con apuntadores se manejan dos operadores diferentes que son ( * y &) el asterisco como
ya se indicó 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 accesar a esos datos,
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:
1. PRIMER PARAMETRO: 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”.
2. SEGUNDO PARAMETRO: 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 más fácil aún se usa sizeof() que regresa el
tamaño del dato.
3. TERCER PARAMETRO: 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.
4. CUARTO PARAMETRO: fwrite() también ocupa conocer exactamente en que
cluster, sector y byte exacto del disco duro debe grabar el registro, la primera
opción sería desarmar el disco duro y ver donde hay lugar para poner el archivo J
o mejor aún usar la variable archdisco que ya tiene esa dirección física del archivo
en disco.

LECTURA DE REGISTROS Prog19.CPP
<code>
#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:acalumnos.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(“MATRICULA =%d ”,alumno.matricula);
printf(” NOMBRE =%s ”,alumno.nombre);
printf(” MESES =%d ”,alumno.edad);
printf(“n”); };
//aqui termina
while
//no olvidar cerrar archivo y siempre fuera de while
fclose(archdisco);
getchar();
getchar();
}
</code>

Corrida:
Las únicas notas son: En fopen() se usó 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 llegó al fin del archivo. Y sería bueno
que el despliegue fuese en una tabla pero esto queda de tarea.
BUSQUEDA ARCHIVOS DIRECTOS
En este tema se analiza la búsqueda de un registro o renglón determinado.
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 registro.
Recordar que en esta operación se muestra la diferencia fundamental entre archivos
secuenciales y archivos directos, es decir aquí se puede accesar directamente un registro n
cualesquiera.
Prog28.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
int edad;} animalito;
void main() {
clrscr();
// cargando clave a buscar
printf("dame clave buscar:");
int claveb; scanf("%d",&claveb);
//abriendo, leyendo,cargando estructura
FILE *archdisco;
archdisco = fopen("cpp:acarchivo1.dat","ab+");

// usar fseek() para posicionarse al principio de registro
//buscado
fseek (archdisco, (long)(claveb)* sizeof(animalito), 0 );
// ahora se lee el registro
fread(&animalito,sizeof(animalito),1,archdisco);
// desplegando estructura y asegurándose
printf("%d ",animalito.clave);
printf("%s ",animalito.nombre);
printf("%d ",animalito.edad);
printf("n");
// no olvidar cerrar archivo
fclose(archdisco);
}
Corrida:
Como se desprende del programa usando fseek() es posible posicionarse en cualquier
byte del archivo.
El formato completo de fseek() es:
fseek(apuntador,(long)(clave)*(sizeof(registro)),0);
Donde los parámetros son:
1. Apuntador al archivo en disco
2. El segundo parámetro es el BYTE donde se quiere que empiece la lectura o
grabación al archivo en disco.
3. Este BYTE debe ser de tipo LONG así que si en algún programa de ejemplo ven
fseek( , 387L, ); que no les llame la atención, es otra manera de hacerle
cast a un dato. Como va a estar difícil que se le atine a un byte determinado, es
por eso que en el programa mejor se deja que sea el propio servidor quien calcule
el byte donde empieza un registro determinado con clave * sizeof o tamaño de
registro.
4. El tercer parámetro es a partir de donde se quiere posicionar el apuntador interno
del archivo, los valores pueden ser:
0 → SEEK_SET principio del archivo.
1 → SEEK_CUR posición actual.
2 → SEEK_END fin del archivo.

RECORDAR QUE ES MUY IMPORTANTE QUE LAS CLAVES GRABADAS EN UN ARCHIVO
DIRECTO TENGAN LA SECUENCIA 0,1,2,3,4,5…..N
FILTROS O CONDICIONES
Otro problema similar al anterior es el de filtros o condiciones, 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, etc. a esto le llamamos filtros o condiciones.
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.
Prog29.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
void main() {
clrscr();
printf("EDAD MAYOR QUE >= :");
int edad; scanf("%d",&edad);getchar();
FILE *archdisco;
archdisco = fopen("cpp:acarchivo1.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 estructura buscada
if (animalito.edad >= edad)

{ printf("%d ",animalito.clave);
printf(" %s ",animalito.nombre);
printf(" %d ",animalito.edad);
printf("n");};
}; // aqui termina while
// no olvidar cerrar archivo y siempre fuera de while
fclose(archdisco);
getchar();
}
Corrida:
Como se observa es un problema y una solución similar al tema anterior de búsquedas.
BAJAS O ELIMINACIONES
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 se usan 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 la instrucción remove el archivo original y se procede a renombrar usando la
instrucción rename del 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.
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.
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.
prog30.cpp
#include <stdio.h>
#include <io.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
void main() {
clrscr();
FILE *arch1;
long r=0;
arch1 = fopen("cpp:acarchivo1.dat","rb+");
while (fread(&animalito,sizeof(animalito),1,arch1)==1)
{
// 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 );
// y se escribe el registro modificado al archivo
fwrite(&animalito,sizeof(animalito),1,arch1);
r=r+1;
//turboc no permite i/o archivos sin un rewind, fseek, etc
fseek(arch1,r*sizeof(animalito),0);
}; // aqui termina for

//cerrando archivo
fclose(arch1);
//avisando
puts("EDADES + 100");
}
Corrida prog27:
Corrida prog30
Corrida prog27
Como se observa la solución es muy sencilla solo se ocupa:
1. leer fread() el registro, esto mueve el apuntador al siguiente registro.
2. modificar registro
3. regresar a posición anterior con fseek()
4. grabar fwrite() el registro corregido
5. volver a usar un fseek() porque turboc no acepta i/o sin rewind, fseek, etc
ver ayuda del compilador y no se ocupan los dos archivos como en el caso
secuencial.

EDICION MODIFICACION DE 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.
Prog31.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
void main() {
clrscr();
printf("dame clave editar:");
//abriendo, leyendo, cargando estructura
FILE *archdisco;
archdisco = fopen("cpp:acarchivo1.dat","rb+");
// usar fseek() para posicionarse al principio de registro
// buscado
// desplegando estructura y asegurandose
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

fwrite(&animalito,sizeof(animalito),1,archdisco);
fclose(archdisco);
//avisando
printf("REGISTRO EDITADO");
}
Corrida:
Observar que es el programa normal de búsqueda pero ya desplegado el registro se piden
los nuevos datos, posteriormente se regresa el apuntador de registros a la posición
original para volverse a regrabar el registro pero con los datos ya editados.

UNIDAD 6: REGISTROS Y ARCHIVOS DIRECTOS
INTRODUCCION REGISTROS ESTRUCTURAS
SE DICE QUE UN ARCHIVO ES DE ACCESO U ORGANIZACION DIRECTA CUANDO PARA
ACCEDER A UN REGISTRO N CUALESQUIERA NO SE TIENE QUE PASAR POR LOS N-1
REGISTROS ANTERIIORES.
Como se observa de esta definición los archivos directos tienen una gran ventaja (son
mucho más rápidos) cuando se comparan con los archivos de acceso u organización
secuencial estudiados en la UNIDAD anterior.
Aunque lo anterior no quiere decir que son mejores que los secuenciales, es decir es el
propio problema planteado quien exigirá una solución u otra, por ejemplo si se quiere
construir un archivo para almacenar los datos de un guestbook, si se construye de manera
directa sería muy rápido pero si lo construimos de manera secuencial, se podrán
almacenar datos con cantidades de información más adecuados al problema.
Es decir un archivo de acceso directo tiene que tener sus registros o renglones de un
tamaño fijo o predeterminado de antemano.
Un archivo de acceso directo permite posicionar el apuntador de interno de registros, a
cualquier registro determinado sin necesidad de pasar por todos los registros anteriores,
usando las siguientes funciones.
1) int fseek(apuntador,long offset,origen);
Esta función posiciona el apuntador de registro en el byte indicado. Regresa 0 si se
pudo posicionar.
apuntador=fopen(“a:archivo.dat”,”r+”);
0 SEEK_SET principio del archivo.
1 SEEK_CUR posición actual.
2 SEEK_END fin del archivo.
2) long ftell(apuntador);
Regresa un valor long indicando la posición actual del cursor interno de registros
de archivo.
3) int rewind(apuntador);
Regresa el apuntador al principio del archivo.
Ejemplo para hacer modificaciones.
fread(&registro,sizeof(registro),1,apuntador);
Hacer las modificaciones.
rewind(apuntador);
fwrite(&registro,sizeof(registro),1,apuntador);

CREACION DE ARCHIVOS DIRECTOS DISCO
En este proceso se pretende solamente crear un archivo directo en disco.
Prog25.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
void main() {
clrscr();
//creando y cerrando el archivo en disco
FILE *archdisco;
archdisco = fopen("cpp:acarchivo1.dat","wb");
fclose(archdisco);
printf("ARCHIVO CREADO");
}
corrida:
Recordar que la estructura que se usó 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.
Observar que es completamente similar a la creación de archivos secuenciales.
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).
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 del archivo en disco, en algún cilindro,
track , sector deberá quedar el archivo no es verdad??.
Como segundo paso se abre el archivo con la instrucción fopen():
archdisco = fopen(“cpp:acarchivo1.dat”,”wb”);
Observar que el path es la dirección física de tu PC.
Recordar también que archivos y directorios msdos deben respetar 8.3 letras.
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.
“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.
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);
GRABACION Y LECTURA DE ARCHIVOS DISCO
Como ya se mencionó 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.

GRABACION DE UNA ESTRUCTURA A UN ARCHIVO EN DISCO
prog26.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
void main() {
clrscr();
printf("dame clave :");scanf("%d",&animalito.clave);getchar();
printf("dame nombre :");gets(animalito.nombre);
printf("dame edad :");scanf("%d",&animalito.edad);
// grabando a disco
FILE *archdisco;
fclose(archdisco);
//avisando usuario
printf("animalito insertado");
}
CORRIDA:
Observar que es completamente similar al programa de archivos secuenciales, solo se
recomienda y exige que las claves sigan la secuencia 0,1,2,3,4,5…..
Otra observación es que se está usando el “fopen()” en modo “ab+” en lugar de modo
“w” pero es para matar dos pájaros de un tiro, reestudiar la clase de modos de apertura.
La instrucción de grabación es:
que ya se estudió anteriormente.

LECTURA CONSULTA DESPLIEGUE DE REGISTROS
Prog27.CPP
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
void main() {
clrscr();
// leyendo disco
FILE *archdisco;
// aquí siempre debe empezar el ciclo de lectura
// y fread() regresa siempre cuantas estructuras leyó
{
// desplegando estructuras
printf("n");
fclose(archdisco);
}
CORRIDA:
Sería bueno que el despliegue fuese en una tabla pero esto queda de tarea.

BUSQUEDA DE ARCHIVOS
En este tema se analiza la búsqueda de un registro o renglón determinado.
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 registro.
Recordar que en esta operación se muestra la diferencia fundamental entre archivos
secuenciales y archivos directos, es decir aquí se puede accesar directamente un registro n
cualesquiera.
Prog28.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
void main() {
clrscr();
printf("dame clave buscar:");
//abriendo, leyendo, cargando estructura
FILE *archdisco;
// usar fseek() para posicionarse al principio de registro buscado
printf("n");
fclose(archdisco);
}

Corrida:
Como se desprende del programa usando fseek() es posible posicionarse en cualquier
byte del archivo.
El formato completo de fseek() es:
donde los parámetros son:
1. Apuntador al archivo en disco
2. El segundo parámetro es el BYTE donde se quiere que empiece la lectura o
grabación al archivo en disco.
3. Este BYTE debe ser de tipo LONG así que si en algún programa de ejemplo ven
fseek( , 387L, ); que no les llame la atención, es otra manera de hacerle
cast a un dato.
Como va a estar difícil que se le atine a un byte determinado, es por eso que en el
programa mejor se deja que sea el propio servidor quien calcule el byte donde
empieza un registro determinado con clave * sizeof o tamaño de registro.
4. El tercer parámetro es a partir de donde se quiere posicionar el apuntador interno
del archivo, los valores pueden ser:
0 → SEEK_SET principio del archivo.
1 → SEEK_CUR posición actual.
2 → SEEK_END fin del archivo.
RECORDAR QUE ES MUY IMPORTANTE QUE LAS CLAVES GRABADAS EN UN ARCHIVO
DIRECTO TENGAN LA SECUENCIA 0,1,2,3,4,5…..N.
FILTROS O CONDICIONES
Otro problema similar al anterior es el de filtros o condiciones, 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, etc. a esto le llamamos filtros o condiciones.
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.

Prog29.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
void main() {
clrscr();
printf("EDAD MAYOR QUE >= :");
int edad; scanf("%d",&edad);getchar();
FILE *archdisco;
archdisco = fopen("cpp:acarchivo1.dat","at+");
// aquí siempre debe empezar el ciclo de lectura
// y fread() regresa siempre cuantas estructuras leyó
{
// desplegando estructura buscada
if (animalito.edad >= edad)
{ printf("%d ",animalito.clave);
printf(" %s ",animalito.nombre);
printf(" %d ",animalito.edad);
printf("n");};
fclose(archdisco);
getchar();
}

Corrida:
Como se observa es un problema y una solución similar al tema anterior de búsquedas.
BAJAS O ELIMINACIONES
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 se usan 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 la instrucción remove el archivo original y se procede a renombrar usando la
instrucción rename del 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.
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 caracter '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.
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.

prog30.cpp
#include <stdio.h>
#include <io.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
void main() {
clrscr();
FILE *arch1;
long r=0;
arch1 = fopen("cpp:acarchivo1.dat","rb+");
while (fread(&animalito,sizeof(animalito),1,arch1)==1)
{
// sumando 100 a edad
animalito.edad = animalito.edad + 100 ;
// como ya se leyó se regresa el apuntador al principio del
registro
fseek(arch1,r*sizeof(animalito),0 );
// y se escribe el registro modificado al archivo
fwrite(&animalito,sizeof(animalito),1,arch1);
r=r+1;
//turboc no permite i/o archivos sin un rewind, fseek, etc.
fseek(arch1,r*sizeof(animalito),0);
}; // aqui termina for
//cerrando archivo
fclose(arch1);
//avisando
puts("EDADES + 100");
}

Corrida prog27:
Corrida prog30
Corrida prog27
Como se observa la solución es muy sencilla solo se ocupa:
1. leer fread() el registro, esto mueve el apuntador al siguiente registro.
2. modificar registro
3. regresar a posición anterior con fseek()
4. grabar fwrite() el registro corregido
5. volver a usar un fseek() porque turboc no acepta i/o sin rewind, fseek, etc.
ver ayuda del compilador y no se ocupan los dos archivos como en el caso
secuencial.
EDICION O MODIFICACION DE 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.

Prog31.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
void main() {
clrscr();
printf("dame clave editar:");
FILE *archdisco;
// usar fseek() para posicionarse al principio de registro buscado
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
fclose(archdisco);

//avisando
printf("REGISTRO EDITADO");
}
cCrrida:
Observar que es el programa normal de búsqueda pero ya desplegado el registro se piden
los nuevos datos, posteriormente se regresa el apuntador de registros a la posición
original para volverse a regrabar el registro pero con los datos ya editados.

UNIDAD 7: VARIABLES APUNTADORES
INTRODUCCION PUNTEROS MEMORIA
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 strings o arreglos esta variable solo podrá
almacenar lo posición más relevante del arreglo es decir la ocupada por el primer
elemento del arreglo, mismo caso para estructuras.
Las utilidades principales de las variables apuntadores es la facilidad que tienen para
accesar 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 *var_apuntador;
Donde tipo especifica el tipo de dato al que apuntara la variable.
main()
{
int x = 7;
float y = 4.5;
int *x1;
float *y1;
}
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.
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 scanf().

APUNTADORES A ESCALARES
Variables apuntador deben ser siempre inicializadas y recordar que ellas almacenan
direcciones FISICAS DE MEMORIA RAM
Existen 2 métodos:
a) inicializar con la dirección de una variable escalar existente.
main()
{
int x,*y;
y = &x;
scanf("%d",&x);
printf("%d %d %d",x,*y,*y+30);
}
scanf("%d",y);
*y = *y+x-8;
b) usar función malloc() para reservar un espacio determinado en memoria, aquí
solo se inicializa con la dirección reservada y devuelta por el compilador.
#include <stdlib.h>
main()
{
float *y = malloc(sizeof(float));
*y = 3.14159;
printf("%f",*y);
free(y);
}
Nota: tipo float no permite captura.

APUNTADORES A STRINGS
Caso A. Solo se necesita inicializar una variable char.
main()
{
char nombre[30];
char *ch;
ch = nombre;
gets(nombre);
puts(ch);
}
Caso B.
main()
{
char *nombre = malloc(30);
gets(nombre);
puts(nombre);
free(nombre);
}

APUNTADORES A ARREGLOS
También solo se ocupa una variable apuntador normal.
Caso A.
main()
{
int x[5]={1,2,3,4,5};
int *y,renglon;
y = x;
printf("%d %d %d",x[1],*y,*(y+1));
for(renglon =0; renglon <= 4; renglon ++)
printf("%d",*(y+renglon));
}
Caso B.
main()
{
int reng;
float *x = malloc(5*sizeof(float));
*(x+2) = 3.14159;
printf("%f",*(x+2);
for(reng = 0; reng <=4; reng ++)
printf("%f",*x++);
free(x);
}

APUNTADORES A TABLAS
a)
main()
{
int x[3][5],*y;
y = x;
*(y+8) = 20;
printf("%d %d",*(y+8),x[1][3]);
}
b)
main()
{
char *nombre[6];
int reng;
for(reng = 0; reng <= 5; reng++)
gets(nombre[reng]);
puts(*(nombre+1);
}

UNIDAD 8: PROGRAMACION ORIENTADA A OBJETOS
INTRODUCCION PROGRAMACION 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 las
reglas ampliamente aprendidas para los campos de los tipos registros.
#include <iostream.h>
#include <stdio.h>
class { public :
int x;
char nombre[30];
}obj;
main()
{
clrscr();
gets(obj.nombre);
scanf("%d",obj.x);
puts(obj.nombre);
return 0;
}
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.

class{ publicpp:
int x;
char nombre[30];
int proc1(void)
}obj;
void main(void)
{
obj.proc1();
}
Un método podrá recibir parámetros, también podrá accesar a los otros campos del
objeto, incluso a otros métodos.
class { publicpp:
int x;
void proc(int y)
{
for( x = 1; x <= y; x++)
printf("Pato);
}
}obj;
void main(void)
{
obj.proc(5);
};
El real poder de OOP es la habilidad que tienen para heredar mucha de su naturaleza a
otro objeto.
Por ejemplo.
1. Pueden utilizar los elementos o campos del objeto del cual descienden, a esta
propiedad se le llama herencia.

2.
#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);
}
3. pasar parámetros al objeto del cual desciende.

4.
#include <stdio.h>
void funcion(int x)
{
printf("%d",x+6);
}
};
int z;
};
void main(void)
{
hijo hijo1;
hijo1.funcion(5);
}

5. Si el método del padre es una función podrá recibir dicho valor.
#include <stdio.h>
int funcion(int n)
{
return n+5;
}
};
int z;
};
void main(void)
{
hijo hijo1;
char nombre[30];
int parametro;
clrscr();
cout <<"Dame tu nombre.. ";
cin >>nombre;
cout <<"Dame el parametro";
cin >>parametro;
hijo.z = hijo.funcion(parametro);
cout <<"n"<<nombre<<"la funcion regreso : "<<hijo.z;
getch();
};

Manual programación lenguaje c

Más contenido relacionado

La actualidad más candente (20)

Similar a Manual programación lenguaje c (20)

Manual programación lenguaje c