domingo, 21 de noviembre de 2010

LENGUAJES ORIENTADOS A OBJETOS - Reporte 8

Lenguajes de Programación - Semana 14 - Reporte 8

C++


Este programa que hice en C++ genera un buen amigo que se preocupa por ti :), llamado "Fulanito", fulanito es un objeto, los objetos de su clase tienen lo que yo llame "memoria", la memoria se divide en tres atributos, un string que almacena tu nombre y 2 enteros que almacenan las 2 respuestas que des a las 2 preguntas que te hará nuestro amigo. A su vez se implementan 3 métodos, uno de presentación y los otros 2 son cuando fulanito te formula las 2 preguntas.
#include <iostream>
#include <string>
using namespace std;

class Amigo {
  string nombre;
  int pre1, pre2;
public:
  void presentacion();
  int pregunta1();
  void pregunta2();
};

void Amigo::presentacion() {
  cout << "\nHola, me llamo Fulanito :), Como te llamas?" << endl;
  getline(cin, nombre);
  cout << "\nHola " << nombre << ", mucho gusto!!" << endl;
  return;
}

int Amigo::pregunta1() {
  cout << "\nY como has estado" << endl;
  cout << "\n\t1. Bien :)\t\t2. Mal :(" << endl;
  cin >> pre1;
  if (pre1 == 1) {
    cout << "\nQue bueno, yo tambien estoy muy bien :)" << endl;
    return pre1;
  } else
    return pre1;
}

void Amigo::pregunta2 () {
  cout << ":( cuentame porque estas mal... " << endl;
  cout << "\n1. Estoy triste\t\t2. Estoy enfermo" << endl;
  cin >> pre2;
  if (pre2 == 1)
    cout << "No estes triste, hoy es un lindo dia, vamos a pasear :)" << endl;
  else if (pre2 == 2) 
    cout << "Bueno, deberias ir a ver al medico y descansar todo el dia :)" << endl;
  else
    return;
}

int main(int argc, char** args) {
  Amigo fulanito;
  int x;
  fulanito.presentacion();
  x = fulanito.pregunta1();
  if (x == 2) {
    fulanito.pregunta2();
  }
  return 0;
}

DESCARGA: amigo.cpp
Para compilar: g++ -o amigo amigo.cpp
Para ejecutar: ./amigo

EJECUCIÓN


Python


Para mi programa en Python decidí practicar la herencia múltiple, una caracteristica de la Programacion Orientada a Objetos de este lenguaje.
Declare muchas clases, cada una parecida pero diferente a las demás, y despues declare otras mas cuyo fin es heredar los atributos de las anteriores para asi generar un solo mensaje concatenado.
#!/usr/bin/python

class Mamifero:
    def tipo (self):
        print "Es mamifero, tiene pelo y es viviparo."

class Reptil:
    def tipo (self):
        print "Es reptil, tiene sangre fria y es oviparo."

class Ave:
    def tipo (self):
        print "Es un ave, tiene plumas y alas por lo que puede volar."

class Insecto:
    def tipo (self):
        print "En un insecto, come hojas, tiene antenas, tres pares de patas y exoesqueleto."

class Pez:
    def tipo(self):
        print "Es un pez, tiene escamas, es oviparo y respira por sus branquias."

class Acuatico:
    def desplazar (self):
        print "Como vive en el agua este animal nada y no se como duermen :p."

class Terrestre:
    def desplazar (self):
        print "Como vive en la tierra este animal camina sobre sus patas."

class Perro(Mamifero, Terrestre):
    def caracteristicas(self):
        print "\nEl perro come todo lo que le den y tiene 4 patas."

class Cocodrilo(Reptil, Terrestre):
    def caracteristicas(self):
        print "\nEl cocodrilo se come a otros animales y tiene 4 patas"

class Aguila(Ave):
    def caracteristicas(self):
        print "\nLas aguilas son carnivoras, cazan a sus presas."

class Hormiga(Insecto, Terrestre):
    def caracteristicas(self):
        print "\nLas hormigas cavan sus hogares bajo la tierra."

class Salmon(Pez, Acuatico):
    def caracteristicas(self):
        print "\nEl salmon es un pez espectacular, come otros peces mas pequenos que el y crustaceos, hacen el viaje mas impresionante del reino animal al regresar al lugar donde nacieron."

def main():
    print "\n1. Perro\t\t2. Cocodrilo"
    print "3. Aguila\t\t4. Hormiga"
    print "5. Salmon"
    x = input("Elige uno ->")
    if x == 1:
        obj = Perro()
        obj.caracteristicas()
        obj.desplazar()
        obj.tipo()
    elif x == 2:
        obj = Cocodrilo()
        obj.caracteristicas()
        obj.desplazar()
        obj.tipo()
    elif x == 3:
        obj = Aguila()
        obj.caracteristicas()
        obj.tipo()
    elif x == 4:
        obj = Hormiga()
        obj.caracteristicas()
        obj.desplazar()
        obj.tipo()
    elif x == 5:
        obj = Salmon()
        obj.caracteristicas()
        obj.desplazar()
        obj.tipo()
    else:
        print "\nOpcion no valida"

if __name__ == "__main__" :
    main()

DESCARGA: animales.py
Para modificar permisos: chmod u+x animales.py
Para interpretar: ./animales.py

EJECUCIÓN


Java


Por último en Java, decidí implementar una calculadora super sencilla, con varios errores porque no he implementado las condiciones para los números negativos, pero funciona con números positivos. Toda la visualizacion es dentro de una ventana generada con las librerias de Java:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Calculadora extends JFrame {

    JTextField pantalla;
    double resultado;
    String operacion;
    JPanel numeros, operaciones;
    boolean nuevaOperacion = true;

    public Calculadora() {
        super();
        setSize(200, 250);
        setTitle("Calculadora");
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setResizable(false);

        JPanel panel = (JPanel) this.getContentPane();
        panel.setLayout(new BorderLayout());

        pantalla = new JTextField("0", 20);
        pantalla.setHorizontalAlignment(JTextField.RIGHT);
        pantalla.setEditable(false);
        pantalla.setBackground(Color.WHITE);
        panel.add("North", pantalla);

        numeros = new JPanel();
        numeros.setLayout(new GridLayout(4, 3));

        for (int n = 9; n >= 0; n--) {
            BotonNumero("" + n);
        }
        BotonNumero(".");

        panel.add("Center", numeros);

        operaciones = new JPanel();
        operaciones.setLayout(new GridLayout(6, 1));

        BotonOperacion("C");
        BotonOperacion("+");
        BotonOperacion("-");
        BotonOperacion("X");
        BotonOperacion("/");
        BotonOperacion("=");

        panel.add("East", operaciones);
    }

    private void BotonNumero(String digito) {
 JButton b = new JButton();
 b.setText(digito);
 b.addMouseListener(new MouseAdapter() {
  
  @Override
      public void mouseReleased(MouseEvent e) {
      JButton b = (JButton) e.getSource();
      numpresionado(b.getText());
  }
     });
 numeros.add(b); 
    }

    private void BotonOperacion(String operacion) {
        JButton b = new JButton(operacion);
        b.setForeground(Color.BLACK);
        b.addMouseListener(new MouseAdapter() {
      
  @Override
      public void mouseReleased(MouseEvent e) {
      JButton b = (JButton) e.getSource();
      operpresionado(b.getText());
  }
     }); 
        operaciones.add(b);
    }

    private void numpresionado(String digito) {
        if (pantalla.getText().equals("0") || nuevaOperacion) {
            pantalla.setText(digito);
        } else {
            pantalla.setText(pantalla.getText() + digito);
        }
        nuevaOperacion = false;
    }

    private void operpresionado(String tecla) {
        if (tecla.equals("=")) {
            calcular();
        } else if(tecla.equals("C")) {
            resultado = 0;
            pantalla.setText("");
            nuevaOperacion = true;
        } else {
            operacion = tecla;
            if((resultado > 0) && !nuevaOperacion) {
                calcular();
            } else {
                resultado = new Double(pantalla.getText());
            }
        }
        nuevaOperacion = true;
    }

    private void calcular() {
        if (operacion.equals("+")) {
            resultado += new Double(pantalla.getText());
        } else if (operacion.equals("-")) {
            resultado -= new Double(pantalla.getText());
        } else if (operacion.equals("/")) {
            resultado /= new Double(pantalla.getText());
        } else if (operacion.equals("X")) {
            resultado *= new Double(pantalla.getText());
        }
        pantalla.setText("" + resultado);
        operacion = "";
    }

    public static void main(String[] args) {
        Calculadora c = new Calculadora();
        c.setVisible(true);
    }
}

DESCARGA: Calculadora.java
Para compilar: javac Calculadora.java
Para ejecutar: java Calculadora

EJECUCIÓN

lunes, 15 de noviembre de 2010

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!!! ^_^

domingo, 14 de noviembre de 2010

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)

sábado, 13 de noviembre de 2010

TIPOS DE DATOS - Presentacion 4

Lenguajes de Programacón - Semana 13

Espero les guste mi presentacion:




DESCARGA DEL CODIGO FUENTE: agenda.c


ANTES DE . . .

Antes de ejecutar el código, asegurense de crear una carpeta llamada agenda en donde descarguen el archivo, si no lo hacen el programa lanzara error porque lo primero que realiza es buscar dicha carpeta para generar el archivo de texto donde se guardarán los registros.

Comentarios, dudas, sugerencias son bienvenidas!!! ^_^ Participen para ganar puntos :p

C - Listas Enlazadas

Lenguajes de Programacón - Semana 12 - PUNTOS EXTRA

Esta aplicacion que escribí el semestre pasado nos permite realizar de una forma simple una lista enlazada. Primero se crea un nodo inicial el cual despues de llena con la información que nos es pedida, despues se nos pregunta si queremos seguir agregando nodos, esto se hace repetiviamente hasta que decidimos no agregar mas datos a la lista, al llegar a este punto la lista se imprime mostrandonos todos los datos incluidos.
// Programa que arma una lista doblemente enlazada

# include 

typedef struct nodoN{
  int info;
  int cabecera;
  struct nodoN *prev;
  struct nodoN *next;
} NODO;

int main(void){
  char pregunta;
  int i = 1;
  NODO *list, *p, *q;
  list=(NODO*)malloc(sizeof(NODO));
  list->info = 0;
  list->cabecera = 1;
  list->prev = NULL;
  q = list;
  p = (NODO*)malloc(sizeof(NODO));
  list->next=p;
  do{
      ++list->info;
      printf("Dame un dato para la lista -> ");
      scanf("%d", &p->info);
      p->cabecera = 0;
      p->prev = q;
      p->next = NULL;
      printf("Deseas seguir (s/n)");
      scanf("%s", &pregunta);
      if(pregunta == 's' || pregunta == 'S'){
          q = p;
          p = (NODO*)malloc(sizeof(NODO));
          q->next = p;
      }
  } while(pregunta != 'n' && pregunta != 'N');
  q = list;
  printf("los nodos de la lista son %d\n", q->info);
  do{
      if(q == list){
          q = list->next;
      } else {
          q = q->next;
      }
      printf("%d.-\t %d\n", i, q->info);
      i++;
  } while(q->next != NULL);
  return 0;
}

DESCARGA: lista.c

Para compilar: gcc -o lista lista.c
Para ejecutar: ./lista


EJECUCION:



La lista utiliza punteros y su tamaño es definido por la funcion malloc. Es un ejemplo basico de una lista, de este esqueleto podemos hacer otras mas extensas y con mas funcionalidad

SALUDOS!!! ^_^

C - Pilas y Colas

Lenguajes de Programación - Semana 12 - PUNTOS EXTRA

Esta vez tambien traigo unos programitas que concluí en estos dias, se tratan se unas aplicaciones que simulan las estructuras de datos: pilas y colas.

PILA

Esta aplicación permite mediante un menú ejecutar diferentes tareas a la pila, claro que para ello primero hay que rellenarla con algunos datos, podemos imprimir los elementos, sacar elementos, meter elementos. Además es posible realizar operaciones con los 2 elementos de hasta arriba de la pila.
Se realiza con arreglos y realmente no es nada complicado de entender:
#include 
#define FALSE -1
#define TRUE 1

void cabecera(void) {
  int i;
  printf("|");
  for(i = 0; i < 50; i++) printf("-");
  printf("|\n|");  
  printf("\t\tEJEMPLO DE PILA\t\t\t   |\n");
  printf("|");
  for(i = 0; i < 50; i++) printf("-");
  printf("|\n");
  return;
} 

int empty(int top) {
  if(top > -1)
    return FALSE;
  return TRUE;
}

int menu(void) {
  int op; 
  printf("\n\t1. Push data\n");
  printf("\t2. Pop data\n");
  printf("\t3. Stacktop\n");
  printf("\t4. Empty\n");
  printf("\t5. Print\n");
  printf("\t6. Operador\n");
  printf("\t7. Exit\n\n");
  printf("    Selecciona una opcion ->  ");
  scanf("%d", &op); 
  return (op); 
} 

int main(void) {
  int opcion = 0, temp, i, temp2[2];
  int pila [15], tope = -1;
  char operador;
  cabecera();
  while (opcion < 7) {  
    switch(opcion = menu()) {            
    case 1: {
      printf("\n\tIntroduce un dato ->  ");
      scanf("%d", &temp);
      tope++;
      pila[tope] = temp;
      break; 
    } 
      
    case 2: {
      printf("\n");
      if(empty(tope) == FALSE) {
         printf("\t\tElemento retirado -> [%d]\n\n", pila[tope]);
         tope = tope -1; 
      } else 
         printf("\t\tPILA VACIA\n\n");
      break;
    }
      
    case 3: {
      printf("\n");
      for(i = tope; i == tope; i++)
          printf("\tElemento en el tope -> [%d]\n\n", pila[i]); 
      break;
    }
      
    case 4: {
      if(empty(tope) == TRUE)
         printf("\n\tLA PILA ESTA VACIA\n\n"); 
      else
         printf("\n\tLA PILA NO ESTA VACIA\n\n");
      break;
    }
      
    case 5: {
      printf("\n\tELEMENTOS EN PILA\n\n");
      for(i = tope; i >= 0; i--)
         printf("\t\t[%d]\n",pila[i]);
      printf("\n");
      break;     
    }
      
    case 6: {
      while (getchar() != '\n') continue;
      printf("Que operacion quieres realizar?\n\n");
      printf("\tSUMA -> +\n\tRESTA -> -\n\tMULTIPLICACION -> *\n\tDIVISION -> /\n");
      scanf("%c", &operador);
      
      switch(operador) {
      case '*': { 
          if(empty(tope) == FALSE) { 
             temp2[0]=pila[tope];
             tope = tope -1;
             if(empty(tope) == FALSE) {
                temp2[1]=pila[tope];
                tope = tope; 
                pila[tope] = temp2[0] * temp2[1];
                break;
             }
          }
      }
 
      case '/': {
         if(empty(tope) == FALSE) {
            temp2[0]=pila[tope];
            tope = tope -1;
            if(empty(tope) == FALSE) {
               temp2[1]=pila[tope];
               tope = tope; 
               pila[tope] = temp2[0] / temp2[1];
               break;
            }
         }
      }
 
      case '+': {
         if(empty(tope) == FALSE) {
            temp2[0]=pila[tope];
            tope = tope -1;
            if(empty(tope) == FALSE) {
               temp2[1]=pila[tope];
               tope = tope; 
               pila[tope] = temp2[0] + temp2[1];
               break;
            }
         }
      }
 
      case '-': {
         if(empty(tope) == FALSE) {
            temp2[0]=pila[tope];
            tope = tope -1;
            if(empty(tope) == FALSE) {
               temp2[1]=pila[tope];
               tope = tope; 
               pila[tope] = temp2[0] - temp2[1];
               break;
            }
         }
      }
      } 
    }         
    }
  }    
  return 0;  
}


DESCARGA: pila.c

Para compilar: gcc -o pila pila.c
Para ejecutar: ./pila


EJECUCIÓN



COLA DE DATOS

En escencia se trata casi del mismo código anterior pero no es igual, ya que ahora se emula lo que sería una cola de datos, de igual forma se incluye un menú con las operaciones que se pueden realizar en una cola de datos, en este ejemplo no podemos realizar operaciones aritmeticas.
#include 
#define FALSE -1
#define TRUE 1

void cabecera(void) {
  int i; 
  printf("|");
  for(i = 0; i < 50; i++) printf("-");
  printf("|\n|");  
  printf("\t\tEJEMPLO DE COLA DE DATOS\t   |\n");
  printf("|");
  for(i = 0; i < 50; i++) printf("-");  
  printf("|\n"); 
  return;
} 

int empty(int frente, int fondo) {
  if(frente > fondo)
    return FALSE;   
  return TRUE;
}

int menu(void) {
  int op; 
  printf("\n\t1. Insertar elemento\n");
  printf("\t2. Retirar elemento\n");
  printf("\t3. Elemento de incio\n");
  printf("\t4. Verificar cola de datos\n");
  printf("\t5. Imprimir cola de datos\n");
  printf("\t6. Operador\n");
  printf("\t7. Salir\n\n");
  printf("    Selecciona una opcion ->  ");
  scanf("%d", &op); 
  return (op);
} 

int main(void) {    
  int opcion = 0, temp, i, temp2[2];
  int cola [15], frente = 0, fondo = -1;
  char operador;
  cabecera();
  while(opcion < 6) { 
    switch(opcion = menu()) {   
    case 1: {
      printf("\n\tDame el dato a ingresar ->  ");
      scanf("%d", &temp);
      fondo++;
      cola[fondo] = temp;
      break;
    } 
      
    case 2: {
      printf("\n");
      if(empty(frente, fondo) == FALSE) {
        printf("\t\tElemento retirado -> [%d]\n\n", cola[frente]);
        frente = frente +1;                
      } else
          printf("\t\tCOLA DE DATOS VACIA\n\n");
      break;
    }
 
    case 3: {
      if(empty(frente, fondo) == FALSE)
         printf("Elemento al frente es %d\n", cola[frente]); 
      else
         printf("LA COLA DE DATOS ESTA VACIA\n");
      break;
    }
                
    case 4: {
      if(empty(frente, fondo)==TRUE)
          printf("\n\tLA COLA DE DATOS ESTA VACIA\n\n");
      else
          printf("\n\tLA COLA DE DATOS NO ESTA VACIA\n\n");
      break;
    }
      
    case 5: {
      printf("\n\tELEMENTOS EN COLA\n\n");
      printf("INICIO");
      for(i=frente;i<=fondo;i++)
            printf(" <- [%d]",cola[i]);
      printf(" <- FIN\n\n");
      break;            
    }           
    }
  }    
  return 0;
}

DESCARGA: cola.c

Para compliar: gcc -o cola cola.c
Para ejecutar: ./cola


EJECUCIÓN



Espero y les sirvan para comprender estos dos conceptos con los que batallamos tanto el semestre pasado

SALUDOS!!! ^_^

C - Calculadora de Fracciones

Lenguajes de Programación - PUNTOS EXTRA

Termine de escribir este código que lo había dejado pendiente desde el semestre pasado, se trata de una calculadora que suma fracciones por medio una estructura, o mas bien, un nuevo tipo de dato definido por mi que toma la forma de una fracción y realiza las operaciones de la aritmética básica.

Esta es la definición de mi nuevo tipo de dato:
typedef struct fraccion {
     int num;
     int den;
} frac;

Un tipo de dato "fraccion" al cual me referire durante el programa como "frac", mi tipo de dato solo esta compuesto por el numerador y el denominador, ambos son enteros.

Este es el constructor del dato:
frac construye(int a, int b) {
  frac temp;
  temp.num = a;
  if(b==0){
      printf("El denominador no puede ser cero");
      temp.den = 1;
      return(temp);      
  }
  temp.den = b;
  return(temp);
}

Toma los parámetros enviados desde main, el numerador y denominador, y los fusiona en un solo tipo de dato; si el denominador el 0, la función regresa una fracción entera ademas de una advertencia. El constructor se visita 2 veces, porque las operaciones se realizan por parejas de datos.

Estas son los algoritmos para realizar las operaciones:
// Para sumar

frac add(frac a, frac b) {
 frac temp;
 temp.den = a.den * b.den;
 temp.num = (a.num * b.den) + (a.den * b.num);
 return(temp);
}

//Funcion para multiplicar

frac mult(frac a, frac b) {
 frac temp;
 temp.num = a.num * b.num;
 temp.den = a.den * b.den;
 return(temp);
}

//Funcion para div

frac div(frac a, frac b) {
 frac temp;
 temp.num = a.num * b.den;
 temp.den = a.den * b.num;
 return(temp);
}

// Para restar
frac res(frac a, frac b) {
 frac temp;
 b.num = b.num * -1;
 temp = add(a, b);
 return(temp);
}

Por si no se acuerdan: la suma es la adición de la multiplicación cruzada de los numeradores y denominadores, los denominadores se multiplican directo; la resta es igual solo cambiamos el signo de un numerador. La multiplicación es directa numerador x numerador, denominador x denominador; mientras que para la división se realiza una multiplicación cruzada.

Para imprimir los datos utilizo esta rutina:
void imprime (frac a, char op, frac b, frac c) {
 printf("\n");
 toprint(a);
 printf(" %c ", op);
 toprint(b);
 printf(" = ");
 toprint(c);
 printf("\n");
 return;  
}

Esta rutina imprime las fracciones construidas con su resultado.

La funcion main pide los datos de una forma especial, no hace falta hacer elecciones ni nada, el formato de entrada de datos es el siguiente: num/den + num/den, mas grafico: 1/2+1/4
La funcion reconoce los datos y los envía al constructor y reconoce el operador aritmético para realizar determinada accion:
int main(int argc, char** args) {
 char f, op;
 int an, bn;
 frac A, B, C;
 f = 's';
 printf("\t\tPROGRAMA PARA REALIZAR CALCULOS CON FRACCIONES\n\n");
 do{
   printf("Dame los datos\n");
   scanf("%d/%d", &an, &bn);
   A = construye(an, bn);
   scanf("%c", &op);
   scanf("%d/%d", &an, &bn);
   B = construye(an, bn);
   if(op == '+')
C = add(A, B);   
   if(op == '*')
C = mult(A, B);
   if(op == '/')
C = div(A, B);
   if(op == '-')
C = res(A, B);
   imprime(A, op, B, C);
   scanf("%c", &f);
 } while(f!='f');
 return 0;
}


PROGRAMA COMPLETO: fracciones.c

Para compilar: gcc -o fracciones fracciones.c
Para ejecutar: ./fracciones

EJECUCIÓN



PD: Para salir del programa escriben "f"

SALUDOS!!! ^_^

lunes, 8 de noviembre de 2010

C - Ejemplos sencillos

Lenguajes de Programación - Semana 12- PUNTOS EXTRA

Estas con algunas aplicaciones pequeñas escritas en C para pasar el rato :) que me gustaria compartirles

FRASE AL REVES

Toma una frase escrita desde el teclado, la almacena en un arreglo y despues utilizando la funcion strlen de la libreria string.h y con la ayuda de un ciclo for giramos la frase al reves.
//Leer una frase y escribirla al reves

#include 
#include 

int main(void) {
  char frase[100];
  int n;
 
  printf("Introduce una frase y la escribire al reves [255 letras]\n");
  printf("Cuando termines pulsa ENTER\n\n");
  scanf("%[^\n]", frase);
  printf("\n");
  
  for (n=strlen(frase)-1; n>=0; n--)
    printf("%c", frase[n]);
 
  printf("\n\n");
  return 0;    
}

DESCARGA: frase.c

Para compilar: gcc -o frase frase.c
Para ejecutar: ./frase

EJECUCION


MULTIPLICACION

Este programa genera multiplicaciones aleatorias con la ayuda de la funcion rand y la libreria time.h que nos ayuda a variar los datos generados.
#include 
#include 

DESCARGA: multaleatoria.c

Para compilar: gcc -o multaleatoria multaleatoria.c
Para ejecutar: ./multaleatoria

EJECUCION



RAIZ "X" DE UN NUMERO

Este programa resuelve la raiz "n" del numero que demos, por un metodo llamado de aproximacion.
// Programa para calcular una Raiz Cuadrada "x" de un numero "n"

#include 

double absoluto(double x){
  if(x < 0) 
    return(-1.0 * x);
  return(x);
}

double potencia(double x, int n) {
  int i;
  double resultado = 1.0;
  for(i = 0; i < n; i++)
    resultado = resultado * x;     
  return(resultado);
}

double raizn(double R, int n) {
  double x = 1.0, y = 2.0;
  while(absoluto(x - y) > .00001) {
    y = x;
    x = (1.0 / n) * (((n - 1) * x) + (R / potencia(x, (n - 1))));
  }
  return(x);
}

int main(void) {
  
  double raiz, valor, resultado;
  
  printf("\t\t\tPROGRAMA PARA CALCULAR UNA RAIZ\n\n");
  printf("Dame el numero para saber su raiz cuadrada -> ");
  scanf("%lf", &valor);
  printf("Dame el valor de la raiz -> ");
  scanf ("%lf", &raiz);
  
  resultado = raizn(valor, raiz);
  
  printf("\nLa raiz %1.1lf del numero %1.1lf en = %1.2lf\n\n", raiz, valor, resultado);
  return 0;
}


DESCARGA: raiz.c

Para compilar:gcc -o raiz raiz.c
Para ejecutar: ./raiz

EJECUCION



NUMEROS PRIMOS

Este programita generara una serie que contiene n numeros primos, la cantidad de resultados se puede controlar desde la constante MAX en el codigo fuente.
/* Programa que imprime "n" numeros primos de acuerdo al numero especificado 
en la constante MAX */

#include 
#define MAX 50

int primo(int numero) {
  int i; 
  for(i = 2; i < numero; i++)
    if(numero % i == 0)
      return 0;
  return 1;
}

int main(void) {
  int primos[MAX], i = 2, k = 0;
  while(k < MAX) {
    if(primo(i) == 1) {
      primos[k] = i;
      k = k + 1;
    }
    i = i + 1;
  }
  printf("\n\t\t\t%d numeros primos\n\n", MAX);
  for(i = 0; i < MAX; i++)
    printf("%d\t", primos[i]);
  putchar('\n');
  return 0;
}


DESCARGA: primos.c

Para compilar: gcc -o primos primos.c
Para ejecutar: ./primos

EJECUCION



SALUDOS!!! ^_^

FORTRAN - Ejemplos

Lenguajes de Programacón - PUNTOS EXTRA

MÁXIMO COMÚN DIVISOR

Este programa calcula el máximo común divisor de una pareja de números utilizando el Algoritmo de Euclides. Como sabemos el algoritmo de Euclides se fundamenta en que el máximo común divisor de la pareja de números a,b es el mismo que el de b,r, siendo r el residuo de la division anterior, por ello intercambiamos los valores de a por r a lo largo de la ejecucion del programa mientras el numero menor no sea igual a 0.

Para compilar: gfortran -o mcd mcd.f
Ejecutar con: ./mcd

Codigo
C ****** PROGRAMA QUE CALCULA EL ******
C ******* MAXIMO COMUN DIVISOR ********
C =====================================
    PROGRAM mcd
    REAL m, n, r, aux
    PRINT*, 'Dame M: '
    READ(*,*) m
    PRINT*, 'Dame N: '
    READ(*,*) n
    PRINT*, 'Maximo Comun Divisor de:'
    PRINT*, m, n
    IF (m.LT.n) THEN
       aux = m
       m = n
       n = aux
    ENDIF
    DO WHILE (r.NE.0)
       r = MOD(m,n)
       m = n
       n = r
    ENDDO
    PRINT*, 'es',m
    STOP
    END


EJECUCION


Para verificar que los resultados son correctos, pueden hacerlo en esta página o calcular el MCD ustedes mismos Calcular MCD

DESCARGA: mcd.f

CALCULO DE LA FUERZA MAGNETICA APLICADA A SUS TRES VARIANTES

Como lo dice el tÍtulo, este algoritmo calcula la fuerza magnetica aplicada ya sea a una particula en movimiento, generada en un conductor o en un solenoide.
Tuve un pequeno problema con el calculo del angulo ya que fortran lo pedia en radianes, aplicando una formula de conversion resolvi el problema :)

Para compilar: gfortran -o fisica fisica.f
Para ejecutar: ./fisica

Codigo
C ******** PROGRAMA QUE CALCULA ************
C ******** LA FUERZA MAGNETICA *************
C ********  EN SUS TRES CASOS **************
C ==========================================
      PROGRAM fisica

      REAL x, q, v, b, i, l, n, o, theta, fb, a 
      PRINT*, 'Calcular la magnitud de la fuerza magnetica para: '
      PRINT*, '1. Particulas en movimiento'
      PRINT*, '2. Conductores'
      PRINT*, '3. Solenoides'
      PRINT*, '4+. Salir'
      READ(*,*) x
      IF (x.EQ.1) THEN
         PRINT*, 'Dame la carga de la particula (Columb) '
         READ(*,*) q
         PRINT*, 'Dame la velocidad de la particula (Metros x seg.)'
         READ(*,*) v
         PRINT*, 'Dame la magnitud del campo magnetico (Teslas) '
         READ(*,*) b
         PRINT*, 'Dame el angulo de los vectores V X B (grados)'
         READ(*,*) o
         theta = ( o * 3.14159 ) / 180
         fb = abs(q)*v*b*sin(theta)
         PRINT*, 'La fueza magnetica para esta particula es',fb,'N'
      ENDIF
      IF (x.EQ.2) THEN
         PRINT*, 'Dame la intensidad de la corriente (Amperes)'
         READ(*,*) i
         PRINT*, 'Dame la longitud del conductor (metros)'
         READ(*,*) l
         PRINT*, 'Dame la magnitud del campo magnetico (Teslas)'
         READ(*,*) b
         PRINT*, 'Dame el angulo de los vectores I X B (Grados)'
         READ(*,*) o
         theta = ( o * 3.14159 ) / 180
         fb = i*l*b*sin(theta)
         PRINT*, 'La fuerza magnetica para este conductor es',fb,'N'
      ENDIF
      IF (x.EQ.3) THEN
         PRINT*, 'Dame el numero de vueltas del solenoide'
         READ(*,*) n
         PRINT*, 'Dame la intensidad de la corriente (Amperes)'
         READ(*,*) i
         PRINT*, 'Dame el area del solenoide (metros cuadrados)'
         READ(*,*) a
         PRINT*, 'Dame la magnitud del campo magnetico (Teslas)'
         READ(*,*) b
         PRINT*, 'Dame el angulo de los vectores V X B (Grados)'
         READ(*,*) o
         theta = ( o * 3.14159 ) / 180
         fb = n*i*a*b*(sin(theta))
         PRINT*, 'La fuerza magnetica para este solenoide es',fb,'N'
      ENDIF
      IF (x.GT.3) THEN
         PRINT*, 'Saliendo . . . . .'
      ENDIF
      STOP
      END


EJECUCION


DESCARGA: fisica.f



SALUDOS!!! ^_^

domingo, 7 de noviembre de 2010

LENGUAJES IMPERATIVOS - Programas Reporte 7

Lenguajes de Programación - Semana 12

FORTRAN
Fortran me inspiró bastante, asi que decidí aplicar algo de matemáticas para este lenguaje. Un programa que calcula las raices de una ecuación de segundo grado, incluyendo sus raices complejas. Para ello apliqué la fórmula general que todos conocemos y le agregue las condiciones para hallar las raices complejas, la cual es simple:

si el discriminante ( b^2 * 4*a*c ) es menor a 0, entonces la ecuación tendra raices complejas

Codigo:
C PROGRAMA QUE CALCULA LAS RAICES
C DE UNA ECUACION DE SEGUNDO GRADO
C --------------------------------------------
    PROGRAM raices
    REAL a, b, c, r, bc, rc, rc2, x, x1, x2
    PRINT*, 'Dame el valor de A: '
    READ(*,*) a
    PRINT*, 'Dame el valor de B: '
    READ(*,*) b
    PRINT*, 'Dame el valor de C: '
    READ(*,*) c

    r = ((b**2)-(4*a*c))
    PRINT*, r

    IF (r.GE.0) THEN
       x1 = (-b + (sqrt(r)))/(2*a)
       x2 = (-b - (sqrt(r)))/(2*a)
       PRINT*, 'x1 = ',x1
       PRINT*, 'x2 = ',x2
    ELSE
       rc = (sqrt(abs(r)))
       bc = -b / (2*a)
       rc2 = rc / (2*a)
       PRINT*, 'Solucion compleja x = ',bc,'+-',rc2,'i'
    ENDIF
    STOP
    END

DESCARGA: raices.f

Para compilar: gfortran -o raices raices.f

Para ejecutar: ./raices


BASIC

Para BASIC hice una calculadora sencilla, da la opción de seguir introduciendo operaciones hasta hartarte, no te permite dividir entre 0 y no acepta letras al momento de realizar una operacion, esto último ya es una funcionalidad del lenguaje. Para cada operación de 2 numeros, los valores se separan por una coma (ver imagen).

Codigo:
DECLARE SUB suma (a AS SINGLE, b AS SINGLE)
DECLARE SUB res (a AS SINGLE, b AS SINGLE)
DECLARE SUB mult (a AS SINGLE, b AS SINGLE)
DECLARE SUB div (a AS SINGLE, b AS SINGLE)
DECLARE SUB pot (a AS SINGLE, b AS SINGLE)
DECLARE SUB raiz (a AS SINGLE)

''' Calculadora Sencilla
   DIM x AS SINGLE, y AS SINGLE, opcion AS INTEGER
   PRINT
   PRINT "===== CALCULADORA 1.0 ====="
   DO
       PRINT
    PRINT "1. Suma"
PRINT "2. Resta"
    PRINT "3. Multiplicacion"
    PRINT "4. Division"
    PRINT "5. Potencia"
    PRINT "6. Raiz Cuadrada"
    PRINT "7+. SALIR"
    PRINT
    INPUT "Elige la operacion -> ", opcion
       PRINT

    SELECT CASE opcion
           CASE 1
     INPUT "Dame los dos valores a sumar -> ", x, y
     suma x, y
           CASE 2
     INPUT "Dame los dos valores a restar -> ", x, y
     res x, y
           CASE 3
        INPUT "Dame los dos valores a multiplicar ->", x, y
        mult x, y
           CASE 4
        INPUT "Dame los dos valores a dividir -> ", x, y
        div x, y
           CASE 5
        INPUT "Dame la base y el exponente (respect.) -> ", x, y
        pot x, y
           CASE 6
        INPUT "Dame un numero para obtener su raiz cuadrada -> ", x
        raiz x
           CASE ELSE
               PRINT "Saliendo . . . . . "
       END SELECT
   LOOP WHILE opcion < b =" 0"> ", b
   WEND
   r = a / b
   PRINT
   PRINT "Resultado: "; r
END SUB

SUB pot (a AS SINGLE, b AS SINGLE)
   DIM i AS INTEGER
   DIM c AS SINGLE
   c = 1
   FOR i = 1 TO b
    c = c * a
   NEXT i
   PRINT
   PRINT "Resultado: "; c
END SUB

SUB raiz (a AS SINGLE)
   PRINT
   PRINT "Resultado: "; SQR(a)
END SUB

DESCARGA: calculadora.bas

Para compilar: fbc calculadora.bas

Para ejecutar: ./calculadora


PASCAL

En este lenguaje batalle un poco, al final les muestro este otro que sirve para practicar la recursion en este lenguaje, un menú utilzando CASES, para seleccionar fibonacci, potencias o factorial

Codigo
PROGRAM recursion;

uses
   crt;

Function fibonacci (x : Integer):LongInt;
Begin
  If x <= 1 Then       fibonacci := x    Else       fibonacci := (fibonacci(x-1) + fibonacci(x-2)); End; { fibonacci }  Function potencia (a , b : Integer):LongInt; Begin    If b = 0 Then       potencia := 1    Else       potencia := a * potencia(a , b-1); End;  Function factorial(m : Integer):LongInt; Begin    If m < recursion ="="="="="="="="');"> ');
  opcion := ReadKey;

  Case opcion of
    'a' : begin
Writeln('');
Writeln('');
Write('BASE -> ');
Readln(num1);
Write('EXPONENTE -> ');
Readln(num2);
Writeln('');
Writeln('RESULTADO = ',potencia(num1,num2));
Writeln('');
    end;
    'b' : begin
Writeln('');
Writeln('');
Write('Cantidad de valores en la serie -> ');
Readln(num1);
For num2 := 1 To num1 Do
   Write(fibonacci(num2),' | ');
Writeln('');
    end;
    'c' : begin
Writeln('');
Writeln('');
Write('Factorial de? -> ');
Readln(num1);
Writeln('');
Writeln(num1,'! = ',factorial(num1));
Writeln('');
    end;
  end; { case }
End.

DESCARGA: recursion.pas

Para compilar: fpc recursion.pas

Para ejecutar: ./recursion


C

En C hice este programita que calcula el salario de los trabajadores de una empresa, el programa solicita las horas trabajadas totales a las que se les aplica el sueldo base seleccionado. Tambien se calculan horas extra (si son mas de 40 horas) y se les aplica una tarifa especial.
Los impuestos se aplican de la siguiente forma:
15% a los primeros $500
16% a los siguientes $300
17% a lo que resta
Despues se suman los descuentos y se le restan a la percepcion asi se obtiene un sueldo neto.
Al final el programa imprime todo el desglose de descuentos, horas y sueldo neto. Todo se maneja por medio de constantes por lo que es fácilmente editable a otros impuestos y sueldos base

Codigo
/*Programa para calcular salario en diferentes esquemas de pago*/

#include <stdio.h>
#define BASE1 57.46   
#define BASE2 55.84
#define BASE3 54.47
#define BASE4 53.00
#define EXTRA 15.00
#define TAX1 0.15
#define TAX2 0.16
#define TAX3 0.17

int menu(void) {    
    int opcion = 0, i;        
    for(i=0; i<79; i++) printf("=");    
    printf("\n\n");
    printf("\t    SELECCIONA EN NUMERO CORRESPONDIENTE A LA TAZA DE PAGO\n\n");
    printf("\t1) $ %.2f hr \t\t\t\t", BASE1);
    printf("\t2) $ %.2f hr\n\n", BASE2);
    printf("\t3) $ %.2f hr\t\t\t\t", BASE3);
    printf("\t4) $ %.2f hr\n\n", BASE4);
    printf("\t5) Salir\n\n");
    for(i=0;i<79;i++) printf("=");    
    scanf("%d", &opcion);
    while(opcion > 5 || opcion == 0) {
        printf("Elige una opcion valida -> ");
 scanf("%d", &opcion);
    }
    return opcion;
}


float calculos(float x, float y) {
 float horas, hrbase, hrext=0.0, hrtot;
 float salariobase, temp=0.0, percepcion, sueldoneto;
 float temp1=0.0, temp2=0.0, temp3=0.0;
 float imp1=0.0, imp2=0.0, imp3=0.0, descuento; 
 hrbase = y;   
 if (y > 40) {
   hrbase = 40;
   hrext = y - 40;
   temp = hrext * EXTRA;
 }
 hrtot = hrbase + hrext;
 salariobase = hrbase * x;
 percepcion = salariobase + temp;
 if (percepcion <= 300.0)     imp1 = percepcion*TAX1;   if (percepcion > 300.0) {
     temp1 = 300.0;
     temp2 = percepcion - 300;
     if (temp2 > 150.0){
temp3 = temp2 - 150;
temp2 = 150;
     }
     imp1 = temp1 * TAX1;
     imp2 = temp2 * TAX2;
     imp3 = temp3 * TAX3;
 }

 descuento = imp1 + imp2 + imp3;
 sueldoneto = percepcion - descuento;
 printf("\nHORAS BASE    %1.2f\nHORAS EXTRA   %1.2f\nHORAS TOTALES %1.2f\n\n", hrbase, hrext, hrtot);
 printf("SALARIO BASE  $%1.2f\nPAGO EXTRA    $%1.2f\nPERCEPCION    $%1.2f\n\n", salariobase, temp, percepcion);
 printf("IMPUESTO 15%% -$%1.2f\nIMPUESTO 20%% -$%1.2f\nIMPUESTO 25%% -$%1.2f\nDESCUENTOS   -$%1.2f\n\n", imp1, imp2, imp3, descuento);
 return(sueldoneto);
}

int main(int argc, char** args) {       
 int opcion;
 float horas, salario;        
 while(( opcion = menu()) != 5) {    
   switch(opcion) {                      
   case 1: {
     printf("\n\t\tSistema para calcular el sueldo con base a $ %.2f x hr\n\n", BASE1);
     printf("\t\tHORA EXTRA [ $ %.2f ]  \n\n", EXTRA);
     printf("INTRODUCE LAS HORAS LABORADAS -> ");
     scanf("%f", &horas);   
     salario = calculos(BASE1, horas);
     printf("SUELDO NETO A PAGAR [ $%1.2f ]\n\n", salario);
     break;
   }          
   case 2: {
     printf("\n\t\tSistema para calcular el sueldo con base a $ %.2f x hr\n\n", BASE2);
     printf("\t\tHORA EXTRA [ $ %.2f ]  \n\n", EXTRA);
     printf("INTRODUCE LAS HORAS LABORADAS -> ");
     scanf("%f", &horas);   
     salario = calculos(BASE2, horas);
     printf("SUELDO NETO A PAGAR [ $%1.2f ]\n\n", salario);
     break;
   }
   case 3: {
     printf("\n\t\tSistema para calcular el sueldo con base a $ %.2f x hr\n\n", BASE3);
     printf("\t\tHORA EXTRA [ $ %.2f ]  \n\n", EXTRA);
     printf("INTRODUCE LAS HORAS LABORADAS -> ");
     scanf("%f", &horas);   
     salario = calculos(BASE3, horas);
     printf("SUELDO NETO A PAGAR [ $%1.2f ]\n\n", salario);
     break;
   }           
   case 4: {
     printf("\n\t\tSistema para calcular el sueldo con base a $ %.2f x hr\n\n", BASE4);
     printf("\t\tHORA EXTRA [ $ %.2f ]  \n\n", EXTRA);
     printf("INTRODUCE LAS HORAS LABORADAS -> ");
     scanf("%f", &horas);   
     salario = calculos(BASE4, horas);
     printf("SUELDO NETO A PAGAR [ $%1.2f ]\n\n", salario);
     break;
   }
   }
 }
 return 0;   
}

DESCARGA: salario.c

Para compilar: gcc -o salario salario.o

Para ejecutar: ./salario

Ejecucion


SALUDOS

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!! ^_^