Diferencias

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

--- algo1:2010-1:taller [2010/05/05 17:48] – francolq
+++ algo1:2010-1:taller [2025/11/15 13:47] (actual) – editor externo 127.0.0.1
@@ Línea 17: / Línea 17: @@
     fac (n+1) = (n+1) * fac n
     len :: [a] -> Int
     len [] = 0
     len (_:xs) = 1 + length xs
 Vimos cómo abrir el intérprete de Haskell y cómo crear, editar y cargar archivos de definiciones.
@@ Línea 424: / Línea 424: @@
     <codigo>
   }
 El siguiente código es un ejemplo de uso de la asignación y del if.
@@ Línea 456: / Línea 455: @@
   }
+=== 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>