Embed Size (px)
Citation preview
Primer programa en C
Oir Lecc.
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.
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.
Tipos de datos (variables)
Oir Lecc.
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.
Mostrando datos por pantalla
Oir Lecc.
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>)
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:
Constantes
Oir Lecc.
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.
Operadores aritméticos
Oir Lecc.
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 como 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):
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:
Operadores de comparación
Oir Lecc.
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
Oir Lecc.
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'.
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
Oir Lecc.
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".
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
Oir Lecc.
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
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.
Introduciendo datos por teclado
Oir Lecc.
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.
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.
Sentencia If
Oir Lecc.
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 como 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".
Sentencia If... Else
Oir Lecc.
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:
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.
Sentencia Switch
Oir Lecc.
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.
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.
Sentencias de salto
Oir Lecc.
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:
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.
Bucle For
Oir Lecc.
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.
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".
Bucle While
Oir Lecc.
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.
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 verdadero, 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.
Bucle Do/While
Oir Lecc.
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.
Ejercicio nº 2
Oir Lecc.
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!
Solución ejercicio nº 2
Oir Lecc.
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:
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'.
Funciones y librerías
Oir Lecc.
Entramos en una parte importante de los lenguajes de programación, las funciones. Las
funciones nos permiten abstraer el contenido de lo que vayamos a programar, es decir, si
por ejemplo nuestro programa tiene que hacer muchas sumas de dos números, podríamos
hacer una función de suma, y esta sería reutilizable.
El ejemplo de la suma precisamente no es un buen ejemplo práctico, ya que podemos sumar
fácilmente con lo que nos ofrece el lenguaje de programación, pero es para que se entienda
el uso de funciones.
Las funciones en C, se declaran justo después de poner los "#include" necesarios y antes de
la función "main" principal. La estructura de una función es la siguiente:
<tipo_de_dato_a_devolver> <nombre_funcion> (<parametros>)
{
//Contenido de la función
}
Hay varios tipos de funciones, están las que devuelven un valor y las que no devuelven
nada. Y en cuanto a parámetros, podemos pasarle a la función todos los parámetros que
creamos conveniente, separados por una coma.
Una vez conocidas las funciones, ahora podéis empezar a comprender el uso de las librerías
en C. Las librerías no son más que un conjunto de funciones, por lo tanto, si estamos
utilizando una función de una librería que no está incluida, el compilador dará error, ya que
esa función no está declarada.
Por ejemplo, el printf que tanto hemos usado, ya os habréis dado cuenta de que es una
función... se encarga de mostrar por pantalla lo que le indiquemos y recibe varios
parámetros, primero el texto a mostrar, y luego las variables a mostrar.
Así como el system("PAUSE"); que también es una función y que se encarga de pausar el
programa para permitirnos ver el resultado por pantalla hasta pulsar una tecla para salir.
Ahora bien, esas son funciones ya preprogramadas, pero también podemos crear nuestras
propias funciones en función de lo que necesitemos, y eso es lo que vamos a aprender en
las siguientes lecciones.
Funciones sin retorno
Oir Lecc.
Vamos a ver un ejemplo práctico de una función, pero primero recordad que hay que
declararla antes del "main"; y luego podrá ser llamada cuando se necesite desde el "main".
Veamos como se construye la función:
En este caso he creado una muy facilita, una función que simplemente suma dos números
recibidos por parámetro y muestra el resultado de la suma por pantalla:
Esto es solo el código de la función, luego mostraremos el del ejercicio completo.
La cabecera de la función es la siguiente, recordad:
<tipo_de_dato_a_devolver> <nombre_funcion> (<parametros>)
En este caso, la función no devolverá nada, por eso escribo "void". Luego el nombre de la
función, en este caso le puse Suma, y entre paréntesis las variables que recibe (las que
necesitará la función). Son dos números tipo "int", o sea, que esta función solo nos valdría
para sumar dos números enteros. Si quisiéramos sumar dos números decimales no nos
valdría... en esto C es muy estricto.
Bien, una vez llamada la función y dados los valores n1 y n2 (estas variables ya vendrán
con valores dados por el programador o por el usuario), lo que hacemos es crear una
variable "resultado", asignamos el resultado de la suma a esta variable y luego la
mostramos por pantalla, simplemente.
Eso en cuanto a la función, ahora bien, si no hacemos una llamada a dicha función, la
función no servirá de nada.
El código completo del programa es el siguiente:
Como ya sabéis el código del main es el que se ejecuta primero nada más ejecutar el
programa. Creamos las variables num1 y num2, y le damos los valores que queramos, en
este caso el 3 y el 7, y luego llamamos a la función:
<nombre_funcion_a_llamar> (<parametros_de_dicha_funcion)
A la hora de llamar a la función solo tenemos que poner el nombre de la función y los
parámetros que queramos pasarle. Fijaos que aquí en la llamada no hace falta poner el valor
de retorno, ni indicar el tipo de las variables de los parámetros.
Las variables "num1" y "num2" no son las mismas variables que n1 y n2 (variables de la
función Suma), estas últimas solo se pueden utilizar en el ámbito de la función, es decir,
que solo podemos trabajar con ellas dentro de la función Suma, no se pueden utilizar en el
main ni en ningún otro sitio. Lo que hace el programa es asignar a estas variables los
valores de "num1" y "num2" al hacer la llamada.
Por supuesto, a la función se le podrían pasar directamente los valores sin necesidad de ser
variables, por ejemplo:
Suma (4, 7);
Funciones con retorno
Oir Lecc.
Veamos ahora las funciones que devuelven un valor, pueden ser del tipo que queramos. En
este caso hagamos la misma función "Suma", pero ahora va a devolver un valor, que será el
resultado de la suma de los dos números que recibe por parámetro.
Quedaría de esta forma:
De esta forma la función cambia un poco. Lo primero es que ahora no es "void", ya que si
devuelve un valor en vez de "void" ponemos el tipo de dato que devolverá la función, en
este caso un número entero, por lo tanto "int".
Dentro de la función, hacemos la suma de ambos números y la guardamos en una variable
llamada "r". Para devolver el valor escribimos la cláusula "return", por lo tanto esta
función devolverá el resultado de la suma de ambos números, que está en la variable "r".
El código del programa completo es el siguiente:
Tenemos que tener en cuenta que si la función devuelve un valor, entonces al ser llamada,
hay que recoger el valor recibido. Como en el ejemplo, crearemos una variable "resultado"
para guardar el resultado de la suma que nos devuelve la función.
Por eso escribimos:
resultado = Suma(num1, num2);
Una vez recogido el valor de la suma, mostramos el resultado por pantalla poniendo el
printf justo después de la llamada a la función, ya que en esta ocasión no se muestra el
resultado en la propia función, tenemos que hacerlo fuera.
Punteros
Oir Lecc.
Los punteros son la parte más problemática a la hora de aprender el lenguaje C. Trataré de
explicarlo de la forma más sencilla posible.
Es obligatorio entender aunque sea por encima el funcionamiento de los punteros, ya que es
una buena base que tendremos en el aprendizaje del lenguaje C.
Un puntero es un tipo de variable, y en estas variables podemos almacenar direcciones de
memoria.
Hemos de saber que cada variable que creamos en el sistema se almacena en la memoria
del ordenador, y el ordenador la detecta a través de una dirección de memoria; es decir, si
tenemos una variable "num" tipo "int", el ordenador sabe donde se encuentra gracias a su
dirección de memoria, es la forma de trabajar que tiene.
Por ello son importantes los punteros, porque es una variable que nos permite almacenar en
ella direcciones de memoria, por tanto, podemos tener en una variable la dirección de
memoria de otra variable, y podemos decir que ese puntero apunta a dicha variable.
Es posible también hacer que nuestro puntero nos muestre el valor de la variable a la cual
apunta... vamos a ver un pequeño ejemplo teórico (en la siguiente lección iremos a lo
práctico) a ver si más o menos se va entendiendo:
num es una variable tipo int, y contiene el valor de 10.
nombre variable: num
dirección de memoria: 000008
valor de la variable: 10
Y ahora, se puede crear una variable tipo puntero llamada 'p', que apunte a esta variable, por
tanto:
nombre variable: p
dirección de memoria: 000008
valor del puntero: 10
¿Por qué el puntero tiene valor 10? Pues porque apunta a la variable "num", por tanto, tiene
su mismo valor. Si le asignamos al puntero otra dirección de memoria que no sea la de la
variable "num", su valor será igual al valor que haya en dicha dirección de memoria.
Así es a grosso modo como trabajan los punteros.
En la siguiente lección trataremos de verlo mejor con el ejemplo práctico.
Uso de punteros
Oir Lecc.
Hemos visto el uso de punteros de forma teórica, ahora toca la práctica.
Primeramente vamos a ver un ejemplo sencillo de cómo distinguir entre la dirección de
memoria de una variable y su valor. Hasta ahora solo habíamos trabajado con los valores de
las variables.
Creamos una variable llamada "num" a la que le damos el valor de 2. Y a través de dos
printf mostramos su dirección de memoria y su valor. Para mostrar la dirección de memoria
es necesario escribir "%p".
Y en el nombre de la variable debemos poner "&" delante. Eso es lo que indica al programa
que muestre la dirección de memoria en vez de su valor.
El programa dará como resultado algo así:
Tened en cuenta que la dirección de memoria es variable, es decir, que seguramente cuando
ejecutéis vosotros el programa saldrá otra diferente a la que estáis viendo ahora en pantalla.
Veamos otro ejemplo con punteros un poco más complejos, esta vez con dos variables.
En este ejemplo crearemos variables tipo puntero. Lo que tenemos que hacer para indicar
que es un puntero es ponerle un "*" antes del nombre de la variable, como ocurre con punt1
y punt2. Al ser "int" indicamos que esos punteros apuntarán a un tipo entero.
Bien, creamos dos variables tipo int y dos punteros tipo int. Le damos valor a las variables
num1 y num2. Luego, a los punteros le damos una dirección de memoria, no un valor.
punt1 = &num1; //punt1 apunta a num1
punt2 = &num2; //punt2 apunta a num2
¿Qué quiere decir esto? Que punt1 apuntará a num1, y que punt2 apuntará a num2. O sea,
que apuntan a la dirección de memoria donde se guardan las variables num1 y num2 (de
hecho, si mostramos la dirección de memoria de &num1 y &num2, veremos como son las
mismas).
Ya solo nos queda por explicar el último printf, donde se muestra el valor que contiene
cada puntero. Esto se muestra poniendo un "*" a la hora de mostrar por pantalla. Como
apunta a un tipo int seguimos poniendo "%i" para mostrar su valor.
Como comprobaréis en el programa, los valores que contienen los punteros son 2 y 5
respectivamente, ya que son los valores que contienen las variables num1 y num2.
¿Por qué tienen ese valor los punteros? Porque le hemos dado la dirección de memoria de
las variables num1 y num2, por tanto los punteros apuntan allí, y tienen sus mismos
valores.
El resultado del programa es el siguiente:
Todo esto resulta muy complejo al principio, es el tema más complicado del lenguaje C, y
solo con el tiempo podréis ir asimilando y comprendiendo de mejor forma como funcionan.
Por lo pronto, con haceros una idea es más que suficiente.
Arrays
Oir Lecc.
Los arrays son un conjunto de variables del mismo tipo. Todas estas variables tienen el
mismo nombre, y se diferencian por un índice que se indica entre "[]".
Esto es muy útil, ya que por ejemplo, imaginemos que queremos tener 10 variables tipo int
para guardar las notas de 10 alumnos de un instituto. Hasta lo que hemos visto ahora, se
haría de la siguiente forma:
int num1, num2, num3, num4, num5, num6, num7, num8, num9, num10; y luego dar
el valor de las notas a cada uno.
Bien, para eso están los arrays, podemos crear un array de 10 variables tipo int. Nos
ahorraríamos así crear cada variable por separado. Además, imagina que en vez de 10
alumnos son 1000, sería inviable hacerlo de esta forma, por eso es tan importante el uso de
arrays en los lenguajes de programación.
Se crea de la siguiente forma:
int notas[10];
El número que tienen entre corchetes "[]" es el número de variables que tiene el array. Para
acceder a ellas, simplemente se le da el índice deseado. Por ejemplo, si queremos introducir
las notas de los 10 alumnos se haría así:
notas[0] = 9;
notas[1] = 2;
notas[2] = 6;
... // Así para todos los índices
Es importante saber que los arrays empiezan a contar desde el índice 0. O sea, que el array
de nuestro ejemplo será desde 0 al 9 (que son 10 variables).
Vamos a ver el ejemplo práctico:
He dado valor solo a los 3 primeros índices para no alargarlo. De todas formas, veremos en
la siguiente lección como inicializar un array de forma más rápida y eficiente.
Inicializar un Array
Oir Lecc.
Para dar valores a todos los elementos del array no es necesario hacerlo uno por uno,
escribiendo cada índice del array y dándole un valor. Existe la forma de inicializar el array
en el mismo momento en el que se crea.
Si tenemos el array tipo int de índice 10 del ejemplo podemos inicializarlo de la siguiente
manera:
int notas[10] = {9, 2, 6, 7, 4, 5, 5, 7, 8, 1};
Introducimos sus valores entre { ,,, } y cada valor separado por una ",". De esta forma le
damos todos los valores directamente.
Y ya si queremos acceder y mostrar el contenido de algún índice en concreto se procede
como ya hemos visto en la lección anterior.
En este ejemplo se inicializa un array y se muestran algunos de los valores que contiene:
Concretamente se muestran los valores del índice 1, 4 y 8. Recordad que el array empieza a
contar con el índice 0. Es decir, que notas[1] nos mostraría el segundo valor del array (ya
que contamos desde 0, de manera que 0 sería el primer valor, y el 1 sería su segundo valor).
Recorrer un Array
Oir Lecc.
En los arrays, a menudo necesitamos recorrer todos sus índices, ya sea para buscar un valor
en concreto o para mostrar todos los valores que tiene dentro del array.
Como imaginaréis es ideal hacerlo con bucles, y por lo general el más adecuado es el bucle
for.
En este ejemplo cogeremos el mismo array que venimos utilizando en estas lecciones
anteriores y lo vamos a recorrer para mostrar todos y cada uno de los 10 valores que
contiene el array.
La inicialización del array es exactamente igual que en la anterior lección, he dejado
incluso los mismos valores para que no haya líos.
Ahora pasamos a explicar con detenimiento el bucle for:
for (int i = 0; i < 10; i++)
Fijaos que la variable "i" la he creado directamente ahí dentro, en la inicialización del
bucle, de esta forma esa variable solo se puede utilizar dentro del ámbito del bucle "for".
Cuando hablo del ámbito me refiero a que solo se puede utilizar dentro de los { } que lleva
el bucle.
Luego, la condición es sencilla: cuando "i" sea menor que 10, de esta forma haremos que lo
que hay dentro del "for" se ejecute 10 veces (que son los índices que tiene el array); y
finalmente i++ para incrementar la variable "i" en uno después de cada ejecución del for,
como ya hemos aprendido en la lección correspondiente.
Con este for conseguimos ejecutar la instrucción que lleva en su interior un total de 10
veces.
Ahora veamos la instrucción que se ejecuta en el bucle:
printf("La nota del %i alumno es: %i \n", i+1, notas[i]);
Mostraremos las 10 notas de los alumnos por pantalla, y vamos a indicarle incluso qué
alumno es el que corresponde a la nota que estamos mostrando.
Recordad que si escribimos 2 veces "%i" el programa esperará 2 variables para mostrar, por
eso entre las "," del final hemos puesto dos variables. Las variables las ponemos en el orden
que queramos mostrarlas; es decir, el "i + 1" se mostrará en el primer "%i" que se encuentre
en la frase que está entre comillas.
Analicemos qué mostrará la primera vez que entre en el for. "i" comienza en 0, por tanto,
hará lo siguiente:
printf("La nota del %i alumno es: %i \n", 0 +1, notas[0]);
Con lo cual, el resultado de la frase sería:
"La nota del 1 alumno es: 9".
Y esto es lo que se hará cada vez que se ejecute el for, solo hay que cambiar la variable "i"
por el valor que tenga en cada momento que entre al for.
El "i + 1" lo ponemos así porque si pusiéramos solo "i" nos mostraría la primera vez la nota
del alumno 0, y eso es algo que no queda muy bien, le ponemos el "+ 1" para que muestre
del alumno 1 en adelante.
Ejercicio nº 3
Oir Lecc.
Este ejercicio es complejo pero nos va a servir para seguir entendiendo el uso de funciones
y arrays.
EJERCICIO Nº3
-Crea una función llamada Máximo10, que devuelva un int, y reciba por parámetro una
variable tipo int también. La cabecera de la función puede ser la siguiente:
int Máximo10 (int n)
Tienes que comprobar que la variable "n" tenga un número comprendido entre el 1 y el 10.
Si "n" no está entre 1 y 10, devuelves un 0, y si "n" tiene un valor entre 1 y 10, devuelves
ese mismo valor.
-Una vez programada la función, el main hará lo siguiente:
Creamos una variable tipo int llamada "longitud_array". Pediremos al usuario que
introduzca un número entre el 1 y el 10. Con la función que hemos creado comprobaremos
que ese número está entre el 1 y el 10, si no es así mostraremos por pantalla que la longitud
no es correcta y terminará el programa.
Si el valor es válido crearemos un array con la longitud dada por el usuario y luego
rellenaremos el array con números del 1 hasta la longitud, es decir, si el usuario introduce
un 4, debemos crear un array de índice 4 y los valores que les daremos serán: 1, 2, 3 y 4,
respectivamente.
Solución ejercicio nº 3
Oir Lecc.
Vamos a dividir en 2 partes la resolución del ejercicio, ya que primero se explicará la
función y luego el resto del código del "main".
La función Maximo10 es la siguiente:
La cabecera de la función ya la había facilitado en el enunciado del ejercicio.
Veamos la programación de la función en si.
Simplemente se trata de poner una condición, si "n" es mayor que 0 y "n" es menor o igual
que 10. Se utiliza el operador "&&" para poner las dos condiciones juntas, ya que se tienen
que cumplir ambas para que se ejecute el if.
Si la condición se cumple, se devolverá el valor de "n" (que es el número que introdujo el
usuario, y será correcto porque la condición nos indica que está entre el 1 y el 10).
Si no es así se devolverá un 0, para que sepamos que el valor es incorrecto.
Bien, ahora veamos el resto del código del programa.
Lo primero es crear la variable de "longitud_array". Pedimos al usuario que introduzca un
número y guardamos ese valor en dicha variable. A partir de ahí empiezan las
comprobaciones.
Pondremos un "if" para saber si la función de Maximo10 me devuelve un 0 o no. Si es
distinto de 0, es que el número que ha introducido el usuario es correcto y está entre el 1 y
el 10. Si no, hemos puesto un "else" a ese "if", que te muestra un mensaje por pantalla
diciendo que la longitud del array no está entre 1 y 10, y acabaría el programa.
En caso de que sea correcto, creamos el array con la dimensión dada por el usuario:
int numeros[longitud_array]; y luego, tenemos que rellenar ese array con valores del 1
hasta el número dado.
Así pues, necesitamos un bucle for. La condición será que se ejecute mientras "i" sea menor
que "longitud_array". De esta forma hacemos que se ejecute tantas veces como índices
tenga el array, que es lo que nos interesa.
Y dentro del bucle lo que haremos es rellenar ese índice del array con un valor y luego
mostrarlo por pantalla:
numeros[i] = i+1; //asignamos valor
printf("Numero %i del array: %i\n", i+1, numeros[i]); //mostrarlo
numeros[i] irá desde 0 hasta longitud_array. Le asignamos el valor de "i + 1" para que
empiece a dar valores a partir del 1 en vez de a partir del 0, esto es simplemente por
cuestión de estética; si queréis le podéis dar simplemente el valor de "i". Y el printf nos
muestra por pantalla el valor de dicho índice.
Como mejora para el programa estaría bien que si el usuario introduce un valor que no está
comprendido entre el 1 y el 10 te vuelva a pedir el número siempre, hasta que el usuario
introduzca un número correcto (esto ya hemos visto como hacerlo anteriormente). Lo dejo
como mejora para que podáis practicar por vosotros mismos y así aprenderéis más.
Cadena de caracteres (Strings)
Oir Lecc.
Las cadenas de caracteres no son más que un array de caracteres. De esta forma podemos
conseguir que el usuario introduzca palabras, y no solo un carácter.
Vamos a ver un ejemplo en el que se pide al usuario que introduzca su nombre y luego se
muestra por pantalla. También se mostrará la longitud de esa cadena de caracteres (string).
Para este tipo de dato string existe una librería con funciones útiles. Por ejemplo, podemos
saber la longitud de las cadenas gracias a una función de esta librería, y como la vamos a
utilizar en este ejemplo, vamos a introducir la librería con un include. La librería es
string.h.
Veamos el código del ejemplo completo:
Lo primero es poner el nuevo include:
#include <string.h>
Ahora crearemos las variables necesarias, una es un int, que será la longitud de la cadena
introducida por el usuario. La otra es la cadena como tal, que se escribe de la siguiente
forma:
char nombre[20];
Como veis es como un array pero de tipo char, o sea, de caracteres. Le damos un total de 20
caracteres, ya que solo le estamos pidiendo el nombre, sin apellidos.
Para guardar el dato introducido por el usuario en nuestra string y mostrarla por pantalla se
procede como habitualmente hacemos:
scanf("%s", &nombre);
printf("Te llamas: %s \n", nombre); //muestro nombre por pantalla
Lo único a tener en cuenta es que el "%" para las string es "%s".
Bien, ya tenemos la string con el nombre del usuario y la hemos mostrado por pantalla, ya
solo nos queda saber la longitud de la cadena y mostrarla también por pantalla. Esto se hace
a través de una de las funciones que tiene la librería string.
La llamada a la función es muy simple, recibe por parámetro la cadena en cuestión y nos
devuelve un tipo int con la longitud de dicha cadena. La función se llama strlen.
longitud_string = strlen(nombre); //strlen cuenta caracteres
printf( "Tu nombre: %s, tiene %i caracteres. \n", nombre, longitud_string ); Asignamos el valor devuelto por la función a nuestra variable longitud_string,, y ya
podemos mostrar la longitud por pantalla (recuerda que también puedes mostrarla
directamente en el printf, sin necesidad de asignarle el valor a una variable).
Probamos el programa con diversos nombres para ver que funciona correctamente. Eso si,
tened en cuenta que los nombres compuestos no los va a asignar bien, ya que C trabaja de
forma que solo coge palabras, en cuanto encuentra un espacio en blanco ya no sigue más.
Por ejemplo, si introducimos: "José Manuel", el programa solo nos mostrará "José". Esto se
soluciona cambiando la función que asigna el valor introducido a nuestra variable. En vez
de scanf, para string se recomienda gets.
Esta función es muy sencilla de utilizar, simplemente le pasamos por parámetro la variable
a la cual queremos asignar el valor introducido: gets(nombre); sustituimos esa línea por la
del scanf y ya veremos como ahora si que nos coge los valores aunque tengan espacios de
por medio.
Funciones Strcpy y Strcat
Oir Lecc.
Ahora que hemos aprendido a utilizar string o cadena de caracteres, vamos a ver alguna de
las funciones más útiles para string que contiene la librería <string.h>.
Veremos las funciones strcpy y strcat, la primera sirve para copiar el contenido de una
cadena a otra, y la segunda para concatenar cadenas; es decir, juntar las cadenas.
En este ejemplo podemos ver el uso de ambas:
En primer lugar, creamos ambas string, una con un nombre y la otra con un apellido.
char nombre[20] = "Jose";
char apellido[20] = "Perez";
Ahora, con strcpy copiaremos el contenido de la string apellido al string nombre. De esta
forma, tras ejecutar la función tendremos las dos string con el mismo contenido "Perez".
strcpy(nombre, apellido); //Lo que hay en apellido se copia a nombre
printf("Cadena copiada: %s \n", nombre);
La función strcpy recibe dos parámetros, primero la string donde se va a copiar el
contenido, y segundo la string del cual será copiado su contenido. Ahí mostramos la
variable nombre, para comprobar que se ha copiado correctamente.
Por último, vamos a concatenar la variable nombre con la variable apellido. Como ambas
contienen "Perez" ahora mismo el resultado sería: Perez Perez.
//strcat concatena dos cadenas
strcat(nombre, " "); //concateno con un espacio en blanco
strcat(nombre, apellido); //le añado la cadena apellido
printf("Cadena concatenada: %s \n", nombre);
Esta función también recibe dos parámetros, el primero el de la primera string y el segundo,
la string que queremos concatenar con la primera. Fijaos que primero he concatenado la
string nombre con un espacio en blanco... para que el resultado no fuese: "PerezPerez".
Después del espacio en blanco ya la concateno con la variable apellido, y luego se muestra
por pantalla.
Función Strcmp
Oir Lecc.
Vamos a ver una función más relacionadas con string. En este caso, strcmp, que nos
servirá para comparar dos cadenas y así saber si son iguales o son diferentes.
Hay muchas más funciones para string en la librería <string.h>, pero solo hemos visto
algunas de las más utilizadas.
La función strcmp recibe dos parámetros que serán dos string, y si son iguales nos
devolverá un 0, y si no son iguales devolverá cualquier otro número.
Por tanto, vamos a ver un ejemplo con dos string diferentes y las compararemos, y luego
también lo probaremos con dos string iguales. El código es muy sencillito:
Crearemos las dos string con los valores que queramos, pero diferentes. Luego en una
sentencia if llamamos a la función, y ponemos en la condición que si lo que devuelve a la
función es igual a 0 (si se cumple la condición significaría que son iguales las cadenas).
Si son iguales se muestra un mensaje por pantalla que lo indica, y si no lo son, también se
muestra por pantalla el mensaje de que NO son iguales.
Simple ¿no?
Definiendo estructuras
Oir Lecc.
Como ya vimos, los arrays nos permiten tener muchas variables ordenadas, pero solo si son
datos del mismo tipo, como ya hicimos en los ejemplos de las notas de los alumnos.
Ahora, con las estructuras, vamos a ver como podemos tener más tipos de datos en una
misma estructura. Supongamos que queremos almacenar el nombre, apellido, edad y nota
media de nuestros alumnos.
El uso de las estructuras puede llegar a ser complejo, por lo que aquí vamos a ver solo un
primer acercamiento. Para manejarlas bien en su totalidad, habría que profundizar más en el
uso de punteros, y se vuelve más complicado. Por lo que aquí solo se explicarán nociones
básicas.
No nos serviría un simple array, tenemos que hacerlo con estructuras. La estructura de las
estructuras sería la siguiente (valga la redundancia):
struct <nombre_estructura> { //Estructura de alumnos
//Variables que queramos meter en dicha estructura...
};
Es una estructura muy sencilla. Vamos a ver en un ejemplo como se define una estructura
en C:
Entre las librerías y la función main, introducimos el código de la definición de la
estructura. Como veis es simplemente crear las variables que queramos dentro de la
definición de la estructura. En este caso, serán los nombrados anteriormente.
Gracias a esto, ahora tendremos almacenada más información de cada alumno, y de forma
organizada.
Este programa como tal no hace nada, porque simplemente declaramos la estructura, en las
siguientes lecciones vamos a aprender a utilizar las estructuras con casos prácticos
Inicializar estructuras
Oir Lecc.
En la lección anterior simplemente hemos definido la estructura. Ahora tendremos que
crear e inicializar dicha estructura. Supongamos que queremos crear un alumno con la
estructura anterior, pues para darle valores a esa estructura se hace de la siguiente forma, ya
en la función main:
struct <tipo_estructura> <nombre_estructura> = {
//Dar valores a las variables que contiene...
}; En "tipo_estructura" pondremos "estructura_alumnos", que es como se llamaba nuestra
estructura definida, y a continuación el nombre que queramos darle, por ejemplo: alumno1.
Dicho esto, vamos a ver como quedaría en un ejemplo práctico:
Así quedaría nuestra inicialización de estructura para el alumno1. Recordad siempre el ";"
al final de cada estructura. Obviamente, los valores que se dan tienen que corresponder a
los tipos de variables, y tenemos que ponerlos en orden. Es decir, no podemos poner la nota
media en la primera línea, o el nombre al final, tiene que estar todo bien ordenado.
Ahora bien, supongamos que en vez de un alumno queremos tener más (que es lo normal),
entonces para esto podríamos crear un array de estructura_alumnos, y ahí almacenar tantos
alumnos como veamos necesarios.
Por ejemplo, para crear 10 alumnos podríamos hacerlo con la siguiente instrucción:
struct estructura_alumnos alumnos[10]; "struct estructura_alumnos" es como si fuera un tipo de dato. Por tanto, estaríamos creando
un array llamado alumnos del tipo estructura_alumnos.
Para acceder a todos los alumnos y leer los datos que contienen tendremos que esperar a la
siguiente lección.
Aún este ejemplo no nos muestra nada por pantalla, simplemente creamos e inicialiazamos
estructuras, pero en la siguiente lección ya aprenderemos a leer los datos.
Introducir y leer datos de la estructura
Oir Lecc.
Veamos ahora como introducir los datos de todos los alumnos de forma sencilla y luego
mostrar estos datos por pantalla. Para que el ejemplo no se haga tan extenso, hagamos un
poco más pequeña la estructura, solo pondremos el nombre y la edad de cada alumno:
Una vez modificada la estructura vamos a la función main, donde crearemos un array de 3
alumnos e introduciremos todos sus datos.
Como imaginaréis, lo ideal tanto para introducir datos como para leerlos es hacerlo a través
de bucles, para no tener que repetir instrucciones.
Lo primero, crear un array de 3 alumnos:
struct estructura_alumnos alumnos[3]; Con esta instrucción tenemos dicho array. Ahora vamos a introducir los datos de todos los
alumnos con un bucle for:
//Bucle para introducir todos sus datos
for (int i = 0; i < 3; i++)
{
printf("Introduce nombre del alumno %i: ", i+1);
gets(alumnos[i].nombre); //gets lee incluso espacios en String
printf("Introduce edad del alumno %i: ", i+1);
scanf("%i", &alumnos[i].edad); //Recoge la edad
while(getchar()!='\n'); //Bucle que vacía buffer de entrada
}
El bucle tiene que ir desde 0 a 3. Y dentro del bucle pedimos al usuario que introduzca
nombre y edad de los alumnos.
gets(alumnos[i].nombre);
Utilizamos la función gets para introducir los nombres. Para acceder al alumno "i" se hace
con los corchetes, como en cualquier array. Y luego ".", y detrás del punto escribimos el
nombre de la variable de la estructura en la que queremos introducir el dato. En este caso
sería ".nombre" y ".edad".
Esta línea nos sirve para vaciar el buffer de entrada del programa:
while(getchar()!='\n');
Sin esta línea no funcionaría bien la inclusión de datos. Es necesario ponerla; para
comprenderla hace falta saber más sobre C, pero ahora mismo no nos incumbe.
Ya tenemos la estructura con los datos introducidos por el usuario. Ahora solo nos queda
leer los datos de todos los alumnos, de nuevo con un bucle for para recorrer todo el array.
//LEER LOS DATOS DE LOS ALUMNOS
for (int i = 0; i < 3; i++)
{
printf("\nALUMNO %i \n", i+1); //Muestra numero de alumno
printf("Nombre: %s\n", alumnos[i].nombre); //Nombre de dicho alumno
printf("Edad: %i \n\n", alumnos[i].edad); //Edad de dicho alumno
} A través de los printf se muestran los datos como venimos haciendo durante todo el curso.
Lo único que tenemos que saber es que para acceder a los datos hay que poner el "." detrás
del array, seguido del nombre del dato que queramos leer.
Para que quede más bonito hemos puesto el número de alumno que está mostrando.
Mostramos el alumno "i+1" para que no se muestre alumno 0, ya sabéis.
Ejercicio final
Oir Lecc.
Terminada toda la teoría y práctica que contiene el curso pasamos ahora a la prueba final.
Un ejercicio en el que pondremos a prueba todos nuestros conocimientos.
EJERCICIO FINAL
-Define una estructura_alumnos que contenga el nombre, dni, y edad de cada uno de los
alumnos.
-Crea un total de 3 alumnos e introduce todos sus datos (pidiendo al usuario que los
introduzca por teclado).
-Una vez hecho esto, pide al usuario que introduzca un DNI. Tendremos que mostrar por
pantalla todos los datos del alumno que pertenezca a dicho DNI. Si el DNI introducido no
existe entre los alumnos, saldrá un mensaje que nos lo indique.
-Realizar esta operación siempre, hasta que el usuario introduzca la palabra "salir",
entonces ya acabará el programa. Si no introduce "salir", el programa seguirá pidiendo un
DNI.
Solución ejercicio final
Oir Lecc.
Vamos con la solución del ejercicio final. Para hacerlo más comprensible iremos por partes,
dividiremos el ejercicio en 3 partes; primero mostraremos las librerías y la definición de la
estructura, luego veremos como se introducen todos los datos de los alumnos en la
estructura, y por último, la búsqueda del alumno por DNI.
Sin más, veamos como sería la definición de la estructura:
La única novedad respecto al último que hemos utilizado es la inclusión del campo "dni",
que será una string de 9 caracteres. Recordad también incluir la librería <string.h>, ya que
vamos a utilizar funciones de cadenas de caracteres, y es necesaria esta librería.
Una vez declarada la estructura vamos ya al "main", a realizar el relleno de datos de los
alumnos:
Como ya vimos en la lección 38, aquí tenemos que poner un bucle que recorra todo el array
de los alumnos e ir introduciendo datos de todos ellos.
Para el nombre utilizamos "gets", que guarda también los espacios en blanco. Para el dni
por ejemplo no es necesario, ya que el scanf lo guarda bien sin ningún problema. Y por
último la edad, que también la guardamos a través de un scanf.
El "while" de la última línea nos sirve para vaciar el buffer, sin esta línea no funcionaría
bien del todo el programa. Cuando hay llamadas a "gets" conviene vaciar el buffer.
Y por último, y aquí viene la parte más complicada del programa, veremos la búsqueda del
alumno después de introducir un DNI:
Primero de todo crearemos dos variables, una será una string del dni a buscar, y la otra un
bool (verdadero o falso) para saber si se ha encontrado el alumno.
Como el ejercicio pedía que siempre nos pidiera dni hasta que no se introdujera la palabra
"salir", entonces tendremos que hacer un bucle.
while (strcmp(dni_buscar, "salir") != 0) //Si el DNI es distinto que "salir"
{ ... } Utilizaremos la función strcmp para comparar cadenas de caracteres. Si la función devuelve
0 es que son iguales. Por tanto, si la función devuelve algo que sea distinto "!=" de 0, es que
el bucle tiene que ejecutarse.
Bien, ahora dentro del bucle lo primero que hacemos es pedir al usuario que introduzca un
dni, y lo asignamos a la variable dni_buscar.
Una vez tengamos en la variable el dni del alumno a buscar tendremos que recorrer todo el
array de la estructura de alumnos, e ir comprobando uno por uno a ver qué DNI coincide
con el que tenemos en la variable dni_buscar.
for (int i = 0; i < 3; i++) //Recorremos el array
{
if (strcmp(dni_buscar, alumnos[i].dni) == 0)
{
encontrado = true; //Alumno encontrado
printf("\nEl alumno con DNI: %s, es el siguiente:\n", dni_buscar);
printf("Nombre: %s\n", alumnos[i].nombre);
printf("DNI: %s\n", alumnos[i].dni);
printf("Edad: %i \n\n", alumnos[i].edad);
}
} De nuevo nos hará falta la función de comparar cadenas de caracteres. Iremos
comprobando en todos los alumnos si el campo alumnos[i].dni es igual a dni_buscar.
En caso de que sea igual, entonces dentro del if se mostrarán los datos de dicho alumno
(solo se podría encontrar un alumno, ya que el DNI es algo único de cada alumno).
Fijaos que aparte de mostrar sus datos, también hemos puesto en true la variable
encontrado. De esta forma sabremos que se ha encontrado un alumno con ese DNI, y este
dato nos servirá para lo que veréis a continuación.
Las últimas líneas del código serán por si se introduce un DNI que no existe en nuestra
estructura de alumnos y el programa tiene que mostrar que no se ha encontrado el alumno:
if (encontrado == false && strcmp(dni_buscar, "salir") != 0)
{
printf("No se ha encontrado a ningun alumno con ese DNI.\n\n");
} Fijaos en la condición doble del if. Si encontrado == false y la cadena dni_buscar es
distinto de "salir". ¿Por qué ponemos esta última condición? Porque si no el programa
también mostraría esta frase de alumno no encontrado cuando se introduzca "salir"; y no
nos interesa, ya que cuando se introduzca la palabra salir el programa acaba sin más, sin
mostrar esa frase que solo nos conviene que la muestre cuando un alumno no es
encontrado.
