Curso de programación en C desde cero

Hawkings

Post #11

En el post de hoy vamos a aprender a crear nuestras propias funciones. En realidad cuando hacemos un programa estámos creando una función (main) que es la que se ejecuta. Pero como también hemos visto en nuestro programa podemos usar otras funciones (como printf o scanf). Al igual que usamos las funciones propias de C también podemos crear las nuestras. Antes de nada debéis saber que las funciones, al igual que las variables tenemos que crearlas antes de usarlas (¿tiene sentido, no?). Para crear una variable tenemos que poner el tipo de datos que va a devolver. Con la fución main ponemos que devuelve int, pero puede devolver char, float y otras cosas. También puede no devolver nada. Para indicar que una función no devuelve nada ponemos void (que significa literalmente "vacío"). Después ponemos el nombre de la función, que al igual que las variables no puede empezar por un número y sólo puede llevar letras, números y el carácter '_'. Tampoco suelen llevar mayúsculas los nombres de las funciones, pero esto no es obligatorio. Después como todas las funciones llevan paréntesis de apertura y de cierre. Si la función recibe algo lo indicamos aquí, y si no podemos poner void o no poner nada (sólo podemos poner void si no recibe nada al crear la función, no al usarla); para este primer ejemplo ni recibirá ni devolverá nada. Y por último, entre dos llaves indicamos qué queremos que haga la función, se hace exactamente igual que con la función main.

Ejemplo 10: Diseña un programa que muestre "abc" por pantalla 40 veces.

Para resolverlo vamos a crear una función que muestre por pantalla "abc" 40 veces:

#include 

//Ahora, antes de usarla, es decir antes de main
//creamos la función abc40, que muestra abc por
//pantalla 40 veces.

void abc40(void) { 
     int i;
     for(i = 0; i < 40; i++) {
           printf("abc\n");
     }
}

int main () {
    abc40(); //usamos la funcion abc40 como usariamos printf o cualquier otra función
    system("pause > null");
    return 0;
}

Con este ejemplo no creo que haya ningún problema. La función crea una variable, hace un bucle y muestra "abc" por pantalla. Ahora veamos qué pasa con las funciones que reciben algo. Se pone el tipo de datos que devuelven y se les da un nombre como si fuera una variable para poder usar ese dato que reciben. Si reciben varias cosas se ponen separadas por comas dentro de los paréntesis. Veamos un ejemplo:

Ejemplo 11: Diseña un programa que muestre por pantalla el carácter que quiera el usuario repetido el número de veces que quiera el usuario.

#include 

void muestra_char(char c, int n) {
     //recibe un caracter. Para referirnos a él en la función lo llamamos c
     //también recibe un entero, para poder usarlo lo llamamos n
     int i;
     for(i = 0; i < n; i++) {//hacemos un bucle desde 0 hasta n
           printf("%c\n", c);//muestra el carácter c
     }
}

int main () {
    int num_veces;
    char caracter;
    printf("Que caracter quieres que se muestre? ");
    scanf("%c", &caracter);
    printf("Cuantas veces se mostrara? ");
    scanf("%d", &num_veces);//recuerda que %i es lo mismo que %d
    muestra_char(caracter, num_veces);
    system("pause > null");
    return 0;
}

Si tienes dudas sobre este ejercicio para de leer y pregunta ahora por que se va a complicar.

Ahora veamos qué pasa cuando las funciones devuelven algo. Primero se indica antes del nombre de la función al crearla el tipo de datos que devuelve. En nuestro caso float (número con decimales). Para hacer que devuelva algo ponemos dentro de la función la palabra clave return seguida de lo que queremos que devuelva. En el momento que la función devuelva algo terminará inmediatamente y no se seguirán realizando las acciones que haya más adelante. En una misma función puede aparecer "return" varias veces, pero en cuanto la función llegue al primero devolverá ese valor y ya no seguirá haciendo nada más. Cuando usamos una función que devuelve algo podemos usar esa función como si usáramos el valor que devuelve. Es decir, si tenemos una función cinco() que devuelve 5 cuando pongamos cinco() es como si pusiéramos 5. No tiene demasiado sentido hacer una función que reciba siempre el mismo valor. Se suelen usar funciones que reciban algo y en función de lo que reciban devolverán una cosa u otra. Por ejemplo vamos a hacer un programa que reciba un array y su tamaño y devuelva la suma de todos sus elementos:

int suma_array(int array[], int tam) {
     int suma = 0, i;//donde se almacenará la suma de todos los elementos del array
     for(i = 0; i < tam; i++) {
           suma += array[i];
     }
     return suma;
}
Si queréis ver un ejemplo completo con función main que lo utiliza aquí está:
[code]#include 

int suma_array(int array[], int tam) {
     int suma = 0, i;//donde se almacenará la suma de todos los elementos del array
     for(i = 0; i < tam; i++) {
           suma += array[i];
     }
     return suma;
}

int main () {
    int array[5] = { 1, 1, 2, 1, 0 }; //la suma deberá ser 5 (1+1+2+1+0)
    printf("%i\n", suma_array(array, 5));
    system("pause > null");
    return 0;
}

Ahora vamos con unos cuantos ejercicios. No me entreguéis solo el código de la función, dadme el código entero del programa que usa esa función.

[u]Ejercicio 24 (B): Diseña una función que reciba dos números con decimales y devuelva su producto. Haz un programa que utilice esa función.[/u]

[u]Ejercicio 25 (M): Diseña una función que reciba dos arrays de enteros y el tamaño de cada uno y devuelva la semisuma (la mitad de la suma) de la suma de los elementos de ambos arrays. Haz un programa que utilice esa función.[/u]

[u]Ejercicio 26 (A): Diseña una función que reciba un carácter, un array de enteros y el tamaño del array. La función mostrará por pantalla el carácter tantas veces como valor tenga el elemento del array con más valor. Sólo lo hará si el mayor valor es positivo. Haz un programa que utilice esa función.[/u]

Aclaración del ejercicio 26: si por ejemplo la función recibe 'A' y el array {1, 3, 2} mostrará por pantalla A tres veces (el mayor valor del array). Sin embargo si recibe {-25, -7, -9, -2, -4, -100} No mostrará nada, ya que el mayor valor (-2) es negativo.[/i][/code][/i]

Hawkings

Post #1

Buenas a todos, inicio este hilo para tener organizado todo el curso. La idea es que aquí no postee nadie, las dudas y los ejercicios que vayáis haciendo se pondrán en el otro post, donde os apuntásteis. Para poder encontrar fácilmente cada ejercicio todos los posts que haga irán numerados, y todos los ejemplos y ejercicios también. Pido comprensión a los moderadores si hago multipost, pero si no lo hago el hilo no subiría y los posts se harían enormes. Creo que estará todo mucho más organizado así.

Antes de empezar quiero pedir que todos los resultados de los ejercicios los posteeis en un spoiler, para que los demás no los vean sin querer. Supongo que nadie viene a este curso obligado, así que no creo que miréis lo que han hecho los demás porque no aprenderíais. También quiero aclarar que todos los ejercicios son opcionales, si crees que no merece la pena hacerlos puedes saltártelos, e incluso puedes pedir alguno más difícil. Todos tendrán una aclaración de dificultad: B (Básica), M (media) y A (Avanzada).

[alinear-centro]INTRODUCCIÓN A LA PROGRAMACIÓN[/alinear-centro]

Antes de empezar a programar en C propiamente dicho, me gustaría que adaptárais vuestras mentes a la forma de pensar de un programador, a dividir todos los problemas en tareas sencillas que puedan ser resueltas por un ordenador, para ello usaremos algo llamado "diagrama de flujo" (en adelante DF). El DF es algo así como un esquema de lo que hace un programa, tiene la ventaja de que es muy gráfico y se ve muy claro.

Para crear el DF de un programa usaremos OpenOffice.org Writer (link en el otro post). Presupongo que todos tenéis nociones básicas de informática y sabéis instalar este programa, si hubira problemas posteadlos en el otro post. Para empezar abrimos un nuevo documento. Una vez abierto necesitaremos mostrar la barra de dibujo, esto se hace en:
Ver --> Barras de herramientas --> Dibujo
Ahora abajo nos saldrá una barra de herramientas con varios botones, nos interesa este:

Ahora os resumiré las formas que vamos a usar. No estoy seguro si su uso original es el que usaremos nosotros pero para el caso da igual. Para poner una forma la seleccionais y luego en el documento pincháis y arrastráis. Es bastante intuitivo, no creo que haya problemas con eso. Ahora veamos las formas básicas:

1- Este óvalo representa el inicio y el final del programa. Un programa tiene un único inicio y uno o más finales.
2- En el cuadro pondremos instrucciones básicas que queremos que haga el ordenador, por ejemplo multiplicar 2 nums. etc.
3- Este trapecio indica que el usuario introducirá datos en el programa. Por ejemplo si quieremos pedir al usuario que introduzca un número lo indicaremos con esto.
4- Esta figura representa "salida" por pantalla, para mostrar algún mensaje lo pondremos aquí.
5- Igual que el anterior, pero la información saldrá por la impresora en papel. Viene a ser lo mismo.
6- Este rombo indica "condición". Si queremos que un programa siga de un modo u otro según si una condición se cumple usaremos este símbolo. Ya lo detallaremos más adelante.

Ejemplo 1: Hola mundo en DF.

Las flechas las he hecho con el menú flechas de bloque que hay al lado del menú diagramas de flujo. No creo que tengáis ningún problema en entender este ejemplo, así que os planteo el primer ejercicio:

Ejercicio 1 (B): Diseña el DF de un programa que imprima en papel tu nombre.

En breve (probablemente hoy) tendréis el segundo post, os recuerdo que para las dudas van a este hilo http://foro.universojuegos.es/viewtopic.php?f=74&t=10279
Y los ejercicios que vosotros resolváis a este [http://foro.universojuegos.es/viewtopic.php?f=74&t=10326][1]">viewtopic.php?f=74&t=10326 allí os los corregiré.

PD: tanto para plantear una duda como para dar la solución de un ejercicio, agradecería que se incluyera el nº del post y del ejemplo/ejercicio, para aclararnos mejor.

Un saludo

[1]: <a href=

Hawkings

Post #2

Ahora voy a intentar explicaros lo que es una variable. Es una de las cosas más básicas de un programa, las variables. Una variable básicamente es algo que puede almacenar datos. Se llama variable por que eso que almacena puede cambiar. Por ejemplo podemos hacer una variable que se llame "número" (o como queramos) y que almacene el 3, y siempre que usemos "número" en el programa es exactamente lo mismo que si pusiéramos 3. Pero este valor podemos hacer que cambie y que en vez de 3 ponga 5 (por ejemplo). En este caso cuando se use "número" será como poner 5. Pero una variable puede almacenar palabras, letras, valores booleanos (verdadero y falso) y lo que se os ocurra.

Ejemplo 2: Diseña el DF de un programa que pida un número al usuario, le sume 1 y muestre por pantalla su valor.

Aquí se complica un pelín la cosa, pero es muy fácil. El programa empieza y muestra el mensaje: "introduce un numero". Ahora guarda lo que el usuario introduzca (acordaos de lo que significa esta figura) en la variable NUM. Ahora viene algo un poco más difícil: a la variable NUM (hacia donde apunta la flecha) le asigna el resultado de la operación de la derecha (desde donde apunta la flecha). Probablemente a muchos os parezca que queda mejor ponerlo al revés, con la operación a la izquierda y el resultado que se asigne a la derecha, pero en programación no se hace así. Aquí básicamente lo que hace es que NUM valga lo que valía antes más uno. Ahora sólo muestra el valor actual de NUM y termina.

Ejercicio 2 (B): Diseña el DF de un programa que pida al usuario un número, y muestre por pantalla el doble de ese número.

Ejercicio 3 (B): Diseña el DF de un programa que pida al usuario dos números, y que muestre por pantalla el resultado de restar al primero el segundo.

Ejercicio 4 (M): Diseña el DF de un programa que pida al usuario dos números, y asigne en una variable nueva el resultado de multiplicarlos. Por último el programa mostrará por pantalla el resultado de sumar esta tercera variable y la primera.

He intentado plantear los ejercicios de forma que no sean ambiguos y se entiendan bien. Para cualquier duda ya sabeis, el otro hilo. Mañana seguiremos con condiciones e iteraciones...

Hawkings

Post #3

Antes de continuar con el curso quiero aclarar bien el uso de las diferentes figuras, por que veo que más o menos sabéis lo que queréis hacer pero lo ponéis mal:

[attachment=4]

Como ya hemos dicho antes esta figura simboliza "mostrar en la pantalla". Lo que pongas dentro se mostrará. Si pones "Hola" se muestra "Hola" y si pones una variable se muestra su valor. Muy importante: no realiza asignaciones, lo que haya en esta figura se muestra y ya está sólo hace eso, aunque si ponéis una operación mostrará el resultado. Por ejemplo si tenéis una variable número y ponéis "número * 2" lo que mostrará será el doble del valor de número.

[attachment=3]

Esta funciona como la anterior, no la usaremos casi nunca. Lo que le pongas dentro lo muestra pero por impresora, cuando la pongo es por variar un poco pero su uso es igual, pones dentro algo y te lo imprime en un papel. Si es una variable imprime su valor.

[attachment=2]

Esta figura asigna asigna lo que el usuario teclee a la variable que haya dentro. Aquí sólo se pueden poner variables, cuyo valor (si existe) será cambiado por lo que introduzca el usuario. No podéis hacer asignaciones aquí dentro ni nada raro, sólo podéis poner una o más variables separadas con comas para que el usuario les de un valor. Es una buena costumbre poner antes un mensaje por pantalla al usuario indicándole que tiene que hacer.

[attachment=1]

Esta es la que peor usáis. Dentro de esta figura van operaciones básicas que ha de hacer el ordenador. De momento todo lo que sabéis hacer son asignaciones: asignar un valor a una variable, por ejemplo "A

Hawkings

Post #4

Youtube Video

Espero que haya quedado bastante claro xD, ahora unos cuantos ejercicios para practicar:

Ejercicio 8 (B): Diseña el DF de un programa que pida al usuario un número y le vaya restando 3 hasta que sea menor que -3. Antes de terminar mostrará su valor por pantalla.

Ejercicio 9 (M): Diseña el DF de un programa que vaya mostrando por pantalla todos los números del 1 al 100.

Ejercicio 10 (A): Diseña el DF de un programa que pida al usuario dos números (N y M). Si el N es mayor que M le dirá al usuario N veces que se ha equivocado y terminará, y si N es menor que M irá multiplicando N por dos hasta que sea mayor que M. (No hace falta que llaméis a vuestras variables N y M, es sólo para explicarlo bien).

Aseguraos de entender completamente esto porque ya es lo último con DF, si lo necesitáis podéis pedir más ejercicios para practicar pero es muy importante que lo entendáis y os salgan antes de seguir ya que lo siguiente de esto ya es el lenguaje C propiamente dicho.

Hawkings

Post #5

Ya hemos terminado con los diagramas de flujo, pero antes de ver el primer hola mundo en C os tengo que explicar unas cosillas para que no os suene completamente a chino. Hemos visto hasta ahora variables, pero nos falta algo muy importante en la programación: las funciones. Una función se caracteriza por llevar siempre paréntesis después de su nombre. Por ejemplo si tenemos una función que se llama mifuncion siempre llevará paréntesis al final, haya o no algo dentro de los paréntesis. En este caso sería mifuncion().
Se podría decir que hay cuatro tipos de funciones: las que no devuelven ni reciben nada, las que no reciben nada y devuelven un valor, las que reciben un valor y no devuelven nada y las que reciben y devuelven un valor. Ahora vamos a ver qué significa esto.

Funciones que no reciben ni devuelven nada: estas funciones básicamente sustituyen a una serie de comandos que siempre hacen lo mismo, por ejemplo si en un determinado programa necesitas varias veces poner "hola" por pantalla, pues haces una función que haga siempre eso, por ejemplo decir_hola() y cada vez que vayas a decir "hola" simplemente pones decir_hola() y el programa hará lo que haya dentro de la función, en este caso decir "hola". Una función de este tipo es clrscr(), que viene del inglés "Clear Screen" (limpiar pantalla) que lo que hace es borrar todo lo que haya escrito tu programa.

Funciones que reciben un valor y no devuelven nada: el valor que reciben estas funciones se indica entre los paréntesis. Por ejemplo queremos hacer una función que multiplique una variable por 3, se podría llamar multiplica_3(). Lo que hace es multiplicar por 3 el valor de la varible que recibe, por ejemplo si tenemos una variable num que vale 5, si hacemos multiplica_3(num) la variable num pasará a valer 15. Son de este tipo las funciones set_algo(), pero de momento no las vamos a usar, las menciono por si las conocéis lo las vemos que os suene. También es de este tipo la función printf(), que la veremos en el primer hola mundo.

Funciones que no reciben nada y devuelven un valor: al igual que si una variable la podemos usar en lugar de el valor que representan (por ejemplo si una variable Z vale 4 donde pongamos Z es como si pusiéramos 4), las funciones que devuelven un valor pueden usarse como el valor que representan, por ejemplo si una función mi_func() devuelve 4 donde pongamos mi_func() es como si pusiéramos 4, y podemos. Son de este tipo las funciones get_algo(), pero tampoco las vamos a usar.

Funciones que reciben y devuelven algo: estas funciones reciben un valor entre los paréntesis y devuelven otro. Si quisiéramos hacer lo mismo que con la anterior función multiplica_3() pero sin cambiar el valor de la variable por si la queremos usar usaríamos una función de este tipo. Por ejemplo la función triplica(), que recibe un número entre los paréntesis y devuelve su triple, por ejemplo, si ponemos triplica(10) es exactamente lo mismo que si ponemos 30. Hay infinidad de funciones de este tipo, veremos muchísimas durante el curso.

NOTA: una función solo puede devolver un valor, pero puede recibir varios, separados por comas. Ya veremos ejemplos de esto.

También me gustaría que supierais algo sobre los tipos de datos antes de ver un hola mundo. Los datos pueden ser de muchos tipos, pero principalmente números y letras. Al principio vermos sólo tres tipos de datos principales:
int (del inglés "integer"): son números enteros, por ejemplo 5, 214, -25, etc.
float: son números decimales, por ejemplo 1.5, 3.141592, -9.00, etc.
char (del inglés "character"): son caracteres del teclado, es decir letras, números y símbolos. Se indican siempre entre comillas simples (apóstrofes), por ejemplo 'a', 'U', '@', '2', etc. Sería incorrecto 'Hola', '85', '^#|' porque contienen más de un carácter, entre comillas simples sólo puede ir un carácter. Además si el carácter es un número, no puede usarse como tal, es decir poner '2' no es lo mismo que 2.

Hay otro tipo de datos, que no es un tipo de datos propiamente dicho en C, pero es muy usado. Son las cadenas de caracteres o "strings" en inglés. Son simplemente un conjunto de caracteres, y se indica que es una cadena de caracteres poniéndolo entre comillas dobles. Por ejemplo: "Hola", "85", "4aBX)", "a", "3". Todas estas son cadenas, una cadena está formada por al menos un carácter y al igual que en los caracteres poner "2567" no es lo mismo que 2567.

Ahora vamos a ver esto de los tipos de datos aplicado a variables. Las variables en C sólo pueden almacenar un tipo de datos. Por ejemplo si tienes una variable de tipo número entero (int) no puedes almacenar números con decimales (float). Si lo intentas perderá los decimales y se almacenará el número como si fuera entero. Para crear una variable se pone el tipo de datos que va a almacenar seguido de al menos un espacio en blanco y el nombre de la variable. Por ejemplo vamos a crear una variable de tipo número entero (int) llamada numero:

int numero

Además, todas las instrucciones, es decir, cualquier operación que hagas, para distinguirla de la siguiente debe acabar siempre en ";" así que vamos a poner el ";".

int numero;

Ahora acabaríamos de crear correctamente una variable de tipo int que puede almacenar números enteros. Con esto ya hemos terminado el preámbulo, vamos a ver el primer hola mundo en C.

[alinear-centro]PROGRAMACIÓN EN C[/alinear-centro]

#include 

int main() {
     printf("Hola mundo.");
     return 0;
}

Siento no tener tiempo ahora mismo para explicarlo y enseñaros a ejecutarlo en Dev-C++, procuraré que el próximo post sea lo antes posible, pero tengo bastantes exámenes esta semana. De momento intentad asimilar todo lo que hay antes del Hola mundo, pero no os ofusquéis si no lo entendéis, pronto llegarán ejemplos.

Pido perdón una vez más por tener que dejarlo aquí, saludos.

Hawkings

Post #6

Bien, aquí está el post que todos esperábais, donde explico el hola mundo y vamos a aprender un poquito más de C.

Primero una mini introducción para aprender a manejar Dev-C++. Supongo que todos vosotros sabéis instalar un programa así que empezaré con el programa ya instalado, vamos a abrirlo.

[attachment=0]

En Archivo --> Nuevo vemos que tenemos dos tipos de archivos a crear, proyectos o códigos fuente. Un código fuente creará un programa que sólo tiene un fichero, todo lo que hace está contenido en ese fichero, todas sus funciones, todas sus variables, todo en el mismo fichero. Nosotros al principio siempre crearemos un nuevo código fuente para cada programa, pero si queremos repartir todo en varios archivos para que quede más ordenado crearíamos un nuevo proyecto. Un proyecto incluye todos los códigos fuentes que queráis, y el programa final los tendrá todos juntos. Vamos a crear un nuevo código fuente (asegúrate de ponerle la extensión .c y no la que viene por defecto, cpp), e introducimos el código anterior del Hola mundo:

#include 

int main() {
     printf("Hola mundo.");
     return 0;
}

Antes de ejecutarlo vamos a intentar comprenderlo un poquito. A una función tenemos que decirle lo que queremos que haga, pero hay funciones que ya hicieron los creadores de C, por ejemplo printf(), para poder usarlas tenémos que poner la primera línea:

#include

#include viene del inglés y significa "incluir", aquí estamos incluyendo stdio.h que es donde los creadores de C guardaron lo que hacen diversas funciones, como printf().

Más adelante encontramos

int main() {

Un nombre con paréntesis detrás, ¿os suena? Exacto, es una función, en todos los programas la función main() será la que se ejectutará al abrir el programa, es decir cuando abramos el programa hará lo que tenga dentro la función main(). el int de delante significa que la función devuelve un número entero. Al "declarar" (crear) una función o al "implementarla" (decir lo que hace) ponemos delante lo que devuelve. Si no devuelve nada ponemos void (literalmente significa vacío). Después para usarlas cuando ya están declaradas e implementadas no se pone.
¿Cómo decimos a una función que queremos que haga? Para implementarla, ponemos primero el tipo de datos que devuelve la función (en este caso int). Después el nombre de la función (en este caso main) seguida de paréntesis, y si recibe algo la función, lo ponemos dentro (en este caso no recibe nada). Ahora viene una llave de apertura, y la función hará todo lo que pongamos desde ahí hasta la llave de cierre. Todo lo que hay desde esta llave hasta la del final es la función main. Veamos qué hace:

Primero tenemos otra función, printf() que recibe una cadena de caracteres (string) y lo que hace simplemente es mostrarla en pantalla. En este caso mostramos en pantalla "Hola mundo.". No tiene mayor dificultad, esta función equivale a la figura de mostrar en pantalla que usábamos en DF, y como todas las instrucciones u órdenes en C acaba con ";".

Habíamos dicho antes que la función devolvía un número entero, pero, ¿cómo ponemos eso? pues con la palabra "return" que significa "devolver". Como no es una función no lleva paréntesis después, después de esta palabra ponemos lo que queremos que devuelva. Se supone que un programa ha terminado correctamente si su función main devuelve 0, así que ponemos

return 0;

Como siempre terminando en ";". Ahora como ya hemos terminado de implementar la función main() pues cerramos la llave que abrimos antes.

Ahora vamos a probarlo en Dev-C++, copiamos el código y lo pegamos en un código fuente nuevo, y ahora le damos a
Ejecutar --> Compilar
El programa estaba escrito hasta ahora en lenguaje relativamente humano, el texto lo podíamos entender, pero el ordenador esto no lo entiende, así que hace falta compilarlo para "traducirlo" a un lenguaje que el ordenador entienda. Os pedirá un lugar donde guardar el archivo, lo ponéis donde queráis con extensión ".c" y le dais a guardar. Ahora lo compilará, al compilar primero buscará errores, si tenéis algún error os lo avisará, si pone "error" el error es tan grave que el programa no se podrá ejecutar, pero si pone "warning" es posible que el programa puede ejecutarse o es posible que se produzca algún error. Una vez compilado, en la ruta donde le habéis puesto que se guarde, encontraréis el código fuente (nombre_programa.c) y el archivo ejecutable, listo para ejecutarse en cualquier ordenador (nombre_programa.exe).
Si abrís el exe directamente con doble clic os daréis cuenta de que sale una ventana y rápidamente se cierra, esto es porque el programa se ha ejecutado, ha terminado y como ha terminado se ha cerrado. Para evitar que se cierre en el programa hay un pequeño truco, dentro de la función main, tenemos que poner, justo antes de return 0; una línea que ponga system("pause");
De esta forma antes de que el programa termine saldrá: "Pulse una tecla para continuar . . ." y hasta que no pulses una tecla el programan no terminará. Si queréis que no salga ese texto, y simplemente espere a que pulséis una tecla poned
system("pause > null");
Esto no lo voy a explicar en el tutorial por que no es C, es Batch (el lenguaje de la consola de comandos de windows), pero si alguien quiere que se lo explique que me pregunte en el post de dudas. El programa ahora para que no se cierre queda así:

#include 

int main() {
     printf("Hola mundo.");
     system("pause > null");
     return 0;
}

Ahora le volvéis a dar a compilar para que se actualice el programa, si queréis le podéis dar a "compilar y ejecutar" que al terminar de compilar si no hay errores ejecuta el programa.

Con esto termina el post #6, ahora un ejercicio para practicar, a ver si os suena

Ejercicio 11 (B): Diseña un programa que muestre tu nombre por pantalla.

Sé que os he metido mucha información de golpe, así que esperaré a responder las dudas antes de seguir y poneros más ejercicios.

Hawkings

Post #7

Antes de seguir vamos a repasar un poco cómo se creaban variables. Primero poníamos el tipo de datos, después el nombre de la variable (el nombre de la variable no puede empezar por un número, y no puede llevar acentos) y por último ";", por ejemplo:

int minumero;

Si queremos hacer muchas variables del mismo tipo de datos, tenemos dos opciones, o ponemos muchas veces lo mismo:

int num1;
int num2;
int num3;
int num4;

O si preferimos hacerlo más corto, ponemos una vez el tipo de datos y después, separados por comas, los nombres de todas las variables. Veamos un ejemplo:

int num1, num2, num3, num4;

Ahora sabemos declarar (crear) variables, pero, ¿cómo las usamos? Antes usábamos la flecha

Hawkings

Post #8

Ahora os voy a enseñar algunas cosas que no son imprescindibles para programar, pero que hacen más fácil a otras personas (o incluso a vosotros) leer el código. Primero os enseñaré a poner comentarios. Un comentario es un texto que no se tiene en cuenta a la hora de compilar el programa, es simplemente para hacer aclaraciones o para poner algo y leerlo luego, lo puedes poner directamente en el código y no modificará el programa, se ignoran luego los comentarios a la hora de compilar. Hay dos formas de comentar un texto. La primera es encerrarlo dentro de /* */. Todo lo que haya entre /* y */ será un comentario. Este tipo de comentarios puede ir en cualquier sitio y puede ocupar varias líneas. El otro tipo de comentario es un comentario de línea, y va desde // hasta el final de la línea. Por ejemplo:

#include 

int main() { //Declaramos la función main (esto es un comentario).
    int /*hacemos una variable de tipo entero */ minumero; //y la llamamos minumero.
    /*Ahora vamos a asignarle
    un valor, por ejemplo 7*/
    minumero = 7;
    printf("%i",minumero);/*y ahora la mostramos por pantalla*/
    system("pause > null");
    return 0; //y terminamos el programa.
    //podemos poner lo que sea en un comentario y se ignorará
    /*printf("esto no se muestra");*/
}

Si introducimos esto en Dev-C++ veremos que nos pone los comentarios en otro color.

Ahora os voy a enseñar a tabular correctamente un código. Hasta ahora lo habéis hecho imitándome, y os ha ido bastante bien, pero creo que debo enseñaros cómo se hace. Os aviso que un programa en C funciona exactamente igual esté bien tabulado o no, incluso podéis poner el programa en una línea y no dará ningún error (siempre que pongáis bien los ";"). Un bloque es todo el código que esté encerrado entre dos llaves ({ y }). Puede haber bloques dentro de otros bloques. En general se empieza el programa con el texto pegado a la izquierda. Cuando llegamos a una llave de apertura ({) todo lo que haya después hasta la llave correspondiente de cierre (}) irá separado de la izquierda del todo pulsando una vez la tecla TAB, pero la llave de cierre ya estará a la distancia normal. Dev-C++ os pone automáticamente un tabulador cuando pulsáis ENTER si en la línea en la que estáis ya hay uno. Además cuando abrís una llave y pulsáis ENTER también os tabula automáticamente la línea siguiente. No es muy difícil de pillar, cada vez que abráis una llave, y hasta que cerréis el bloque, todas las líneas de dentro empezarán con una tabulación más.

Otra buena práctica en programación, pero que tampoco es necesaria (el programa funcionará igual) es crear todas las variables que vayamos a usar al principio, y no poco a poco mientras las vayamos usando. También es común crear todas las variables al principio poniendo solo una vez el tipo de datos y luego separando los nombres por comas. Así alguien que vea vuestro código verá de un tirón todo lo que vais a usar. Os pido por favor que lo hagáis vosotros así, por que es más cómodo para corregirlo.

Lo último que queda es hablaros de los nombres de las variables. Os recomiendo que pongáis nombres coherentes, puede que el programa funcione si llamas a tus variables wqercgdfgd pero se entiende mejor si poneis numero1 o suma o letra que si les poneis nombres sin sentido. Hasta ahora no habéis tenido problemas con los nombres de las variables, pero por si acaso debo deciros qué nombres les podéis poner y qué nombres no. Esto sí es importante ya que si lo hacéis mal el código no funcionará. El nombre de vuestras variables NO pueden empezar por un número pero sí pueden llevar un número después. Podeis usar letras SIN ACENTOS de la a a la z sin incluir la ñ; mayúsculas o minúsculas, y también el símbolo _. Se suele usar este símbolo en lugar de un espacio, por ejemplo como no podéis hacer una variable que se llame "fecha nacimiento" por que los espacios no están permitidos, podéis hacer una que se llame "fecha_nacimiento". Por convenio (aunque vosotros podéis no hacer caso y funcionará igual) las variables sólo contienen letras minúsculas, no mayúsculas, pero repito que podeis no hacer caso. Por último hay una serie de palabras que pertenecen al lenguaje C y no podéis usar como nombre de vuestras variables. Se llaman palabras clave o palabras reservadas (keywords) y son las siguientes:

auto break case char const continue default
do double else enum extern float for
goto if int long register return short
signed sizeof static struct typedef union unsigned
void volatile while

Ahora vamos a aprender a usar condiciones en C. Las condiciones usan la palabra clave if. Se usa de la siguiente forma:

if(condicion) {
     accion
}

Pero, ¿qué condiciones podemos usar? Ya las vimos en el post #3, con la única diferencia de que en C = es para asignar un valor, así que para comparar se usa == (dos signos igual). Repasemos un poco:
valor1 == valor2 será verdadero si son iguales, y falso en cualquier otro caso.
valor1 != valor2 será verdadero si son diferentes, y falso en cualquier otro caso.
valor1 < valor2 será verdadero si valor1 es menor que valor2, y falso en cualquier otro caso.
valor1

Hawkings

Post #9

En el post de hoy vamos a aprender a hacer bucles, pero antes voy a resolver el ejercicio 16, que en general ha salido bastante mal. No os preocupéis, miradlo aunque no lo hayáis resuelto bien, después vienen más ejercicios y me interesa que aprendáis a tabular bien el código porque es mucho más cómodo de corregir.

Ejercicio 16:

#include  //para poder usar printf y scanf

int main() { //Ahora abrimos una llave, a partir de aquí con una tabulación
    int num1, num2, num3; //creo todas las variables que voy a usar al principio del programa
    printf("Introduce un numero: ");
    scanf("%i",&num1);
    fflush(stdin); //Como después voy a usar otra vez scanf pues pongo esto
    printf("Introduce otro numero: ");
    scanf("%i",&num2);
    fflush(stdin);
    /* Lo que voy a hacer a continuación también se puede hacer con
    dos variables en una se guarda la suma y en la otra el producto */
    if( (num1+num2) < (num1*num2) ) { //Abrimos una llave, a partir de ahora una tabulación más
        /* Aquí también podemos hacerlo creando una variable antes */
        printf("%i\n", (num1*2));
    } //CIERRO una llave, a partir de esta línea incluyéndola una tabulación menos
    /* Así se puede ver perfectamente donde empieza el if y donde termina,
    además se ve de un tirón todo lo que hay dentro */
    else { //Vuelvo a abrir llaves, una tabulación más
         printf("Introduce otro numero mas: ");
         scanf("%i",&num3);
         if(num3 != 4) { //Otra llave abierta, ya sabéis lo que significa
                 printf("Hasta luego.\n");
         } //Cierro una llave, así que quito una tabulación
    } //Ahora cierro la llave del último else, ¿verdad que se ve más claro así?
    system("pause > null"); //Para que el programa se pare antes de terminar
    return 0; //Con esto termina.
} //Ahora como cierro main quito la tabulación que quedaba

A continuación vamos a ver bucles, repeticiones o iteraciones, como queráis llamarlos. Al igual que en DF hay de dos tipos. De los que conocemos el número de repeticiones y de los que no. Vamos a empezar a ver los que no, son los bucles "while":

while(condición) {
    acción
}

Eso se leería "mientras que condición sea verdadero, repetir acción". Vamos a ver un ejemplo para que quede más claro:

Ejemplo 7: Diseña un programa que pida al usuario un número, y lo vaya multiplicando por dos y mostrando su valor hasta que sea mayor que 250.

#include 

int main() {
    int numero;
    printf("Introduce un numero: ");
    scanf("%i",&numero);
    while(numero < 250) {
        numero *= 2;
        printf("%i\n",numero);
    }
    system("pause > null");
    return 0;
}

Lo único que os habrá extrañado del programa es donde pone numero *= 2. Esto significa lo mismo que numero = numero * 2 pero no es el único que hay, vamos a ver varios:

variable += n es lo mismo que variable = variable + n
variable -= n es lo mismo que variable = variable - n
variable /= n es lo mismo que variable = variable / n
variable *= n es lo mismo que variable = variable * n
variable++ es lo mismo que variable += 1
++variable es lo mismo que variable++
variable-- es lo mismo que variable -= 1
--variable es lo mismo que variable--

En realidad hay una pequeña diferencia entre variable++ y ++variable, y entre variable-- y --variable; pero aún no la vamos a ver.

Ahora veamos bucles pero cuando conocemos el número de repeticiones. Se usa el bucle "for". Se escribe así:

for(asignación;condición;operación) {
     acción
}

Este es más difícil de entender, vamos a ir paso a paso. Este bucle necesita de una variable que se use como contador. A las variables que se usan como contador en los bucles for todo el mundo las llama i, pero como son variables podrían tener cualquier nombre. Así que antes creamos una variable. En el bucle for, en la parte de asignación le damos un valor a esa variable. El 99.9% de las ocasiones pondréis i = 0. Después viene la parte de condición, ahí se pone una condición. Mientras esa condición se cumpla el bucle se seguirá repitiendo. Ahí casi siempre pondréis i < (otro_numero), pero podéis poner cualquier condición. La útima parte se deja para poner operaciones como i = i * 2. Ahí también pondréis el 99.9% de las veces i++.

Sé que es bastante difícil de coger al principio vamos a ver un ejemplo para comprenderlo mejor:
Ejemplo 8: Diseña un programa que cuente del 0 al 9.

#include 

int main() {
    int i;
    for(i = 0; i < 10; i++) {
          printf("%i\n",i);
    }
    system("pause > null");
    return 0;
}

Primero creamos la variable i (podría llamarse de otra forma pero a las variables contador en un for todo el mundo las llama i). Ahora en el bucle for ponemos primero a i el valor 0. Se repetirá mientras que valga menos que 10 (cuando valga 10 ya no se cumple la condición y no se repite). Después de cada repetición lo que hará es i++ (aumentar en 1 el valor de la variable). Dentro del bucle ponemos lo que queremos que se repita, en este caso mostrar el valor de i. Este bucle se podría leer algo así como "para i = 0 mientras que sea menor que 10, aumentamos i en 1 y mostramos el valor de i".

Bueno, enhorabuena a todos, ya hemos llegado a donde llegamos con DF pero en C, lo que significa que a partir de ahora todo lo que veremos será nuevo completamente. Próximamente veremos lo que son arrays y estructuras, crearemos nuestras propias funciones y aprenderemos a trabajar con strings, pero antes unos cuantos ejercicios:

Ejercicio 17 (B): Crea un programa que pida al usuario tres números y vaya multiplicando los tres números por 4 hasta que uno de ellos sea mayor que 500.

Ejercicio 18 (A): Crea un programa que pida al usuario dos números. Después creará una variable y le asignará el valor 0. Mientras que esa tercera variable no sea mayor de 50 irá sumandole alternativamente el primer número y el segundo. Al terminar mostrará por pantalla 1 si la última variable que sumaste a la tercera fue la primera, y mostrará 2 si la útima que sumaste a la tercera variable fue la segunda.
El 18 es el más difícil que os he mandado hasta ahora, no os desesperéis si no os sale, es normal.

Ejercicio 19 (B): Crea un programa que cuente del 1 al 10 de uno en uno.

Ejercicio 20 (M): Crea un programa que pida al usuario un número. Si el número es negativo dirá hola 15 veces y terminará. Si el número es positivo el programa contará de 4 a -8 de uno en uno.