Notas Del Curso Programacion y Fundamentos de Algoritmica

1.
CONCEPTOS GENERALES DE PROGRAMACIÓN
Software
Componente lógico del computador. Conjunto de programas para que el computador
funcione.
Entre ellos se tiene: Sistemas operativos, compiladores/intérpretes (Lenguajes de
programación), editores de texto, utilitarios, graficadores y otros.
Lenguajes de Programación
Sirven para escribir programas que permitan la comunicación usuario/máquina.
 Lenguajes de máquina (0 / 1)
 Lenguajes de bajo nivel (Ensamblador)
 Lenguajes de alto nivel
Lenguajes de alto nivel

Utilizan reglas sintácticas similares a los lenguajes humanos.
Primeros lenguajes
Cobol, Fortran IV, Basic, Logo
Posteriores
C, C++, Pascal, Visual Basic, Java, C
Extendidos
Ada-95, Modula-2, Prolog, LISP, Smalltalk, Eiffel
Otros visuales
Borland, Delphi, SQL, Power Builder
Para Internet
Java, HTML, XML, Java Script, Visual J, C, ASP Net, PHP, Ajax, Ruby, etc.
Compilador
Programa de computadora que permite traducir de un programa fuente a un programa
objeto.
Ejemplo:
DevC++ de Bloodshed y se ejecuta bajo Windows
GCC de GNU, se ejecuta bajo Linux y Unix
Programa
Conjunto de instrucciones que indican al computador qué debe hacer. Programa o software
son conceptos similares.
Programa fuente: instrucción escrita por el programador o desarrollador en un
lenguaje de programación.
Programa objeto: instrucciones en lenguaje máquina producida por el computador.
1
1.1 Algoritmo
Secuencia finita de instrucciones, reglas o pasos que describen de modo preciso las
operaciones que un computador debe realizar para ejecutar una tarea determinada en un
tiempo finito [ Knuth 68 ].
Es un razonamiento que nos permite resolver un problema.
A
- Idea
- Razonamiento
- Bosquejo B
Problema
- Matemático
- Lógico
Ejemplo:
Teniendo las edades de Juan y José debe determinar lo siguiente:
1. Promedio de edades
2. Quién es mayor
Solución:
Edad de Juan = X años  1°
Edad de José = Y años  2°
a) X + Y  Mat. +, / Algorit. Mat.

2
b) Si X > Y  Juan > que José “V, F”
Si Y > X  José > que Juan “T, F” Algoritmo
Si X = Y  Edades iguales
Recomendaciones
 Un algoritmo debe ser lo más corto posible.
 Si un problema grande, para su solución, se divide en partes pequeñas, entonces es más
fácil de resolver.
2 1
3
n
...
“Divide y vencerás...”
Esto es lo que en programación se llama “modularizar”

Sugerencia
Usar comentarios en los algoritmos y más tarde en los programas.
2
Dado el enunciado de un problema, se puede elaborar un algoritmo, seudo código, y
posteriormente el programa.
Enunciado
V
V
V
Algoritmo (Crear
Diseñar)
seudo código
Enunciado
Problema
“C”
“Delphi”
Programa “LISP”
“Prolog”
“PHP”
1.2 Seudo código
- Paso previo entre algoritmo y programa.

- Se usan comandos en castellano.
- Nosotros creamos los comandos.
- Se puede convertir fácilmente a un lenguaje de programación.
- Con la experiencia se puede obviar.
- Seudo código usa estructuras fijas (programación estructurada)
- Seudo código similar a las páginas estructuradas (eventos, módulos) .
1.3 Variable de Memoria

Espacio de memoria que se necesita para almacenar un dato, y puede cambiar su valor
durante la ejecución del programa o aplicación.
- Espacio de memoria RAM
- Guardar un dato
- Nombre único
Nombre variable
3
Entender el problema
¿Qué datos tengo? Datos Diagrama de Flujo
¿Qué necesito?
Procesar Algoritmo
Entregar la solución Información
Pseudocódigo
Bajo símbolos inventados se puede
simular varios lenguajes.
Herramienta utilizada en el diseño
del programa para describir la
solución del problema en forma de
algoritmos, dirigido a la máquina,
haciendo uso del lenguaje natural
lógico, sometido a ciertas reglas.
Datos Procesos Información
NUMERICAS
CONSTANTES
ALFANUMERICAS
DATOS
VARIABLES
NUMÉRICA
VARIABLES CARACTER
ALFANUMÉRICA
STRING
Ejempo de definición de Variable
Valor  5
Nombre
de la Definición
variable
Otros ejemplos
Total <- Valor + 2

Valor <- Valor + 1 (Contador)
1.4 TIPO DE VARIABLES
Variable Numéricas: Guardan números, ejemplo: 0,1,2 …………………., 9
4
Ej. Valor = 5
i ) V. Numéricas reales
ii) V. Numéricas enteras
Variables alfanuméricas:
Contienen letras y números: “A,B……..Z,a,b ….z,0,1,2 …………………………, 9”
La condición es que estén encerrados entre comillas.
Ejm. NOMBRE = “Juan”
Jose = “Jose”
Nomb. de Representa
variable al dato
Las variables alfanuméricas son las mismas que las variables tipo cadena, string, character,
cadena.
Variables lógicas:
.T., .F.
.V., .F.
Los puntos entre T, V, F sirven para identificar un valor lógico.
La lógica es una herramienta que usa el computador.
SISTEMA BINARIO
0 .F. 0FF
1 .T. ON
1.5 OPERADORES
OPERADORES ARITMETICOS
( ) Paréntesis
^ Circunflejo (Potencia)
** Potencia
* Multiplicar
/ Slash (Dividir)
+, - Suma, Resta
= Igualar
div división entera
mod resto de una división
OPERADORES RELACIONALES
A > B Mayor que

>= Mayor o igual
< Menor que
<= Menor o igual que
< > Diferente a {! =, #}
= Igual a
5
OPERADORES LÓGICOS
.AND. Incluyente
.OR. Excluyente
.NOT. Negación
AND OR
VV V VV V
VF F VF V
FV F FV V
FF F FF F
Hallando en el ejemplo el valor lógico, dados A=5, B=10, C=-1, D=0
6
Seudo código
Hallar el promedio de edades de 2 personas:
Juan = X Jose = Y
X  Edad de Juan
Y  Edad de José
Algoritmo
X + Y  Edad Promedio
2
Seudo código
Juan <- 0
Jose <- 0
Leer (Jose)
Leer (Juan)
Prom <- (Jose + Juan)/ 2
Escribir ( PROM )
Otra forma
EJose <- 0
EJuan <- 0
Escribir (‘Ingrese edad de José:’)
Leer (EJose)
Escribir (‘Ingrese edad de Juan:’)
Leer ( EJuan)
/*Prom: contiene el resultado*/
Prom <- (EJose + EJuan)/2
Escribir ( ‘El promedio de ambas edades:’, Prom)
HERRAMIENTAS PARA RESOLVER PROBLEMAS
1.6 DIAGRAMA DE FLUJO

INICIO
Inicio o fin de un proceso

FIN
Proceso (operaciones)
- Asignación
- Operación Aritmética
Entrada o salida general de

datos
Condicional
7
Líneas de unión
Indican la dirección
que siguen los datos
Impresora
Teclado
Sub-programas
Conector de
página
8
Problema:
Dados dos números elaborar un seudo código(algoritmo) para hallar la suma, y mostrar la
suma de dichos números.
A Recibidor 1er Nº
B Recibidor 2º Nº INICIO
C A+B
A <== 0
Seudo código B <== 0
C <== 0
ALGORITMO Suma
VARIABLES: A,B,C, enteros
Inicio Leer
A
A0
B0
C0
Leer
Escribir ‘Ingresar un valor’ B
Leer (A)
Escribir ‘Ingresa otro valor’
C <== A+B
Leer (B)
CA+B
Escribir( ‘La suma es:’, C)
‘La suma
Fin-inicio es ‘, C
FIN
Un algoritmo consta de 2 partes
1. Cabecera de programa
2. Bloque algoritmo
Instrucciones Básicas de un Algoritmo
Asignación RECEPTOR EMISOR
Impresión: Escribir <mensajes>, <variables>

Ej.
Escribir (‘Hola’)
/* X: Contenido de una Variable */
Escribir (‘Hola’, X)
Escribir (‘Hola’, X, ‘que tal’)
Entrada de Datos
Leer <variable>
9
Ej.
Leer (A)
Leer (A,B)
1.7 TÉCNICAS DE PROGRAMACIÓN (EVOLUCION DE LA PROGRAMACIÓN)
- Programación Lineal
-
- Programación modular
-
- Programación estructurada
-
- Programación orientada a objetos
PROGRAMACIÓN ORIENTADA A OBJETOS (POO)
POO es una técnica o estilo de programación que utiliza objetos como bloque esencial de
construcción.
Los objetos son tipos abstractos de datos (TAD)
Ej. En C (Leng. Prog.) un TAD es typedef, struct
C++ define y utiliza TAD
Un objeto es una colección de datos, junto con las funciones asociadas, utilizadas para operar
sobre esos datos.
La potencia de los objetos radica en las propiedades que soportan;
- Herencia
- encapsulación
- polimorfismo
- clases
- métodos
- mensajes
Ejemplo de trabajo con POO

Objeto: Ventana en la pantalla
Operaciones:
- Mover objeto ventana a la derecha
- Mover objeto ventana a la izquierda
- Mover objeto ventana hacia arriba
- Mover objeto ventana hacia abajo.
10
2. C/C++/DevC++
El Lenguaje C, nació en los laboratorios Bell. Este lenguaje está inspirado en el lenguaje B,
escrito por Ken Tompson en 1970.
En 1972 Dennis Ritche modifica este lenguaje creando de esta manera el lenguaje C.
El C (plus plus) (C + +) es un lenguaje de propósito general. Basado en el lenguaje C, fue
desarrollado por Bjarne Stroustrup en 1985 en los mismos laboratorios Bell.
2.1 Características
1. Es de propósito general, utilizado para una gran variedad de tareas de todo tipo. Sistemas
científicos, financieros, programas de educación, Gestión Empresarial, de pasatiempo,
etc.
2. Es de alto y bajo nivel con más características de lenguaje de alto nivel ya que es un
lenguaje civilizado, es decir cuyas instrucciones, son escritas en palabras similares a los
lenguajes humanos lo que le hace más fácil leer y entender por el programador.
Alto
goto
print
label
lenguaje C (intérprete)
Bajo
MOV
RCL
NOP
3. Es estructurado.
4. Se debe seguir un orden y cumplir ciertas reglas para el diseño de programas.
5. Permite el diseño modular aumentando la productividad de este lenguaje.
Nota:
 Es Estructurado: porque por ejemplo primero se definen las variables y luego son
utilizadas.
Además cuando hay procedimientos que se repiten son incluidos en ellos.
 Es no estructurado: cuando conforme se va necesitando se va definiendo las
variables.
Además cuando en la ejecución va y ordena a cualquier lado.
6. Posteriormente orientado a objetos.
IDENTIFICADORES
Los identificadores son una secuencia de caracteres que pueden tener cualquier longitud.
Pero sólo los primeros 32 caracteres serán significativos. Se utilizan para definir: nombres de
constantes, variables, funciones y etiquetas del programa. Los caracteres pueden ser
mayúsculas o minúsculas y se consideran como caracteres diferentes.
Ej: A y a son variables diferentes A  a (Caracteres s )
Para definir un identificador se debe seguir las siguientes reglas:
a) Debe comenzar con una letra (de la A.......Z) o de (a,....., z) exceptuando el caracter ñ,
además se puede utilizar el carácter de subrayado.
Ej. _23 (Identificador), nom_ape
b) No puede ser palabras reservadas
Ej. goto
11
c) No debe contener espacios en blanco ni caracteres especiales como por ejemplo: +, - , &,
*, /, ni códigos ASCII, ni vocales acentuadas.
Ej.
Nom
Nom / ape X
Nota1
1ra. – Nota X
nom_ape
nom – ape X
nomb ape X
break X
PALABRAS CLAVE (PALABRAS RESERVADAS)
Son identificadores predefinidos que tienen un significado especial para el lenguaje C. Un

identificador definido por el usuario no puede tener el mismo nombre que una palabra clave.
Ejms. auto
break
do
char
long
union, etc.
white (Todos los colores)
CONSTANTES
Una constante es un identificador cuyo valor se mantendrá inalterable desde el inicio hasta el
final del programa.
(1) # define (identificador) (valor)

(2) const tipo (identificador) = (Valor)
VARIABLE
Es un identificador cuyo valor puede variar o cambiar durante la ejecución de un programa.

Las variables almacenan valores de un determinado tipo de dato.
TIPOS DE DATOS PREDEFINIDOS
a) char (caracter – 1 byte): Se almacena en un byte.
Es un tipo que puede almacenar un solo carácter, correspondiente al código ASCII.

También puede almacenar un número entero en el rango: - 128 a 127. De forma similar
con el modificador unsigned (sin signo) puede almacenar valores en el rango de 0 a 255
Ej.
char op;
char letra;
op = ‘A’;
12
letra = 164;  letra = ñ;
Ej.
char op, op2;
op = 65 ; ~ op = ‘A’ ;
op = 65 + 1; ~ op = ‘B’ ;
= 65 + 100 =
op = 165 ~ op = ‘Ñ’ ;
op = ‘A’ + 1 ; ~ op = ‘B’
op = 165 ; ~ op = ‘Ñ’ ;
b) short (entero – 2 bytes); int (2 – 4 bytes de memoria)

short: Almacena la parte entera de un número en el rango de –32768 y 32767 de forma
similar con el modificador unsigned puede almacenar valores en el rango : 0 a 65535
Ejs: unsigned int num3, int num1, num2 ;

num1 = 10 ;
num1 = 10.9 ; //no considera como error pero solo asume 10
num1 = 100 + 500 ;
num2 = 400000 ;// (error) (sobrepasa desbordamiento)
num3 = 400000 ; // (error) (sobrepasa desbordamiento)
int: Almacena la parte entera de un número en el rango de –2147483648 y +2147483647
c) long (entero largo ocupa 4 bytes de memoria)
Almacena la parte entera de un número en el rango : -2147483648 y 2147483647. De forma

similar el tipo unsigned puede almacenar valores en el rango : Ø y 4294967295
unsigned long area_pais ;

long Telef ;
Telef = 752550;
d) float (reales en simple precisión – 4 bytes) (ocupa 4 bytes de memoria)
Almacena al conjunto de los números reales, es decir aquellos que poseen parte decimal
o fraccionario. Su rango de funcionamiento va desde:
-3.4 x 1038 hasta 3.4 x 1038 (7 dígitos)
No existe el modificador unsigned para float.
Ejs:
float nota ;
float pi ;
pi = 3.1416 ;
nota = 10.5 ;
e) double (reales en doble precisión – 8 bytes)
Al igual que el tipo float almacena al conjunto de los números reales, pero su rango de
almacenamiento es mucho mayor.
Almacena valores en el rango de :
Rango : -1.7 x 10308 hasta 1.7 x 10308 (15 dígitos)
Ej:
double monto = Ø ;
double cuenta ;
13
long double (8 bytes)
Almacena en el rango de: 3.4 x 10-4932 hasta 2.1 x 104932 (19 dígitos)
El tipo de dato bool

Guarda los valores “verdadero” (true) o “falso” (false), permitiendo declarar variables lógicas.
Si en el compilador de C++ no está disponible el tipo bool, se puede utilizar el tipo de dato int
para representar el tipo de dato bool. C++ utiliza el valor entero 0 para representar falso y
cualquier valor entero distinto de cero (normalmente 1) para representar verdadero. De esta
forma, se pueden utilizar enteros para escribir expresiones lógicas.
Ej.
bool b1, b2=false, b3=true;
int i1=b3, i4=10;
cout<<” b2: “<<b2<<end1; // muestra el valor b2 que es 0
SENTENCIA
Son las instrucciones que van a ser ejecutadas y que controlan el flujo de la ejecución de un
programa, toda sentencia termina con un punto y coma ( ; ) el cual significa “fin de instrucción”.
Puede existir 2 ó mas sentencias en una misma línea.

Tipos de efectos de sentencia:
Sentencia de Declaración int num ;

Sentencia de asignación num = 20 ;
Sentencia de funcion printf (“hola”) ;
Sentencia de control if (num > 50) ;
Tipos de sentencias:
Sentencia Simple : Que es simplemente una sola instrucción.
Sentencia Compuesta : bloque de instrucciones ; que es el conjunto de 2 o
mas sentencias entre llaves ({ } ).
OPERADORES :
Son símbolos que indican como deben ser manipulados los datos ;
Se clasifican en :
a) Aritméticos :
( ) paréntesis
/ slash (división) “división entera”
* asterisco (multiplicación)
% Residuo
+ Suma
- Resta
Nota :
- En la división si ambos operandos son enteros el resultado será un N° entero,

de lo contrario el resultado será real (flotante).
- En el residuo, para obtener el residuo (modulo) de
una división entera los operandos tienen que ser enteros.
Ej.:
float C ;
C = 5/2 C=2
C = 5.ø/2 ; C = 2.5
14
C = 8*2%4 resto C=Ø
C = 8+2/2 ; C=9
C = (8+2)/2 C=5
b) Operadores Lógicos :
& & y Lógico

¦ ¦ O Lógico
! no Lógico
c) Relacionales :
> Mayor
< Menor
>= mayor Igual
! = Diferente
= = Igual
Ej. int a ;
a = (10 > 5) ; // a=1

a = (10 > 15) ; // a=Ø
a = (10 = = 10) // a=1
a = (5 >= 4+1) // a=1
int b, a = 1Ø ;
b = ( a > 10 ¦ ¦ a < 20 ) ; // b = 1
b = (a + 20 < = 30 & & a ! = 10) ; // b = Ø
b = !1 ; // b = Ø …. b es igual a no “1” (falso)
d) Operadores de Asignación :
= Asignación simple
++ incremento
-- Decremento
*= Multiplicación mas asignación
/= División mas asignación
%= Módulo mas asignación
+= suma mas Asignación
-= Resta mas asignación
int a = Ø , b = 1Ø , c = Ø ;
a + + ; // a = a + 1 ; a = 1
b + = a ; // b = b + a ; b = 11
a=1;
c = + + a + b ; //a = 2 ; c = 13 ;
a=Ø;
c = (a + +) + b ; // a = 1, c = 12 ; a = 2
Estructura genérica de un programa en C++ / Dev C++
# include <archivo externo>
15
°
°
°
# define identificador valor
°
°
using namespace std;
declaraciones globales ;
°
°
declaraciones de funciones;
int main(int argc, char *argv[] ) // int main() //void main ( )
{
declaraciones locales ;
°
°
°
instrucciones ;
°
°
°
}
funcion _1 ( )
{
declaraciones locales;
°
°
°
instrucciones ;
°
°
°
}
°
°
°
°
°
funcion_N( )
{
declaraciones locales ;
°
°
°
°
instrucciones
°
°
°
°
}
# include <archivo externo>
16
Es utilizado para incorporar (incluir) archivos externos de funciones (librerías de cabeceras) a
un programa escrito en C.
Ejs.
# include “stdio. h” ~ # include <stdio.h>
# include “conio.h” ~ # include <conio.h>
# include “iostream.h” ~ # include <iostream.h>
# define identificador valor

Es utilizado para definir una constante
# define PI 3.14
# define notamax 20
Declaraciones globales
Son identificadores que podrán ser utilizadas en cualquier función del programa.
Las constantes son variables globales.
Declaraciones Locales
Son identificadores que podrán ser utilizados solo en la función en que fueron declarados.
Sentencias o Instrucciones
Son las instrucciones que controlaran el flujo de la ejecución de un programa.
int main ( )
Es la 1ra función que se ejecuta en todo programa en C++ / DevC++, siempre debe de existir
y ser única, ya que define el inicio y el final de el programa.
función_1 ( ) .....................................funcion _N ( )
Son las funciones, o módulos que pueden existir en todo programa, en la mayoría de los
casos son necesarios.
Declaraciones variables
Declarar una variable implica :
a) Definir su tipo de dato : char, int, short,

b) Asignarle un nombre o identificador
c) Opcionalmente asignarle un valor inicial
d) Además cabe resaltar que toda variable ocupa una posición física de memoria.
Ej:
int nota ;
int edad, promedio;
int suma = Ø ;
int suma = Ø, nota = Ø ;
suma = nota = Ø
float area ;
Especificadores de formato
Son símbolos especiales que determinaran como deben de capturarse o visualizarse las
variables. Siempre empiezan con el símbolo % y están seguido de uno o más caracteres
permitidos.
Para manejar los enteros, dobles, largos necesitamos de espécificadores como por ejemplo:
Especificador Tipo
17
%d int
%i int
%ld long
%f float
%lf double
%c caracter (char)
%s cadena (char*)
%p direcciones de memoria
%u enteros sin signos (unsigned)
Función printf (stdio.h)

Escribe con formato una serie de caracteres o un valor en la salida estándar (pantalla).
Devuelve el N° de caracteres escritos. Se encuentra en la librería stdio.h.
Nota. En C escribir todo en minúscula, excepto por Ej: variables y etc.
Función cprintf
Similar a printf se utiliza para visualizar atributos de video (ej: subrayado, negrito, colores), se
encuentra en la librería conio.h.
Al imprimir o mostrar en la pantalla , y leer :

En C En C + +
printf ( ) cout<<”………………….”;
scanf ( ) cin »___;
gets() gets(); cin.getline( );
Entradas y salidas
En c++ la entrada y salida se lee y escribe en flujos (streams). Cuando iostream.h se incluye
en un programa , diferentes flujos estándar son definidos automáticamente . El flujo cin se
utiliza para la entrada , que normalmente se lee de teclado. El flujo cout se utiliza para salida
y, normalmente , se envía a la pantalla del usuario
Salida (cout)
El operador de inserción , <<, inserta datos en el flujo cout que los visualiza en la pantalla del
equipo. Es posible utilizar una serie de operadores, <<, en cascada.
cout<<“esto es una cadena”;: // visualiza : esto es una cadena

cout<<500<<600<<700; // visualiza : 500 600 700
cout<<500<<“ ,” <<600; // visualize : 500 , 600
C++ utiliza secuencias de escape para visualizar caracteres que no están representados por
símbolos tradicionales. Entre las mas usadas están : linea.nueva linea (\ n) , tabulacion (\ t) y
alarma (\ a). Una lista de las secuencias de escape se muestra en la tabla 1.1.
Ej
cout<<“\n Error \n Pulsar una tecla para continuar \n” ;
La instrucción anterior salta de la línea , escribe en otra línea error , salta de línea escribe
pulsar una tecla para continuar y saltar de línea. Es decir produce la siguiente salida :
Error
Pulsar una tecla para continuar
Tabla 1.1. Caracteres secuencias de escape
18
Secuencia de escape Significado
\a Alarma
\b Retroceso de espacio
\f Avance de pagina
\n Retorno de carro y avance de linea
\r Retorno de carro
\t Tabulacion
\v Tabulacion vertical
\\ Barra inclinada
\? Signo de interrogación
\“ Dobles comillas
\ 000 Numero octal
\xhh Numero hexadecimal
\0 cero , nulo (ASCII 0)
Entrada ( cin )
El archivo de cabecera iostream.h de la biblioteca C++ proporciona un flujo de entrada

estandar cin y un operador de extracción , », para extraer valores del flujo y almacenarlos en
variables . Si no se redirige explícitamente cin , la entrada procede del teclado.
int numero; double real ;

cin»numero; cin»real ;
Las ordenes cin leen dos datos del teclado y los almacenan en las variables número y real.
Ejemplo : Programa que lee las iniciales del nombre y primer apellido y las escribe en pantalla
seguidas de un punto.
#include <cstdlib>
#include <iostream>
int main( )
char Nombre , Apellido ;
cout<<“ Introduzca la inicial de su nombre y primer apellido : “ ;

cin»Nombre»Apellido;
cout<<“Hola,” <<Nombre<< “.”<<Apellido<<”.\ n”;
system ( “ PAUSE”);
return EXIT_SUCCESS;
Espacios de nombres (NAMESPACES)
Un espacio de nombres es un mecanismo para agrupar lógicamente un conjunto de

identificadores (nombres de tipos , funciones , etc). Existe un espacio de nombres global y
sobre él se define el resto de los espacios de nombres. A un identificador que se encuentra
en un espacio de nombres se puede acceder de distintas formas.
Ej: Espacio de nombre estandar.
19
En el programa estandar , la claúsula using carga espacio de nombres estandar (std) en el
espacio de nombres actual, que es global permitiendo así el ejemplo de identificadores como
endl (declarado en <iostream> sin necesidad de cualificar con el operador de alcance).
// Programa
#include <iostream>
………………………..
using namespace std ;
int main( )
{
cout<<“ ! Hola amigos ! ” <<endl;
}
Un espacio de nombres namespace es una región declarativa con nombre opcional . El

nombre de un espacio de nombres se puede utilizar para acceder a entidades declaradas en
ese espacio de nombres ; es decir los miembros del espacio de nombres .
En esencia , un conjunto de variables , de funciones , de clases y de subespacios de nombres,
miembros que siguen unas reglas de visibilidad . El espacio de nombres es una característica
de C++ introducida en las ultimas versiones , diseñada para simplificar la escritura de
programas.
Definición de un espacio de nombres
namespace identificador{cuerpo_del_espacio_de_nombres.}
Cuerpo_del_espacio_de_nombres
Seccion_de_declaraciones // miembros del espacio de nombre
Para acceder al espacio de nombres se debe invocar al nombre del mismo cuando se refiera
a ellos Existen dos procedimientos para hacer esto.
Metodo 1 : Proceder a cada nombre del elemento en el nombre del espacio y el operador de
resolución del ámbito de alcance (::).
Metodo 2 : Utilizar la directiva using , lo que permite poder utilizar el espacio de nombres a
partir de donde se declare.
Ej. Espacio de nombres geo
#include<iostream>
namespace geo
{
const double PI = 3.141592;

double longcircun ( double radio)
return 2*PI*radio;
}

using namespace geo;
int main (int argc, char *argv[] )
20
{
cout<<“ ! Hola amigos ! ” <<endl;

cout<<longcircun(16); // no funciona al omitir using namespace geo ;
cout<<geo::longcircun(20);
}
Ejercicios secuenciales
1. Escribir un programa que visualice la letra B con asteriscos
*****
* *
* *
* *
******
* *
* *
* *
*****
#include <cstdlib>
#include <iostream>

int main ( )
{
cout<<“******* \ n” ;
cout<<“* * \ n” ;
cout<<“* * \ n” ;
cout<<“* * \ n” ;
cout<<“******* \ n” ;
cout<<“* * \ n” ;
cout<<“* * \ n” ;
cout<<“* * \ n” ;
cout<<“******* \ n”
system ( “ PAUSE”);
return EXIT_ SUCCESS;
}
Operadores y expresiones
En c++ los operadores fundamentales son: aritméticos, lógicos y relacionales; de
manipulación de bits; condicionales y especiales. Además, se analizan las conversiones de
tipos de datos y las reglas que sigue el compilador cuando concurran en una misma expresión
diferentes tipos de operadores. Estas reglas se conocen como reglas de prioridad y
asociatividad.
Los programas C++ constan de datos, sentencias de programas y expresiones. Una expresión
es, una sucesión de operadores y operandos debidamente relacionados que especifican un
cálculo. C++ soporta un conjunto potente de operadores unitarios, binarios y de otros tipos.
Operador de asignación
El operador de asignación es un operador cuya sintaxis es la siguiente:
21
variable=expresión;
donde variable es un identificador válido de C++ declarado como variable. El operador =

asigna el valor de la expresión derecha a la variable situada a su izquierda. Este operador
es asociativo por la derecha, eso permite realizar asignaciones múltiples. Así, A=B=C=D=12;
equivale a A= (B=(C= (D=12))) que asigna alas variables A,B,C y D el valor de 12. Esta
propiedad permite inicializar varias variables con una solo sentencia. Además del operador
de asignación =, C++ proporciona cinco operadores de asignación adicionales dados en la
tabla 1.2.
Ejemplo
Programa que declara variables y hace uso de operadores de asignación.
#include<cstdlib>
#include <iostream>
int main(int argc, char *argv[])

{
int codigo, CoordX, CoordY;
float fahrenheit , valor;
codigo=3467;
valor=10 ;
valor *=3;
CoordX =525;
CoordY =725
CoordY - =10;
fahrenheit = 123.456;
system(“PAUSE”);
}
Tabla 1.2 Operadores y equivalencias de asignación C++
Símbolo Uso Descripción Sentencia Sentencia

abreviada no abreviada
= a=b Asigna el valor de b a a. m=n; m=n;
*= a *=b Multiplica a por b y asigna el resultado a la variable a. m *=n; m =m*n;
/= a /=b Divide a entre b y asigna el resultado a la variable a. m / =n; m=m/n;
%= a %=b Fija a al resto de a/b. m%=n; m=m%n;
+= a +=b Suma b y a y los asigna a la variable a. m+=n; m=m+n;
-= a - =b Resta b de a y asigna el resultado a la variable a. m-=n; m =m-n;
Operadores aritméticos
Los operadores aritméticos de C++ sirven para realizar operaciones aritméticas básicas.
Siguen las reglas algebraicas típicas de jerarquía o prioridad, clásica de matemáticas. Estos
operadores se aprecian también en la tabla 1.3.
Tabla 1.3 Operadores aritméticos
Operador tipos enteros tipos reales ejemplo
+ Suma Suma x+y
22
- Resta Resta b-c
* Producto Producto x*y
/ División entera: Cociente División en coma flotante b/5
% División entera: Resto b%5
Los paréntesis se pueden utilizar para cambiar el orden usual de evaluación de una expresión
determinada por su prioridad y asociatividad. La prioridad de los operadores y su asociatividad
se recogen en la tabla 1.4
Tabla 1.4 Prioridad y asociatividad
Prioridad (mayor a menor) Asociatividad

+, - (unitarios) izquierda-derecha(---)
*, /, % izquierda-derecha(--)
+, - izquierda-derecha(--)
Ejemplo Evaluación de expresiones
a) ¿Cuál es el resultado de evaluación de la expresión: 5 * (10 – 2 * 4 + 2 ) – 2?
5 * (10 – 2 * 4 + 2) -2
5 * (10 – 8 + 2) -2
5 * 4 -2
20- 2
18
b) ¿Cuál es el resultado de la expresión: 7 * 5 – 6 % 4 * 4 + 9?
7*5-6%4*4+9
35-6%4*4+9
35-2*4+9
35-8+9
27+9
36
c) ¿Cuál es el resultado de la siguiente expresión 15 * 14 – 3 * 7?
15*14-3*7
210-3*7
210-21
189
d) ¿Cuál es el resultado de la siguiente expresión 3 + 4 *(8 *(4-(9+3)/6))?
3+4*(8*(4-(9+2)/6))
3+4*(8*(4-11/6))
3+4*(8*(4-1))
3+4*(8*3)
3+4*24
3+96
99
23
EJEMPLO
Programa que lee el radio , calcula y visualiza la longitud de la circunferencia de ese radio , y
el área del circulo del mismo radio.
#include<cstdlib>
#include <iostream>
#define pi 3.141592

{
float radio, longitud, area;
cout<<”radio de una circunferencia=”;
cin>>radio;
longitud= 2 * pi* radio;
area= pi * radio * radio;
cout<<”radio=”<<radio<<endl;
cout<<”longitud=”<<longitud<<endl;
cout<< “area = “<< area <<endl;
return EXIT_ SUCCESS;
}
EJEMPLO
Desglosar cierta cantidad de segundos introducida por teclado en su equivalente en
semanas, día, horas, minutos y segundos.
El programa lee el numero de segundos y realiza las conversiones, teniendo en cuenta que
una semana tiene 7 días , un día tiene 24 horas , una hora 60 minutos, y un minuto 60
segundos.
#include<cstdlib>
#include <iostream>

{
int semanas ,dias, horas ,minutos ,segundos ,acu;
cout<<”introduzca segundos”;
cin>>acu;
segundos = acu%60;
acu = acu / 60;
minutos= acu%60;
acu = acu / 60;
horas= acu%24;
acu = acu / 24;
dias= acu%7;
semanas = acu / 7;
cout<<” segundos en semanas dias horas minutos y segundos”<<endl;

cout<<”numero de semanas”<<semanas<<endl;
cout<<”numero de dias”<<dias<<endl;
cout<<”numero de horas”<<horas<<endl;
cout<<”numero de minutos”<<minutos<<endl;
cout<<”numero de segundos”<<segundos<<endl;
24
}
En resultado de ejecución dará lo siguiente:
Introduzca segundos 4567456

Segundos en semanas dias horas minutos y segundos
Numero de semanas 7
Numero de dias 3
Numero de horas 20
Numero de minutos 44
Numero de segundos 16
Presione una tecla para continuar. . .
Operadores de incrementación y decrementación
De las características que incorpora C++ una de las mas útiles son los operadores de
incremento ++ y decremento--. Estos operadores unitarios suman o restan 1 respectivamente
a la variable y tiene la propiedad de que puedan utilizarse como sufijo o prefijo. El resultado
de la expresión puede ser distinto, dependiendo de contexto. En la tabla 1.5 se recogen los
operadores de incremento y decremento.
Tabla 1.5 operadores de incremento(++)y decremento(- -)
Incrementación Decrementación
++n, n++ --n, n--

n += 1 n -= 1
n= n+1 n= n – 1
si los operadores ++ y - - están de prefijo, la operación de incremento se efectúa antes que la

operación de asignación; si los operadores ++ y - - están de sufijos, la asignación se efectúa
en primer lugar y la incrementación o decrementación a continuación.
Ejemplo diferencias entre operadores de preincrementacion y postincrementacion.
#include<cstdlib>
#include <iostream>

{
int m= 10, n;
n=++m; // primero se incrementa m y luego se asigna a n

cout<<”m=”<<m<<”n=”<<n<<endl;
n=m++; // primero se asigna a n y luego se incrementa m
cout<<”m=”<<m<<”n=”<<n<<endl;
cout<<”m=”<<m++<< endl;
cout<<”m=”<<++m<< endl;
n=5;
m=++n * - -n; // ++n pone n a 6, luego - - n pone n a 5, luego m =25
cout<<”n=”<<n<<”m=”<<m<<endl;
25
}
Resultado de la ejecucion
m =11 n=11
m =12 n=11
m =12
m =14
n =5 m =25
Operadores relacionales
C++ soporta el tipo bool que tiene dos literales false y true. Una expresión booleana es, por
consiguiente, una secuencia de operandos y operadores que se combinan para producir uno
de los valores true y false. C++ utiliza el tipo int para representar los valores verdadero (true)
y falso (false). El valor entero 0 representa a falso y cualquier valor distinto de cero a
verdadero. Operadores tales como >= y == que comprueban una relación entre dos operandos
se llaman operadores relacionales y se utilizan en expresiones de la forma:
expresión1 operador_relacional expresión2
expresión 1 y expresión 2 expresiones compatibles C++

operador_relacional un operador de la tabla 1.6
La tabla los operadores relacionales que se pueden aplicar a operandos de cualquier tipo de
dato estandar:
char, int, float, double,etc
Tabla de 1.6 operadores relacionados de C
Operador significado forma ejemplo
== igual a a== b ‘A’ == C’ FALSO

!= no igual a a != b 2 != 4 VERDADERO
> mayor que a>b 5>6 FALSO
< menor que a<b ‘a’ < ‘c’ VERDADERO
>= mayor o igual que a >= b ‘B’ >=’b’ FALSO
<= menor o igual que a <= b 2 <= 1 FALSO
OPERADORES LOGICOS
Los operadores lógicos se utilizan con expresiones para devolver un valor verdadero
(cualquier entero distinto de cero) o un valor falso(0). Los operadores lógicos de C son: not(!),
and (&&) y or(ll). El operador unitario logico ! (not, no) produce falso (cero) si su operando es
verdadero(distinto de cero) y viceversa. El operador binario logico &&(and , y) produce
verdadero solo si ambos operandos son verdaderos(no cero); si cualquiera de los operandos
26
es falso produce falso. El operador binario logico ll (or, o) produce verdadero si cualquiera de
los operandos es verdadero(distinto de cero ) y produce falso solo si ambos operandos son
falsos.
La precedencia de los operadores es: los operadores matemáticos tienen precedencia sobre
los operadores relacionales, y los operadores relacionales tienen precedencia sobre los
operadores lógicos.
El operador ! tiene prioridad mas alta que &&, que a su vez tiene mayor prioridad que ll . La
asociatividad es de izquierda a derecha.
Evaluación en cortocircuito. En C++ los operandos de la izquierda de && y ll se evaluán

siempre en primer lugar ; si el valor del operando de la izquierda determina de forma
inequívoca el valor de la expresión, el operando derecho no se evalúa. Esto significa que si el
operando de la izquierda de && es falso o el de || es verdadero, el operando de la derecha
no se evalúa. Esta propiedad se denomina evaluación de corto circuito.
Las sentencias de asignación se pueden escribir de modo que se pueda dar un valor de tipo
bool o una variable bool.
Ejemplo: Sentencias de asignación a los tipos de variables bool.
int n;
float x;
char car;
bool r, esletra, espositiva;
r=(n>-100) && (n<100); //true si n estan entre -110 y 100

esletra=((‘A’<=car) && (car<=’Z’))
((‘a’<=car) && (car<=’Z’));
// si car es una letra la variable es la letra true, y toma false en otro caso
//espositivo = x >= 0;
Operadores de manipulación de bits
Los operadores de manipulación o tratamiento de bits (bitwise) ejecutan operaciones lógicas

sobre cada uno de los bits de los operandos. Estas operaciones son comparables en eficiencia
y en velocidad a sus equivalentes en lenguaje ensamblador. Cada operador de manipulación
de bits realiza una operación lógica bit a bit sobre datos internos. Los operadores de
manipulación de bits se aplican solo a variables y constantes char, int y long, y no a datos en
coma flotante.
La tabla 1.7 recoge los operadores lógicos bit a bit.
Tabla 1.7 Operadores lógicos bit a bit
Operador Operacion
& y (and) lógica bit a bit.

| o (or) lógica (inclusiva) bit a bit
^ o (xor) lógica (exclusiva) bit a bit (or exclusive,xor).
~ Complemento a uno (inversión de todos los bits)
<< Desplazamiento de bits a izquierda
>> Desplazamiento de bits a derecha
27
Operadores de desplazamiento de bits (>>,<<)
Efectúa un desplazamiento ala derecha (>>) o a la izquierda (<<) de numero_de_bits

posiciones de los bits del operando, siendo numero_ de _ bits un numero entero. Los
formatos de los operadores de desplazamiento son:
1. valor << numero_de_bits; 2. valor >> numero_de_bits;
Ejemplo sentencia de manipulación de bits
Variable V. entero V binario

X 9 00001001 1001
Y 10 00001010 1010
X&Y 8 00001000 1001 & 1010 and bit a bit
X|Y 11 00001011 1001 | 1010 or bit a bit
XˆY 3 00000011 1001 ˆ 1010 xor bit a bit
X << 2 36 01000100 1000100 aparecen dos ceros a la derecha
Y >> 2 2 00000010 10
El siguiente programa comprueba los valores anteriores de manipulación de bits
#include<cstdlib>
#include <iostream>
int main(int argc, char*argv[])

{ int x=9, y=10, x_y_y, x_or_y, x_Xor_y;
x_y_y = x & y;
x_or_y = x | y;
x_Xor_y = x ˆ y;
cout << “x= ”<< x << “ \n”;
cout << “y= ”<< y << “ \n”;
cout << “x_y_y = ” << x_y_y << “ \n”;
cout << “x_or_y = ”<< x_or_y << “ \n”;
cout << “x_Xor_y = ”<< x_Xor_y << “ \n”;
x=x<<2;
y=y>>2;
cout << “x<<2= ”<< x << “ \n”;
cout << “y>>2= ”<< y << “ \n”;
system (“PAUSE”);
El resultado de ejecución del programa anterior es :
x=9
y=10
x_y_y=8
x_or_y=11
x_Xor_y=3
x << 2=36
x >>2=2
28
Operadores de asignación adicionales
Los operadores de asignación abreviados estan disponibles tambien para operadores de

manipulación de bits estos operadores se muestran en la tabla 1.8.
Tabla 1.8. Operadores de asignación adicionales
Símbolo Uso Descripción

<<= a << =b Desplaza a a la izquierda b bits y asigna el resultado a a.
>>= a >> =b Desplaza a a la derecha b bits y asigna el resultado a a
&= a &= b Asigna a a el valor a & b.
ˆ= a ˆ= b Establece a a aˆ=b.
||= a ||= b Establece a a a | b.
Operadores de direcciones
Son operadores que permiten manipular las direcciones de los objetos. Se recogen en la tabla
1.9
Tabla 1.9 operadores de direcciones
Operador Acción
* Lee o modifica el valor apuntado por la expresión. Se corresponde con un puntero

y el resultado es de tipo apuntado.
& Devuelve un puntero al objeto utilizado como operando, que debe ser un lvalue
(variable dotada de una dirección de memoria). El resultado es un puntero de tipo
idéntico al del operando.
. Permite acceder a un miembro de un objeto agregado (unión, estructura).
-> Accede a un miembro de un objeto agregado (unión, estructura) apuntado por el
operando de la izquierda.
Operador condicional ?
El operador condicional ?, es un operando ternario que devuelve un resultado cuyo valor

depende de la condición comprobada. El formato del operador condicional es:
expresion_L ? expresion_v: expresion_f;
Se evalúa la expresión lógica expresión_L y su valor determina cual es la expresión a

ejecutar; si la condición es verdadera se ejecutara expresión_v y si es falsa se ejecutara la
expresión_f. La presencia de
? es menor que la de cualquier otro operando tratado hasta ese momento. Su asociatividad
es a derecha.
Ejemplo Uso del operador condicional ?.
#include<cstdlib>
#include <iostream>

{
int x = 10, y = 12, mayor, menor;
29
bool z;
z= x >= y ? true : false ; // z toma el valor de false.
mayor= x >= y? x : y; // calcula y almacena el mayor
menor= x >= y? y : x ; // calcula y almacena el mayor
cout<< “x=”<< x << ” \n”;
cout<< “y=”<< y << ” \n”;
cout<< “el mayor es = “<< mayor <<” \n”;
cout<< “el menor es =”<< menor << ” \n”;
}
RESULTADO DE EJECUCION
x=10
y=12
el mayor es=12
el menor es = 10
Operador coma
El operador coma permite combinar dos o mas expresiones separadas por comas en una sola
línea. Se evalua primero la expresión de la izquierda y luego las restantes expresiones de
izquierda a derecha. La expresión mas a la derecha determina el resultado global de la
expresión. El uso del operador coma es:
expresion1, expresion2, expresion3……….expresión
Cada expresión se evalúa comenzando desde la izquierda y continuando hacia la derecha
Ejemplo Uso del operador condicional , .
#include<cstdlib>
#include <iostream>

{
Int i, j, r, k;
r = j = 10, i = j, k=(i++,i+1);
cout <<” i= “<< << “ j =” << j << “ r= “<< r <<” k=” << k << ” \n” ;
retun EXIT_SUCCESS;
}
EL RESULTADO DE EJECUCION ES:
i=11 j=10 r=10 k=12
j toma el valor de 10 , r toma el valor de j que es 10, i toma el valor de 10. Posteriormente i
toma el valor de 11 se ejecuta la expresión de i + 1 que es 12 y se asigna a k.
Operadores especiales ( ), [ ] y ::
C++ admite algunos operadores especiales que sirven para propositos diferentes. Cabe
destacar : ().[] y ::.
30
El operador () es el operador de llamada a funciones. Sirve para encerrar argumentos de una
funcion, efectuar conversiones explicitas de tipo, indicar en el seno de una declaracion que un
identificador corresponde a unaq funcion y resolver los conflictos de prioridad entre
operadores.
El operador [] sirve para designar un elemento de un array. Tambien se puede utilizar en union
con el operador delete ; en este caso , indica el tamaño de arraya destruir y a su sintaxis es:
delete[tamaño_array] puntero_array;
El operador :: es especifico de C++ y se denomina operador de ambito de resolucion , y
permite especificar el alcance o ambito de un objeto. Su sintaxis es:
class::miembro o bien ::miembro
El operador sizeof
C++ proporciona el operador sizeof, que toma un argumento, bien un tipo de dato o bien el
nombre de una variable (escalar, array, registro,etc), y obtiene como resultado el numero de
bytes que ocupa. El formato del operador es:
sizeof(nombre_variable)
sizeof(tipo_dato)
sizeof expresión
Ejemplo El siguiente programa escribe el tamaño de los tipos de datos en el computador.
#include<cstdlib>
#include <iostream>

{
cout<< “ el tamaño de variables de esta computadora son:\n”;
cout<<”entero: “<<sizeof(int) << ‘ \n’;
cout<<”entero largo: “<<sizeof(long int) << ‘\n’;
cout<<” rael : “<< sizeof(float)<<’\n’;
cout<<”doble; “<<sizeof(double) << ‘\n’;
cout<<” long doble: “<<sizeof(long double) << ’\n’;
cout<<” long doble:”<<sizeof 20 << ‘\n’;
}
Conversiones de tipos
Las conversiones de tipos pueden ser implícitas (ejecutadas automáticamente) o explicitas

(solicitadas específicamente por el programador). C++ hace muchas conversiones de tipos
automáticamente: convierte valores cuando se asigna un valor de un tipo a una variable de
otro tipo; convierte valores cuando se combinan tipos mixtos en expresiones; convierte valores
cuando se pasan argumentos a funciones.
Conversión implícita. Los tipos fundamentales (básicos) pueden ser mezclados libremente
en asignaciones y expresiones. Las conversiones se ejecutan automáticamente: los
operandos de tipo mas bajo se convierten a los de tipo mas alto de acuerdo con las siguientes
reglas: si cualquier operando es de tipo char, short o enumerado se convierte en tipo int ; si
los operandos tienen diferentes tipos, la siguiente lista determina a que operación convertirá.
Esta operación se llama promoción integral.
31
Int, unsigned int, long, unsigned long, float, double
El tipo que viene primero , en esta lista , se convierte en el que viene segundo, etc.
Conversiones explicitas. C++ fuerza la conversión explicitas de tipos mediante el operador

de molde (cast). El operador molde tiene el formato (tiponombre) valor. Convierte valor a
tiponombre.
Por ejemplo dada la declaracion : float x;
X= 3/2 asigna a x el valor de 1,

X= (float)3/2 asigna a x el valor de 1. 5
Ejemplo: El siguiente programa muestra conversiones implícitas y explicitas de enteros y

caracteres
#include<cstdlib>
#include <iostream>

{
char c=’Z’ + 1 ; //asigna a c el siguiente carácter de ‘Z’
cout <<’A’ << “ “ <<(int)’A’ << endl; //carácter y numero ASCII

cout <<’0’ << “ “ <<(int)’0’ << endl; //carácter y numero ASCII
cout <<’a’ << “ “ <<(int)’a’ << endl; //carácter y numero ASCII
cout <<’c’ << “ “ <<(int)’c’ << endl; //carácter y numero ASCII
cout <<’z’ +1 << “ “ <<(char)(’Z’+1) << endl; // numero ASCII y carácter
}
LA EJECUCION DEL PROGRAMA ANTERIOR
A 65
0 48
a 97
[ 91
91 [
Prioridad y asociatividad
La prioridad o precedencia de operadores determina el orden en que se aplican los operadores

a un valor. A la hora de evaluar una expresión hay que tener en cuenta de las siguientes reglas
y la tabla 1.10.
- Los operadores del grupo 1 tienen mayor prioridad que los de grupo 2 y así
sucesivamente.
- Si dos operadores se aplican el mismo operando, el operador con mayor prioridad
se aplica primero.
- Todos los operadores del mismo grupo tienen igual prioridad y asociatividad
- La asociatividad izquierda-derecha significa aplicar el operador mas a la izquierda
primero , y en la asociatividad derecha-izquierda se aplica el operador mas a la
derecha
- Los paréntesis tiene la máxima prioridad .
32
Tabla 1.10 Prioridad y asociatividad de los operandos
Prioridad Operadores Asociatividad
1 :: x -> [ ] () I-D
2 ++ -- ~ ! - + & * sizeof D-I
3 . * ->* I-D
4 * / % I-D
5 +- I-D
6 << >> I-D
7 < <= > >= I-D
8 == != I-D
9 & I-D
10 ^ I-D
11 | I-D
12 && I-D
13 || I-D
14 ?: (expresión condicional) D-I
15 = *= /= %= += -= <<= >>= &= ||= ^= D-I
16 ,(operador coma ) I–D
I – D : IZQUIERDA A DERECHA D – I : DERECHA A IZQUIERDA
EJERCICIOS :
a. Determina el valor de las siguientes expresiones aritmeticas
15/12 15&12
24/12 24%12
123/100 200%100
b. ¿Cuál es el valor de cada una de las siguientes expresiones?
a) 10 * 14 – 3 * 2 d) (4-40/5)%3
b) -4 +5 *2 e) 4*(3+5)-8*4&2-5
c) 13-(24+2*5)/4 & 3 f) -3*10+4*(8+4*7-10*3)/6
TRABAJO PARCIAL
1. Elaborar un algoritmo y seudo código para hallar el máximo común divisor de dos
números.
33
Sugerencia: aplicar repetidamente la resta del mayor con el menor, hasta que ambos sean
iguales.
2. Elaborar un algoritmo para hallar el cuadrado de un número de un número entero n.

Sugerencia: el cuadrado de un número entero n se evalúa por la suma de los n primeros
impares.
3. Calcular la planilla de una empresa, se ingresa el número de los empleados, y para cada
uno de ellos se ingresa el número de horas y el pago por hora; se calcula el pago y se
acumula para el total de la planilla.
4. Algoritmo que calcule el producto de los n primeros números naturales.
5. Escribir un algoritmo que permita emitir la factura correspondiente a la compra de un solo

artículo determinado del que se adquieren una o varias unidades. Si al precio bruto(Precio
del artículo*Nro de unidades del artículo)-Valor de venta de la factura se realiza un
descuento del 1%, calcular el IGV (18%), además el precio de venta.
6. Dados tres números A,B,C; hallar el menor, intermedio y el mayor.
7. Dados tres números A,B,C; hallar el mayor.
8. Dados tres números A,B,C; hallar el menor.
9. Se necesita conocer una serie de datos de una empresa con 50 empleados:
a. ¿ Cuántas personas ganan más de 3000 nuevos soles al mes?

b. ¿ Entre 700 y 3000 nuevos soles?
c. Menos de 700 nuevos soles
d. Imprimir el valor del menor sueldo.
10. Realizar un algoritmo que permita calcular la nota media(promedio) general de todos los
alumnos de un curso considerando N (como número de alumnos)
Nota: se debe pedir el número de alumnos, nombre del alumno, además nota promedio
de cada alumno en el curso.
3. ESTRUCTURAS DE CONTROL SELECTIVAS

Permiten evaluar una condición y puede ser: simple, doble, múltiple.
34
Estructura de Control simple (Condicional Simple)
Evalúa una condición simple.
Condici
SI ón
Si <condición> -
---- -
---- -----
---- -----
---- -----
Fin_Si -
---- -----
---- -
---- ----
----
-
-
-
- ----
----
- ----
- Es independiente de la
- ----
condición
-
----
Ejercicio
Realizar un algoritmo que determine cuál es el mayor de 3 datos numéricos ingresados.
A B C
1 2 3
35
ESTRUCTURA DE CONTROL DOBLE (CONDICIONAL DOBLE O DE DOS CAMINOS)
Condici
SI ón NO
----
----
----
----
----
----
----
----
----
Evalúa una condición, y ejecuta un conjunto de instrucciones en caso de ser verdadera y
otra en caso de ser falsa.
A B C VMAYOR
1 2 3 3
Si A > B
Si A > C Si A > B
Escribir ‘El mayor es’, A VMAYOR  A
Si_no Si_no
Escribir ’El mayor es’, C VMAYOR  B
Fin_si
Fin_si
Si_no
Si B > C Si C > VMAYOR

Escribir ‘El mayor es’, B VMAYOR  C
Si_no
Fin_si
Escribir ‘El mayor es’, C Escribir ‘El mayor es’, VMAYOR

Fin_si
Fin_si
36
ALGORITMO MAYOR
Variables:
A, B, C, VMAYOR: Entero
INICIO (Acción Principal)

A <- 0
B <- 0
C = 0
VMAYOR  0
Escribir ‘Ingrese el primer valor’

Leer A
Escribir ‘Ingrese segundo valor’

Leer B
Escribir ‘Ingrese tercer valor’

Leer C
Si A > B
VMAYOR  A
Si_no
VMAYOR  B
fin_si
si C > VMAYOR
VMAYOR  C
fin_si
Escribir ‘El mayor es’, VMAYOR

FIN_INICIO
37
INICIO
A0
B0
C0
VMAYOR  0
SI VMAYOR < B
VMAYOR  B
Ingrese el 1er.
valor F_si
A
SI VMAYOR < C
Ingrese el 2do. VMAYOR  C
valor
B F_si
Ingrese el 3er.
valor
C
Si A> NO
B
VMAYOR  A VMAYOR  B
NO C> SI
VMAYOR
VMAYOR  C
‘El mayor es’,

VMAYOR
FIN
if – else ( Si – Sino )
Ejecuta una instrucción si una condición dada es verdadera, y opcionalmente otra en caso
sea falsa.
Formato
38
if (Condición)
Instrucción;
else
Instrucción;
Donde la condición es una expresión lógica (solo puede ser verdadero o falso.)
Instrucción.- Es el grupo de sentencias que serán ejecutadas.
Observaciones.-
1. Si la condición es verdadera, la sentencia “if” asumirá que el valor resultante en la

condición fue 1. de lo contrario fue 0.
2. Si hay mas de una instrucción, estas deben estar encerradas entre llaves.
Ejemplo
Elaborare seucocódigo y programa que pida el sueldo de un empleado y determine su
bonificación si:
a) Si el Empleado gana menos de 500, la bonificaron será de 15%

b) Si el Empleado gana 500 o mas, la bonificaron será del 10%
El programa deberá imprimir la bonificación que le corresponde a ese empleado junto con
su nuevo sueldo.
#include <cstdlib>
#include <iostream>

{
float sueldo,bonif,tot ;
cout<<" Ingrese Sueldo: ";
cin>>sueldo;
if (sueldo>=500)
bonif= sueldo* 0.10;
else
bonif= sueldo*0.15;
tot= sueldo+ bonif;
cout<<"\n La bonificacion es: "<<bonif;
cout<<"\n El sueldo total es: "<<tot<<endl;
system("PAUSE");
}
ESTRUCTURA DE CONTROL MULTIPLE (SELECCIÓN MULTIPE)

(Según sea o caso de /case)
Permite evaluar una condición y seleccionar un caso dependiente de la acción que se
requiere.
Ver figura 1.1
39
Ejercicio
1. Diseñar un algoritmo que escriba los nombres de los días de la semana en función del valor
de una variable Día introducida por teclado.
Los días de la semana son 7; por consiguiente, el rango de valores de días será 1….7, y
caso de que día fuere un valor fuera de este rango se deberá producir un mensaje de crear
advirtiendo la situación ano malas.
Co
AcFF Acción Acción Acción

FF C2 C3 Acción Cn
1 C3 ......
Figura 1.1
Según- sea E hacer
Inicio
E1: Acción S1
E2: Acción S2
E3: Acción S3
*
*
*
*
En: Acción Sn
Fin
Otras : acción Sx
Fin – Según
Caso expresión de
C1: Acción S1
C2: Acción S2
C3: Acción S3
*
*
*
*
Cn: Acción Sn
En cualquier otro caso
Acción Sx
Fin caso
40
switch ( Según Sea)
Permite ejecutar una o varias sentencias, evalúa una expresión y compara su valor en una
lista de opciones.
Formato
switch ( expresión )
{
case const1 : instrucción(s) ; break ;
case const2 : instruccion(s) ; break :
*
*
*
*
case constN : instruccion(s) ; break ;
default : instruccion(s) ; break;
}
Donde :
Expresión. – Puede ser un valor entero o de tipo char.

Instrucción. – Puede ser una sentencia simple o compuesta.
Ejemplo:
Dado el número de un mes del 1 al 12, mostrar el nombre del mes, en otro caso error.
#include <cstdlib>
#include <iostream>

{
int nmes;
cout<<"\n Ingrese Numero de Mes:";
cin>>nmes;
switch(nmes)
{
case 1 : printf ( "Enero");break ;
case 2 : printf ("Febrero");break ;
case 3 : printf ("Marzo");break ;
case 4 : printf ("Abril");break ;
case 5 : printf ("Mayo");break ;
case 6 : printf ("Junio");break ;
case 7 : printf ("Julio");break ;
case 8 : printf ("Agosto");break ;
case 9 : printf ("Sieptiembre");break ;
case 10 : printf ("Octubre");break ;
case 11 : printf ("Noviembre");break ;
41
case 12 : printf ("Diciembre");break ;
default : printf ("Mes Erroneo");break;
}
cout<<"\n";
system("PAUSE");
}
Ejemplo:
Elaborar un programa que permita hacer conversiones de temperatura entre grados
Fahrenheit, Celsius, Kelvin y Ranking. Primero debe preguntar que tipo de grados quiere
convertir. Por ejemplo si se le indica que se desea convertir una temperatura en grados
Fahrenheit, debe leer la cantidad de grados y luego su equivalente en grados Celsius, Kelvin
y Rankine, y así hacer lo mismo en cada uno de los otros casos tipo. Para convertir a Celsius
la temperatura Fahrenheit se le resta 32 y se le multiplica por 5/9, para convertir a Kelvin, se
le suma 273 a los grados Celsius. Para convertir a Rankine a los grados Fahrenheit se le
suma 460.
#include <cstdlib>
#include <iostream>

{
int op1;
float f,c,k,r;
cout<< "\n conversiones de temperatura";
cout<< "\n1 De oF a oC, oK ,oR";
cout<< "\n2 De oC a oF, oK, oR";
cout<< "\n3 De oK a oF, oC, oR";
cout<< "\n4 De oR a oF, oC, oK";
cout<< "\n seleccione opcion:";
cin>>op1;
switch(op1)
{
case 1 : cout<<"\n Ingrese temperatura en oF:";
cin >>f;
c=(f-32)*5/9;
k=c+273;
r=f+460;
cout<< "\n"<<"oF cequivale a:";
cout<< "\n"<<c<<"oC";
cout<< "\n"<<k<<"oK";
42
cout<< "\n"<<r<<"oR";break;
case 2 : cout<<"\n Ingrese temperatura en oC:";

cin>>c;
f=(9/5*c)+32;
k=c+273;
r=f+460;
cout<<"\n"<<"oC cequivale a:";
cout<<"\n"<<f<<"oF";
cout<<"\n"<<k<<"oK";
cout<<"\n"<<r<<"oR";break;
case 3 : cout<< "\nIngrese temperatura en oK:";

cin>>k;
c=k-273;
f=(9/5*c)+32;
r=f+460;
cout<<"\n"<<"oK cequivale a:";
cout<<"\n"<<c<<"oC";
cout<<"\n"<<f<<"oF";
cout<<"\n"<<r<<"oR";break;
case 4 : cout<< "\n Ingrese temperatura en oR:";

cin>>r;
f=r-460;
c=(f-32)*5/9;
k = c+273;
cout<< "\n"<<" oR cequivale a:";
cout<< "\n"<<f<<"oF";
cout<< "\n"<<c <<"oC";
cout<< "\n"<<k<<"oK";break;
default : cout<< "\n ERROR, pulse 1,2,3,4,";break;

}
cout<< "\n";
system("PAUSE");
}
43
4. ESTRUCTURAS REPETITIVAS
Permiten evaluar procesos repetitivos. Se tiene:
Mientras, para, repetir.
Ejecuta un grupo de instrucciones mientras la

Mientras <condición> condición sea verdadera .
___________
Caso de ser falsa sale del mientras.
___________
___________
___________ Ej. Para que nunca entre a la condición
FIN MIENTRAS
A 6
B 6
C 0
SW  0
Mientras SW = 1
C A+B
F SW  0
F_mientras
condici
ón Escribir ‘C=’, C
Ej. Para que Si entre a la condición
V A 8
B 6
C 0
SW  1
Mientras SW = 1
CA+B
---- SW  0
-- f-Mientras
Escribir ‘C=’, C
----
--
----
--
----
--
Ejercicios:
1. Ejercicio Hallar suma de los cinco primeros números naturales
2. Hallar la suma de los 50 primeros números naturales impares
44
Repetir
-------
-------
-------
Hasta (<condición>)
Inicio
A 7
B4
C0
SW  0
Repetir
C A+B
SW  1
Se realizan
-------- por lo menos
Hasta (SW = 1)
Escribir ‘C=’, C.
-- una vez
-------- Fin
-- Otro ejemplo de repetic.

-------- Repetir
-- A0
-------- B0
C0
-- Escribir ‘Valor de’, A
-------- Leer A
Escribir ‘Valor de’, B
-- Leer B
-------- C=A+B
Escribir ‘La suma es: ‘, C
--
<Condición> Hasta (C = 50)
NO
--------
--
SI
Otro Ejm. de Mientras
C 5
Mientras C <> 50
A0
B0
C0
Escribir ‘valor de A’
Leer A
Escribir ‘valor de B’
Leer B
CA+B
Escribir la suma, =’, C
Fin Mientras
Repetir
Escribir ‘Ingrese respuesta < s/n>’
Leer RP
45
Hasta (RP = ‘s’ O R RP =‘N’)
Ej. Mientras y Repetir
RP  ‘S’
Mientras RP =’S’
A0
B0
C0
Leer A
Leer B
CA+B
Repetir
Escribir ‘Ingrese respuesta <S/N>’
Leer RP
Hasta (RP=’S’ or RP=’N’)
F-mientras
Con un repetir fuera y 1 repetir dentro
Repetir
A0
B0
C0
Leer A
Leer B
CA+B
Repetir
Escribir ‘Ingrese respuesta <S/N>’
Leer RP
Hasta (RP=’S’ oR RP=’N’)

Hasta (RP=’N’)
ACUMULADOR
Variable que recibe el valor que anteriormente tenía más un valor cualquiera.
X=X+Y
X = X + < valor variable>
CONTADOR
X = X + <valor fijo>
Contador: Variable que nos permite guardar su valor anterior más un valor fijo.
46
Para / Desde
Para I  Valor Inicial Hasta Valor final Variando Valor de cambio
________
El conjunto de instrucciones se
________ ejecuta “N” veces
________
Fin-para
Para I  1 hasta 5 A éstas instrucciones no le interesa con que valor llegue “I”,
ella mismo (el para) se encarga de inicializar
Escribir I
Fin_para
Inicio de la Instrucc. Para
I  1 I  1
I> I<=
5 5
Escribir Escribir
I I
II+1 II+1
F
Para I  1 hasta 5 variando 2

Escribir I
Fin_para
_______
_______
_______
Si <condición>
_______
_______
_______
_______
F_si
47
Anidados
Si <C1>
_______
_______
_______
Si <C2>
_______ Si C2 Es V
_______
_______
f_si
_______ Si C1 es V
_______
_______
Si no
_______
_______
_______
Si <C3>
_______
_______ Si C3 es V
_______
si no
_______ Si C3 es F
_______
_______
_______
_______
_______
f_si
f_si
Mientras <c1>
----------
----------
----------
mientras <c2>
----------
----------
----------
f-mientras
----------
----------
----------
F-Mientras
Repetir
----------
48
----------
----------
Repetir
----------
----------
----------
Hasta (c2)
----------
----------
---------
Hasta (c1)
Para I  1 hasta 5
----------
----------
----------
----------
----------
----------
Fin – para
----------
----------
----------
Fin-Para
49
Ejemplo: Anidados en IF
En una empresa deseamos contar los varones y mujeres que son programadores y los
hombres y mujeres que son usuarios.
si la especialidad es programador
Si el sexo es hombre
Contar hombre_P
Si no
Contar mujeres_P
f-si
si no
si el sexo es hombre
contar hombres_u
si no
Contar mujeres_u
f-si
f-si
F V
Esp = ‘P’
F V F V
Sex = ‘H’ Sex = ‘H’
CMUCMU+1 CHUHU+1 CMP  CMP +1 CHP CHP +1
50
PROBLEMAS
Deduzca el salario neto de un trabajador, a partir de los siguientes datos de entrada: nombre,
horas trabajadas, precio de la hora, y sabiendo que los impuestos son el 10% sobre el salario
bruto.
NOMPER
PAGHOR
HORTRA
SUENET
SUEBRU
DSCLEY
ALGORITMO SUELDO
Variables:
NOMPER: Cadena
PAGHOR, HORTRA, SUENET, SUEBRU, DSCLEY: Reales
Inicio (Acción Principal)

PAGHOR  .
HORTRA  .
SUENET  .
SUEBRU  .
DSCLEY  .
NOMPER  ‘’
Escribir ‘nombre’
Lee NOMPER
Escribir ‘Horas Trabajadas’
Leer HORTRA
Escribir ‘pago por hotra’
Leer PAGHOR
Sue Bru  HORATRA * PAGHOR
DSCLEY  SueBru * 0.10
SUENET  SueBru - DscLey
Escribir ‘El sueldo neto es:’, SUENET
Fin-Inicio
Sueldo para “n” personas; n° definido”

ALGORITMO SUELDO
Entorno (Variables)
51
NomPer : Cadena
PagHor, Hortra, SueNet: Reales
I, N: Entera
Inicio
N
I 
Escribir ‘Ingresa el N° de Trabajadores’
Lee N
Para I  1 hasta N
NOMPER  ‘ ‘
Leer NOMPER
Escribir “horas trabajada”
Leer HORTRA
Escribir ‘pago por hora’
Leer PAGHOR
SUENET  PAGHOR*HORTRA*0.9
Escribir, NOMPE, ‘SUELDO NETO’, SUENET
HORTRA  
PAGHORA  
SUENET  
Fin-Para
Sueldo para N personas, “Cuando N: indefinido”

Algoritmo Sueldo
Variables
NOMPER : Cadena
PAGHOR, HORTRA, SUENET: REALES

RP : Carácter
Inicio
RP  ‘ ‘
52
Repetir
NOMPER  ‘ ‘
Leer NOMPER
Escribir ‘Pago por Hora’
Lee PAGHOR
SUENET  PAGHOR * HORATRA*0.9
Escribir “NOMPER”, Sueldo Neto, SUENET
PAGHOR  
HORTRA  
SUENET  
Escribir “desea continuar < S/N>’
Leer RP
Hasta (RP = ‘N’)
Otra forma
Algoritmo
Repetir
PAGHOR  
HORTRA  
SUENET  
RP  ‘ ‘
NOMPER  ‘ ‘
Leer HORTRA
Leer PAGHORA
SUENET  PAGHOR * HORATRA * 0.9
Escribir, NOMPER, SUENET
Escribir ‘Desea Continuar <S/N>’
Leer RP
ALGORITMO SUELDO
Entorno:
NOMPER: Cadena
PAGHOR, HORTRA, SUENET, SUEBRU, DSCLEY: Reales
RP  ‘S’
mientras RP = ‘S’
53
NOMPER  ‘’
Lee NOMPER
Leer HORTRA
Leer PAGHOR
SUENETO PAGHORA * HORTRA * 0.9
Escribir NOMPER ‘El sueldo neto es:’, SUENET
Escribir ‘Desea continuar <S/N>’
Leer RP
F-Mientras
Ejercicios
1. Se desea realizar un Seudo código que resuelve el siguiente problema:
- Calculo de 1.5 salario semanales de los empleados de una empresa, sabiendo que éstos se
calculan en base a las horas semanales trabajados y de acuerdo a un precio especificado por
cada hora. Si se pasan de 40 horas semanales, las horas extras se pagan a razón de 1.5
veces la hora ordinaria.
N° Horas normales : 4
Nomper
Horatra
Paghor
1.4 x Paghor por c/hora extra

Ejemplo si sueldo x hora = S/ 80.00
 Hora extra = 1 s (10) = S 15.
Hora – Extra: Hora Extra –40
ALGORITMO SUELDO1
Entorno (Variables)
RP: Carácter
Nomper: Cadena
Hortra, Paghor, SueNet, : Reales
Inicio
54
RP  ‘S’
Mientras RP= ‘S’
Nomper  ‘ ‘
Hortra  .
Suenet  .
RP  ‘ ‘
Leer Nomper
Leer Paghor
Escribir ‘horas, trabajados
Leer Hortra
Si Hortra < 4
SueNet  Pag Hor * hortra
Si no
Sunet  Paghor * 40 + (Hortra -40) x 1.5 x paghor
F-si
Escribir ‘sueldo net’, suenet
To+sue  tot sue + suenet
Leer RP
Fin Mientras
Escribir ‘El total de sueldos es: ‘, totsue
Fin-Inicio
2. Se debe ingresar una lista de nacionalidades y se desea saber cuantos chilenos y peruanos
han sido ingresados a su vez deberá UD. indicar cuantas personas ingresaron
CONTPER
CONTCHI
CONTOT
NAC
RP
ALGORITMO NACIONALIDAD
Entorno (Variables)
CONTPER, CONTCHI, CONTOT: Enteros
NAC: Cadena
RP: Carácter
55
Inicio
CONTPER  0
CONTCHI  0
CONTOT  0
RP  ‘S’
Mientras RP = ‘S’
NAC  ‘ ‘
Escribir ‘nacionalidad’ :
Leer NAC
Si NAC = ‘Peruano’ OR NAC = ‘Peruana’
CONTPER  CONTPER + 1
F-Si
Si NAC = ‘CHILENO’ OR NAC= ‘CHILENA’
CONTCHI  CONTCHI + 1
F-Si
CONTOT  CONTOT + 1
RP  ‘ ‘
Leer RP
Fin – Mientras
Escribir ‘El total de peruanos es:’, CONTPER
Escribir ‘El total de Chilenos es:’, CONTCHI
Escribir ‘El total de nacionalidades ingresadas es:’, CONTOT
Fin-Inicio
PROBLEMAS
Dado: 10 números enteros, visualizar la suma de los números pares de la lista. ¿Cuántos
números pares existen y cuál es la media aritmética de los Numeros impares?
Algoritmo: NPEI
RES,COC,NroEnt, I, COMPART, CONIMPAR, SUM PAR, SUMIMPAR: Enteros
ProImp: Real
INICIO
SumaPar  0
SumaImpar  0
ConPar  0
ConImpar  0
Para I  1 Hasta 10
56
NROENT  0
Escribir ‘ingrese un N°’
Leer NroEnt
Coc  Parte entera (nroent/2)
Res  Nroent –(2*COC)
Si res = 0
Conpar  Conpar +1
Sunpar  Sunpar + nroent
Si no
Conimpar  Conimpart +1
Sunimp  Suminp + nroent
F-si
F-Para
ProImp  SumImp/ConImpar
Escribir ‘ Promedio Impares’, ProImpar
Escribir ‘Suma de Pares’, SumPar
Escribir ‘Hay’, ConPar, ‘Nros Pares’
Los empleados de una fábrica trabajan en dos turnos, diurno y nocturno. Se desea calcular el
jornal diario de acuerdo con los siguientes puntos.
1. La tarifa de las horas diurnas es de 10 nuevos soles
2. La tarifa de las horas nocturnas es de 15 nuevos soles
3. En caso de ser domingo, la tarifa se incrementa en 8 nuevos soles el turno diurno y al
doble en turno nocturno
Algorito Jornal
Variables
Rp,Turtra: Carácter
DiaTra, Nomtra: Cadena
Hortra, JorDia: Enteros
INICIO
Repetir
Nomtra  ‘ ‘
Escribir ‘ Nombre del Trabajador’
Leer Nomtra
DiaTra  ‘ ‘
Escribir ‘Dia trabajado: ‘
Leer DiaTra
TurTra  ‘ ‘
Escribir ‘ Turno Trabajado’
Leer TurTra
Si DiaTra= ‘Domingo’
57
Si Turtra=’D’
JorDia  18*HorTra
Sino
F-si
Sino
Si Turtra=’D’
Sino
F-si
F-si
Escribir ‘El Jornal es’,JorDia
Repetir
RP  ‘ ‘
Escribir ‘Desea Continuar <S/N>
Leer RP
Hasta RP = ‘S’ OR RP=’N’
Hasta(RP=’N’)
Escribir el ‘Sueldo total pagar’: , SUetotal
FIN-INICIO
ALGORITMO SUELNET
Variables
RP: Carácter
ImpMen PagHor
Hortra, SueNetMen
PagMen; Real
Nomtra : Cadena
Inicio
Repetir
Nombre  ‘ ‘
Escribir nombres trabajador:
Leer Nomtra
Escribir ‘ Horas Trabajadas‘
Leer Hortra
Escribir ‘pago hora:’
Leer PagHor
ImpMen  0.000
Si Hortra < = 35
58
SueNet Sem  PagHor * Hortra
Pag Mens  Sue Net Sen *4

Si no
Sue Net SemPag Hor * 1.5 * (Hortra -35)+PagHor *35
Pag Mens  Sue Net Sen *4
F-si
Si PagMens > 300 and. Pag Men <= 1100
ImpMen  0.15 * (Pag Mens –300)
Si no
Si Pag Mens >1.100
ImpMen  0.30 * (Pag Men - 1100)
F-si
F-si
Sue Net Sem  Sue Net Sem _ ImpMen
Escribir Nomtra, sue Net Sem
Repetir
Escribir ‘desea continuar’ <S/N>’
Leer RP.
Hasta (RP = ‘S’ .OR. RP = ‘N’)
Hasta RP = ‘N’
F-Inicio
Elementos básicos de un algoritmo:
- Palabras reservadas (Inicio, fin)

- Identificadores (Nombres de variables)
- Carácter especiales (coma, apostrofe etc)
- Constantes
- Variables
- Expresiones
- Instrucciones
- Contadores
- Acumuladores
- Interruptores (switch)
- Estructuras:
o Secuenciales
o Selectivas
o Repetitivas
59
while ( mientras )
Ejecuta una instrucción simple o compuesta: ninguna, una o mas veces dependiendo del
valor de la condición.
Formato:
while ( condición )
Loop {
o Instrucciones;
Bucle }
Ejecución:
1. Se evalúa la condición.
2. Si el resultado de la evaluación es verdadero (1) la instrucción se ejecuta y el proceso se
repite mientras que la condición sea verdadera.
3. Si la condición es falsa no se ejecuta la sentencia y se procede a ejecutar el resto del
programa.
Ejemplo
Programa que imprime los números del 1 al 10.
#include <cstdlib>
#include <iostream>

{
int c;
c =1;
while(c<=10)
{
cout<<c<<endl;
c++ ;
}
system("PAUSE");
}
60
do while (hacer - mientras)
Ejecuta una instrucción simple o compuesta por lo menos una vez dependiendo del valor de
la condición.
Formato
do
{
Instrucciones;
}
while (condición);
Ejecución
1. Se ejecuta la instrucciones simples o compuestas

2. Se evalúa la condición
3. Si el resultado es verdadero el proceso se repetirá hasta que la condición se
convierta en falsa.
Si el resultado de la condición es falso se pasa a ejecutar el resto del programa.
Ejemplo
Programa para indicar que nos encontramos en un bucle repetitivo (do – while). Desea
continuar < s / n >, el proceso se repite cuando al final la respuesta es: s o S.
#include <cstdlib>
#include <iostream>

{
char resp ;
do
{
cout<<"\n Estamos dentro de un do_while\n";
cout<<" Desea continuar < s / n >.......";
cin>>resp;
}while(resp== 'S' || resp =='s');
cout<<"\n Eso fue todo";
cout<<"\n";
system("PAUSE");
}
61
for ( para)
Ejecuta un conjunto de instrucciones un determinado Nº de veces cuyo valor se conoce por

anticipado.
Formato
for (var =vi; condición; progresión)

{
Instrucciones;
}
Donde:
var = vi; var representa a una variable que será inicializada con el valor vi ( se evalúa una
sola vez)
Condición : es una condición lógica si se omite se asume que es verdadera.
Progresión: es una expresión que incrementa o decrementa la variable var.
Ejempo
Programa que permita calcular el producto de 2 números usando solamente sumas.
#include <cstdlib>
#include <iostream>

{
int i, num1, prod,num2;
prod =0;
cout<<"Ingrese Primer Numero : ";
cin>>num1;
cout<<"\n Ingrese Segundo Numero: ";
cin>>num2;
for (i =1 ; i <=num1 ; i++)
{
prod =prod + num2;
62
}
cout<<"El producto es "<<prod;
cout<<"\n";
system("PAUSE");
}
5. PUNTEROS
Cuando una variable se declara, se asocian tres atributos: nombre, tipo y dirección en
memoria. Al valor, o contenido de una variable se accede por medio de su nombre. A la
dirección de la variable se accede por medio del operador de dirección &.
Una referencia es una alías de otra variable. Se declara utilizando el operador de referencia
(&) que se añade al tipo de la referencia.
Ejemplo: Obtener el valor y la dirección de una variable y una referencia.
#include <cstdlib>
#include <iostream>

{
int Variable=100; // Declaración de variable
int &Referencia = Variable; // Referencia(dirección) e inicialización
cout<<"Contenido de Variable = "<<Variable<<endl;
cout<<"Direccion de &Variable = "<<&Variable<<endl;
cout<<"Contenido de Referencia = "<<Referencia<<endl;
cout<<"Direccion de &Referencia = "<<&Referencia<<endl;
system("PAUSE");
}
Reglas
& se refiere a la dirección en que se almacena el valor. El carácter & tiene diferentes usos
en C++:
1. Cuando se utiliza como prefijo de un nombre de una variable, devuelve la dirección de
esa variable.
2. Cuando se utiliza como un sufijo de un tipo en una declaración de una variable, declara la
variable como sinónimo de la variable que se ha inicializado.
3. Cuando se utiliza como sufijo de un tipo en una declaración de parámetros de una
función, declara el parámetro referencia de la variable que se pasa a la función.
63
Puntero
Un puntero es una variable que contiene una dirección de una posición de memoria que
puede corresponder o no a una variable declarada en el programa. La declaración de una
variable puntero debe indicar el tipo de dato al que apunta; para ello se hace preceder al
nombre con asterisco (*):
< tipo de dato apuntado> *<identificador de puntero>
C++ no inicializa los punteros cuando se declaran y es preciso inicializarlos antes de su uso.
Para asignar una dirección de memoria a un puntero se utiliza el operador &, éste método
de inicialización, denominado estático requiere:
o Asignar memoria estáticamente definiendo una variable y, a continuación, hacer que
el puntero apunte al valor de la variable.
o Asignar un valor a la dirección de memoria.
Otro método para inicializar un puntero, consiste en utilizar asignación dinámica de

memoria, utilizar operadores new y delete.
Operadores de punteros
Operador Propósito
& Obtiene la dirección de una variable
* Define una variable como puntero
* Obtiene el contenido de una variable puntero
Notas:
- Siempre que aparezca un (*) en una definición de variable, ésta es una variable puntero.
- Siempre que aparezca un (*) delante de una variable puntero se accede a la variable
contenido del puntero.
- El operador & devuelve la dirección de la variable a la cual se aplica.
Ejemplo. Asignar a una variable puntero una dirección, y a su contenido un valor.
#include <cstdlib>
#include <iostream>

{
int var;
int *pun; //puntero al entero pun
pun=&var; //direccion de var a pun

*pun=120;
cout<<" &var. Direccion de var = "<<&var<<endl;
cout<<" pun. Contenido de pun es la misma de var = "<<pun<<endl;
cout<<" Contenido de var = "<<var<<endl;
cout<<" Contenido de *pun es el mismo de var = "<<*pun<<endl;
system("PAUSE");
}
Gestión dinámica de memoria

Operador new
puntero = new nombreTipo (inicializador opcional)
o bien:
64
1. tipo *puntero=new tipo // No arreglos
2. tipo *puntero=new tipo[dimensiones] // Arreglos
Sintaxis de operadores new y delete
puntero = new tipo;

delete puntero:
Asignación-desasignación de un arreglo dinámico
puntero Array= new [tamaño del arreglo];

delete[] puntero Array;
Ejemplo. Asignar memoria dinámica a una cadena de caracteres y a un entero y se libera la

memoria asignada.
#include <cstdlib>
#include <iostream>

{
char *Cadena=" Buenas tardes a los alumnos de Algoritmica 1";
int *pEntero, longCadena, Entero=20;
char *pCadena;
longCadena=strlen(Cadena);
pCadena=new char[longCadena+1]; //memoria mas una posic.de fin de cadena
strcpy(pCadena,Cadena); // Cadena a pCadena
pEntero=new int; // reservar memoria para pEntero
*pEntero=Entero; // se almacena en pEntero 20
cout<<"pCadena = "<<pCadena<<", longitud = "<<longCadena<<endl;
delete pCadena; // libera memoria de pCadena
cout<<" *pEntero = "<<*pEntero<<endl;
delete pEntero;
system("PAUSE");
}
65
Ejemplo. Reservar, asignar memoria dinámica a un vector de enteros, cargar el vector,
mostrar los contenidos, visualizar las direcciones de memoria.
#include <cstdlib>
#include <iostream>

{
int n,*v,*d,i;
cout<<"Asignacion dinamica de memoria a un vector de enteros"<<endl;
cout<<"Numero de elementos: ";
cin>>n;
v=new int[n];
d=v;
for(i=0;i<n;i++)
{
cout<<"\n v["<<i+1<<"]=";
cin>>*v;
v++;
}
cout<<"CONTENIDO DIRECCION DE MEMORIA "<<endl;
for(i=0;i<n;i++)
{
cout<<" v["<<i+1<<"]="<<*d<<"\t\t\t"<<d<<endl;
d++;
}
system("PAUSE");
}
66
6. FUNCIONES
Las funciones contienen varias sentencias bajo un solo nombre, que un programa puede
utilizar una o más veces para ejecutar dichas sentencias.
Si se agrupan funciones en bibliotecas, otros programas pueden reutilizar las funciones.
Las funciones también pueden ser definidas por el usuario.
6.1 Funciones de biblioteca o funciones estándar

Las funciones estándar o predefinidas, se dividen en grupos; todas las funciones que
pertenecen al mismo grupo se declaran en el mismo archivo de cabecera(librería), ejemplo:
Librería Funciones
<stdlib.h> random(num); atoi(cadena);
<ctype.h> toupper(ch); tolower(ch);
<math.h> exp(num); pow(a,b); sqrt(num);
<string.h> strcpy(cadena1,cadena2); strcmp(cadena1,cadena2);
<stdio.h> gets(cad); scanf(“cadena de formato”;&Lista de Argumentos);
printf(“cadena de formato”,[Lista de Argumentos]);
6.2 Funciones de usuario

Es un conjunto de instrucciones que ejecutan una tarea específica. Tiene las siguientes
características:
No puede contener otra función.
Posee un tipo determinado
Puede o no retornar un valor
Tiene que ser reconocida antes de la función main( )
Formato
tipo Nombre ([lista de argumentos])
{
definiciones locales;
instrucciones;
[return (valor);]
}
tipo
Es el tipo de datos que retorna la función. En caso que la función no retorne valor alguno
será del tipo void (vacío).
Nombre
Es el identificador que definirá el nombre de la función.
Lista de argumentos
También llamadas parámetros formales. Son el conjunto de identificadores separados por
comas que utilizaran la función. A estos se le pueden considerar como variables locales, las
cuales han recibido un valor inicial.
return
Es una sentencia opcional encargada de devolver algún valor, puede ser o no las última y
puede aparecer mas de una vez en una función.
Si la función no retorna valor será del tipo void (vació).
Nota
Todas las funciones deben estar desarrolladas antes de la función main( ), en caso contrario
deberán ser definidos como cualquier variable al inicio del programa. A esta función definida
se le denomina función prototipo.
Ejemplo
float suma(float x, float y)
{
float w;
w=x+y;
return (w);
}
67
Ejemplo:
Hallar en una función el máximo común divisor de dos números enteros, y mostrar el resultado
en el programa principal.
#include <cstdlib>
#include <iostream>
int mcd(int x, int y);
{ int x,y,r1;
double r2;
cout<< "\n Hallando mcd de dos numeros";
cout<< "\n 1er numero:";
cin>>x;
cout<< "\n 2do numero:";
cin>>y;
r1=mcd(x,y);
cout<<"\n el mcd de:"<< x<<" y "<<y<<" es "<<r1;
cout<<"\n";
system("PAUSE");
}
int mcd(int x, int y)
{ while(x!=y)
{if(x>y)
x=x-y;
else
y=y-x;
}
return(x);
}
68
Parámetros de una función
a. Paso por valor(paso por copia): La función recibe una copia de los valores de los
parámetros actuales. La función receptora no puede modificar la variable de la
función(parámetro pasado).
Ejemplo:
Leer un número entero cualquiera, pasar el valor leído a través de una función de paso de
parámetro por valor, en la función mostrar el valor enviado, duplicar el valor. Al término de la
función, regresar al programa principal mostrar el valor leído después de la llamada de paso
por valor.
#include <cstdlib>
#include <iostream>

void paso_por_valor(int x);

{
int x;
cout<<"\n Ingrese un numero: ";
cin>>x;
cout<<"\n Antes de la llamada de paso por valor x= "<<x<<endl;
paso_por_valor(x);
cout<<"\n despues de la llamada a paso por valor x= "<<x<<endl;
system("PAUSE");
}
void paso_por_valor(int x)
{
cout<<"\n dentro de paso por valor x= "<<x<<endl;
x*=2;
cout<<"\n despues de x*=2 y dentro de paso por valor x= "<<x<<endl;
}
69
b. Paso por referencia (o dirección): Cuando una función debe modificar el valor del
parámetro pasado y devolver este valor modificado a la función llamadora.
Ejemplo:
En el programa principal inicializar una variable entera con un valor, mediante la llamada a
una función de paso de parámetro por referencia modificar el valor de la variable, y mostrar el
resultado en el programa principal.
#include <cstdlib>
#include <iostream>

void referencia(int &x)
{
x+=2;
}

{
int x=20;
cout<<"antes de la llamada: "<<"x= "<<x<<endl;
referencia(x);
cout<<"despues de la llamada: "<<"x= "<<x<<endl;
system("PAUSE");
}
70
RECURSIVIDAD
Un programa recursivo es aquel que se llama asimismo ( y una función recursiva es aquella
que se llama asimisma) pero con una condición de termino que autorice al programa a dejar
de llamarse asimismo ( y que la función deje de definirse en términos de si misma).
Ej. Desarrollar un algoritmo para hallar factorial de un número entero positivo usando
recursividad, incluir el cero.
n! = n(n-1)! Para n  =1 con 0! =1
Algoritmo factorial
Variables
Respta,n: enteros
INICIO (Acción Principal)
Escribir(‘ Ingresar Nro entero positivo para hallar factorial‘)

Leer(n)
Respta=factorial(n)
Escribir(´El factorial de ´, n, ´es´, Respta)
FIN
Funcion entero factorial(entero n)

INICIO
Si n= 0
Retornar 1
Caso contrario
Retornar(n*factorial(n-1))
Fin-si
FIN
7. ARREGLOS
Son conocidos como vectores o matrices, sea por ejemplo
……………….
DATOS
DATOS(1) DATOS(3) DATOS(15)
Tiene las siguientes características

- La misma longitud
- El mismo tipo de datos
- Referencias a un mismo nombre.
71
Ejemplo:
Datos(15) : Arreglo de enteros
Nombre Arreglo (Nro de Elementos) : Arreglo de <tipo>
Algoritmo Nros
Variables:
Datos (15): Arreglo de enteros
Suma,I : Entero
Inicio
Suma  0
Datos (I)  0
Fin – Para
Escribir ‘Nro’, I, ‘-‘
Leer Datos (I)
Suma  Suma + Datos (I)
Fin - Para
Limpia Pantalla
Escribir ‘Datos (‘, I, ’). – ‘, Datos (I)
Fin - Para
Escribir ‘La suma de éstos datos es:’ , Suma
Fin Inicio
Se necesita ingresar en nombre y las evaluaciones de cada uno de los alumnos del curso de
programación, existen 2 evaluaciones por alumno. El Psedocódigo debe permitir la impresión
de la Acta de Notas de dicha sección. Los datos al imprimir deben ser los siguientes:
- Nombre
- Evaluación 1Not Par)
- Evaluación 2 (Not Fin)
- Promedio
ALGORITMO ACTAS
Variables:
NomAlu(45): Arreglo de cadenas
NotPar (45) , NotFin(45), ProAlu(45): Arreglo de reales
I, K: Entero
RP: Carácter
72
Inicio
Para I  hasta 45
NomAlu(I)  ‘ ‘
NotPAr (I)  .00
NotFin (I)  0.00
ProAlu (I)  0.00
Fin Para
I0
Repetir
II+1
Escribir ‘nombre del alumno’
Leer NomAlu (I)
Escribir ‘Ex-parcial’
Leer NotPar (I)
Escribir Ex_Final
Leer NotFin (I)
ProAlu (I) (NotPar (I) + NotFin (I))/2
RP  ‘ ‘
Escribir ‘Hay más alumnos <S/N>’
Leer RP
Para k  1 hasta I
Escribir NomAlu (K),‘b’, NotPar(K), ‘b’, NotFin(K), ‘b’. ProAlu(K)
Fin para
Fin Inicio
Ejercicio
Se necesita ingresar el nombre, las evaluaciones y los trabajos de los alumnos del curso de
contabilidad básica, existen cuatro evaluaciones por alumno y dos trabajos parciales. El seudo
código debe permitir la impresión del Acta de notas de dicho curso. Los datos ha imprimir son
los siguientes:
Nombre Ex1, Ex2, Ex3, Ex4, T1, T2 PF
El promedio final es un promedio simple.
ORDENAR
SORTEAR LOS DATOS DE UN VECTOR (METODO BURBUJA)

Método de intercambio (Burbuja)
El algoritmo consiste en:
73
Ir comparando los valores almacenados, en las diferentes posiciones del arreglo. Las
comparaciones se realizan tomando 2 valores por iteración (Acción de repetir algo) los valores
a comparar deben estar en posiciones consecutivas, empezando de la posición N°01
Conclusión
Si Nros (y) > Nros(y+1)
Aux  Nros (y)
Nros (y)  Nros (y+1)
Nros (y+1)  Aux
F-si
Para x  1 hasta N-1

Para y 1 hasta N-x
Si Nro(y)> Nros (y+1)
Aux  Nros (y)
Nro (y)  Nros (y+1)
Nro (y+1)  Aux
F- si
F-para
F- para
Donde:
x = Nro del análisis al algoritmo
y: Indica las posiciones del vector (controlar comparaciones)
N: Nro de datos a ordenar
N-1: N° de análisis a realizar
N-x : N° de comparaciones por cada análisis
BÚSQUEDA EN ARREGLOS
Ejemplo: Ingresa 50 nombres a un vector, tipear un nombre aleatorio y verificar si se encuentra
en el arreglo.
Algoritmo Búsqueda
Variables:
Nomper(50) : Arreglo de Cadenas
I,SW : Entero
NomBus : Cadena
Inicio
Nomper (I)  ‘ ‘
Escribir ‘nombres: ‘
Leer NomPer(I)
Fin – Para
Nombus  ‘ ‘
Escribir ‘Ingresa el nombre a buscar:’
Leer NomBus
SW  0
74
Si Nombus = NomPer (I)
Escribir ‘lo encontre’
I  50
SW  1
F-SI
F-Para
Si SW = 0
Escribir ‘no existe el nombre’
F-si
Fin
OTRA FORMA
Algoritmo
Inicio
NomPer (I)  ‘ ‘
Escribir ‘nombre:’
Leer Nomber (I)
F-Para
NomBus  ‘ ‘
Escribir ingrese nombre a buscar: ‘
Leer Nombus
Para I  Hasta 50
Si Nombus = NomPer(I)
Escribir ‘lo encontre’
I  51
Fin – si
Fin – Para
Si I = 51
Escribir ‘NO EXISTE’
Fin-si
Fin-si
INSERCIÓN DE DATOS EN UN VECTOR
ALGORITMO INSERTAR
Variables Nro(5) : Arreglo de enteros
Pos, I, Dato: Entero
Inicio
Nros(I)  0
Escribir ‘numero’
Leer Nros(I)
Fin - Para
75
DATO  0
Escribir ‘Ingresar el valor a insertar’
Leer Dato
Pos  0.
Escribir ‘Ingresar posición donde desea insertar’
Leer POS.
Para I  5 hasta Pos+1 Variando –1
Nros (I)  Nros (I-1)
Fin – Para
Fin
EJERCICIO
En el vector anterior
i) Ordenar de < a >
ii) Insertar el valor 12 en el lugar correspondiente, ya sea eliminado el último valor o
ampliando el vector y no eliminado valor alguno.
Para I  1 hasta 5-I
Si V(J) > V(J+1)
Temp.  V(J)
V(J)  V(J+1)
V(J+1)  Temp.
Fin – si
Fin – Para
Fin para
Dato  0
Escribir (‘Ingresar valor a insertar:’)
Leer (Dato)
SW  0
Para i  1 Hasta 5
Si Datoins <= V(I)
Para J  6 hasta I
V(J)  V(J-1)
Fin- para
V(I)  Dato
I5
SW  1
Fin si
Fin – para
*****************************************************************
#include<iostream>
#include<cstdlib>
int main(int argc, char *argv[]){
76
int V[6],j,i,dato,aux;
cout<<"\nLeer Vector ";
cout<<"\n";
for(i=0;i<5;i++){
cout<<"Numero ["<<i+1<<"]= ";
cin>>V[i];
}
for(i=0;i<5;i++){
for(j=0;j<5-i-1;j++){
if(V[j]>V[j+1]){
aux=V[j];
V[j]=V[j+1];
V[j+1]=aux;
}
}
}
cout<<"\nVector ordenado ";
for(i=0;i<5;i++){
cout<<"\nElemento ["<<i+1<<"]= "<<V[i];
}
cout<<"\nDato a insertar(menor que el mayor valor): ";
cin>>dato;
for(i=0;i<5;i++){
if(dato<=V[i]){
for(j=5;j>=i;j--)
V[j]=V[j-1];
V[i]=dato;
i=4;
}
}
cout<<"\nVector y valor insertado ";
for(i=0;i<6;i++)
cout<<"\nV["<<i+1<<"]= "<<V[i]<<endl;
system("PAUSE");
}
ALGORITMO ACTAS
Variables
Nom(12): Arreglo de cadenas
Notas: (13,4)
Arreglo de reales
77
I, J, Confat : Entero
AcuNot, AcuPro : Reales
Inicio
AcuPro  0
Confalt  0
AcuNot 0
Leer Nom(I)
Para J I hasta 3
Escribir ‘nota’, J.
Leer Notas (I,J)
Si Notas (I,I) = 88
Confalt  Confalt + 1
Si no
AcuNot  AcunNot + Notas (I, J)
Fin-si
Fin - para
Notas (I, J)  AcuNot/3
AcuPro  AcumPro + Notas (I,J)
AcuNot + 0
F Para
Notas (13,4)  AcuPro/12
Notas (13,1)  000
Notas (13,2)  000
Notas (13,3)  000
Para I  Hasta 12
Si Notas (I,1)! = 88
Notas (13,1)  Notas (13,1) + Notas (I,1)
Fin –si
Si Notas (I,2)! = 88
Notas (13,2)  notas (13,2)+ Notas (I,2)
F-SI
Si notas (I,3)! = 88
Notas (13,3)  Notas (13,3) + notas (I,3)
F-si
F-para
Notas (13,1)  Notas (13,1)/12
Notas (13,2)  Notas (13,2) /12
Notas (13,3)  Notas (13,3)/12
78
EJERCICIOS
1. Se desea un algoritmo que proporcione la palabra inversa simétrica de una dada. Por
ejemplo AMIL es la palabra inversa simétrica de LIMA.
2. Se dispone de una lista de cien números enteros. Calcular el valor máximo y el orden que
ocupa en la lista.
3. Calcular los promedios de las asignaturas de una clase. Deducir cuántas son más altas
que el promedio y cuántas son más bajas que el promedio.
4. Elaborar un algoritmo para ingresar o añadir registros a un archivo.
5. Hallar el factorial de un número entero positivo usando usando recursividad.
6. Dados dos números enteros positivos cualesquiera hallar la raíz cuadrada del mayor.
7. Elaborar un algoritmo el cual nos permita ingresar un menu de opciones: ingreso, ordena,
listado y cuadro.
Al ingresar los datos se pide: número de alumnos, nombre, sexo y nota promedio.
Al ordenar se ordena de mayor a menor por el promedio.
Además se emite un listado y mensaje de aprobado o desaprobado.
8. Investigar otros métodos para ordenar datos, aparte del método de la burbuja (método del
intercambio) visto en clase. Describa por lo menos un método y su algoritmo.
9. Dar concepto y por lo menos un ejemplo de árbol y grafo.
Ejercicio
Dar dos matrices enteras de orden 2, y hallar el producto de dichas matrices.
#include <cstdlib>
#include <iostream>

{
float A[4][4],B[4][4],C[4][4];
int m,n,p,q,i,j,x,y,z;
cout<< "\n Dar dos matrices y hallar el producto";

cout<< "\n Filas y columnas de la primera matriz:";
cin>>m>>n;
cout<< "\n filas y columnas de la segunda matriz:";
cin>>p>>q;
if(n!=p)
cout<< "\n No es posible producto";
else
{
cout<< "\n Lectura de la matriz A:\n";
79
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
cout<< "A["<<i<<"]["<<j<<"]=";
cin>>A[i][j];
}
cout<< "\n";
}
cout<< "\n Lectura de la matriz B:\n";
for(i=0;i<p;i++ )
{
for(j=0;j<q;j++)
{
cout<< "B["<<i<<"]["<<j<<"]=";
cin>>B[i][j];
}
cout<< "\n";
}
for(x=0;x<m;x++)
{
for(y=0;y<q;y++)
{
C[x][y]=0;
for(z=0;z<n;z++)
{
C[x][y]=C[x][y]+A[x][z]*B[z][y];
}
}
cout<< "\n";
}
cout<< "\n Matriz producto\n";
for(i=0;i<m;i++)
{
for(j=0;j<q;j++)
cout<<C[i][j]<<" ";
cout<< "\n";
}
}
system("PAUSE");
}
Ejercicio
Ingresar cinco nombres y ordenar alfabéticamente por apellidos.
#include <iostream.h>
{ char apellidos_ns[5][30];
char temporal[30];
int i,x,y;
cout<<"ORDENAR POR APELLIDOS Y NOMBRES";
for(i=0; i<5;i++)
{ fflush(stdin);
cout<<"\nAPELLIDOS Y NOMBRES["<<i+1<<"]=";
//gets(apellidos_ns[i]);
cin.getline(apellidos_ns[i],28);
80
}
cout<<"DATOS INGRESADOS";
for(i=0; i<5;i++)
{
cout<<"\n"<<i+1<<" ."<<apellidos_ns[i];
}
for(x=0;x<4;x++)
{
for(y=0;y<4-x;y++)
{if(strcmp(apellidos_ns[y],apellidos_ns[y+1])>0)
{
strcpy(temporal,apellidos_ns[y]);
strcpy(apellidos_ns[y],apellidos_ns[y+1]);
strcpy(apellidos_ns[y+1],temporal);
}
}
}
cout<<"\nDATOS ORDENADOS";
for(i=0; i<5;i++)
{
cout<<"\n"<<i+1<<" ."<<apellidos_ns[i];
} cout<<endl;
//getch();
system("PAUSE");
//return 0;
}
CAMPO: Elemento de datos (Elemental)
81
:REGISTRO
Nombre Dirección Tf. Fecha.Nac. EsSalud Sueldo
Un campo es la menor unidad de información de un registro

Existen casos en que un campo se divide en subcampos
Ejemplo:
1 7 0 5 2 0 0 4
Sub campo Dia Mes Año
8. REGISTROS ( ESTRUCTURAS)
Un registro es una colección de información (campos) relacionados entre sí relativa a una

entidad particular.
Ejemplos de registros
- Registros de nacimiento (Nombre, día Nac. Padre, Madre)

- Registros de empleos (Nombre, direcc, fecha, estudios, sueldo) etc.
Los registros pueden ser de long. Fija o variable

Los registros organizados en campos denominan registros lógicos
Los registros de datos organizan frecuentemente un ejercicio de campos, registros y archivos.
Un registro es diferente de un arreglo lineal por los siguiente:
- Un registro puede ser un conjunto de datos no homogéneos es decir los elementos de

cada registro puede ser de diferente tipo.
- Los elementos de un registro se referencia a través del nombre de cada atributo, por lo
que no existe un orden natural de sus elementos.
Ejemplos:
De un registro de asistencia médica de maternidad donde se registra nacimientos

1 Recién Nacido
2 Nombre
2 Sexo
2 Día nacimiento
3 día
3 mes
3 año
2 Padre
3 Nombre
82
3 Edad
2 Madre
3 Nombre
3 Edad
El Número de izquierda de identificador recibe el nombre de N° de nivel.
Acceder a un elemento determinado de un registro
Ejemplo:
Recién nacido como un archivo con 20 registro: en este caso cada elemento del registro se
convierte en un arreglo de 20 elementos.
Algunos lenguajes referencian el sexo del recién nacido, como:
Recién_nacido.sexo [6]
Otro, edad del padre del 6°

Recién_nacido.padre.edad [6].
ARREGLO COMO REGISTROS
Los elementos pueden almacenarse en un array.

Suponemos una lista de miembros de una organización con:
Nombre, edad, sexo, tf.
Nombre Edad Sexo Tf.
1 JUAN 22 M 284952
2 LUIS 23 M 280011
3 ROSA 16 F 214950
Para un determinado índice K los elementos NOMBRE [K]

Edad[K], Sexo [k], TF [K] Pertenecen al mismo registro.
Datos almacenados en array paralelos (cuatro)
Ejercicio
Usando la estructura alumno:
struct alumno{
int cod;
char nom[30];
83
char sexo;
float prom;
};
Desde un menú de opciones, permitir añadir alumnos, y listar.
#include <cstdlib>
#include <iostream>
//using namespace std;
# define max 50
struct alumno{
int cod;
char nom[30];
char sexo;
float prom;
};
int menu();
void carga(struct alumno *p, int * pn);
void lista(struct alumno p[], int x);

{
int n=0, op;
alumno d[max];
do
{
op=menu();
switch(op)
{
case 1: carga(d,&n); break;
//case 2: ordena(d,n); break;
case 3: lista(d,n); break;
}
}while(op!=4);
system("PAUSE");
}
int menu()
{ int op1;
cout<<"\n MENU ";
cout<<"\n 1. Carga ";
cout<<"\n 2. Ordena ";
cout<<"\n 3. Listado ";
cout<<"\n 4. Salir ";
cout<<"\n Seleccione Opcion: ";
cin>>op1;
return op1;
}
void carga(struct alumno *p, int *pn)
{
int k;
struct alumno e;
cout<<"cuantos alumnos desea ingresar:";
do
84
{
cin>>*pn;
}while(*pn<1 || *pn>max);
for(k=0; k<*pn;k++)
{
cout<<"datos del alumno N."<<k+1<<"\n\n";
cout<<"codigo :";
cin>>e.cod;
fflush(stdin);
cout<<"nombre:";
cin.getline(e.nom,30); // o, gets(e.nom). Ingresar a lo sumo 28 caracteres.
fflush(stdin);
cout<<"sexo : m - f";
do
{
cin>>e.sexo;
}while(e.sexo!='m'&& e.sexo!='f');
cout<<"promedio: " ;
do
{
cin>>e.prom;
}while(e.prom<0 || e.prom>20);
*(p+k)=e;
}
}
void lista(struct alumno p[], int x)
{
int k;
cout<<" LISTADO DE ALUMNOS "<<endl;
cout<<" CODIGO NOMBRE SEXO PROMEDIO "<<endl;
for(k=0;k<x;k++)
{
cout<<"\n"<<p[k].cod<<"\t"<<p[k].nom<<"\t\t\t"<<p[k].sexo<<"\t"<<p[k].prom<<endl;
}
}
85
Ejercicio
Ejercicio
Se pretende representar un triángulo en el espacio tridimensional, pero minimizando el
espacio necesario para almacenarlo. Teniendo en cuenta que un triángulo en el espacio
tridimensional viene determinado por las coordenadas de sus tres vértices, escribir un
programa con una estructura para representar un triángulo que usando un vector dinámico
almacene el índice de los tres vértices (de esta forma se almacena los tres vértices con tres
enteros en lugar de nueve, ahorrando memoria).
Luego indique si los puntos dados forman o no un triangulo.
#include <stdio.h>
#include <iostream.h>
#include <conio.h>
#include <math.h>
struct Punto{
int CoordX;
int CoordY;
int CoordZ;
};
Punto *Vector;
void LeerVectorPuntos(Punto *Vector,int n);
void MostrarVectorPuntos(Punto *Vector,int n);
int estriangulo(Punto *p);
{
int n,rpta;
cout<<"\n REPRESENTANDO TRIANGULO EN EL ESPACIO TRIDIMENSIONAL";
do{
cout<<"\n Vertices del triangulo en el espacio tridimensional(3):";
cin>>n;
}while(n!=3);
Vector=new Punto[3];
LeerVectorPuntos(Vector,n);
MostrarVectorPuntos(Vector,n);
rpta=estriangulo(Vector);
if(rpta==1)
cout<<"\n LOS PUNTOS DADOS FORMAN UN TRIANGULO";
else
cout<<"\n LOS PUNTOS DADOS NO FORMAN UN TRIANGULO";
getche();
return 0;
}
void LeerVectorPuntos(Punto *Vector,int n)
{
int i;
for(i=0;i<n;i++)
{cout<<"\n COORDENADAS X,Y,Z: "<<"del punto "<<i+1<<": ";
cin>>Vector[i].CoordX>>Vector[i].CoordY>>Vector[i].CoordZ;
}
}
void MostrarVectorPuntos(Punto *Vector,int n)
{int i;
for(i=0;i<n;i++){
cout<<"\n COORDENADAS DEL PUNTO: "<<i+1;
86
cout<<": ("<<Vector[i].CoordX<<","<<Vector[i].CoordY<<","<<Vector[i].CoordZ<<")";
}
}
int estriangulo(Punto *p)
{
double d1,d2,d3;
d1=sqrt(pow((p[1].CoordX-p[0].CoordX),2)+pow((p[1].CoordY-
p[0].CoordY),2)+pow((p[1].CoordZ-p[0].CoordZ),2));
if(d1<d2+d3 && d2<d1+d3 && d3<d1+d2)
return 1;
else
return 0;
}
9. ARCHIVOS
En C/C++/DevC++, encontramos archivos de tipo texto, binario.

En general los archivos podemos reconocer como registros relacionados entre si con aspectos
en común y organizado para un propósito específico.
Organizar los datos de tal manera que se pueden: actualizar recuperar, borrar insertar
Tienen: nombre, tamaño(peso), fecha, etc.
CLAVE: (Indicativo)
Clave que identifica el registro y lo diferencia de otros registros
Ejemplos: de clave: N° de identificación
Ejercicio 1:
Usando la estructura empleado con los campos: código, nombre, y sueldo, crear un archivo
empleados.dat, que permita realizar las siguientes acciones en el siguiente:
MENU
87
1. Adición de un empleado
2. Modificar por código
3. Consultar por código
4. Eliminar por código
5. Listado
6. Salir
Seleccione opción:
Nota:
El programa siguiente solo permite: adición de un empleado, y listado.
#include <cstdlib>
#include <iostream>
//#include <fstream>
struct empleado{
char codigo[10];
char nombre[30];
float sueldo;
};
empleado Reg;
FILE *almacen1;
int menu();
void adicionar_empleado();
void listado();
{ int op;
do{
op=menu();
switch(op)
{
case 1: adicionar_empleado(); break;
case 2: break;
case 3: break;
case 4: break;
case 5: listado();break;
case 6: break;
default: cout<<"\n Error, pulse: 1,2,3,4,5,6";break;
}
}while(op!=6);
cout<<"\n";
system("PAUSE");
}
int menu()
{
int op1;
cout<<"\n MENU";
cout<<"\n 1. Adicion de un empleado";
cout<<"\n 2. Modificar por codigo";
cout<<"\n 3. Consultar por codigo";
cout<<"\n 4. Eliminar por codigo";
cout<<"\n 5. Listado";
cout<<"\n 6. Salir";
cout<<"\n Seleccione Opcion:";
88
cin>>op1;
return op1;
}
void adicionar_empleado()
{ char R;
almacen1=fopen("D:\\algoritmos1\\empleados.dat","ab");
if(almacen1!=NULL)
{
do{
cin.clear();
cout<<"\n Ingreso de datos de empleado \n";
cout<<"\n Codigo:";
cin>>Reg.codigo;
fflush(stdin);
cout<<"\n Nombre:";
cin.get(Reg.nombre,30); //Ingresar a lo sumo 28 caracteres
fflush(stdin);
cout<<"\n Sueldo:";
cin>>Reg.sueldo;
fwrite(&Reg,sizeof(Reg),1,almacen1);
cout<<"\n Continuar <s/n>:";
do{
cin>>R;
R=toupper(R);
}while(R!='S' && R!='N');
}while(R=='S');
}
else
cout<<"\n No pudo crearse el archivo empleados.dat \n";
fclose(almacen1);
}
void listado()
{
almacen1=fopen("D:\\algoritmos1\\empleados.dat","rb");
if(almacen1!=NULL)
{
cin.clear();
cout<<"\n LISTADO DE EMPLEADOS ";
cout<<"\n ====================";
cout<<"\n CODIGO"<<"\t\t"<<"NOMBRE "<<"SUELDO ";
cout<<"\n ===================================================";
fread(&Reg,sizeof(Reg),1,almacen1);
while(!feof(almacen1)){
//cout<<"\n";
//printf("\n%3c\t%28s\t%8.2f",Reg.codigo,Reg.nombre,Reg.sueldo);
cout<<"\n"<<Reg.codigo<<"\t"<<Reg.nombre<<"\t\t"<<Reg.sueldo;
fread(&Reg,sizeof(Reg),1,almacen1);
}
cout<<"\n";
system("PAUSE");
}
else
cout<<"\n El archivo empleados.dat no existe \n";
fclose(almacen1);
}
89
Ejercicio 2:
Escribir un programa que gestione una agenda de direcciones, utilizando archivos. Los datos
de la agenda utiliza estructuras, la cual tiene los siguientes campos: nombre, dirección,
teléfono fijo, teléfono móvil, dirección de correo electrónico. El programa debe permitir añadir
una nueva entrada a la agenda, mostrar agenda, modificar contacto, buscar, y eliminar una
entrada.
#include <iostream>
//#include <stdlib.h>
#include <cstdlib>
#include <stdio.h>
#include <conio.h>
//#include <conio.c>
#include <string>
#include <iomanip>
#include <cmath>
#include <ctype.h>
90
struct PERSONA{
char nom[20];
char ape1[20];
char ape2[20];
char direc[30];
char fijo[10];
char movil[15];
char msn[30];
};
void CrearRegistro(FILE *F, PERSONA A);
void MostrarRegistro(FILE *F, PERSONA A);
void BuscarNombre(FILE *F, PERSONA A);
void BuscarApellidoPaterno(FILE *F, PERSONA A);
void BuscarApellidoMaterno(FILE *F, PERSONA A);
void BuscarMovil(FILE *F, PERSONA A);
void EditarRegistro(FILE *F, FILE *G, PERSONA A);
void EliminarRegistro(FILE *F, FILE *G, PERSONA A);
void msjerror();
void datos(PERSONA A);
void MenuBusqueda();
void MenuPrincipal();

{
//textbackground(YELLOW);
//system("color",4);
system("cls");
//textcolor(GREEN);
FILE M;
FILE N;
PERSONA Z;
int op,op2;
do{
system("cls");
MenuPrincipal();
cout<<"\nIngrese su opcion ---> ";
cin>>op;
switch(op){
case 1:
system("cls");
CrearRegistro(&M,Z);
system("pause");
system("cls");
cout<<"\n\nPERSONA GUARDADA
CORRECTAMENTE!!!!!!\n\n";
system("pause");
break;
case 2:
system("cls");
MostrarRegistro(&M,Z);
system("pause");
break;
case 3:
system("cls");
EditarRegistro(&M,&N,Z);
91
system("pause");
break;
case 4:
do{
system("cls");
MenuBusqueda();
cout<<"\n\nIngrese su opcion ---> ";
cin>>op2;
switch(op2){
case 1:
system("cls");
BuscarNombre(&M,Z);
system("pause");
break;
case 2:
system("cls");
BuscarApellidoPaterno(&M,Z);
system("pause");
break;
case 3:
system("cls");
BuscarApellidoMaterno(&M,Z);
system("pause");
break;
case 4:
system("cls");
BuscarMovil(&M,Z);
system("pause");
break;
case 5:
break;
default :
system("cls");
cout<<"\n\nINGRESE OPCION
CORRECTA !!!!!\n\n";
system("pause");
break;
}
}while(op2!=5);
break;
case 5:
system("cls");
EliminarRegistro(&M,&N,Z);
system("pause");
break;
case 6:
exit(1);
break;
default :
system("cls");
cout<<"\n\nINGRESE OPCION CORRECTA !!!!!!!\n\n";
system("pause");
break;
}
}while(op);
system("PAUSE");
92
//return 0;
}
void MenuBusqueda()
{
cout<<"**************************************************\n";
cout<<"************* MENU DE BUSQUEDA ****************\n";
cout<<"**************************************************\n";
cout<<"****** 1.- BUSQUEDA POR NOMBRE ******\n";
cout<<"****** 2.- BUSQUEDA APELL. PATERNO ******\n";
cout<<"****** 3.- BUSQUEDA APELL. MATERNO ******\n";
cout<<"****** 4.- BUSQUEDA TELEFONO MOVIL ******\n";
cout<<"****** 5.- SALIR ******\n";
cout<<"**************************************************\n";
cout<<"**************************************************\n";
}
void MenuPrincipal()
{
cout<<"**************************************************\n";
cout<<"**************** MENU PRINCIPAL **************\n";
cout<<"**************************************************\n";
cout<<"****** 1.- AGREGAR CONTACTO ******\n";
cout<<"****** 2.- MOSTRAR AGENDA ******\n";
cout<<"****** 3.- MODIFICAR CONTACTO ******\n";
cout<<"****** 4.- BUSCAR CONTACTO ******\n";
cout<<"****** 5.- ELIMINAR CONTACTO ******\n";
cout<<"****** 6.- CERRAR AGENDA ******\n";
cout<<"**************************************************\n";
cout<<"**************************************************\n";
}
void CrearRegistro(FILE *F, PERSONA A)
{
cout<<"\n\n Nombre ---> ";
cin.seekg(0,ios::end);
cin.clear();
cin.getline(A.nom,20);
cout<<" Apellido Paterno ---> ";
cin.getline(A.ape1,20);
cout<<" Apellido Materno ---> ";
cout<<" Direccion ---> ";
cin.getline(A.direc,30);
cout<<" Telefono fijo ---> ";
cin.getline(A.fijo,10);
cout<<" Telefono movil ---> ";
cin.getline(A.movil,15);
cout<<" correo electronico --> ";
cin.getline(A.msn,30);
F=fopen("AGENDA.dat","a+");//abrimos el archivo(creamos)
if(F==NULL){
msjerror();
}
//guardamos la estructura en un registro
fwrite(&A,sizeof(A),1,F);
93
fclose(F);//cerramos el archivo
void MostrarRegistro(FILE *F, PERSONA A)

{
F=fopen("AGENDA.dat","a+");
if(F==NULL)
msjerror();
//cargamos el 1er registro a la RAM
fread(&A,sizeof(A),1,F);
cout<<"\n\t*******************************\n";
cout<<"\t*** AGENDA ***\n";
cout<<"\t*******************************\n\n";
cout<<"\n=========================================\n";
while(feof(F)==0){
datos(A);
fread(&A,sizeof(A),1,F);//cargamos el siguiente registro a la RAM
}
cout<<"\n=========================================\n";
void BuscarNombre(FILE *F, PERSONA A)

{
char aux[20];
int hallado=0;
cout<<"\nNombre a buscar --> ";
cin.clear();
cin.getline(aux,20);
F=fopen("AGENDA.dat","a+");//abrimos el archivo
if(F==NULL)
msjerror();
fread(&A,sizeof(A),1,F);//cargamos el registro a la RAM
while(feof(F)==0){
if(strcmp(aux,A.nom)==0){
datos(A);
hallado=1;
}
}
if(hallado==0){
cout<<"\n\nPERSONA NO ENCONTRADA !!!!!\n\n";
}
}
void BuscarApellidoPaterno(FILE *F, PERSONA A)

{
char aux[20];
int hallado=0;
cout<<"\nApellido Paterno a buscar --> ";
94
cin.clear();
if(F==NULL)
msjerror();
while(feof(F)==0){
if(strcmp(aux,A.ape1)==0){
datos(A);
hallado=1;
}
}
if(hallado==0){
}
}
void BuscarApellidoMaterno(FILE *F, PERSONA A)
{
char aux[20];
int hallado=0;
cout<<"\nApellido Materno a buscar --> ";
cin.clear();
if(F==NULL)
msjerror();
while(feof(F)==0){
if(strcmp(aux,A.ape2)==0){
datos(A);
hallado=1;
}
}
if(hallado==0){
}
}
void BuscarMovil(FILE *F, PERSONA A)

{
char aux[20];
int hallado=0;
cout<<"\nTelefono Movil a buscar --> ";
cin.clear();
if(F==NULL)
95
msjerror();
while(feof(F)==0){
if(strcmp(aux,A.movil)==0){
datos(A);
hallado=1;
}
}
if(hallado==0){
}
}
void EditarRegistro(FILE *F, FILE *G, PERSONA A)

{
char aux[20];
cout<<"\nNombre a Editar --> ";
cin.clear();
F=fopen("AGENDA.dat","r+");//abrimos el archivo
if(F==NULL)
msjerror();
G=fopen("auxiliar.dat","a+");//creamos-abrimos un archivo temporal
if(G==NULL)
msjerror();
int hallado=0;
fread(&A,sizeof(A),1,F);//cargamos el 1er registro en la RAM
while(feof(F)==0){
if(strcmp(aux,A.nom)==0){
datos(A);
cout<<"\nNuevo Nombre --> ";
cin.clear();
cin.getline(A.nom,20);
cout<<"Nuevo Apellido Paterno ---> ";
cout<<"Nuevo Apellido Materno ---> ";
cout<<"Nueva Direccion --> ";
cin.getline(A.direc,30);
cout<<"Nuevo Telefono fijo ---> ";
cin.getline(A.fijo,10);
cout<<"Nuevo Telefono movil ---> ";
cin.getline(A.movil,15);
cout<<"Nuevo correo electronico --> ";
cin.getline(A.msn,30);
fwrite(&A,sizeof(A),1,G);//guardamos el registro en el archivo G
hallado=1;
}
else {
fwrite(&A,sizeof(A),1,G);//guardamos el registro en el archivo G
}
96
fread(&A,sizeof(A),1,F);//cargamos el sieguiente registro a la RAM
}
if(hallado==0){
system("pause");
system("cls");
cout<<"\n\nEsta Persona no existe !!!!\n\n";
}
else {
system("pause");
system("cls");
cout<<"\n\nRegistro Editado con exito!!!!!\n\n";
}
//cerramos los archivos
fclose(F);
fclose(G);
remove("AGENDA.dat");//eliminamos el archivo AGENDA.dat

rename("auxiliar.dat","AGENDA.dat");//cambiamos de nombre aux.dat a AGENDA.dat
void EliminarRegistro(FILE *F, FILE *G, PERSONA A)

{
char aux1[20],aux2[20],aux3[20];
cout<<"\nDATOS DE CONTACTO A ELIMINAR :\n";
cout<<"\nNombre --> ";
cin.clear();
cin.getline(aux1,20);
cout<<"\nApellido Paterno ---> ";
cout<<"\nApellido Materno ---> ";
F=fopen("AGENDA.dat","r+");//abrimos el archivo AGENDA.dat

if(F==NULL)
msjerror();
G=fopen("auxiliar.dat","a+");//creamos-abrimos un archivo auxiliar
if(G==NULL)
msjerror();
int hallado=0;
fread(&A,sizeof(A),1,F);//cargamos un registro a la RAM
while(feof(F)==0){
if(strcmp(aux1,A.nom)!=0 || strcmp(aux2,A.ape1)!=0 ||
strcmp(aux3,A.ape2)!=0){
fwrite(&A,sizeof(A),1,G);
}
if(strcmp(aux1,A.nom)==0 && strcmp(aux2,A.ape1)==0 &&
strcmp(aux3,A.ape2)==0)
hallado=1;
}
fclose(F);
fclose(G);
97
remove("AGENDA.dat");
rename("auxiliar.dat","AGENDA.dat");
if(hallado==0){
system("pause");
system("cls");
cout<<"\n\nPERSONA NO ENCONTRADA _!!!!!\n\n";
}
else{
system("pause");
system("cls");
cout<<"\n\nPERSONA ELIMINADA CON EXITO_!!!!!!\n\n";
}
}
void msjerror()
{
cout<<"\n\nNO SE PUEDE ABRIR EL ARCHIVO \n\n";
system("pause");
exit(1);
}
void datos(PERSONA R)
{
cout<<"\n------------------------------\n";
cout<<"\tNOMBRE : "<<R.nom<<endl;
cout<<"\tAPELLIDO PATERNO : "<<R.ape1<<endl;
cout<<"\tAPELLIDO MATERNO : "<<R.ape2<<endl;
cout<<"\tDIRECCION : "<<R.direc<<endl;
cout<<"\tTELEFONO FIJO : "<<R.fijo<<endl;
cout<<"\tTELEFONO MOVIL : "<<R.movil<<endl;
cout<<"\tCORREO ELECTRONICO : "<<R.msn<<endl;
cout<<"\n------------------------------\n";
}
10. LISTAS ENLAZADAS
Estructura de datos dinámica, que es una colección de elementos llamados nodos, dispuestos
uno a continuación de otro, cada uno de ellos conectado al siguiente elemento por un “enlace”
o “puntero”.
Los elementos se almacenan en posiciones de memoria que no son contiguas o adyacentes.
Tipos:
 Listas simplemente enlazadas
 Listas doblemente enlazadas
 Lista circular simplemente enlazada
 Lista circular doblemente enlazada
Listas simplemente enlazadas

Operaciones: declaración de los tipos nodo, puntero a nodo, clase nodo; declaración de clase
lista, creación; insertar elementos en una lista, buscar, eliminar, recorrer una lista enlazada;
comprobar si la lista está vacía.
Declaración de los tipos nodo y puntero a nodo y clase nodo

En C++, se puede definir un nodo mediante las palabras reservadas struct o class.
98
struct Nodo { class Nodo {
public
int dato; int dato;
Nodo *enlace; Nodo *enlace;
// constructor
}; };
Declaración e implementación de una clase Nodo que contiene información de tipo elemento
y el siguiente de tipo puntero a nodo.
class Nodo typedef class Nodo typedef double Elemento;

{ { class Nodo
public: public: {
int info; int info; public:
Nodo* sig; Nodo *sig; Elemento info;
}; }NODO; Nodo *sig;
};
Una clase Nodo tiene dos atributos protegidos que son el elemento e y Sig que es un puntero
a la propia clase Nodo. Ambos atributos sirven para almacenar la información del nodo, y la
dirección del siguiente nodo. Se declaran como funciones miembro tres constructores. Estos
constructores son: el constructor por defecto, el constructor que inicializa el atributo x del Nodo
al valor de x, y pone el atributo Sig a Null; el constructor, que inicializa los dos atributos del
Nodo. Las funciones miembro encargadas de Obtener y Poner tanto el elemento e como el
puntero Sig son: Telemento OE(); void PE(Telemento e); Nodo *Osig(); y void Psig(Nodo *p)..
El destructor, se declara por defecto. El tipo elemento de la clase Nodo es un entero, pero al
estar definido en un typedef, puede cambiarse para que almacene otro tipo de información.
#include <cstdlib>
#include <iostream>
typedef int Telemento;
class Nodo{
protected:
Telemento e;
Nodo *Sig;
public:
Nodo(){} // Constructor vacio
Nodo(Telemento x); //Constructor
Nodo(Telemento x, Nodo* s); //Constructor
~Nodo(){} // Destructor
Telemento OE(); // Obtener elemento
void PE(Telemento e); // Poner elemento
Nodo *OSig(); // Obtener siguiente
void PSig(Nodo *p); // Poner siguiente
};
Nodo::Nodo(Telemento x)
{ // constructor inicializa e a x y Sig a Null
e=x;
Sig=NULL;
}
Nodo(Telemento x, Nodo* s)
{ // constructor inicializa e a x y Sig a s
e=x;
Sig=s;
99
}
Telemento Nodo::OE()
{ // obtiene una copia del atributo e
return e;
}
void Nodo::PE(Telemento x)
{ // pone el atributo e a x
e=x;
}
Nodo* Nodo::OSig()
{ // obtiene una copia del atributo sig
return Sig;
}
void Nodo::PSig(Nodo *p)

{ // Pone el atributo Sig a p
Sig=p;
}
REFERENCIAS
1. H.M Deitel, P.J. Deitel. C++ como Programar. Edit. Prentice Hall
Hispanoamericana, S.A 2012. México.
2. García, Félix; Carretero, Jesús et al. Programación en Lenguajes

Estructurados. Edit. Paraninfo. 2008. España. ISBN: 978-84-9732-549-3. 447p.
3. Ceballos Sierra, Fco. Javier. Enciclopedia del lenguaje C++. 2009. Edit.
Alfaomega Ra-Ma. México. ISBN: 978-607-7686-43-9. 856p.
4. Cairó, Osvaldo. METODOLOGÍA DE LA PROGRAMACIÓN, 2011. Edit.

Alfaomega. México. ISBN: 970-15-1100-X. 462p.
5. Joyanes, Luis; Zahonero, Luis. Programación en C, C++, Java y UML. Edit. Mc

Graw Hill. 2010.. México.
100
INDICE
Pág.
1. Conceptos Generales de Programación ………................................................ 1
2. C/C++/DevC++ ……………………………………………………………………… 11
3. Estructuras de Control Selectivas …………………………………………………. 35
4. Estructuras Repetitivas …………………………………………………..…………. 44
5. Punteros …………………………………………………………………………….. 63
6. Funciones ………………………………………………………………………….…. 67
7. Arreglos …………………………………………………………………………..…… 71
8. Registros ………………………………………………………………………….…. 82
101
9. Archivos ………………………………………………………………………………. 88
102
Agradecimiento:
A Dios, a mis padres, a los

que fueron mis alumnos, y
todos los que colaboraron en
la presente guía.
UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS
FACULTAD DE INGENIERIA DE SISTEMAS E INFORMATICA

E.A.P INGENIERIA DE SISTEMAS
Notas del Curso Programación y Fundamentos de

Algorítmica
103
Luis Guerra Grados
Abril – 2019
104

Notas Del Curso Programacion y Fundamentos de Algoritmica

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Notas Del Curso Programacion y Fundamentos de Algoritmica

Cargado por

Copyright:

Formatos disponibles

1.

CONCEPTOS GENERALES DE PROGRAMACIÓN

Lenguajes de alto nivel

a) X + Y  Mat. +, / Algorit. Mat.

Esto es lo que en programación se llama “modularizar”

1.2 Seudo código

- Paso previo entre algoritmo y programa.

1.3 Variable de Memoria

Entregar la solución Información

Datos Procesos Información

Ejempo de definición de Variable

Total <- Valor + 2

1.4 TIPO DE VARIABLES

Variable Numéricas: Guardan números, ejemplo: 0,1,2 …………………., 9

Ejm. NOMBRE = “Juan”

A > B Mayor que

Hallando en el ejemplo el valor lógico, dados A=5, B=10, C=-1, D=0

Hallar el promedio de edades de 2 personas:

HERRAMIENTAS PARA RESOLVER PROBLEMAS

1.6 DIAGRAMA DE FLUJO

Inicio o fin de un proceso

Entrada o salida general de

Instrucciones Básicas de un Algoritmo

Asignación RECEPTOR EMISOR

Impresión: Escribir <mensajes>, <variables>

1.7 TÉCNICAS DE PROGRAMACIÓN (EVOLUCION DE LA PROGRAMACIÓN)

PROGRAMACIÓN ORIENTADA A OBJETOS (POO)

La potencia de los objetos radica en las propiedades que soportan;

Ejemplo de trabajo con POO

Ej: A y a son variables diferentes A  a (Caracteres s )

Para definir un identificador se debe seguir las siguientes reglas:

PALABRAS CLAVE (PALABRAS RESERVADAS)

Son identificadores predefinidos que tienen un significado especial para el lenguaje C. Un

(1) # define (identificador) (valor)

Es un identificador cuyo valor puede variar o cambiar durante la ejecución de un programa.

TIPOS DE DATOS PREDEFINIDOS

a) char (caracter – 1 byte): Se almacena en un byte.

Es un tipo que puede almacenar un solo carácter, correspondiente al código ASCII.

b) short (entero – 2 bytes); int (2 – 4 bytes de memoria)

Ejs: unsigned int num3, int num1, num2 ;

c) long (entero largo ocupa 4 bytes de memoria)

Almacena la parte entera de un número en el rango : -2147483648 y 2147483647. De forma

unsigned long area_pais ;

d) float (reales en simple precisión – 4 bytes) (ocupa 4 bytes de memoria)

e) double (reales en doble precisión – 8 bytes)

Almacena valores en el rango de :

Rango : -1.7 x 10308 hasta 1.7 x 10308 (15 dígitos)

El tipo de dato bool

cout<<” b2: “<<b2<<end1; // muestra el valor b2 que es 0

Puede existir 2 ó mas sentencias en una misma línea.

Sentencia de Declaración int num ;

- En la división si ambos operandos son enteros el resultado será un N° entero,

& & y Lógico

a = (10 > 5) ; // a=1

Estructura genérica de un programa en C++ / Dev C++

# include <archivo externo>

int main(int argc, char *argv[] ) // int main() //void main ( )

# include <archivo externo>

# define identificador valor

a) Definir su tipo de dato : char, int, short,

Función printf (stdio.h)

Al imprimir o mostrar en la pantalla , y leer :

d) ¿Cuál es el resultado de la siguiente expresión 3 + 4 (8 (4-(9+3)/6))?