Tres en Raya. Parte IV.

Como añadí en el comentario de la parte III de este juego, he buscado cómo añadir un control para que el usuario no pueda introducir un valor incorrecto al pedir un número. He cogido este código de internet  ( http://www.cristalab.com/tutoriales/validacion-de-tipos-de-datos-en-c--c92149l/ ).

Para utilizarlo se puede utilizar como condición que sea un número correcto y si no es así, que repita un bucle para volver a introducir el valor correcto o salir del programa. Exactamente igual que en el "main" cuando preguntamos al usuario si quiere volver a jugar o no.

Juego del ahorcado. Parte I.

Creo que todos conocemos el juego del ahorcado, en el que hay que adivinar la palabra oculta a través de sus letras (como la ruleta de la fortuna, pero más macabro). Vamos diciendo letras, si la palabra o frase contiene esa letra, se nos indica la posición o posiciones en los que se encuentra, si no contiene esa letra, se pierde una "vida" o lo que es lo mismo, se pinta una de las líneas que forman el muñequito del ahorcado, si el muñequito termina de formarse sin acertar la palabra, has perdido.

Como este será seguramente el último ejemplo práctico como aplicación de consola, me gustaría enfocarlo de una forma diferente, más en el diseño que en mostrar el código ya hecho. Vamos a empezar analizando los requisitos:

Para la primera versión, dispondremos de un fichero de texto en el que estarán las palabras que pueden aparecer en el juego, de ahí se seleccionará una palabra y se mostrará en pantalla el contador de vidas (para la primera versión no vamos a pintar muñequito) y la representación de las diferentes letras de la palabra. Se solicitará al usuario que introduzca una letra y se comprobará si ésta está contenida en la palabra, en caso afirmativo, se pintarán todas las coincidentes y en caso negativo, restaremos una "vida". Si el usuario completa la palabra gana y si se terminan sus vidas, pierde. Debe haber una opción para que el usuario pueda dejar de jugar en cualquier momento.

Tenemos una idea clara y concreta de qué nos están pidiendo, ¿pero cómo lo hacemos? Vamos a dividir el problema en partes más sencillas:
   1. Elegir y coger una palabra del fichero.
   2. Mostrar por pantalla el "tablero" de juego.
   3. Procesar cada palabra que introduzca el usuario.
   4. Ofrecer al usuario una opción de salida y de volver a jugar al terminar.

El primer paso, es aprender a abrir el fichero de texto (esto lo aprenderemos a hacer en el próximo post). Una característica de estos ficheros, es que hay que extraer su información línea a línea (en nuestro caso, como tendremos una sóla palabra por línea, será palabra a palabra), es decir, no podemos elegir a qué linea acceder directamente. Aquí podemos ver un ejemplo de un fichero de palabras:

Para escoger una palabra para el juego, se me han ocurrido dos ideas (todas las sugerencias serán bienvenidas):
 La primera opción es coger directamente la primera palabra (el usuario jamás debe tener acceso a esta lista de palabras, sería trampa) utilizarla para el juego y al terminar, colocarla en el último lugar de la lista. Esta opción es la que menos recursos utiliza y nos va a enseñar mucho sobre cómo manejar ficheros.
La segunda opción es mantener intacto el fichero, copiar todo su contenido y manejarlo de forma interna en el programa. La parte buena es que será mucho más rápido, ya que sólo tendrá que abrir y leer el fichero una vez.

Mañana seguiremos viendo cómo hacer las siguientes partes del programa.

Tres en Raya. Parte III.

Vamos a ver en detalle las diferentes funciones que invoca el 'main'. La primera y más sencilla es 'reiniciarTablero'. Es una función destinada a poner en blanco el tablero de juego (en nuestro caso, en blanco supone el valor '-1'). Para ellos utilizamos dos bucles 'for' anidados (uno dentro de otro) para recorrer todas las posiciones de la matriz de dos dimensiones.

La siguiente función es 'pintarTablero'. Como su nombre indica, pinta el tablero de juego. Primero añade muchas líneas en blanco para que no se vea el tablero anterior y después comienza a pintar el tablero. Para saber qué valor hay que pintar (vacío o el símbolo de uno de los jugadores) utiliza la función 'comprobarValores' que veremos más adelante.

Esta función 'comprobarTablero' repasa las condiciones para que el último jugador que haya jugado (cuyo número se pasa como argumento) gane la partida, es decir, tres símbolos en raya. Si ha ganado la partida devuelve 'true' y si no es una jugada ganadora, devuelve 'false'.

La función 'comprobarValores' es la que es llamada desde 'pintarTablero' y se encarga de decirnos qué valor debemos dibujar en cada casilla. Si el valor es '-1' se dibuja la casilla en blanco, si el valor es 0 se dibuja '()' y si es 1 se dibuja ')('. Esto lo realiza para una línea completa.

La función más interesante es la función 'jugada'. Un jugador introduce las coordenadas de la casilla que quiere ocupar, se comprueba que las coordenadas son correctas, si es así, almacena el valor correspondiente en el tablero y se pinta el tablero actualizado. Después se comprueba si la jugada es ganadora y por último, se comprueba si el tablero está completo (el contador está a cero, es decir, se han terminado las casillas libres).

Y con esto... está listo el programa. ¿Alguna sugerencia para una modificación o mejora?

Tres en Raya. Parte II.

Por fin, aquí tenemos el main de nuestro juego. Es más corto que los anteriores, cada vez intentaremos que sea más y más pequeño y que el peso del programa recaiga en las funciones.

Al principio vemos las variables más importantes: una matriz 'valores' que guardará los valores del tablero, un contador que cuenta atrás desde 9 para saber si el tablero está completo, una variable para indicar que salimos del programa y una variable 'char' (un carácter) para almacenar la opción que elegimos cuando nos pregunta si queremos seguir jugando o no.

Después podemos ver las llamadas a nuestras funciones. Vamos a recordar la lista de funciones que ya comentamos en la entrada anterior:

       * 'reiniciarTablero' --> Es una función que reinicia el tablero, es decir, lo vacía de fichas.
       * 'pintarTablero' --> Dibuja en pantalla el tablero incluyendo las fichas introducidas.
       * 'comprobarValores' --> Esta función es llamada desde 'pintarTablero' y es la que se encarga de que cuando una ficha está en una casilla, la función que pinta, coloque el "dibujito" que corresponde con la ficha.
       * 'comprobarTablero' --> Es una función para comprobar si el último jugador que ha colocado una ficha ha realizado una jugada ganadora.
       * 'jugada' --> Es la función que permite a un jugador colocar una ficha en el tablero.


Podemos ver en el main la llamada a reiniciarTablero y pintarTablero nada más empezar, es decir, lo primero es reiniciar todo y mostrar el tablero.

Con el do-while hacemos que todo se repita hasta que los jugadores decidan que ya no quieren jugar más (opción 'N' a la pregunta de si quiere volver a jugar). Lo que caracteriza a todos los juegos es justamente un bucle que se repite mientras el jugador no quiera terminar.

Ahora viene algo nuevo e interesante, hemos metido en un if una función. Esto es totalmente posible siempre que el valor que devuelva la función sea coherente con la condición del if.

En este caso, la función jugada devuelve bool (true o false), es decir 100% compatible con la condición del if. ¿Qué supone esto? Pues en este caso para obtener el valor que devuelve la función, debe ejecutarse y una vez ejecutada, comprobamos si todo ha ido bien y si ha habido algún contratiempo, se ejecuta la salida del bucle.

El símbolo '!' delante de una variable bool o una función que devuelve bool significa 'lo contrario', es decir, el if se ejecutará si hay algún contratiempo. El símbolo '||' significa 'OR' (o en inglés) significa que todo será verdadero si se cumple la parte de la derecha 'o' la parte de la izquierda.

Para la llamada a la función jugada, introducimos el número de jugador (0 para redondos y 1 para Xs), el estado actual del tablero (sus valores) y el contador con las casillas que quedan libres. Lo llamamos dos veces para que juegen los dos jugadores una vez en cada ronda.

Si la partida ha finalizado, entramos al if y preguntamos al jugador si quiere jugar otra partida o prefiere dejarlo. Si prefiere jugar otra partida, reiniciamos el juego (vaciar tablero y colocar el contador con el número de casillas vacías a 9),

En la próxima entrada seguimos con las funciones.

Tres en Raya. Parte I.

¡Empezamos con el Tres en Raya! Antes de entrar a ver código, quiero que visualicéis cómo va a ser el programa y que intentéis ver cómo se podría hacer con todo lo que ya conocemos:
       - Bucles para repeticiones.
       - Condiciones para actuar de diferente manera según los valores que va tomando el programa.
       - Funciones para reciclar el código.
       - Matrices para almacenar datos.

Al no tener ratón, para introducir la casilla en la que queremos colocar la "marca" se introduce la línea y la columna. Si el valor es correcto (entre 1 y 3), se comprueba si es una jugada ganadora y si no es así, se comprueba si el tablero está completo, en ambos casos, termina la jugada.

Nuestros jueguecillos simples empiezan a ser cada vez más complicados y más largos, por eso hay que empezar a estructurarlos mejor. Esto se hace incluyendo cada vez más funciones y dejando un main cada vez más pequeño y más simple que se dedica a ir llamando a las funciones según las necesita.

En un principio tenemos 5 funciones. No todas se llaman desde el main, en muchos casos, una función puede ser llamada por otra función, podemos utilizarlas como queramos.
       * 'reiniciarTablero' --> Es una función que reinicia el tablero, es decir, lo vacía de fichas.
       * 'pintarTablero' --> Dibuja en pantalla el tablero incluyendo las fichas introducidas.
       * 'comprobarValores' --> Esta función es llamada desde 'pintarTablero' y es la que se encarga de que cuando una ficha está en una casilla, la función que pinta, coloque el "dibujito" que corresponde con la ficha.
       * 'comprobarTablero' --> Es una función para comprobar si el último jugador que ha colocado una ficha ha realizado una jugada ganadora.
       * 'jugada' --> Es la función que permite a un jugador colocar una ficha en el tablero.

Mañana empezamos a ver el código y a explicar cómo funciona todo. Pero mientras, aquí os pongo un vídeo algo cutre del funcionamiento:

El juego de las siete y media. Parte V.

Y por fin, ¡la última modificación para nuestro primer juego! Me hace ilusión que esto avance y vayan saliendo cosillas interesantes. Ahora nuestra baraja es como una de verdad, no puede haber dos cartas iguales y se van gastando. Cuando se termina, se coge una nueva. Algo así:

En esta modificación he decidido incluir algo muy muy importante, el concepto de función. Básicamente una función es un trozo de código, que como se va a repetir más veces, para que quede más claro y más práctico, se saca fuera del main y se le llama cuando sea necesario. Vamos a verlo:

Justo antes del main aparece nuestra función, se llama 'inicializarBaraja' y dentro de ella se han anidado dos bucles 'for' para inicializar toda una matriz de dos dimensiones y también inicializa a 40 un contador. Bien ¿para qué sirve esto? Pues hemos creado una baraja imaginaria (la matriz de dos dimensiones) con 4 palos y 10 cartas cada uno. Le hemos dado un valor bool (verdadero o falso) según se haya utilizado esa carta o no. El contador de baraja es una cuenta atrás desde 40 cada vez que se utiliza una carta, así cuando la baraja se termina, este contador nos avisa.

¿Cómo estamos utilizando la función? Había pensado en poner un post teórico sobre esto, pero sería un rollo y creo que mejor ir viendo casos, así que vamos a ver cómo funciona ésta.

La palabra que hay delante del nombre nos dice el valor que devuelve, en este caso, la palabra 'void' (vacío en inglés) nos dice que no va a devolver nada.

Entre paréntesis detrás del nombre aparecen las variables que se le pasan a la función, en este caso, la baraja y el contador (hay que incluir el tipo de datos y el nombre es independiente). Fíjate que antes del nombre del contador aparece un '&', esto significa (sin entrar en detalles técnicos) que se puede modificar el valor de esa variable, en el caso de la matriz, no es necesario añadirlo.

Poco a poco iremos viendo más funciones y todo irá quedando más claro.

Ya en el 'main' podemos ver que al principio de la ejecución se llama a la función inicializarBaraja para hacer lo que sería "barajar la baraja" (qué mal suena). Después tenemos:

Al hacer una jugada (sacar una carta) comprobamos si la baraja está vacía (contadorBaraja == 0), si es así, avisamos con un mensaje y volvemos a inicializar la baraja, es decir, coger una baraja nueva.

Una vez tenemos los dos números aleatorios (palo y valor), comprobamos en nuestra baraja si esa carta en concreto se ha utilizado ya o no, en caso de que sí se haya utilizado (el valor de su posición sea 'true') utilizamos un 'continue' (continúa en inglés), esto supone avanzar el bucle justo a partir de ese punto, es decir, en nuestro caso, no seguiría mostrando la carta y añadiendo el valor, sino que directamente pasa a sacar una nueva carta y esto se repite hasta que tengamos una carta válida, entonces es cuando ponemos a 'true' su posición en la baraja y restamos uno al contador de la baraja.

Y ale, si no se os ocurre ninguna modificación más, aquí hemos terminado nuestro juego de las siete y media.

El juego de las siete y media. Parte IV.

La modificación para que muestre la carta que sale en concreto puede ser muy sencilla, por ejemplo, además del número aleatorio de 1 a 10 para el valor de la carta, añadir otro aleatorio de 1 a 4 para el palo.

He añadido algo nuevo muy interesante, una alternativa a los if-else largos, es el switch-case. Se le pasa una variable, por ejemplo el número de la carta o el palo, y según el valor que tenga, se ejecutan unas cosas u otras. En el código podemos ver cómo se usa, tanto para el valor de la carta como para el palo.

Vamos a verlo:

El switch no deja utilizar double para la carta, sólo acepta valores enteros, así que hemos cambiado carta a 'int' y hemos creado una nueva variable "valor" como double y así guardar el valor concreto de cada tabla.

En el primer switch podemos ver cómo según el valor de 'carta' se muestra un mensaje según el valor ('case' es caso en inglés, es decir, se ejecuta un código para cada caso). Con el 'break' hacemos que pare la sección de código para cada 'case'. El segundo switch para el palo es exactamente igual.

Podéis ver cómo vamos encadenando los 'cout' para ir generando mensajes por partes con diferente información según nos interese.

La siguiente modificación es lógica después de ésta. Si ahora sabemos qué carta está saliendo, sería raro que apareciese varias veces la misma carta, por eso vamos a controlar que no aparezca dos veces la misma carta, es como tener una baraja que se va utilizando, cuando se termine, empezamos una nueva (o se reutiliza la baraja anterior completa, que para nosotros es lo mismo).

Señoras y señores, ¡a programar!

IDE para crear aplicaciones visuales.

Según avanzamos, dentro de no mucho habría que empezar a hacer cosillas visuales (típico programa interactivo con botones, vamos, lo que usamos normalmente) y dejar lo antes posible la pantallita negra estilo MS-DOS. Como para pasar a las aplicaciones de pantalla fue todo muy precipitado, este post lo quería colocar con más tiempo.

Sólo he utilizado dos aplicaciones para crear este tipo de programas, el Microsoft Visual Studio y el Qt Creator. El Qt Creator me gustaría dejarlo para más adelante, algo así como una evolución desde C++ a Qt, así que por el momento, creo que voy a utilizar la versión gratuita del Visual Studio (versión Express) que se puede descargar desde aquí:
                    
                           Microsoft Visual Studio Express

Si alguien tiene alguna otra proposición, podemos verlo. También cotillearé un poco por ahí cuando tenga un ratillo por si hubiese alguna otra opción interesante.

El juego de las siete y media. Parte III.

MODIFICACIÓN: Mostrar el podio con los tres ganadores de la partida.

Vamos a ver primero un ejemplo de código de cómo hacerlo y luego las cosas interesantes que hemos añadido:

Este es el resultado de una partida cualquiera:

Se puede ver cómo se han cogido los tres jugadores con puntuaciones más altas y se han colocado en el podio.

Ahora vamos a ver detalladamente el código. Lo más llamativo es algo que no había comentado antes, en realidad, son dos cosas en una: el uso de la memoria estática y los arrays de varias dimensiones. Suena muy técnico, pero no es tan complicado.

La memoria estática se da cuando el valor de un array es siempre fijo, se puede construir desde el primer momento, no es necesario hacerlo más tarde con la palabra new. Un array normal en memoria estática se declararía así:    
     
                                                  double podio[3];

Así se montaría una "estantería" de tres pisos desde el primer momento y con tamaño fijo (la ventaja de la memoria dinámica es que se puede modificar el tamaño).

Los arrays (matrices o como le hemos llamado aquí "estanterías") pueden ser de varias dimensiones, ¿y qué significa esto? Pues imaginemos nuestra estantería, en un array simple de, supongamos 4 estantes, tenemos un sólo mueble de 4 estantes. Ahora imaginemos que en vez de un mueble, montamos 2, tendríamos dos estanterías de 4 estantes cada una. Y así indefinidamente.

Si vemos el código, vemos que tenemos
          
                                                  double podio[3][2]

si seguimos con la metáfora de las estanterías, esto se correspondería a 3 estanterías, con dos estantes cada una. Concretamente, tenemos las tres posiciones del podio, cada una con dos espacios para guardar números, en el primer espacio almacenamos el resultado de la jugada y en el segundo el número que identifica al jugador.

Cuando el programa encuentra un valor que es mejor que el primer valor (el oro), modifica todo el podio bajando una posición al primero y al segundo y coloca en primer lugar el nuevo valor. Si el nuevo valor es sólo mejor que el segundo (pero no el primero), se baja una posición el segundo clasificado (pasando a tercer lugar) y se coloca en segundo lugar el nuevo valor. Si es sólo mejor que el tercero, directamente se intercambia el valor del tercer clasificado con el nuevo valor.

Todo termina mostrando el mensaje con el podio.

Para la próxima modificación, una un poco más sencilla, vamos a mostrar el valor de cada carta.

El juego de las siete y media. Parte II.

Y aquí tenemos un ejemplo de cómo codificar el juego.

Suponiendo que le decimos al programa que van a jugar 3 jugadores, un resultado podría ser éste:

Bueno, cosillas interesantes del código. Por ejemplo, se puede ver que se ha utilizado un bucle 'for' para  dar turno a cada jugador y a su vez dentro hemos colocado un bucle 'do-while' para que cada jugador pueda sacar las cartas que quiera o hasta que pierda.

Si el resultado es mayor que 7,5 o igual, se da un aviso y se utiliza una sentencia 'break' (romper en inglés), esto lo que hace es romper el bucle más interior que se está ejecutando en ese momento, en estos dos casos, bucle que dejaría de repetirse es el do-while para así pasar directamente al siguiente jugador.

Para que un jugador pueda decidir si quiere otra carta o no, utilizamos un carácter (Y/N), que sería YES (si) o NO (no). Mientras se introduzca la Y, se darán más cartas al jugador, si no, al introducir N, el bucle deja de repetirse para pasar al siguiente jugador.

Como hemos ido guardando todos los resultados en un array, al final podemos sacarlos para mostrar la tabla de resultados.

¡Modificaciones!

La primera modificación que se me ocurre, es que al final, después de mostrar la tabla de resultados, que muestre también el ranking con los tres jugadores que mejores puestos han obtenidos, es decir, un podio.

Otra modificación, es que no sólo nos dé el valor obtenido al sacar una carta, sino que también nos diga qué carta es (del 1 al 7 y sota, caballo y rey) y el palo (bastos, oros, copas y espadas).

Una vez que hemos hecho la modificación anterior, ¿por qué no hacer que cada carta pueda salir sólo 1 vez? Si se terminase la baraja, daría un aviso y se cogería una nueva baraja (o se reutilizaría la anterior al completo).

A ver quién es el valiente.

Para todo tipo de dudas, sugerencias, otras modificaciones, otras ideas para mejorar el código, tenéis a vuestra disposición los comentarios.

El juego de las siete y media. Parte I.

Vamos a empezar con el primer programa más complicado y entretenido: El juego de las siete y media.
Lo primero es conocer el juego. Es un antiguo juego de cartas (a mí me lo enseñó mi abuela) en el que cada jugador va sacando cartas hasta acercarse lo máximo posible al valor 7 y medio, pero sin pasarse. El que quede más cerca del valor, es el ganador.

Las cartas tienen su valor del 1 al 7 y las tres cartas más altas (sota 8, caballo 9 y rey 10) tendrán el valor de medio punto.

A la hora de desarrollar una idea, hay que ir dividiendo el "problema" o idea en bloques más pequeños que sean más asequibles. La forma de abordar esto es totalmente personal y se puede realizar de todas las formas imaginables, habrá muchas formas de hacerlo y todas válidas, aunque unas pueden ser más eficientes que otras (en otro post hablaremos de la eficiencia y su importancia), ahora mismo, con que funcione, podemos estar contentos.

Por ejemplo, uno de los primeros problemas que podemos diferenciar es cómo simular que se obtienen cartas aleatorias de la baraja. Para simular esto, vamos a crear números aleatorios del 1 al 10, para eso se utiliza la función 'rand()'. Esta función se utiliza de la siguiente forma:
                                                              int carta = rand() % 10 + 1;
Así indicamos que nos devuelva un número aleatorio del 1 al 10 (por eso se le suma 1 al final, para que empiece desde 1 y no sea de 0 a 9);

Otro de los bloques a resolver sería cómo conocer el número de jugadores y hacer que todos jueguen. Para resolver esto, podemos preguntar al principio cuántos jugadores van a jugar y a través de un bucle, controlar que cada uno juegue su ronda.

Para guardar los resultados, se me ha ocurrido utilizar un array (una matriz). Una matriz es algo parecido a una estantería, en cada estante va una caja (variable). Como hasta que el usuario no nos lo indique no sabremos cuántos jugadores hay, utilizaremos lo que se conoce como memoria dinámica, es decir, que no crearemos la estantería hasta saber cuántos estantes tendrá. Es un concepto un poco abstracto, pero quizá se vea más claro en el ejemplo.
                             double *resultados;
                             resultados = new double[jugadores];
                             for ( int i=0; i<jugadores; i++)
                             {
                                        resultados[i] =0;

La primera línea crea la base de la estantería, una vez que conocemos el valor de la variable 'jugadores' es cuando creamos los pisos de la estantería con la palabra 'new'. Para acceder a las diferentes posiciones, se utiliza lo que sería el número de estante (empezando desde cero).

Al final del programa, podemos rescatar todos los resultados y mostrar el marcador con todos los jugadores y su puntuación.

El próximo post veremos el código (una posibilidad), el resultado y propondremos algunas mejoras para los valientes.

Interactuando con el programa y el bucle 'for'

Lo primero ahora es instalar un entorno de trabajo. Yo he elegido CodeBlocks para poder trabajar con mi viejo portátil (ya pocos programas puedo instalar). Se puede descargar de: www.codeblocks.org/ .

Lo primero es crear un nuevo proyecto del tipo "Console Application" o "Aplicación de Consola" en castellano. Se le da el nombre que queramos y se abre el fichero main. Ahora, a trabajar.

Vamos a "hablar" con nuestro programa y por primera vez a darle órdenes para que se comporte como queremos.

Vamos a incluir un bucle 'for'. Es uno de los bucles más utilizados y a la vez el más complejo. La sintaxis es la siguiente:

for(variable con valor inicial ; expresión de repetición ; aumento/disminución de la variable de control)
{
        .......
}

Es decir, se inicia una variable con un valor (en la primera posición). Se comprueba que se cumpla la expresión de la segunda posición. Por último, se modifica la variable que hará que finalice el bucle. Pero mejor verlo en el código, añadiré comentarios para que quede más claro.

La salida es la siguiente:

Ahora ya sabemos cómo dar órdenes a nuestros programitas.

Primera condición (if-else) y primer bucle (while).

Esto va a empezar a ponerse interesante. Vamos a empezar con las condiciones y los bucles, con lo que ya podremos hacer cosas más complicadas.

Lo primero es la condición 'if-else' ('si-sino' en inglés), la idea es que el programa tenga opción de seguir varios itinerarios según la condición del 'if'. Un ejemplo gráfico:

Si tengo 2 manzanas, las comparto con mi amigo, sino (si sólo tengo una), me la como yo.

Esta condición se comprueba con los operadores de comparación y para eso hay que conocer los valores 'true' (verdadero) y 'false' (falso).

==   --> Igualdad. Devuelve 'true' si son iguales y 'false' si no lo son.
!=    --> Desigualdad. Devuelve 'true' si son diferentes y 'false' si no lo son.
<     --> Menor que. Devuelve 'true' si el valor de la izquierda es menor que el de la derecha. Fácil de recordar si os fijáis en los picos de la flecha.
<=   --> Menor o igual que. Devuelve 'true' si el valor de la izquierda es menor o igual que el de la derecha.

>     --> Mayor que. Devuelve 'true' si el valor de la izquierda es mayor que el de la derecha. 

>=   --> Mayor o igual que. Devuelve 'true' si el valor de la izquierda es mayor o igual que el de la derecha.

Ahora vamos al grano y a practicar. Este va a ser el primer código:

Esta es la salida si ponemos a 'true' la variable 'tengoManzanas':

Si ponemos a 'false' esa variable:

Probad todas las combinaciones que se os ocurran y comentad cualquier duda que pueda surgir.

Vamos a añadir otro concepto nuevo, los bucles, en concreto el bucle while (mientras). Básicamente es la repetición de un trozo de código las veces que nos interese. Se me ha ocurrido un ejemplo en el que tengo 8 libros esparcidos por el salón y tengo que recogerlos en la estantería: 

Mientras haya libros en el salón:

     Recogo el libro y lo llevo a la estantería. Ahora hay un libro menos sin recoger.

Repito hasta que no queden libros por el salón.

Al igual que el if, se controla con una expresión que hace que el bucle se repita mientras esa expresión sea cierta.

Nota: Cuando trabajamos con bucles, es importante asegurarse de que termina, si es un bucle infinito, se ejecutará siempre (hasta que lo detengamos de mala manera cerrando el programa).

Vamos a ver cómo sería el código para recoger el salón:

La salida sería la siguiente:

Se puede ver perfectamente cómo se ha repetido hasta recoger todos los libros.

Mi objetivo es empezar a hacer jueguecitos lo antes posible (es bastante más ameno y productivo) pero antes hay que conocer estas cosillas básicas aunque sea aburrido.

Para la próxima, algunos bucles más y a por la instalación de un Entorno de desarrollo en condiciones que nos deje libertad total.

Compilador C++ a utilizar.

Aunque prefería evitar instalaciones tan pronto, la verdad es que vale la pena poder ver cómo es el programa que estás creando, comprobar que has creado algo. Además, es divertido la parte de entrada de datos, no sólo ejecutar tu programita, sino interactura con él y darle órdenes para que se comporte de una forma u otra.

Así que entramos en el eterno debate, ¿qué programa gratuito utilizar para generar nuestros programas? Hay muchos, unos los he utilizado y otros no y algunos serán más potentes que otros, pero como al principio sólo haremos aplicaciones de consola sencillas, no vamos a ser muy exigentes. Como no quiero decidir de manera unilateral, voy a dar la opción de votar a los que esteis interesados y por eso he colocado este post tan pronto, para dar tiempo a que si alguien quiere expresar sus preferencias, lo haga.

Si nadie se animase, elegiría yo uno y más adelante si alguien quiere que veamos otras opciones, pues las vemos. Es mi primer tutorial y me gustaría adaptar el contenido a quien lo quiera seguir y sus intereses, por eso son muy importantes las sugerencias y la colaboración.

Los entornos que he encontrado a simple vista son:
                  * Microsft Visual C++ Express Edition  (versión gratuita y limitada del famoso Visual Studio de Microsoft de pago).
                  * Dev C++.
                  * Code::Blocks.
                  * Eclipse C++.

Si alguien conoce alguno más, lo añadimos a la lista. En cuanto vea que empieza a ser necesario el entorno de desarrollo, según los comentarios (si los hay), tomaré una decisión y prepararé un post sobre cómo instalarlo.

Variables y pequeñas operaciones.

La base de la programación son las variables. Son algo parecido a cajas, aunque sean cajas para guardar información. Cada tipo de caja tiene una forma y tamaño y dentro se pueden guardar sólo objetos de una forma correspondiente y de un tamaño no mayor que la caja.

Las variables más comunes son las que guardan valores numéricos y cadenas de caracteres (es decir, pequeños textos).

Para simplificar, por ahora sólo utilizaremos 3 tipos de variables:
- int : para guardar números enteros, es decir, sin decimales.
- double: para guardar números parte decimal.
- string: para guardar cadenas de caracteres.

En el holaMundo ya vimos cómo mostrar directamente una cadena de caracteres o mensaje fijos, pero puede ser que nos interese que ese mensaje esté personalizado, por ejemplo, podemos pedir su nombre al usuario y saludarle apropiadamente. Las opciones son tantas como nos proporcione nuestra imaginación.

Ahora vamos a jugar con los números. Aquí tenéis un código en el que se utilizan valores del tipo "int" y se muestran por pantalla:

La salida sería algo así como:

Puede parecer tonto, pero hay que aprenderlo y probar, es la base, todo tiene que ser de lo más natural.

Quería hacer algo con entrada y salida de datos, pero me he topado con que codepad no admite entrada de datos.... mi gozo en un pozo. Habrá que dejarlo para más adelante, cuando elijamos (y hablo en plural porque me gustaría elegir algo entre todos) un compilador "serio" que sea gratis.

Me gustaría que probaseis por vuestra cuenta a hacer algo parecido con los números double (con decimles) y con cadenas de texto para ver cómo los muestra vuestro programilla.

Ejemplos de declaraciones para estos tipos serían:

A darle caña, y para cualquier duda... comentarios!!

¡Empezando a enredar!

La teoría es aburrida, así que vamos a pasar directamente a hacer cositas básicas.

Hay miles de compiladores (el programa que convierte lo que escribimos en un programa que funciona), unos de pago y otros gratis, pero como al final todos funcionan igual, he elegido uno gratis y online, para evitar instalaciones engorrosas y todo eso, pero el código funcionará igual en todos.

Si entráis en esta web:   http://codepad.org/   aparecerá la siguiente pantalla:

Para compilar en C++ sólo hay que marcar la opción bajo la palabra "Language" y escribir el código en el cuadro central.

Una vez que nuestro código está listo, al pulsar el botón "Submit" la web comprueba si hay errores y si todo está correcto, nos mostrará el resultado de nuestro programita.

Si hay algún error, nos indicará qué error es y la línea en la que se encuentra.

Ahora vamos a empezar con el clásico de todos los lenguajes de programación, el primer programa con el que todos hemos empezado, el "¡Hola Mundo!". Para ello, escribimos el siguiente código:

La primera línea es para incluir la biblioteca que contiene la función que muestra por pantalla el mensaje.

La tercera línea es el inicio de la función "main", es el bloque principal y es lo primero que se lee, es decir, donde empieza y termina todo. Su contenido siempre irá entre llaves {}.

En la tercera línea es dónde enviamos nuestro mensaje para que lo pinte por pantalla. Es imprescindible terminar estas órdenes individuales con un ";".


Al pulsar el botón "submit" este es el resultado:

Arriba aparece el código que se ha ejecutado y abajo aparece la salida "Output" con nuestro mensaje. Parece un poco tonto, pero es el primer paso y probar varios mensajes puede ser interesante para familiarizarse con el entorno.

Para cualquier duda o sugerencia, ya sabéis, ahí tenéis los comentarios.

Para la próxima entrada, variables y primeras operaciones aritméticas.

Introducción.

Aprendí a programar hace casi 13 años y es en lo que trabajo actualmente.

La sociedad española ha cambiado mucho en el terreno laboral, antes se aprendía un oficio y era común trabajar en el mismo sitio toda la vida. Ahora la población está mucho más formada y hay muchísimo movimiento, lo que supone la necesidad de seguir formándose constantemente e incluso reciclarse para acceder a otro sector.

El desarrollo de aplicaciones está en auge, la tecnología inunda nuestras vidas y detrás de todo lo que la hace funcionar están los desarrolladores de software.

Aplicaciones de móvil, videojuegos, podemos hacer todo lo que podamos imaginar, todo es cuestión de esfuerzo y tiempo (a veces, mucho de ambos), pero todo está a nuestro alcance.