Introduccion a la programacion en el lenguaje C++

Profa. Saray Ma Lezcano Gantes

8 de noviembre de 2012

1. Qu
e es un algoritmo?
Un algoritmo se define como un conjunto de reglas que, aplicadas sistem aticamente a unos datos de entrada
adecuados, resuelven un cierto problema en un n umero finito de pasos elementales. La anterior es una
definici
on suficiente, pues considera todas las caractersticas que un algoritmo debe tener:

1. Es un conjunto de reglas: aunque la definicion no lo especifique de manera explcita, dicho conjunto

tambien debe ser finito, pues cualquier conjunto infinito de reglas provocaria que quien las realiza,
nunca terminara, lo que no respetara la u
ltima parte de la definicion, es decir, el que el problema sea
resuelto en n
umero finito de pasos.
2. Aplicadas sistem
aticamente: un algoritmo no se comportara de manera distinta si dos veces recibe la
misma entrada.
3. Datos de entrada adecuados: un algoritmo puede estar dise nado de manera especfica para cierta clase
de datos. Por ejemplo, si se tiene pimienta, sal, cebolla, carne de pollo, aceite vegetal comestible, agua
y salsa de soya, existe una receta de cocina (que es un algoritmo) que nos dice como preparar pollo
en salsa china. Sin embargo, si tenemos rocas, un par de zapatos, pelos de perro y un litro de leche,
la misma receta no nos dice c omo podriamos obtener un plato de pollo en salsa china con dichos
ingredientes.
4. Resuelven un cierto problema: un algoritmo debe solucionar un problema sin importar cuales datos
especificos se le den. Volviendo al ejemplo de la receta del pollo en salsa china, la receta no exige que el
pollo del que se obtuvo la carne sea de plumas blancas. Si la receta funcionara para pollos de plumas
blancas, pero no para pollos de plumas negras, entonces no seria un algoritmo.
5. En un numero finito de pasos: un algoritmo debe terminar. Asi, por ejemplo, contar todos los numeros
enteros no puede ser parte de un algoritmo, pues dicho procedimiento jamas llegara a un fin.
6. De pasos elementales: cada paso debe ser lo suficientemente claro, como para que dos personas o
maquinas distintas lo realicen de la misma manera. As entonces, cortar una papa en pedazos no es
un paso elemental, pues Romina podria cortarla en rodajas y Pedro en cuadritos.

Ahora bien, Los algoritmos son algo nuevo para nosotros? Evidentemente no. Las recetas de cocina son
algoritmos, as como tambien las partituras de una obra musical (donde se supone que tocar un acorde es un
paso elemental, pues resulta b asico para la interpretacion de m
usica) y el procedimiento que se nos ense
no
en la primaria para sumar dos n umeros.
En que parte entran las computadoras en lo respectivo a los algoritmos? Pues bien, una computadora no es
mas que un mont on de circuitos conectados de cierta manera, que la maquina resultante es capaz de seguir
ordenes distintas, es decir, capaz de ejecutar algoritmos especificados en su propio lenguaje. Las computadoras

no razonan: son tontas, pero son capaces de realizar tareas repetitivas, como sumas, multiplicaciones y demas,
a una velocidad asombrosamente superior a la de un ser humano. Por ejemplo, una computadora personal
moderna puede realizar miles de millones de multiplicaciones aritmeticas en un segundo.

1
1.1. Diagramas de flujo

Hay muchas maneras de describir un algoritmo, siendo quiza la mas natural, por ser inherente a nuestro
lenguaje, el listarlo como una secuencia de pasos. Sin embargo, dentro del ambito de la programaci on, se
requiere de metodos m as descriptivos y representativos para un ser humano. Uno de ellos el de los diagramas
de flujo.
Hay diferentes convenciones simb olicas sobre que representa cada smbolo en un diagrama de flujo, y estas
varian entre libros, sin embargo, no es difcil cambiar una por otra. En nuestro caso:

Todo diagrama de flujo comienza con un rectangulo de esquinas ovaladas con la palabra Inicio escrita
dentro, o bien, si se trata de una funcion, con el nombre de la misma en dicho recuadro, seguida de los
argumentos que toma encerrados entre parentesis y separados por comas.
Todo diagrama de flujo termina con un rectangulo de esquinas ovaladas con la palabra Fin escrita
dentro.
Un paso elemental se coloca dentro de un recuadro con la descripcion del paso escrita dentro.

Las figuras de un diagrama de flujo se conectan con flechas de un solo sentido, comenzando con el
simbolo de inicio y acabando en el del fin.
Cada declaracion de variables se escriben dentro de un recuadro com un, con el nombre de la variable
precedido por la palabra Sea y sucedido por el nombre del tipo de la variable. Por ejemplo Sea x
entero. Se pueden colocar varias declaraciones en un recuadro si se separan en distintas lneas.

Una operaci on de salida se describe mediante un rectangulo con la salida escrita y precedida por
la palabra Escribir. Se pueden concatenar varias salidas con el simbolo <<. Por ejemplo, son
equivalentes

Escribir Este es un mensaje no muy grande

Escribir Este es << un mensaj << e no muy grande.

Recuerda que las cadenas textuales deben entrecomillarse, como en el ejemplo anterior.

Una asignacion a una variable se describe mediante un rectangulo con la variable escrita, seguida de
una flecha de derecha a izquierda con lo que se le asignara a la variable en el extremo derecho (como
en x 5).
Una operaci on de entrada del teclado se describe mediante un rectangulo con la palabra Leer. Si la
entrada se le asignar
a a una variable, entonces se siguen las convenciones del punto anterior, colocandose
el Leer y el texto a la derecha de la flecha (como en x Leer).
Una decisi
on se representa mediante un rombo con la pregunta escrita dentro y dos flechas saliendo
del mismo, una etiquetada como s y otra etiquetada como no.

En la descripci
on anterior de los diagramas de flujo, se ha hecho referencia a algunos conceptos como variables,
asignaciones y dem as, que se estudiaran a su debido tiempo.
Un ejemplo de diagrama de flujo que muestra en pantalla la frase Hola, mundo. se muestra a continuaci
on:

2
Ahora, un diagrama que muestra un mensaje saludando a la persona que lo observa, despues de que esta le
haya proporcionado su nombre mediante el teclado, se muestra a continuacion:

2. El lenguaje de programaci
on C++
Todos conocemos al menos un idioma para comunicarnos, y este debe ser comun para entendernos. De otra
manera, nos quedamos aislados y no podremos preguntarle a alguien en donde estamos y si ese alguien nos
lo cuenta, simplemente no lo entenderemos.
Las computadoras tienen sus propios lenguajes, todos binarios, pero no necesariamente iguales. Algo escrito
en lenguaje binario para una PC, probablemente no lo entendera una computadora DEC o una PlayStation
(las consolas de videojuegos tambien son computadoras, aunque de uso mas especifico).
Los algoritmos que debe ejecutar una computadora, por tanto, los recibe escritos en su lenguaje nativo,
que se denomina lenguaje m
aquina. Los seres humanos debemos especificar dichos algoritmos, que reciben el
nombre de programas.
Es muy cansado, lento y aburrido escribir con ceros y unos, por lo que una solucion optima es escribir los
programas que queremos que la computadora lleve a cabo en un lenguaje intermedio entre el lenguaje de
la computadora y el nuestro, y despues traducir dicho programa a lenguaje maquina para que entonces
la computadora sea capaz de ejecutarlo. La traduccion se denomina compilaci on y el lenguaje intermedio,
es generalmente un lenguaje de programaci on de alto nivel, que si bien no es castellano, aleman o ingles,
se acerca mas y nos permite saber que hace tras darle una ojeada, si antes lo aprendimos ya. Esta clase
de lenguajes se denominan formales, porque una sentencia escrita en los mismos, puede significar solo una

3
 cosa. Es decir, pierden las met
aforas, las deducciones y los dobles sentidos de nuestros idiomas, que como
contraparte se conocen como lenguajes naturales (el castellano es un lenguaje natural).
Existe una infinidad de lenguajes de programacion, con diversos enfoques o paradigmas para abordar un
problema. El que nos ocupa es C++.
C++ es un lenguaje multiparadigma: es estructurado (los algoritmos se escriben especficamente, paso por
paso) y orientado a objetos opcionalmente (pueden crearse clases y ejemplares (objetos) de dichas clases) y
adem as, tiene mecanismos para escribir en el lenguaje ensamblador de la computadora (los ensambladores
son lenguajes de bajo nivel, pues se corresponden exactamente con el lenguaje de la maquina, pero utilizando
palabras en lugar de dgitos binarios).
C++ es un lenguaje muy utilizado en la actualidad, sobre todo en el desarrollo de programas que requieren
de ejecutarse a una gran velocidad, como videojuegos y procesadores de video. Un subconjunto de C++,
denominado C, es casi por regla general el lenguaje utilizado en el desarrollo de sistemas operativos.

2.1. Un primer programa

El programa en C++ correspondiente al primer diagrama de flujo (el que solo escriba Hola, mundo) es el
siguiente:
1 #include < iostream >
2 #include < cstdio >
3
4 using std :: cout ;
5 using std :: endl ;
6
7 main () {
8 cout << " Hola , mundo " << endl ;
9
10 getchar ();
11 return 0;
12 }

La primera lnea significa usar la biblioteca iostream, como la segunda significa usar la biblioteca cstdio.
Las bibliotecas no son m as que colecciones de codigo ya escrito en C++, para que lo podamos usar nosotros.
La biblioteca iostream tiene funciones para manejar la entrada y la salida de datos. cstdio es muy similar
a la primera, pero con las funciones que se usan en el subconjunto de C (que es mas antiguo que C++). La
u
nica funcion de cstdio que utilizamos es getchar(), que lee un solo caracter del teclado. La colocamos
al final de nuestro programa para que se detenga mientras que no tecleemos algo y nos permita ver lo que
escribi
o antes, pues de otra manera, si ejecutamos el programa desde Windows, se abrira una ventana de
MS-DOS, mostrara el mensaje y se cerrara en una fraccion de segundo, por lo que no podriamos ver el
resultado.
En las lneas 4 y 5, le decimos al compilador de C++ que queremos escribir en lo sucesivo solo cout y
endl en lugar de sus nombres completos, que son std::cout y std::endl (si sientes curiosidad, std es un
objeto creado dentro de la biblioteca iostream, por lo que su naturaleza corresponde al paradigma de la
programaci on orientada a objetos).
En la lnea 7 da inicio la u
nica funci
on que tiene nuestro programa, y que se llama main. Una funcion puede
tener casi cualquier nombre, pero s olo puede haber una llamada main en un programa, y esto porque la
ejecucion del programa se iniciar a automaticamente siempre en ella. Es decir, main es siempre la funci on
principal. Todo lo que est a dentro de una funcion se escribe entre llaves, como puedes ver en el ejemplo.
En C++ se manejan flujos de entrada y flujos de salida, para controlar lo que le decimos al programa y lo
que el nos responde. El flujo de salida se denomina cout y todo lo que le arrojemos, el nos lo mostrar
a en
la pantalla de la computadora. Para arrojarle algo a cout, escribimos cout seguido de << y lo que queremos
arrojar. Si queremos arrojar m as cosas, seguimos colocando mas smbolos << seguidos de dichas cosas.

4
 En la lnea 8, por tanto, escribimos en la pantalla el texto Hola, mundo, entrecomillado para dar a entender
que queremos mostrar ese texto tal cual, pues de otra manera, C++ pensara que se trata de dos variables,
y luego escribimos endl, que no es m as que un salto de lnea textual. Terminamos la lnea con un car
acter
; para indicar que lo que se ponga despues es otra instruccion.
En la lnea 10 llamamos a la funci
on getchar, colocando los parentesis vacios para decirle a C++ que es una
funci
on y no una variable, para que espere a que el usuario pulse una tecla para luego terminar el programa.
En la lnea 11 se escribe la instrucci
on return 0; que significa que al terminar la funcion main, esta le regre-
sar
a el valor 0 al sistema operativo, para que Windows interprete que el programa se ejecuto correctamente.
En la lnea 12 s
olo se coloca la llave de cierre de la funcion, que significa que la especificacion de la funci
on
termina all.
Notese que se ha indentado todo el contenido de la funcion main. Esto no es obligatorio, pues el resultado
sera el mismo, pero es una buena costumbre, pues el programador puede ver tras una primera ojeada que
todo lo que esta indentado es el contenido de la funcion.

2.2. Entrada mediante teclado

Para ilustrar metodos de entrada comunes en C++, recurriremos a traducir el algoritmo del segundo diagrama
de flujo a c
odigo compilable.
El c
odigo de nuestro segundo programa puede consultarse en el siguiente listado:
1 #include < iostream >
2 #include < cstdio >
3
4 using std :: cin ;
5 using std :: cout ;
6 using std :: endl ;
7
8 main () {
9 char nom [40];
10
11 cout << " Cual es tu nombre ? " << endl ;
12 cin >> nom ;
13 cout << " Hola , " << nom << " . Eres bienvenido ( a ). " << endl ;
14
15 getchar ();
16 getchar ();
17 return 0;
18 }

Puede verse que el esqueleto del programa es igual al del primero, no obstante hay algunas novedades relativas
a los flujos de entrada. La primera diferencia se observa en la lnea 4: ademas de informarle al compilador
de que usaremos cout (el flujo de salida) y endl (el caracter de nueva lnea), agregamos algo que tambien
nos sera muy com un desde ahora, y esto es que haremos uso de std::cin, que abreviaremos como cin. Este
representa el flujo de entrada est
andar (esta conectado al teclado) y por ello su nombre es analogo al de
cout: c de C++ e in de input (entrada), o sea, es el flujo de entrada de C++.
La manera de hacer uso de cin es bastante natural y similar a la de cout. Cuando se desea leer alg un dato
del teclado, simplemente se coloca el nombre del flujo, seguido de >> (notese que es en sentido contrario a
los smbolos usados para la salida), y a la derecha de dicho smbolo, se coloca el nombre de una variable en
la que se ha de almacenar lo que se lea.
Del p
arrafo anterior surge la interrogante Que es una variable?. En C++ y en todos los lenguajes de
programacion imperativos y orientados a objetos, una variable es un nombre que se asocia a una posici
on

5
de memoria en la que se ha de almacenar cierta informacion. En C++, las variables tienen tipos, pues los
datos con que se trata, pueden ser de naturaleza muy diversa.
Los tipos de datos b
asicos de C++ se listan a continuacion.

bool Es el tipo utilizado para manejar datos booleanos, es decir, aquellos que solo pueden tener dos valores
posibles: verdadero y falso, que en C++ se denominan true y false, respectivamente.
int Tipo de datos para n
umeros enteros.
char Tipo para caracteres. Los caracteres son letras, dgitos y signos de puntuacion como $, y /. N
otese
que los caracteres se reconocen dentro del codigo de un programa en C++, encerrandolos entre comillas
simples. Por ejemplo, 9, k, = y S.
float Si se requiere hacer c
alculos con numeros reales, tales como 13.131313 y 5.4321, float es un tipo de
datos apropiado para ello. Cabe mencionar que en realidad se trata solo de aproximaciones, pues algunos
numeros necesitaran de una infinita cantidad de dgitos para representarse (como , por ejemplo) y
las computadoras, evidentemente, no tienen memoria infinita.
double Este tipo tambien se usa en el tratamiento de n
umeros reales, pero tiene mas precision que float,
es decir, con double, pueden tratarse numeros mas grandes (o mas peque nos) y con mas posiciones
decimales.

Hay m as tipos de datos en C++, pero los anteriores son los basicos. Cabe mencionar que en el diagrama de
flujo se dice que la variable nom debe ser de tipo cadena. Una cadena es una secuencia de caracteres, es decir,
una sucesi on de datos de tipo char. Para tratar con cadenas, se declararan las variables de tipo char, pero
especificando adem as una longitud maxima para las cadenas.
La sintaxis de una declaraci
on de variable es la siguiente:

tipo nombre_de_la_variable;

Por ejemplo, una variable de tipo entero y llamada x, se declarara de la siguiente manera:

int x;

Otra operacion muy importante que se da con las variables es la asignaci on, es decir, el guardar un dato
en una variable, de tal manera que cuando se escriba la variable sera como si se escribiera dicho dato
(aunque este puede ser cambiado mediante otra asignacion). En nuestros diagramas de flujo representamos
on con el smbolo , sin embargo, en C++, el smbolo que se usa es = (el signo de igualdad).
esta operaci
Por ejemplo, si a nuestra variable entera x, queremos asignarle el valor del n
umero 13, bastara con hacer lo
siguiente:

x = 13;

Mas aun, si a x, queremos asignarle el resultado de dividir el resultado de sumar 5 y 10, entre 3 ( 5+10
3 ),
escribiramos

x = (5 + 10) / 3;

Automaticamente, x obtendra el valor 5. Es importante tener en cuenta que a la izquierda de un = siempre

debe haber una variable (s
olo una).
Los datos tambien pueden leerse del teclado, como en nuestro ejemplo, y para esto se recurre al flujo de
entrada cin.

6
Otra anotacion importante es que las variables las declararemos siempre, inmediatamente despues de empezar
la funci
on main.
Volviendo a nuestro ejemplo, en la lnea 8 da inicio la funcion main y podemos ver la declaracion de la
cadena nom en la lnea 9. Se especifica la longitud maxima de la cadena entre corchetes, que en este caso
es 40, aunque podra ser cualquier otro numero entero positivo. Decidimos que fuera de 40 porque existen
algunos nombres propios de persona un poco largos.
Recordemos que las cadenas, dentro del codigo de un programa en C++, se representan encerrandose entre
comillas, pero no simples como en el caso de los caracteres individuales, sino dobles.
En la lnea 11 se escribe el mensaje Cual es tu nombre?1 , concatenado con el caracter de nueva lnea (endl).
Luego, en la lnea 12, se lee el nombre del teclado y se almacena en la variable de cadena nom. Ahora la
computadora conoce el nombre del usuario y puede mostrarle un mensaje personalizado, lo que se especifica
en la lnea 13, concaten
andole a la cadena Hola, el valor de la variable nom y concatenando a su vez la
cadena . Eres bienvenido (a). y el car
acter de nueva lnea.

Despues se colocan dos llamadas a la funcion getchar() y no una. Esto, porque despues de ingresar su
nombre, el usuario, este teclear
a Enter y ese car
acter (equivalente a endl), lo leera el primer getchar(),
por lo que ser
a necesario colocar un segundo getchar(), de manera que se espere un segundo tecleo, antes
de cerrar la ventana.
Finalmente, se coloca la sentencia return 0; y se cierra la funcion main.

2.3. Condiciones

Todos los programas que hemos escrito hasta ahora, se han ejecutado de manera totalmente lineal, es decir,
de arriba hacia abajo, lnea a lnea. Sin embargo, puede suceder, como se esperara, que no siempre se desee
esto, que queramos que a veces se ejecuten algunos fragmentos de codigo y otros no, dependiendo de los
valores que las entradas nos proporcionen. Y de hecho, esto es bastante com un en la mayor parte de los
algoritmos.
La necesidad anterior se satisface con las bifurcaciones condicionales, o condiciones, simplemente. Las condi-
ciones, en C++, se construyen con la sentencia if, cuya sintaxis se muestra a continuacion:

if (valor_booleano) {
sentencia_1;
sentencia_2;
.
.
.
sentencia_m;
}
else {
sentencia_alterna_1;
sentencia_alterna_2;
.
.
.
sentencia_alterna_n;
}
1 En este ejemplo exclumos los caracteres especiales y
a, porque no son de representaci
on sencilla, y si en el c
odigo
pueden verse de manera clara, muy probablemente al ejecutarse en MS-DOS, aprezcan distorsionados, pues los sistemas de
codificaci
on de caracteres son distintos.

7
 Cuadro 1: Operadores relacionales (o de comparacion) de C++.
Operador Significado Ejemplo
< Menor que 5 < 10
> Mayor que 10 > 5
<= Menor o igual que 13 <= 13
>= Mayor o igual que 13 >= 12
== Igual a 7 == 7
!= Diferente de 5 != 0

Recalquemos que todo lo que aparezca entre llaves, en C++, se denomina un bloque. As, en la sintaxis
anterior hay dos bloques. El primero se ejecutara si y solo si el valor booleano es verdadero (true); de otra
manera, lo que se ejecutar
a ser
a el segundo bloque (el que esta despues de else). Es imposible que se ejecuten
ambos bloques, pues una vez iniciado, queda totalmente descartado el otro. Se ha tomado una decision, pues,
sobre el flujo del programa.
La parte de else es opcional. Puede colocarse solo el primer bloque, lo que significara que se ejecutara s
olo
si el valor booleano es verdadero, y de otra manera, simplemente se seguira con el programa, pasando el
bloque de la condici
on.
El valor booleano puede ser directo, es decir, true o false, o bien, ser el resultado de evaluar algunos valores
con operadores relacionales (como < y >=), o el resultado de una funcion que devuelve un valor booleano.
Los operadores relacionales (o de comparacion) se muestran en la tabla 1. Es importante mencionar que s
olo
funcionan con numeros (tanto enteros como reales), caracteres (individuales, no cadenas) y los u
ltimos dos
tambien funcionan con valores booleanos.
Ahora se veran algunos programas de ejemplo. Para el primero, haremos uso de un operador aritmetico que
a
un no conocemos. Sabemos para que sirven +, -, * y /, sin embargo desconocemos la utilidad de %: no tiene
nada que ver con porcentajes, simplemente es el operador de m odulo de divisi
on entera, es decir, devuelve el
residuo de dividir su operando izquierdo entre su operando derecho. As, por ejemplo, el resultado de 5 / 3
es obviamente 1, y el de 5 % 3 es 2 (el residuo). El programa que escribiremos es uno que determinara si un
n
umero entero es par o impar.
Un numero es par si al dividirse entre 2, deja un residuo 0, as que solo necesitaremos calcular dicho residuo
y de acuerdo al resultado, decidir con una condicion si es par o impar.
1 #include < iostream >
2 #include < cstdio >
3
4 using std :: cin ;
5 using std :: cout ;
6 using std :: endl ;
7
8 main () {
9 int x;
10
11 cout << " Ingresa un numero entero " << endl ;
12 cin >> x ;
13
14 i f ( x % 2 == 0) {
15 cout << " El numero es par " << endl ;
16 }
17 else {
18 cout << " El numero es impar " << endl ;
19 }
20
21 getchar ();

8
22 getchar ();
23 return 0;
24 }

Describiremos s
olo el c
odigo correspondiente a la funcion main(), que da inicio en la lnea 8.
En la lnea 9 se declara una variable x, de tipo entero. Luego se escribe en la pantalla un mensaje solicitandole
al usuario que proporcione un n umero entero, el cual se almacena en la variable x. Finalmente, en la lnea 14
se coloca la condici on, se verifica si el residuo de dividir x entre 2 es cero. Si as sucede, entonces se ejecuta
la lnea 15, que le comunica al usuario que el n umero que ingreso es par; de otra manera, se ejecuta el bloque
else, cuya unica sentencia es la de la lnea 18, que le dice al usuario qu el numero es impar. Despues de esto,
s
olo se colocan dos llamadas a getchar(), para que la ventana no se cierre y el clasico return 0;.

2.4. Ciclos
Con las herramientas que tenemos hasta este momento, podemos claramente resolver una importante can-
tidad de problemas, tomando decisiones con base en las caractersticas de las entradas, sin embargo, la
representaci on de la mayor parte de los algoritmos sigue quedando fuera de nuestro alcance, Por que?
Demos un ejemplo sencillo: calcular el factorial de un numero arbitrario. El factorial de un n
umero entero
positivo se obtiene al multiplicar dicho n
umero por cada uno de los enteros positivos que sean menores que
el, as, por ejemplo:

factorial de 3 = 321=6
factorial de 5 = 5 4 3 2 1 = 120

Es claro que no podemos resolver ese problema en general con condiciones ni con nada que hayamos estudiado
ya. Podemos escribir un programa que calcule el factorial de 5, por ejemplo, realizando solo la multiplicaci
on,
pero dicho programa no funcionara si se desea conocer tambien el factorial de 7, o el de 10. Sin embargo,
para nuestra buena fortuna, s existe una manera de abordar este tipo de procedimientos y es mas sencilla
de lo que podran los desconocedores imaginarse. Nuestra nueva estructura de control se llama ciclo o bucle.
Un ciclo no es m
as que un bloque de c
odigo que se repite una y otra vez, deteniendose solo hasta que se haya
cumplido una condicion determinada. Podemos ver algunas situaciones paralelas en nuestra vida diaria, por
ejemplo:

Dormimos mientras no haya empezado a sonar el despertador.

Es esa la forma en que muchos determinamos cuanto tiempo debemos (o podemos dormir). Si suena
el despertador y lo ignoramos, seguramente no llegaremos a clases.
Caminamos desde casa mientras no hayamos llegado a
un al colegio.
Caminar mientras no se ha llegado es natural. Si caminamos menos, nos quedaremos a la mitad del
camino y si caminamos mas, entonces llegaremos a otro lugar o chocaremos contra un muro.
Comemos mientras tengamos apetito.
Tanto comer menos como comer m
as puede tener graves consecuencias en nuestra salud si se realiza
constantemente.
Nos portamos mal en clase mientras no nos manden a la direccion.
Tristemente, esta es la filosofa de muchos estudiantes.

Ahora, bien, los ciclos mas b

asicos en C++ se denominan while (existen otras clases de ciclos en el lenguaje),
que se traduce del ingles como mientras y su sintaxis es la siguiente:

9
 while (valor_booleano) {
sentencia_1;
sentencia_2;
.
.
.
sentencia_m;
}

Como puede observarse, no es muy diferente de la sintaxis de las condiciones (solo se cambia la palabra if por
while), no obstante, su comportamiento en el momento de ejecutarse el programa, es totalmente distinto.
La idea es simple: todas las sentencias del bloque se ejecutaran repetidamente, mientras que valor_booleano
siga siendo true. Evidentemente, comunmente no colocaremos una constante booleana, sino una variable o
una expresi on l
ogica (como una comparacion) que pueda cambiar mas adelante, o de otra manera, el ciclo
se ejecutara cero veces (puede ser que a veces esto es lo que se quiera) o infinitas veces. Si nunca se detiene
un ciclo, se le denomina ciclo infinito, y generalmente terminara ocasionando un error grave, por lo que el
programa terminar a bruscamente, al haber agotado los recursos de la computadora que tena asignados por
el sistema operativo (generalmente, lo que se agota es la memoria disponible).
Un ciclo que se ejecuta cero veces es el siguiente:

while (2 > 5) {
cout << "Hola" << endl;
}

puesto que 2 no es mayor que 5. Un ciclo que se ejecuta infinitamente, es el siguiente

while (true) {
cout << "Hola" << endl;
}

Pues el valor true es. . . Bueno, siempre es verdadero.

Antes de resolver el problema del factorial, nos entrenaremos con uno mas sencillo: mostrar en pantalla todos
los numeros enteros positivos, desde 1 hasta un n umero arbitrario que el usuario proporcione. Por ejemplo,
si el usuario teclea el n
umero 13, entonces el programa debera mostrar la siguiente secuencia de numeros:

1 2 3 4 5 6 7 8 9 10 11 12 13

El c
odigo es el siguiente:
1 #include < iostream >
2 #include < cstdio >
3
4 using std :: cin ;
5 using std :: cout ;
6 using std :: endl ;
7
8 main () {
9 int n;
10 i n t contador ;
11
12 cout << " Escribe un numero entero positivo : " << endl ;
13 cin >> n ;
14 contador = 1;

10
15
16 while ( contador <= n ) {
17 cout << contador << " " ;
18 contador = contador + 1;
19 }
20
21 cout << endl ;
22
23 getchar ();
24 getchar ();
25 return 0;
26 }

El primer punto importante del programa anterior, es la necesidad de tener una variable para contar cada
una de las repeticiones del ciclo. A este tipo de variables se les denomina contadores, y por ello en nuestro
c
odigo la bautizamos de esa manera. Es muy importante inicializar los contadores antes de usarlos, es decir,
asignarles un valor apropiado para iniciar el ciclo: si vamos a contar repeticiones, claramente el valor 1 es
mas que adecuado y por ello se lo asignamos en la lnea 14.
En la lnea 16 comienza nuestro ciclo, cuya expresion booleana es que el valor de la variable contador sea
menor o igual que el del numero que el usuario nos proporciono. El ciclo se ejecutara entonces si y s
olo si
el valor de n es positivo. Cada vez que se ejecuta el cuerpo del ciclo, este muestra en la pantalla el valor
de contador y le concatena un espacio (n otese que no concatenamos endl, pues queremos que los n umeros
se separen solo por un espacio, para que no llenen la pantalla tan rapido) y en la lnea 18, a contador le
asignamos el valor que ya tena m
as 1.
La lnea 18 es fundamental, pues si no se ejecutara algo dentro del ciclo que pudiera cambiar el valor de
contador o de n, entonces tendramos un ciclo infinito.
La lnea 18 es totalmente valida en la programacion imperativa y en la programacion orientada a objetos,
pues en C++, = no significa igualdad, sino asignacion, por ello podemos escribir cosas como x = x + 1.
En matem aticas eso no es v
alido (pues, por ejemplo, no es cierto que 5 = 6).
Una vez que el contador ha superado el valor de n, el ciclo deja de ejecutarse y el programa continua en
la lnea 21, donde mostramos en la pantalla un simple salto de lnea, pues ya hemos terminado de mostrar
todos los n umeros que debamos.

2.5. El ciclo for

El lenguaje C++ dispone de construcciones alternativas a while para especificar ciclos, aunque while es la
mas general. Las restantes dos son especializaciones que se vuelven mas adecuadas en determinados casos.
Los ciclos for son equivalentes a los ciclos while: eval
uan una condicion al principio del ciclo y este se deja de
repetir cuando la condicion no se cumple mas, no obstante, esta dise nado especialmente para realizar ciclos
que esten basados en el uso de contadores, es decir, aquellos para los que desde un principio se conoce el
n
umero de iteraciones que se llevar an a cabo. La sintaxis del ciclo for es la siguiente:

for (inicializacion; valor_booleano; expresion_de_incremento) {

sentencia_1;
sentencia_2;
.
.
.
sentencia_m;
}

11
La parte de inicializacion se ejecutar a una sola vez, antes de que se lleve a cabo la primera iteraci on
del ciclo, por lo que es
optima para colocar en ella la inicializacion de nuestro contador. El ciclo se repetir
a
mientras que el valor de valor_booleano sea true (al igual que como sucede con el ciclo while) y la parte de
expresion_de_incremento se ejecutar a al final de cada iteracion, por lo que es un buen lugar para colocar
nuestras actualizaciones del contador del ciclo.
Por ejemplo, el siguiente ciclo, que imprime en pantalla los primeros n n
umeros enteros positivos,

int contador;

contador = 1;

while (contador <= n) {

cout << contador << " ";
contador = contador + 1;
}

cout << endl;

puede escribirse tambien, con menos lneas, haciendo uso de un ciclo for, de la siguiente manera:

for (int contador = 1; contador <= n; contador = contador + 1) {

cout << contador << " ";
}

cout << endl;

N
otese que est
a permitido declarar variables dentro de la parte correspondiente a inicializacion.

2.6. El ciclo do/while

La tercera y u
ltima estructura cclica de C++ es do/while, que es en cierta manera casi tan general como while,
en el sentido de que no cuenta con un arsenal de segmentos en su sintaxis que esten hechos para especializarse
en alguna clase de iteraciones, como sucede con for (que se especializa en ciclos con contadores), pero con la
diferencia fundamental de que siempre se ejecutara el ciclo una vez al menos; esto sucede porque la condici
on
de iteraci
on no se ejecuta al principio, sino al final de la estructura. Su sintaxis es la siguiente:

do {
sentencia_1;
sentencia_2;
.
.
.
sentencia_m;
} while (valor_booleano);

Es extremadamente importante colocar el ; en la u ltima lnea, pues de otra manera, el compilador de C++
puede confundirse e interpretar que se trata del principio de un ciclo while y no del final de un ciclo do/while.
Nuevamente, la versi
on con do/while del ciclo que imprime los primeros n n
umeros enteros positivos es:

12
int contador;

contador = 1;

do {
cout << contador << " ";
contador = contador + 1;
} while (contador <= n);

cout << endl;

Sin embargo, esta no es la especialidad de while, sino, como ya se menciono, aquellos casos donde es necesario
que el ciclo se ejecute al menos una vez.
Por ejemplo, si queremos que el usuario escriba un entero positivo y queremos prevenir errores posteriores
que podran ser causados por n
umeros negativos (o por el cero), podramos leer el n
umero de la siguiente
manera:

int n;

do {
cout << "Ingresa un numero positivo:" << endl;
cin >> n;
} while (n <= 0);

La anterior es una forma muy elegante de validar la entrada (validar significa asegurarse de que los datos
ledos son adecuados). Si el usuario escribe un numero positivo, entonces el ciclo se habra ejecutado una
sola vez y habra sido como si no existiera, pero si el usuario tiene cierta inclinacion por la maldad y desea
que nuestro programa falle (o bien, es un poco tonto), entonces podra ingresar un n umero negativo, como
1, pero Vaya sorpresa que se llevara cuando nuestro programa vuelva a pedirle otro n umero, simplemente
porque reconocio que el anterior era negativo!.
Los ciclos do/while son excelsos para validar entradas.

3. Arreglos y cadenas
Todos los tipos de datos que hemos utilizado son tipos primitivos, o sea, provistos por el propio lenguaje de
programaci on C++, no obstante, es posible y necesario construir tipos de datos mas complejos (con base en
los primitivos), que permitan tratar informacion que represente propiedades que no puedan ser entendidas
mediante un simple n umero.
La necesidad m as com
un que no es cubierta por los tipos de datos primitivos es la de un grupo de valores
multiples, que en C++ se solventa mediante el uso de los arreglos. Un arreglo es una secuencia de valores a
los que se accede mediante el nombre de una sola variable.
Un arreglo se declara con la siguiente sintaxis:

tipo nombre_del_arreglo[numero_m
aximo_de_elementos_del_arreglo];

As, si queremos declarar un arreglo de mil enteros, se hace como sigue:

int arreglote[1000];

13
 Y listo! Ya tenemos un arreglo con capacidad para almacenar mil valores enteros, la cuestion es ahora el c omo
acceder a cada uno de esos valores en la memoria. Es muy sencillo, en realidad, u nicamente debe escribirse
el nombre del arreglo y el subndice del valor al que queremos acceder, pero entre corchetes. Un subndice es
un entero no negativo para se nalar el primer valor, el segundo valor, el trigesimo primer valor, etcetera.
No obstante, hay un peque no detalle que debe tomarse en cuenta: a las computadoras les gusta contar desde
cero! Bueno, en realidad no es que les guste, sino que es mas natural porque el n umero mas peque no es
cero, y no usarlo sera un desperdicio de memoria (recordemos que la memoria de una computadora no es
infinita). As, si se declara que determinado arreglo tiene capacidad para n elementos, entonces los subndices
que se pueden usar son los enteros desde 0 hasta n 1. Es muy importante tener cuidado con esto, pues si se
se
nala un valor m a del que tiene subndice n 1, puede ser que no pase nada, o que se modifique una
as all
variable distinta (cosa que sera terrible, por ejemplo, en el programa que maneje cuentas bancarias) o bien,
que se cierre estrepitosamente el programa sin despedirse (lo que sera una verg uenza para el programador,
si alguien m as lo ve).
Para aterrizar las ideas, recurramos al arreglo declarado arriba (arreglote). Su primer elemento tiene
subndice 0, su segundo tiene subndice 1, el tercero tiene subndice 2, y as seguimos hasta llegar al milesimo
elemento, que tiene subndice 999. Supongamos que queremos asignarle un 13 al primer elemento y un 30 al
segundo, luego leer un entero del usuario y almacenarlo en el milesimo elemento, y, por u ltimo, sumar esos
tres elementos (para mostr arselos al usuario), entonces se debe escribir lo siguiente:

arreglote[0] = 13;
arreglote[1] = 30;
cout << "Escribe un entero: ";
cin >> arreglote[999];
cout << "La suma es " << arreglote[0] + arreglote[1] + arreglote[999] << endl;

N
otese que cada elemento del arreglo puede usarse como cualquier variable comun. Podra pensarse en un
primer momento que la u
nica ventaja de esto es declarar menos variables, pero realmente las posibilidades
de c
omputo se incrementan muchsimo con el uso de arreglos.
Veamos un ejemplo. Si se van a registrar 10 notas parciales para calcular su promedio y se quiere que el
programa pida cada una de las notas (o sea que no se vale leerlas al mismo tiempo y separadas por espacios),
es posible declarar diez variables con nombres distintos, con lo que tendramos que hacer lo siguiente:
1 #include < iostream >
2 #include < cstdio >
3
4 using std :: cin ;
5 using std :: cout ;
6 using std :: endl ;
7
8 i n t main ()
9 {
10 double notas [10]
11 double nota2 ;
12 double nota3 ;
13 double nota4 ;
14 double nota5 ;
15 double nota6 ;
16 double nota7 ;
17 double nota8 ;
18 double nota9 ;
19 double nota10 ;
20 double promedio ;
21
22 cout << " Ingresa la nota 1: " ;
23 cin >> nota1 ;

14
24 cout << " Ingresa la nota 2: " ;
25 cin >> nota2 ;
26 cout << " Ingresa la nota 3: " ;
27 cin >> nota3 ;
28 cout << " Ingresa la nota 4: " ;
29 cin >> nota4 ;
30 cout << " Ingresa la nota 5: " ;
31 cin >> nota5 ;
32 cout << " Ingresa la nota 6: " ;
33 cin >> nota6 ;
34 cout << " Ingresa la nota 7: " ;
35 cin >> nota7 ;
36 cout << " Ingresa la nota 8: " ;
37 cin >> nota8 ;
38 cout << " Ingresa la nota 9: " ;
39 cin >> nota9 ;
40 cout << " Ingresa la nota 10: " ;
41 cin >> nota10 ;
42 promedio = ( nota1 + nota2 + nota3 + nota4 + nota5 + nota6 + nota7 +
43 nota8 + nota9 + nota10 ) / 10;
44 cout << " El promedio es " << promedio << endl ;
45
46 getchar ();
47 getchar ();
48 return 0;
49 }

Notese que para en C++, una lnea de codigo no termina sino hasta que aparece un ;, por lo que es
conveniente partir una lnea en dos o m
as cuando esta se sale de la pantalla, como hicimos en las lneas 42
y 43.
El anterior es un programa bastante tedioso de teclear, as que, por que mejor no usar arreglos para convertir
diez voluminosas declaraciones en una sola? Es una buena idea (se dice que una virtud del buen programador
es la pereza, porque as siempre busca hacer mas con menos esfuerzo), as que hagamoslo. Nuestro programita
se transforma en el siguiente:
1 #include < iostream >
2 #include < cstdio >
3
4 using std :: cin ;
5 using std :: cout ;
6 using std :: endl ;
7
8 i n t main ()
9 {
10 double notas [10];
11 double promedio ;
12
13 cout << " Ingresa la nota 1: " ;
14 cin >> notas [0];
15 cout << " Ingresa la nota 2: " ;
16 cin >> notas [1];
17 cout << " Ingresa la nota 3: " ;
18 cin >> notas [2];
19 cout << " Ingresa la nota 4: " ;
20 cin >> notas [3];
21 cout << " Ingresa la nota 5: " ;
22 cin >> notas [4];
23 cout << " Ingresa la nota 6: " ;

15
24 cin >> notas [5];
25 cout << " Ingresa la nota 7: " ;
26 cin >> notas [6];
27 cout << " Ingresa la nota 8: " ;
28 cin >> notas [7];
29 cout << " Ingresa la nota 9: " ;
30 cin >> notas [8];
31 cout << " Ingresa la nota 10: " ;
32 cin >> notas [9];
33 promedio = ( notas [0] + notas [1] + notas [2] + notas [3] + notas [4] +
34 notas [5] + notas [6] + notas [7] + notas [8] + notas [9]) / 10;
35 cout << " El promedio es " << promedio << endl ;
36
37 getchar ();
38 getchar ();
39 return 0;
40 }

Sin duda, el estudiante observara que cuando pedimos, por ejemplo, la nota 5, en realidad leemos la del
subndice 4. Este desfasamiento se debe a que, como ya mencionamos, el primer subndice del arreglo es 0,
pero a la mayor parte de los seres humanos les gusta empezar a contar con el 1 (es una fea costumbre que
nos heredaron los romanos, porque en el sistema numerico romano no existe el cero).
En esta version nos ahorramos muchas declaraciones y eso es un gran avance, pero sigue siendo incomodo
tener que pedirle al usuario un valor y leerlo, y repetir lo mismo diez veces. Es una tarea repetitiva y aburrida,
pero. . . Est
a, el estudiante, pensando lo mismo que nosotros? As es! Ciclos! Esta es la principal ventaja
de los arreglos: se puede usar el contador de un ciclo como subndice para el arreglo. Veamos como se hace
esto:
1 #include < iostream >
2 #include < cstdio >
3
4 using std :: cin ;
5 using std :: cout ;
6 using std :: endl ;
7
8 i n t main ()
9 {
10 double notas [10];
11 double promedio ;
12 i n t subindice ;
13
14 subindice = 0;
15 promedio = 0;
16
17 while ( subindice < 10) {
18 cout << " Ingresa la nota " << subindice + 1 << " : " ;
19 cin >> notas [ subindice ];
20 subindice = subindice + 1;
21 }
22
23 subindice = 0;
24
25 while ( subindice < 10) {
26 promedio = promedio + notas [ subindice ];
27 subindice = subindice + 1;
28 }
29
30 promedio = promedio / 10;

16
31
32 cout << " El promedio es " << promedio << endl ;
33
34 getchar ();
35 getchar ();
36 return 0;
37 }

Divertido, eh? A esto se le llama recorrer arreglos. Vamos a explicar las partes del codigo que pudieran
parecer mas complicadas.
En la lnea 10 declaramos nuestro arreglo notas, con una capacidad para 10 elementos de tipo double, en
la 11 declaramos la variable promedio para almacenar el promedio que calculemos y, ademas, en la lnea 12
declaramos la variable subindice, que sera el contador de los ciclos y el subndice del arreglo.
En la lnea 14 inicializamos a subindice con un cero y lo mismo hacemos con promedio.
En la lnea 17 comienza nuestro primer ciclo, cuya finalidad es leer las diez notas, por lo que la condici
on de
ejecucion es que sub
ndice sea menor que 10. En el ciclo, primero se le pide al usuario que ingrese la nota
n
umero subindice + 1, luego se lee esta en notas[subindice] (en la lnea 19) y finalmente, se incrementa
el contador subindice en 1, con lo que este ciclo se repetira diez veces.
Cuando termina el ciclo, las diez notas han sido ledas y, en la lnea 23, se vuelve a inicializar el contador
subindice, pues volveremos a usarlo en un ciclo mas, mismo que comienza en la lnea 25. Este ciclo va
sumando a promedio (en la lnea 26) cada una de las notas que antes fueron ledas; fue por esto que
habamos inicializado promedio con un cero en la lnea 15. Cuando termina el ciclo, no tenemos el promedio,
sino la suma de todas las notas, por lo que, en la lnea 30, dividimos esta suma entre 10 y se la volvemos a
asignar a promedio. En este punto, promedio tiene almacenado ya el promedio de las diez notas, por lo que
se lo mostramos al usuario y con esto, termina el programa.
El segundo ciclo fue para no escribir una suma gigantezca, como en las versiones anteriores. Podra ser que
el usuario considere que sera m
as sencillo escribir

promedio = (notas[0] + notas[1] + notas[2] + notas[3] + notas[4] +

notas[5] + notas[6] + notas[7] + notas[8] + notas[9]) / 10;

Tal vez en este caso particular tenga raz

on pero, y si se le pidiera calcular el promedio de 10000 notas?
Dejamos al estudiante imaginar lo agradable y productivo que sera escribir esa suma en su programa.

17