LENGUAJES ORIENTADOS A OBJETOS - Python

Laboratorio de Lenguajes de Programación - Semana 9

Siempre hago mucho hincapie en las características de este hermoso lenguaje, la verdad es que desde que lo utilice por primera vez me enamore :p, pues es muy sencillo de usar y de aprender asi que realmente los invito a utilizarlo

Esta es una corta entrada hecha por mi sobre Python y la Web

INTÉRPRETE

Recordemos que los códigos escritos en Python no son compilados sino interpretados, y Ubuntu incluye dicho intérprete.
Solo basta con teclear en la terminal: which python
para comprobar y verificar la ubicación donde esta disponible.


Por lo general el intérprete se encuentra en la carpeta /usr/bin/python.

La extensión de los códigos fuente es *.py.

Para interpretar un script en Ubuntu primero hay que otorgarle permisos de ejecución, esto se hace con el comando chmod.

Por ejemplo: chmod u+x archivo.py

VARIABLES Y TIPOS

Python maneja 3 tipos de variables:

Números que pueden ser enteros (int), coma flotante (float) o complejos (complex)
Cadenas de texto que son simples caractéres (char)
Booleanos o lógicos, que devuelven dos estados "TRUE" o "FALSE".

Python es un lenguaje de tipado dinámico se refiere a que no es necesario declarar el tipo de dato que va a contener una determinada variable, sino que su tipo se determinará en tiempo de ejecución según el tipo del valor al que se asigne, y el tipo de esta variable puede cambiar si se le asigna un valor de otro tipo, claro, siempre y cuando se haga un typecasting.

Yo puedo hacer esto:

c = 90
x = 12.36
a = "Hola a todos"

Todas las anteriores son declaraciones de variables, no necesito en realidad decirle a Python de que tipo son (int, float o char), el intérprete me lo detectará automáticamente

Operadores

Operadores a nivel bit

El operador and (&), del inglés “y”, devuelve 1 si el primer bit operando es 1 y el segundo bit operando es 1. Se devuelve 0 en caso contrario.

El operador or (|), del inglés “o”, devuelve 1 si el primer operando es 1 o el segundo operando es 1. Para el resto de casos se devuelve 0.

El operador xor u or exclusivo (^) devuelve 1 si uno de los operandos es 1 y el otro no lo es.

El operador not (~), del inglés “no”, sirve para negar uno a uno cada bit; es decir, si el operando es 0, cambia a 1 y si es 1, cambia a 0.

Por último los operadores de desplazamiento (<<>>) sirven para desplazar los bits n posiciones hacia la izquierda o la derecha.

Booleanos

BÁSICO

Salida estándar

Para imprimir en pantalla un mensaje o el resultado de algun proceso se utiliza la función print:

print "Hola, esto es una cadena de texto"

Para imprimir el valor de una variable:

x = 20
print x

Para imprimir variables y texto combinados, se concatenan con el operador "+".

nombre = "Juan"
edad = 20
print "Hola, me llamo " + nombre + " y tengo " + edad + "años"

Entrada estándar

Para introducir datos desde el teclado se utilizan las funciones input y raw_input:

Si queremos introducir una cadena competa utilizaremos raw_input:

cadena = raw_input("Introduce una oracion: ")

Para un dato numerico se utiliza input:

x = input("Dame un valor: ")

ESTRUCTURAS DE CONTROL

Codicional

if condicion:
 proceso(s)

Por ejemplo:

if x == 2:
 print "x es un dos"

if ... else ...

if condicion:
 proceso(s)
else:
 proceso(s)

Por ejemplo

if x == 2:
 print "x es un dos"
else:
 print "x es igual a " + x

elif (multiples condiciones)

if condicion1:
 proceso(s)
elif condicion2:
 proceso(s)
elif condicion3:
 proceso(s)
else:
 proceso(s)

Por ejemplo:

if x == 1:
 print "x es igual a uno"
elif x == 2:
 print "x es igual a dos"
elif x == 3:
 print "x es igual a tres"
else:
 print "desconozco cuanto valga x"

Ciclo For

for var_iteracion in secuencia:
 proceso(s)

Por ejemplo

print "Inicia el conteo"
for i=1 in range (10):
 print i
print "FUEGO!!!"

Ciclo While

while condicion:
 proceso(s)

Por ejemplo

salir = False
while salir == False:
respuesta = raw_input("Desea Salir \n")
if(respuesta == "si"):
   salir=True
else:
   salir=False
print "Acabas de Salir"

Python y la Programación Orientada a Objetos

Conceptos Básicos

Para entender este paradigma primero tenemos que comprender qué es una clase y qué es un objeto.

Un objeto es una entidad que agrupa un estado y una funcionalidad relacionadas. El estado del objeto se define a través de variables llamadas atributos, mientras que la funcionalidad se modela a través de funciones a las que se les conoce con el nombre de métodos del objeto.

Un mensaje es la manera en que se comunican los objetos entre si, por eso cuando llamemos a alguna funcion de un objeto diremos que le estamos enviando un mensaje; entonces los metodos se encargan de procesar los mensajes que lleguen al objeto.

Una clase, por otro lado, no es más que una plantilla genérica a partir de la cuál instanciar los objetos; plantilla que es la que define qué atributos y métodos tendrán los objetos de esa clase.

Como ya mencione en la entrada de C++, las clases y por lo tanto los objetos tienen partes públicas y privadas, a la parte pública muy regularmente nos referiremos a ella como la interfaz, esta sera la única parte visible para los demas procesos y además la que esta dispuesta a compartir información y comunicarse con los demás.

La herencia se refiere basicamente al hecho de que una subclase, ademas de contener metodos y atributos propios tiene a su vez todos los atributos y métodos de la clase madre o superclase

Un ejemplo de objeto podría ser un coche, en el que tendríamos atributos como la marca, el número de puertas o el tipo de carburante y métodos como arrancar y parar. O bien cualquier otra combinación de atributos y métodos según lo que fuera relevante para nuestro programa.

Clases

En Python, una clase se declará con la palabra reservada class:

class Nombre_clase:

Importante señalar que el nombre de las clases por convención debe iniciar con mayúscula, aunque no es formalmente necesario para su correcto funcionamiento.

Si la clase no define atributos, pues no debe estar vacía, entonces se utilizará la palabra pass:

class Sin_atributos:
  pass

Equivalente a usar "{}" en otros lenguajes.

Métodos

Los métodos se declaran con la misma sintáxis que las funciones, con la palabra reservada def:

class Aritmetica:
  def suma(atributos):

Constructores???

Python no contiene formalmente lo que llamaremos Constructor, tienen un método llamado __init__ (con doble guion bajo antes y despues del nombre), su función es emular un constructor inicializando las variables o atributos:

class Aritmetica:
  def __init__ (self, x, y):
     self.a = x
     self.b = y

  def suma (self):
     print self.a + self.b

Este método es llamado automáticamente tras crear una instancia de la clase.

Como ya vimos, el primer atributo del método es self, que es una referencia al objeto recién creado, en otros mótodos se refiere a la instancia cuyo método ha sido llamado. Después de el pueden seguir la cantidad de argumentos que sean necesarios.

Instancias

Crear una instancia es tan fácil como enviar un valor a una función, en términos de OO, como enviar un mensaje a un método:

class Aritmetica:
  def __init__ (self, x, y):
     self.a = x
     self.b = y

  def suma (self):
     print self.a + self.b

def main():
  print "Suma mediante Programacion Orientada a Objetos"
  operacion = Aritmetica(3,5)
  operacion.suma()

if __name__ == "__main__":
  main()

En este ejemplo, la instancia se crea cuando "operacion" envia parámetros a "Aritmetica", recordemos que el metodo "__init__" se llama automáticamente por lo que ya tenemos asignados los parámetros a los atributos de la clase (suma1 y suma2).
Despues invocamos al método "suma" para realizar la operación, "suma" imprimirá el resultado final.

**RECUERDEN AGREGAR EL INTERPRETE AL CÓDIGO (#!/usr/lib/python) EN LA PRIMERA LÍNEA.

EJECUCIÓN DEL EJEMPLO ANTERIOR


No es necesario liberar de manera explícita las instancias (definir destructores) ya que Python elimina automáticamente las variables cuando salen del ámbito.

Herencia

Para declarar explícitamente la herencia de los atributos de la clase madre a otras subclases, es necesario colocar después del nombre de la subclase un paréntesis con el nombre de la clase madre, por ejemplo:

class Animales:
   pass

class Gato(Animales):
   pass

class Perro(Animales):
   pass

Encapsulación

Python no tiene modificadores de acceso explícitos, en su lugar el acceso a un atributo de determina en su nombre:

Privados: Si en el nombre del metodo se inicia con doble guión bajo y no termina con doble guión bajo:

class Animales:
  def __nombre(self):

Todos lo demas que no cumpla con esta regla se considera público.

Espero y les sirva bastante esta entrada sobre la programación orientada a objetos en Python

SALUDOS!!! ^_^

LENGUAJES ORIENTADOS A OBJETOS - C++

Laboratorio de Lenguajes de Programación - Semana 9

"C++ es un lenguaje de programación diseñado a mediados de los años 1980 por Bjarne Stroustrup. La intención de su creación fue el extender al exitoso lenguaje de programación C con mecanismos que permitan la manipulación de objetos. En ese sentido, desde el punto de vista de los lenguajes orientados a objetos, el C++ es un lenguaje híbrido.

Posteriormente se añadieron facilidades de programación genérica, que se sumó a los otros dos paradigmas que ya estaban admitidos (programación estructurada y la programación orientada a objetos). Por esto se suele decir que el C++ es un lenguaje de programación multiparadigma.

El nombre C++ fue propuesto por Rick Mascitti en el año 1983, cuando el lenguaje fue utilizado por primera vez fuera de un laboratorio científico. Antes se había usado el nombre "C con clases". En C++, la expresión "C++" significa "incremento de C" y se refiere a que C++ es una extensión de C."

FUENTE: http://es.wikipedia.org/wiki/C%2B%2B

C++ se considera un lenguaje híbrido porque ademas de incluir múltiples mecanismos para manejar objetos, se incluyen todas las funcionalidades de C, se puede decir que es un remix.

COMPILADOR

El S.O. de Ubuntu trae por defecto un compilador para C++ que forma parte del proyecto GCC, para llamarlo podemos ejecutar en la terminal la siguiente instrucción:

g++

Con ello llamaremos al compilador, que nos debe lanzar una ventana como esta:


La extension de los códigos fuente escritos en este lenguaje es *.cpp, los headers tienen la terminación *.hpp

VARIABLES

A grandes razgos podemos decir que los tipos de datos son los mismos que en el lenguaje C, sin embargo, un tipo de dato nuevo que llamo mi atencion es el llamado wchar_t, como sabemos la variable tipo char es de 1 byte, esto nos permitia manejar los 255 caractéres basicos del ASCII, pero en la actualidad ese estandar ASCII ha crecido con la inclusión de diferentes alfabetos de diferentes regiones; asi la variable wchar_t permite almacenar cualquier caracter que este por encima de los 255 del alfabeto ingles, por ejemplo símbolos griegos, cirílicos, chinos, etc.

Otra particularidad es el manejo de cadenas de caracteres, mientras en C teniamos que declarar un "arreglo" de caracteres, en C++ se utiliza la palabra string para declarar una cadena, claro que hay que incluir la libreria <string> por ejemplo:

C : char cadena[4] = "HOLA"

C++ : string cadena = "Esto es una cadena"

BÁSICO

La libreria estándar se C++ se llama iostream, tiene la misma funcionalidad que la libreria stdio.h, leer una sequencia de caractéres, números, o instrucciones desde el teclado, y tambien imprimir en pantalla los mensajes y resultados de los procesos ejecutados por nuestro programa. Tambien debemos agregar la línea using namespace std;

Salida Estándar

Para imprimir en la pantalla algun dato o mensaje desde nuestra aplicación usaremos cout; el cual obedece la siguiente sintaxis:

cout << "Cadena de salida"; // Imprime una cadena en pantalla
cout << 120;                // Imprime un numero
cout << x;                  // Imprime el contenido de la variable x
cout << "Hola, tengo " << x << " años y me llamo " << nombre; // Combinacion variables y texto

Al igual que en C, para saltar de línea se puede usar \n, pero tambien podemos indicarle que una línea ha terminado con endl, por ejemplo:

cout << "Primera linea." << endl;
cout << "Segunda linea." << endl; 

Que produciria la salida:

Primera linea.
Segunda linea

Entrada Estándar

Para ingresar datos se utiliza cin; de la siguiente manera:

int a, b, c, d;
string cadena;

cout << "Ingresa un valor -> ";
cin >> a;

cout << "Ingresa tres valores mas -> ";
cin >> b >> c >> d;

cout << "Ingresa una palabra -> ";
cin >> cadena;

La última sentencia es valida si deseamos introducir una palabra, si deseamos introducir una cadena de caractéres completa, se combinara cin con la instruccion getline:

string cadena;

cout << "Ingresa una cadena -> ";
getline(cin , cadena);

ESTRUCTURAS DE CONTROL

Existen diferentes estructuras de control que nos ayudaran a controlar nuestro programa dadas diferentes circunstancias especiales:

Estructura condicional

if (condicion) {proceso1; proceso2; ... ; proceson; }

if (x == 100)
 cout << "x es igual a 100";

.
"DOS POSIBILIDADES (Si no es uno es lo otro)"

if (condicion) proceso1; else proceso2

if (x == 100)
 cout << "x es igual a 100";
else
 cout << "x no es igual a 100";

"MULTIPLES POSIBILADES (Si no es esto entonces es esto, si no esto otro"

if (condicion) proceso1; else if (condicion2) proceso2; else proceso3;

if (x > 0)
 cout << "x es positiva";
else if (x < 0)
 cout << "x es negativa";
else
 cout << "x es 0";

Estructuras de Iteracion

Ciclo while

while (expresion) proceso;

int x = 10;
cout << "Comenzando conteo Houston . . ."
while (x>0) {
   cout << x << endl;
   --x;
}
cout << "FUEGO!!!";

Ciclo do-while

do proceso while (expresion);

int x;
do {
  cout << "Ingresa un numero (0 para salir);
  cin >> x;
  cout << "Igresaste el numero " x;
} while (x != 0);

Ciclo for

for (inicializacion; condicion; incremento) procesos;

int x;
cout << "Inicia el conteo Houston . . .";
for(x = 10; x > 0; x--)
   cout << x << "-";
cout << "FUEGO!!!";

Estructura Selectiva

switch (expresion) {
case constante1:
grupo de procesos 1;
break;
case constant2:
grupo de procesos 2;
break;
.
.
.
default:
grupo de procesos por default (cuando no se cumple ninguno de los anteriores);
}

switch (x) {
 case 1:
   cout << "x es 1";
   break;
 case 2:
   cout << "x es 2";
   break;
 default:
   cout << "el valor de x se desconoce";
 }

C++: Programación Orientada a Objetos

Clases y Objetos

Una clase es un concepto ampliado de una estructura de datos, pero en lugar de mantener sólo los datos, que puede contener tanto datos como funciones.

Un objeto es una creación de instancias de una clase.

En términos de coloquiales de variables, una clase sería el tipo y un objeto sería la variable.

Las clases se declaran con la palabra reservada class, y su estructura sería como la siguiente:

class nombre_clase {
 especificador_de_acceso1:
   miembro1;
 especificador_de_acceso2:
   miembro2;
 ...
 } nombre_del_objeto;

Los especificadores de acceso pueden ser de tres tipos:

private (miembros privados) Miembros de una clase que sólo son accesibles desde el interior de los demás miembros de la misma clase o de sus amigos.
protected (miembros protegidos) Miembros que son accesibles desde los miembros de su misma clase y de sus amigos, y también de los miembros de sus clases derivadas.
public (miembros publicos) Son accesibles desde cualquier lugar donde el objeto es visible.

Por ejemplo:

class CRectangle {
   int x, y;
 public:
   void set_values (int,int);
   int area () {return (x*y);}
}rect;

Mi clase se llama CRectangle, y el objeto completo se llama rect, aunque no los hayamos especificado como tales tenemos dos miembros privados x y y (ya que el nivel de acceso por default es private, después tenemos otros dos miembros públicos: void valores (int,int); y int area (void);. "set_values" será considerado como un emulador de un constructor, porque inicializara los valores de "x" y "y", mientras que "area" calculara el área del rectángulo.

Pequeño Ejemplo

#include <iostream>
using namespace std;

class CRectangle {
   int x, y;
 public:
   void set_values (int,int);
   int area () {return (x*y);}
};

void CRectangle::set_values (int a, int b) {
 x = a;
 y = b;
}

int main () {
 CRectangle rect;
 rect.set_values (3,4);
 cout << "area: " << rect.area();
 return 0;
}

Comenzando en la función main: Primero creamos un objeto de la clase CRectangle llamado "rect". Llamamos a lo que denominamos "constructor" enviandole los 2 parámetros que son los lados del rectángulo, estos valores se envían a la función "void CRectange::set_values (int a, int b)" el cual asignará los 2 valores enviados a los miembros privados "x" y "y". Después imprimimos el valor del área calculada llamando a "rect.area", el cual esta preparado para regresarnos el producto de los dos lados.

EJECUCIÓN

Constructores y Destructores

Todos los objetos necesitan inicializar las variables al momento de ser llamados y volverse operativos. En el ejemplo anterior nosotros necesitamos asignar un valor a las variables "x" y "y" si realmente queremos que se nos regrese algún resultado al momento de ejecutar nuestro programa, es por ello que necesitamos lo que denomina Constructor.

Los constructores tienen el mismo nombre que la clase madre y son llamados automaticamente cuando un objeto de su misma clase es creado. Estos constructores no regresan ningun valor, ni siquiera void.

Un destructor cumple la función opuesta, son llamados cuando un objeto es destruido porque su tiempo de existencia ha terminado ya sea porque el objeto de definió localmente en una función y el proceso de la función terminó o porque se trataba de un objeto asignado dinamicamente y la memoria ocupada se libera con "delete". Los destructores se declaran como miembros de la clase y se deben llamar igual, pero van precedidos por un tilde (~), al igual que los constructores no regresan nada al terminar su ejecucion.

Si nosotros quisieramos implementar un constructor y un destructor en el ejemplo anterior basta con reemplazar la funcion "void set_values"; asi el nuevo miembro público se llamaría CRectangle (int,int), que sería el constructor. Y la función quedaría de esta forma:

CRectangle::CRectangle (int a, int b) {
 x = a;
 y = b;
}

Y nuestro destructor se llamaría ~CRectangle ();, y tendriamos que darle algunos procesos:

CRectangle::~CRectangle () {
 delete width;
 delete height;
}

Su tarea sera la de liberar la memoria ocupada por las variables "width" y "height".

EJEMPLO UTILIZANDO CONSTRUCTOR Y DESTRUCTOR

#include <iostream>
using namespace std;

class CRectangle {
   int *width, *height;
 public:
   CRectangle (int,int);
   ~CRectangle ();
   int area () {return (*width * *height);}
};

CRectangle::CRectangle (int a, int b) {
 width = new int;
 height = new int;
 *width = a;
 *height = b;
}

CRectangle::~CRectangle () {
 delete width;
 delete height;
}

int main () {
 CRectangle rect (3,4), rectb (5,6);
 cout << "rect area: " << rect.area() << endl;
 cout << "rectb area: " << rectb.area() << endl;
 return 0;
}

EJECUCIÓN


Ahora implementamos 2 instancias diferentes de la misma clase y los mismos miembros.

Estos son algunos aspectos basicos del lenguaje C++, claro que faltan otros mas por analizar. Si les interesa seguir aprendiendo pueden ver el tutorial que les deje en mis Recursos, donde podrán aprender otros conceptos relacionados a la programación orientada a objetos.

SALUDOS!!! ^_^

TIPOS DE DATOS

Laboratorio de Lenguajes de Programación - PUNTOS EXTRA

En la programacion, un tipo de dato es un atributo, que le indica al sistema la clase de información a procesar. Los tipos de dato mas comunes son los numéricos, los caractéres y los légicos.

Al principio todos los datos en la máquina ingresan y se representan como bits (1 y 0) en su nivel mas bajo. Los bits se pueden agrupar, por ejemplo, en 8 y formar un Byte.

Como los tipos de datos son una referencia a la clase de información a procesar, la máquina es capaz de considerar un rango de valores específico para cada tipo de dato, acorde a las necesidades de memoria del mismo. Este rango delimita por ejemplo cuantos números es capaz de procesar la maquina antes de que haya algun fallo. Estos son los rangos de cada tipo de dato:



Caractéres: Son digitos individuales con los cuales se pueden representar digitos, letras y el simbolo $.
Enteros: Como su nombre lo dice, este tipo de dato almacena numeros enteros.
Punto Flotante: Este tipo de dato almacena números muy grandes con parte decimal.
Lógicos: Los considerados booleanos, solo tienen 2 posibles estados TRUE y FALSE.

Tambien existen tipos de datos compuestos, por ejemplo las cadenas de caracteres que son grupos de caracteres que pueden formar una oracion o un dato mas complejo.
Las estructuras son definiciones que contienen 2 o mas tipos de datos fusionados en uno solo.

ESTRUCTURAS DE DATOS

Una vez que tenemos los tipos de datos que vamos a necesitar usualmente despues necesitamos organizarlos de cierta manera, y las estructuras de datos nos ayudan muchas veces a realizar esa tarea.

Comenzando desde el incio, existen identificadores de memoria a las cuales de les conoce como variables, una variable es un nombre que se le da a determinada direccion de memoria y a su vez es el lugar donde se almacenaran los datos que el usuario utilizara durante la ejecucion del programa.
En general existen varias reglas para declarar una variable, ya que no cualquier nombre es valido, estas reglas se extienden a la mayoria de los lenguajes de programacion, estas son:

1. Iniciar con una letra del alfabeto ingles, nunca se debe iniciar con caracteres especiales, ni simbolos (excepto el guion bajo).
2. Despues de la primera letra se pueden colcar mas caracteres y numeros, pero siguiendo la regla numero 1.
3. No espacios en blanco.
4. No palabras reservadas del lenguaje.

Las variables quedan definidas por el tipo de dato con el que han sido "marcadas" y despues estas variables son las que a nivel usuario son manejadas por nosotros.

Arreglos

Tambien son llamados vectores, y son espacios de alamacenamiento continuo dentro de la memoria, dichos espacios contiguos almacenan una serie de datos del mismo tipo y llamados todos por igual, si se quiere referir a un solo elemento del arreglo se hace por medio de un indice, por ejemplo:

int a[5] => |0|1|2|3|4|

considerandose el arreglo anterior, cada elemento queda enumerado del 0 al 4 y cada uno de estos numeros se considera el indice de cada elemento; y por lo general se almacenan en fila (una dimension), tambien existen arreglos multidimensionales siendo el limite humano aquel arreglo de tres dimensiones.



Listas

Es otro tipo de estructura de datos. Consiste en una secuencia de nodos, en los que se guardan campos de datos arbitrarios y una o dos referencias (punteros) al nodo anterior o posterior.

El principal beneficio de las listas enlazadas respecto a los array convencionales es que el orden de los elementos enlazados puede ser diferente al orden de almacenamiento en la memoria o el disco, permitiendo que el orden de recorrido de la lista sea diferente al de almacenamiento.
La desventaja frente a los arreglos es que cada elemento esta referenciado por lo que no es posible accesar a cada uno de manera aleatoria y hay que seguir una secuenciaa para llegar al elemento deseado.

Existen diferentes tipos de listas enlazadas: Lista Enlazadas Simples, Listas Doblemente Enlazadas, Listas Enlazadas Circulares y Listas Enlazadas Doblemente Circulares.

Lista enlazada simple: Cada uno de los nodos de la lista tiene un solo enlace que apunta al nodo siguiente, o a NULL si esta vacia o es el nodo final


Lista enlazada doble: Cada nodo tiene 2 enlaces, uno apunta al elemento anterios o a NULL si es el primer nodo; el otro apunta al siguiente elemento o a NULL si es el ultimo elemento.


Lista circular enlazada simple: Son identicas a las listas enlazadas simples, la diferencia es que en estas, el nodo final esta enlazado al primero.


Lista circular enlazada doble: Son lo mismo que las listas enlazadas dobles, donde el ultimo elemeno apunta al primero y el primero apunta al ultimo.

Pilas

es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Se aplica en multitud de ocasiones en informática debido a su simplicidad y ordenación implícita en la propia estructura.

Para el manejo de los datos se cuenta con dos operaciones básicas: apilar (push), que coloca un objeto en la pila, y su operación inversa, retirar (o desapilar, pop), que retira el último elemento apilado.

En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto apilado (denominado TOS, Top of Stack en inglés). La operación retirar permite la obtención de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS.


Existen diferentes operaciones que se pueden realizar a una pila:

Crear: se crea la pila vacía.
Apilar: se añade un elemento a la pila.(push)
Desapilar: se elimina el elemento frontal de la pila.(pop)
Cima: devuelve el elemento que esta en la cima de la pila. (top o peek)
Vacía: devuelve cierto si la pila está vacía o falso en caso contrario.

Colas

Son otro tipo de estructura de datos, que es caracterizada por ser una secuencia de elementos en la que la operación de inserción push se realiza por un extremo y la operación de extracción pop por el otro. También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer elemento en entrar será también el primero en salir.

La caracteristica las colas de datos es el hecho de sólo poder acceder al primer y al último elemento de la estructura. Así mismo, los elementos sólo se pueden eliminar por el principio y sólo se pueden añadir por el final de la cola.

Ejemplos de colas los vemos todo el tiempo, al ir de compras y hacer "cola" para pagar, o al ir al banco y hacer fila para ser atendido.


Las operaciones basicas para una cola son:

Crear: se crea la cola vacía.
Encolar (añadir, entrar, push): se añade un elemento a la cola. Se añade al final de esta.
Desencolar (sacar, salir, pop): se elimina el elemento frontal de la cola, es decir, el primer elemento que entró.
Frente (consultar, front): se devuelve el elemento frontal de la cola, es decir, el primero elemento que entró.

Arboles

Es una estructura de datos ampliamente usada que imita la forma de un árbol. Los nodos son la unidad sobre la que se genera un árbol y puede tener cero o más nodos conectados a él denominados hijos. Un nodo a es padre de un nodo b si existe una union de a hasta b. Un nodo sin padres se raíz. Un nodo sin hijos se conoce como hoja. Los demás nodos (tienen padre y uno o varios hijos) se les conoce como rama.


Las operaciones comunes en árboles son:
Enumerar todos los elementos.
Buscar un elemento.
Dado un nodo, listar los hijos (si los hay).
Borrar un elemento.
Eliminar un subárbol (algunas veces llamada podar).
Añadir un subárbol (algunas veces llamada injertar).
Encontrar la raíz de cualquier nodo.

Por su parte, la representación puede realizarse de diferentes formas. Las más utilizadas son:
Representar cada nodo como una variable en el heap, con punteros a sus hijos y a su padre.
Representar el árbol con un array donde cada elemento es un nodo y las relaciones padre-hijo vienen dadas por la posición del nodo en el array.

Usos comunes de los árboles son:
Representación de datos jerárquicos.
Como ayuda para realizar búsquedas en conjuntos de datos

En una entrada anterios pueden ver un codigo en c con la implementación de una cola de datos y una pila de datos.

SALUDOS!!! ^_^

Fuentes:
http://es.wikipedia.org/wiki/Vector_(programación)
http://es.wikipedia.org/wiki/Lista_(estructura_de_datos)
http://es.wikipedia.org/wiki/Pila_(estructura_de_datos)
http://es.wikipedia.org/wiki/Cola_(estructura_de_datos)
http://es.wikipedia.org/wiki/Árbol_(estructura_de_datos)

LENGUAJES IMPERATIVOS - Generalidades ALGOL

Laboratorio de Lenguajes de Programación - Semana 8

Su nombre proviene del acrónimo ALGOrithmic Languaje (Lenguaje Algoritmico), se desarrollo en la década de los años 60 y se convirtió en el estándar para el diseño de algoritmos en libros por los siguientes 30 anos, sin embargo, a pesar de su uso nunca llego a sobresalir como lenguaje de uso comercial, su uso quedo aislado solamente a investigaciones cientificas.

Un comité de representantes de Europa y América diseñaron ALGOL en 1958, en una respuesta a la creciente necesidad de tener un solo lenguaje de programación que fuese universal e independiente de la arquitectura de las computadoras de la época.

Los tres objetivos que rigieron el desarrollo de Algol fueron:

1) Debía ser tan cercano como fuese posible a la notación matemática estándar y debía ser legible dando pocas explicaciones adicionales.

2) Debía ser posible usarlo para la descripción de procesos de cómputo en las publicaciones científicas.

3) Debía ser traducible, de manera mecánica, a programas en lenguaje máquina.

Para sorpresa de todos el diseño original de ALGOL tomó sólo 8 días (el lenguaje consistía de unos cuantos constructores de propósito general y no de una cantidad innumerable de funciones barrocas). Asi, Algol 60 (la primera revision de Algol 58) estaba lista para mayo de 1960.

Algol influyó a muchos lenguajes de la época, por lo que nos daremos cuenta que mucha de la sintaxis de otros lenguajes old school es parecida a la de Algol.

La version que analizaremos sera Algol66.

INSTALANDO EL COMPILADOR

Algol forma parte de la familia de lenguajes imperativos, y un código fuente escrito en Algol necesita ser compilado (aunque parecera mas que lo estaremos interpretando), asi que lo primero es instalar y configurar el compilador.

Lo primero que vamos a hacer es visitar esta pagina y descargar el compilador a una carpeta en nuestro equipo (la descarga debe iniciar automaticamente)

Algol 68 Compiler, Interpreter & Runtime

Nos vamos a dirigir a la carpeta donde descargamos el compilador y extraemos el contenido del archivo algol68g-2.0.0.tgz, lo que nos generará una carpeta llamada algol68g-2.0.0.

Ahora, vamos a abrir nuestra terminal y nos vamos encaminamos a la carpeta algol68g-2.0.0, dentro de la carpeta vamos a encontrar un archivo llamado configure


Para ejecutarlo tecleamos la secuencia ./configure.

Una vez que termine tecleamos la secuencia: make

Veremos una lista de archivos con extensión *.c que estan siendo compilados.


Y despues tecleamos la secuencia make install


Para el correcto funcionamiento del compilador necesitamos instalar la libreria libncurses5-dev con la secuencia:

sudo apt-get install libncurses5-dev


(en mi caso ya la tengo instalada puesto que la necesite en el compilador de Cobol, sin embargo ustedes prosigan con su instalacion, aceptando los mensajes de confirmacion)

Por ultimo una vez mas la secuencia make y despues make install

Con ello ya tenemos listo el compilador, la terminacion del codigo fuente en Algol es *.a68

VARIABLES Y DATOS

Al igual que en muchos lenguajes de programacion, Algol maneja tipos simples de datos y otros mas complejos, estan por ejempo:

INT: Enteros
REAL: Numeros punto flotante
DOUBLE: Punto flotante de precision doble
CHAR: Caractéres
BOOL: Lógicos o Booleanos
COMPLEX: Complejos
STRING: Cadenas de caractéres.
NODE: Nodos (para grafos, árboles, ect)
FILE: Manejo de archivos

En Algol a estos tipos de datos de les conoce como mode-indicants (indicadores de modo), en otros lenguajes de les llama type identifier (identificadores de tipo [de dato]).
Los indicadores de dato se pueden complementar con el indentificador de modo LONG




Las variables se declaran con la siguiente sintaxis:

[mode-identifier] [var name]

Por ejemplo:

INT numero
CHAR letra
STRING nombre

Para declarar una variable e inicializarla se sigue esta sintaxis:

[mode-identifier] [var name] := [value]

Por ejemplo:

REAL pi := 3.14159;
CHAR letra := "A";
STRING nombre := "Juan Carlos";

ENTRADA Y SALIDA DE DATOS

Para mostrar los datos en pantalla (salida), se utiliza la funcion print();, lo que se va a imprimir se escribe dentro de doble parentesis y encerrado en comillas dobles, por ejemplo:

print (("Hola, mundo"));

Si se quiere pasar un espacio se escribe new line dentro de los parentesis, por ejemplo:

print (("Hola, mundo", new line));

Para tomar datos desde el teclado se utiliza el proceso read;, se sigue la siguiente sintaxis:

[mode-identifier] [var name] = read [mode-identifier [low-case]];

Por ejemplo:

INT x = read int;

FUNCIONES MATEMATICAS

Algol incluye algunas funciones que nos pueden ser muy utiles al momento de escribir nuestro codigo; aqui se muestran algunas:

sqrt(x): Raiz Cuadrada
curt(x): Raiz Cúbica
exp(x): Potencias
ln(x): Logaritmo Natural
log(x): Logaritmo base 10
sin(x): Seno
arcsin(x): Seno Inverso
cos(x): Coseno
arccos(x): Coseno Inverso
tan(x): Tangente

ESTRUCTURA DEL CÓDIGO

Todo código en Algol tiene que estar delimitado por clausulas que marquen su inicio y su final de esta forma:

BEGIN
  ...
  PROCEDURES
  ...
END

Con ello podemos definir el código mas corto que podemos escribir :)

BEGIN
  print(("HOLA MUNDO", new line));
END

Los comentarios se limitan mediante la etiqueta COMMENT:

BEGIN
  COMMENT
     Este es mi primer programa en Algol
  COMMENT
  print(("HOLA MUNDO", new line))
END

SECUENCIAS DE CONTROL

Condicional

BEGIN
   IF INT x = read int;
      x < 0
   THEN print ((x, " es negativo"))
   ELSE print ((x, " no es negativo"))
   FI
END

CICLOS

BEGIN
  INT j := 10;
  FOR i TO j DO
     print (("HOLA", new line))
  OD
END

Desde un valor a otro final, incremento

BEGIN
  FOR i FROM -10 TO 10 DO
     print ((i, new line))
  OD
END

Desde un valor a otro final, dos en dos

BEGIN
  FOR i FROM 0 BY 2 TO 10 DO
     print ((i, new line))
  OD
END

Desde un valor a otro final, decremento

BEGIN
  FOR i FROM 10 DOWNTO 1 DO
     print ((i, new line))
  OD
END

CICLO WHILE

BEGIN
  INT x;
  WHILE
     read(X);
     int > 0
  DO
     print (("Mas abajo..."))
  OD
END

EJEMPLO

Ahora que ya vimos la teoria, vamos a la práctica; escribamos un pequeño código en Algol que nos calcule potencias.

Abrimos una terminal y tecleamos emacs -nw potencia.a68

Despues escribimos este código:

BEGIN
  INT base;
  INT exp;
  LONG INT pot := 1;

  print(("BASE: "));  
  read(base);
  print(("EXPONENTE: "));  
  read(exp);

  FOR i TO exp DO
     pot := pot * base
  OD;

  print((base," elevado a la potencia",exp," es",pot))
END

Para compilarlo necesitamos regresar a la carpeta donde esta el compilador algol68g-2.0.0, esto lo hacemos desde la terminal claro esta.
Ya que estamos en la carpeta algol68g-2.0.0 tecleamos esta sintaxis para ejecutarlo:

./a68g /ubicacion_codigo_fuente/, en mi caso:

./a68g /home/juancarlos/temp/potencia.a68


Espero que les haya servido esta información, en la barra de recursos les deje un tutorial para Algol bastante bueno: Tutorial ALGOL.

SALUDOS!! ^_^

LENGUAJES IMPERATIVOS - Generalidades C

Laboratorio de Lenguajes de Programación - Semana 8

Todos conocemos a este lenguaje, considerado el mas importante hasta la fecha y quien a influenciado a una gran cantidad de lenguajes de programación.

A pesar de que es viejo, es muy apreciado por su la eficiencia del código que produce.
Se trata de un lenguaje débilmente tipificado de medio nivel pero con muchas características de bajo nivel. Dispone de las estructuras típicas de los lenguajes de alto nivel pero, a su vez, dispone de construcciones del lenguaje que permiten un control a muy bajo nivel. Los compiladores suelen ofrecer extensiones al lenguaje que posibilitan mezclar código en ensamblador con código C o acceder directamente a memoria o dispositivos periféricos.

Podemos mencionar entre sus principales caracteristicas:

* Un núcleo del lenguaje simple, con funcionalidades añadidas importantes, como funciones matemáticas y de manejo de archivos, proporcionadas por bibliotecas.
* Es un lenguaje muy flexible que permite programar con múltiples estilos. Uno de los más empleados es el estructurado "no llevado al extremo" (permitiendo ciertas licencias de ruptura).
* Un sistema de tipos que impide operaciones sin sentido.
* Usa un lenguaje de preprocesado, el preprocesador de C, para tareas como definir macros e incluir múltiples archivos de código fuente.
* Acceso a memoria de bajo nivel mediante el uso de punteros.
* Interrupciones al procesador con uniones.
* Un conjunto reducido de palabras clave.
* Por defecto, el paso de parámetros a una función se realiza por valor. El paso por referencia se consigue pasando explícitamente a las funciones las direcciones de memoria de dichos parámetros.
* Punteros a funciones y variables estáticas, que permiten una forma rudimentaria de encapsulado y polimorfismo.
* Tipos de datos agregados (struct) que permiten que datos relacionados (como un empleado, que tiene un id, un nombre y un salario) se combinen y se manipulen como un todo (en una única variable "empleado").

Con base a el han surgido otros lenguajes como C++, C#, Objective-C; que se consideran extensiones del mismo para proporcionarle programacion orientada a objetos.

PREPARACIÓN

El sistema operativo UBUNTU incluye el compilador de este lenguaje, su nombre es gcc, para verficar la existencia de este compilador podemos teclear en la terminal

gcc: lo que mostrara un mensaje como este, es una respuesta de la llamada que ejecutamos al compilador, lo que indica que esta instalado y preparado.



LO BÁSICO

En C, las variables se declaran de una forma clara y directa, algunas de ellas pueden ser de los tipos:

char: Caractér del ANSI C
int: Entero
float: Número con punto flotante
double: Número con precisión doble
bool: Lógico

Para su declaración se tiene la siguiente sintaxis:

TipoVariable nombre1, nombre2, ..., nombreN;

Por ejemplo:

char nombre;
int suma;
float pi;
double euler;

Existen también palabras reservadas que no podemos utilizar al momento de escribir nuestro código tales como if, for, while, do, else, break, main, void, return, etc.

Las variables pueden ser locales, y declararse dentro de la función donde vayan a ser utilizadas, con ello solo estaran disponibles para un solo proceso; sin embargo, tambien pueden ser globales y declararse fuera de una funcion, mas especificamente despues de declarar las librerias que han de anclarse al codigo.

ESTRUCTURA DEL CODIGO

Para estructurar un codigo en C, se sigue el siguiente esqueleto:

#include <stdio.h>
#include <libreria.h>
...
#define CONSTANTE
...

tipo variable global;

tipo funcion1 (tipo variable1, tipo variable2) {
  ...;
  procesos;
  ...;
  return;
}

tipo funcionn (...) {
 ...;
}

int main (int argc, char *argv[]) {
  ...;
  procesos;
  ...;
  return 0;
}

Esto es muy general, y algunas parte pueden omitirse o ampliarse dependiendo de la extensión de nuestro programa.

La funcion siempre lleva su tipo, su nombre y entre parentesis los argumentos que recibirá, posteriormente el alcance de la función se limita a un par de corchetes dentro de ellos va el proceso de la función, varias funciones pueden unirse y llamarse entre si para aumentar sus capacidades, el programa siempre terminará cuando se llegue al return 0 de la funcion main.

CICLOS

Son llamados tambien Secuencias de Control, un buen programa debe combinarlas de manera eficiente para lograr un objetivo, nos ayudan a:

- Ejecutar varias veces una secuencia de instrucciones
- Repetir una instruccion.
- Decidir entre alternativas.

Un ciclo if nos ayuda a evaluar una condición y alternar entre dos caminos o mas a seguir:


Su forma general:

...
if(expresion) {
  enunciado1;
} else {
  enunciado2
}
...

Cuando la expresión dentro del parentesis es evaluada como verdadera el enunciado 1 se ejecutara; se der falsa se procedera con la ejecucion del enunciado 2.

Un ciclo for nos sirve para repetir un bloque n cantidad de veces hasta alcanzar un limite determinado, hasta obtener un objetivo, encontrar un resultado, etc.


Es de la forma general:

...
for(expresion1; expresion2; expresion3) {
  ...
  proceso
  ...
}

En la expresion1 se declara el inicio del ciclo, en la expresion2 el limite a alcanzar, la expresion3 marcara si la expresion1 aumenta o disminuye su valor en n cantidad de pasos; mientras de alcanza el limite de la expresion3 el proceso se repetira.

Un ciclo while nos ayuda a evaluar un dato, y mientras ese dato no corresponda con la condicion predeclarada, el ciclo se repetira indefinidamente.


Es de la forma general:

...
while (condicion) {
  ...
  proceso
  ...
}
...

Son utilizadas paa generar pequenas pausas en el sistema, mientras se espera que el usuario proporcione determinada respuesta, tambien puede adaptarse y usarse indistintamente a un ciclo for.

Una sentencia switch nos ayuda a disernir entre varios caminos a seguir, a cada camino le corresponde un proceso completamente individual.


Son de la forma general:

...
switch(expresion entera) {
  case constante1:
      ...
      proceso1
      ...
  case constante2:
      ...
      proceso2
      ...
  case constanten:
      ...
      proceson
      ...
  default :
      ...
      predeterminado
      ...
}
...

Nos ayuda mas que nada a minimizar el uso de sentencias if... else... if lo que es un beneficio al momento de escribir codigos largos.

Dentro se las secuencias se pueden agregar las palabras reservadas continue y break

continue: causa que el resto de una iteración sea saltada y se prosiga con la ejecución de la siguiente.
break: causa la salida del ciclo para comenzar con la siguiente parte del programa.

EJEMPLOS

Para darle mas alcance a esta entrada, y suponiendo que ya todos entendemos lo basico de C, les voy a mostrar como funcionan los punteros en C.

Un puntero, valga la redundancia, apunta a otro dato de su mismo tipo y su valor es la direccion de memoria de la otra variable. Hay que recalcar que una direccion de memoria no es igual al contenido de esa direccion de memoria

Para trabajar con punteros se utilizan 2 operadores especificos:

Operador de direccion "&": Representa la direccion de memoria.
Operador de contenido "*": Representa el valor asignado a la variable apuntada.

int x = 25;


La direccion de la variable x (&x) es 1502.
El contenido de la variable es 25.

En la actualidad las computadoras utilizan muchisima memoria para ejecutar diversos procesos, seria muy complicado tratar de indicarle al programa que dirección de memoria queremos visitar, es su lugar a cada dirección de memoria se le da una etiqueta, esta etiqueta la conocemos como variable; ya que lo que nos interesa es almacenar los datos que usaremos y no dónde se localizan.

Un puntero se declara como cualquier otra variable, pero su identificador va precedido por un asterisco (*):

int *puntero;

Incluso los punteros tienen sus propias direcciones de memoria: &puntero

Hay tantos tipos de punteros, como tipos de variables y estos pueden declararse dentro se estructuras complejas, funciones, ect.

...
char dato;
char *puntero;
puntero = &dato;
...

en la variable puntero guardamos la direccion de memoria de la variable dato. puntero apunta a dato, ambos del mismo tipo.

Para entenderlo mejor podemos teclear un pequeno codigo, abrimos la terminal y escribimos

emacs -nw puntero.c

despues tecleamos el siguiente codigo:

#include<stdio.h>
int main(int argc, char *argv[]) {

  int a = 20;
  int *b;

  printf("Direccion de a: %p\n", a);      // aqui muestra la direccion donde se guardo el valor de "a"
  printf("\nDireccion de b: %p\n", b);    // aqui muestra la direccion donde se guardo el valor del apuntador "b"
  printf("\nValor de a: %d\n", a);        // lo que se almaceno en "a"
  printf("\nValor de b: %d\n", b);        // lo que hay en "b" (basura)
  printf("\nDireccion de apuntador b: %p\n", *b);  // aqui esta la direccion donde se guardo el apuntador "b"
  printf("\nMemoria de a: %p\n", &a);     // se muestra la direccion donde se almaceno "a"
  b = &a;                                 //aqui se igualan direcciones
  printf("\nNueva memoria de b: %p\n", b);
  printf("\nNueva direccion de apuntador b: %p\n", *b);
  printf("\nValor de b: %d\n", b);
  return 0;
}

Para compilar tecleamos la secuencia: gcc -o puntero puntero.c.


Se generaran algunos warnings, pero el archivo sera completamente funcional.

Para ejecutar tecleamos: ./puntero



Hay pueden ver los espacios que la computadora reserva para almacenar "a" y el puntero "b", en las ultimas líneas pueden ver como las direcciones y los bloques de memoria del puntero "b" se igualan a los de "a", pero el puntero "b" sigue conteniendo basura.
Aqui le demuestro como es que un puntero no almacena el valor del bloque de memoria, solo su dirección.

Espero les haya sido útil la información, pueden consultarme cualquier duda.

SALUDOS!!! ^_^

LENGUAJES IMPERATIVOS - Generalidades BASIC

Laboratorio de Lenguajes de Programación - Semana 8

BASIC es el acrónimo de Beginners All-purpose Symbolic Instruction Code ("Código de instrucciones simbólicas de propósito general para principiantes")

"Forma parte de la familia de lenguajes de alto nivel. Originalmente fue desarrollado como una herramienta de enseñanza; se diseminó entre las microcomputadoras hogareñas a partir de la década de 1980. Actualmente continúa siendo muy popular, en muchos dialectos bastante distintos del original.
FUENTE: http://es.wikipedia.org/wiki/BASIC

Se dice que es un lenguaje hecho para niños, que ya esta en desuso, pero la verdad es de los pocos lenguajes "old school" que siguen vigentes para su uso.

BASIC fue diseñado para permitir a los estudiantes escribir programas usando terminales de un computador en tiempo compartido. Estaba pensado para reducir notablemente la complejidad de los otros lenguajes del momento, diseñado específicamente para un usuario más sencillo fuera del área de las ciencias de la computación y a quien no le interesaba tanto la velocidad, sólo el hecho de ser capaz de programar y usar la máquina sin demasiadas complicaciones. Los diseñadores del lenguaje también querían que permaneciera en el dominio público, lo cual contribuyó a que se diseminara rápidamente.

Los ocho principios que rigeron el diseño de BASIC fueron:

1. Ser fácil de usar para los principiantes.
2. Ser un lenguaje de propósito general (no orientado).
3. Permitir a los expertos añadir características avanzadas, conservando simple el lenguaje para los principiantes.
4. Ser interactivo.
5. Proveer mensajes de error claros y amigables.
6. Responder rápido en los programas pequeños.
7. No requerir un conocimiento del hardware de la computadora.
8. Proteger al usuario del sistema operativo.

INSTRUCCIONES INICIALES

Una vez mas estamos hablando de un lenguaje de programacion que requiere un compilador para generar sus archivos ejecutables.
Lo primero que vamos a hacer es entrar a esta pagina web:

FreeBasic Compiler

La descarga comenzara automaticamente. Cuando termine la descarga procedemos a descomprimir el contenido, se generara una carpeta llamada FreeBASIC-0.21.1-linux-standalone.

Despues abrimos nuestra terminal, y desde ahi nos dirigimos al lugar donde guardamos la carpeta, una vez detro de la carpeta (utilizando la terminal), ejecutaremos la siguiente secuencia:

sudo ./install-standalone.sh -i

Una vez que termine todo el proceso (no se nos preguntara nada), teclearemos en la terminal: fbc para llamar al compilador, si todo corrio bien veremos una ventana como esta:


Donde se listaran todos los atributos que se pueden agregar al compilar un codigo basic.
La extension de los archivos es *.bas

VARIABLES Y DATOS

Al igual que todos los lenguajes de programacion, BASIC se basa en la declaración de variables para la asignación de memoria.'
Las variables pueden ser numericas o cadena de caractéres.
La sintaxis de la declaración es:

DIM nombre_var AS tipo_var

Por ejemplo:

DIM numero AS INTEGER: crea la variable numero, de tipo número entero
DIM frase AS STRING: crea la variable frase, de tipo cadena
DIM a AS SINGLE: crea una variable a de tipo punto flotante
DIM b AS DOUBLE: crea una variable a de tipo punto flotante de precision doble

Estas declaraciones son equivalentes:

DIM numero%: crea la variable numero, de tipo número entero
DIM frase$: crea la variable frase, de tipo cadena
DIM a!, b#: crea dos variables a y b, de tipo número de precisión simple y doble, respectivamente.

$ - String - 8bits
% - Integer - 16bits
& - Long - 32bits
! - Single - 32bits
# - Double - 64bits

La palabra LET se usa para asignar un valor a una variable, actualmente esta en desuso para que el codigo se vea mas limpio, su sintaxis es:

LET nombre_var[type] = valor

Por ejemplo:

OLD SCHOOL: LET numero% = 523
NEW: numero% = 653

Si se intenta poner un valor decimal en una variable entera el valor se redondea. Se pueden poner valores enteros en variables Single y Double.

Cuando se quiere que la variable sea global, el nombre va precedido por la palabra SHARED

Por ejemplo:

DIM SHARED numero AS INTEGER
DIM SHARED cadena$

BASIC no es sensible mayósculas y minósculas, por lo que utilizar una variable hola
es igual a otra llamada Hola y tambien a otra llamada HoLa

Los compiladores tienen sus palabras reservadas las cuales no pueden ser utilizadas como nombres de variables y/o funciones, tales como DIM, END, PRINT, INTEGER, etc.

ESTRUCTURA DEL CODIGO

La programacion en BASIC se puede estructurar en funciones y subprogramas que ayudan a mejorar la legibilidad del mismo, por lo general siguen la siguiente estructura:

' Programa principal

 declaración de funciones y subprogramas
 declaración de variables
 sentencias

END

SUB Subprograma1 ( )

 declaración de variables
 sentencias

END SUB

FUNCTION Funcion1 ( )

 declaración de variables
 sentencias

END FUNCTION

...
...
...

SUB Subprograman( )

 declaración de variables
 sentencias
END SUB

FUNCTION Funcionn ( )

 declaración de variables
 sentencias

END FUNCTION

ENTRADA Y SALDA

Cuando se quiere imprimir algo en pantalla se utiliza la palabra PRINT, por ejemplo:

PRINT "HOLA"
PRINT "El valor de a es"; a%

Para leer un dato desde el teclado se utiliza la palabra INPUT, por ejemplo:

PRINT "Dame un numero: "
INPUT numero%

PRINT "Introduce tres valores: "
INPUT x%, y%, z%

Algo mas sencillo:

INPUT "Dame un numero: ", num%

Cadenas de texto:

DIM cadena AS STRING
INPUT 'Escribe unas palabras: ', cadena

EJEMPLO

Llego el momento de poner en práctica lo que hemos aprendido, vamos a teclear un pequeño código en BASIC.
Escribiremos un programa que nos convierta de grados centigrados a grados fahrenheit.
Abrimos nuestra terminal y tecleamos lo siguiente:

emacs -nw convierte.bas

Y escribimos el siguiente codigo en el editor EMACS (emacs no incluye Basic Mode):

'' Convierte Centigrados a Fahrenheit
  DIM cent AS SINGLE
  DIM fahr AS SINGLE

  PRINT "Dame los grados Centigrados: "
  INPUT cent
 
  fahr = cent * (9 / 5) + 32

  PRINT " ";cent;"C son";fahr;" F"

END

Una vez que terminemos, lo guardamos y lo compilamos con la siguiente orden:

fbc convierte.bas

Se generará un ejecutable sin extensión llamado convierte, para ejecutarlo escribimos: ./convierte



En la barra de "RECURSOS" les dejo un tutorial que me sirvio mucho para comprender este lenguaje: Tutorial BASIC"

Espero les haya gustado la entrada, dudas o sugerencias ya saben, comenten.

SALUDOS!!! ^_^

LENGUAJES IMPERATIVOS - Generalidades PASCAL

Laboratorio de Lenguajes de Programación - Semana 8

Pascal es un lenguaje de programación desarrollado por el profesor suizo Niklaus Wirth entre los años 1968/9 y publicado en 1970. Su objetivo era crear un lenguaje que facilitara el aprendizaje de programación a sus alumnos, utilizando la programación estructurada y estructuración de datos. Sin embargo con el tiempo su utilización excedió el ámbito académico para convertirse en una herramienta para la creación de aplicaciones de todo tipo.

Pascal se caracteriza por ser un lenguaje de programación estructurado fuertemente tipificado. Esto implica que:

1. El código está dividido en porciones fácilmente legibles llamadas funciones o procedimientos. De esta forma Pascal facilita la utilización de la programación estructurada en oposición al antiguo estilo de programación monolítica.
2. El tipo de dato de todas las variables debe ser declarado previamente para que su uso quede habilitado.

El nombre de Pascal fue escogido en honor al matemático Blaise Pascal.

A diferencia de lenguajes de programación descendientes de C, Pascal utiliza el símbolo ":=" para la asignación en vez de "=". Si bien el segundo es más conocido, la práctica ha demostrado que muchos usuarios utilizan el símbolo de igualdad para comparar valores en lugar del comparador de C que es el símbolo ==. Esta sintaxis conduce a muchos errores o bugs difíciles de rastrear en código C. Dado que Pascal no permite asignaciones dentro de expresiones y utiliza sintaxis distintas para asignaciones y comparaciones, no sufre estos errores.

FUENTE: http://es.wikipedia.org/wiki/Pascal_%28lenguaje_de_programaci%C3%B3n%29

COMPILADOR

Pascal necesita un compilador para generar ejecutables útiles, asi que lo primero que vamos a hacer es instalarlo.
Primero abrimos nuestra terminal, para escribir la siguiente orden:

sudo apt-get install fp-compiler


Nos aparecera en la terminal un mensaje de confirmación, aceptamos y dejamos que prosiga la instalación.

Una vez terminados todos los procesos podemos teclear fpc para llamar al compilador, nos saldrán varias pantallas con información del compilador (dando varias veces ENTER salimos).
La extension de los archivos fuente escritos en Pascal es *.pas


VARIABLES Y DATOS

La asignación de unidades de memoria para el ejecución del programa se realiza con la declaración de variables, las cuales pueden ser lógicas, numericas, cadenas de caractéres.


la declaración de variables se hace con esta sintaxis:

var
   nom_var: type;

para inicializarlas se hace en el siguiente bloque con la sintaxis:

begin
   nom_var := value;

por ejemplo:

var
   i: Integer;
   s: String;
   b: Boolean;
 
begin
   i := -3;
   s := 'Hello';
   b := True;

Podemos realizar varias operaciones aritméticas con las variables declaradas:



por ejemplo en el siguiente programita:

program Ejemplo;
 
var
   X, Y, S, R, M, D: Integer;
 
begin
   X := 5;
   Y := 10
   S := X + Y;
   R := Y - X;
   M := X * Y;
   D := Y / X;
end.

(se que falta imprimir resultados, es solo ejemplo)

Las constantes de declaran con la siguiente sintaxis, dentro de su propio bloque de datos:

const
   nom_const: Type = value;

Por ejemplo:

const
   pi: Real = 3.14;

ENTRADA Y SALIDA DE DATOS

Para leer datos desde el teclado se utilizan las funciones Readln y ReadKey, ReadKey lee un solo caractér, mientras que Readln lee numeros y cadenas de caractéres, ambos funcionan de distinta forma:

program Ejemplo2;
 
uses crt;
 
var
   i: Integer;
   s: String;
   c: Char;
 
begin
   Readln(i);
   Readln(s);
   c := ReadKey;
end.

Para imprimir mensajes en pantalla o los resultados de una operación se utilizan la funciones Writeln() y Write() , lo que se imprime va dentro del paréntesis, y cada dato se separa por comas, por ejemplo:

program Ejemplo3;
 
var
   i: Integer;
   s: String;
begin
   i := 24;
   s := 'Hello';
   Writeln(i);
   Writeln(s,' world');
end. 

SECUENCIAS DE CONTROL



CICLO IF... ELSE

program Si o no;
 
var
   i: Integer;
 
begin
   Writeln('Dame un valor');
   Readln(i);
   if i > 5 then
      Writeln('Mayor que 5')
   else
      Writeln('Menor que 5');
end. 

DECISIONES "CASE"

program Decisiones;
 
uses
   crt;
 
var
   Choice: Char;
 
begin
   Writeln('Elige la que mas te gusta');
   Writeln('a - Manzana:');
   Writeln('b - Platano:');
   Writeln('c - Zanahoria:');
   Choice := ReadKey;
   case Choice of
      'a': Writeln('Te gustan las manzanas');
      'b': Writeln('Te gustan los platanos');
      'c': Writeln('Te gustan las zanahorias');
   else
      Writeln('No te gusta nada de aqui');
   end;
end. 

CICLO FOR

program ciclo;
 
var
   i: Integer;
 
begin
   for i := 1 to 10 do
      Writeln('Hola, otra vez!!!');
end. 

CICLO WHILE

program Ciclos2;
 
var
   i: Integer;
 
begin
   i := 0;
   while i <= 10
      begin
         i := i + 1;
         Writeln('Hola, una vez mas.');
      end;
end. 

CICLO WHILE... UNTIL...

program Ciclos3;
 
var
   i: Integer;
   s: String;
 
begin
   i := 0;
   repeat
      i := i + 1;
      Write('Dame un valor: ');
      Readln(s);
   until (i = 10) or (s = 0);
end. 

EJEMPLO

Para terminar, teclearemos un ejemplo donde les mostrare la sintaxis de Pascal y practicaremos lo aprendido.
Un programa que me calcule el área de diversas figuras geometricas.
Abirmos la terminal y tecleamos:

emacs -nw areas.pas

Acto seguido, tecleamos el siguiente codigo:

program areas;

uses
   crt;

const
   pi: Real = 3.14159;
 
var
   Choice     : Char;
   X, Y, Area : Real;
   
begin
   Area := 0;
   Writeln('Calcular el area de: ');
   Writeln('a - Cuadrado');
   Writeln('b - Circulo');
   Writeln('c - Triangulo');
   Choice := ReadKey;
   case Choice of
     'a' : begin
         Writeln('Dame la longitud del lado');
         Readln(X);
         Area := X*X;
         Writeln('El area del cuadrado es: ', Area);
     end;   
     'b' : begin
         Writeln('Dame la longitud del radio');
         Readln(X);
         Area := pi*X*X;
         Writeln('El area del circulo es: ', Area);
     end;
     'c' : begin
         Writeln('Dame la longitud de la base');
         Readln(X);
         Writeln('Dame la altura: ');
         Readln(Y);
         Area := (X * Y) / 2;
         Writeln('El area del triangulo es: ', Area);
     end;
   end; { case }
end.

Despues que lo escribimos, lo guardamos y lo compilamos con la orden:

fpc areas.pas

Se generarán 2 archivos, un archivo objeto *.o y un ejecutable sin extensión "areas", para correrlo tecleamos: ./areas


Espero les haya gustado la entrada, en la seccion Recursos les deje el tutorial correspondiente a este lenguaje, donde ademas podran aprender como declarar arreglos, estructuras, punteros, etc.

SALUDOS!!! ^_^