Resultados 1 al 4 de 4

Tema: Introducción a la programación estructurada. Capítulo 2

  1. #1  
    Moderador HH
    Fecha de ingreso
    Mar 2003
    Ubicación
    Galiza
    Mensajes
    3.916
    Descargas
    8
    Uploads
    1
    Introducción a la programación estructurada

    Capitulo 2: VARIABLES, CONSTANTES, FUNCIONES PREDEFINIDAS


    En el capitulo se tratarán las variables, constantes y funciones predefinidas básicas de Modula 2, y todo lo relacionado con ello, como pueden ser los tipos predefinidos, identificadores válidos...


    Variables:

    Es muy común que alguien que se acerca por primera vez a la programación, piense que las variables de programación son similares a las algebraicas. Ese es un gran problema, ya que aunque hay una similitud formal, las diferencias son muy grandes.

    Una variable algebraica representa valores simbólicos, que puede ser un valor cualquiera o un valor desconocido, pero una vez asociada esa variable a un valor, ese valor no puede modificarse. En cambio una variable en programación está más íntimamente ligada a la idea de contenedor, puede tener un valor “x” en una parte del código y un valor “y” en otra parte del código.

    La definición de variable para la mayoría de los autores estaba relacionada con una posición de memoria, pero yo me alejare de estas definiciones, ya que son muy especificáis y si las usamos nos estamos cerrando puertas restringiendo la definición.

    Un buen ejemplo que corrobora que la definición de variable como posición de memoria es un error es compararlo con las variables de un PIC (por ejemplo el 16F84), en donde las variables puras (es muy flexible y hay otras opciones) solo son 8 y se corresponden con 8 registros, además en los PICs el código y los datos están separados ya que siguen la arquitectura Hardbarg y no la Von Newman que impera en los PCs. Alguno pensara, pero ¿que dice este tío, si se está contradiciendo? Pues no, no me contradigo, ya que el concepto de memoria está muy ligado a la arquitectura Von Newman y además, como he dicho, en los PICs son 8 registros, no actúan como actúa una posición de memoria de un PC, por ejemplo. Además, hoy en día, incluso en el PC, la idea de variable como posición de memoria ya es muy débil, ya que la memoria virtual (en almacenamiento secundario, como el Disco Duro) y las caches (que son memorias asociativas de carga en paralelo y muchas veces dentro del propio procesador) hacen que realmente ese concepto de variable como posición de memoria no sea correcto.

    NOTA: Los procesadores actuales ya rara vez ejecutan código directo de la memoria (alguno incluso ya no puede), sino que lo que se ejecuta es el código que hay en la Cache, y cuando referenciamos posiciones de memoria no presentes en la cache, lo que se haces es desalojar una porción de la cache y cargar en ella una zona de la memoria RAM que incluya a la zona referenciada y a partir de lo cargado en las caches se procede a ejecución.

    Pero entonces ¿Qué es una variable? Una definición más correcta de variable y que coincide con la definición habitual de variable en los lenguajes imperativos es: “Una variable representa un valor almacenado, y que se puede conservar indefinidamente para ser usado tantas veces como se desee. Pero el valor de una variable se puede modificar en cualquier momento, y será el nuevo valor el que estará almacenado en ella a partir de entonces”.

    Las variables se designan mediante identificadores (o nombres). El identificador representa el valor almacenado en dicha variable. Los identificadores son elegidos por el programador atendiendo a ciertas reglas propias de cada lenguaje de programación en particular.

    Por otro lado, podemos encontrarnos con 2 tipos básicos de variables dependiendo del lenguaje, variables estáticas y variables dinámicas. Modula 2 no tiene variables dinámicas puras, por lo cual solo se mencionaran.

    Las variables estáticas son aquellas íntimamente ligadas a un tipo de datos (numérico, texto…) mientras que las variables dinámicas están ligadas al contenido, si en un momento contiene un número se comportaran como variables estáticas numéricas, pero en la siguientes instrucción puede cargarse un carácter y entonces esa variables pasara a comportarse como una variable estática de tipo carácter… Modula 2 básicamente utiliza variables estáticas, aunque hay forma de simular variables dinámicas, no es el propósito de este texto.

    Dentro de los lenguajes que utilizan variables estáticas (Modula 2, C, Pascal…) podemos diferencias aquellos fuertemente tipados (Modula 2) de los débilmente tipados (C). Modula 2 es un leguaje muy fuertemente tipado, lo que significa que no se pueden hacer operaciones entre variables de tipos distintos, por ejemplo no se pueden hacer directamente la suma de un carácter con un número entero. Eso no quiere decir que no se pueda hacer, simplemente que el lenguaje integra protecciones para que eso no pase como consecuencia de un fallo del programador, ya que si el programador quiere pues hay forma de hacerlo, como puede ser realizar la operación anterior usando la posición del carácter (con ORD()) para realizar la suma. En los lenguajes débilmente tipados no hay estas restricciones y se pueden hacer operaciones entre tipos sin haber hecho una conversión explicita. Esto suele deberse a que todos los tipos internamente son tratados como números, el clásico ejemplo es el lenguaje “C”.

    En cuanto a tipos de datos, en casi todos los lenguajes hay unos tipos básicos y unos tipos definidos por el programador. Y Modula2 no iba a ser la excepción, en Modula 2 hay unos tipos básicos (CHAR, INTEGER, CARDINAL y REAL) y tipos definidos (ARRAYS, Conjuntos, Registros…). Esto no es más que una adaptación de las leyes matemáticas a la informática, ya que en matemáticas no es lo mismo un número Real que un número Entero, o un número Natural y un Entero, solo por mencionar algunos ejemplos. Además hay que programar de alguna forma lenguaje humano dentro de binario, y de ahí surgen el tipo Carácter y sus derivados (STRINGS…).

    La gran diferencia entre las matemáticas y la informática es que mientras en matemáticas trabajar con números grandes (incluyo al infinito) o números terriblemente pequeños no tiene ningún problema, en la informática si, ya que las máquinas tienen unas restricciones, básicamente de hardware, por lo cual los tipos tienen limites dentro de los que podemos trabajar. Y no es que no se pueda trabajar con números muy grandes en un ordenador, por poner un ejemplo, sino que los tipos y operaciones básicas no pueden, pero hay forma de operar con números grandísimos, simplemente se trata de utilizar técnicas para simular esos números grandísimos con números mucho más pequeños. Y es que no hace falta una máquina capaz operar con número de 30 cifras para operar con números de 30 cifras, solo hace falta saber algo de matemáticas y saber programar para superar esa barrera.

    Tipos:
    Los tipos predefinidos básicos de Modula 2 son:

    -INTEGER

    -CARDINAL

    -REAL

    -CHAR

    El tipo STRING, al igual que en muchos otros lenguajes, como el C, no es un tipo primitivo sino un tipo especifico de ARRAY (por ahora llega que entendáis que un ARRAY es una agrupación de varios elementos del mismo tipo en un orden determinado. Por otro lado algo lógico, ya que las palabras, están compuestas de letras (sería más correcto de fonemas, pero no nos vetamos en berenjenales) siguiendo un orden determinado, esto último es realmente importante, porque por ejemplo SOPA y PASO son 2 palabras con las mismas letras, pero que representan conceptos muy distintos.

    En cuanto al tipo BOOLEAN, pues tampoco es un tipo predefinido, sino un tipo enumerado predefinido.

    Ahora paso a dar las características de cada tipo por separado:

    INTEGER

    Podemos decir que el tipo INTEGER se corresponde con los números enteros de matemáticas, con una sola limitación, no hay infinitos números. Solo existen en un determinado rango, rango determinado por la maquina y el compilador. Un procesador de 16 bits no puede trabajar con enteros que estén fuera del rango [-32768..0..32767] y uno de 32 bits en el rango de [-2147483648..0.2147483647]. Y como los compiladores general código máquina para un procesador determinado, pues si el compilador vuestro genera para procesadores de 16 bits tenéis que apañaros con el rango para procesadores de 16 bits, por eso se dice que depende también del compilador. Por desgracia, a excepción del XDS para Windows y el MOKA para Linux, la mayoría de los compiladores para Modula 2 son de 16 bits, como casi todas las versiones del FST. Como la mayoría de los compiladores aun compilan para 16 bits, pues a lo largo de los textos usare el rango de enteros de 16 bits.

    Si tenéis dudas de que rango es capaz de mostrar vuestro compilador no tenéis más que integrar este código en un programa y ya os lo da:


    WriteString(“Número máximo: “);

    WriteInt(MAX(INTEGER), 7);

    WriteLn;

    WriteString(“Número menor: “);

    WriteInt(MIN(INTEGER),7);

    WriteLn;

    Las funciones predefinidas “MAX(tipo)” y “MIN(tipo)” dan el valor más alto y más bajo del tipo pasado. Son funciones internas al lenguaje con lo cual podéis usarlas directamente sin tener que llamar a ninguna librería.

    Pero pasemos a partes serias, las operaciones básicas que podremos realizar con el tipo INTEGER. Básicamente son las operaciones básicas, valga la redundancia, de matemáticas para trabajo con enteros, y son:

    + Suma (Ej: a+b)

    - Resta (Ej: a-b)

    * Multiplicación (Ej: a*b)

    DIV División entera (Ej: a DIV b)

    MOD Resto de división (Ej: a MOD b)

    + Identidad de entero (Ej: +a) (un signo “+“ delante no cambia el valor de un número)

    - Cambio de signo (Ej: -a) (un signo “-“ delante cambia el signo del número)
    NOTA: no se pueden hacer divisiones por “0”, cuidado de que nunca se produzcan, producirían un error insalvable del programa, en cristiano, en el mejor de los casos el programa se cerraría, en el peor un pantallaza azul de Windows. Tampoco se puede pasar del rango (ni por abajo ni por arriba).

    CARDINAL

    Este tipo es el equivalente a los números naturales de matemáticas (de cero a infinito), pero como siempre en programación, aquí hay unos limintes:

    [0..65535] en caso de 16 bits.

    [0..4294967295] en caso de 32 bits.

    Por lo demás es igual al INTEGER, tanto es así que en este caso se produce la única excepción que tiene Modula2, las variables INTEGER Y CARDINAL se pueden mezclar en operaciones, eso sí, teniendo en cuenta los rangos del tipo de cada variable. No se pueden introducir valores negativos en variables CARDINAL, ni valores fuera de rango en las INTEGER. Y es que los tipos CARDINAL e INTEGER realmente son 2 versiones del mismo tipo, los números enteros con y sin signo.

    REAL

    El tipo REAL es el encargado de trabajar con números reales (Ej: 4,56), tanto positivos como negativos. El de REAL de Modula 2 internamente utiliza el formato de 32bits definido por el IEEE.

    Un punto muy importante cuando trabajamos con variables tipo REAL es que la precisión no es exacta y no es un tipo cardinal (la representación interna no respecta que para que uno valla delante de otro sea menor).

    Su rango más habitual es:

    [-3.4E+38 .. -1.2E-38] para números negativos.

    [1.2E-38 .. +3.4E+38] para números positivos.

    Otro punto importante: 5 y 5.0 no son representan al mismo número. El primero es un INTEGER o CARDINAL y el segundo un REAL. Cuando trabajéis con números reales no os olvidéis nunca de ponerle parte fraccionaria, aunque esta sea cero (“0”).

    Las operaciones asociadas al tipo REAL también son diferentes a las de los tipos INTEGER y CARDINAL:

    + Suma (Ej: a+b)

    - Resta (Ej: a-b)

    * Multiplicación (Ej: a*b)

    / División real (Ej: a/b)

    + Identidad de entero (Ej: +a) (un signo “+“ delante no cambia el valor de un número)

    - Cambio de signo (Ej: -a) (un signo “-“ delante cambia el signo del número)
    NOTA: En algunos compiladores el tipo real se denomina FLOAT, porque este nombre es el más usado en los distintos lenguajes.

    Un Ejemplo de que los reales que usan los computadores no son exactos sino aproximaciones puede ser:

    3.3333332538604736E+0=10.0/3.0

    Este ejemplo es muy usado porque es donde patinaban los Pentium Originales, que no daban este valor, sino uno muy similar cambiando uno de los últimos decimales.

    CHAR

    El tipo CHAR es el equivalente a las letras, aunque en su formato digital, en este caso son los caracteres de la tabla ASCII (me han dicho que actualmente hay algún compilador que trabaja con UNICODE, pero supongo que será alguna características introducida cuando se estandarizo el lenguaje Modula 2 por el ISO). Aun así, hay algún computador donde esto no es así, ya que el compilador para este tipo recurre siempre al SO. En concreto se dice que ciertos compiladores de Mainframes y Minicomputadoras que incluyen (o incluyeron) este lenguaje no usan el ASCII, pero no creo que ninguno de vosotros tenga problemas con eso, y la única diferencia es el cambio de posición de los símbolos de la tabla, no los símbolos en si mismo.

    Una particularidad de Modula 2, que es una de las características que más lo diferencian de C/C++, es que en Modula 2 los caracteres son caracteres y no se comportan como números, algo que en C no es así, ya que en C realmente todos los tipos son números, incluso los bolean y los char, lo que cambia es la representación. Por lo anterior, en Modula no se pueden utilizar directamente operaciones de enteros sobre el tipo CHAR, antes hay que cambiarlo a su valor ordinal con la función “ORD(“carácter”);”. Por otro lado, también podemos obtener el carácter correspondiente a una posición (entero) con la ord “CHR(Número);”. Puede decirse que son operaciones opuestas ya que:

    “C”=CHR(ORD(“C”));

    x=ORD(CHR(x));
    Hay otros tipos que aunque son basicos, no se consideran como tal ya que no pueden ser tratados por el procesador directamente, porque no coinciden con los tipos que el puede operar directamente. Los principales son LONGINT (Un Entero con un rango mayor que el INTEGER) y LONGREAL (Un Real con un rango mayor que el REAL). Todo lo dicho para el tipo INTEGER (LONGINT) y REAL (LONGREAL) es igual para los tipos largos (o grandes). Las funciones que trabajan con estos tipos estan en las mismas librerias que las de los tipos basicos, por ejemplo, el equivalenet al WriteInt es WriteLongInt, y el de ReadReal es ReadLongReal. Seguire los criterios de la mayoria de los autores de manuales de Modula 2 y no explicare nada mas sobre ellos, aunque con lo dicho llega. Cualquier duda me consultais.

    Conversiones entre tipos:

    Aparte de las ya vistas CHR y ORD, existen las funciones FLOAT y TRUNC.

    FLOAT transforma un número INTEGER o CARDINAL en el número REAL más próximo (recordad lo dicho sobre la precisión de los REAL). Ej:

    45.0=FLOAT(45)

    TRUNC convierte un número REAL en un número INTEGER/CARDINAL, truncando la parte entera del número (puede depender del compilador ya que algunos toman directamente la parte entera y en cambio otros realizan una aproximación al entero más proximo. Ej:

    -10=TRUNC(-10.5)

    ORD no devuelve la posición de un carácter, dicho valor se puede utilizar como si fuese un CARDINAL/INTEGER.

    CHR convierte un CARDINAL en su equivalente, por posición en la tabla, CHAR.

    Funciones de consola de los tipos básicos:

    De poco nos servirían los lenguajes de programación si no fuesen interactivos (que permiten operar con el usuario del programa). Para ello tienen que disponer de funciones para poder obtener datos desde el teclado y funciones para sacarlos por la pantalla. El teclado y la pantalla son los dispositivos estándar, pero pueden ser redirecionados a otros medios, por ejemplo un archivo, un puerto, etc.

    En Modula 2, las funciones para trabajar con los tipos estándar no forman parte del lenguaje directamente, sino que están incluidas dentro de las librerías estándar que todo compilador debe llevar, además hay posibilidad de generar nuestras propias funciones y no tener que utilizar las básicas, algo habitual cuando se realizan proyectos de cierta envergadura.

    Por otro lado, por cada tipo hay una función para capturar el valor del teclado y otra para presentar el valor en pantalla.

    En Modula 2, las funciones para trabajar con los tipos estándar no están todas en la misma librería, sino que las del tipo INTEGER, CARDINAL y CHAR (entre otras) están en la librería InOut, mientras que las equivalente para el tipo REAL están en la biblioteca RealInOut. Esto tiene una explicación simple, los tipos INTEGER, CARDINAL y CHAR son tipos ordinales (su valor depende de la posición en la tabla de valores, solo hay un mayor de todos los menores del un valor y un menor de todos los mayores de un valor). En cambio los tipo REAL, por lo comentado antes, no es un tipo ORDINAL.

    Para poder utilizar estas funciones hay que declararlas en la parte declarativa del programa, ejemplo:

    FROM InOut IMPORT WriteInt, WriteCard;

    FROM RealInOut IMPORT WriteReal;
    Hay otra posible declaración, aunque es menos utilizada para este tipo de funciones:

    IMPORT InOut.WriteInt, InOut.WriteCard;

    IMPORT RealInOut.WriteReal;
    Esta segunda formula de declaración es más usada para cuando llamamos módulos propios, o funciones de librerías no estándar. Su ventaja es que siempre tendremos claros en donde está declarada tal o cual función, mejorando la legibilidad del código. Aun así creo que no es demasiado utilizada.

    Aunque se pueden declarar todas las funciones de una libreria y muchas librerias, lo recomendable es solo declarar las que se utilicen.

    WriteInt(valor de tipo INTEGER, espacios reservados)

    WriteInt es la funcion encargada de sacar por pantalla valores INTEGER, tanto da literales como variables, ademas tambien se encarga de la presentacion de ese valor. Si en espacios reservados poner un 10 por ejemplo, lo que estamos haciendo es escribir el numero de izquierda a derecha dejando espacios en blanco hasta un total de 10 cifras:WriteInt(10,10)= ¬¬¬¬¬¬¬¬10, donde "¬" representa un espacio en blanco. Esta funcion pertenece a la libreria InOut.

    NOTA: Los literales son valores escritos directamente, por ejemplo 10, es un literal de un INTEGER o CARDINAL. En cristiano, cuando escribimos un numero o un caracter que participa en operaciones aritmeticologicas.

    WriteCard(valor de tipo CARDINAL, espacios reservados)

    WriteCard es similar al WriteInt con la diferencia de que WriteCard es para trabajar con valores CARDINALES, por lo demas lo dicho para WriteInt es correcto para WriteCard.

    WriteReal(valor de tipo REAL, espacios reservados)

    WriteReal es la funcion encargada de sacar por pantalla valores REAL, tanto literales como variables, y al igual que las anteriores tambien se encarga de la presentacion del numero. Ejemplo: WriteReal(1,10)=0.1000E+01. Pertenece a la libreria RealInOut.

    Write(valor de tipo CHAR)

    Write es la funcion para la salida de caracteres a pantalla, tanto literales como funciones. A diferencia de las anteriores, saca el valor directamente, no tiene funcion de presentacion, aunque es logico, ya que mientras que los valores numericos pueden ser de un numero de cifras desconocido en el momento de realizar el programa, los caracteres siempre son 1 solo caracter por cada funcion Write que hagamos. Pertenece a la libreria InOut. Hay dos formas de poner literales:

    Write("*");

    Write('*');
    Aunque por logica deberia pasar a las funciones de lectura desde teclado, voy a mencionar otras 2 funciones pertenecientes a la libreria InOut, ya mencionadas en el capitulo pasado: WriteString() y WriteLn. Os remito al capitulo anterior. Solo decir que WriteString se utiliza para imprimir varibles tipo STRING y literales tipo STRING, pero ese tipo de variables las daremos mas alante, con los ARRAYS, un ejemplo es «WriteString("Hola");». WriteLn se utiliza para hacer un salto de linea en la pantalla.
    ReadInt(Variable INTEGER)
    La funcion ReadInt, de la libreria InOut, es la encargada de capturar valores INTEGER del teclado.
    ReadCard(Variable CARDINAL)
    La funcion ReadCard, de la libreria InOut, es la encargada de capturar valores CARDINAL del teclado.
    ReadReal(Variable REAL)
    La funcion ReadReal, de la libreria RealInOut, es la encargada de capturar valores REAL del teclado.
    Antes de seguir, hay que mencionar algo muy importante relativo a esas funciones (ReadInt, ReadCard y ReadReal), y es que lee los caracteres introducidos hasta el primer caracter valido del tipo que quiere leer, sigue leyendo hasta el primer caracer invalido para el tipo que esta leyendo, hace la combersion de ese valor y devuelve a la variable correspondiente. Pero mejor un ejemplo para que lo entendais:
    ¬¬a¬4/6¬¬8
    Pues en este ejemplo, si la llamada fuese un ReadInt, lo que cogeria seria 4, porque hasta el 4 hay espacios y letras que ignora, y despues del 4 hay un caracter ("/") que tambien ingnora y da por terminada la lectura. Esta peculiaridad de estas funciones provablemente se deba a que el usuario del programa, muchas veces no tiene cuidado con lo que escribe y el programador no puede tener en cuenta todas las opciones posibles, con lo cual el propio lenguaje ya incorpora ciertas medidas de seguridad.
    Read(Variable CHAR)
    La funcion Read, de la libreria InOut, lee el primer caracter introducido desde la anterior posicion del cursor, y es el valor qeu devuelve. Cualquier caracter es valido, incluidos letras, numeros, signos de puntuacion.... Un Ejemplo puede ser:
    a.t srs2
    En este caso la funcion Read devolveria el caracter "a", ya que es el primer caracter introducido.
    Constantes:
    Podemos definir constantes como un valor fijo que se utiliza en un programa y no cambia de una ejecucion a otra. Hay 2 formas basicas de constantes: los literales y las declaradas. Nos centramos en las constantes declaradas, que no son mas que dar un identificador a un valor fijo. Una vez declarada una constante, puede ser utilizada a lo largo del programa utilizando su nombre como si se tratase de un literal. Precisamente ahi radica la ventaja de su utilizacion, ya que con este metodo tenemos asegurado que a lo largo del programa ese valor no sera modificado, y si queremos modificarlo, solo tenemos que modificar la definicion y no tenemos que preocuparnos por cambiar un monton de literales. Un ejemplo que suele usarse para demostrar su utilidad, es la de declarar una constante con el valor PI (3.14159265), aunque tambien es muy utilizada la constante de Euler y otras muchas. Ademas declarar constantes es una muy buena estrategia de programacion. Las constantes, al igual que cualquier literal, aunque no se declaren con tipo, lo tienen implicito, es un detalle que hay que tener en cuenta siempre. Un ejemplo de definicion de constantes es el siguiente:
    CONST
    E = 2.718281828459; (*Se podria haber decladado en una sola linea, pero asi se mejora la legibilidad del codigo*)
    PI = 3.14159265;
    Como puede apreciarse, la declaracion va precedida de la etiqueta CONST que indica que a partir de ahi se van a declarar constantes. Ademas las declaraciones de constantes tienen que hacerse en la parte declarativa de los modulos o procedimientos.
    Para terminar con las constantes, solo repetir algo ya dicho, declarar constantes es una muy buena politica de programacion, incluso voy mas alla, parafraseando a un profesor que tuve en el ciclo superior de electronica: "Los buenos programadores saben de la importancia de la utilizacion de las constantes, por eso las utilizan mucho, si no utilizas constantes, probablemente sea un programodor pesimo, aunque hayas programdo un PhotoShop". Que significa lo anterior, que las constantes no son obligatorias normalmente, pero deben usarse, es mejor pecar de un exceso de declaracion de constantes que una falta de su utilizacion.
    Identificadores:
    Cuando definimos Variables, Constantes, Funciones... siempre tenemos que darles un nombre, ese nombre es lo que se conoce como Identificador y al acto se llama definicion o declaracion.
    Modula 2 sigue los criterios mas usualmente usados en lo referente a los identificadores, criterios normalmente utilizados por la mayoria de los lenguajes. Esos criterios son:
    -Deben comenzar con una letra obligatoriamente.
    -Puede ser una letra o una letra seguida de otras letras o numeros.
    -Sin espacios en blanco.
    -Pueden suarse las 52 letras (52 entre mayusculas y minusculas) del alfabeto ingles y los digitos del 0 al 9.
    -Modula 2 es case sensitive, lo que significa que distingue entre mayusculas y minusculas, no son lo mismo: Hola, hola, HOLA...
    -No se pueden usar las letras ñ, Ñ o las vocales acentuadas. Estos caracteres solo pueden estar incluidos dentro de varibles CHAR o STRING.
    -No pueden usarse palabras clave o predefinidas del lenguaje Modula 2, como pueden ser BEGIN, END, MODULE...
    Por lo demas, casi todas las demas construcciones son admisibles, aunque hay que tener en cuenta unas normas basicas de diseño, que mas que nada sirven para mejorar la legibilidad del codigo, por ejemplo, no deben usarse identificadores de un tamaño esceciso, como podria ser el siguiente: "VariableEnteraQueUsoComoContador", que muy bien, es muy descritivo y todo lo que se quiera, pero, por Dios, hay formas de, manteniendo la misma informacion, definir un identificador mas corto e igualmente legible, como puede ser "IntContador", ademas este identificador cumpliria las recomendaciones de MicroSoft suele recomendar y que suele denominarse Notacion Hungara, en honor a un programador ya fallecido de MicroSoft.
    Palabras Clave:
    Las palabras clave son aquellas utilizadas para determinar las construcciones del lenguaje Modula 2 y son:
    AND, ARRARY, BEGIN, BY, CASE, CONST, DEFINITION, DIV, DO, ELSE, ELSIF, END, EXIT, EXPORT, FOR, FROM, IF, IMPLEMENTATION, IMPORT, IN, LOOP, MOD, MODULE, NOT, OF, OR, POINTER, P ROCEDURE, QUALIFIED, RECORD, REPEAT, RETURN, SET, THEN, TO, TYPE, UNTIL, VAR, WHILE, WITH.
    Identificadores Predefinidos:
    En Modula 2, al igual que otros muchos lenguajes, tiene elementos de uso tan frecuente que se ha considerado conveniente tenerlos disponibles en cualqueir porograma sin necesidad de declararlos explicitamente. El compilador reconoce una serie de indentificadores predefinidos. La lista completa es:
    ABS, BITSET, BOOLEAN, CAP, CARDINAL, CHAR, CHR, DEC, EXCL, FALSE, FLOAT, HALT, HIGH, INC, INCL, INTEGER, LONGINT, LONGREAL, MAX, MIN, NIL, ODD, ORD, PROC, REAL, SIZE, TRUE, TRUNC, VAL.
    Bueno, con identificadores predefinidos llegue al final deste tema, el proximo tratara de las estructuras de control y repeticion del lenguaje Modula 2. Alguno echara en falta que no haya tocado nada de C/C++ como hice en el tema anterior, y en verdad si que lo habia puesto, pero complico el tema mucho mas de lo deseable y decidi borrar esos elementos, ademas de reescribir una parte (especialmente las refentes a funciones basicas). Es posible que haga un pequeño apendice del tema con las equivalencias a C/C++, pero no prometo nada.

    Hasta la proxima.
    iberhack@gmail.com
    He conocido muchos dioses. Quien niegue su existencia está tan ciego como el que confía en ellos con una fe desmesurada. Robert E. Howard
    La suerte ayuda a la mente preparada.
    Citar  
     

  2. #2  
    Iniciado
    Fecha de ingreso
    Jul 2007
    Ubicación
    En la playa :)
    Mensajes
    48
    Descargas
    0
    Uploads
    0
    Muy bueno el tutorial, espero que pongas el apendice para aprender C, C++, hay algun programa para programar en Modula 2 para OS X?.
    Aquello que no ha sido elegido por no nostros no podemos considerarlo ni como merito ni como fracaso.
    Citar  
     

  3. #3  
    Iniciado
    Fecha de ingreso
    Nov 2007
    Mensajes
    1
    Descargas
    0
    Uploads
    0
    Me parece muy bue material el que dictas habra algun libro donde ampliar los conceptos
    Citar  
     

  4. #4  
    Colaborador HH
    Fecha de ingreso
    Jun 2006
    Ubicación
    Uruguay
    Mensajes
    1.450
    Descargas
    11
    Uploads
    0
    surfman, eso de "programa para programar" se llama IDE - entorno de desarrollo -
    Y en realidad lo único que hace es colorear los comandos y las palabras reservadas, para que quede más lindo y entendible.
    ahh y te trae un boton para compilar todo junto sin comandos eso sí es bueno..
    Pero.. podés programar en modula con el block de notas o con gedit

    Para MAC no hay compilador pero sí para GNU/Linux, son compatibles los binarios ? en freebsd sí :S

    Aqui podes bajarte todo http://www.excelsior-usa.com/xdsdl.html

    ---
    k3nsh1n, existe un libro llamdo "Programming in Modula2", escrito por Wirth, pero usa el estandar pim en ese libro

    Saludos,
    Cypress
    Última edición por Cypress; 11-11-2007 a las 04:40
    Louis Armstrong le dice a Ella Fitzgerald
    "take another drink of wine, and maybe you change your mind"
    Citar  
     

Marcadores
Marcadores
Permisos de publicación
  • No puedes crear nuevos temas
  • No puedes responder temas
  • No puedes subir archivos adjuntos
  • No puedes editar tus mensajes
  •