Wiki CC3301

Herramientas de usuario

Herramientas del sitio

Estás aquí: start
Traza: • start • threads
start

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
start [2012/07/28 16:31] – [Clase 1: Lenguaje C, E/S Estándar] lmateustart [2014/11/15 12:44] (actual) – [Servidor Multi-cliente con select] lmateu
Línea 1: Línea 1:
 ====== CC3301 - Programación de Software de Sistemas ====== ====== CC3301 - Programación de Software de Sistemas ======
  
-Programa de curso:+Estos son los apuntes de José Piquer.  Además se encuentran disponibles en youtube 
 +[[http://www.youtube.com/watch?v=maJkL9kpoek&feature=c4-overview-vl&list=PLC4BC3AFA8B75D08B|videos de las 23 clases]] de 
 +José Piquer. Hay un índice del contenido en los comentarios para las clases 2, 3, 4 y 5.  El que vea 
 +los siguientes videos sin el índice agregue un comentario con el contenido por favor.  Observen que el botón que aparece en la esquina de arriba a la izquierda en el video permite seleccionar el número de la clase que desean ver. 
 +Pero cuidado, la enumeración de las clases de esta página no corresponde uno a uno a la enumeración de los 23 videos, 
 +ni siquiera el orden. 
 + 
 +En los apuntes de [[temario|Luis Mateu]] se explican los mismos conceptos de esta página pero con más detalle.
  
-[[http://www.dcc.uchile.cl/docs/2010/CC3301_2009-2-ADD_2010.pdf]] 
 ===== Clase 1: Lenguaje C, E/S Estándar ===== ===== Clase 1: Lenguaje C, E/S Estándar =====
  
- +Ver contenido extendido en [[introduccion|Introducción]].
-=== Historia === +
- +
-  * En los 50's nace el primer lenguaje de programación: Fortran (//Formula Translator//).  La idea era poder escribir fórmulas cómodamente sin tener que escribir en lenguaje ensamblador.  No hay while: se usa goto. +
-  * En los 60's surge el primer lenguaje con programación estructurada: Algol.  Posee while e if con else. De este lenguaje se derivan 2 variantes, Pascal y C. +
-  * 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.  Busca dar el poder del assembler en un lenguaje de alto nivel.  No es robusto.  Es minimalista. +
-  * En los 80's Bjarne Stroustrup le agrega clases a C, creando C++.  Tampoco es robusto y es complejo. +
-  * En los 90's James Gosling concibe Java.  Es complejo pero **robusto**. +
- +
-=== Ejemplo ===+
  
 Ejemplo estudiado: [[http://www.dcc.uchile.cl/jpiquer/Docencia/cc31a/copy.c|copy.c]] Ejemplo estudiado: [[http://www.dcc.uchile.cl/jpiquer/Docencia/cc31a/copy.c|copy.c]]
Línea 23: Línea 19:
 #include <stdio.h> #include <stdio.h>
  
-/*+/* 
  * Copia la entrada en su salida sin modificaciones  * Copia la entrada en su salida sin modificaciones
  */  */
Línea 37: Línea 33:
 } }
 </code> </code>
- 
  
 Pueden probar compilando este programa: Pueden probar compilando este programa:
Línea 57: Línea 52:
 </code> </code>
  
-Entonces los archivos out, out2 y out3 todos son iguales. 
- 
-=== Comparación entre C y Java === 
- 
-== Programación orientada a objetos == 
- 
-  * C no es un lenguaje orientado a objetos: no posee clases. 
-  * 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. 
- 
-== 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 bytes, 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 caracteres y terminados con '\0'. 
-  * En Java existe la clase String con métodos bien definidos. 
- 
-== Punteros == 
- 
-^ Java ^ C ^ 
-| <code>Node p= new Node();</code> | <code>Node *p= (Node*)malloc(sizeof Node);</code> | 
-| <code>Node q= p.next;</code>     | <code>Node *q= p->next;</code> | 
-|                                  | <code>free(p);</code> | 
- 
-  * 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 explicitamente 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. 
- 
-== Variables locals 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//.  
  
 ====== Clase 2: Lenguaje C y tipos básicos ====== ====== Clase 2: Lenguaje C y tipos básicos ======
  
 +Ver contenido extendido en [[tipos|tipos]] y [[variables|variables]].
 ===== Enteros ===== ===== Enteros =====
 char: 8 bits, 1 byte char: 8 bits, 1 byte
Línea 125: Línea 75:
 ===== Punteros ===== ===== Punteros =====
  
 +Ver contenido extendido en [[punteros|punteros]] y [[strings|strings]].
 ==== Strings ==== ==== Strings ====
  
Línea 3180: Línea 3131:
 Atendemos todos los clientes en el mismo ciclo, usando select: Atendemos todos los clientes en el mismo ciclo, usando select:
 <code C> <code C>
 +#define _BSD_SOURCE 1
 +
 #include <stdio.h> #include <stdio.h>
 #include <stdlib.h> #include <stdlib.h>
Línea 3268: Línea 3221:
    }    }
 } }
 +</code>
 +
 +Se necesita definir la macro _BSD_SOURCE al inicio del programa para hacer válido el uso de la función getdtablesize().  El encabezado de esta función está incluido en unistd.h, pero solo cuando se define la macro _BSD_SOURCE.  Eso se indica en la documentación de getdtablesize:
 +
 +<code>
 +  % man 3 getdtablesize
 +  NAME
 +       getdtablesize - get descriptor table size
 +
 +  SYNOPSIS
 +       #include <unistd.h>
 +
 +       int getdtablesize(void);
 +
 +     Feature Test Macro Requirements for glibc (see feature_test_macros(7)):
 +
 +       getdtablesize():
 +           Since glibc 2.12:
 +               _BSD_SOURCE ||
 +                   !(_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600)
 </code> </code>
  
start.1343493064.txt.gz · Última modificación: por lmateu