JorgeOrtiz’s Weblog

Freymam Alexis Vallejo Cuero – fvallejocuero@unicauca.edu.co

Jorge Eliécer Ortiz Romo – jorgeortiz@unicauca.edu.co

Resumen

El siguiente artículo intenta proveer información acerca de las características más relevantes de lenguajes de programación como C++, Python, Java y Ruby, haciendo un paralelo entre ellos, respecto a las características soportadas por cada uno.

También, se pretende mostrar con pequeños trozos de código para cada concepto o característica en cada uno de los lenguajes de programación considerados, tratando de mostrar mejor el comportamiento, o la aplicación de cada uno.

Orientación a Objetos

Muchos lenguajes se declaran Orientados a Objetos. Pero la definición exacta del término depende de muchos rasgos y conceptos que se deben cumplir en su totalidad [1]; estos rasgos y características son:

1. Ocultamiento y encapsulamiento de la información

2. Herencia

3. Polimorfismo

4. Todos los tipos de datos predefinidos son objetos

5. Todas las operaciones realizan envío de mensajes a objetos

6. Todos los tipos de datos definidos por los usuarios son objetos

Para propósito de esta discusión, un lenguaje será considerado Orientado a Objetos Puro si satisface todos los seis ítems nombrados. Será híbrido si sólo cumple con algunos de esos 6 lineamientos (por lo generar son híbridos cumpliendo los tres primeros). Tanto C++, Python y Java serán considerados Orientados a Objetos Híbridos, porque, C++ cumple solamente con los tres primeros; por su parte, Python no cumple con el encapsulamiento y ocultamiento de la información y tampoco con que todas las funciones usen mensajes a objetos.

C++ es un lenguaje multi-paradigma, y uno de los paradigmas que soporta es orientación a objetos. Ruby es un genuino lenguaje orientado a objetos que desde las fases iniciales de su diseño se tuvo en cuenta que debía soportar completamente este modelo; incluso los tipos estándar como los números son objetos de la clase Fixnum o Bignum.

Tipos de Datos Estáticos y Dinámicos

Python implementa tipos dinámicos. Esto quiere decir que el tipo de un objeto (en Python todo son objetos) se comprueba dinámicamente cada vez que es necesario dicho objeto. A un objeto se le asigna un tipo en el momento en que es asignado. Pero podemos realizar asignaciones de diferentes tipos. Esto significa que un mismo identificador puede referenciar objetos de tipo diferente en distintos puntos del programa. De esta forma es legal:

(1) >>> a = 7 #a es un entero

(2) >>> a = ‘pepe’ #a es una cadena

(3) >>> a = [1,7,'pepe'] #a es una lista

En lenguajes compilados, suele implementarse tipos de datos estáticos. Esto significa que durante la vida de un programa, una variable no puede cambiar de tipo, Java y C++ son un ejemplo para este concepto:

(1) int numero;

(2) numero=”hola”; //error

En el anterior ejemplo la variable numero se ha definido de tipo entero y no se le puede asignar un tipo de dato string, lo cual genera un error (línea (2)).

En Ruby no se declara los tipos de variables o métodos, todo esto es solamente un tipo de objeto, también se hace una aclaración respecto a que las clases no siempre representan los tipos de los objetos y se plantea que el tipo de un objeto está determinado por lo que el objeto puede hacer y no por su clase.

(1) def append_song(result, song)

(2) result << song.title << ” (” << song.artist << “)”

(3) end

(4) result = “”

(5) append_song(result, song) ! “I Got Rhythm (Gene Kelly)”

En el ejemplo anterior no se necesita chequear el tipo de los argumentos. Si ellos soportan << (en el caso de result, línea (2)) o title o artist(en el caso de song), todo simplemente funcionará, si no, el método lanzara una excepción que de cualquier forma se lanzaría si se chequean tipos), pero sin el chequeo, el método es de repente mas flexible ya que se podría pasar un array, string, un archivo u otro objeto que pueda usar <<

Clases Genéricas

La idea de Clases Genéricas es parametrizar las clases con tipos de datos distintos, inclusive tipos de datos definidos por el mismo usuario. Un ejemplo común es la Clase Pila que es un contenedor de objetos similares definidos por el usuario.

El principal beneficio de la parametrización de las clases radica en los lenguajes compilados, porque el tipo de dato a utilizar se define en tiempo de compilación de una forma segura.

C++ utiliza una muy buena forma de clases genéricas llamadas plantillas (templates) que aunque dan más funcionalidades aumenta la complejidad en el uso de esta:

El siguiente ejemplo en C++, se define una clase de tipo template llamada MiClase que tiene un atributo TMP (de cualquier tipo), al momento de instanciar de MiClase, se debe definir el tipo del objeto TMP que para el ejemplo es el tipo int (línea (5)):

(1) template <class TMP>

(2) class MiClase{

(3) TMP P;

(4) …

};

(5) MiClase <int> miObjeto;

Herencia

La herencia es la habilidad de una clase u objeto para se definido como una extensión o especialización de otra clase u objeto. La mayoría de los lenguajes orientados a objetos soportan la herencia basada en clases, mientras otros, tales como JavaScript soporta la herencia basada en objetos, en la cual una clase puede heredar de otras clases y objetos individuales pueden se extendidos en tiempo de ejecución con las capacidades de los otros objetos.

La herencia múltiple consiste en que una clase hereda de muchas otras clases al mismo tiempo. Esta forma de herencia trae, por su puesto, complicaciones: puede presentarse la muy común ambigüedad en los nombre de variables y funciones. La herencia de subtipo es la herencia más común, en la cual una subclase es considerada como un subtipo de su superclase, comúnmente denominada relación IS-A.

C++ define la herencia múltiple como se puede ver en este ejemplo: Vestido hereda de forma pública de Chaqueta y de Pantalón (línea (3))

(1) Class Chaqueta { … };

(2) Class Pantalón { … };

(3) class Vestido: public Chaqueta, public Pantalon{

(4) //definición de variables y funciones

};

Para este ejemplo, en Python, la clase C hereda de forma múltiple de A y B; donde la clase B heredad de forma simple de A:

(1) class A:

…

(2) class B(A):

…

(3) class C(A,B):

…

Por otro lado Java nos plantea una herencia simple y una herencia múltiple de subtipo (línea (2)), ejemplo:

(1) public MiClase { …

}

(2) public class MiNuevaClase extends MiClase

{ …

}

Ruby, por su parte, ofrece la simplicidad de la herencia simple y el poder de la herencia múltiple. Una clase en Ruby puede tener solo un padre directo por lo tanto Ruby es un lenguaje de herencia simple. Sin embargo, las clases en Ruby pueden incluir la funcionalidad de varios mixin (un mixin es como una definición parcial de una clase) y de esta manera provee la capacidad controlada de la herencia múltiple.

El siguiente es un ejemplo que ilustra el uso de los módulos mixin para simular la herencia multiple; la clase ScaleDemo “hereda” la funcionalidad de los modulos MajorScales y PentatonicScales(lineas (15) y (16)).

(1) module MajorScales

(2) def majorNum

(3) @ms_numNotes = 7 if

(4) @ms_numNotes.nil?

(5) @ms_numNotes # Return 7

(6) end

(7) end

(8) module PentatonicScales

(9) def pentaNum

(10) @ps_numNotes = 5 if

(11) @ps_numNotes.nil?

(12) @ps_numNotes # Return 5?

(13) end

(14) end

(1) class ScaleDemo

(15) include MajorScales

(16) include PentatonicScales

(17) def initialize

(18) puts majorNum #be 7

(19) puts pentaNum # be 5

(20) end

(21) end

ScaleDemo.new

Característica de Renombrado

La característica de renombrado es la habilidad que tiene una clase u objeto para renombrar uno de sus rasgos que normalmente es heredado de la superclase. Hay dos importantes causales que nos permiten el uso de esta técnica:

§ Proporcionar un rasgo con un nombre más natural para su nuevo contexto.

§ Resolver la ambigüedad de los nombres cuando se realiza herencia múltiple.

Aunque es válido decir que Python no soporta renombrado, si soporta el uso de alias. En el siguiente ejemplo a la función imprimirA de A se le asigna un alias llamado ‘a’:

(1) class A:

(2) def imprimirA(self):

(3) print ‘a’

(4) >>> a = A.imprimirA

(5) >>> a

(6) ‘a’

Ruby brinda la capacidad de renombrado donde una clase hija puede sobrescribir o redefinir atributos o métodos de sus clases ancestro, el siguiente ejemplo ilustra esta situación.

(1)class Person

(2)  attr_accessor :name, :age, :sex

(3)  def initialize(name, age, sex)

(4)    @name, @age, @sex = name, age, (5)sex

(6)  end

(7)  # ...

(8)end

(9)class Student < Person

(10)  attr_accessor :idnum, :hours

(11)  def initialize(name, age, sex, (12)idnum, hours)

(13)   super(name, age, sex)

(14)    @idnum = idnum

(15)    @hours = hours

(16)  end

(17)  # ...

(18)end

(19)a = Person.new("Dave Bowman", 37, (20)"m")

(21)b = Student.new("Franklin Poole",     36, "m", "000-13-5031", 24)

En la línea (11) se renombra el constructor inicialize, definido en la superclase Person.

Sobrecarga de Métodos

Sustenta el polimorfismo. Es la capacidad para que una clase, módulo u otro enlace tenga dos o más métodos con el mismo nombre. Las llamadas a estos métodos no presentan ambigüedad porque se diferencian por el número y/o tipo de los argumentos pasados en la invocación de la función.

C++ plantea la siguiente forma de realizar una sobrecarga de métodos. En el siguiente código hay 3 métodos con el mismo nombre setDatos, pero tienen distinto número y tipo de parámetros, lo que los hace a todos distintos (línea (2), (3) y (4)):

(1) class Persona{

…

(2) void setDatos(char*, char*);

(3) void setDatos(char*);

(4) void setDatos();

…

};

En Java se presenta una sobrecarga similar a la presente en C++: se sobrecarga, en este ejemplo la el constructor :

(1) class MiClase{

(2) MiClase ( ){ …

}

(3) MiClase (String s, int i){ …

}

(4) MiClase (MiClase obj){ …

}

}

Python no soporta la sobrecarga de funciones por tipo, sólo por número de parámetros como se puede observar en el siguiente ejemplo (en las líneas (2), (3) y (4)):

(1) class linea:

(2) def __init__ (self): …

(3) def __init__ (self, xi, xf, yi, yf): …

(4) def __init__ (self, ini, fin): …

Sobrecarga de Operadores

La sobrecarga de operadores es la capacidad que se le da al programador para que defina operaciones entre los tipos de datos del usuario (objetos). Esto permite el uso de notación infijo, prefijo y postfijo, como la notación estándar. Por ejemplo, un tipo de dato de usuario, Matriz, puede definir un operador infijo ‘*’ para la multiplicación de dos Matriz (matriz1 * matriz2).

Para evitar algunos problemas de legibilidad del código, se recomienda:

1. Todas las operaciones deben ser mensajes a objetos (función miembro) y así todos los operadores son siempre llamadas a métodos.

2. Los operadores deben tener una forma funcional equivalente, entonces el uso del operador como una llamada a método se comportará precisamente de la misma forma que en la notación infija, prefija y postfija.

La sobrecarga de operadores en C++ se plantea de la siguiente forma general:

<tipo retorno> <Nobre de la Clase> :: operator <operador> (<parámetros>)

{

//implementación de la función

}

La sobrecarga de operadores en Java y Ruby no existe.

Funciones de Alto Orden

Las funciones de alto Orden, básicamente son funciones que pueden ser tratadas como si fueran objetos de datos. En el orden de ideas, estas pueden ser tomadas como variables (incluyendo la habilidad de ser almacenadas en colecciones), ser pasadas a otras funciones como parámetro y ser retornadas como resultado de otra función. Debido a esta habilidad, las funciones de alto nivel peden ser vistas como una forma de ejecución diferida, donde una función puede ser definida en un contexto, pasado a un segundo contexto y entonces ser invocada desde allí. A esto se le llama funciones lambdas anónimas, donde el contexto de invocación no necesita saber el nombre de la función a invocar.

Python proporciona funciones de alto orden como map, filter, reduce y lambda, que se pueden usar de forma similar como se verá:

(1) def par( x ): return not x%2

(2) print filter( par, range( 20 ) )

Cerraduras Léxicas

Las Cerraduras Léxicas (o Cerradura Estática o simplemente Cerradura) se basan en las funciones de alto nivel dándole una utilización mas eficiente. La idea es que cada vez que una función cambie de contexto lleve consigo, de alguna forma, el ambiente en que fue creado. Esto facilita también el acceso a variables y parámetros locales al contexto real de la función.

Python plantea el uso de las cerraduras cuando se presenta una situación parecida:

class Foo {

def doOperationA():

…

def stage2():

…

def doOperationB():

…

def stage2():

…

def stage3():

…

…

Recolector de Basura

El recolector de basura consiste en liberar la memoria de los objetos del usuario que ya dejó de usar. Existen varias estrategias de implementación de esto:

o El conteo de referencias (que se hace en Python) es el esquema simple. El sistema guarda la cantidad deferencias hacia un objeto, cuando este conteo da cero se libera el objeto.

o Java por su parte maneja “Mark and Sweep”, marcar y barrer. La recolección de basura se decide en dos pasos: 1) Marcar: se recorren los objetos desde la raíz marcándolos como ‘vivo’, si están en uso. 2) Barrido: se recolecta los objetos no marcados como ‘vivos’.

También hay que dejar constancia que C++ no tiene oficialmente uso de Recolector de Basura…

Ruby actualmente usa “mark and sweep” como recolector de basura automatico.

Métodos y Variables de Clase

Los métodos pertenecen a la clase y no al objeto, es decir, para una clase se dispone de un espacio en memoria para sus métodos, y este espacio lo comparten todos los objetos instanciados de la clase.

Clase C++:

class IntList {

public:

void func1( int );

int func2();

private:

int i;

char a;

};

Clase Java, indicando casi siempre la visibilidad por cada elemento:

(1) public class MiClase {

(2) private int i;

(3) int k;

(4) public MiClase(){

…

}

(5) private setI( int valor ) {

…

}

}

En Python se puede usar la palabra reservada global asi (línea 3):

(1) X = 88 #variable global X

(2) def func( ):

(3) global X

(4) X = 99 #variable global X: definida afuera de la función

(5) func( )

(6) print X #Imprime 99

Reflexión

Es la habilidad que tiene un objeto para auto describirse en tiempo de ejecución (indicar tipo del objeto, estructura de herencia, métodos que contiene, numero y tipos de parámetros y tipos de retorno).

C++ no maneja la reflexión, mientras Python permite una forma de reflexión muy fuerte.

El siguiente es código ejemplo de reflexión en Java:

(1) TextField t = new TextField();

(2) Class c = t.getClass();

(3) Class sup = c.getSuperclass();

(4) String str = c.getName();

(5) int m = c.getModifiers();

En el anterior código se define un objeto TextField al cual se le pide su objeto Class (línea 1), luego se le pide su objeto Super Clase (línea 2), el nombre de la clase (línea 4) y su modificador –public, private– (línea 5).

En Python se pueden utilizar distintas rasgos para acceder a la información descriptiva de un objeto:

(1) type(a)

(2) a.__dict__

(3) a.__dict__.values()[i]

Para el anterior código, type(a) indica el tipo de dato de la variable a (línea 1), a.__dict__ es un diccionario que maneja el compilador para relacionar el nombre de la variables y su valor (línea 2) a través de la función values definida para los diccionarios (línea 3).

Contrario a los lenguajes estáticos, donde el tipo de la variable determina su clase, y de ahí los métodos que soporta, Ruby soporta objetos liberados. No se puede decir con exactitud que puede hacer un objeto, hasta haber mirado dentro de su cubierta [8].

Se puede conocer los métodos a los que un objeto responde…

(1) r = 1..10

(2) list = r.methods

(3) list.length

(4) list[0..3]

en la linea (1) se crea un objeto rango, luego, en la linea (2), a “list” se le asignan los métodos que responde “r”. las lineas (3) y (4) nos darian las siguientes salidas respectivamente:

» 60

» ["size", "exclude_end?", "to_s", "length"]

se puede determinar la clase del objeto, su identificador único y verificar si se relaciona con otras clases [8]…

num = 1

num.id » 3

num.class » Fixnum

num.kind_of? Fixnum » true

num.kind_of? Numeric » true

num.instance_of? Fixnum » true

num.instance_of? Numeric » false

Control de Acceso

El Control de Acceso tiene una relación estrecha con el encapsulamiento de la información que es uno de los principios de la Orientación a Objetos.

Normalmente los lenguajes definen dos tipos de visibilidad en sus clases: público y protegido. Se recomienda que todos los atributos sean protegidos y los métodos públicos, para garantizar el ocultamiento de la información; aunque hay lenguajes que involucran una tercera visibilidad: privado, que hace que los elementos sean inaccesibles por otros módulos fuera de la clase que lo implementa.

C++ nos muestra el control de acceso así:

(1) class MiClass {

(2) public: void func1();

(3) private: int i;

};

Python, no proporciona un fuerte control de acceso. Más sin embargo Python define un mecanismo llamado Name Mangling . Aunque esto no impide que el código del programador acceda de forma libre a los nombres Mangled ya que este funciona solo como un simple indicador de privacidad (como una sugerencia).

Existe una forma de declarar métodos privados en una clase y es la siguiente:

(1) class Persona(object):

(2) def __init__(self, name, edad):

(3) self.name = name # atributo público

(4) self.__edad = edad # atributo privado

los dos caracteres underscore (__) que comienzan el nombre del segundo atributo (línea 4) indican que es un atributo privado y solo otros métodos de la misma clase pueden acceder o invocarlo.

Java proporciona un cuarto “nivel de seguridad”, conocido como ‘Package Private’ que permite el acceso entre clases del mismo paquete.

(1) public void CualquieraPuedeAcceder(){}

(2) protected void SoloSubClases(){}

(3) private String NumeroIdentidad;

Ruby soporta tres niveles de protección o control de acceso a sus métodos.

• Métodos Públicos: Pueden ser llamados por cualquiera, no es un control de acceso. Los métodos son públicos por defecto (excepto para inicialize que es siempre privado). (Siguiente ejemplo línea 3).
• Métodos Protegidos: Pueden ser invocados solamente por objetos instanciados de la clase que los define o subclases de esta. (Siguiente ejemplo línea 4).
• Métodos Privados: Pueden ser llamados solo en la definición de la clase y por descendientes directos, dentro del mismo objeto. (Siguiente ejemplo línea 5).

(1) class MyClass

(2) def method1

end

# … y los otros metodos.

(3) public :method1, :method4

(4) protected :method2

(5) private :method3

end

El anterior código en Ruby ilustra el uso de modificadores de acceso para los métodos.

Multihilos

Es la capacidad para que un programa procese dos o mas tareas concurrentemente (no se ejecutan simultáneamente a causa de la arquitectura del computador). Los multihilos se implementan principalmente en Sistemas Operativos, servidores Web, etc. La dificultad muy presente en la sincronización de los hilos hace de esta práctica poco llamativa para aplicaciones simples.

El siguiente ejemplo, en C++, crea un hilo (línea 4) para cada una de las funciones definidas (funcA, funcB) llamados h1 y h2, y luego los vincula a cada una (líneas 5 y 6). Posteriormente impide que el programa principal termine sin que antes hallan termindos sus hilos (líneas 7 y 8).

(1) #include <pthread.h>

(2) void funcA(){ … }

(3) void funcB(){ … }

int main(){

(4) pthread_t h1, h2;

(5) pthread_create( &h1, NULL, funcA, NULL );

(6) pthread_create( &h2, NULL, funcB, NULL );

(7) pthread_join( h1, NULL );

(8) pthread_join( h2, NULL );

}

Por su parte Java plantea el uso de hilos usando tipo de datos Thread (linea 2) y la función run (línea 4); también implementa muchas funciones que facilitan la sincronización de los hilos:

(1) public class reloj implements Runnable {

(2) private Thread hilo;

(3) int periodo_refresco = 1000;

(4) public void run() {

(5) while ( hilo != null ) {

(6) Thread.sleep( periodo_refresco );

}

}

}

Por su parte Python define también sus funciones para el manejo de hilo que se pueden acceder a través de la librería threading (import threading), por la cual podemos crear instancias de hilos (threadin.Thread). Y usando la función run para definir la secuencia de ejecucción; el atributo background para que se ejecute de forma paralela (utilizando las funciones background.start(),background.join()).

Los hilos en Ruby son hilos a nivel de usuario que son independientes del sistema operativo, y hay disponibles métodos de sincronización para controlar el acceso a variables y recursos, proteger secciones criticas de código, entre otras tareas [9].

El siguiente ejemplo ilustra la declaración del hilos en Ruby…

thread = Thread.new do

  # Statements comprising

  #   the thread...

end

Expresiones Regulares

Son un modelo que permite reconocer los idiomas regulares. Para esto se utilizan las bibliotecas que sustentan las estructuras de los lenguajes Regulares. El lenguaje regular se basa en el reconocimiento de estructuras en una comunicación o mensaje.

Java plantea la utilización de Expresiones Regulares usando las definiciones de la librería java.util.regex (línea 1), con el tipo de objetos Patter para definir el patrón a seguir con su función compile (líneas 5 y 8), matcher para verificar la estructura usando su función find() (líneas 7 y 10):

(1) import java.util.regex.*;

(2) public class ValidacionEmail {

(3) public static void main(String[] args) throws Exception {

(4) String input = “www.?regular.com”;

(5) Pattern p = Pattern.compile(“^\\.|^\\@”);

(6) Matcher m = p.matcher(input);

(7) if (m.find())

System.err.println(“Las direcciones email no empiezan por punto o @”);

(8) p = Pattern.compile(“^www\\.”);

(9) m = p.matcher(input);

(10) if (m.find())

System.out.println(“Los emails no empiezan por www”);

input = sb.toString();

}

}

Por su parte Python también permite el manejo de expresiones regulares, así:

# se busca un patrón

>>> if (re.search(“\Aa[0-9].*(end|fin)$”, “a2 lo que quiera fin”)):

… print “se ha encontrado el patrón”

…

se ha encontrado el patrón

Ruby, considera las expresiones regulares como parte de sus tipos estándar, y son objetos de tipo Regexp.

El siguiente ejemplo ilustra el uso de expresiones regulares para encontrar pares clave, valor.

(1) pat = /(\w+)\s*=\s*(.*?)$/

(2) str = “color = blue”

(3) matches = pat.match(str)

(4) puts matches[1] # “color”

(5) puts matches[2] # “blue”

En la linea (1) se define la expresión regular. El supuesto es que la clave o atributo es una plabra simple; el valor se encuentra al final de la linea y el signo igual puede estar rodeado por espacios en blanco, las salidas se muestran en comentarios en las lineas (4) y (5).

Aritmética de Apuntadores

La aritmética de apuntadores es la habilidad que tiene un lenguaje de programación para manipular de forma directa el espacio de memoria asignada. A menudo esta habilidad conlleva a errores semánticos (violación de segmento,…) lo cual hace que esta técnica no sea muy deseada en sistemas de alto nivel si no sí en sistemas de bajo nivel.

De los tres lenguajes en cuestión, sólo C++ permite el manejo de apuntadores que se hace de la siguiente forma:

void * p = 200F;

*p = CONSTANTE;

p++;

Integración de Lenguajes

La integración con sistemas existentes, en especial, módulos de bajo nivel, se hace necesaria para mejorar la velocidad de ejecución de nuestras funciones (particularmente en lenguajes interpretados). Desde la aparición y aceptación de C, la mayoría de los lenguajes (incluyendo Java y Python) implementan integración con este (C).

C++, implementa integración con C y Assembler. En el siguiente código de ejemplo se muestra la interacción con Assembler:

/* Código de manejo de arreglos y llamada a la función printf*/

#include <stdio.h>

void main(void) {

asm{

mov AX, 23

inc AX

jnz printf

}

}

Java define integración con C y algo de C++. Código ejemplo de integración con C:

extern “C”

jdouble Java_Timer_sinceLast (JNIEnv *env, jobject obj, jstring comment) {

jclass cls = env->FindClass(“timing.Timer”);

jfieldId last_time_id = env->GetFieldID(cls, “last_time”, “J”);

jfieldId last_comment_id = env->GetFieldID(cls, “last_comment”, “Ljava_lang_String;”);

…

}

Python define integración con C++. Código ejemplo de integración con C++:

%module example

%{

/* Put headers and other declarations here */

%}

extern double My_variable;

extern int fact(int);

extern int my_mod(int n, int m);

Variables

Los lenguajes que estamos analizando (C++, Java y Python) son lenguajes imperativos, es decir que se basan en una abstracción a la arquitectura de computadores de Von Newman (procesador y memoria). Estos lenguajes, como correspondencia, usan variables que normalmente se caracterizan por:

· Nombre de la variable

· Tipo de dato de la variable

· Ligadura de la variable

· Inicialización de la variable

· Alcance de la variable

· Tiempo de vida de la variable

· Forma de tipado

· Chequeo de tipos

· Compatibilidad de tipos entre variables

· Ambiente de referencia de la variable

· Variables constantes

Las tres principales características de las variables son: tipo, valor y celda de memoria.

Nombre de la variable

Es la palabra con la cual se conoce y se referencia a la variable. Se debe tener cuidado al darle un nombre a la variable, este no puede ser igual a las palabras reservadas del compilador y tampoco debe ser igual al nombre de las funciones declaradas de forma local o importadas de los módulos. Tampoco se puede tener varias variables con el mismo nombre.

El nombre de las variables debe tener la siguiente estructura:

nombre ::= (letra|”_”)(letra|digito|”_”)*

letra ::= l_mayuscula | l_minuscula

l_mayuscula ::= “A” … “Z”

l_minuscula ::= “a” … “z”

digito ::= “0” … “9”

Es decir iniciar con una letra o guion_bajo; no iniciar con un digito.

Tipo de dato de la variable

Un tipo de dato define todo el posible rango de valores que una variable puede tomar al momento de ejecución del programa y a lo largo de toda la vida útil del propio programa. Aunque este rango por lo general depende de la implementación del compilador y la arquitectura de la máquina.

C, en particular, es muy estricto en el manejo y almacenamiento de variables; por esta razón se requiere declarar cada variable que se valla a usar indicando su tipo de dato o clase a la que pertenece antes de usarla.

Los tipos de datos en C++ definido en algunos compiladores son.

Python por su parte define una jerarquía de tipos de datos un poco especial:

Tipo de datos numéricos: plain integers, long integers, floating point numbers y complex number. Hay que notar que el Boolean es un tipo de dato plain integers.

Tipo de datos secuencia: son aquello tipos de datos compuestos: vector, string y tupla. Pueden contener otros elementos como números y ellos mismos (ej. Un vector de vectores de cadenas).

Tipo de dato de mapeo: los únicos existente en esta jerarquía son los diccionarios; estos tienen una llave, y a través de esta localizan un valor.

Ligadura de la variable

Una variable es la abstracción de un espacio de memoria que puede ser accedida con una referencia o nombre que lo identifica. Dependiendo el tipo de dato el sistema operativo asignará un espacio limitado para el almacenamiento del valor que quiera llevar la variable.

La ligadura se presenta normalmente en el momento de definir la variable. Una vez se define la variable se le asigna un espacio de memoria.

Ejemplo en C++ de ligadura:

int mi_entero = 4;

float mi_flotante;

char mi_caracter;

El anterior ejemplo define tres variables escalares de las cuales solo mi_entero se inicializa con un valor de su tipo. Normalmente se puede inicializar cualquier variable.

Hay que tener en cuenta que si le asignamos un dato distinto al tipo de dato de la variable, esto generará un error (posiblemente) en C++ -esto no ocurrirá en Python-

int mi_entero; //variable entera

mi_entero = ‘g’; //dato carácter ‘g’

En Python, que es un lenguaje de tipado dinámico (cambiar de tipo de dato en tiempo de ejecución –se explicará en siguientes items-) el espacio de memoria y el nombre se mantienes igual, más sí, el tipo dato que almacena cambia. Usa declaración implicita.

Ejemplo en Python, ligadura y tipado dinámico:

a = 3

a += 2

a = “Hola mundo”

En este ejemplo se define una variable a. Note que no es necesario definir el tipo de dato que almacenará. La variable a se inicializa con el valor de 3; se incrementa en 2 unidades; finalmente se cambia el tipo de dato numérico entero por el tipo de dato secuencia String –almacenando “Hola mundo”-.

Inicialización de la variable

Como se vio en el item anterior, las variables en C++ pueden ser o no ser inicializadas asignándole un dato, un función o cualquier otro elemento que represente un dato del mismo tipo de dato definido en la variable. Ejemplo:

//define una función que retorna un int

int fun_inc( int i ){

return i+1;

}

void main(){

/*Definimos un entero que se

*inicializa inclusive con el valor

*que retorna la funcion fun_inc*/

int mi_entero = fun_inc(0);

/*O también inicializarlo con un

*dato en específico*/

char mi_caracter = ‘m’;

}

En Python la inicialización de las variables se presenta siempre, porque para poder definirlas debemos darle un valor inicial, de esta forma

#definimos la función incremento

#que retorna un entero

def fun_inc (i):

return i+1

#iniciamos la variable entera sin

#definir el tipo de dato, porque este

#se define dinámicamente una vez le

#un valor que este caso en un dato

#entero

mi_entero = fun_inc( 0 )

mi_cadena = “Hola mundo”

Alcance de la variable

El alcance hace referencia a que en qué bloque la variable puede ser accedida o referenciada (un bloque es una secuencia de código agrupado). Es decir, desde qué módulos, funciones o en general bloques, se puede acceder a una variable dada.

Los lenguajes de programación por lo general implementan una visibilidad de variable por bloque de código, o sea, la variable solo es conocida en el bloque en que se define; contando algunas excepciones:

Variables No Locales al Bloque: son variables que no se declararon dentro del bloque; por lo general se definen antes de iniciar el bloque en cuestión.

Ejemplo de variable no local a (global) en C++:

//variable global

int MAX_N;

void imprimirN(){

//acceder a la variable global al

//método

for( int i=0; i<MAX_N; i++ )

cout<< i<< “\n”

}

void main(){

//acceso a la variable global al

//método

MAX_N = 10;

imprimirN();

}

Variables Escondidas: son aquellas a la cual el compilador proporciona una forma de acceso especial. A estas variables no se tiene visibilidad aparente pero se pueden referenciar de la siguiente forma:

Estructura de C++ para acceder a variables escondidas:

//cuando se ha definido una clase

//nom_clase a la cual no puedo ver

//normalmente

nom_clase::nom_variable

Estructura en Python para referenciar variables escondidas:

#cuando se tiene un módulo al cual no

#puedo ver de forma normal

nom_archivo.nom_variable

Ejemplo en C++ de bloque:

//bloque main

int main(){

//bloque for

for( int i=0; i<10; ++i )

//primer bloque if

if( i==3 ){

cout<< i;

}

//Segundo bloque if

if( i==2 ){

cout<< “Esto no es valido”;

}

}

En el anterior ejemplo vemos un bloque main, un bloque for y dos bloques if. El bloque se compone por la cabecera (definición) y un conjunto de sentencias. Es notable que el código producirá un error a causa de que la variable i en el segundo bloque no puede ser vista, no existe, murió al terminar el bloque for que la definió.

Ejemplo en Python de bloque:

#bloque Analizar

def Analizar():

#bloque for

for ObjIns in vecObjIns:

#primer bloque if

if ObjIns.getTipo() == ‘para’:

SenFor( objIns )

#segundo bloque if

if objIns.getTipo() == ‘mientras’:

SenWhile( objIns )

En este ejemplo vemos que el inicio de un bloque en Python está definido por el carácter ‘:’, el conjunto de sentencia de distinguen por la identación y el fin lo limita igualmente la identación.

En Ruby las variables globales están disponibles en todo el programa, cada referencia a un nombre global particular retorna el mismo objeto, referenciar una variable global no inicializada retorna “nil”.

Las variables de clase están disponibles dentro de una clase o en el cuerpo de un modulo y deben ser inicializadas antes de usarlas, una variable de clase es compartida entre todas las instancias de una clase y está disponible dentro de la clase misma.

Ambiente de referencia de la variable

Este ambiente está conformado por todos los nombres de variables y funciones a los cuales la variable tiene visibilidad.

Si se utiliza el concepto de alcance estático, las variables visibles no locales se buscan en tiempo de compilación.

Ejemplo en C++:

//variables globales

char *a, *b, *c = “c_global”;

//function g

void g(){ print (a, b, c); }

//function f

void f(){

char* a;

a= “a_en_f”;

g();

}

//Function h

void h(){

char* b;

b= “b_en_h”;

g();

}

//principal

int main(){

char* c;

a = “a_global”;

b = “b_global”;

c = “c_en_main”;

f();

g();

h();

}

En este ejemplo, las variables a, b y c que son definidas en la funcion main, pierden al alcance cuando el hilo de ejecución se encuentra listo para imprimir, en la funcion g, estas variables y siempre tomará la referencia a las variables globales. Ignorando, tanto la variable a definida en f() como la misma variable b definida en h().

No importa desde que función se invoca g() el resultado del print es siempre el mismo.

Si se utiliza el concepto de alcance dinámico, se tendrán en cuenta a las variables no locales; esto se resuelven en tiempo de ejecución, dependiendo de la función desde la que se produce la invocación. Se determinan examinando el árbol de activación.

Figura 1: Árbol de activación, alcance dinámico

En esta figura (el seguimiento se hace desde el main) la función main invoca a la función f() que se encarga de crear la variable a (a en f), y llama a la función g(); esta función g(), imprime las variables a, b y c, de las cuales a será referenciada de la función f() que la definió y aún es un subprograma activo (función que se está ejecutando). Las otras dos variables b y c son tomadas de las referencias globales.

Tiempo de vida de la variable

El tiempo de vida de una variable está dada a partir de cuando se crea hasta el momento de dejar de existir físicamente (en memoria).

Hay dos formas de definir el inicio y el fin de una variable: por el compilador y por el usuario.

Tiempo de vida definido por el compilador:

- Variable global a todos los bloques del programa: esta variable tiene un espacio en memoria desde el momento de compilación y es eliminada junto con el sistema

- Variable definida sin algún modificador dentro de un bloque: La variable empieza a vivir en el momento de compilación (en el caso de C++), o en el momento en que se le asigna un valor a un nombre desconocido (en el caso de Python). Al final la variable deja de existir cuando termina la ejecución del bloque que la creó.

- Variable definida con el modificador static en C++: a este tipo de variables se le asigna un espacio de memoria en el momento de compilación; se elimina cuando se termina la ejecución del programa.

Tiempo de vida definido por el usuario en C++: tomando como herencia de C, C++ implementa la asignación y rechazo de memoria dinámicamente (en tiempo de ejecución). Usando las palabras reservadas new –para asignación de memoria- y delete –para la eliminación de memoria pedida a través del new-

Ejemplo C++, new y delete:

Nodo::~Nodo(){

cout<< “Se elimino nodo”;

delete sig;

}

Nodo* Nodo::creaNodo(Nodo* Nuevo){

Nuevo= new Nodo;

return Nuevo;

}

El anterior ejemplo es tomado de la implantación de una lista de caracteres. Mostrándose aquí las funciones Destructutor (~Nodo) y la función que retorna un Nodo nuevo

Compatibilidad de tipos entre variables

Un lenguaje de programación realiza un comprobación de los tipos de datos cuando el usuario define una asignación o simplemente en una operación aritmética o lógica.

Los lenguajes dinámicamente tipados (como Python) no necesariamente necesitan hacer validación de los tipos de datos en las asignaciones (auque hay que notar que al invocar las funciones Python utiliza un algoritmo de validación de tipos de datos), pero si en las operaciones.

Validación de tipos por nombre: C++ utiliza este tipo de comparación. Se basa en comparar los nombres de los tipos de datos involucrados en la comparación. Por lo general C++ utiliza el Casting (conversión a otro tipo de dato) para definir operaciones de asignación o expresiones lógicas o aritméticas, permitiendo hacer lo siguiente, sólo mostrando un warning:

int a;

//solo se toma la parte entera

a = 3.4;

Python, por su parte, hace uso de este tipo de validación para la invocación de funciones empotradas (built-ins) comprobando su tipo. Ejemplo que genera un error de tipo de dato:

>>> b = 0

>>> len(b)

Traceback (most recent call last):

File “<interactive input>”, line 1, in ?

TypeError: len() of unsized object

>>>

La validación de tipos por estructura consiste en verificar que se posea:

- Idéntica estructura pero con nombres distintos.

En este caso de validación se toman dos elementos compuestos y se compara cada sub-elemento y se garantiza que halla otro sub-elemento del mismo tipo (o con la misma estructura) en el otro elemento compuesto.

Referencias:

[1] Programming Language Comparison (Paper

of Jason Voegele)

[2] Learning Python, Second Edition. Published by

O’Reilly & Associates, Inc.,

[3] DAWSON, Michael. Python Programming for

the Absolute Beginner. Premier Press © 2003

Copyright © 2003 by Premier Press, a division

of Course Technology.

[4] KEOGH, Jim y GIANNINI, Mario. OOP

Demystified: A Self-Teaching Guide. McGraw-

Hill/Osborne © 2004

ISBN:0072253630.

[5] MITCHELL, John C. Concepts in Programming

Languages. Cambridge University Press ©

2003 (529 pages)

[6] OBASANJO, Dare. A Comparison Of

Microsoft’s C# Programming Language To Sun

Microsystems’ Java Programming Language.

2001.

[7] IGLESIAS CURTO, José Ignacio. VAQUERO

HERRERO, Juan. Comparación De

Características De Los Lenguajes De

Programación Java Y C#. Departamento de

Informática y Automática Universidad de

Salamanca. 2003.

[8] “Programming Ruby – The Pragmatic Programmer’s Guide”
Copyright © 2000 Addison Wesley Longman, Inc.

[9] “The Ruby Way”-Hal Fulton

Publisher : Sams Publishing