Ciencias de la Computación FAMAF

Herramientas de usuario

Herramientas del sitio

Traza:
algo1:2010-1:taller

Diferencias

Muestra las diferencias entre dos versiones de la página.

Enlace a la vista de comparación

Ambos lados, revisión anteriorRevisión previa
Próxima revisión		Revisión previa
algo1:2010-1:taller [2010/04/21 18:59] – francolqalgo1:2010-1:taller [2018/08/10 03:03] (actual) – editor externo 127.0.0.1
Línea 17: Línea 17:
     fac (n+1) = (n+1) * fac n     fac (n+1) = (n+1) * fac n
  
-    len :: [a] -> Int                                                                                +    len :: [a] -> Int 
-    len [] = 0                                                                                       +    len [] = 0 
-    len (_:xs) = 1 + length xs                                                                      +    len (_:xs) = 1 + length xs
  
 Vimos cómo abrir el intérprete de Haskell y cómo crear, editar y cargar archivos de definiciones. Vimos cómo abrir el intérprete de Haskell y cómo crear, editar y cargar archivos de definiciones.
Línea 331: Línea 331:
  
  
-/* +===== 5 de mayo de 2010 ===== 
-===== 16 de marzo de 2010 =====+==== Introducción al Lenguaje C ====
  
-Repaso:+=== Hola Mundo ===
  
-  *  Grafiquito con conceptos.+El programa "Hola Mundo" es una forma típica de presentar un lenguaje de programación. 
 +Este programa muestra cómo hacer para imprimir en pantalla un mensaje que diga "Hola mundo!".
  
-Mas tipos y clases:+**hola.c**:
  
-  * Definición de max polimórfica, y uso con Color. +  #include <stdio.h> 
-  * "deriving" (de Eq, Show, Ord, etc.). +   
-  * Otras clases: Show, Bounded.+  int main() { 
 +    printf("Hola mundo!\n"); 
 +   
 +    return 0; 
 +  }
  
-===== 17 de marzo de 2010 ===== 
  
-  * Tipos compuestos (data Point a = Pt a a) +=== El Compilador de C: GCC === 
-  * Tipos recursivos (data Tree a = Leaf a | Branch (Tree a) (Tree a) )+ 
 +El lenguaje C es un [[http://es.wikipedia.org/wiki/Lenguaje_compilado|lenguaje compilado]]. 
 +Para usar los programas, primero hay que compilarlos usando un programa especial, el **compilador** que traduce el código en un archivo ejecutable. 
 +En esta materia vamos a usar el compilador GCC (GNU Compiler Collection), que se invoca a través del comando "gcc". 
 +Para compilar el programa "hola.c" ejecutamos el siguiente comando: 
 + 
 +  gcc -Wall -pedantic -ansi hola.c -o hola 
 + 
 +Las opciones "-Wall -pedantic -ansi" le indican al compilador que nos dé la mayor cantidad de advertencias y errores posibles sobre nuestro código. 
 +La opción "-o hola" le indica al compilador que el archivo ejecutable de salida debe llamarse "hola". 
 +Para ejecutar el archivo hacemos: 
 + 
 +  ./hola 
 + 
 + 
 +=== Entrada/Salida === 
 + 
 +Para interactuar con el usuario usaremos las funciones "printf" y "scanf" provistas por la librería "stdio.h". 
 +Por ejemplo, el siguiente programa le pide al usuario que ingrese dos números, y luego imprime la suma de ambos: 
 + 
 +**es.c**: 
 + 
 +  #include <stdio.h> 
 +   
 +  int main(void) { 
 +    int a, b; 
 +   
 +    printf("Ingrese los numeros a sumar:\n"); 
 +   
 +    scanf("%i", &a); 
 +    scanf("%i", &b); 
 +   
 +    printf("La suma da %i gracias por preguntar.\n", a + b); 
 +   
 +    return 0; 
 +  } 
 + 
 + 
 +=== Asignación y Condicional (if) === 
 + 
 +La asignación sirve para guardar en una variable el resultado del cálculo de una expresión. 
 +En general una asignación tiene la forma 
 + 
 +  <var> = <expr> 
 + 
 +a dónde <var> es una variable y <expr> es una expresión. 
 + 
 +El condicional sirve para ejecutar un bloque de código sólo en caso de que se cumpla determinada condición o guarda. 
 +En general un condicional tiene la forma 
 + 
 +  if (<expr>) { 
 +    <codigo> 
 +  } 
 + 
 +a dónde <expr> es una expresión booleana y <codigo> es el bloque de código que queremos ejecutar en caso de que la guarda se cumpla. 
 +También existe una cláusula "else" que se ejecuta si la guarda es falsa: 
 + 
 +  if (<expr>) { 
 +    <codigo> 
 +  } else { 
 +    <codigo> 
 +  } 
 + 
 +"if" y "else se pueden combinar para escribir un "if" multiguarda parecido a los análisis por caso de Haskell: 
 + 
 +  if (<expr>) { 
 +    <codigo> 
 +  } else if (<expr>){ 
 +    <codigo> 
 +  ... 
 +  } else { 
 +    <codigo> 
 +  } 
 + 
 +El siguiente código es un ejemplo de uso de la asignación y del if. 
 +El programa pide al usuario que ingrese dos números. 
 +Si el segundo número es cero, da un error. 
 +Si no, calcula el cociente y el resto de la división y guarda los resultados en las variables q y r, y luego imprime los resultados. 
 + 
 +**if.c**: 
 + 
 +  #include <stdio.h> 
 +   
 +  int main(void) { 
 +    int a, b, q, r; 
 +   
 +    printf("Ingrese los numeros a dividir:\n"); 
 +   
 +    scanf("%i", &a); 
 +    scanf("%i", &b); 
 +   
 +    if (b == 0) { 
 +      printf("Error: no puedo dividir por cero.\n"); 
 +      return 1; 
 +    } 
 +   
 +    q = a / b; 
 +    r = a % b; 
 +   
 +    printf("La division da %i con resto %i.\n", q, r); 
 +   
 +    return 0; 
 +  } 
 + 
 + 
 +=== Repetición (while) === 
 + 
 +La repetición sirve para ejecutar un bloque de código una y otra vez hasta que determinada condición o guarda se haga falsa. 
 +En general una repetición tiene la forma 
 + 
 +  while (<expr>) { 
 +    <codigo> 
 +  } 
 + 
 +a dónde <expr> es una expresión booleana y <codigo> es el bloque de código que queremos ejecutar repetidamente hasta que la guarda se haga falsa. 
 + 
 +El siguiente código es un ejemplo de uso del while. 
 +Es una modificación del ejemplo de la sección anterior en el que se calculan cociente y resto de la división. 
 +El programa pide al usuario que ingrese dos números, pero esta vez pide repetidamente que ingrese el 2do número hasta que éste sea distinto de cero. 
 + 
 +**while.c**: 
 + 
 +  #include <stdio.h> 
 +   
 +  int main(void) { 
 +    int a, b, q, r; 
 +   
 +    printf("Ingrese los numeros a dividir:\n"); 
 +   
 +    scanf("%i", &a); 
 +    scanf("%i", &b); 
 +   
 +    while (b == 0) { 
 +      printf("Error: no puedo dividir por cero.\n"); 
 +      printf("Ingrese el divisor de nuevo: "); 
 +      scanf("%i", &b); 
 +    } 
 +   
 +    q = a / b; 
 +    r = a % b; 
 +   
 +    printf("La division da %i con resto %i.\n", q, r); 
 +   
 +    return 0; 
 +  } 
 + 
 + 
 +=== Funciones y Procedimientos === 
 + 
 +Las funciones sirven para separar un bloque de código que realiza una tarea determinada, de manera que pueda ser ejecutado varias veces con diferentes parámetros. 
 + 
 +Las funciones tiene un nombre, una aridad y un cuerpo. La aridad es la cantidad y tipo de parámetros que toma, y el tipo de valor que devuelve como resultado. 
 +En general una función tiene la forma 
 + 
 +  <tipo_resultado> <nombre>(<parametros>) { 
 +     
 +    <cuerpo> 
 +   
 +    return <expr>; 
 +  } 
 + 
 +a donde: 
 + 
 +  * <tipo_resultado> puede ser un tipo ("int", "char", etc.) o puede ser "void", que quiere decir que la función no devuelve nada; 
 +  * <nombre> es el nombre que le queremos dar a la función; 
 +  * <parametros> es una secuencia de la forma <tipo1> <nombre1>, ..., <tipon> <nombren>, que dice el tipo de cada parámetro y el nombre que le queremos dar; 
 +  * <cuerpo> es el bloque de código que ejecuta la función; 
 +  * "return <expr>" es la instrucción que indica el valor que devuelve la función (si <tipo_resultado> es "void", esta instrucción no hace falta). 
 + 
 +La función **main** del programa "Hola Mundo" es un claro ejemplo de función: 
 + 
 +  int main() { 
 +    printf("Hola mundo!\n"); 
 +   
 +    return 0; 
 +  } 
 + 
 +En este caso, la función no toma ningún parámetro y devuelve un valor de tipo int. 
 + 
 +El siguiente código es otro ejemplo de uso de las funciones. 
 +Es una modificación del ejemplo de la sección anterior en el que se calculan cociente y resto de la división. 
 +En este caso, definiremos una función para el código que pide al usuario que ingrese un número, y la utilizaremos dos veces, una para el dividendo y otra para el divisor. 
 +Además, definiremos una función para el cálculo del cociente y el resto. 
 + 
 +**func.c** 
 + 
 +  #include <stdio.h> 
 +   
 +  int leer_int(char* mensaje); 
 +  int dividir(int x, int y, int* z); 
 +   
 +  int main(void) { 
 +    int a, b, q, r; 
 +   
 +    a = leer_int("Ingrese el dividendo: "); 
 +    b = leer_int("Ingrese el divisor: "); 
 +    while (b == 0) { 
 +      printf("Error: no puedo dividir por cero.\n"); 
 +      b = leer_int("Ingrese el divisor de nuevo: "); 
 +    } 
 +   
 +    q = dividir(a, b, &r); 
 +   
 +    printf("La division da %i con resto %i.\n", q, r); 
 +   
 +    return 0; 
 +  } 
 +   
 +  int leer_int(char* mensaje) { 
 +    int x; 
 +     
 +    printf(mensaje); 
 +    scanf("%i", &x); 
 +     
 +    return x; 
 +  } 
 +   
 +  int dividir(int x, int y, int* z) { 
 +    int w; 
 +     
 +    w = x / y; 
 +    *z = x % y; 
 +     
 +    return w; 
 +  } 
 + 
 +===== 12 de mayo de 2010 ===== 
 + 
 +==== Traducción del Lenguaje Imperativo Teórico al Lenguaje C ==== 
 + 
 +=== Asignación === 
 + 
 +La asignación múltiple 
 + 
 +  x1, ..., xn := E1, ..., En 
 + 
 +se traduce a C como la secuencia de asignaciones simples 
 + 
 +  x1 = E1; 
 +  x2 = E2; 
 +  ... 
 +  xn = En 
 + 
 +Para garantizar que esta traducción es correcta, en cada expresión Ei sólo pueden aparecer variables xj con j >= i. 
 + 
 + 
 +=== Condicional === 
 + 
 +El condicional 
 + 
 +  if B0 -> S0 
 +  [] B1 -> S1 
 +  ... 
 +  [] Bn -> Sn 
 +  fi 
 + 
 +se traduce a C como 
 + 
 +  if (B0) { 
 +    S0; 
 +  } else if (B1) { 
 +    S1; 
 +  ... 
 +  } else if (Bn) { 
 +    Sn; 
 +  } 
 + 
 + 
 +=== Repetición === 
 + 
 +La repetición con una sola guarda 
 + 
 +  do B -> S od 
 + 
 +se traduce a C como 
 + 
 +  while (B) { 
 +    S; 
 +  } 
 + 
 +La repetición multiguarda 
 + 
 +  do B0 -> S0 
 +  [] B1 -> S1 
 +  ... 
 +  [] Bn -> Sn 
 +  od 
 + 
 +se traduce primero a una repetición con una sola guarda con un if adentro 
 + 
 +  do B0 v B1 v ... v Bn -> 
 +    if B0 -> S0 
 +    [] B1 -> S1 
 +    ... 
 +    [] Bn -> Sn 
 +    fi 
 +  od 
 + 
 +y luego se traduce a C con las reglas ya vistas, obteniendo 
 + 
 +  while (B0 || B1 || ... || Bn) { 
 +    if (B0) { 
 +      S0; 
 +    } else if (B1) { 
 +      S1; 
 +    ... 
 +    } else if (Bn) { 
 +      Sn; 
 +    } 
 +  } 
 + 
 + 
 +===== 2 de junio de 2010 ===== 
 + 
 +==== Tipos de Datos ==== 
 + 
 +Falta completar. Ver los siguientes enlaces, tomados de [[http://www.space.unibe.ch/comp_doc/c_manual/C/cref.html|"C Programming Reference"]]. Está en inglés pero leyendo el código se puede llegar a entender. 
 + 
 +  * **Tipos Básicos**: [[http://www.space.unibe.ch/comp_doc/c_manual/C/CONCEPT/data_types.html]]. 
 +  * **Enumeraciones**: [[http://www.space.unibe.ch/comp_doc/c_manual/C/SYNTAX/enum.html]]. 
 +  * **Estructuras**: [[http://www.space.unibe.ch/comp_doc/c_manual/C/SYNTAX/struct.html]]. 
 +  * **Definiciones de tipos**: [[http://www.space.unibe.ch/comp_doc/c_manual/C/SYNTAX/typedef.html]] 
 + 
 +==== Arreglos ==== 
 + 
 +**arreglo.c** 
 +  #include <stdio.h> 
 +   
 +  #define TAM 10 
 +   
 +  int main() { 
 +    int arreglo[TAM], i; 
 +   
 +    i = 0; 
 +    while (i < TAM) { 
 +      printf("Ingrese el %i-esimo valor: ", i); 
 +      scanf("%i", &arreglo[i]); 
 +      i = i + 1; 
 +    } 
 +   
 +    i = 0; 
 +    while (i < TAM) { 
 +      printf("%i\n", arreglo[i]); 
 +      i = i + 1; 
 +    } 
 +   
 +    return 0; 
 +  } 
 + 
 + 
 +==== TADs ==== 
 + 
 +=== El TAD Pila de Enteros === 
 + 
 +**booleano.h** 
 +  typedef enum {False, True} booleano; 
 + 
 +**pila.h** 
 +  #include "booleano.h" 
 +   
 +  #define LARGO_MAX 40 
 +   
 +  struct spila { 
 +      int a[LARGO_MAX]; 
 +      int largo; 
 +  }; 
 +   
 +  typedef struct spila pila; 
 +   
 +  pila pila_vacia(); 
 +   
 +  booleano es_vacia(pila p); 
 +   
 +  pila push(pila p, int e); 
 +   
 +  pila pop(pila p); 
 +   
 +  int top(pila p); 
 + 
 + 
 +**pila.c** 
 +  #include "pila.h" 
 +   
 +  pila pila_vacia() { 
 +    pila p; 
 +    p.largo = 0; 
 +    return p; 
 +  } 
 +   
 +  booleano es_vacia(pila p) { 
 +    booleano b; 
 +     
 +    if (p.largo == 0) { 
 +      b = True; 
 +    } else { 
 +      b = False; 
 +    } 
 +    return b; 
 +  } 
 +   
 +  pila push(pila p, int e) { 
 +    p.a[p.largo] = e; 
 +    p.largo = p.largo + 1; 
 +   
 +  pila pop(pila p) { 
 +    p.largo = p.largo - 1; 
 +    return p; 
 +  } 
 +   
 +  int top(pila p) { 
 +    return p.a[p.largo-1]; 
 +  } 
 + 
 +Se compila con  
 + 
 +  gcc -c -Wall -ansi -pedantic pila.c -o pila.o 
 + 
 + 
 +=== Usando el TAD Pila de Enteros === 
 + 
 +**main.c** 
 +  #include <stdio.h> 
 +  #include "pila.h" 
 +   
 +  int main() { 
 +    pila p1; 
 +     
 +    p1 = pila_vacia(); 
 +    p1 = push(p1, 25); 
 +    p1 = push(p1, 34); 
 +    p1 = push(p1, 1); 
 +    p1 = push(p1, 2); 
 +     
 +    while (!es_vacia(p1)) { 
 +      printf("El tope de la pila es %i\n", top(p1)); 
 +      p1 = pop(p1); 
 +    } 
 +   
 +    return 0; 
 +  } 
 + 
 +Se compila el módulo main.o con  
 + 
 +  gcc -c -Wall -ansi -pedantic main.c -o main.o 
 + 
 + 
 +Se obtiene el ejecutable con 
 + 
 +  gcc main.o pila.o -o main 
 + 
 + 
 +===== Apéndice ===== 
 + 
 +==== Strings ==== 
 + 
 +Los strings en C son simplemente arreglos de caracteres, con la única particularidad de que el final del string se marca con un caracter especial '\0'. 
 +De esta manera podemos tener en un arreglo de caracteres un string más corto que la cantidad de elementos del arreglo. 
 + 
 +El siguiente código muestra cómo leer un string del teclado y guardarlo en un arreglo, y cómo recorrer los elementos del arreglo desde el principio hasta llegar al caracter '\0' que marca el final del string. 
 +Obsérvese que si el arreglo tiene TAM caracteres, entonces el string debe tener a lo sumo TAM-1 caracteres porque uno  
 +de los caracteres se va a usar para la marca '\0'. 
 + 
 +**strings.c** 
 +<code> 
 +#include <stdio.h> 
 + 
 +/* TAM es el tamanio maximo del string */ 
 +#define TAM 10
  
-Recursión y alto orden:+int main() { 
 +  char str[TAM]; 
 +  int i;
  
-  * WTF!?+  /* Leer un string del teclado: */ 
 +  printf("Ingrese el string (maximo %i caracteres): ", TAM-1); 
 +  scanf("%s", str);
  
-Otros:+  /* Recorrer el string: */ 
 +  i = 0; 
 +  while (str[i] != '\0') { 
 +    printf("%i-esimo elemento: %c\n", i, str[i]); 
 +    i = i + 1; 
 +  }
  
-  * Configurar editor con "# export EDITOR='mcedit +%d %s'". +  return 0; 
-  * Usar ":f ==" para buscar la clase Eq, y así... +} 
-*/+</code>
  
algo1/2010-1/taller.1271876366.txt.gz · Última modificación: 2018/08/10 03:03 (editor externo)