Introducción a la programación (2 de 2). Hoy nos vamos a acercar un poco más a las generalidades y características de los lenguajes de programación, para prepararnos ya a la programación VS2005.

En cualquier lenguaje de programación, sea cual sea la aproximación que utilicemos (estructurada, orientada a objetos, etc.) vamos a disponer de una serie de características comunes que hacen posible el desarrollo de aplicaciones con lenguajes de alto nivel: los tipos de datos (simples y complejos), el uso de variables y constantes, las sentencias de código, operaciones y expresiones para trabajar con los datos, estructuras de control y por último, procedimientos y funciones. Adicionalmente, si nos decidimos por una aproximación orientada a objetos -este será nuestro caso- debemos conocer un poco más este paradigma o forma de programar con objetos, pero este será el tema de otro par de artículos dentro de la escuela de programación.

Tipos de datos.

Un lenguaje nos proporcionará un buen conjunto de tipos de datos con los que podemos trabajar en nuestros programas. Los tipos de datos son “los ladrillos” que correctamente tratados, unidos, agrupados, van a dar forma y crear “casas” en nuestro caso programas, que realicen las tareas que les encomendemos. Un ejemplo, si queremos que nuestro programa haga operaciones aritméticas, necesitaremos por un lado los “números” y por otro las “operaciones” que, aplicadas a dichos números producen otro resultado de la operación aplicada. Los tipos de datos nos permiten detectar errores de operación en nuestro programa y además nos permite determinar cómo se van a ejecutar las operaciones entre datos concretos.

Los “números” son los datos y como el concepto número es bastante ambiguo, los lenguajes de programación suelen ofrecer una categorización más “estricta” y formal para poder construir nuestro programas. Por ejemplo, para el caso de los “números”, en realidad los tipos de datos que manejaremos en el lenguaje serán: entero, real, flotante, entero doble… etc. Ya sabemos algunos tipos de datos con los que podremos trabajar desde el código, pero también tenemos las “cadenas de caractéres” o string en la mayoría de los lenguajes. Los booleanos, para representar y trabajar con valores de Verdadero/Falso. Estos tipos de datos son los comúnmente denominados “tipos de datos simples”, pero en los lenguajes también encontraremos tipos de datos algo más elaborados y que conviene conocer para resolver mejor los problemas, los tipos de datos complejos. Entre estos tipos complejos encontraremos los tipos objeto (object), estructura (struct), colección (collection)… y una larga lista que conviene estudiar en cada caso.

Para ver el conjunto de tipos de datos que nos proporciona el lenguaje de programación escogido conviene echarle un vistazo a la ayuda del lenguaje ¡sí, hay que mirar la ayuda también, que para eso la ponen! ahí encontraréis una descripción del tipo de dato, de su representación en memoria (cuántos bytes utiliza) y algunos ejemplos de uso que podréis ejecutar directamente en el entorno de desarrollo ¿véis? todo son ventajas… hay que mirar siempre -sobre todo al principio- los tipos de datos que nos ofrecen los lenguajes y para qué se recomienda su uso, en cada caso, os daréis cuenta que el Framework .NET por ejemplo (que es el marco de trabajo o entorno de base sobre el que se apoya todo el sistema de programación y ejecución de aplicaciones de plataforma Windows -y Linux con el proyecto Mono-, os proporciona un montón de tipos de datos optimizados para un montón de situaciones concretas y puntuales; ¿y esto qué significa? que podéis incrementar el rendimiento de vuestros programas de forma notable utilizando los tipos de datos apropiados. Creo que es suficiente sobre los tipos de datos.

Variables y constantes. Declaración, uso y visibilidad.

Ya tenemos los tipos de datos, es hora de trabajar con ellos, para lo cual tendremos que establecer un sistema que nos permita crear “variables” = espacio en memoria del PC para almacenar temporalmente valores concretos de un tipo de dato concreto. Un ejemplo, mi nombre: se representaría con un tipo de datos cadena de caractéres (string), pero para poder trabajar con él, necesitaría, ya dentro de mi programa, declarar una variable (darle un nombre) de tipo string (darle este tipo) y, si quiero, inicializarla (es decir, darle un valor inicial), otra posibilidad sería dejarla sin valor (= “cadena vacía”). Así tendríamos en pseudo-código: declarar variable miNombre como string = “Miguel”; -> y en C#: string miNombre = “Miguel”;

En nuestros programas utilizaremos montones de variables que van y vienen de un lado a otro del programa, incluso entre diferentes aplicaciones, y aquí es donde entra en juego otro concepto importante relacionado con las variables. La visibilidad (scope en Inglés) hace referencia a dónde, en qué partes del programa o aplicación podemos utilizar cada una de las variables. En principio y por no complicar mucho el tema, ya veremos más en profundidad otros aspectos de la visibilidad en programación orientada a objetos, vamos a disponer de variables locales que se declaran en un bloque de código y son visibles = se pueden usar sin problema, dentro del fragmento de código donde se han definido. Y por otro lado tenemos las variables globales, cuyo ámbito es mayor, y las podemos utilizar en programas o librerías con muchas más líneas de código, yendo y viniendo entre bloques de código diferentes (ya veremos los procedimientos y las funciones). Atención, al principio de empezar con esto de la programación solemos utilizar mucho las variables globales porque las podemos utilizar donde nos rota. Peligro: si se puede utilizar una variable local mejor, ya que las globales consumen espacio de memoria durante toda la ejecución del programa, mientras que las locales se crean y se destruyen en los “trozos” de código donde se han declarado, liberando la memoria que se había reservado para ellas. Así que sé prudente ¡My friend! Usa variables locales de forma correcta y no te preocupes, esto lo irás aprendiendo con el tiempo, e iréis mejorando vuestro estilo de código.

Las constantes son como las variables pero tienen un valor fijo que… como su nombre indica, no varía. Un ejemplo, pues el canónico por excelencia, declarar una constante llamada “Pi” cuyo valor es 3,14159 -por ejemplo. Y en vez de usar el numeraco, usaremos simplemente “Peeeeeeedrooooo”, que diga “Pi”. ¿fácil no? No tiene más.

Sentencias de código.

Las sentencias pueden resultar un poco más difícil de entender, pero para los que nos ocupa nos vamos a quedar con una definición fácil -nos servirá por el momento-: las sentencias son líneas de código que describen acciones algorítmicas que se pueden ejecutar ¡vaya tela!, bien, digamos que una sentencia de código de asignación (a una variable le asignamos un valor) es una sentencia; más fácil así ¿verdad?

Podemos clasificar las sentencias en ejecutables (sentencias correspondientes a cálculos aritméticos y otras operaciones como entrada/salida) y no ejecutables (ayudan a la legibilidad del programa pero no realizan acciones concretas) y en simples (no contienen ninguna otra sentencia) o estructuradas (compuestas, a su vez, por varias sentencias simples). Las sentencias ejecutables serán transformadas por el compilador en una o más instrucciones máquina dentro del código objeto. Las no ejecutables no se traducen en intstrucciones en lenguaje máquina y por lo tanto no aparecerán en el archivo de código objeto.

Creo que por lo que toca a las sentencias es suficiente por ahora. Pasemos a ver las operaciones y las expresiones.

Operaciones y expresiones

Tenemos datos, tenemos sentencias, ya podemos operar o relacionar los datos para obtener algún resultado. Si os habéis fijado en el título de esta entrega de la escuela de programación, “la ‘p’ con la ‘a’, “pa”", se puede traducir a código mediante la operación de concatenación entre caractéres o cadenas ¿divertido no? string letra1 = “p”; string letra2 = “a”; y ahora ponemos la operación: string concat = letra1 + letra2; ahora concat tiene la palabra (cadena) “pa”. Hemos “operado” dos datos, la operación ha sido la de concatenación entre cadenas y los operandos dos cadenas, más concretamente, dos letras o caractéres. Atención: que igual que no podemos sumar números con peras, tampoco podemos operar cualquier dato entre sí, los tipos de datos deben ser consistentes y operables entre sí.

Visto un ejemplo de operación, podemos ya decir que una expresión es un conjunto de variables o constantes relacionadas en una sentencia por algún operador. Digo algún operador porque es posible que en una misma expresión aparezcan varios operadores, en cuyo caso hay que conocer las reglas básicas de funcionamiento de los operadores, y así utilizar paréntesis para agrupar correctamente los datos que estamos operando de forma que obtengamos un resultado apropiado. También conviene conocer las reglas de precedencia, es decir, qué operadores “dominan” sobre otros, esto quiere decir que ante dos operaciones, y si no se han precisado los paréntesis apropiados para diferenciar la sentencia, el lenguaje de programación tiene predefinidas una serie de reglas de importancia, por las que, por ejemplo, primero multiplica y luego suma (en una expresión del tipo (5 + 4 * 10) obtendremos un resultado, concretamente 45, y si ponemos (5+4)*10 obtendremos otro diferente, 90. Conviene conocer las reglas de precedencia de los operadores para no obtener resultados inesperados.

¿Qué tipo de expresiones vamos a poder escribir? Expresiones aritméticas, en las cuales el resultado termina siendo un número y expresiones lógicas o booleanas, cuyo resultado suele ser una condición de verdad/falsedad (valores “sí se cumple” o “no se cumple”).

Los operadores aritméticos típicos (los puedes consultar todos en la referencia del lenguaje, desde Visual Studio, F1 y buscas Operadores aritméticos): suma, resta, multiplicación, división, módulo (= resto)… Los operadores lógicos: and (y), or (o), not (no), xor (o exclusiva)… También tenemos otro tipo de operadores que podemos denominar “de relación” y que operan generalmente devolviendo un booleano (verdadero/falso) o uno de los dos elementos comparados: igual, mayor que, menor que, mayor o igual que, distinto, etc. En vez de enumerarlos todos, os invito a abrir vuestra herramienta de desarrollo, a darle a F1 (ayuda) y buscar en la referencia del lenguaje “operadores”, ahí tendréis una descripción detallada de los que hay, cómo funcionan y algunos ejemplos, aunque sea repetitivo, ¡mirad la ayuda siempre! ¡consultad msdn local u on line! ¡utilizad los recursos que tenéis a vuestro alcance! -es divertido y se aprende un montón-.

Estructuras de control

Ya se va complicando la cosa. Sabemos declarar variables y constantes de algún tipo de datos, sabemos compararlas, sabemos escribirlas pero ¿cómo vamos a controlar la secuencia de lo que ocurre en nuestro programa? Pues muy fácil, preguntando valores de variables y ejecutando partes del código en función de la respuesta a estas preguntas. ¿Y cómo se pregunta y se actúa en consecuencia? Pues en los lenguajes de programación con lo que se llaman sentencias o estructuras de control.

Las estructuras de control son fragmentos de código en los que se evalúa una condición (comparación de variables, objetos que deben tener un determinado valor, resultado de una expresión lógica…). Y en función del resultado de la evaluación nos vamos por una parte del código o nos vamos por otra. Un ejemplo: Si tengo pelas me voy de marcha y si no tengo pelas me quedo en casa viendo una peli divX- La condición aquí es (Tengo Pelas), y el resultado de la evaluación es Sí o NO. Es fácil, me meto las manos en el bolsillo y si toco algodón a casa, y si toco papel (billes) me voy de marcha. -siempre me quedará la posibilidad de salir de marcha y gorrearle a los amigotes un par de copas, pero esto no lo podemos hacer siempre si no queremos convertirnos en gorrones [;)] .

Por lo tanto ya sabemos qué forma van a tener las estructuras de control, Si (condición o expresión lógica) entonces (conjunto de sentencias a realizar en caso de que se evalúe a cierto la condición) SI NO, es decir si la condición no se cumple, no hago lo anterior sino que me voy por la parte de sentencias que tengo que hacer en caso de que no se cumpla. Es fácil. Esto es lo que se suele llamar estructura de control selectiva (se escoge una opción en función de una expresión lógica. Hay otra forma de controlar el flujo o la secuencia de acciones de un programa de forma selectiva y es utilizando la sentencia “En caso de que” = CASE. Esta estructura de control nos permite evaluar más resultados de la expresión lógica, es decir, en vez de tener Verdadero/Falso, podríamos recorrer un vector, o una lista de valores, por ejemplo: En caso de que “opcion” sea igual a 1 entonces mostramos el botón 1, si es 2, mostramos el botón 2, si es tres, mostramos el botón 3… En este ejemplo, opción no devuelve un sí/no, sino que tendrá un valor numérico que puede ser, por ejemplo un valor entre 1 y 4, dando cinco posibilidades de actuación, es decir, o es 1, o es 2, o es 3 o es 4 o no es ningúno de los anteriores ¿está guay eh? Pues es así de fácil.

Otro conjunto de estrucutras de control bastante chulo, son las repetitivas, que nos van a servir para ejecutar un conjunto de sentencias de forma repetida un número determinado de veces o bien hasta que se cumpla una determinada condición. El conjunto de sentencias que se ejecutarán se denomina “bucle” y cada repetición del cuerpo del “bucle” -de las sentencias incluídas aquí dentro- se denomina iteración (o “vuelta” aunque este término no es muy formal). Las estructuras de control repetitivas más conocidas son los bucles WHILE (mientras se de una condición que se evalúa al principio de la ejecución) y FOR (repetir un conjunto de sentencias mientras vamos evaluando unas variables de control o índices del buble).

Bucle WHILE: MIENTRAS HACER { } FIN_MIENTRAS.

Bucle FOR: DESDE HASTA HACER {} FIN_DESDE.

No os preocupéis por ahora si os resulta complicado o no lo acabáis de ver. En cuando empecemos a codificar lo váis a ver más fácil que nunca.

Procedimientos y funciones. Estructurando nuestro código.

Cuando nuestro programa comienza a crecer y crecer, a veces se complica el manejo del mismo y resulta difícil encontrar las cosas y ver cómo se ejecuta el programa. Además, hay determinadas aplicaciones que son muy grandes de abordar y resulta casi imposible poder empezar a trabajar pensando en toda la aplicación como conjunto.

Los procedimientos y las funciones son mecanismos que nos ofrece el lenguaje, por un lado para estructurar y agrupar fragmentos de código que se centran en resolver un subproblema o tarea más pequeña del gran problema y por otro nos ayudan a pensar en el problema como un conjunto de pequeñas -o a veces no tan pequeñas- tareas que hay que ir resolviendo, es lo que se denomina a menudo, el enfoque Top-Down que quiere decir que un programa se puede diseñar pensando en el gran problema y descomponiéndolo en pequeñas partes o subproblemas más sencillos de abordar. Estos subprogramas o subtareas de un programa más grande o aplicación es lo que podemos denominar procedimientos y funciones (lo que nos ofrecen los lenguajes para abordar esta descomposición), y son unidades de programa diseñados y codificados para ejecutar una tarea específica dentro de nuestro programa.

Los procedimientos se caracterizan porque son mini-programas (piezas de código) que pueden devolver cero, uno o más valores de vuelta (resultado de la ejecución del mismo). La forma de identiricarlos es a través de una firma (signature en inglés) que define el nombre del procedimiento y los parámetros que recibe con sus correspondientes tipos.

Las funciones por el contrario se caracterizan porque son fragmentos de código que realizan una o varias operaciones y devuelven como resultado de la ejecución de la función un valor concreto (un entero, un objeto, una estructura, una colección….). La forma de identiricarlos es a través de una firma (signature en inglés) que define el nombre de la función y los parámetros que recibe con sus correspondientes tipos.

Los parámetros son un mecanismo de comunicación con el programa principal. Son como “puertos” en argot informático, más concretamente pueden ser de entrada, salida y entrada/salida en función de que sean parámetros de lectura (entrada), escritura (salida) o bien se utilice como entrada/salida (parámetro de lectura/escritura). Los parámetros de entrada se leerán dentro del procedimiento o función, los de salida se escribirán como resultado de operar dentro del procedimiento o función y serán proporcionados al programa principal que los usará como sea necesario.

Un ejemplo para finalizar:

procedimiento SumaDosNumeros (numero1 como entero, numero2 como entero) devuelve entero_resultado

{ Devolver entero_resultado = numero1 + numero2;}

fin_procedimiento;

Una vez declarado podremos llamar al procedimiento desde el programa principal, habiendo inicializado/declarado dos valores enteros que le pasaremos al procedimiento en su llamada podemos llamar a nuestro procedimiento desde el programa principal: resultado_de_la_suma = SumaDosNumeros(num1, num2);

Como creo que este artículo ya es lo bastante largo -espero que me comprendáis, intento resumir al máximo- yo creo que está bien por hoy, que ya hay bastantes cosas para aprender o repasar, así que lo dejamos aquí y continuamos en el siguiente artículo de la serie “Escuela de programación .NET” con “Mi gato es OO. Una breve introducción a la programación orientada a objetos”.

Seguimos en contacto en la bloguera… Maik.

Para jugar un poco…

using System;

using System.Text;

namespace muybasica1

{

class Program {

static void Main(string[] args)

{ // Declaración e inicialización de variables de nuestro programa.

string letra1 = “p”;

string letra2 = “a”;

string concat = letra1 + letra2;

Console.WriteLine(concat);

int num1 = 5 + 4 * 10;

Console.WriteLine(num1);

int num2 = (5 + 4) * 10;

Console.WriteLine(num2);

Console.WriteLine(“Quieres mostrar por pantalla: 1=Cadena 2=Número”);

Console.Write(“Por favor, realiza tu selección: “);

string cadenaopcion = Console.ReadLine();

int num_opcion = int.Parse(cadenaopcion);

switch (num_opcion) {

case 1:

Console.WriteLine(“Has elegido letra: ” + concat); break;

case 2:

Console.WriteLine(“Has elegido número: ” + num2); break;

default:

Console.WriteLine(“No has elegido una opción válida. Fin del pgorrama”); break;

}

Console.ReadLine();

}

}

}