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/05/05 20:30] – 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 332: Línea 332:
  
 ===== 5 de mayo de 2010 ===== ===== 5 de mayo de 2010 =====
- 
 ==== Introducción al Lenguaje C ==== ==== Introducción al Lenguaje C ====
  
Línea 340: Línea 339:
 Este programa muestra cómo hacer para imprimir en pantalla un mensaje que diga "Hola mundo!". Este programa muestra cómo hacer para imprimir en pantalla un mensaje que diga "Hola mundo!".
  
-  /* hola.c */+**hola.c**: 
   #include <stdio.h>   #include <stdio.h>
      
Línea 366: Línea 366:
  
  
 +=== 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
 +
 +int main() {
 +  char str[TAM];
 +  int i;
 +
 +  /* Leer un string del teclado: */
 +  printf("Ingrese el string (maximo %i caracteres): ", TAM-1);
 +  scanf("%s", str);
 +
 +  /* Recorrer el string: */
 +  i = 0;
 +  while (str[i] != '\0') {
 +    printf("%i-esimo elemento: %c\n", i, str[i]);
 +    i = i + 1;
 +  }
 +
 +  return 0;
 +}
 +</code>
  
algo1/2010-1/taller.1273091403.txt.gz · Última modificación: 2018/08/10 03:03 (editor externo)