Diferencias

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

--- algo1:2010-1:taller [2010/05/18 22:04] – francolq
+++ algo1: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
     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 514: / Línea 514: @@
 a donde:
-  * <tipo_resultado> puede ser un tipo ("int", "char2, etc.) o puede ser "void", que quiere decir que la función no devuelve nada;
+  * <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;
@@ Línea 661: / Línea 661: @@
     }
   }
+===== 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>