Lección 2: Primeras Frases

Es hora de que nos internemos ya en la codificación, y vayamos acostumbrándonos a ver y escribir código. Al igual que a andar se aprende andando, a programar se aprende programando. En esta lección no haremos ningún programa funcional, pero iremos viendo retazos de código que luego uniremos en las siguientes lecciones para hacer un programa.

El lenguaje de programación con el que vamos a empezar será C++, un lenguaje muy extendido y ampliamente conocido, del que se puede encontrar mucha información en Internet lo cual os solucionará muchos problemas. De momento no voy a entrar en las características de este lenguaje, excepto una, que es importante para empezar, y es que utiliza los tipos, de los que ya hablamos la anterior lección.

El sistema para el que vamos a programar es un ordenador tipo PC (Windows o Linux) o Mac, lo que se conoce como aplicaciones de escritorio, que no son aplicaciones web. Los programadores seremos nosotros.

A continuación vamos a ir repasando los elementos de los que se hablaron en la lección anterior.

Hemos dicho que C++ utiliza los tipos, y esto quiere decir que cuando creamos una variable tenemos que definir qué se va a almacenar en ella, y si intentamos almacenar otra cosa, el compilador nos lo va a impedir.
Los tipos básicos que de momento nos van a interesar de C++ son:

• Los números enteros. En una variable de tipo entero se podrá almacenar cualquier número entero, que son números positivos o negativos sin parte decimal: -2346, -4, 0, 1, 46, 3389002...
• Los números reales. En una variable de tipo real se podrá almacenar cualquier número, positivo o negativo, con parte decimal o sin ella (sí que tendrá pero no nos la representará): -34.17, -2.0, 0.14, 1.8989, 42456.12342...
• Los caracteres. En una variable de tipo caracter se podrá almacenar cualquier caracter, que viene a ser letras, números, símbolos corrientes o símbolos especiales de impresión: a, X, 1, ª, @, fin_de_párrafo ¶...
• Los booleanos. En una variable de tipo booleano se podrá almacenar true o false, lo que indicará que la variable es verdadera o falsa. Una aplicación de esto lo veremos en esta misma lección, y aunque la idea al principio puede ser confusa, la práctica nos dará el entendimiento.

Hay más tipos en C++ que iremos viendo en las siguientes lecciones. Pero conociendo éstos, ya podemos ver cómo se escribiría la declaración de una variable, que viene a ser crear la variable para luego poder usarla o, en un sentido más profundo, el decirle al sistema que nos reserve un hueco en su memoria (la RAM, por ejemplo), para que nosotros guardemos ahí información de un tipo correspondiente. En C++ se pone primero el tipo que queremos que tenga la variable y después el nombre, y si queremos que tenga un valor inicial, añadimos un símbolo igual (=) y después el valor que deseamos. Por último se pone punto y coma (;) ya que es una instrucción y todas la sinstrucciones en C++ terminan en punto y coma. Hay que tener en cuenta que veremos cosas que no se consideran instrucciones, como los bloques de control.

Veamos unos ejemplos de declaraciones. Si quisieramos declarar una variable entera para almacenar el número de piedras que tenemos, sería algo así:

int piedras;

Si además sabemos que empezamos con 12, la declaración sería:

int piedras = 12;

Los nombres de las variables los construiremos utilizando combinaciones de únicamente letras minúsculas (aunque se puede con mayúsculas también, lo haremos como costumbre), números y el caracter '_'.
Si queremos declarar un variable de tipo caracter, para almacenar los caracteres que nos entran por el teclado, un ejemplo sería:

char tecla_pulsada;

Pero si queremos poner una variable para un programa que busque un caracter en un texto, pondremos un valor inicial y sería:

char busqueda = '@';

Aquí podemos ver dos cosas interesantes. El lenguaje no admite tildes en en la declaración de variable (y básicamente en cualquier lugar que no sea como caracteres especiales). Y si queremos expresar un caracter en nuestro código, tenemos que rodearlo de la comilla (').

Para declarar una variable, por ejemplo, para la búsqueda de la que hablábamos antes, y que el programa pare cuando se haya encontrado, crearemos una variable booleana que empezará en falso y que pondremos a verdadera cuando encontremos el caracter. La declaración sería:

bool encontrado = false;

Si queremos definir una variable de tipo real será algo como:

float raiz; float pi = 3.1416;

En resumen habría que decir que los tipos son: enteros son int, los reales float, los caracteres char, y los booleanos bool.

El ejemplo de pi lo puse por una razón, y es que pi sabemos que es una constante, un número inalterable. En la lección pasada hablamos de las constantes, variables que no cambian. Son útiles ya que definen cosas inalterables, que se podrían poner directamente en el código sus valores, pero que al usar constantes, si queremos cambiar su valor sólo lo tendremos que cambiar en un sitio y no buscar todas sus apariciones en todo el código.
Por ejemplo yo he definido pi como 3.1416, pero si luego mi jefe me dice que necesitamos un decimal más de precisión, sólo tengo que ir a la declaración de pi y cambiarlo, mientras que si he puesto en vez de pi el número directamente en sus apariciones, tendré buscarlas todas y cambiarlo en todas. Además, si la defino como constante, me aseguro que si intento cambiarla por accidente mediante instrucciones del programa, el compilador no me lo permitirá.

Las constantes se declaran igual que las variables pero añadiendo delante la palabra const:

const float pi = 3.1416;
const bool verdad = true;
const char arroba = '@';

Cuando ponemos, en nuestro código un número, caracter o valor booleano directamente, como al darle un valor inicial a una variable o constante (por ejemplo en las últimas declaraciones 3.1416, true o '@') a esto se le llama constante literal. Estamos creando una constante de un solo uso y totalmente explícita, sin el intermediario de un nombre. Como hemos visto, las constantes literales de los enteros se crean poniendo simplemente el número, el de los reales igual, solo que si tiene decimal, usamos el punto (.) para separar parte real y parte decimal, los caracteres se muestran entre las comillas simples (') y los booleanos se ponen o true o false.

Hay una forma de declarar varias variables de un mismo tipo en una sola línea y es poniendo el tipo y de todas ella y luego los nombres separados por comas. Se puede asignar además un valor inicial a las que se desee:

int num1 = 0, num2 = 3, num3;

Esto declararía tres variables con nombre num1, num2 y num3 y le asignaría 0 y 3 como valores iniciales respectivamente a las dos primeras.

Veamos ahora algunos operadores del lenguaje.

La asignación nos permite darle valores a las variables. Ya lo hemos usado en los ejemplos anteriores. Se representa mediante el símbolo de igualdad (=) y a la izquierda se pone la variable a modificar, y a la derecha el nuevo valor. El nuevo valor no tiene por qué ser una constante literal, puede ser otra variable, una constante o cualquier otra expresión. El compilador comprobará si el tipo de la parte de la izquierda es el mismo que el de la expresión de la derecha. Si por ejemplo hacemos estas tres líneas de código:

int num1 = 2;
int num2 = 3;
num1 = num2;

Al final de la ejecución en num1 estará el valor 3 y el compilador no nos dará error ya que ambos son del mismo tipo. En este ejemplo había tres asignaciones, como se puede comprobar por los tres símbolos (=). En el siguiente ejemplo el compilador nos daría un error:

char caracter = 'a';
int num1;
num1 = caracter;

Estamos intentando meter una variable de tipo char en un de tipo int, y eso el compilador nos lo impedirá. En este caso parece claro que no se pueda pero, ¿qué pasa si intentamos meter un entero en un real (int en float)?

Veamos ahora otros operadores a parte de la asignación que nos permitirán modificar nuestras variables. Los operadores más comunes son:

• Aritméticos. Manipulan o dos enteros o dos reales y devuelven o un entero o un real. Son: la suma (+), la resta (-), la multiplicación (*), la división (/), el módulo o resto (%). Hay uno que sólo recibe o un entero o un real y devuelve un entero o un real, que es el negativo (-).
• Relacionales. Manipulan dos enteros o dos reales y devuelven un booleano. Son: menor que (<), mayor que (>), igual que (==), diferente que (!=), menor o igual que (<=) y mayor o igual que (>=).
• Lógicos. Reciben uno o dos booleanos y devuelven un booleano. Son: negación (!), and (&&) y or (||). Si la negación recibe un true, devuelve un false, y si recibe un false, devuelve un false. El and devolverá true cuando ambos booleanos sean true, y falso si solo uno o ninguno son true. El or devolverá true si al menos hay alguno que sea true y devuelve false si ambos son false.

Veámoslos en acción:

int operando1 = 2, operando2 =3, resultado1, resultado2, resultado3, resultado4;
bool mayor, menor;

resultado1 = operando1 + operando2;
resultado2 = operando1 * operando2;
mayor = resultado1 > resultado2;
menor = !mayor;
resultado3 = operando1 * operando1 + operando2;
resultado4 = operando1 * (operando1 + operando2);

Analicemos ahora los resultados de este trozo de código. Al final de la ejecución de estas instrucciones, en resultado1 debería encontrarse un 5 (2 más 3), en resultado 2 un 6 (2 por tres 3), en mayor un false (ya que el 5 de resultado1 no es mayor que el 6 de resultado2), en menor un true (ya que el inverso de false es true), en resultado3 un 7 (ya que la multiplicación se realiza antes, al igual que en matemáticas) y en resultado4 un 10 (ya que si ponemos paréntesis, se realiza antes la suma de 2 más 3 y luego se multiplica esto por 2.

Es importante, pues, tener en cuenta la precedencia de cada operador, lo que significa conocer cuáles se ejecutan antes que otros. Esto no lo incluiré en la lección ya que de momento será algo intuitivo, aunque si se tiene curiosidad se pueden consultar las precedencias en cualquier manual del lenguaje.

Quiero destacar también el uso de los tipos en el ejemplo. Los operadores devolvían en toda ocasión los tipos que la variable a la que se lo asignábamos podía almacenar. Los resultados de operadores relacionales o lógicos fueron asignados a variables booleanas, y los resultados de operaciones sobre enteros fueron asignadas a variables de tipo entero.

Con todo esto hemos cubierto ya un tercio de la base de la programación, nos faltarían las estructuras de control y las funciones, que veremos en la próxima lección.

Un saludo y para cualquier duda, escribid un comentario.