Diferencias

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

--- ejemplo [2012/07/28 21:48] – lmateu
+++ ejemplo [2012/07/28 22:07] (actual) – borrado lmateu
@@ Línea 1: / Línea 1: @@
-===== Programa de curso =====
-Programa de curso:
-[[http://www.dcc.uchile.cl/docs/2010/CC3301_2009-2-ADD_2010.pdf]]
-===== Historia =====
-  * En los 50's nace el primer lenguaje de programación: Fortran (//Formula Translator//).  La idea era poder escribir fórmulas algebraicas cómodamente sin tener que escribir en lenguaje ensamblador.  No hay while ni if/else: se usa if ... goto.
-  * En los 60's surge el primer lenguaje con programación estructurada: Algol.  Posee while e if/else.  Es un lenguaje demasiado complejo para las máquinas de la época. De este lenguaje se derivan 2 variantes minimalistas, Pascal y C, que sí son implementables.
-  * En los 70's aparece Pascal (de Niklaus Wirth).  Busca la robustez en la programación.  Es un lenguaje minimalista.
-  * También en los 70's aparece C (de Brian Kernighan).  La sintaxis es distinta de Algol y Pascal.  C recible la flexibilidad del manejo de memoria del assembler para así poder programar un sistema operativo (Unix) en un lenguaje de alto nivel (C).  Por eso no puede ser robusto, aunque sí es minimalista.
-  * A fines de los 70's aparece el primer lenguaje orientado a objetos: Smalltalk.  Es puro, todo es un objeto.  Es minimalista, pero es extremadamente ineficiente porque debe ser interpretado.
-  * En los 80's Bjarne Stroustrup enriquece C con clases para facilitar la programación orienta a objetos en un lenguaje eficiente, dando así origen al lenguaje C++.  Tampoco es robusto y es complejo.
-  * En los 90's James Gosling concibe Java como una forma de darle robustez a C++.  Es menos complejo que C++.
-===== Ejemplo de pograma en C =====
-Ejemplo estudiado: [[http://www.dcc.uchile.cl/jpiquer/Docencia/cc31a/copy.c|copy.c]]
-<code C>
-#include <stdio.h>
-/*
- * Copia la entrada en su salida sin modificaciones
- */
-int main() {
-    int c;
-    while((c=getchar()) != EOF)
-        putchar(c);
-    return 1;
-}
-</code>
-  * Un archivo fuente escrito en el lenguaje C lleva la extensión '.c'.
-  * Los comentarios se inician con '/*' y terminan con '*/'.  Pueden extenderse por varias líneas.
-  * C estándar no admite comentarios iniciados con %%'//'%% como Java y C++.  GNU-C sí los admite.  Evite usarlos porque no funcionarán en otros compiladores.
-  * La función de inicio de un programa se llama main.
-  * getchar es una función estándar de C que lee un caracter de la entrada estándar.
-  * Entrega una constante caracterizada como EOF cuando llega al final del archivo.
-  * putchar es otra función estándar de C que escribe un caracter en la salida estándar.
-  * El include al inicio del archivo es una directiva para el procesador.  Indica que se debe agregar en ese punto textualmente el archivo stdio.h.  Este contiene declaraciones de funciones de E/S típicamente usadas como getchar, putchar, printf.  Y constantes como EOF.
-  * Observe que una asignación puede aparecer en cualquier lugar en donde es válido colocar una expresión porque = es un operador como +, *, etc.  No es usual que en Java un argumento de una expresión sea una asignación, pero en C sí lo es.
-Pueden probar compilando este programa:
-<code>
-% gcc copy.c -o copy
-</code>
-  * El comando gcc es el compilador de C de la GNU.
-  * Recibe como argumento el archivo fuente (copy.c) y produce un archivo binario con instrucciones de máquina ejecutables directamente (copy).
-Y jugando a manejar su entrada y salida:
-<code>
-% ./copy >out
-hola
-^D
-% ./copy <out
-hola
-% ./copy <out >out2
-% ./copy <out2 | ./copy >out3
-%
-</code>
-  * Todo programa en Unix tiene una entrada estandar y una salida estandar.
-  * Además existe una salida estándar de errores.
-  * La entrada estándar se especifica con '<' seguido del nombre del archivo.
-  * La salida estándar se especifica con '>' seguido del nombre del archivo.
-  * Si no se especifica entrada o salida estándar se usa la del shell que corresponde usualmente a teclado y consola respectivamente.
-  * Entonces los archivos out, out2 y out3 todos son iguales.
-Ejecute ahora:
-<code>
-% ./copy < out > out4
-% echo $status
-%
-</code>
-  * El 1 es el código de retorno y es el valor retornado por main.  Cambie 'return 1' por 'return 2' y rehaga el experimento.
-  * El shell almacena en la variable $status el código de retorno del último programa ejecutado.
-===== Comparación entre C y Java =====
-==== Generalidades ====
-  * Los archivos en C llevan las extensión '.c' mientras que en Java '.java'.
-  * El compilador de C (comandos gcc o cc) produce archivos con instrucciones de máquina en binario que son directamente ejecutables por la máquina.
-  * El compilador de Java (comando javac) produce archivos '.class' que corresponden a instrucciones de una máquina virtual (la JVM: java virtual machine).  Para ejecutarlos se invoca el comando java que incluye un compilador JIT (just in time) que traduce en memoria las instrucciones virtuales a las intrucciones de la plataforma usada.  Al no generar un archivo con la traducción, la compilación JIT ocurre cada vez que se ejecuta el programa.
-==== Programación orientada a objetos ====
-  * C no es un lenguaje orientado a objetos: no posee clases.  Java sí es orientado a objetos (aunque no es puro como Smalltalk).
-  * En C se definen los tipos compuestos mediante la declaración **struct**.  Ahí no se pueden incluir métodos.
-  * La abstracción que describe como se procesan los datos es la //función// mientras que en Java es la //clase//.
-  * En Java un archivo contiene 1 clase (opcionalmente más de 1).  No hay funciones aisladas.  Mientras que en C un archivo es una secuencia de declaraciones que pueden ser tipos de datos (structs), variables globales o funciones.
-  * En un archivo en C, las abstracciones declaradas se conocen a partir del punto en donde se declaran. No se pueden referenciar antes. Típicamente se declaran prototipos de las abstracciones (especialmente las funciones) en archivos de encabezado (extensión .h).
-  * En Java las abstracciones declaradas en un archivo o clase son globalmente conocidas.  No se requiere declarar prototipos ni archivos de encabezados.
-==== Tipos primitivos ====
-  * Usan casi los mismos tipos primitivos: char, short, int, long, float, double.
-  * Pero en C, char es en realidad un entero de 1 byte, mientras que en Java ocupa 2 bytes y solo almacena caracteres.
-  * En C se puede agregar el atributo unsigned a los enteros.
-==== Strings ====
-  * C no posee el tipo String.  Los strings se representan mediante punteros a arreglos de caracteres terminados con el caracter '\0'.
-  * En Java existe la clase predefinida String con métodos bien definidos.
-==== Punteros ====
-La siguiente tabla compara la sintaxis usada para las distintas operaciones con punteros:
-^ ^ Java ^ C ^
-| declaración | <code>Node p;</code> | <code>Node *p;</code> |
-| asignación de memoria | <code>p= new Node();</code> | <code>p= (Node*)malloc(sizeof Node);</code>|
-| acceso | <code>Node q= p.next;</code>     | <code>Node *q= p->next;</code> |
-| destrucción |                                  | <code>free(p);</code> |
-| puntero nulo | <code>p= null;</code>            | <code>p= NULL;</code> |
-  * En C se usa el '*' para trabajar con punteros.  En Java no.
-  * En C la memoria se pide con malloc, mientras que en Java con new.
-  * malloc necesita el tamaño de la memoria a asignar.  Esta se obtiene con sizeof.
-  * En C se accede a los campos de la esctructura con el operador %%'->'%%, mientras que en Java se hace con '.'.
-  * En Java nunca se libera el área de memoria ocupada por p.  Hay un recolector de basuras que recicla esa memoria cuando deja ser referenciada.
-  * C //no posee recolector de basuras//.  Se necesita liberar explícitamente la memoria con free.
-  * Un error frecuente en C es el puntero loco o colgante (dangling reference).  Ocurre cuando equivocadamente se libera la memoria, pero todavía está siendo referenciada.
-  * Otro error frecuente en C es la gotera de memoria: cuando un trozo de memoria pedido con malloc nunca se libera.
-  * En Java el recolector de basura evita por completo los punteros locos.  Usualmente se piensa que también evita las goteras, pero no esto no es cierto.  Las reduce pero no las evita.  Un típico caso es poblar una tabla de hash con objetos que nunca serán consultados.  Esos objetos sí son goteras.
-  * En C el puntero nulo es NULL en mayúscula.  En Java es null en minúsculas.
-==== Variables locales de tipo compuesto ====
-  * En C se pueden declarar variables de tipo compuesto (structs) que son locales a una función.  Por ejemplo: <code>Node node;</code>
-  * No se debe llamar a malloc.  El espacio de memoria requerido se asigna automáticamente al ingresar a la función.
-  * Se accede a los campos con el operador '.': <code>node.next</code>  No se usa '->'.
-  * La variable se destruye automáticamente al retornar de la función.
-  * Se puede asignar la dirección de la variable a un puntero: <code>Node *p= &node;</code>
-  * Un error típico es acceder al contenido de p después del retorno de la función en donde se declaró node.
-  * Como Java es un lenguaje robusto, para evitar este error simplemente en Java no se pueden declarar variables de tipos compuestos locales a una función.  Por eso en Java se eliminó el uso de '*' pues //todas las variables de tipo compuesto son punteros//.