Utp - Ciclo III - Separata Programacion en Lenguaje de Alto Nivel I

1.
Estructura de un programa en C++
1.1 El formato general de un programa en C++ es el siguiente:
/
| Definición de constantes y macros,
ENCABEZADO < declaración de variables globales,
| Inclusión de archivos.
\
void main(void) <---linea de cabecera de la función principal.

{ <-------------Inicio de bloque.
.........
.........
......... <---Cuerpo de la función principal.
.........
} <-------------Fin de bloque.
En el listado 1.1 se muestra un programa que despliega en la pantalla del monitor

el mensaje:
El Lenguaje C++ es poderoso
// PRIMER.CPP
//
// Despliega un mensaje en la pantalla.
#include <stdio.h> // Para utilizar la función printf()
void main(void)
{
printf("El lenguaje C++ es poderoso\n");
}
Listado 1.1.- Primer programa en C++
1.2.- Archivos de cabecera.
El listado 1.1 contiene la línea :
#include <stdio.h>
En ella, stdio.h es el nombre de un archivo de cabecera en el cual se

encuentran declarados los prototipos de las funciones y macros que se
utilizan para la entrada/salida estándar. Existe un extenso grupo de archivos
de cabecera, y cada uno de ellos sirve para manejar un grupo de funciones
relacionadas. La extensión h de estos archivos es la inicial de la palabra
header.
Generalmente estos archivos se incluyen en las primeras líneas de los
archivos que contienen el código fuente de los programas en C++ . El
1
compilador de C++ desplegará un mensaje de error cuando se trate de
utilizar una función sin antes haber incluido el archivo de cabecera que
contiene el prototipo de ella.
Los archivos de cabecera son almacenados en el directorio INCLUDE cuando
se instala el paquete del compilador.
1.3.- Comentarios.
En el C++ existen dos formas de manejar los comentarios:
La primera sirve para escribir comentarios que abarcan varias líneas, y

utiliza los caracteres /* para marcar el inicio de un comentario, y los
caracteres */ para marcar el final, como se ve en los siguientes ejemplos:
/* Este es un pequeño comentario */
/* Este es otro comentario, pero a diferencia del

anterior, utiliza varias líneas.
Observe que también puede incluir líneas en blanco (como la

anterior y la
siguiente).
*/
La segunda forma solo sirve para comentarios que abarcan una línea o
parte de ella, y utiliza los caracteres // al principio del comentario. El fin del
comentario queda marcado por el fin de la línea, como se muestra a
continuación:
// Este es un comentario de una línea,
// y este es otro.
void main(void) // Este comentario ocupa parte de la línea.

Los comentarios de una sola línea pueden anidarse dentro de los
comentarios de varias líneas, como en :
/* El principio del comentario de varias líneas.
// Primer comentario de una sola línea.
// Segundo comentario de una sola línea.
*/ Fin del comentario de varias líneas.
1.4.- Directivas del preprocesador
El preprocesador es un programa que viene incluido en los compiladores de

C++, y se encarga de ejecutar ciertas órdenes llamadas DIRECTIVAS DEL
PREPROCESADOR. Estas directivas empiezan con el carácter # ( Numeral ).
Al inicio de la compilación, el compilador invoca al preprocesador, quien
actúa de acuerdo a la directiva correspondiente.
Las directivas del preprocesador pueden clasificarse en tres grupos

principales:
1.4.1.- Inclusión de archivos
2
Pueden incluirse los contenidos de otros archivos de texto en el archivo que
contiene código en C++ . Esto se logra por medio de la directiva #include
en cualquiera de las tres formas siguientes :
#include <nombre_archivo>
/* nombre_archivo se buscará solamente en el directorio INCLUDE */
#include "nombre_archivo"
/* nombre_archivo se buscará en el directorio de trabajo actual */
#include "d:\trayectoria\nombre_archivo"
/* En este caso, nombre_archivo será buscado en el directorio especificado en
trayectoria */
Ejemplo:
#include "C:\DATOSCPP\PANTALLA.C"
1.4.2.- Reemplazamiento de cadenas y procesamiento de macros
El reemplazamiento de cadenas consiste en sustituir (antes de efectuar la

compilación) cada una de las ocurrencias de cierta cadena (llamada
constante simbólica) por otra cadena equivalente. Esto de logra por medio
de la directiva #define, como se muestra en los siguientes ejemplos:
#include <stdio.h>
#define CADENA "El Lenguaje C++ es poderoso\n"
void main(void)
{
printf(CADENA);
}
En este caso, el preprocesador sustituirá CADENA por El Lenguaje C++ es
poderoso, de tal manera que el compilador se encontrará con la instrucción:
printf("El Lenguaje C++ es poderoso\n");
#define VALMAX 1000

Aquí, se está definiendo la constante simbólica VALMAX, cuyo valor será el
entero 1000.
La directiva #define también sirve para declarar macros, las cuales incluyen
una ó más instrucciones del Lenguaje C++ , como en:
#define CUBO(N) ((N)*(N)*(N))
Esta macro puede utilizarse en una instrucción de la siguiente forma:

r = CUBO(5);
El preprocesador sustituye lo anterior por:

r = ((5)*(5)*(5));
Las macros pueden tomar formas complejas y ocupar varias líneas de

código, como se muestra en el siguiente ejemplo:
#define REDOND(x) ((x)>=0?((x)+1/VALOR1)*(1-1/VALOR1): \

((x)-1/VALOR1)*(1+1/VALOR1))
3
Obsérvese que al final de la primera línea se escribió una diagonal invertida
( \ ), la cual sirve como enlace.
1.4.3.- Compilación condicional
Existe un grupo de directivas del preprocesador que permiten controlar

cuales partes del código fuente se van a compilar al cumplirse ciertas
condiciones. A continuación se muestra una lista de tales directivas;
dejándose la ejemplificación de su uso para unidades más avanzadas de
este trabajo.
#if
#ifdef
#if defined(algo)
#ifndef
#else
#elif
#endif
Además de las directivas vistas hasta aquí, existen las siguientes:
#error
#pragma inline
#pragma warn
#pragma saveregs
1.5.- La Función main()
Todo programa de C++ debe contener una función llamada main()

(principal), la cual sirve de enlace con el sistema operativo que se esté
utilizando. Cuando se intente obtener un programa ejecutable(.EXE ) a partir
de un archivo que no contenga una función main(), el compilador
desplegará un mensaje de error.
Al invocar a un programa escrito en C++, desde el indicador de presencia

del sistema operativo, se le pueden pasar ciertos valores que se llaman
argumentos, los cuales van a ser recibidos por la función principal. Esta, a
su vez, va a regresar un valor de retorno al sistema operativo que la invocó.
La devolución del valor de retorno se hace por medio de la instrucción
return, por ejemplo:
return 0 ;
La explicación acerca de la utilización de argumentos en la función main()
requiere del conocimiento de apuntadores, por lo que se tratará en la
unidad 6.
1.6.- Identificadores
Los nombres que son utilizados para referenciar variables, funciones,

etiquetas y demás objetos que se manejan con el Lenguaje C++, son
referidos en forma genérica como identificadores.
1.6.1.- Identificadores creados por el usuario
4
El usuario debe cuidar que los identificadores creados por él cumplan las
siguientes:
Reglas generales para los identificadores:

1.- Pueden estar formados por:
a.- Letras mayúsculas y/o minúsculas.

b.- El carácter de subrayado.
c.- Los dígitos del 0 al 9.
2.- El primer carácter debe ser una letra o el carácter de subrayado.
3.- Pueden contener un número arbitrario de caracteres; pero Borland C++

considera como significativos los primeros 32 o los n primeros que
decida el programador, donde:
1 <= n <="32"
4.- Se toma en cuenta la diferencia entre letras mayúsculas y minúsculas,

por lo que : SUMA, Suma y suma son identificadores diferentes.
5.- No puede utilizarse el mismo identificador para dos objetos que se

encuentren dentro del mismo ámbito.
1.6.2.- Palabras reservadas
Las palabras reservadas, como su nombre lo indica, son identificadores que

tienen asignado un uso específico y no podrán ser utilizadas como
identificadores creados por el usuario.
La tabla 1.1 muestra las palabras reservadas de Borland C++

_asm @ _ds int @ _seg
+ asm else _interrupt short
auto enum @ interrupt signed
break @ _es @ _loadds sizeof
case @ _export long @ _ss
@ _cdecl extern @ _near static
@ cdecl @ _far @ near struct
char @ far + new switch
+ class @ _fastcall + operator + template
const float @ _pascal + this
continue for @ pascal typedef
@ _cs + friend + private union
default goto + protected unsigned
+ delete _huge + public + virtual
do @ huge register void
double if return volatile
+ inline @ _saveregs while
Tabla 1.1.- Palabras reservadas de Borland C++.
Las palabras marcadas con + en la tabla 1.1 son las palabras reservadas
específicas de C++, las marcadas con @ son las palabras añadidas por
Borland al C, y las palabras sin marca son las palabras reservadas del C
estándar.
5
1.7.- Entrada/Salida
En el Lenguaje C++, la entrada/salida se maneja de dos formas.
La primera consiste en la utilización de las funciones cuyos prototipos

vienen declarados en el archivo stdio.h, y es la forma que tradicionalmente
ha utilizado el Lenguaje C.
La segunda es propia del C++ y consiste en el manejo de objetos y

operadores cuyas definiciones se encuentran en el archivo iostream.h .
A continuación explicaremos cada una de estas dos formas.
1.7.1.- Funciones declaradas en stdio.h

En esta forma, se requiere la inclusión de la siguiente línea al principio del
programa fuente:
#include <stdio.h>
En el archivo stdio.h se encuentran definidos, entre otros, los prototipos de

las funciones printf(), scanf(), gets() y puts() además de las macros getc(x) y
putc(). A continuación analizaremos cada una de estas funciones y macros:
1.7.1.1.- La función printf()
Esta función es la mas utilizada en C para desplegar información en la

pantalla, más no en el lenguaje C++ como veremos más adelante.
El formato general para la función printf() es:
printf(<cadena_formato> , <elem> , <elem> , ... );
donde:
cadena_formato es una cadena de caracteres encerrada entre comillas

dobles. Esta cadena es enviada a la pantalla ( la
salida estándar ) después de haber sustituidos los
elementos listados después de la cadena.
La sustitución de los elementos se hace de acuerdo a los comandos de

formato incluidos en cadena_formato, los cuales empiezan con un símbolo
de porciento ( % ) .
En la tabla 1.2 se muestran los comandos de formato más usuales:
Comando Sirve para:

%d Entero
%u entero sin signo
%ld entero largo
%p valor de apuntador
%f número de punto flotante
6
%e número de punto flotante en valor exponencial
%c Carácter
%s cadena de caracteres
%x entero en formato hexadecimal
%o entero en formato octal
Tabla 1.2.- Comandos de formato.

A fin de poder mostrar algunos ejemplos de aplicación de la función printf(),
se presenta aquí la tabla 1.3 que contiene los tipos de datos disponibles en
el compilador de Borland C++ 3.1.
Tipo Tamaño (bits) Precisión Rango de valores:

char 8 . -128 a 127
unsigned char 8 . 0 a 255
enum 16 . -32,768 a 32,767
int 16 . -32,768 a 32,767
short int 16 . -32,768 a 32,767
unsigned int 16 . 0 a 65,535
long 32 . -2,147'483,648 a 2,147'483,647
unsigned long 32 . 0 a 4,294'967,295
float 32 7 dígitos 3.4E-38 a 3.4E+38
double 64 15 digitos 1.7E-308 a 1.7E+308
long double 80 19 digitos 3.4E-4932 a 3.4E+3932
void . . .
near pointer 16 . Direcciones de memoria
far pointer 16 . Direcciones de memoria
Tabla 1.3.- Tipos de datos, tamaños y rangos en Borland C++ 3.1
1.7.1.2.- La función scanf()
Esta función toma la entrada, normalmente del teclado, y la almacena en

variables previamente
declaradas. El formato para la función scanf() es :
scanf( <cadena_formato> , <elem> , <elem> , ... ) ;
Los significados de <cadena_formato> y <elem> son los mismos que en el caso de la

función printf() . La función scanf() utiliza la mayoría de los comandos mostrados en la
tabla 1.2 La función scanf() debe utilizarse con cautela cuando se van a introducir
valores numéricos y de cadenas de caracteres en una sola instrucción.
1.7.1.3.- Las funciones gets() y puts()
7
Las funciones scanf() y printf() sirven para varios formatos, por lo cual son muy
voluminosas. Es por esto que se han desarrollado las funciones gets() y puts(),
específicas para la entrada/salida de cadenas de caracteres.
La función gets() toma una cadena de caracteres desde el teclado y la almacena en la

variable cuyo identificador aparece como argumento en la invocación a gets(), como en:
gets(nombre);
La función puts() despliega en la pantalla una cadena de caracteres que se
encuentra almacenada en la variable cuyo identificador aparece como
argumento en la invocación a la función puts().
1.7.1.4.- Las macros getc() y putc()
La macro getc(c) toma un caracter desde el teclado y lo almacena en la variable c.

Por su parte, putc() despliega un caracter en la pantalla. Estas macros están definidas en
el archivo stdio.h .
1.7.2.- Funciones declaradas en conio.h.
La consola es un concepto heredado de los ambientes multiusuario, y está formada por

el teclado y el monitor. En las implementaciones de Borland C++ existe una serie de
funciones que manejan la entrada/salida por la consola, entre otras:
clrscr(), que limpia la pantalla y posiciona el cursor en la esquina superior izquierda

de la ventana actual.
gotoxy(a,b), posiciona el cursor en la posición establecida por la columna a y el

renglón b.
window(a,b,x,y), establece la ventana actual. Los valores a,b pertenecen a la

columna y el renglón de la esquina superior izquierda; los valores x,y corresponden a
la columna y el renglón de la esquina inferior derecha de la nueva ventana.
getch(), toma un carácter desde el teclado y no lo despliega en la pantalla.
getche(), toma un carácter desde el teclado y lo despliega en la pantalla.

Para poder utilizar las funciones relacionadas con la consola, es necesario
incluir la linea:
#include <conio.h>
Donde conio.h es el archivo de cabecera donde se encuentran declarados los prototipos

de las funciones que manejan la entrada/salida estándar por la consola.
Los listados 1.2 a 1.8 muestran ejemplos de utilización de formatos por

medio de algunas funciones antes mencionadas
// IMPRIME ENTEROS EN "DECIMAL"
8
#include<stdio.h>
#include<conio.h>
int main()
{
int y=12345;
printf("%13d\n",y);
getch();
return 0;
}
Listado 1.2
// IMPRIME ENTEROS EN OCTAL
#include<stdio.h>
#include<conio.h>
int main()
{
int y=12345;
printf("y = %13d EN DECIMAL\n",y);
printf("y = %13o EN OCTAL\n",y);
getch();
return 0;
}
Listado 1.3
// IMPRIME ENTEROS EN HEXADECIMAL
#include<stdio.h>
#include<conio.h>
int main()
{
int y=12345;
printf("y = %13d EN DECIMAL\n",y);
printf("y = %13x EN HEXADECIMAL\n",y);
getch();
return 0;
}
Listado 1.4
// IMPRIME ENTEROS SIN SIGNO
#include<stdio.h>
#include<conio.h>
int main()
{
int y= -12345;
printf("y = %13d ENTERO CON SIGNO\n",y);
printf("y = %13u ENTERO SIN SIGNO\n",y);
getch();
return 0;
}
Listado 1.5
// IMPRIME NUMEROS CON PUNTO FLOTANTE

#include <stdio.h>
#include<conio.h>
9
int main()
{
float x=123.45;
double y=678.90;
printf("x = %12.2f\ny = %12.1f\n",x,y);
getch();
return 0;
}
Listado 1.6
// IMPRIME CARACTERES
#include <stdio.h>
#include<conio.h>
int main()
{
char a='X', b='Y', c='Z' ;
printf("%c%c%c\n",a,b,c);
getch();
return 0;
}
Listado 1.7
// IMPRIME CADENAS DE CARACTERES

#include <stdio.h>
#include<conio.h>
int main()
{
/*
Formato: %[-a.b]s
donde: - JUSTIFICA A LA IZQUIERDA

a NUMERO DE ESPACIOS DISPONIBLES PARA DESPLEGAR
b NUMERO MAXIMO DE CARACTERES QUE PUEDEN DESPLEGARSE
*/
printf("\n%10s","DESPLEGADO DE CADENAS EN LENGUAJE C++");

printf("\n%-10s","DESPLEGADO DE CADENAS EN LENGUAJE C++");
printf("\n%25.10s","DESPLEGADO DE CADENAS EN LENGUAJE C++");
printf("\n%-25.10s","DESPLEGADO DE CADENAS EN LENGUAJE C++");
printf("\n%.10s","DESPLEGADO DE CADENAS EN LENGUAJE C++");
getch();
return 0;
}
Listado 1.8
Para desplegar el símbolo de porciento puede escribirse en

cadena_formato : % . Por ejemplo:
..........
..........
int utilidad;
utilidad = 30;
printf("La utilidad es del %2d %\n", utilidad);
..........
10
desplegará :
La utilidad es del 30 %
1.7.3.- Objetos declarados en iostream.h
C++ provee una nueva forma para manejar la entrada/salida, proporcionando una
sintaxis más sencilla, elegante e intuitiva que la de stdio.h , además de un mecanismo
más eficiente y flexible. La palabra iostream tiene su origen en las palabras: input
output stream , por lo que puede traducirse como flujo de entrada/salida. El flujo de
entrada/salida es utilizado para enviar datos desde una fuente ( productor ) a un destino (
consumidor ) . En esta forma se tiene una vasta jerarquía de clases para el manejo de
entrada/salida para archivos y dispositivos. En el archivo iostream.h se encuentran
definidos los objetos cin y cout.
El objeto cin utiliza al operador sobrecargado >> para tomar datos desde la entrada
estándar (habitualmente el teclado). El objeto cout utiliza al operador sobrecargado <<
para enviar datos hacia la salida estándar (normalmente la pantalla). Veamos como se
utilizan estos elementos en un pequeño ejemplo:
#include <iostream.h>
int main()
{
char nombre[30];
cout << "CUAL ES TU NOMBRE ? " ; cin>> nombre ;
cout << "\n" ; cout << "!! HOLA , " << nombre << " !! \n" ;
system("PAUSE");
return 0 ;
}
Listado 1.9.- Ejemplo de utilización de cin y cout
También es posible especificar el ancho de un campo por medio del manipulador

setw(), que se encuentra declarado en iomanip.h ; así como los manipuladores
window(), clrscr() y gotoxy() declarados en constrea.h, como se muestra en el listado
1.10.
#include <iomanip.h>
#include <constrea.h>
int main()
{
char nombre[10] ;
int numero = 150 ;
float sueldo ;
constream ventana0, ventana1, ventana2 ;
11
ventana0.window(1,1,80,25);
ventana0.clrscr();
ventana1.clrscr();
cout << "NUMERO: " << setw(3) << numero;
cout << " NOMBRE : " ; cin.getline(nombre,10);
ventana2.clrscr();
cout << "\nSUELDO : $ " ; cin>> sueldo ;
return 0;
}
Listado 1.10.- Uso de manipuladores.
2.- Constantes, variables, operadores

En esta unidad se trata el manejo de los objetos donde se almacenan los datos, así como
las operaciones que pueden realizarse con los valores almacenados.
En este contexto, llamaremos objeto a una región identificable de memoria que
puede almacenar un valor fijo o variable. No debe confundirse el significado
que se dá aquí al vocablo objeto con el que tiene en la Programación Orientada
a Objetos.
2.1.- Constantes
Podemos definir a una constante como una localidad de memoria (objeto), la cual tiene
un nombre y un tipo de dato asociados, además de un valor que permanece fijo durante
el tiempo de ejecución.
En la unidad 1 se estudió la manera de definir constantes por medio de la directiva

#define . Aquí definiremos a las constantes utilizando el modificador const, usando del
formato mostrado a continuación:
const <tipo> <identificador> = <valor>
Ejemplo: const int iva = 10 ;
Los valores para las constantes, permitidos por Borland C++, se clasifican en cuatro
clases:
I).- Enteros, que pueden escribirse en formato:
I.a).- Decimal, con valores de 0 a 4,294'967,295.
Ejemplo: const int smin = 15300 ;
I.b).- Octal, que deben empezar con un 0 (cero).
Ejemplo: const int lim = 030 ; (decimal 27)
I.b).- Hexadecimal, que empiezan con 0X ó 0x (cero x)
Ejemplo: const int mem = 0xFFFF ;
12
II).- Caracteres, compuestos de uno o más caracteres encerrados entre comillas
sencillas (apóstrofes).
Ejemplo: const char inicial = 'A' ;
Para manejar los caracteres de control se utilizan las secuencias de escape que
empiezan con el carácter de diagonal hacia atrás (\) seguida de un carácter. Si el
carácter que sigue a la diagonal es alguno de los caracteres mostrados en la tabla 2.1,
se obtendrá el efecto explicado en ella; pero si es cualquiera de los demás caracteres
del Código ASCII, se visualizará el carácter tal cual.
Secuencia Caracter Efecto

\a BEL Sonido de la bocina
\b BS Retroceso
\f FF Alimentación de forma
\n LF Nueva línea
\r CR Retorno de carro
\t HT Tabulación horizontal
\v VT Tabulación vertical
\\ \ Diagonal hacia atrás
\' ' Comilla sencilla
\" " Comilla doble
\? ? Interrogación
\O O Cualquiera O=Número octal de hasta tres dígitos
\x H Cualquiera H=Número hexadecimal
Tabla 2.1.- Secuencias de escape.
Borland C++ permite el uso de dos caracteres juntos como valores de caracteres.
Por ejemplo: 'AB' , '\n\t' , '\007\007'
III).- Punto flotante, cualquiera con punto decimal ó con formato exponencial.
Ejemplos: 3.135 , 0. , .0 , 34e3 , -3.4 , .075E12
IV).- Enumeración, son identificadores definidos en declaraciones de tipo enum.
Ejemplo: enum frutas { pera, uva, manzana, fresa } ;
donde: pera, uva, manzana y fresa son constantes de enumeración y tienen los
siguientes valores:
pera = 0
uva = 1
manzana = 2
fresa = 3
13
Pueden asignarse valores explícitos como en:
enum frutas {pera, uva , manzana = 10 , fresa = uva+5} ;
y entonces :
pera = 0
uva = 1
manzana = 10
fresa = 6
2.2.- Variables
Una variable es un espacio de memoria que tiene un nombre y un tipo de dato

asociados, además de un valor que puede cambiarse durante el tiempo de ejecución.
En el Lenguaje C++ puede declararse una variable en cualquier lugar del programa, con
la única restricción de que la declaración preceda a la primera instrucción donde se
utiliza tal variable.
El formato para la declaración de una variable o grupo de variables es el siguiente:
[, var2, ... ] ;
Ejemplos:
int algo, otro ;
int suma = 0 , inicial = 1 ;
float desc , acum = 0 ;
char prim = 'A' , seg ;
2.3.- Ambito
El ámbito es una zona de programa donde puede utilizarse un identificador para accesar
su objeto . El ámbito va a depender, básicamente, del lugar del programa en que aparece
la declaración.
Bajo este enfoque, se tienen las siguientes clases de ámbito:
Ambito de BLOQUE.
En el Lenguaje C++, se generaliza el concepto de ámbito local, a través de la

introducción del concepto de bloque.
Un bloque está formado por las instrucciones delimitadas por un par de llaves { }.
Es posible anidar una serie de bloques, y pueden declararse variables dentro de cada
bloque. Si, en diferentes bloques, existen variables con el mismo identificador, todas
serán consideradas como variables diferentes. Así que puede tenerse:
..............
14
..............
int x=5; // x del bloque 1
{
{
{
printf("x=%d",x); // x=30
}
printf("%d",x); // x=20
}
printf("%d",x); // x=10
}
printf("%d",x); // x=5
.............
.............
Debe tenerse cuidado al utilizar identificadores iguales para diferentes variables. Lo más
recomendable es no utilizar los mismos identificadores y no intentar manejar variables
en un ámbito diferente al que pertenecen.
Ambito de FUNCION.
En esta clase sólo se encuentran los identificadores que se utilizan como etiquetas
cuando se tienen instrucciones goto. El identificador de una etiqueta debe ser único
dentro de una función, y no puede utilizarse la instrucción goto para saltar de una
función a otra.
Ambito de PROTOTIPO DE FUNCION.
El ámbito de los identificadores utilizados dentro de los paréntesis en la declaración de

prototipo de una función, finaliza con la declaración del prototipo.
Ambito de ARCHIVO.
Las variables declaradas fuera de cualquier bloque en un archivo son consideradas como
variables globales, y el ámbito de sus identificadores abarca todos los bloques
contenidos en el archivo en cuestión; por lo que: una variable con éste ámbito puede ser
utilizada en las funciones del archivo que estén definidas después del punto donde se
declaró dicha variable.
2.4.- Duración
La duración define el periodo de tiempo durante el cual los identificadores declarados

tienen objetos asignados en memoria. Las variables, por ejemplo, tienen memoria
asignada durante el tiempo de ejecución.
Existen tres clases de duración:
2.4.1.- Duración estática
15
Los objetos con duración estática están localizados en memoria durante todo el tiempo
de ejecución del programa. Las funciones, las variables con ámbito de archivo y las
variables con especificadores de clase de almacenamiento static ó extern, tienen
duración estática. Los objetos con duración estática son inicializados a cero , en
ausencia de un valor inicial explícito.
2.4.2.- Duración local
Los objetos de duración local, conocidos también como objetos automáticos, son
creados en la pila de la memoria RAM ó en los registros del microprocesador. La
memoria asignada a éstos objetos es liberada cuando finaliza la ejecución del bloque
donde fueron creados. Los objetos de duración local deben utilizarse siempre en un
ámbito local ó de función. Cuando se utiliza el especificador de clase de
almacenamiento register, se implica el uso del especificador de clase de
almacenamiento auto.
2.4.3.- Duración dinámica
Los objetos de duración dinámica se crean y se destruyen, por invocaciones a funciones

específicas, durante el tiempo de ejecución de un programa. El almacenamiento de estos
objetos se dá en el área de reserva de la memoria RAM llamado montículo.
2.5.- Enlace
En la creación de un programa ejecutable, primero se lleva a cabo la compilación de

diversas unidades de traslación, las cuales se componen del código fuente junto con los
archivos incluidos. Posteriormente, el archivo objeto (.obj) , se enlaza con librerías
preexistentes para obtener el archivo ejecutable (.exe).
El enlace es el proceso que permite a cada instancia de un identificador asociarse

correctamente con un objeto o función particular. Todos los identificadores tienen uno
de los siguientes atributos de enlace, íntimamente relacionados con su ámbito:
. ENLACE EXTERNO,
. ENLACE INTERNO,
. SIN ENLACE.
Estos atributos se determinan a través del emplazamiento y los formatos de las

declaraciones, junto con el uso (implícito ó explícito) de los especificadores de clase de
almacenamiento static ó extern. Cada instancia de un identificador con enlace externo
representa al mismo objeto ó función a través de todo el conjunto de archivos y librerías
que componen el programa.
Cada instancia de un identificador con enlace interno representa al mismo objeto ó

función solamente dentro de un archivo. Los identificadores sin enlace representan
entidades únicas.
A continuación se presentan las:
16
REGLAS PARA LOS ENLACES INTERNO Y EXTERNO:
1. Cualquier identificador de objeto ó archivo que tenga ámbito de archivo tendrá

enlace interno si su declaración contiene el especificador static.
Para C++, si el mismo identificador aparece con ambos tipos de enlace en el
mismo archivo, el identificador tendrá enlace externo.
2. Si la declaración de un identificador de un objeto ó función contiene el

especificador extern, el identificador tendrá el enlace correspondiente a una
declaración con ámbito de archivo.
3. Si una función se declara sin un especificador de clase de almacenamiento, su

enlace está determinado como si se hubiera utilizado el especificador extern.
4. Si un identificador de objeto con ámbito de archivo se declara sin especificador

de clase de almacenamiento, el identificador tendrá enlace externo.
Los siguientes identificadores no tienen atributo de enlace:
a).- Cualquier identificador declarado para ser algo diferente de un objeto ó

función ( p.ej. un identificador typedef ).
b).- Los parámetros de las funciones.
c).- Los identificadores de ámbito de bloque para objetos declarados sin el el

especificador extern.
Para aclarar lo relacionado con el especificador extern, revisemos los listados 2.1 y 2.2.
// EXTERN1.CPP
int edad; char nombre[31]; // DEFINICION de variables globales
Listado 2.1.- EXTERN1.CPP, que define las variables globales.
// EXTERN2.CPP
// DECLARACION de variables globales que:
extern int edad; // se encuentran en otro archivo
extern char nombre[];
void main()
{
cout << "\nCUAL ES TU NOMBRE ? " ; cin>> nombre ;
cout << "\nCUANTOS AÑOS TIENES, " << nombre << " ?" ; cin>> edad ;
cout << "\n\n" ;
cout << " TE FALTAN " << 100-edad ;
cout << " PARA LLEGAR A LOS CIEN, " << nombre << "\n" ;
}
Listado 2.1.- EXTERN2.CPP, que declara y utiliza variables globales definidas en otro
archivo.
17
En el archivo EXTERN1.CPP se definen las variables globales edad y nombre.
Posteriormente se compila este archivo para obtener el archivo EXTERN1.OBJ.
En el archivo EXTERN2.CPP se declaran las variable edad y nombre utilizando el

modificador extern.
Finalmente, se crea un proyecto al que puede llamarse EXTERN.PRJ, en el cual se

incluyen los archivos EXTERN1.OBJ y EXTERN2.CPP; se compila el proyecto y se
obtiene el archivo ejecutable EXTERN.EXE
2.6.- Operadores
Los objetos que se manejan en C++ van a tener un tipo de dato asociado, el cual
determina la cantidad de espacio de almacenamiento que se le asigna a cada uno de los
objetos de tal tipo, así como el conjunto de operaciones que podrán realizarse con los
valores almacenados. Las operaciones serán representadas a través de identificadores
específicos llamados operadores.
En esta sección estudiaremos los operadores, agrupándolos en:
2.6.1.- Operadores ariméticos
Los operadores aritméticos se aplican sobre objetos con valores numéricos, como se
muestra en la tabla 2.2 .
Sean: X = 20 , Y = 30 , A = 100.0 , B = 200.0
Operador Operación Ejemplo Resultado

+ Adición Z=X+Y Z=50
- Sustracción Z=Y-X Z=10
* Multiplicación Z=X*Y Z=600
/ División Z=Y/X Z=1.5
% Módulo Z=Y%X Z=10
++ Incremento X++ X=21
-- Decremento X- X=19
Tabla 2.2.- Operadores aritméticos.
2.6.2.- Operadores relacionales
Los operadores relacionales se usan para comparar los valores que resultan de reducir
expresiones. Los resultados coincidirán con los valores de verdad:
FALSO igual a CERO, VERDADERO diferente de CERO. Los operadores relacionales

en C++ son :
> Mayor que
18
>= Mayor ó igual que
<= Menor ó igual que

= Igual que
!= Diferente que ( No igual que )
2.6.3.- Operadores lógicos
Los operadores lógicos se aplican sobre los enunciados que resultan de las operaciones
relacionales, y el resultado siempre será un valor de verdad. Los operadores lógicos son:
&& Y ( Conjunción )
|| O ( Disyunción )
! NO ( Negación )
2.6.4.- Operadores entre bits
Con estos operadores se puede realizar la comprobación, colocación ó desplazamiento

de los bits actuales de una variable de los tipos int y char.
Los operadores entre bits son:
& Y ( Conjunción )
| O ( Disyunción )
^ O ( Disyunción Exclusiva ó XOR )
~ ( Complemento a uno ó NOT )
>> ( Desplazamiento a la DERECHA )
<< ( Desplazamiento a la IZQUIERDA )
A continuación se presentan ejemplos de algunas operaciones entre bits:
Ejemplo 2.6.1:
Supongamos que se quiere cambiar el bit de paridad ( el de la extrema izquierda ) de

uno a cero. Para esto puede utilizarse la operación de conjunción entre bits.
Si tenemos la declaración:
char indice = 81 ;
y, suponiendo que se quiere cambiar el bit de paridad de 1 a 0 , la instrucción en C++ se

escribiría :
indice & 127 ;
19
La operación realizada a mano es :
11010001 <------ indice

operador> &
01111111 <------ 127 en binario
01010001 <------ resultado
En este caso se utilizó el número 127 porque es el único número entero que puede
escribirse en un octeto ( byte ) y que tiene los siete primeros bits con valor 1 .
Ejemplo 2.6.2
Se requiere que en el número 112 tengan valor 1 los bits que correspondan con los del
número 7 que tengan valor 1. En este caso, la operación a utilizar es la disyunción entre
bits, quedando las instrucciones en la siguiente forma:
char masc ;
masc = 112 | 7 ;
La operación manual tomaría la siguiente forma:
01110000 <------ 112 en binario
operador> |
00000111 <------ 7 en binario
01110111 <------ resultado
Ejemplo 2.6.3
La disyunción exclusiva sirve para poner a uno los bits del primer operando cuyos
correspondientes bits en el segundo operando sean distintos, como se ve a continuación:
x = 125 ^ 120 ;
char x ;
Manualmente se tendría:
01111101 <------- 125 en binario

operador> ^
01111000 <------- 120 en binario
00000101 <------- resultado
Los operadores de desplazamiento mueven todos los bits, de una variable entera ó de
carácter, hacia la izquierda ó hacia la derecha. A medida que los bits son desplazados
hacia un extremo, los lugares desocupados del estremo contrario van siendo ocupados
por ceros. Los unos que salen por los extremos no se pueden recuperar(no hay
rotación) .
2.6.5.- Operadores de asignación
20
El estudio de los operadores de asignación requiere del conocimiento de los conceptos
de valor izquierdo ( lvalue ) y de valor derecho ( rvalue ). Un valor izquierdo es una
expresión que designa un objeto. Las expresiones utilizadas como valor izquierdo
corresponden a objetos cuyos valores pueden cambiar durante la ejecución de un
programa. Generalmente, en la expresión correspondiente a un valor izquierdo aparece
el identificador de una variable. Cuando el valor izquierdo se refiere a la dirección de
una variable, la expresión puede constar de una combinación de varios identificadores.
Un valor derecho es una expresión formada por cualquier combinación de objetos y

operadores que pueda ser reducida a un valor. Los operadores de asignación sirven para
asignar un valor derecho a un valor izquierdo, y están formados por la combinación del
operador de asignación simple = con otro operador, como se muestra en la tabla 2.3 .
Operador Significado Ejemplo: Equivale a:

= Asignación múltiple .
+= Suma asigna X+=Y X=X+Y
-= Resta asigna X-=Y X=X-Y
*= Multiplicación asigna X*=Y X=X*Y
/= Divide asigna X/=Y X=X/Y
%= Residuo asigna X%=Y X=X%Y
<<= Dezplaz. izq. asigna X<<Y X=X<<Y
>>= Dezplaz. der. asigna X>>Y X=X>>Y
&= Conj. e/bits asigna X&=Y X=X&Y
^= Disy. exclu. asigna X^=Y X=X^Y
|= Disyunción asigna X|=Y X=X|Y
Tabla 2.3.- Operadores de asignación.
Los operadores estudiados hasta aquí no son todos los que existen en el C++, sino los
que a mi juicio son indispensables para iniciar el estudio del lenguaje. Si,
posteriormente, es necesario utilizar algún operador no tratado en esta unidad, en ese
momento se estudiarán las características particulares de tal operador.
3.- Instrucciones de control

En esta unidad estudiaremos las instrucciones que sirven para controlar el flujo de
ejecución de un programa en C++ . De acuerdo a las características de cada una, las
clasificaremos en grupos de estructuras básicas de:
Las estructuras básicas deben cumplir con la condición básica de la Programación

Estructurada de: sólo una entrada, sólo una salida.
3.1.- Secuencia
21
A este grupo pertenecen las instrucciones que están formadas por una o varias
expresiones simples colocadas una a continuación de la otra. La sintaxis para las
instrucciones estructuradas en secuencia es la siguiente:
instruccion_1 ;
instruccion_2 ;
.........
instruccion_N ;
Su diagrama de flujo se presenta en la figura 3.1.
Ejercicios
1. Elabore un programa que permita determinar la distancia (m) que recorre un móvil
que se desplaza con una velocidad (m/s) constante, después de transcurrir un
determinado tiempo (s)
#include <stdio.h>
#include <conio.h>
int main()
{
int V;
int T;
int D;
printf("\n INGRESE ");
printf("\n ");
printf("\n Velocidad (m/s) : "); scanf("%i",&V);;
printf("\n Tiempo (s) : "); scanf("%i",&T);;
D= V*T;
printf("\n RESULTADO ");

printf("\n ");
printf("\n Distancia recorrida en metros es: %2.i ", D);
getch();
return 0;
}
22
2. Dado dos números diferentes, determinar y mostrar la suma, resta y
multiplicación de estos numeros.
3. Elabore programa que permita determinar la velocidad final (m/s) de un
auto que realiza un MRUV, conociendo la velocidad inicial (m/s), el
tiempo que transcurre (s) y la aceleración (m/s²)
Datos de prueba: Vi = 40 m/s; T = 12 s A = 5 m/s²
Vf = Vi + A*T
Vf: velocidad final Vi: velocidad inicial
A: aceleración T: tiempo
4. Elabore un programa que permita determinar el promedio que ha
obtenido un alumno en un determinado curso, conociendo las notas de:
tres prácticas, el examen parcial y el examen final.
Datos de prueba: P1 = 15; P2 = 17; P3 = 16; EP = 14; EF = 15
PP = ( P1 + P2 +P3 ) / 3
PROM = ( PP + 2*EP + 3*EF ) / 6
PP: promedio de práctica PROM: promedio
EP: examen parcial EF: examen final
5. Elabore un programa que permita determinar el trabajo (joule) que
realiza un motor, conociendo la potencia (watt o vatios) que realiza en
un determinado tiempo (segundo).
Datos de prueba: potencia = 300 w ; tiempo = 5 s
6. Elabore un programa que permita determinar el área (cm²) de un
triángulo, conociendo su base (cm) y su altura (cm).
Datos de prueba: base = 6 cm; altura = 8 cm
7. Elabore un algoritmo/programa que permita determinar la hipotenusa
(cm) de un triángulo rectángulo, conociendo sus catetos (cm)
Datos de prueba: cateto1 = 4 cm; cateto2 = 3 cm
8. Elabore un algoritmo/programa que permita convertir la velocidad de un
auto que esta en km/h a m/s
Dato de prueba: velocidad = 9 km/h
9. Elabore un algoritmo/programa que permita determinar el área (cm²) de
un triángulo equilátero, conociendo su lado (cm).
Dato de prueba: lado = 8 cm
10.Elabore un algoritmo/programa que permita determinar el área (cm²) de
un circulo, conociendo su radio (cm).
Dato de prueba: radio = 2 cm; π = 3.1415
11.Elabore un programa que acepte los siguientes datos de un trabajador:
código, nombre, horas normales de trabajo, pago por hora normal, horas
extras (el pago por hora extra es el 50% más del pago por hora normal),
seguidamente se debe mostrar: importe por horas normales, importe por
horas extras y el importe total.
3.2.-Selección
A este grupo pertenecen aquellas instrucciones que sirven para que la ejecución del
programa tome una de varias opciones existentes en una ramificación.
En C++ se tienen las siguientes instruccións de selección:
3.2.1.- La instrucción if - else
23
Esta instrucción permite elegir entre dos opciones de ejecución, y su sintaxis es :
if( condición )
[bloque_1]
[else]
[bloque_2]
donde:
bloque_1 y bloque_2 pueden estar formados por uno ó
más instrucciones.
else es opcional, y en caso de no existir, bloque_2

tampoco existirá.
Al ejecutarse esta estructura, primero se evalúa la condición. En caso de que, de esta

evaluación, resulte un valor de verdad verdadero, se ejecutarán las instrucciones que
forman el bloque_1; en caso contrario (si el valor de verdad es falso), se ejecutarán las
instrucciones del bloque_2.
El diagrama de flujo para la estructura if-else se presenta en la figura 3.2.
Esta estructura puede anidarse para elgir entre un grupo de más de dos opciones,
tomando la siguiente forma:
if(condición_1)
bloque_1;
else if(condición_2)
bloque_2;
else if(condición_3)
bloque_3;
............
else
bloque_N;
A continuación se muestran algunos ejemplos de aplicación de la instrucción if-else
int main()
24
{
long ncontrol;
cout << "NUMERO DE CONTROL: "; cin>> ncontrol;

if(ncontrol<=0)
cout << "NUMERO INVALIDO.........";
else cout << "CORRECTO !!" << "\n\n\n";
system("PAUSE");
return 0;
}
Listado 3.1.- Uso de if-else
#include <conio.h>
int main()
{
int calif;
clrscr();
cout << "CALIFICACION: "; cin>> calif;
if(calif > 100)
cout << "ERROR: CALIFICACION DEMASIADO ALTA .....";
else if(calif < 0)
cout << "ERROR: CALIFICACION DEMASIADO BAJA .....";
else if( (calif>= 70) && (calif <=100))
cout << "CALIFICACION APROBATORIA.";
else cout << "CALIFICACION REPROBATORIA.";
getch();
return 0;
}
Listado 3.2.- Uso de if-else-if
Ejercicios (uso de if)
1. Elabore un programa que permita determinar la velocidad (m/s)

constante de un móvil que se ha desplazado una determinada distancia
(m), en un tiempo cierto tiempo (s). Se debe considerar que el valor del
tiempo debe ser mayor de cero
Datos de prueba: Distancia = 146m; Tiempo = 5s
25
#include <stdio.h>
#include <conio.h>
int main()
{
float V;
int T;
int D;
printf("\n ");
printf("\n Distancia (m) : "); scanf("%i",&D);;
printf("\n Tiempo (s) : "); scanf("%i",&T);;
if (T > 0)
V= static_cast<float>(D) / static_cast<float>(T);
printf("\n RESULTADO ");
printf("\n ");
printf("\n La velocidad en m/s es: %5.2f ", V);
getch();
return 0;
}
2. Elabore un programa que permita determinar el tiempo (s) que
transcurrirá hasta que dos autos se encuentren, considerando que estos
autos separados una distancia (m) van uno al encuentro del otro con
velocidad constante (m/s)
Datos de prueba: distancia = 130 m T= D / (V1 +
auto1: velocidad = 5 m/s V2)
auto2: velocidad = 8 m/s
3. Elabore un programa que permita determinar el tiempo (s) que

transcurrirá hasta que un auto alcanza al otro, se sabe que estos autos
separados una distancia (m) van en igual dirección con velocidad
constante (m/s). Considere la velocidad del primero auto mayor.
Datos de prueba: distancia = 120 m
auto1: velocidad = 9 m/s T= D / (V1 -
auto2: velocidad = 6 m/s V2)
4. Elabore un programa que permita determinar la aceleración (m/s²) de un
bloque que se encuentra en reposo, conociendo su masa (kg) y la fuerza
(Newton) horizontal que se le aplica. Se debe considerar que el valor de
la masa sea mayor de cero
Datos de prueba: Fuerza = 54 N; Masa = 6 kg
5. Elabore un programa que permita determinar la potencia (watt o vatios)
que realiza un motor, conociendo el trabajo (joule) que realiza en un
determinado tiempo (segundo). El valor del tiempo debe ser positivo y
diferente de cero
Datos de prueba: trabajo = 1000 j ; tiempo = 5 s
6. Elabore un programa que permita determinar si un número ingresado es
un número entero.
Dato de prueba: número = 57
7. Elabore un programa que permita determinar si un número entero
positivo es número par.
26
Dato de prueba: numero = 38
8. Elabore un programa que permita expresar una cantidad dada en
segundos a horas, minutos y segundos. La cantidad debe ser entera y
mayor a cero
Dato de prueba: Cantidad = 8000 s
Ejercicios (uso de if – else / if – else - if)
1. Elabore un programa que permita determinar la velocidad (m/s)

constante de un móvil que se ha desplazado una determinada distancia
(m), en un tiempo cierto tiempo (s). Se debe considerar que los valores
ingresados sean positivos y mayores de cero
Datos de prueba: Distancia = 146 m; Tiempo = 5 s
#include <stdlib.h>
int main()
{
int D;
int T;
float V;
cout<<"\n INGRESE ";
cout<<"\n ";
cout<<"\n Distancia (m) : ";cin>>D;
cout<<"\n Tiempo (s) : ";cin>>T;
if (T > 0 & D > 0)
{
V= static_cast<float>(D) / static_cast<float>(T);
cout<<"\n RESULTADO ";
cout<<"\n ";
cout<<"\n La Velocidad en m/s es : "<<V;
cout<<"\n ";
}
else
cout<<"\n Ingrese valores positivos y mayores a cero";
system("PAUSE");
return 0;
}
2. Elabore un programa que permita aceptar dos números diferentes,

seguidamente se debe determinar y mostrar el mayor de los números.
3. Elabore un programa que permita aceptar un número entero de dos
cifras, de tal manera que si sus cifras son pares se debe mostrar la suma
de estas cifras, pero si las cifras son impares se debe mostrar el
producto de estas cifras.
4. Elabore un programa que permita aceptar un número entero,
seguidamente se debe determinar y mostrar si el número es múltiplo de
siete.
5. Elabore un programa que permita aceptar un número entero menor a
31524, seguidamente se debe determinar y mostrar cuantas cifras tiene
dicho número.
27
6. Elabore un programa que permita aceptar un número entero de dos
cifras, seguidamente se debe mostrar el número ingresado pero con sus
cifras intercambiadas. Ej. Si el número ingresado es 38 se debe mostrar
83.
7. Elabore un programa que permita aceptar los siguientes datos de un

trabajador: código, nombre, sueldo básico, año de ingreso a la empresa y
número de hijos.
Si los años de servicio es mayor a 8 años se le da una bonificación de 10
soles por cada año, en caso contrario se le da 4 soles por cada año de
servicio. Si el numero de hijos es menor a 4 se le da 8 soles por cada
hijo, en caso contrario se le da sólo 20 soles. El sueldo bruto es la suma
del sueldo básico, la bonificación por años de servicio y la bonificación
por los hijos. Si el sueldo bruto es mayor a 1500 soles se le hace un
descuento del 1.5% del sueldo bruto, en caso contrario el descuento es
el 0.5% del sueldo bruto. El sueldo neto es igual al sueldo bruto menos el
descuento.
Se pide realizar los cálculos necesarios para mostrar las bonificaciones,
el sueldo bruto, el descuento y el sueldo neto.
8. Elabore un programa que permita aceptar un número entero,
seguidamente se debe determinar y mostrar si el número ingresado es
positivo, cero o negativo.
9. Elabore un programa que permita aceptar tres números diferentes,
seguidamente se debe determinar y mostrar el mayor y menor de los
números.
10.Elabore un algoritmo/programa que permita determinar las raíces reales
de una ecuación de segundo grado (Ax² + Bx + C).
Dato de prueba: x² + 5x + 6
Para determinar las raíces puede utilizar
− B + B2 − 4AC − B − B2 − 4AC
2A 2A
3.2.2.- La instrucción switch
Esta instrucción es útil cuando se tiene que elegir entre más de dos opciones, como es el
caso de manejo de menús. Esta instrucción es preferible que el uso de anidamientos de
varios if-else.
28
Su sintaxis es:
switch(expresión_entera)
{
case Const_1 : Bloque_1 ; break ;
case Const_2 : Bloque_2 ; break ;
.............................
.............................
.............................
case Const_N : Bloque_N ; break ;
default : Bloque_X ;
}
A la entrada en una instrucción switch, primero se evalúa la expresión_entera. En caso

de que el resultado coincida con Const_1, se ejecuta el Bloque_1 y break interrumpe la
ejecución del instrucción; en caso de que coincida con el valor de Const_2, se ejecuta el
Bloque_2 , se interrumpe la ejecución de la instrucción. Lo mismo pasa en caso de que
el resultado coincida con cualquiera de los otros valores constantes. En caso de existir
default:, y si el resultado no coincide con ninguno de los valores constantes, se ejecutan
las instrucciones contenidas en el Bloque_X.
Esta estructura puede representarse con el diagrama mostrado en la figura 3.3.
Es recomendable el uso de la instrucción switch en el caso del manejo de un menú de

opciones como se observa en el listado 3.3.
#include <conio.h>
void main()
{
char opcion;
clrscr();
gotoxy(30,5);
29
cout << "MENU DE OPCIONES"; gotoxy(30,8);
cout << "1.- CREACION"; gotoxy(30,10);
cout << "2.- MODIFICACION"; gotoxy(30,12);
cout << "3.- ELIMINACION"; gotoxy(30,14);
cout << "0.- SALIDA"; gotoxy(30,18);
cout << "SU OPCION ? "; opcion= getche();
cout << "\n\n";
switch(opcion)
{
case '1': clrscr(); cout << "RUTINA DE CREACION \n"; break;
case '2': clrscr(); cout << "RUTINA DE MODIFICACION \n"; break;
case '3': clrscr(); cout << "RUTINA DE ELIMINACION \n"; break;
case '0': clrscr(); cout << "SALIDA DE LA APLICACIÓN \n";break;
default: clrscr(); cout << "OPCION INVALIDA.....\n";
}
}
Listado 3.3.- Uso de switch
Ejercicios
1. Elabore un algoritmo/programa que acepte un número entero y positivo

desde 1 hasta 7 y permita determinar que día de la semana le
corresponde
Dato de prueba: Número = 3
#include<stdio.h>
#include<conio.h>
int main()
{
int N;
printf("\n ");
printf("\n Numero desde 1 hasta 7 : ");scanf("%i",&N);
switch (N)
{
case 1:
printf("\n Lunes ");
break;
case 2:
printf("\n Martes ");
break;
case 3:
printf("\n Miercoles ");
break;
case 4:
printf("\n Jueves ");
break;
30
case 5:
printf("\n Viernes ");
break;
case 6:
printf("\n Sabado ");
break;
case 7:
printf("\n Domingo ");
break;
default:
printf("\n No existe el dia ");
}
getch();
return 0;
}
2. Elabore un programa que acepte un número entero desde 1 hasta 12

(representa un mes del año) y permita determinar a que estación del
año pertenecen
3. Elabore un programa que permita ingresar dos números enteros y un
operador aritmético (+, -, /, *), seguidamente se debe determinar el
resultado de la operación que indica el operador.
Datos de prueba: A = 10 ; B = 5 ; OP = *
A: es el primer número; B: es el segundo número; OP: es el operador
4. Elabore un programa que permita aceptar el sueldo básico de un
trabajador así como su categoría (A, B, C). Se pide determinar cuanto se
le debe pagar si se sabe que si la categoría es “A” se le descuenta el 3%
de su sueldo básico; si es “B” se le bonifica con el 1% de su sueldo
básico y si es “C” se le bonifica con el 2% de su sueldo básico.
Datos de prueba: SB = 1000 soles; CAT = B
5. Elabore un programa que acepte un número entero hasta tres cifras,
seguidamente se debe determinar cuales de sus cifras tienen raíz
cuadrada exacta
3.3.- Iteración
Las estructuras de iteración se utilizan en la ejecución repetida de un bloque de

instrucciones. En el Lenguaje C++, se tienen: Para el manejo de las estructuras de
iteración.
3.3.1.- La instrucción while
Con esta instrucción se maneja una estructura en la que, de entrada, se evalúa una
condición. En caso de que el resultado de tal evaluación sea un valor diferente de cero ,
se ejecuta un bloque de instrucciones, en el cual debe existir una instrucción que
modifique la condición, ya que de lo contrario ejecutará un ciclo infinito ( loop ). Si el
resultado de la evaluación es un valor igual a cero, el bloque de instrucciones no se
ejecuta y finaliza la ejecución de la instrucción.
31
La sintaxis de la instrucción while es la siguiente:
while(condición)
bloque;
En la figura 3.4 se presenta el diagrama de la instrucción while.
El listado 3.4 muestra el uso de la instrucción while.
#include <conio.h>
#define FALSO 0
int main()
{
int valor=1;
clrscr();
while(valor!=FALSO)
{
cout<<"\n Teclee un valor entero ( 0 para salir ): "; cin>>valor;
}
return 0;
}
Listado 3.4.- Uso de la instrucción while
Ejercicios
1. Elabore un programa que permita sumar todos los números naturales

menores a un número ingresado.
#include<stdio.h>
#include<conio.h>
int main()
{
int N;
int I, S;
32
printf("\n ");
printf("\n Numero limite para la suma: "); scanf("%i",&N);
I = 1;
S = 0;
while ( I < N)
{
S = S + I; // hacemos uso de un acumulador
I = I +1;
}
printf("\n La Suma es: %i",S);
printf("\n ");
getch();
return 0;
}
menores a un número ingresado. Los números sumados deben ser pares
3. Elabore un algoritmo/programa que permita contar todos los números
naturales menores a un número ingresado. Los números contados deben
ser pares
naturales que se encuentran en un rango de números (incluyendo estos
numeros). Los números contados deben ser pares
Dato de prueba: Rango de Números = 13 a 45, es decir debe ingresar
dos números (13 y 45).
5. Elabore un programa que permita multiplicar y sumar todos los números
naturales menores a un número ingresado. Los números considerados
deben ser multipos de tres.
6. Elabore un programa que permita sumar y multiplicar todas las cifras de
un numero entero ingresados
7. Elabore un programa que permita sumar todas las cifras impares de un
numero entero ingresados
8. Elabore un programa que permita sumar todas las cifras de posición
impar y todas las cifras de posición par (por separado), seguidamente se
debe mostrar la diferencia de estos resultados
9. Elabore un algoritmo/programa que permita aceptar un número entero
en el sistema decimal y expresarlo en el sistema de numeración, cuya
base debe ser ingresada y mayor a uno pero menor a diez
3.3.2.- La instrucción do - while
La instrucción do-while tiene un comportamiento similar a while, sólo que en este caso
primero se ejecuta el bloque de instrucciones y después se evalúa la condición. Con esto
se asegura que el bloque se ejecutará al menos una vez.
33
Esta es la sintaxis de la instrucción do-while :
do
bloque;
while(condición);
La instrucción do-while puede representarse con el diagrama mostrado en la figura 3.5.
Como una aplicación de la instrucción do-while , se presenta en el listado 3.5 una

variante al problema resuelto en el listado 3.3 .
#include <conio.h>
void main()
{
char opcion;
do
{ // inicia ciclo 1
clrscr();
gotoxy(30,5);
cout << "MENU DE OPCIONES";
gotoxy(30,8); cout << "1.- CREACION";
gotoxy(30,10); cout << "2.- MODIFICACION";
gotoxy(30,12); cout << "3.- ELIMINACION";
gotoxy(30,14); cout << "0.- SALIDA";
gotoxy(30,18); cout << "SU OPCION ? ";
window(42,18,42,18);
do
{ // inicia ciclo 2 clrscr();
opcion="getche();"
}while((opcion < '0')||(opcion>'3'));// fin ciclo 2
window(1,1,80,25);
switch(opcion)
{
case '1': clrscr();
cout << "RUTINA DE CREACION\n";
break;
case '2': clrscr(); cout << "RUTINA DE MODIFICACION\n";
34
break;
case '3': clrscr(); cout << "RUTINA DE ELIMINACION\n";
break;
case '0': clrscr(); cout << "SALIDA DE LA APLICACIÓN \n";
break;
}
cout << "\n\nPULSE CUALQUIER TECLA PARA CONTINUAR.."; getch();
}while(opcion!="0" ); // fin ciclo 1 }
Listado 3.5.- Aplicación de la instrucción do-while
Ejercicios

hasta un número ingresado.
#include <stdlib.h>
int main()
{
int N;
int I, S;
cout<<"\n ";
cout<<"\n Numero limite para la suma : ";cin>>N;
S = 0;
I = 1;
do
{
S = S + I;
I = I + 1;
}
while ( I <= N);
cout<<"\n La Suma es: "<<S;
cout<<"\n ";
system("PAUSE");
return 0;
}
2. Elabore un algoritmo/programa que permita elegir que desea determinar
el usuario con respecto a la formula V=D/T
V : Velocidad D : Distancia T: Tiempo
#include <stdlib.h>
int main()
{
float V, D, T;
int OP;
int Resp;
do
{
cout<<"\n Que desea determinar en V = D / T ";
cout<<"\n 1. Velocidad ";
cout<<"\n 2. Distancia ";
cout<<"\n 3. Tiempo ";
cout<<"\n Opcion "; cin>>OP;
switch (OP)
35
{
case 1:
cout<<"\n Ingrese ";
cout<<"\n Distancia (m) "; cin>>D;
cout<<"\n Tiempo (s) < > de cero "; cin>>T;
V = D / T;
cout<<"\n La velocidad en (m/s) es: "<<V;
break;
case 2:
cout<<"\n Velocidad (m/s) "; cin>>V;
cout<<"\n Tiempo en segundos "; cin>>T;
D = V* T;
cout<<"\n La distancia en metros es: "<<D;
break;
case 3:
cout<<"\n Velocidad (m/s) < > de cero ";cin>>V;
cout<<"\n Distancia en metros "; cin>>D;
T = D / V;
cout<<"\n El Tiempo en segundos es: "<<T;
break;
default:
cout<<"\n Opcion Incorrecto ";
}
cout<<"\n Desea Continuar SI = 9 / NO = 0? ";cin>>Resp;
} while ( Resp == 9);
cout<<"\n ";
system("PAUSE");
return 0;
}
3. Elabore un programa que permita sumar y contar todos los números

naturales hasta un número ingresado. Los números sumados deben ser
múltiplos de cinco
Dato de prueba: Número ingresado = 80
4. Elabore un programa que permita determinar, utilizando un menú de
opciones, el área de un cuadrado, un trinagulo, un círculo y un trapecio.
5. Elabore un algoritmo/programa que permita elegir que desea determinar
el usuario con respecto a la formula T= D / (V1 - V2)
6. Elaborar un programa que acepte un número entero, seguidamente se
debe determinar el factorial de la mayor cifra (valor absoluto) que tiene
el número ingresado.
7. Elaborar un programa que acepte un número entero, seguidamente se
debe determinar si el numero ingresado es numero perfecto
8. Elaborar un programa que determine y muestre todos los números
perfecto menores a 100.
36
3.3.3.- La instrucción for
Entre las instrucciones de iteración, for es la más versátil, ya que, entre otras
características, permite la declaración de variables dentro de su estructura.
La sintaxis de la instrucción for es la siguiente:
for(inicialización ; condición ; control)

bloque;
donde:
inicialización es un bloque de instrucciones que puede
incluir la declaración de las variables
involucradas y la asignación de valores
iniciales.
condición es una instrucción que puede evaluarse de

tal forma que se obtenga como resultado un
valor de verdad ( falso ó verdadero ).
Mientras, se cumpla la condición, se ejecu-
tará el bloque de instrucciones.
control es un bloque de instrucciones separadas por

comas y que controlan la variación de los
valores de las variables utilizadas.
Los bloques de inicialización, condición y control no son obligatorios, pero sí lo son los
tres punto y coma que los separan; de tal suerte que la forma mínima de una instrucción
for quedaría así:
for(;;) // ciclo infinito

; // no realiza tarea alguna
El diagrama para la instrucción for se muestra en la figura 3.6.
El listado 3.6 muestra el uso de la instrucción for.
37
#include <conio.h>
int main()
{
clrscr();
for(int x=1 ; x <= 25 ; x++)
{ for(int y=1 ; y <=80 ; y++)
{ gotoxy(y,x);
if((x==25) && (y==80))
getch();
cout << '.';
}
}
return 0;
}
Listado 3.6.- Utilización de la instrucción for
Ejercicios
1. Elabore un algoritmo/programa que permita sumar todos los números

naturales hasta un número ingresado.
#include<stdio.h>
#include<conio.h>
int main()
{
int N;
int I, S;
printf("\n ");
printf("\n Numero limite para la suma : ");scanf("%i",&N);
S = 0;
for ( I = 1; I <= N; I++)
S = S + I; // hacemos uso de un acumulador
printf("\n La Suma es: %i",S);
printf("\n ");
getch();
return 0;
}
2. Elabore un algoritmo/programa que permita sumar todos los números
naturales hasta un número ingresado. Los números sumados deben ser
pares
naturales que se encuentran en un rango de números, incluyendo el
rango. Los números contados deben ser múltiplos de cinco.
Dato de prueba: Rango de Números = 13 a 45, es decir debe ingresar
dos números (13 y 45)
4. Elabore un algoritmo/programa que permita aceptar un número entero
mayor a la unidad y determinar si es primo absoluto o no.
5. Elabore un algoritmo/programa que permita generar la serie de
Fibonacci, con una cantidad de términos igual a un número entero
ingresado
38
BREAK Y CONTINUE
Los enunciados break y continue son utilizados para modificar el flujo de

control dentro de un programa.
El break utilizado dentro de las estructuras de controlcausa la inmediata

salida de dicha estructura (por lo tanto no sigue repitiéndose el bloque y
continúa la ejecución de las instrucciones que le siguen a la estructura de
control).
Veamos un ejemplo del uso de break:
int num;
num = 1;
while (num <= 10)
{
if (num == 5)
{
break;
};
printf(“%d - ”, num);
num = num + 1;
};
El código anterior imprime:

1–2–3–4–
Lo que sucede es que cuando la variable num toma el valor 5, la condición

del while se cumple, al ingresar al bloque se evalúa en la estructura if si
num es igual a 5 y se ejecuta el break saliendo del bloque while. Num
termina valiendo 5 pues jamás se ejecuta la suma num = num + 1.
Por otra parte, el enunciado continue, dentro de las estructuras de

repetición, al ser ejecutado salta las instrucciones que siguen en el bloque y
ejecuta la siguiente repetición en el ciclo. Veamos un ejemplo para aclarar
el funcionamiento de continue:
int num;
num = 0;
while (num <= 7)
{
num = num + 1;
if (num == 5) {
continue;
};
39
printf(“%d - ”, num);
};
El código anterior imprime en pantalla:
1–2–3–4–6–7
Como vemos, en una de las repeticiones se saltea la impresión del número

5.
Algunos programadores dicen que el uso del break y del continue dentro
de las estructuras de control (excepto el break en la estructura switch)
viola las normas de la programación estructurada. Lo cierto es que no es
necesario el uso de break y continue si se utilizan las estructuras
correctas
4.- Diseño de funciones

Las funciones son el módulo básico para la construcción de programas en C++.
Además de la función main(), con frecuencia es necesario utilizar funciones adicionales

que pueden ser accesadas a través del enlace de librerías precompiladas ó a través de su
definición en el archivo de código fuente ó en archivos de cabecera.
En esta unidad estudiaremos los procedimientos necesarios para el manejo de las

funciones definidas en el código fuente.
En principio, debemos distinguir entre: declarar, definir e invocar una función, ya que la
confusión de éstos términos es causa de frecuentes problemas.
Desde los orígenes del Lenguaje C ha existido la distinción entre definir y declarar una
función. Cuando se define una función se le está reservando espacio de almacenamiento
en memoria; en cambio cuando se declara solo se está avisando que más adelante se
encuentra una función con ciertas características, pero no se le reserva espacio en
memoria.
4.1.- Definición de funciones
La definición de una función implica reservarle espacio de almacenamiento en

memoria, de acuerdo al tipo de dato a retornar.
Es en la definición donde se incluye el cuerpo de la función.
El formato general de la definición de una función es el siguiente:
tipo identificador( argumentos )

{
bloque;
}
40
donde:
tipo es el tipo de dato que va a retornar la función, e identificador es el nombre de la

función.
La existencia de argumentos dependerá de la tarea que va a realizar la función, pero el

par de paréntesis es requisito indispensable.
En el ejemplo 4.1. se presenta una aplicación de la definición, la declaración y la

invocacion de funciones.
4.2.- Declaración de funciones
Cuando se declara una función, se está avisando al compilador que más adelante
encontrará la definicion de tal función, y que por el momento, tome nota de las
características de ella, como son: el tipo de dato que retorna, su nombre y los tipos de
argumentos que va a recibir. Con esto, no habrá ningún problema en invocar a la
función en un bloque de programa ubicado antes del lugar donde se encuentra escrita su
definición.
En el ejemplo 4.1, las líneas:
void saludo();
float calcula(float);
representan la declaración de las funciones ó la declaración de los prototipos de las

funciones saludo() y calcula().
En la declaración de la función saludo() se especifica que no va a retornar valor alguno,

y que no recibirá argumentos.
En la declaración de la función calcula() se especifica que va a retornar un valor de tipo

float, y que va recibir un argumento de tipo float.
Es importante observar que la declaración de una función es parecida a la línea de

encabezado de su definición , sólo que en el caso de la declaración se escribe un punto y
coma al final.
También cabe hacer notar que en la declaración no se requiere escribir identificadores

para los argumentos, como se observa en el ejemplo 4.1, sino que basta con incluir los
tipos de datos de los argumentos. Se pueden incluir identificadores de argumentos, sólo
que el ámbito de tales identificadores estará restringido a la declaración de la función
correspondiente.
Por lo tanto, la declaración:
float calcula(float); podría haberse escrito así :
float calcula(float arg);
En este caso, el identificador arg no tiene uso alguno; por lo que es innecesaria su
inclusión.
41
Si el número de argumentos, o los tipos correspondientes no coinciden entre la
declaración y la línea de encabezado de la definición de la función el compilador
marcará un error.
4.3.- Invocación a funciones
Una invocación ó llamada a una función implica pasarle el control de la ejecución del
programa, así como los argumentos ó parámetros que requiere para realizar su tarea. En
el listado 4.1 se tienen las líneas:
saludo(); //INVOCACION A LA FUNCION saludo()

precio = calcula(costo); //INVOCACION A LA FUNCION calcula()
En la primera, se invoca a la función saludo() y no se le pasa ningún argumento. En la

segunda, se invoca a la función calcula(), pasándosele como argumento una copia del
valor que tiene la variable costo. El valor retornado por calcula() se asigna a la variable
precio.
// ENCABEZADOS
#include <conio.h>
// DECLARACION DE FUNCIONES
void saludo();
float calcula(float);
// DEFINICION DE LA FUNCION PRINCIPAL
void main()
{
float costo, precio;
clrscr();
cout << "COSTO : $ "; cin>> costo;
cout << "PRECIO : $ " << precio;
}
// DEFINICION DE LA FUNCION saludo()
void saludo()
{ clrscr();
cout << "!! BIENVENIDO A LA VENTA ESPECIAL !!";
}
// DEFINICION DE LA FUNCION calcula()
float calcula(float x)
{
return( x * 1.6);
}
Listado 4.1.- Diseño de funciones usando prototipo.
4.4.- El prototipo de una función ¿es obligatorio?
Cuando encuentra la primera invocación a una función, el compilador verifica si ya se

realizó la declaración ó la definición de la función invocada. En caso de no existir ni
declaración ni definición previa, enviará un mensaje de error diciendo que la función
invocada debe tener un prototipo. En ese momento se detiene la compilación y no se
genera el archivo .OBJ correspondiente.
42
Lo anterior puede sugerir que el prototipo de la función invocada es indispensable. La
realidad es que se puede omitir el prototipo si escribimos la definición de la función
antes de su primera invocación, como se muestra en el ejemplo 4.2.
// ENCABEZADOS
#include <conio.h>
// DEFINICION DE LA FUNCION saludo()
void saludo()
{
clrscr();
cout << "!! BIENVENIDO A LA VENTA ESPECIAL !!";
}
// DEFINICION DE LA FUNCION calcula()
float calcula(float x)
{
return( x * 1.6);
}
// DEFINICION DE LA FUNCION PRINCIPAL
int main()
{ float costo, precio;
clrscr();
cout << "COSTO : $ "; cin>> costo;
cout << "PRECIO : $ " << precio;
return 0;
}
Listado 4.2.- Diseño de funciones sin uso de prototipos.
Aunque el prototipo no es obligatorio, es recomendable utilizarlo, ya que de esta manera

se permite al compilador verificar que el número y tipos de argumentos utilizados en la
invocación (parámetros actuales) coinciden con los de la definición (parámetros
formales).
La declaración de prototipos también sirve para que el usuario de un programa conozca

la forma de utilización de la función, sin tener que proporcionarle el código fuente.
Por ejemplo, si tenemos un programa que maneja operaciones matemáticas podemos
distribuir a los usuarios el código objeto que contenga las definiciones de las funciones
y un archivo de cabecera que contenga los prototipos.
4.5.- Sobrecarga de funciones
En la mayoría de los casos, los identificadores ó nombres de los objetos deben ser
únicos, esto es, que dos objetos dentro del mismo ámbito no deben tener el mismo
nombre. Una de las excepciones la constituyen las funciones, que pueden compartir el
mismo nombre entre varias de ellas, dando la impresión de que a una sola función se le
ha "sobrecargado de tareas", razón por la cual se les llama funciones sobrecargadas.
Por ejemplo, supongamos que deseamos una función que sirva para sumar números. Lo
ideal sería contar con una sola función que realizara la suma de números de diferentes
tipos y que retornara un valor de acuerdo al tipo de resultado. El Lenguaje C++ permite
resolver este problema por medio de la sobrecarga de funciones.
43
A continuación se muestran los prototipos para cada una de las funciones que
comparten el nombre suma :
int suma(int,int); // Recibe enteros, devuelve entero
float suma(float,float);
double suma(double,double);
Aquí surge la pregunta: ¿ cómo distingue el compilador entre cada una de las funciones
suma()?.
Debido a que varias funciones sobrecargadas pueden usar el mismo identificador, C++
utiliza el concepto de nombres ampliados para controlar cada función individualmente.
El nombre ampliado de una función se construye tomando como base el nombre de la
función y los tipos de los argumentos. El tipo de retorno de la función no se utiliza en la
formación del nombre ampliado. La composición del nombre ampliado ocurre a nivel
del compilador, no al nivel del enlazador. El enlazador resuelve fácilmente las
referencias externas para sobrecargar las funciones debido a que éstas tienen nombres
ampliados únicos.
Ejercicios
1. Elabore un programa que permita utilizar una función que determine la

suma de dos números enteros.
Dato de prueba: Primer numero = 12; Segundo numero = 10
#include <stdlib.h>
//función que permite sumar dos números enteros
int suma(int a, int b)
{
int s;
s = a + b;
return s;
}
// fin de la función
int main()
{
int A, B;
int S;
cout<<"\n ";
cout<<"\n Primer numero : ";cin>>A;
cout<<"\n Segundo numero : ";cin>>B;
S= suma(A, B); //Se invoca a la funcion
cout<<"\n ";
cout<<"\n La suma es : "<<S;
cout<<"\n ";
system("PAUSE");
return 0;
}
44
2. Elabore un programa que permita utilizar una función que determine la
suma, resta, multiplicación y división de dos números enteros (utilizar
una función para cada operación).
Dato de prueba: Primer numero = 12 Segundo numero = 10
3. Elabore un programa que permita utilizar una función que determine el

área de: un triángulo (b*h/2), un cuadrado (l*l) y un circulo (3.1415*r*r),
Utilizar una función para cada área a determinar.
Dato de prueba: base = 4; altura = 6; lado = 5; radio = 3
4. Elabore un programa que permita utilizar una función para determinar el

máximo común divisor de dos números enteros.
#include <stdlib.h>
int mcd(int a , int b)
{
int r; //usaremos el r como residuo
a = (a < 0) ? -a:a; //le damos el intervalo a
b = (b < 0) ? -b:b; //le damos el intervalo b
r = (a < b) ? a:b; //le damos el intervalo desde a hasta b
while ( (a % r) || (b % r)) //Usamos el "o"
--r; //Decremento "--"
return r;
}
int main()
{
int A, B;
float D;
cout<<"\n ";
cout<<"\n Primer numero : ";cin>>A;
cout<<"\n Segundo numero : ";cin>>B;
D= mcd(A, B); //Se invoca a la funcion
cout<<"\n ";
cout<<"\n El maximo comun divisor (MCD) es: "<<D;
cout<<"\n ";
system("PAUSE");
return 0;
}
5. Elabore un programa que permita utilizar una sola función para
determinar la suma, resta y multiplicación de dos números enteros.
45
5.- Arreglos.
Los arreglos consisten de un conjunto de elementos del mismo tipo almacenados en
localidades contíguas de memoria. Los elementos de un arreglo comparten el mismo
nombre, pudiéndo distinguirse un elemento de otro a través de un subíndice.
En esta unidad, describiremos la declaración de los arreglos, el manejo de los elementos

de un arreglo dado, así como lo relacionado con los arreglos que se utilizan para formar
las cadenas de caracteres.
5.1.- Declaración de arreglos
Los elementos de los arreglos son variables de algún tipo dado, que al compartir el
mismo nombre pueden ser tratadas como una sola entidad.
La sintaxis para la declaración de un arreglo es la siguiente:
46
tipo identificador [ <expresión_constante> ] ;
donde:
tipo es el tipo de los elementos que componen el arreglo
identificador es el nombre del arreglo
expresión_constante es una expresión que al reducirse debe

dar como resultado un valor
entero positivo.
En el ejemplo 5.1 se muestra la declaración de arreglos.
DECLARACION RESULTADO
char nombre[31]; Declara un arreglo unidimensional llamado

nombre compuesto de 31 elementos de tipo
carácter.
int valor[20]; Declara un arreglo unidimensional llamado
valor, compuesto por 20 elementos de tipo
entero con signo.
unsigned long abc[x] Declara un arreglo unidimensional llamado
abc, compuesto por x elementos de tipo
entero largo sin signo. En este caso x
debe ser una constante entera.
double matriz[5][7]; Declara un arreglo bidimensional llamado
matriz, compuesto por 35 elementos de
tipo entero.
int trid[3][5][8]; Declara un arreglo tridimensional llamado
trid, compuesto por 120 elementos de tipo
entero.
Ejemplo 5.1.- Declaraciones de arreglos.

Como se observa en el ejemplo 5.1, la declaración de un arreglo multidimensional se
distingue en que se agrega una pareja de corchetes para cada dimensión, por lo que la
sintaxis, en este caso, toma la siguiente forma:
tipo identificador [ cte1 ][ cte2 ][ cte3 ] ... ;
donde: cte1, cte2, etc. representan los subíndices para cada

dimensión.
El número y tamaño de las dimensiones solo estará restringido por la disponibilidad de

memoria RAM, por lo que se puede tener una declaración como la siguiente:
double multidim [5][5][5][5][5][5] ;
El espacio de memoria ocupado por el arreglo multidim es el mismo que el ocupado

por:
double unidim [15625]
5.2.- Manejo de arreglos
47
En la sección anterior se ha tratado lo relacionado con la declaración de arreglos con
elementos de diferentes tipos y con una o varias dimensiones. En esta sección se tratará
lo relativo al acceso a los elementos individuales de un arreglo, ya sea para asignarles
valores específicos o para utilizar los valores almacenados.
5.2.1.- Asignación de valores a los elementos de un arreglo
Al declarar un arreglo dentro de una función, los valores almacenados en cada uno de
los elementos son desconocidos (se dice que el arreglo "tiene basura"), lo cual causa que
el programa correspondiente arroje resultados inesperados. Para evitar los valores
desconocidos, se recomienda asignar valores iniciales a cada uno de los elementos de
los arreglos, como se muestra a continuación:
Por ejemplo, supongamos la siguiente declaración:
int vector[5];
En este caso, se declara un arreglo de 5 variables de tipo entero agrupadas con el

nombre vector, las cuales pueden representarse con la figura 5.1.
Figura 5.1.- Representación de un arreglo

Como puede observarse en la figura 5.1, el primer subíndice tiene valor cero y el último
tiene valor cuatro.
Lo anterior se debe a que, en C++, el primer subíndice siempre vale cero y el último
tiene un valor menor en uno que el valor de la dimensión del arreglo.
Una vez declarado el arreglo, se pueden asignar valores a cada uno de sus elementos,
como se muestra enseguida:
vector[0] = 100 ;
vector[1] = 101 ;
vector[2] = 102 ;
vector[3] = 103 ;
vector[4] = 104 ;
y el arreglo vector luciría como en la figura 5.2.
48
Figura 5.2.- El arreglo vector después de asignarle valores.
En este caso particular, pudimos haber asignado los valores por medio de un estatuto for
de la siguiente forma:
for( int x = 0 ; x < 5 ; x++)

vector[x] = x + 100 ;
Esta forma es la más conveniente en caso de que la cantidad de elementos sea grande y
que los valores a asignar sean iguales o las diferencia entre elementos consecutivos sea
constante.
Todo lo escrito en este ejemplo es válido para arreglos con elementos de cualquier tipo.
Por ejemplo, si queremos desplegar en pantalla los caracteres del código ASCII lo
haríamos por medio del siguiente grupo de instrucciones:
unsigned char caracter[256];

for( int x=0 ; x < 256 ; x++ )
printf("%c", caracter[x]) ;
Ejercicios
1. Elabore un programa que permita aceptar 10 números enteros y

seguidamente se deben mostrar estos números ingresados.
Dato de prueba: 34, 56, 32, 54, 67, 21, 89, 47, 91, 13
#include <stdlib.h>
int main()
{
int NUM[10];
int I;
cout<<"\n INGRESE 10 NUMEROS ENTEROS ";
cout<<"\n ";
for ( I=1; I<=10;I++)
cin>>NUM[I];
cout<<"\n LOS NUMEROS INGRESADOS SON: ";
cout<<"\n ";
for ( I=1; I<=10;I++)
cout<<NUM[I]<<" ";
cout<<"\n ";
system("PAUSE");
return 0;
}
seguidamente se deben mostrar estos números ingresados ordenados en
forma ascendente.
Datos de prueba: 34, 56, 32, 54, 67, 21, 89, 47, 91, 13
#include <string.h>
#include <stdlib.h>
int main()
{
int NUM[10];
49
int I, J, AUX;
cout<<"\n INGRESE 10 NUMEROS ENTEROS ";

cout<<"\n ";
for ( I=1; I<=10;I++)
cin>>NUM[I];
cout<<"\n ";
// haciendo uso del metodo de la burbuja
for ( I=1; I<=9;I++)
for ( J=I + 1; J<=10;J++)
if (NUM[J] < NUM[I])
{
AUX = NUM[I];
NUM[I]= NUM[J];
NUM[J]= AUX;
}
cout<<"\n numeros ordenados en forma ascendente ";

cout<<"\n ";
for ( I=1; I<=10;I++)
cout<<NUM[I]<< " ";
cout<<"\n ";
system("PAUSE");
return 0;
}
3. Elabore un algoritmo/programa que permita aceptar 10 números enteros

y seguidamente se deben mostrar la suma de estos de números y su
promedio.
Dato de prueba: 34, 56, 32, 54, 67, 21, 89, 47, 91, 13
y seguidamente se deben mostrar el número menor y el número mayor.
Datos de prueba: 34, 56, 32, 54, 67, 21, 89, 47, 91, 13
y seguidamente se deben mostrar la suma de de las cifras del mayor de
los números ingresados.
Dato de prueba: 342, 356, 632, 154, 687, 221, 189, 647, 891, 913
6. Elabore un algoritmo/programa que permita aceptar 10 números
enteros, seguidamente se deben mostrar la división del mayor entre el
menor de los números ingresados.(PUEDE INGRESARSE EL NUMERO
CERO UNA O VARIAS VECES . SI SE DA ESTE CASO LA DIVISION DEBE SER
CON EL SIGUIENTE MENOR NUMERO DIFERENTE DE CERO.)
Dato de prueba: 2, 0, 6, 154, 0, 21, 18, 7, 81, 13
y seguidamente se deben mostrar la cantidad de valores que son
mayores al promedio de todos los numeros.
Dato de prueba: 342, 356, 632, 154, 687, 221, 189, 647, 891, 913
y seguidamente se debe crear dos arreglos más, el primero debe
contener todos los números que se han ingresado pero que son primos
absolutos y en el segundo arreglo el resto de los números ingresados.
Se debe mostrar el contenido de estos dos arreglos
Dato de prueba: 31, 43, 63, 54, 87, 21, 19, 47, 91, 13
50
Arreglo con dos dimensiones.
Cuando se manejan arreglos de varias dimensiones, debe recordarse que el subíndice de

cada una de ellas inicia con un valor 0, como se observa en el listado 5.1.
#include <conio.h>
void main(void)
{
int matriz[3][4];
clrscr();
for(int x=0 ; x < 3 x++)
{
for(int y=0; y< 4 ; y++)
{
matriz[x][y]=x+y+1 ;
gotoxy(y+1,x+1);
cout<< matriz[x][y];
}
cout<<"\n";
}
getch();
}
Listado 5.1.- Arreglo con dos dimensiones.
El resultado de ejecutar el programa del listado 5.1 es el siguiente:
1234
2345
3456
El arreglo matriz puede representarse con la figura 5.3 .
51
Figura 5.3.- Representación del arreglo matriz .
Obsérvese que el primer subíndice varía de 0 a 2 y el segundo varía de 0 a 3.
En los párrafos anteriores, se ha mostrado la forma de asignar valores a cada uno de los
elementos de un arreglo una vez que se ha escrito su declaración. Aquí veremos la
manera de asignarle valores iniciales a los elementos, en la misma instrucción que
contiene la declaración del arreglo.
Por ejemplo, para declarar un arreglo de 10 enteros y al mismo tiempo asignarle a cada
uno de sus elementos los valores 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, puede escribirse:
int digitos[] = { 0,1,2,3,4,5,6,7,8,9 };
En este caso, aunque no se escribe el tamaño de la dimensión del arreglo digitos, tiene
el mismo efecto que escribir:
int digitos[10];
digitos[0] = 0 ;
digitos[1] = 1 ;
digitos[2] = 2 ;
digitos[3] = 3 ;
digitos[4] = 4 ;
digitos[5] = 5 ;
digitos[6] = 6 ;
digitos[7] = 7 ;
digitos[8] = 8 ;
digitos[9] = 9 ;
Como puede verse, la primera forma es mucho más compacta, aunque, como en muchas
de las instrucciones de C++, la brevedad del código sacrifica la claridad.
Ejercicios
52
seguidamente se deben mostrar estos números ingresados.
Dato de prueba:
columna1 columna2 columna3
Fila 1 14 35 46
Fila 2 25 18 49
#include <stdlib.h>
int main()
{
int NUM[2][3];
int I, J;
for ( I=1; I<=2; I++)
{
cout<<"\n INGRESE 3 NUM. ENTEROS DE LA FILA "<<I<<"\n ";
for ( J=1; J<=3;J++)
cin>>NUM[I][J];
}
cout<<"\n LOS NUMEROS INGRESADOS SON: ";
cout<<"\n ";
for ( I=1; I<=2; I++)
{
for ( J=1; J<=3;J++)
cout<<NUM[I][J] <<" ";
cout<<"\n ";
}
cout<<"\n ";
system("PAUSE");
return 0;
}
seguidamente se deben mostrar la suma y promedio de estos números
ingresados.
Dato de prueba:
columna1 columna2 columna3
Fila 1 14 35 46
Fila 2 25 18 49
seguidamente se debe mostrar la suma de los valores de cada una de
sus filas (por separado).
Dato de prueba:
columna1 columna2 columna3 columna 4
Fila 1 14 35 46 32
Fila 2 25 18 49 43
Fila 3 51 34 12 65
5.3.- Cadenas de caracteres
En C++ no existe un tipo predefinido para el manejo de cadenas de caracteres como en

otros lenguajes, sino que tienen que declararse como arreglos de caracteres.
Lo que distingue a una cadena de caracteres, con respecto a un arreglo de caracteres
53
cualquiera, es que la cadena de caracteres tiene como último carácter al carácter nulo \0.
Por ejemplo, si se declara el arreglo:
char cadena[8];
Podemos asignar los siguientes valores a cada uno de sus elementos:
cadena[0] = 'A' ;
cadena[1] = 'R' ;
cadena[2] = 'R' ;
cadena[3] = 'E' ;
cadena[4] = 'G' ;
cadena[5] = 'L' ;
cadena[6] = 'O' ;
cadena[7] = '\0';
Al contener el carácter nulo, el arreglo cadena será reconocido por las funciones y
objetos diseñados para manipular cadenas de caracteres. Para manejar un arreglo de
cadenas de caracteres se debe declarar como un arreglo bidimensional de elementos de
tipo char, como puede observarse en el listado 5.2.
#include <conio.h>
void main()
{
unsigned short int calif[10];
char nombre[10][21]; // Se declara un arreglo bidimensional
// para 10 nombres de 20 caracteres por
// nombre mas un caracter para el nulo.
clrscr();
for( int x=0 ; x < 10 ; x++)
{
gotoxy(10,x+1);
cout << "NOMBRE [" << x << "] = " ;
cin >> nombre[x];
gotoxy(45,x+1);
cout << "CALIFICACION [" << x << "] = " ;
cin >> calif[x];
}
}
Listado 5.2.- Manejo de un arreglo de cadenas de caracteres.
En el listado 5.2, se inicia con el subíndice 0 para no desperdiciar el primer elemento

del arreglo. Además, se debe recordar que el subíndice del último elemento del arreglo
es igual al tamaño de la dimensión menos 1.
5.4.- Asignación de Valores Iniciales a Cadenas
54
Cuando se tiene un arreglo de cadenas de caracteres, se puede utilizar la forma
compacta mostrada en la sección anterior, sólo que , en lugar de constantes numéricas
manejaríamos constantes de cadena.
Por Ejemplo:
char nombres[][5] = { "HUGO", "PACO", "LUIS" } ;
es equivalente a:
char nombres[3][5];
nombres[0] = "HUGO" ;
nombres[1] = "PACO" ;
nombres[2] = "LUIS" ;
Esto también puede manejarse a nivel de caracteres, así:
char nombres[][5] = { 'H','U','G','O','\0',

'P','A','C','O','\0',
'L','U','I','S','\0' };
o así:
char nombres[3][5];
nombres[0][0] = 'H' ;
nombres[0][1] = 'U' ;
nombres[0][2] = 'G' ;
nombres[0][3] = 'O' ;
nombres[0][4] = '\0' ;
nombres[1][0] = 'P' ;
nombres[1][1] = 'A' ;
nombres[1][2] = 'C' ;
nombres[1][3] = 'O' ;
nombres[1][4] = '\0' ;
nombres[2][0] = 'L' ;
nombres[2][1] = 'U' ;
nombres[2][2] = 'I' ;
nombres[2][3] = 'S' ;
nombres[2][4] = '\0' ;
En los listados 5.3 y 5.4 se muestran las dos primeras formas, observándose que se
obtiene el mismo resultado.
#include <conio.h>
void main()
{
char nombres[][5] = { "HUGO","PACO","LUIS" };
int calif[] = { 100, 90, 100 };
clrscr();
for( int x=0 ; x < 3;x++)
55
{
gotoxy(35,x+10);
cout<< nombres[x];
gotoxy(40,x+10);
cout << calif[x];
}
}
Listado 5.3.- Manejo de arreglos de cadenas.
#include <conio.h>
void main()
{
char nombres[][5] = { 'H','U','G','O','\0',
'P','A','C','O','\0',
'L','U','I','S','\0' };
int calif[] = { 100, 90, 100 };
clrscr();
for( int x=0 ; x< 3;x++)
{
gotoxy(35,x+10);
cout<< nombres[x];
gotoxy(40,x+10);
cout << calif[x];
}
}
Listado 5.4.- Manejo de arreglos bidimensionales de caracteres.
En los listados 5.3 y 5.4, se muestra que no es necesario escribir el valor de la primera
dimensión de los arreglos cuando, en su declaración, se asignan valores constantes a los
elementos.
La ventaja que tiene la forma mostrada en 5.3 y 5.4 es que, al no especificar una de las
dimensiones, la cantidad de cadenas a manejar puede variarse con sólo agregarlas a la
lista o eliminarlas de ella.
5.5.- Funciones para el manejo de cadenas
Como se estableció al principio de esta unidad, el lenguaje C++ no cuenta con algún
tipo de dato específico para el manejo de cadenas de caracteres, pero sí cuenta con un
grupo de funciones que se han acumulado durante la evolución del Lenguaje C.
Para leer una cadena de caracteres desde el teclado existe la función gets(), y para
desplegar una cadena en pantalla se usa la función puts(). Los prototipos de ambas
funciones se encuentran declarados en el archivo STDIO.H.
Por ejemplo, el listado 5.5 muestra un programa que sirve para leer y desplegar cadenas
de caracteres utilizando las funciones gets() y puts().
#include <stdio.h> // Para gets() y puts()

#include <conio.h> // Para clrscr() y gotoxy()
#include <string.h> // Para strupr() y strlen()
56
void main()
{
char nombre[31]; // Declara un arreglo de 31 caracteres
char saludo1[] = "?? HOLA,"; //Constante de caracteres
char saludo2[] = " !!";
clrscr();
gotoxy(20,10);
puts("¿ Cuál es tu nombre ? "); //Despliega cadena de car.
gotoxy(45,10);
gets(nombre); // Lee cadena de caracteres
strupr(nombre); // Convierte a mayúsculas
gotoxy(20,12);
puts(saludo1);
gotoxy(30,12);
puts(nombre);
gotoxy(30+strlen(nombre),12); // Longitud de la cadena
puts(saludo2);
}
Listado 5.5.- Lectura y desplegado de cadenas de caracteres.
Además de las funciones gets() y puts(), existe otro grupo de funciones para el manejo
de cadenas de caracteres, como strlen() y strupr() utilizadas en el programa del listado
5.5. Los prototipos de estas funciones se encuentran declarados en el archivo
STRING.H En la tabla 5.1 se describen brevemente algunas de las funciones para el
manejo de cadenas de caracteres en el C++ de Borland, cuyos prototipos se encuentran
declarados en el archivo STRING.H .
FUNCION DESCRIPCION
Copia una cadena de caracteres en otra.Se detiene cuando encuentra el
stpcpy
terminador nulo.
strcat Añade una cadena de caracteres a otra.
strchr Busca, en una cadena, un caracter dado.
strcmp Compara dos cadenas.
Macro que compara dos cadenas sin distinguir entre mayúsculas y
strcmpi
minúsculas.
strcpy Copia una cadena.
Busca segmentos que no contienen un subconjunto de un conjunto
strcspn
especificado de caracteres.
strdup Copia una cadena a una nueva localidad.
_strerror Genera un mensaje de error definido por el programador.
strerror Retorna el apuntador al mensaje asociado con el valor del error.
stricmp Compara dos cadenas sin diferenciar entre mayúsculas y minúsculas
strlen Determina la longitud de una cadena.
strlwr Convierte las mayúsculas de una cadena en minúsculas.
strncat Añade el contenido de una cadena al final de otra.
strncmp Compara parte de una cadena con parte de otra.
57
Compara parte de una cadena con parte de otra, sin distinguir entre
strncmpi
mayúsculas y minúsculas.
strncpy Copia un un número de bytes dados, desde una cadena hacia otra.
Compara parte de una cadena con parte de otra, sin distinguir entre
strnicmp
mayúsculas y minúsculas.
strnset Hace que un grupo de elementos de una cadena tengan un valor dado.
Busca la primera aparición, en una cadena, de cualquier caracter de un
strpbrk
conjunto dado.
strrchr Busca la última aparición de un caracter en una cadena.
strrev Invierte el orden de los caracteres de una cadena.
strset Hace que los elementos de una cadena tengan un valor dado.
Busca en una cadena el primer segmento que es un subconjunto de un
strspn
conjunto de caracteres dado.
strstr Busca en una cadena la aparición de una subcadena dada.
_strtime Convierte la hora actual a una cadena.
strtod Convierte una cadena a un valor double ó long double.
strtol Convierte una cadena a un valor long.
strtoul Convierte una cadena a un valor unsigned long.
strupr Convierte las minúsculas de una cadena a mayúsculas.
Tabla 5.1.- Funciones para el manejo de cadenas de caracteres.
58

Utp - Ciclo III - Separata Programacion en Lenguaje de Alto Nivel I

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Utp - Ciclo III - Separata Programacion en Lenguaje de Alto Nivel I

Diunggah oleh

Hak Cipta:

Format Tersedia

1.

Estructura de un programa en C++

1.1 El formato general de un programa en C++ es el siguiente:

void main(void) <---linea de cabecera de la función principal.

En el listado 1.1 se muestra un programa que despliega en la pantalla del monitor

#include <stdio.h> // Para utilizar la función printf()

Listado 1.1.- Primer programa en C++

1.2.- Archivos de cabecera.

El listado 1.1 contiene la línea :

En ella, stdio.h es el nombre de un archivo de cabecera en el cual se

En el C++ existen dos formas de manejar los comentarios:

La primera sirve para escribir comentarios que abarcan varias líneas, y

/* Este es otro comentario, pero a diferencia del

Observe que también puede incluir líneas en blanco (como la

void main(void) // Este comentario ocupa parte de la línea.

// Primer comentario de una sola línea.

// Segundo comentario de una sola línea.

*/ Fin del comentario de varias líneas.

1.4.- Directivas del preprocesador

El preprocesador es un programa que viene incluido en los compiladores de

Las directivas del preprocesador pueden clasificarse en tres grupos

1.4.1.- Inclusión de archivos

1.4.2.- Reemplazamiento de cadenas y procesamiento de macros

El reemplazamiento de cadenas consiste en sustituir (antes de efectuar la

#define VALMAX 1000

Esta macro puede utilizarse en una instrucción de la siguiente forma:

El preprocesador sustituye lo anterior por:

Las macros pueden tomar formas complejas y ocupar varias líneas de

#define REDOND(x) ((x)>=0?((x)+1/VALOR1)*(1-1/VALOR1): \

1.4.3.- Compilación condicional

Existe un grupo de directivas del preprocesador que permiten controlar

1.5.- La Función main()

Todo programa de C++ debe contener una función llamada main()

Al invocar a un programa escrito en C++, desde el indicador de presencia

Los nombres que son utilizados para referenciar variables, funciones,

1.6.1.- Identificadores creados por el usuario

Reglas generales para los identificadores:

a.- Letras mayúsculas y/o minúsculas.

2.- El primer carácter debe ser una letra o el carácter de subrayado.

3.- Pueden contener un número arbitrario de caracteres; pero Borland C++

4.- Se toma en cuenta la diferencia entre letras mayúsculas y minúsculas,

5.- No puede utilizarse el mismo identificador para dos objetos que se

1.6.2.- Palabras reservadas

Las palabras reservadas, como su nombre lo indica, son identificadores que

La tabla 1.1 muestra las palabras reservadas de Borland C++

Tabla 1.1.- Palabras reservadas de Borland C++.

En el Lenguaje C++, la entrada/salida se maneja de dos formas.

La primera consiste en la utilización de las funciones cuyos prototipos

La segunda es propia del C++ y consiste en el manejo de objetos y

A continuación explicaremos cada una de estas dos formas.

1.7.1.- Funciones declaradas en stdio.h

En el archivo stdio.h se encuentran definidos, entre otros, los prototipos de

1.7.1.1.- La función printf()

Esta función es la mas utilizada en C para desplegar información en la

El formato general para la función printf() es:

printf(<cadena_formato> , <elem> , <elem> , ... );

cadena_formato es una cadena de caracteres encerrada entre comillas

La sustitución de los elementos se hace de acuerdo a los comandos de

En la tabla 1.2 se muestran los comandos de formato más usuales:

Comando Sirve para:

Tabla 1.2.- Comandos de formato.

Tipo Tamaño (bits) Precisión Rango de valores:

Tabla 1.3.- Tipos de datos, tamaños y rangos en Borland C++ 3.1