Curso de Lenguaje de programación C http://www.aulafacil.com/cursos/t1454/informatica/programacion/lenguaje-de-programacion-cModificado y ampliado por Gustavo Zazo

Índice1. Introducción..............................................................................................................................................3

2. Compiladores del lenguaje C....................................................................................................................3

3. Instalar el compilador...............................................................................................................................4

4. Primer programa en C...............................................................................................................................7

5. Tipos de datos (variables).......................................................................................................................10

6. Mostrar datos por pantalla.....................................................................................................................12

7. Constantes..............................................................................................................................................14

8. Operadores aritméticos..........................................................................................................................15

9. Operadores de comparación..................................................................................................................17

10. Operadores lógicos.................................................................................................................................18

11. Introducir datos por teclado...................................................................................................................19

12. Sentencia If.............................................................................................................................................21

13. Sentencia If... Else...................................................................................................................................22

14. Sentencia Switch.....................................................................................................................................24

15. Bucle For.................................................................................................................................................26

16. Bucle While.............................................................................................................................................28

17. Bucle Do/While.......................................................................................................................................30

18. Funciones y bibliotecas...........................................................................................................................31

19. Funciones sin retorno.............................................................................................................................32

20. Funciones con retorno............................................................................................................................34

21. Punteros.................................................................................................................................................36

22. Uso de punteros.....................................................................................................................................37

23. Arrays......................................................................................................................................................40

24. Inicializar un Array..................................................................................................................................41

25. Recorrer un Array...................................................................................................................................42

26. Cadena de caracteres (Strings)...............................................................................................................44

27. Funciones Strcpy y Strcat........................................................................................................................46

28. Función Strcmp.......................................................................................................................................48

29. Definir estructuras..................................................................................................................................49

30. Inicializar estructuras..............................................................................................................................50

31. Introducir y leer datos de la estructura..................................................................................................52

32. Ejercicios resueltos.................................................................................................................................55

Curso de C 1

1. IntroducciónEl 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 el siguiente capítulo 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?

2. Compiladores del lenguaje CLo 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++, que es gratuito.

Esta es la única herramienta que necesitaremos para aprender a programar en C. En el siguiente capítulo veremos cómo se instala el compilador en nuestro ordenador.

Curso de C 2

3. Instalar el compiladorVamos a ponernos manos a la obra con la instalación del compilador. Partimos de la base de que ya hemos descargado el archivo, y ahora vamos con la instalación. Es muy sencillo, puesto que apenas hay que modificar cosas.

1- Doble clic al archivo descargado:

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

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

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

Curso de C 3

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, clic en "Si" o "No", depende lo que quieras.

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

Curso de C 4

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

Curso de C 5

4. Primer programa en CUna 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 mediante instrucciones de programación, y cada instrucción acabará con un ";", que indica el final de la instrucción y que pasará a ejecutarse la siguiente.

Veamos cómo 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 F11 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. Se llaman comentarios, y nos sirven para que nosotros mismos, los programadores, sepamos qué hace cada instrucción. En programas sencillos como este no son necesarios, pero imaginad un programa de más de 3000 líneas de código; este 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 "#include" hacen referencia a bibliotecas.

Curso de C 6

Una biblioteca (library en inglés) es un archivo que incluye diversas funciones que pueden ser usadas en un programa. Las funciones pueden ser de entrada y salida de datos, matemáticas, de manejo de cadenas y de otros muchos tipos.

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 "c" y en C++ tienen la extensión “cpp”.

NOTA IMPORTANTEDevC++ no soporta por defecto las características del español escrito. Es decir, no presenta en la consola ni la ñ ni las vocales con tilde o diéresis. Véase el ejemplo:Si escribimos este código:

Obtendremos este resultado al ejecutar el programa:

Curso de C 7

Para evitar este problema, hay que hacer lo siguiente:

1. Incluir la biblioteca locale.h2. Escribir dentro de main la línea

setlocale(LC_CTYPE, "Spanish");

Por tanto, el código anterior debería quedar así:

Y en la consola se obtendría:

Ejercicios propuestos:Ejercicio 0

Curso de C 8

5. Tipos de datos (variables)Los tipos de datos (la información que manipularemos en C) son 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.

Datos numéricos:

Tipo de dato Rango (*) Memoria requerida (*) Observaciones

int Datos numéricos enteros - 32768 a 32767 2 bytes

float Datos numéricos con decimales - 3,4·1038 a 3,4·1038 4 bytes Hasta 6 decimales

double Datos numéricos con decimales - 1,79·10308 a 1,79·10308 8 bytes Hasta 14 decimales

(*): Orientativo. Depende del dispositivo en el que se ejecute el programa

Datos referentes a los caracteres o cadenas:

Tipo de dato Rango Memoria requerida Observaciones

char Un solo carácter. 0 a 255 1 byte Por ejemplo: a, H, @, 1,

string Cadenas de caracteres

No es un tipo de datos como tal. Ya veremos más adelante cómo se utilizan.

Otros tipos de datos:

Tipo de dato Rango Memoria requerida

bool

"true" o "false", es decir, verdadero o falso.

0 a 1 1 byte

Para crear las variables y asignarles valores (inicializarlas) se aplica la siguiente sintaxis:

<tipo_de_variable> <nombre_variable> = <valor>

En C quedarían así algunos ejemplos:

int num = 7;char caracter = 'b'

Curso de C 9

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.

No os preocupéis que todo esto se va a poner en práctica en el siguiente capítulo, donde enteréis mejor el uso de las variables.

Curso de C 10

6. Mostrar datos por pantallaVamos 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 (o inicializació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 este capítulo 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.

Curso de C 11

En la siguiente tabla veréis las letras para cada tipo:

int %i o %d

char %c

float %f

double %f

Para los dos últimos tipos se utiliza el mismo símbolo.

Después del texto entre las comillas viene 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.

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:

Descargar datosporpantalla.cpp

Ejercicios propuestos:Ejercicios 1, 2 ,3, 5, 6, 7, 8 y 9

Curso de C 12

7. ConstantesVeremos ahora un tipo de datos que son especiales. Estos datos 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.

Hay otra manera de declarar las constantes:

const <tipo_dato><nombre_constante>=<valor_constante>;

Por ejemplo: const float NUM=23.65;

Con esta última sintaxis, la constante se puede definir dentro del main.

Este sencillo programa lo que hace es multiplicar 3 por PI y mostrarlo por pantalla.

Una forma más corta de realizar el ejercicio 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", e 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 como el resultado es un número con decimales utilizamos "%f" para mostrarlo.

Código fuente: Descargar Constantes.cpp

Ejercicios propuestos:Ejercicio 4

Curso de C 13

8. Operadores aritméticosHasta 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:

Operador Símbolo Ejemplo de uso Resultado

Suma + num1+num2 Suma de num1 y num2

Incremento ++ num1++ Suma 1 al valor de num1

Resta - num1-num2 Resta de num1 menos num2

Decremento -- num1-- Resta 1 al valor de num1

Multiplicación * num1*num2 Producto de num1 por num2

División / num1/num2 División de num1 entre num2

Resto % num1%num2 Resto de la división de num1 entre num2

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):

Curso de C 14

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 actualiza 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

Ejercicios propuestos:Ejercicios 10, 11, 12, 13, 14, 15 y 16

Curso de C 15

9. Operadores de comparaciónYa que estamos con los tipos de operadores que nos ofrece C, vamos ahora a ver los operadores de comparación, aunque estos 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 para, por ejemplo, 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.

Si la condición se cumple, se devuelve el valor booleano “true” (o 1). En caso contrario, se devuelve “false” (o 0).

Suponiendo que tenemos la variable a y variable b:

Operador Símbolo Ejemplo de uso Valor que devuelve

Igual que == a==b true si a es igual a b

Distinto a ¡= a¡=b true si a es distinto a b

Menor que < a<b true si a es menor que b

Mayor que > a>b true si a es mayor que b

Menor o igual que <= a<=b true si a es menor o igual que b

Mayor o igual que >= a>=b true si a es mayor o igual que 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.

Curso de C 16

10. Operadores lógicosComo ocurre en el anterior capítulo, este también va a ser meramente teórico, ya que tampoco podemos ponerlo 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 y d.

Operador Símbolo Ejemplo de uso Valor que devuelve

Y(AND lógico)

&& a==b && c>d true si a es igual a b Y c es mayor que d

O(OR lógico)

|| a<b || c<d true si a es menor que b O c es menor que d

NO(NOT lógico)

¡ ¡(a==b) true si a NO es igual que b

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 

Se obtendría true 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.

a == b || a > d || b != d 

En el caso del operador O (||), se obtendría true si al menos una de todas las condiciones fuera cierta.

El operador! nos sirve para negar cualquier condición. Recordad poner 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 los apartados correspondientes os quedará todo mucho más claro.

Consultar Ejercicio resuelto A

Curso de C 17

11. Introducir datos por tecladoHasta el momento, el valor de las variables los hemos puesto nosotros mismos. Ahora veremos cómo hacer para que el propio usuario que utilice el programa dé valores a las 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 "%" y la letra adecuada para cada tipo de dato, y luego, separado por una coma, escribimos el nombre de la variable en la que 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 introducir 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.

Curso de C 18

Lo primero que tenemos que hacer es introducir otro "include", en este caso: conio.h. ya que sin esta biblioteca (que es de lo que se encargan los includes, de incluir bibliotecas) el programa no funcionaría, porque la función getche(); está incluida en esa biblioteca. Todo esto de funciones y bibliotecas se entenderá posteriormente en siguientes apartados.

Lo que cambia de este programa respecto 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

Ejercicios propuestos:Ejercicios 17, 18 y 19

Curso de C 19

12. Sentencia IfEn este capítulo nos metemos ya con lo que son las sentencias de flujo de control del programa. Estas sentencias son condiciones, y ahora, dependiendo de 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 (condición){ ... //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 que 5. Si no, no ocurrirá nada y el programa acabará. En el siguiente capítulo veremos qué hacer para 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

Curso de C 20

13. Sentencia If... ElseEn el capítulo 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.

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:

Curso de C 21

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, puede haber ocasiones en las que se necesiten más.

Descargar IfElse.cpp

Descargar IfElse2.cpp

Ejercicios propuestos:Ejercicios 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 y 31

Curso de C 22

14. Sentencia SwitchSeguimos con las sentencias de control de flujo del programa. En este capítulo 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 1break;case 2:// código que se ejecuta si elige la opción 2break;...}

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.

Curso de C 23

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 qué 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

Curso de C 24

15. Bucle ForPasamos 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 se cumple, se saldrá del for.

En este caso queremos que se cumpla 10 veces, por tanto, ponemos si "i" es menor o igual que 10. Y en "<incremento>" lo que haremos es incrementar la variable "i" en 1 en cada iteración del bucle.

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

Curso de C 25

Explico cómo funciona el for:

Primero se asigna el valor inicial a la variable "i"; en este caso, 1. Ahora se ejecuta la condición: ¿"i" es menor o igual que 10? Como ahora "i" vale 1, la condición se cumple (i<=10) y, por tanto, se ejecutan las instrucciones de dentro del bucle, es decir, se muestra por pantalla el 1.

Al terminar, el bucle for efectúa el <incremento> de la variable "i" y, 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, 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 11, momento en el que la condición deja de cumplirse y se sale del bucle for.

Descargar For.cpp

Curso de C 26

16. Bucle WhileSeguimos 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 que 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 el capítulo 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.

Curso de C 27

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". 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

Curso de C 28

17. Bucle Do/WhileEste 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 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

Consultar Ejercicio resuelto B

Ejercicios propuestos:Ejercicios 32, 33, 34, 35 y 36

Curso de C 29

Curso de C 30

18. Funciones y bibliotecasEntramos 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: 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 bibliotecas en C. Las bibliotecas no son más que un conjunto de funciones; por lo tanto, si estamos utilizando una función de una biblioteca que no está incluida, el compilador dará error, ya que esa función no está declarada.

Por ejemplo, ya os habréis dado cuenta de que el printf que tanto hemos usado 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.

system("PAUSE")también es una función 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 los siguientes apartados.

Curso de C 31

19. Funciones sin retornoVamos 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 cómo 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:

Curso de C 32

Como ya sabéis, el código de la función main es el que primero se ejecuta nada más abrir 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> (<parámetros_de_dicha_función)

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); 

Esto nos mostraría por pantalla un 11.

Descargar FuncionesSinRetorno.cpp

Curso de C 33

20. Funciones con retornoVeamos ahora las funciones que devuelven un valor, que puede 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" debemos especificar 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 se almacena en la variable "r".

El código del programa completo es el siguiente:

Curso de C 34

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.

Descargar FuncionesConRetorno.cpp

Curso de C 35

21. PunterosLos 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.

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 dónde se encuentra gracias a su dirección de memoria.

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 el siguiente capítulo 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 de la 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 de la 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 el siguiente capítulo trataremos de verlo mejor con el ejemplo práctico.

Curso de C 36

22. Uso de punterosHemos 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 aparecerá 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.

Curso de C 37

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.

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 num1punt2 = &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 que son las mismas).

Ya solo nos queda por explicar el último printf, donde se muestra el valor que contiene cada puntero. Esto se obtiene poniendo un "*" a la hora de mostrarlo 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:

Curso de C 38

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 cómo funcionan. Por lo pronto, con haceros una idea es más que suficiente.

Descargar Punteros.cpp

Descargar Punteros2.cpp

Curso de C 39

23. ArraysUn array (matriz) es un conjunto de variables del mismo tipo. Todas estas variables tienen el mismo nombre, y se diferencian por un índice que se indica entre "[]".

Imaginemos que queremos tener 10 variables tipo int para guardar las notas de 10 alumnos de un instituto. Según 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íamos el valor de las notas a cada uno.

Sin embargo, 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 muy tedioso hacerlo de la primera forma.

El array se crea de la siguiente forma:int notas[10];

El número que tiene entre corchetes ("[]") es el número de variables que tiene el array. Para acceder a ellas, simplemente se le da el índice deseado. Es decir, 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 el siguiente capítulo como inicializar un array de forma más rápida y eficiente.

Curso de C 40

24. Inicializar un ArrayPara 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. Hay una 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 el capítulo 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).

Descargar InicializarArray.cpp

Curso de C 41

25. Recorrer un ArrayEn los arrays a menudo necesitamos recorrer todos sus índices, ya sea para buscar un valor en concreto o para mostrar todos los valores que contiene.

Como imaginaréis es ideal hacerlo con bucles, y por lo general el más adecuado es el bucle for.

En este ejemplo tomaremos el mismo array que venimos utilizando en estos apartados anteriores y lo vamos a recorrer para mostrar todos y cada uno de los 10 valores que contiene.

La inicialización del array es exactamente igual que en el anterior capítulo. 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 el capítulo 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

Curso de C 42

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 se cambia 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.

Descargar RecorrerArray.cpp

Consultar Ejercicio resuelto C

Ejercicios propuestos:Ejercicios 37, 38, 39, 40, 41 y 42

Curso de C 43

26. Cadena de caracteres (Strings)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 biblioteca con funciones útiles. Por ejemplo, podemos saber la longitud de las cadenas gracias a una función de esta biblioteca, y como la vamos a utilizar en este ejemplo, vamos a cargar la biblioteca con un include. La biblioteca 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".

Ya tenemos la string con el nombre del usuario y la hemos mostrado por pantalla. 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 biblioteca string.

Curso de C 44

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 caracteresprintf("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 sí, tened en cuenta que los nombres compuestos no los va a asignar bien, ya que C trabaja de forma que solo toma 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 sí que toma los valores aunque tengan espacios de por medio.

Descargar String.cpp

Curso de C 45

27. Funciones Strcpy y StrcatAhora 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 biblioteca <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, unir 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] = "Ana"; char apellido[20] = "Blanco";

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: "Blanco".

strcpy(nombre, apellido); //Lo que hay en apellido se copia a nombreprintf("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 " Blanco " ahora mismo el resultado sería: Blanco Blanco.//strcat concatena dos cadenas

Curso de C 46

strcat(nombre, " "); //concateno con un espacio en blancostrcat(nombre, apellido); //le añado la cadena apellidoprintf("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.

Descargar FuncionesString.cpp

Curso de C 47

28. Función StrcmpVamos a ver una función más relacionada 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 biblioteca <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?

Descargar FuncionStrcmp

Curso de C 48

29. Definir estructurasComo 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.

Sin embargo, con las estructuras vamos a ver cómo 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.

No nos serviría un simple array, tenemos que hacerlo con estructuras. La sintaxis para definir una estructura es la siguiente:struct <nombre_estructura> {       //Variables que queramos poner en dicha estructura...};

Veamos un ejemplo:

Entre las bibliotecas 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.

Descargar DefinicionEstructura.cpp

Curso de C 49

Curso de C 50

30. Inicializar estructurasEn el capítulo anterior simplemente hemos definido la estructura. Ahora tendremos que crear e inicializar dicha estructura. Supongamos que queremos asignar los datos de un alumno a la estructura anterior. 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 datos de más alumos (que es lo normal). 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.

Curso de C 51

Para acceder a todos los alumnos y leer los datos que contienen tendremos que esperar al siguiente capítulo.

Aún este ejemplo no nos muestra nada por pantalla, simplemente creamos e inicializamos estructuras, pero en el siguiente capítulo ya aprenderemos a leer los datos.

Pero ya van cogiendo forma las estructuras ¿no?

Descargar InicializarEstructura.cpp

Curso de C 52

31. Introducir y leer datos de la estructuraVeamos 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.

Curso de C 53

Lo primero es 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 datosfor (int i = 0; i < 3; i++){printf("Introduce nombre del alumno %i: ", i+1); gets(alumnos[i].nombre); //gets lee incluso espacios en Stringprintf("Introduce edad del alumno %i: ", i+1);scanf("%i", &alumnos[i].edad); //Recoge la edadwhile(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 ALUMNOSfor (int i = 0; i < 3; i++){printf("\nALUMNO %i \n", i+1); //Muestra numero de alumnoprintf("Nombre: %s\n", alumnos[i].nombre); //Nombre de dicho alumnoprintf("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.

Curso de C 54

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.

El código del programa lo tenéis aquí:

Descargar LeerEstructuras.cpp

Consultar Ejercicio resuelto D

Curso de C 55

32. Ejercicios resueltos

Ejercicio resuelto A

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 el siguiente capítulo. 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.

Curso de C 56

Solución del ejercicio A

Según su enunciado, podíamos hacer el ejercicio con la variable "resultado", o 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.

Curso de C 57

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 sí, hay que poner 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 sumaría 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 EjercicioA.cpp

Descargar código fuente EjercicioA(2).cpp

Curso de C 58

Ejercicio resuelto B

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.

Solución del ejercicio B

Espero que hayas dado con la solución para el ejercicio B, y si no, aquí la tienes. El truco para que el programa no acabe 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.

Curso de C 59

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 EjercicioB.cpp

Curso de C 60

Ejercicio resuelto C

Este ejercicio es complejo pero nos va a servir para seguir entendiendo el uso de funciones y arrays.

- Crea una función llamada Maximo10, 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 Maximo10 (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.

Curso de C 61

Solución del ejercicio C

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 sí.

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.

Curso de C 62

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 valorprintf("Numero %i del array: %i\n", i+1, numeros[i]); //mostrarlo

Curso de C 63

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.

Aquí adjunto el código del programa completo para que lo estudiéis mejor y lo trasteéis.

Descargar Ejercicio3.cpp

Curso de C 64

Ejercicio resuelto D

- 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.

Curso de C 65

Solución del ejercicio D

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 bibliotecas y la definición de la estructura, luego veremos cómo 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 cómo 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 biblioteca <string.h>, ya que vamos a utilizar funciones de cadenas de caracteres, y es necesaria esta biblioteca.

Una vez declarada la estructura vamos ya al "main", a realizar el relleno de datos de los alumnos:

Como ya vimos en el capítulo 30, 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.

Curso de C 66

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 dice 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); 

Curso de C 67

 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.

El código completo del ejercicio final:

Descargar EjercicioFinal.cpp

Curso de C 68