8 – Resumen del primer bloque

1. Resolución del ejercicio del capítulo anterior Hola, bienvenido de nuevo a Programar mola con Visual Studio donde puedes seguir éste curso de programación en C# con Visual Studio y .NET Framework 4.5. Antes de empezar con nuevo temario vamos a resolver el ejercicio que planteamos en el capítulo anterior, pero antes recordemos el enunciado: Te piden un formulario que recoja el nombre de una persona y permita escoger es estado civil de ésta persona de un listado predefinido. La lista de estados es la siguiente:

  • Soltero/a
  • Casado/a
  • Divorciado/a
  • Viudo/a

También te piden una opción que permita cambiar el color de:

  • Fondo del formulario
  • Fondo de los controles
  • Texto

Bien, la parte sencilla es la que ya hemos visto en el capítulo anterior y no es otra que usar un textbox para recoger el nombre, le pondremos también un label para que el usuario sepa que le estamos pidiendo: 8.resol.1 Hasta aquí ningún misterio, lo siguiente si es un poco más complicado básicamente porque no lo he explicado, pero seguro que has hecho caso de las pistas y has buscado por internet como se usa el control “ComboBox”. Vamos a empezar añadiendo uno en nuestro formulario: 8.resol.2 Si haces clic en el combo verás que aparece una flechita en su esquina superior derecha que te permite desplegar un menú, desde ahí puedes entrar en “Editar elementos” y añadir los que te pide el enunciado: 8.resol.3 Después de aceptar el mensaje vamos a darle al play y comprobar como se comporta nuestro nuevo y flamante combo: 8.resol.4 ¿Fácil verdad? Los combos están ahí para eso, para que un usuario escoja entre alguna de las opciones prefijadas que se le ofrecen. No tiene sentido preguntar el estado civil en un campo de texto libre como un “textbox” porque no nos interesa que se inventen un estado civil o que lo escriban mal, por ejemplo. Bien, vamos a la última parte del ejercicio: el cambio de color. Hasta ahora el enunciado no nos pedía programar nada de código, simplemente montar el formulario para recoger datos pero me temo que con lo de los colores nos vamos a tener que manchar las manos de barro. Empecemos añadiendo un control “ColorDialog” tal y como nos dicen las pistas: 8.resol.5 Como ves se parece al “Timer” ya que no tiene una representación gráfica en nuestro formulario, pero nos aparece bajo éste para que sepamos que lo tenemos creado y podamos tocar sus propiedades. Bien, si has buscado por Internet verás que para usar éste control necesitamos pedirle que nos muestre su cuadro de colores y esto lo tenemos que hacer por código. Una buena práctica es estudiarse el listado de propiedades, eventos y métodos de un objeto, lo cual ya hemos visto en capítulos anteriores cuando, desde código, escribíamos el nombre de un control y le dábamos al punto, desplegando el listado de opciones. Para no complicarlo vamos a añadir un menú en el formulario y vamos a programar el evento click de sus opciones para que nos muestre el cuadro de diálogo: 8.resol.6 Recuerda que haciendo doble click podemos programar directamente el evento click de la opción: 8.resol.7 A éste cuadro que nos muestra lo que podemos hacer con un objeto se le conoce como “IntelliSense” y hasta nos explica para que sirven los métodos si sus nombres no están del todo claros. Piensa que seguramente seas capaz de aprenderte los métodos y propiedades más importantes de los controles que trae el .NET Framework pero también se pueden instalar componentes de terceros (que suelen ser muy potentes… y también de pago…) y la única forma de saber que coño hacen y como utilizarlos es mirar la documentación donde, precisamente, te explican que propiedades y métodos traen consigo. Como somos personas curiosas vamos a echar un vistazo y… ¡voila! Hay un método que se llama “ShowDialog” que nos viene de perlas: 8.resol.8 Vamos a ver como se comporta ahora nuestro form cuando usamos dicha opción: 8.resol.9 ¡Anda la hostia! Que opción más chula pero… ¿una vez se escoge un color como lo usamos? Pues volvamos a investigar la lista de opciones que tiene el objeto… vaya, tiene una propiedad llamada “Color” y además nos dice que es la que nos da el color seleccionado por el usuario… pues vamos a cogerlo y a ponerlo de color de fondo del formulario: 8.resol.10 Quizás la parte más complicada aquí sea ver como cambiar el color del formulario, pero no es para nada difícil una vez lo ves claro. Si te fijas bien estás programando el código el propio formulario que quieres modificar, lo puedes ver justo después de declarar el namespace, cuando se declara la clase actual (en mi caso línea 13), estamos dentro de la clase Form1 que es de tipo Form por lo que queremos modificar el objeto dentro del cual estamos programando, y la mejor forma de acceder a dicho objeto es mediante la palabra “this”. Una vez visto esto, modificando la propiedad “BackColor” de “this”, es decir, el objeto actual, es decir, el formulario que queremos cambiar, queda todo hecho. ¿Por que no le damos al play para probarlo? 8.resol.11 Si hasta aquí está todo claro solo nos queda repetir todo esto en la otra opción, pero en lugar de cambiar le color del formulario cambiaremos el de los controles: 8.resol.12 Y listos, con esto tenemos el ejercicio completado. Espero que te animes a probar los otros controles y a jugar con ellos, se pueden hacer cosas muy chulas 🙂

2. Contenido del capítulo

Le he estado dando algunas vueltas al tema y creo que antes de continuar explicando cosas nuevas sería conveniente hacer un repaso de todo lo que llevamos visto hasta ahora, aunque he intentado que todos los ejemplos que he ido poniendo sean acumulativos, incluyendo así elementos ya vistos antes, nunca está de mas echar la vista atrás para refrescar conceptos sin detenernos en los detalles.

Éste es el listado de lo que hemos aprendido hasta ahora y, por tanto, vamos a repasar:

  • Tipos de datos básicos
  • Arrays
  • Variables y constantes
  • Operadores lógicos
  • Operadores booleanos
  • Condicionales
  • Programación orientada a objetos
  • Windows Forms

¡Pues no perdamos más tiempo y vamos a repasar un poco!

3. Tipos de datos básicos

Dado que programamos con C# sobre .NET Framework disponemos de un conjunto de tipos de datos que vienen incluidos en el sistema con los que podemos trabajar.

Los tipos que hemos visto hasta ahora son:

  • int: para números enteros
  • float: para números reales
  • bool: almacena el valor de cierto o falso.
  • string: contiene una cadena de texto.
  • object: es el tipo básico, como si fuera un comodín podríamos tratar todos los tipos que hemos visto como si fueran object (cuando hablemos de herencia quedará más claro).

Existen otros tipos de datos pero para lo que vamos a hacer nos podemos bastar de sobras con estos, si tienes curiosidad sobre otros tipos puedes consultar la documentación de Microsoft al respecto.

4. Arrays

Es posible crear colecciones de elementos, por ejemplo, un conjunto de enteros o un conjunto de floats. Los arrays son de tamaño fijo y es necesario indicar que tamaño queremos reservar, por ejemplo:

int[] my_array = new int[10];

De ésta forma estamos declarando un array de de enteros de 10 posiciones, después podemos acceder a dichas posiciones mediante los corchetes y tomar o asignar valores, asi:

my_array[3] = 25;

Esiten otras formas de inicializar arrays, como por ejemplo la siguiente que nos permite establecer sus valores de forma inlne:

object[] my_array = new object[]{1, “hola”, 4.5f, false};

Como puedes ver, todo cabe en un array de objects 😉

5. Variables y constantes

Como hemos visto en multitud de ocasiones, cuando necesitamos trabajar con datos es necesario que los guardemos en campos constantes o variables, dependiendo de si el valor es fijo es modificable respectivamente.

El valor de una constante se declara junto con la misma y no se puede modificar durante la ejecución del programa, es importante identificar las constantes y hacer buen uso de ellas ya que no solo mejora el rendimiento del programa sino que nos indica que estamos entendiendo lo que hacemos.

Las constantes se declaran así:

const int my_const = 25;

En el otro lado tenemos las variables, que son valores que se pueden modificar durante la ejecución de un programa y se declaran asi:

int my_var = 35;

6. Operadores lógicos

Hemos visto distintos tipos de operadores lógicos y seguro que te son muy familiares ya que hablamos de cosas tan típicas como sumar, restar, multiplicar o dividir. Es importante remarcar que los operadores lógicos solamente se pueden utilizar con datos del mismo tipo, es decir, no se puede sumar un entero con un string si antes no se ha hecho algún tipo de conversión.

Suma:
int a = 1;
int b = 2;
int c = a + b;

Resta:
float a = 2.2f;
float b = 1.2f;
float c = a – b;

Multiplicación:
int a = 33;
int b = 4532;
int c = a * b;

División:
float a = 0;
float b = 1.0000012f;
float c = a / b;

Recuerda también que los strings se pueden concatenar sumándolos.

7. Operadores booleanos

Se trata de lógica básica, los operadores booleanos se suelen aplicar a condicionales y consisten en evaluar ciertas propiedades para determinar si son ciertas o falsas.Por tanto el tipo de dato que retorna un operador de éste tipo siempre es booleano.

Mayor que:
int a = 33;
int b = 4532;
bool c = a > b; (falso)

Mayor que:
int a = 33;
int b = 4532;
bool c = a < b; (cierto)

Igual que:
int a = 33;
int b = 4532;
bool c = a == b; (falso)

Distinto que:
int a = 33;
int b = 4532;
bool c = a != b; (cierto)

A estos operadores de comparación se le unen otros de unión o conjunción:

Y:
int a = 33;
int b = 4532;
int c = 2;
bool c = a > b && c == 2; (falso)

O:
int a = 33;
int b = 4532;
int c = 2;
bool c = a > b || c == 2; (cierto)

8. Condicionales

Los condicionales son una herramienta básica en la programación secuencial (como la nuestra) ya que nos permiten ejecutar piezas de código únicamente si se cumplen ciertas condiciones:

if(low_battery){
ModoReposo();
}
else{
ModoNormal();
}

9. Programación orientada a objetos

Esta es, en mi humilde opinión, la parte más divertida y quizás la más compleja.

Como hemos visto los tipos de datos se representan con objetos, donde un objeto es una entidad que contiene uno o varios valores y un conjunto de métodos. Los integers, booleans, strings y floats que hemos visto tienen un conjunto de métodos predefinidos pero solamente toman un valor dependiendo del tipo que hayamos declarado. Lo divertido del asunto es que nosotros somos capaces de crear nuestros propios objetos mediante clases, donde podemos meter lo que nos dé la gana.

Por ejemplo:

8.clases.1

Lo que tenemos aquí es una clase que se llama Persona u que describe, de una forma muy resumida, los datos de una persona. Tiene 3 atributos privados, un método constructor, 3 propiedades y un método.

El constructor toma como datos de entrada el nombre de la persona y su edad y los almacena en los atributos privados. Si te fijas aparece la palabra reservada “this”, en éste punto es necesaria porque si te fijas los atributos de la clase se llaman igual que los parámetros de entrada del constructos, usando “this” le estamos diciendo al programa a cual de los dos nos referimos. Además como se trata de atributos privados no se pueden acceder desde fuera de la clase, es decir, quien use Persona no podrá ver estos atributos ni modificarlos por lo que los tenemos bien protegidos.

Lo sieguiente son las propiedades, una propiedad es un método especial que solo se encarga de entregar un valor o modificarlo. En nuestro caso, como los atributos son privadas necesitamos propiedades que permitan acceder a los valores pero si te fijas, las dos primeras solo permiten consultarlo por lo que una persona siempre tendrá el mismo nombre de creación (algo similar a la vida real suponiendo que nadie se cambiara el nombre) y tampoco se nos permite modificar libremente la edad.

La última propiedad si que permite modificar los datos a parte de consultarlos, lo hemos permitido porque es normal que una persona cambie de domicilio.

Lo último es un método que representa el día del cumpleaños, incrementando en uno la edad de esa persona.

Es importante que se entienda que tenemos el control absoluto de nuestra clase y, lo que es más importante, somos libres de dejar nuestra clase más abierta o más cerrada a cambios desde el exterior, en mi caso no he dejado que un programador le pueda quitar años a una persona ni le pueda cambiar el nombre una vez creada, pero si que le dejo consultar esos datos o hacerle cumplir años.

10. Windows Forms

Es la parte más gráfica ya que nos permite montar una interfaz para que el usuario interactue con nuestra aplicación de forma más amigable, los formularios se componen de controles que. a su vez, tienen atributos, métodos y eventos. Recuerda que los eventos son métodos programables que se disparan en una situación concreta como, por ejemplo, un clic.

Los controles más comunes son:

  • TextBox: permite recoger texto libre.
  • ComboBox: permite escoger una opción de una lista predefinida.
  • CheckBox: permite marcar una o varias opciones.
  • RadioButton: permite seleccionar una única opción.
  • Button: permite insertar un botón y programar su comportamiento.
  • MenuStrip: permite construir un menú.

Existen multitud de controles nativos y de terceros, todos hacen cosas distintas pero todos tienen cosas en común. Que no te de miedo jugar con ellos, investigar sus métodos, propiedades y eventos, muchas veces descubres una mejor forma de resolver un problema cuando estás haciendo experimentos.

11. Resumen

Y hasta aquí el resumen, porque no pienso hacer un resumen de un capítulo que ya es un resumen. Tampoco se me ocurre un ejercicio que aporte nada porque siempre hemos hecho ejercicios acumulativos, es decir, hemos aprovechado lo aprendido en capítulos anteriores y lo hemos ampliado con lo aprendido en el actual… así que prefiero no ser redundante y dejarte descansar y coger fuerzas.

En el próximo capítulo nos meteremos de lleno en el camino de la iteración (o bucles) y más adelante hablaremos de recursividad, si entretanto te aburres te invito a que crees una clase basándote en algo de la vida real (una persona, una nevera, un armario…), programes sus métodos y atributos y busques la manera de representarlo con WinForms, a tu rollo, sin prisas ni reglas, esa es la mejor forma de aprender.

Mucha suerte y nos vemos en la próxima entrada.
¡Gracias por seguir mi blog!

Anuncios

3 – Tipos de datos

1. Resolución del ejercicio del capítulo anterior

Hola, bienvenido de nuevo a Programar mola con Visual Studio donde puedes seguir éste curso de programación en C# con Visual Studio y .NET Framework 4.5.

Antes de empezar con nuevo temario vamos a resolver el ejercicio que planteamos en el capítulo anterior, recordemos el enunciado:

“El mismo señor que te había pedido que sumaras dos número cualesquiera te pide ahora que le hagas lo mismo con una resta, una multiplicación y una división y guardes los resultados en cuatro variables diferentes.”

Solución:

Lo cierto es que el ejercicio no tenía mucho misterio y estoy seguro que, después de haber hecho una suma en el capítulo dos no os ha resultado muy difícil hacer el resto de operaciones.

El código quedaría de la siguiente manera:

result_ejer

Como siempre, existen multitud de formas de resolver los ejercicios, tus variables (en mi caso numero1, numero2, resultado_suma, etc.) seguramente se llamen diferente pero el resto debe ser muy parecido.

2. Contenido del capítulo

En base a lo que hemos aprendido en el capítulo anterior, hoy vamos a ampliar horizontes aprendiendo lo siguiente:

  • Constantes
  • Nuevos tipos de datos
  • Arrays
  • Resolución de un ejercicio de ejemplo
  • Enunciado del ejercicio para la próxima entrada.

Como siempre, voy a dar por sentado que los conceptos del capítulo anterior están claros. Si no es así te animo a pegarle un repaso o a dejarme tus consultas en los comentarios.

3. Constantes

En el capítulo anterior y en la resolución del ejercicio hemos hecho uso de variables, recuerda que una variable es como una caja de zapatos: un día puede contener bambas, al día siguiente zapatillas y dentro de un mes quizás libros viejos o herramientas. Es un recipiente donde poner cosas, en los casos que nosotros hemos visto números enteros, pero números que pueden ir cambiando.

Siguiendo el ejemplo del ejercicio anterior, si el enunciado no nos hubieran exigido usar variables nuevas las podríamos haber aprovechado, por ejemplo así:

reapro

Como puedes ver, en lugar de declarar nuevas variables para guardar el resultado he reaprovechado la que ya teníamos, si debugas el programa paso a paso verás como el valor de “resultado” va cambiando.

Si te fijas bien, verás que hemos usado variables para numero1 y numero2, y si te fijas mejor verás que esos números nunca cambian, nos son variables sino que son constantes.

Podemos definirlos como constantes de la siguiente forma:

constantes

Ahora numero1 y numero2 son constantes y su valor no se puede modificar durante la ejecución.

Nuestro programa es tan pequeño que apenas se nota pero hemos mejorado su eficiencia, al reaprovechar variables es como si en lugar de comprar una nevera nueva cada vez que se llena, la vaciáramos para llenarla con otras cosas. Con las constantes se mejora la velocidad de acceso a datos, es como si te aprendes de memoria tu DNI en lugar de sacarlo de la cartera y consultarlo cada vez que te lo piden.

Como he dicho todos estos cambios apenas se notan en un pequeño programa pero si éste crece cada día hasta transformarse en una gran aplicación habrás agradecido tener estas cosas en mente desde el principio.

¡Ah! Un último detalle, ¿te has fijado en la línea verde debajo de resultado? Se parece a la línea roja que vimos en el capítulo anterior y se llama “warning”. A diferencia de los errores, los warnings son sólo avisos y, en éste caso, nos está diciendo esto:

warning

Básicamente nos está diciendo: “Has creado resultado, le estás poniendo valores, pero nadie los usa por lo que te la puedes ahorrar”. Pero VS no sabe que las estamos usando para consultar el valor de las operaciones mientras debugamos.

4. Otros tipos de datos

Bueno, llegados a este punto hemos aprendido a declarar variables y constante de tipo entero y a realizar diferentes operaciones matemáticas. Ahora me gustaría enseñarte otros tipos diferentes.

4.1. float

El float es el tipo de dato que representa un número decimal, al igual que los int se les pueden realizar operaciones matemáticas como sumar, restar, etc.

floats

En este código hemos definido dos constantes de tipo float y las hemos sumado poniendo el resultado en una variable float. Si te fijas hay una “f” al final del número decimal que da valor a las constantes, es necesario para indicarle a VS que es un valor float válido.

4.2. string

El string es el tipo de dato que representa una cadena de texto.

stringsAquí hemos repetido el ejemplo del float pero usando strings.

Si te fijas el valor del string va siempre entre comillas, y si, los strings se pueden sumar aunque lo que realmente se hace es concatenarlos, por lo que en nuestro caso resultado valdría “holaadios”. Como el string no es un valor numérico no se los puede restar ni multiplicar ni dividir.

Ahora me gustaría que probaras de primera mano lo que te he enseñado en éste apartado, vamos a picar un poco de código hasta obtener lo siguiente:

ejemplo simple

Bueno, en el capítulo anterior vimos como se podía debugar para comprobar el valor de las variables, pero quiero enseñarte un pequeño truco: podemos hacer que aparezca un mensaje en pantalla con los valores que queremos ver. Vamos a hacer un par de cambios:

ejemplo mshbox

Hemos añadido un par de líneas donde hacemos uso de MessageBox.Show, MessageBox es el objeto y Show el método. Más adelante explicaremos que es un objeto y que es un método, por ahora me conformo con que os suenen esas palabrejas.

MessageBox.Show acepta un string, que es lo que le ponemos entre paréntesis. Si te fijas con resultado_string no hay problema, porque es un string, pero con resultado_float hay que hacer una cosa llamada .ToString(). Más adelante lo explicaré, no te preocupes.

Vamos a darle al play, recuerda que es el botón verde donde pone Iniciar.

msgbox_float  msgbox_string

Y ahí lo tienes, te aparece un mensaje (un MessageBox) con un número 2, que es el contenido de resultado_float (0.5 + 1.5). Si pulsas aceptar te sale el siguiente mensaje, que no es más que el contenido de resultado_string.

5. Arrays

Bueno, llegados a éste punto ya has visto cómo se declaran variables y constantes de distintos tipos (ints, strings y floats) y como se puede operar con ellos. Vamos a darle una vuelta de tuerca y nos vamos a introducir en el mundo de los arrays.

Un array no es más que un grupo de variables del mismo tipo, nosotros hemos estado usadando cajones (las variables) y un array es como un armario que tiene cajones dentro. Te voy a poner un ejemplo sencillo para que veas como funciona:

Te viene una señora y te pide que le calcules cuanto dinero tiene en la cartera si:
Empieza con 2 monedas de 2 euros, 3 de un euro, 15 monedas de 5 céntimos y una de dos céntimos.
Después paga con una moneda de 2 euros, una de uno y una de 5 céntimos.
Y le dan de cambio una de un céntimo.

Como nosotros somos gente muy apañada vamos a ordenar todo este lío de números:

tabla 1

Si pagamos con esto nos queda:

tabla 2

Y al darle el cambio nos queda:

tabla 3

Ahora sumamos el dinero y nos da que tenemos 4.73€. ¿Fácil no?

¡Pues a programar se ha dicho! Abramos Visual Studio y busquemos una manera de realizar éste cálculo con nuestro querido C#.

Una posible solución sería la siguiente:


array 1

Como puedes ver es una solución muy tonta, hay tantas variables como tipos de moneda, se realizan las operaciones, se calcula el total y se muestra el resultado.

Seguro que te has fijado en que hay una línea partida, lo he hecho a posta para que ocupara menos en pantalla. Si una línea te parece demasiado larga la puedes partir con un intro que no pasa nada… ¿mola eh?

Pues existe una forma igual de válida pero más elegante de hacer y es mediante arrays, como hemos dicho un array es una colección de elementos y nos viene perfecto porque todas las variables que hemos usado (menos el resultado) son de tipo entero.

El array de enteros se declara así:arrayç

Se parece mucho a declarar una variable normal, ¿verdad?

Lo primero como siempre es el tipo, en éste caso int, y va seguido de corchetes para decirle a C# que es un array. Luego como siempre viene el nombre (en éste caso monedero) y por último viene una cosa un poco especial: le estamos diciendo a C# que nuestro array tiene 8 posiciones.

Lo que acabamos de hacer es decirle al ordenador que queremos una tabla como la que hemos visto arriba con 8 posiciones vacías y que se llama monedero.

tabla 4

Aquí hay una cosa curiosa a tener en mente, y es que en C# la primera posición de nuestro array es la número cero, y la última la número siete.

Si nos imaginamos que las posiciones corresponden a la tabla que habíamos usado en el ejemplo nos quedaría una cosa así:

array 2

Poner valores en el array es muy parecido a ponerlos en una variable y que ya hemos visto tantas veces. Para hacerlo con un array hay que poner el nombre de la variable, la posición a la que queremos acceder entre corchetes y el valor a asignar.

En la primera línea estamos diciendo: “a monedero, en la posición cero, le pones un dos”.

En la segunda línea estamos diciendo: “a monedero, en la posición uno, le pones un tres”.

En cada una de las líneas estamos accediendo a una posición del array y poniéndole un valor, desde la primera (la cero) hasta la última (la siete) lo cual en nuestro dibujo equivaldría a tener esto:

tabla 5

Aunque parezca una tontería te recomiendo que siempre que tengas que pensar en una solución tengas papel y boli al lado. Ojo que no he dicho siquiera programar, los dibujos, esquemas y anotaciones es recomendables hacerlos siempre antes para tener bien claro cómo se va a ir desarrollando el código. Si te fijas, lo que estoy programando es exactamente y paso por paso lo que he explicado antes de programar nada cuando he estado dibujando las tablas con los euros.

Bien, ya tenemos nuestro array montado y solo queda calcular el resultado:

array 3

La lectura es un poco más confusa pero el resultado es el mismo, lo he partido en varias líneas para que se viera mejor en éste blog pero lo puedes poner en una si te resulta más cómodo.

Vale, tenemos la nueva versión casi acabada así que vamos a hacer un poco de limpieza.

Cuando se declara una variable de tipo entero, su valor inicial siempre es cero. En el caso de los arrays de int pasa lo mismo, las posiciones iniciales siempre valen cero por lo que podemos limpiar unas cuantas líneas:

array 4

¿Fácil verdad? Pues se puede dejar un poco más bonito todavía… aunque supongo que esto va por gustos:

array 5

Como puedes ver he declarado el array de una forma diferente y un poco más clara.

Consiste en no decir el número de posiciones y acto segudio poner entre llaves el listado de valores iniciales de todas las posiciones. De esta forma se tiene una visión mucho más clara del valor inicial de nuestro array aunque, como he dicho, es una cuestión de gustos y quizás a ti te mola más hacerlo de otra forma.

Bien, para acabar del todo nos queda hacer las operaciones del enunciado, es prácticamente igual que el ejemplo sin array pero accediendo a las posiciones con lo que el resultado final queda así:

array 6

6. Resmuen.

La verdad es que tenía pensado explicar más cosas en éste capítulo pero me da miedo que sea demasiada información de golpe y me interesa más que vayamos poco a poco y dejando bien claras las cosas.

Recapitulando hemos visto variables de distintos tipos que se declaran así:

tipos

Siempre de la misma forma: tipo -> nombre -> valor inicial -> punto y coma.

Recordemos también que, si sabemos que una variable no va a cambiar nunca de valor entonces no es una variable sino una constante:

tipos const

Basta con poner const delante para que no tengamos una variable sino una constante, esto siempre es bueno hacerlo para ayudar a nuestro programa a ir más rápido.

También hemos visto como realizar operaciones matemáticas simpes (suma, resta, multiplicación y división) con los tipos int y float así como concatenar strings sumándolos.

Y para terminar hemos visto como se crear arrays y como se accede a sus posiciones:

tipo array

7. Ejercicio

Una persona te dice que tiene un huerto con cinco parcelas, en la primera cultiva lechugas, en la segunda cultiva zanahorias, en la tercera planta cebollas, la cuarta la tiene vacía y en la quinta tiene puerros.

Un día viene una chica a comprarle unas hortalizas, y en la lista de la compra tiene apuntado comprar 3 zanahorias, 1 cebolla y 2 lechugas.

Escribe el código necesario para calcular el número de hortalizas totales (un número entero) que le quedarán al payés una vez haya realizado la venta. Utiliza como mínimo un array.

Pista:
Puedes montar una solución parecida a la que se ha usado de ejemplo en éste capítulo usando arrays.

Como siempre la respuesta en el próximo post.
Saludos y gracias por llegar hasta aquí.

¡Hasta la próxima!