Administración de Sistemas Informático

Libro de entorno
a Programación
en lenguaje C.
U.E.S.L
Área Técnica

Prof. Daniel Villamar Avilés

 Introducción
El lenguaje de programación C, fue creado por Dennis Ritchie en el año 1972, siendo así uno de los
lenguajes de programación más antiguos y versátiles.
C sirve para realizar todo tipo de programas, incluso se puede utilizar para programar sistemas
operativos (por ejemplo Linux está programado en C). Esto es posible porque es un lenguaje de
bajo nivel, lo que quiere decir que nos permite conectar con información de la máquina, como
puede ser la memoria del ordenador, por ejemplo.
Otra de las características de C es que es un lenguaje de programación estructurado. Es decir, el
compilador que ejecuta nuestro programa en C irá "leyendo" las instrucciones del mismo de forma
estructurada, de arriba abajo.
Como ocurre con todos los lenguajes, para que el ordenador interprete el código del programa
tenemos que utilizar un compilador. Hay diversos compiladores para C, en la siguiente lección
veremos algunos.
La mayoría de programadores han empezado por aprender con este lenguaje, ya que es de los más
versátiles e importantes. Casi cualquier programa que se nos ocurra es muy posible que tenga
líneas de código en C. Es muy utilizado para todo.

¿Listos para aprender?

Compiladores del lenguaje C

Bien, lo primero que tenemos que hacer para crear nuestros propios programas en C es tener un
compilador para este lenguaje; será una herramienta que se encargará de ejecutar el código C en
un programa ejecutable, entendible por el ordenador.
Como podréis imaginar hay una amplia variedad de compiladores, algunos gratuitos, otros de
pago, etc... Evidentemente, en este curso vamos a utilizar un compilador gratuito y que además es
de los más reconocidos para C.

Hay muchos compiladores... por ejemplo, Turbo C++, DJGPP, Borland C++, etc...
Puedes utilizar cualquier compilador, pero recomendamos que si estás empezando utilices el
mismo que voy a utilizar durante el curso, así no te perderás.
El compilador que vamos a utilizar en este curso se llama Dev C++.

Esta es la única herramienta que necesitaremos para aprender a programar en C. En la siguiente

lección instalaremos el compilador en nuestro ordenador.

Anl. Sist. Daniel Villamar Avilés 1

 Instalando el compilador
Vamos a ponernos manos a la obra con la instalación del compilador. Partimos de la base de que
ya hemos descargado el archivo en la lección anterior, ahora vamos con la instalación. Es muy
sencillo, puesto que apenas hay que modificar cosas.
1- Doble click al archivo descargado:

2- Nos aparece la siguiente ventana, en la cual seleccionaremos nuestro idioma y después click en
"OK".

3- En la siguiente ventana simplemente aceptamos la licencia del programa.

4- En esta dejamos todo tal cual y click en "Siguiente".

Anl. Sist. Daniel Villamar Avilés 2
 5- Ahora seleccionamos la ruta en la que queremos que se instale nuestro compilador (es
preferible dejarlo tal cual está).

6- Se comenzará a instalar el compilador... y casi cuando esté acabando, nos aparecerá una
ventana para indicar si queremos que se instale para todos los usuarios del ordenador, click en "Si"
o "No", depende lo que quieras.

Anl. Sist. Daniel Villamar Avilés 3

 7- Ya está, hacemos click en "Terminar" en la siguiente ventana y ya se nos abrirá el compilador, si
hemos dejado tildada la casilla de "Ejecutar DevC++".

Esto es todo, ya tenemos el compilador de C instalado en nuestro ordenador. Tiene que verse así:

Por si algo no ha quedado del todo claro, ahora adjunto un vídeo donde se ve mejor el proceso
que hay que llevar a cabo para la instalación del compilador:

Anl. Sist. Daniel Villamar Avilés 4

 Primer programa en C
Una vez instalado el compilador podemos empezar a meternos en la práctica, que es como
realmente se aprende a programar: programando.
No te preocupes si al principio te cuesta captar los conceptos básicos de la programación o si hay
líneas de código que no entiendes, es normal, al empezar vas a ver ciertas cosas que no se pueden
explicar en este momento que no sabes nada, porque son conceptos que se aprenderán
posteriormente en el curso. Así que por eso no te preocupes.
Como ya hemos aclarado, C es un lenguaje estructurado que se escribe por instrucciones de
programación, y cada instrucción acabará con un ";" al final, que indica el final de la instrucción y
que pasará a ejecutarse la siguiente.

Veamos como queda nuestro primer programa:

Lo único que hace este programa es mostrar la frase "Hola Mundo" en la consola de nuestro
Windows.
Para ejecutar nuestro programa pulsamos la tecla F9 o bien vamos al Menú ejecutar > compilar y
ejecutar.
Primero quiero dejar claro que las frases que llevan antes "//" son cosas que el compilador no
ejecuta. Esto se llama comentarios, y nos sirven para que nosotros mismos, los programadores,
sepamos que hace cada instrucción. En este tipo de programas no, pero imaginad un programa de
más de 3000 líneas de código; éste tendría que tener comentarios aclaratorios para que no se
convierta en un caos.

Bien, empezamos a analizar el código (ya os digo que no temáis si no entendéis cosas ahora, es
completamente normal, a todos nos ha pasado).

#include <stdio.h>
#include <stdlib.h>
Estos "#includes" hacen referencia a librerías. Las librerías las veremos más adelante, por lo que ya
entenderéis por qué están ahí. De momento ponedlas sin más, porque son necesarias para que
funcione el programa.

Anl. Sist. Daniel Villamar Avilés 5

 int main()
{
...
}
Esto es la función "main", es decir, la función principal del programa. Todo lo que esté dentro de {
... } del main es lo que se va a ejecutar cuando ejecutemos el programa. Por eso, todo programa
debe llevar su "main".

printf("Hola Mundo. \n");

printf es una función que nos permite escribir por pantalla. Escribiremos entre paréntesis y
comillas como veis, la frase a mostrar, y el programa la mostrará. Aclaro que el "\n" es equivalente
a un salto de línea en la consola de Windows.
system("PAUSE");

Y esta instrucción dejará en pausa a la consola de Windows hasta que pulsemos una tecla para que
se cierre. Comprobad si queréis que si quitáis el "pause", la consola se cerrará nada más ejecutar
el programa, por lo que no podremos ver el contenido de nuestro programa.

Adjunto el archivo del código fuente:

PrimerPrograma.cpp

NOTA: Guarda los archivos de los códigos fuente en una

carpeta que tengas bien localizada. Recuerda que los
archivos de programas en C tienen la extensión "cpp".

Para aclarar un poco mejor todo, vamos a ver un vídeo donde se realizan diversos cambios en el
código para que se aprecien esos cambios en el programa.

Anl. Sist. Daniel Villamar Avilés 6

 Tipos de datos (variables)
Los tipos de datos, la información que manipularemos en C, serán variables. Estas variables
pueden ser de diferentes tipos. Vamos a ver las más comunes. Hay que decir que generalmente en
todos los lenguajes de programación son los mismos tipos o muy parecidos.

Empezamos con los datos numéricos, que pueden ser:

-Tipo entero (int): estas variables contienen datos numéricos enteros.

-Tipo float: son datos numéricos con decimales.

-Tipo double: también contienen datos numéricos con decimales, pero a diferencia del float,
estas variables son de más tamaño, es decir, que pueden almacenar números más grandes.
Y luego estarían los datos referentes a las caracteres o cadenas:

-Tipo char: estas variables contienen un solo carácter. Por ejemplo: A, h, b, 1, 5... lo que sea,
pero solo un dígito.

-Tipo string: son cadenas de caracteres, no es un tipo de datos como tal, pero ya veremos más
adelante cómo se utilizan.

Para crear las variables y asignarles valores se hace de la siguiente forma:

<tipo_de_variable> <nombre_variable> = <valor>

Esa es la estructura a seguir, en C quedarían así algunos ejemplos:

int num = 7;
char caracter = 'b'
Tiene que quedar muy claro que si en el programa queremos almacenar un número tipo int, dicha
variable tiene que ser tipo int, no puede ser tipo char o double. C es muy inflexible en eso, los
datos tienen que estar claramente distinguidos.
Por ejemplo, NO podemos hacer lo siguiente:
int num = 10.95;
Nos dará error, porque el valor es un número con decimales, por lo que tendremos que utilizar un
double o float.

Por último un tipo de dato diferente, dato bool, que puede tomar solo dos valores "true" o
"false", es decir, verdadero o falso.
No os preocupéis que todo esto se va a poner en práctica en la siguiente lección, donde enteréis
mejor el uso de las variables.

Anl. Sist. Daniel Villamar Avilés 7

 Mostrando datos por pantalla
Vamos a aprender ahora a crear variables, darles valor y mostrar ese valor por pantalla. De esta
forma sabemos qué valor contiene cada variable.
Haremos un programa muy simple en el que crearemos 2 variables de diferente tipo, le
asignaremos un valor y lo mostraremos por pantalla.
El código es el siguiente:

Recordad los comentarios que voy poniendo en el código, son muy útiles para que sepáis qué está
realizando cada instrucción del programa.
Cabe decir que la creación y asignación de las variables se pueden hacer en una sola línea también,
eso lo podéis hacer como queráis. En este caso, lo hice aparte para que se vea un poco más claro,
pero también se puede hacer lo siguiente:
int num = 10;

Es lo mismo. El programa funcionará igualmente.

Lo novedoso de esta lección es la muestra por pantalla de valores que hemos dado a nuestras
variables, esto se hace a través del printf, como se ve en el código. Esto funciona de la siguiente
manera:

printf("<texto_a_mostrar>", <variables_a_mostrar>)

Anl. Sist. Daniel Villamar Avilés 8

 Entre comillas se escribe el texto que se mostrará, y cuando se quiera mostrar una variable se hace
con el "%". La letra que lleva detrás cambiará dependiendo del tipo de dato que utilicemos. En la
siguiente tabla veréis las letras para cada tipo:

int -> %i

char -> %c

float -> %f

double -> %f

Para los dos últimos se utiliza el mismo.

Bueno, y retomando la muestra de los valores, una vez hayamos escrito el texto entre las comillas
luego vendrá una "," para separar, y a continuación el nombre de la variable a mostrar... como
podéis apreciar en el código.
Debéis saber que se pueden mostrar ambas variables en un solo "printf", todo es saber manejar la
sintaxis del printf, en el video podéis comprobar cómo hacerlo.
Aquí dejo el código fuente para que practiquéis, haciendo cambios y probando cosas, como por
ejemplo modificar los valores de las variables o crear otras variables y mostrarlas en un solo
printf:

Anl. Sist. Daniel Villamar Avilés 9

 Constantes
Veremos ahora un tipo de variables que son especiales, por eso no las he metido en la lección de
tipos de datos. Estas variables pueden ser de cualquier tipo, pero con la característica que tendrán
un valor constante, como su propio nombre indica.
Tenemos que tener claro que este valor no se va a poder modificar en todo el programa. Las
constantes son muy útiles por ejemplo para valores como PI.
Vamos a ver un ejemplo:

Como veis, las constantes se definen en la parte superior, debajo de los "includes". La estructura
es la siguiente:

#define <nombre_constante> <valor_constante>

Se escribe así todo directamente, no hace falta utilizar "=" para asignar el valor a la constante.
Este sencillo programa lo que hace es multiplicar 3 por PI y mostrarlo por pantalla.
En el video comprobaremos que no se puede cambiar el valor de la constante, y también se verá
una forma más corta de realizar el ejercicio, que es mostrando directamente en el "printf" el valor
de 3 por PI, de forma que nos podemos saltar la asignación del resultado a la variable "num",
incluso podemos obviar la creación de la variable "num"... y hacerlo todo directamente, de esta
forma:

printf( "El resultado es: %f \n", 3 * PI);

Recordad que ahora, al ser un número con decimales, utilizamos el "%f" para mostrarlo.
Código fuente:

Descargar Constantes.cpp

Anl. Sist. Daniel Villamar Avilés 10

 Operadores aritméticos
Hasta el momento, en las variables que hemos utilizado no hemos modificado su valor,
simplemente le dábamos un valor manualmente y lo mostrábamos por pantalla. Es el momento de
ver los operadores, que nos servirán para hacer operaciones con las variables.
Los operadores aritméticos que podemos utilizar son los siguientes:

Todo esto en cuanto a teoría. Ahora veamos cómo se aplica a nuestras variables de un programa
en C. Vamos a realizar un ejercicio donde hay 2 números, y estos dos números se sumen, resten,
multipliquen y dividan; y todo lo que vayamos haciendo, se mostrará por pantalla.
El código es el siguiente (puede parecer un poco grande, pero no os asustéis, ya que realmente
siempre se realiza lo mismo, solo vamos cambiando el operador en cada caso):

Anl. Sist. Daniel Villamar Avilés 11

 Creamos 3 variables, dos para cada número, y una variable para ir guardando el resultado de cada
operación. Se hace la suma de dos números, se guarda en la variable "resultado" y se muestra... se
resta, se guarda en "resultado" y se muestra... y así sucesivamente.
A lo mejor estabais pensando que habría que crear una variable de "resultado" para cada
operación, es decir, crear 4 variables de resultado. Pero no, esto es así porque cada vez que
mostramos el resultado después el valor se machaca en la siguiente asignación de la variable
"resultado"...

Como siempre adjunto el código fuente para que experimentéis, que así también se aprende
mucho.
Descargar codigo OperadoresAritmeticos.cpp

Y por supuesto, un vídeo en el que veréis el resultado del programa y algunos cambios que podéis
hacer al código para entender mejor el funcionamiento de dichos operadores:

Anl. Sist. Daniel Villamar Avilés 12

 Operadores de comparación
Ya que estamos con los tipos de operadores que nos ofrece C, vamos ahora a ver los operadores
de comparación, aunque éstos no los podremos poner en uso hasta más adelante, cuando se
estudien las sentencias IF, SWITCH... que son sentencias de control.

Así que vamos con la teoría. Bien, estos operadores se utilizan para comparar. Compararemos
valores de variables por ejemplo para saber si una variable contiene el mismo valor que otra
variable. Estos operadores se utilizan para comprobar si una condición se cumple o no.
Suponiendo que tenemos la variable "a" y variable "b":

Esto es lo que podemos ver en cuanto a teoría. Como ya he dicho anteriormente, primero
tenemos que ver las sentencias de control para aprender realmente a poner todo esto en práctica.
Aunque como se ve en la tabla, no tiene mucha complicación, son comparaciones básicas entre
variables

Operadores lógicos
Como ocurre en la anterior lección, esta también va a ser meramente teórica, ya que tampoco
podemos ponerla en uso con los conocimientos aprendidos hasta ahora. Estos son operadores que
se utilizan para comparar más de dos condiciones.
Os dejo la tabla de los 3 operadores lógicos que vamos a ver. Ahora vamos a suponer que tenemos
4 variables, como pueden ser 'a', 'b', 'c', 'd'.

Anl. Sist. Daniel Villamar Avilés 13

 En los ejemplos solo se hacen comparaciones de dos condiciones, pero se pueden hacer de más de
dos... de hecho, de todas las necesarias.
Por ejemplo:
a == b && a > d && b != d
Esto se cumpliría solo si se dan las 3 condiciones, es decir, si 'a' es igual que 'b', y 'a' es mayor que
'd', y también, 'b' es distinto de 'd'.

En cambio, en el caso del segundo operador (||), se cumpliría con que una de todas las
condiciones fuera correcta.

Y el operador (!) nos sirve para negar cualquier condición. Recordad meter dicha condición entre
paréntesis.

Repito que estos operadores aún no se pueden entender bien del todo hasta que no los pongamos
en práctica más adelante. No os preocupéis que en las lecciones correspondientes os quedará
todo mucho más claro.

Ejercicio nº 1
Llegados a este punto vamos a elaborar un ejercicio para poner en práctica lo que sabemos hasta
ahora.
A lo largo del curso iré haciendo algún que otro ejercicio para que podáis practicar por vosotros
mismos y se os queden mejor los conceptos de programación. No os preocupéis que en la
siguiente lección estará la solución a este ejercicio.
Sin más preámbulos, vamos con el enunciado del ejercicio:

EJERCICIO Nº 1
Realiza un programa con 3 variables, dos para números enteros, y otra
llamada "resultado". Inicializa las variables numéricas con los valores 7
y 2, respectivamente y:
-Muestra por pantalla la resta de estos dos números.
-Muestra por pantalla la suma de estos dos números, multiplicada por
10. Y ese 10, será el valor de una constante creada con anterioridad por
nosotros.
-Intenta realizar el mismo ejercicio sin la creación de la variable
"resultado".

Anl. Sist. Daniel Villamar Avilés 14

 El resultado del programa es el siguiente:

Procurad realizar el programa vosotros solos, y luego comprobáis la solución en la siguiente

lección. Os recomiendo que lo hagáis así, que es como realmente aprenderéis de verdad a
programar... fallando y probando las veces que haga falta.

Solución ejercicio nº 1
Si ya has hecho el ejercicio propuesto en la lección anterior, aquí puedes ver la solución.
Según su enunciado, podíamos hacer el ejercicio con la variable "resultado", y mejorar el
programa haciéndolo más eficiente ahorrándonos hacer la variable "resultado". Veamos las dos
formas:
Con la variable resultado

Anl. Sist. Daniel Villamar Avilés 15

 Recordad que lo primero es crear la constante DIEZ, con el valor 10, obviamente.
El resto del ejercicio ya lo veis resuelto en la imagen. Primero creamos todas las variables, luego
las inicializamos con los valores correspondientes.
Mostramos la resta de los dos primeros números. Luego metemos en la variable "resultado" la
suma de los dos números, para más tarde multiplicarla por la constante DIEZ, como nos indicaba el
ejercicio.
Esta forma es más sencilla de entender, pero si lo hacemos sin la variable "resultado" podemos
ahorrar recursos y es más eficaz.

Sin la variable resultado

Fijaos que no nos hace falta para nada la variable "resultado".

Directamente en el printf se puede realizar la operación de sumar los dos números y multiplicar
por la constante DIEZ. Eso si, hay que meter la suma de ambos números entre paréntesis, por
principio matemático, como ya sabréis.
Si hubiéramos puesto esto:
num1 + num2 * DIEZ

Primero se ejecutaría DIEZ * num2 y luego el resultado de eso se sumaria a num1, y no es eso
lo que queremos.

Os adjunto el código de ambas soluciones, por si tenéis algún problema:

Descargar código fuente Ejercicio1.cpp

Descargar código fuente Ejercicio1(2).cpp

Anl. Sist. Daniel Villamar Avilés 16

 Introduciendo datos por teclado
Hasta el momento, el valor de las variables los hemos puesto nosotros mismos. Ahora veremos de
qué forma hacer para que el propio usuario que utilice el programa dé valores a nuestras
variables.
Para guardar valores dados por el usuario en una variable se utilizará la función scanf.
Vamos a ver un ejemplo en el que el usuario introduzca el número que quiera por teclado, y ese
mismo número, lo mostraremos por pantalla:

Creamos la variable "num", indicamos al usuario a través de un mensaje por pantalla que
introduzca un número... y ahora viene la nueva instrucción que analizaremos:

scanf( "%i", &num );

En el valor entre comillas escribiremos el "%" y la letra adecuada para cada tipo de dato, y luego,
separado por una "," escribimos el nombre de la variable donde queremos que se guarde ese
número, en este caso "num", y fijaos que delante tiene un "&". Es necesario ponerlo, aunque
ahora no entendáis bien el por qué. Se entenderá cuando veamos los punteros unas lecciones
más adelante.

Este programa lo único que hace es mostrar por pantalla ese número tecleado por el usuario.

Ahora bien, si lo que queremos es meter un carácter, ya no nos sirve esta función. Para ello,
tendremos que hacer otro procedimiento. Se lleva a cabo con la función getche();
Veamos un ejemplo para introducir un carácter.

Anl. Sist. Daniel Villamar Avilés 17

 Lo primero que tenemos que hacer es introducir otro "include", en este caso: conio.h. ya que sin
esta librería (que es de lo que se encargan los includes, de incluir librerías) el programa no
funcionaría, porque la función getche(); está incluida en esa librería. Todo esto de funciones y
librerías se entenderá posteriormente en siguientes lecciones.
Lo que cambia de este programa al anterior es que ahora para recoger el carácter tecleado por el
usuario, se hace a través de una asignación, como veis en el código:

caracter = getche();

De esta forma se guarda en la variable "caracter" el valor introducido por el usuario.

Adjunto ambos programas:

Descargar IntroduciendoDatosPorTeclado.cpp
Descargar IntroduciendoDatosPorTeclado2.cpp

Y para acabar, un vídeo de cómo funcionan ambos programas:

Anl. Sist. Daniel Villamar Avilés 18

 Sentencia If
En esta lección nos metemos ya con lo que son las sentencias de flujo de control del programa.
Estas sentencias son condiciones, y ahora, dependiendo si se cumple esta condición o no, el
programa tomará un rumbo u otro, de ahí que se les denomine sentencias de control de flujo.
Estas sentencias tienen la siguiente estructura:

if (condicion)
{
... //Aquí las instrucciones se ejecutarán solo si se cumple la
condición}

Y eso es todo. Simplemente ponemos la condición entre paréntesis y dentro de los corchetes "{ ...
}" escribiremos el código que ejecutaremos si esa condición se cumple.
Veamos cómo funciona con un ejemplo práctico:

Este programa pedirá al usuario que introduzca un número, luego pondremos una condición "si el
número del usuario es mayor que 5...", y si es correcto escribiremos por pantalla que
efectivamente, ese número introducido es mayor a 5. Si no, no ocurrirá nada y el programa
acabará. En la siguiente lección veremos como hacer que si no se cumple la condición se ejecuten
otras instrucciones.

Como veis, en la condición se utilizan los operadores de comparación, en este caso el operador ">"
que nos servirá para comprobar si el número es mayor que 5. Con este sencillo programa espero
que se haya entendido bien la finalidad de los "If".

Descargar If.cpp
Vídeo del funcionamiento del programa:
Anl. Sist. Daniel Villamar Avilés 19
 Sentencia If... Else
En la lección anterior hemos visto como es una sentencia IF simple, ahora vamos a ver como
completarla con un ELSE. De esta forma podemos hacer que cuando la condición se cumpla se
ejecuten ciertas instrucciones, y cuando no se cumpla, se ejecuten otras instrucciones,
dependiendo del caso.
Siguiendo con el ejemplo anterior, recordad que el programa escribía por pantalla cuando el
número introducido por el usuario era mayor a 5. Pero... ¿y si es menor?
Pues si es menor, vamos a hacer que también se nos avise por pantalla, gracias al "else".

Cuando acabe el IF añadimos ELSE, también encerrado entre { ... }. Ahí dentro escribiremos las
instrucciones que queremos ejecutar si no se cumple la condición. En este caso, escribimos por
pantalla que el número es menor que 5.
Ahora bien, ¿y si el número introducido fuese el 5? El programa no mostraría nada, porque el
número ni es mayor, ni es menor que el 5, por lo tanto no ejecutaría ni las instrucciones del IF ni
del ELSE.
Para estos casos, podemos hacer un IF/ELSE anidados, de forma que en el ELSE podemos
introducir otro IF, y así con cuantas condiciones queramos.
Veamos un ejemplo:

Anl. Sist. Daniel Villamar Avilés 20

 El ELSE IF (num < 5) comprobará si el número es menor que 5, y debajo ponemos el ELSE, que se
ejecutará si el número no es mayor ni es menor que 5, es decir, si el número es 5. Mostramos por
pantalla que el número es 5 y listo.

Se pueden poner tantos ELSE IF como se quiera, aunque en este ejemplo solo es necesario uno, se
pueden dar ocasiones en las que se necesiten más.

Descargar IfElse.cpp

Descargar IfElse2.cpp

Y aquí el vídeo donde se muestra el funcionamiento del programa:

Anl. Sist. Daniel Villamar Avilés 21

 Sentencia Switch
Seguimos con las sentencias de control de flujo del programa. En esta lección aprenderemos a
utilizar una sentencia switch.

Esta sentencia sirve para crear muchas condiciones de igualdad. Es útil por ejemplo para la
creación de un menú. Imaginad que tenemos un menú con 4 opciones. Pues con el switch
podemos hacer que dependiendo de la opción que elijas se ejecute un código u otro.
La estructura del switch es la siguiente:

switch (<variable>)
{
case 1:
// código que se ejecuta si elige la opción 1
break;
case 2:
// código que se ejecuta si elige la opción 2
break;
...
}
Y así con todas las opciones que queramos introducir. Si el usuario no elige una opción del 1 al 4,
entonces se podría ejecutar otro código diferente; lo haremos a través de un "default" que se
pondrá al final de todas las opciones, como vamos a ver en el ejemplo práctico de C.

Anl. Sist. Daniel Villamar Avilés 22

 Es necesario poner el "break" después de cada "case", ya que esto hará que una vez se ejecute
el código que hay en ese "case" el programa se salga del switch, saltándose el resto de código
que tenga por debajo del "break".

Lo que hacemos es crear la variable "num", pedir al usuario que introduzca un número y lo
asignamos a la variable "num". Luego switch comprueba que número ha sido el introducido por el
usuario, y dependiendo del número, nos muestra una cosa u otra por pantalla.

Este tipo de sentencias solo vale para igualdades, es decir, no podemos poner en un case: num < 5.
Realmente case 1, significa: si num es igual a 1... y así con todas las opciones.

Descargar Switch.cpp

Veamos el funcionamiento de switch en el siguiente vídeo:

Anl. Sist. Daniel Villamar Avilés 23

 Sentencias de salto
Las sentencias de salto no son muy utilizadas para este tipo de lenguajes porque son
estructurados, y no conviene que el programa dé "saltos". Con "saltos" me refiero a que se salte
instrucciones.

A través de una sentencia "go to" podemos hacer que el programa vaya hasta otro punto del
código a ejecutar instrucciones, por ejemplo:

Para hacer el salto escribiremos lo siguiente:

goto <nombre_etiqueta>

El nombre_etiqueta podemos escribirlo de la forma que queramos, dependiendo de la

ocasión, en este caso, se llama etiqueta1.

Para crear dicha etiqueta simplemente escribimos el nombre en el punto exacto que queramos
crear la etiqueta seguida de ":", como veis en el ejemplo.

El compilador de C irá ejecutando instrucciones una a una, de arriba hacia abajo. Cuando llegue al
"go to", busca el nombre de la etiqueta, automáticamente se va hasta donde esté creada la
misma, y continúa ejecutando instrucciones a partir de ahí.

En el caso del programa, "num" tendrá el valor 1, porque la asignación se la salta el "go to", como
se puede observar.

Un ejemplo un poco más práctico y útil para el "go to" sería el siguiente:
Anl. Sist. Daniel Villamar Avilés 24
 En este ejemplo vamos a pedir al usuario que introduzca un número menor que 10. Si introduce el
número menor que 10, el programa acabará; y si no es menor que 10 pondremos un "go to" a una
etiqueta creada al inicio para que nos vuelva a pedir que introduzcamos un número... de esta
forma conseguimos que el programa nos pregunte siempre que no metamos lo que nos pide, o
sea, un número menor que 10.

Para ver mejor el funcionamiento de estos programas adjunto el código fuente.

Descargar GoTo.cpp
Descargar GoTo2.cpp

Y aquí el vídeo de ambos ejercicios:

Anl. Sist. Daniel Villamar Avilés 25

 Bucle For
Pasamos ahora a las sentencias de bucles. Estos bucles nos permiten ejecutar instrucciones un
determinado número de veces. Imagina que queremos escribir por pantalla los números del 1 al
10 por ejemplo.
Sería muy tedioso hacer:

printf("1");
printf("2");
printf("3");
etc...

Bien, para eso están los bucles, para realizar instrucciones un determinado número de veces de
forma sencilla.
El ejemplo que hemos puesto vamos a realizarlo con un bucle "for".

La estructura del "for" es la siguiente:

for (<valor_inicial>; <condicion>; <incremento>)

{
//Instrucciones a ejecutar "x" número de veces
}

En <valor_inicial> vamos a darle a una variable ya creada el número por el que queremos que
empiece, en este caso será 1. La condición, si se cumple, ejecutará las instrucciones del "for", y si
no, pues ya sale del "for".

En este caso queremos que se cumpla 10 veces, por tanto, ponemos si "i" es menor que 10. Y en
"<incremento>" lo que haremos es incrementar la variable "i" en 1.

Anl. Sist. Daniel Villamar Avilés 26

 Dentro del "for", simplemente mostramos la variable "i", que irá teniendo los valores del 1 al 10.

Explico como funciona el "for":

Primero se asigna el valor inicial a la variable "i", en este caso, 1. Bien, ahora se ejecuta la
condición: Si "i" es menor o igual que 10, de manera que ahora "i" vale 1; ¿es menor o igual que
10? Sí, pues se ejecuta lo de dentro, es decir, se muestra por pantalla el 1.

Al terminar, el "for" hace el <incremento> de la variable "i", por lo tanto ahora "i" vale 2.

Y misma operación: se ejecuta la condición... ¿"i" es menor o igual que 10? Como "i" vale 2, sí, es
menor que 10. Entra dentro del "for" y muestra la "i", el 2, por pantalla. Ahora se incrementa, y la
"i" vale 3... y así sucesivamente hasta llegar a 10, momento en el que la condición deja de
cumplirse y se acaba el "for".

Descargar For.cpp

Vídeo donde se muestra su funcionamiento:

Anl. Sist. Daniel Villamar Avilés 27

 Bucle While
Seguimos con los bucles. Todos los bucles sirven para lo mismo, lo único que cambia es la
estructura, y a veces es más recomendable utilizar uno u otro.

Vamos ahora con un bucle While. En este tipo de bucles, el aumento de la variable (o disminución)
se debe realizar dentro del mismo bucle, y la variable no se inicializa en el propio bucle, como
ocurría en el "for".

La estructura del bucle While es la siguiente:

while (<condicion/es>)
{
//Instrucciones a ejecutar en el bucle
}

Como se puede apreciar, aquí el bucle se ejecuta si se cumple la condición sin más.
Vamos a crear el mismo ejemplo que hicimos para el "for", pero ahora utilizando un bucle "While"
para que se vea la diferencia.

Escribimos los números del 1 al 10 por pantalla.

Inicializamos a "i" en 1. La condición sigue siendo la misma: si "i" es menor o igual que 10 entra en
el bucle.

Y fijaos que dentro del propio bucle aumentamos el valor de "i" en 1. Esto es muy importante, ya
que si no cambiamos el valor de "i" (el valor que interactúa en la condición) podemos entrar en un
bucle infinito, puesto que siempre se cumplirá la condición, porque "i" siempre sería 1. Hay que
tener cuidado con eso.

Anl. Sist. Daniel Villamar Avilés 28

 Ahora bien, como ya indicamos en la lección de los operadores lógicos, a la hora de elaborar
condiciones se pueden poner más de una, y de dos... todas las que queramos.

Vamos a hacer este mismo ejercicio pero con 2 condiciones. Crearemos una variable tipo "bool"
con el valor de "true" (verdadero). Y en la condición del While, añadiremos que la variable bool
sea verdadera, para que entre al bucle.

De esta forma:

El While ahora tiene que cumplir ambas condiciones para que se ejecute el bucle. El operador
utilizado es el "&&", recordad que significa "y"; es decir, si "i" es menor o igual que 10 y "b" es
igual a "true", y como "b" siempre va a ser "true" (porque no se modifica en el bucle), pues va a
entrar al bucle siempre y cuando "i" sea menor o igual que 10. O sea, que ahora mismo el
programa funcionará de la misma forma que anteriormente. Pero es para que se vea que se puede
utilizar más de una condición.

¿Qué pasaría si en vez de "&&" ponemos el operador "||"? Este operador significa "o", es decir,
que entraría al bucle si se cumple una de las dos condiciones. No nos conviene ponerlo ahora
mismo porque "b" siempre es "true"... entonces el bucle se ejecutaría SIEMPRE, por tanto,
entramos en bucle infinito. Si quisiéramos poner ese operador en este ejemplo, habría que
cambiar la variable "b" en algún momento.

Descargar While.cpp
Descargar While2.cpp

Y aquí el vídeo del funcionamiento de ambos ejemplos:

Anl. Sist. Daniel Villamar Avilés 29

 Bucle Do/While
Este es el último tipo de bucle que vamos a ver. Realmente casi nunca se utiliza, puesto que ya con
el "for" y el "while" se puede hacer de todo. Este está en desuso, pero aún así lo explico, ya que
tiene una particularidad reseñable.

En este tipo de bucle se ejecutan al menos una vez las instrucciones del bucle, y esto no se
sucede en los dos anteriores. Aquí ocurre esto porque el programa comprueba la condición del
bucle después de ya haberse ejecutado una vez.

La estructura es la siguiente:

do
{
//Instrucciones del bucle
}
while (<condicion/es>));

Cuando el programa llega a estas líneas de código lo primero que hace es ejecutar lo que hay
dentro del "do", se cumpla la condición o no, y después comprueba si la condición se cumple; si se
cumple, sigue ejecutando lo que hay dentro del "do", si no se cumple, sale del bucle.
Ejemplo para mostrar los números del 1 al 10.

Muy similar a los otros dos ejemplos, como ya os podéis imaginar, solo que ahora utilizamos el
do/while.

Descargar dowhile.cpp
En el vídeo de muestra veréis como se ejecuta siempre una vez lo que hay dentro del "do";
cambiaremos la condición del while para que no se cumpla, y aún así, ejecutará una vez la
instrucción, o sea, que se mostrará un 1 por pantalla.
Anl. Sist. Daniel Villamar Avilés 30
 Ejercicio nº 2
Pasamos al 2º ejercicio. Esta vez será un ejercicio más complicado y más práctico que el anterior.

EJERCICIO Nº2
Realiza un programa que contenga un menú de 3 opciones. Estas
opciones serán 1, 2 y 3. Si el usuario introduce el número 0, el
programa acabará, pero mientras elija una opción válida que no sea el 0
el programa debe seguir.
Estaría bien que si introduce una opción que no sea del menú, o sea, ni
1, ni 2, ni 3, el programa te avisara.
Es decir, que el resultado del programa tiene que ser como se aprecia
en el vídeo en la parte inferior de la lección.

¿Serás capaz de hacerlo? En la siguiente lección tienes la solución.

¡Ánimo!

Vídeo que demuestra cómo ha de quedar el programa:

Solución ejercicio nº 2
Espero que hayas dado con la solución para el ejercicio nº 2, y si no, aquí la tienes. El truco para
que el programa no acabara y siempre te pregunte para introducir una opción del menú es la de
crear el "menú" dentro de un bucle, con la condición de que el número introducido sea distinto a
0. Ya que cuando el usuario introduzca un 0, el programa acabará.

El resultado final es este:

Anl. Sist. Daniel Villamar Avilés 31

 Primero, inicializamos la variable "n" en 1, para que sea distinto de 0 y entre en el While por
primera vez.
Ahora, pedimos al usuario que introduzca un número. Dependiendo del número que sea
mostraremos por pantalla lo que nos convenga, gracias al Switch.
Si es 0 indicaremos que has salido del programa, si es 1 has elegido la opción 1... y así con todas las
opciones posibles. Recordad que el 'default' se ejecutará cuando el usuario introduzca algo
diferente a los otros 'case'.

Podéis descargar el código del ejercicio para estudiarlo más detenidamente.

Descargar Ejercicio2.cpp

Anl. Sist. Daniel Villamar Avilés 32