lenguaje de programacion ii

Upload: chino-hdz

Post on 20-Jul-2015

58 views

Category:

Documents


0 download

TRANSCRIPT

UNIDAD 1: REGISTROS: 1.1 CONCEPTOS GENERALES. LENGUAJE DE PROGRAMACIN:

Es un conjunto de smbolos junto a un conjunto de reglas para combinar dichos smbolos que se usan para expresar programas. Constan de un lxico, una sintaxis y una semntica. Qu conoces tu por lxico, sintaxis y semntica? Lxico: Conjunto de smbolos permitidos o vocabulario Sintaxis: Reglas que indican cmo realizar las construcciones del lenguaje Semntica: Reglas que permiten determinar el significado de cualquier construccin del lenguaje. Tipos de lenguajes: Atendiendo al nmero de instrucciones necesarias para realizar una tarea especfica podemos clasificar los lenguajes informticos en dos grandes bloques: bajo nivel alto nivel Lenguaje de bajo nivel Es el tipo de lenguaje que cualquier computadora es capaz de entender. Se dice que los programas escritos en forma de ceros y unos estn en lenguaje de mquina, porque esa es la versin del programa que la computadora realmente lee y sigue. Lenguajes de alto nivel Son lenguajes de programacin que se asemejan a las lenguas humanas usando palabras y frases fciles de entender. En un lenguaje de bajo nivel cada instruccin corresponde a una accin ejecutable por el ordenador, mientras que en los lenguajes de alto nivel una instruccin suele corresponder a varias acciones.

1.2 CONCEPTO DE CAMPO:

Hay varios campos de estudio que o bien caen dentro de la teora de lenguajes de programacin, o bien tienen una profunda influencia en ella; muchos de estos se superponen considerablemente. Teora de los compiladores es la base formal sobre la escritura de compiladores (o ms generalmente traductores); programas que traducen un programa escrito en un lenguaje a otra forma. Las acciones de un compilador se dividen tradicionalmente en anlisis sintctico (escanear y parsear), anlisis semntico (determinando que es lo que debera de hacer un programa), optimizacin (mejorando el rendimiento indicado por cierta medida, tpicamente la velocidad de ejecucin) y generacin de cdigo (generando la salida de un programa equivalente en el lenguaje deseado; a menudo el set de instrucciones de una CPU). La Teora de tipos es el estudio de sistemas de tipos, que son "mtodos sintcticos tratables para proveer la ausencia de ciertos comportamientos de programa mediante la clasificacin de frases segn los tipos de valores que

computan." (Types and Programming Languages, MIT Press, 2002). Muchos lenguajes de programacin se distinguen por las caractersticas de sus sistemas de tipos. La Semntica formal es la especificacin formar del comportamiento de programas de ordenador y lenguajes de programacin. La Transformacin de programas es el proceso de transformar un programa de una forma (lenguaje) a otra forma; el anlisis de programas es problema general de examinar un programa mediante la determinacin de sus caractersticas clave (como la ausencia de clases de errores de programa). Sistemas en tiempo de ejecucin se refiere al desarrollo de entornos runtime para lenguajes de programacin y sus componentes, incluyendo mquinas virtuales, recoleccin de basura, e interfaces para funciones externas. Anlisis comparativo de lenguajes de programacin busca clasificar los lenguajes de programacin en diferentes tipos basados en sus caractersticas; amplias categoras de diferentes lenguajes de programacin se conocen frecuentemente como paradigmas de computacin. Metaprogramacin es la generacin de programas de mayor orden que, cuando se ejecutan, producen programas (posiblemente en un lenguaje diferente, o en un subconjunto del lenguaje original) como resultado. Lenguajes dedicados son lenguajes construidos para resolver problemas en un dominio de problemas en particular de manera eficiente.

Adems, PLT hace uso de muchas otras ramas de las matemticas, ingeniera del software, lingstica, e incluso ciencias cognitivas

1.3 CONCEPTO DE ESTRUCTURAS:

Qu es una estructura? Una estructura es un tipo de dato definido por el usuario, al utilizar una estructura Usted tiene la habilidad para definir un nuevo tipo de dato considerablemente ms complejo que los tipos que hemos utilizado hasta ahora. Una estructura es una combinacin de varios tipos de datos previamente definidos, incluyendo otras estructuras que hayamos definido previamente. Una definicin simple es, "una estructura es un grupo de datos relacionados en una forma conveniente al programador y/o al usuario del programa". Como es costumbre, un ejemplo nos clarifica los conceptos:

#include struct { char inicial; /* Letra inicial del apellido */ int edad; /* Edad */ int calificacion; /* Aprovechamiento */ } chico, chica; int main() { chico.inicial = 'R'; chico.edad = 15; chico.calificacion = 75; chica.edad = chico.edad - 1; /* Ella es un ao menor que l */ chica.calificacion = 82;

chica.inicial = 'H'; printf("%c tiene %d anos y su calificacion es de %d\n", chica.inicial, chica.edad, chica.calificacion); printf("%c tiene %d anos y su calificacion es de %d\n", chico.inicial, chico.edad, chico.calificacion); } return 0;

El programa empieza definiendo una estructura utilizando la palabra clave struct seguida de tres variables sencillas encerradas entre llaves, las cuales son los componentes de la estructura, despues de la llave de cierre tenemos enlistadas dos variables llamadas chico y chica. De acuerdo a la definicin de una estructura, chico es una variable compuesta de tres elementos, inicial, edad y, calificacion. Cada uno de los tres campos estn asociados a chico y cada uno almacena una variable de su respectivo tipo, lo mismo se puede decir para chica pero sus variables son diferentes por lo tanto tenemos 6 variables agrupadas en dos, de tipo struct. 1.4 MANIPULACIN DE ESTRUCTURAS (CON EJEMPLO): El siguiente programa es bsicamente el mismo que el anterior, pero esta vez definimos un array de 12 variables llamadas chicos, est claro que ste programa contiene 12 veces 3=36 variables sencillas cada una de las cuales puede almacenar un tem de dato siempre y cuando sea del tipo adecuado, se define adems una variable comn llamada indice para utilizarla en los bucles, estudie el cdigo:

#include struct { char inicial; int edad; int calificacion; } chicos[12]; int main() { int indice; for (indice = 0; indice < 12; indice++) { chicos[indice].inicial = 'A' + indice; chicos[indice].edad = 16; chicos[indice].calificacion = 84; } chicos[3].edad = chicos[5].edad = 17; chicos[2].calificacion = chicos[6].calificacion = 92; chicos[4].calificacion = 57; /* Asignacion de estructura solo en compiladores ANSI-C */

chicos[10] = chicos[4]; for (indice = 0; indice < 12; indice++) printf("%c tiene %d anos y una calificacion de %d\n", chicos[indice].inicial, chicos[indice].edad, chicos[indice].calificacion); return 0; }

1.5 MANIPULACIN DE ESTRUCTURAS (CON EJEMPLO): Para asignar un valor a cada uno de los campos utilizamos un bucle for, en cada ciclo del bucle se asignan todos los valores para uno de los chicos, en una situacin real sta podra no ser la mejor manera de asignar datos, pero un bucle puede leer los datos de un archivo y almacenarlos en la correcta ubicacin en un programa real, considere ste ejemplo como un inicio burdo a una base da datos, pues eso es justamente nuestro ejemplo. El cdigo resulta fcil de entender, solo har un comentario respecto a la lnea 26 en donde podemos ver una asgnacin de estructura, en ste enunciado los tres campos de chicos[4] son copiados en los respectivos campos de chicos{10], esto no siempre est permitido en el lenguaje C, solo en los compiladores que cumplen con la norma ANSI-C, si su compilador no es ANSI-C encierre en comentarios la lnea 26. El resultado de la ejecucin delprograma es el siguiente:

UNIODAD II: ARCHIVO:

2.1 CONCEPTOS GENERALES CAMPO, ESTRUCTURA, ARCHIVO:

Qu es un campo? Para finalizar la presente leccin estudiaremos el concepto de campo de bits, en el siguiente cdigo podemos ver la manera de definirlo y utilizarlo, en el programa tenemos una unin de una variable sencilla de tipo int en la lnea 5 y la estructura definida en las lneas 6 a la 12:

#include union { int indice; struct { unsigned int x : 1; unsigned int y : 2; unsigned int z : 2; } bits; } numero; int main() { for (numero.indice = 0; numero.indice < 20; numero.indice++) { printf("indice = %3d, bits = %3d%3d %3d\n", numero.indice, numero.bits.z, numero.bits.y, numero.bits.x); } } return 0;

La estructura est compuesta de tres campos de bits llamados x, y, y z. La variable llamada x es de un solo bit, la variable y es de dos bits y es adyacente a la variable x, y la variable z es de dos bits y adyacente a la variable y. Como la unin causa que los bits sean almacenados en la misma ubicacin en memoria que la variable indice, la variable x es el bit menos significante de la variable indice, y conforma los siguientes dos bits, y z es almacenado en los siguientes dos bits de indice. Compile y ejecute el programa y ver que al ser incrementada la variable indice en cada ciclo del bucle, ver los campos de bits incrementarse en sus respectivas ubicaciones. Una cosa debemos sealar, los campos de bits deben definirse como partes de un tipo unsigned int de lo contrario el compilador marcar error. El resultado de la ejecucin del programa es:

2.2 ARCHIVOS DE TEXTO: INTRODUCCIN, DECLARACIN, APERTURA Y MANIPULACIN (CON EJEMPLO): ARCHIVOS DE TEXTO. Tambin conocidos como (Slream File) son utilizados para almacenar documentos que consisten en texto; En ellos, cada registro es un solo smbolo o cdigo de control. El leer estos archivos recibimos la informacin en orden secuencial en el que aparece cuando lo vemos en un monitor. Los archivos de texto son una secuencia de lneas separadas por marcas de fin de lnea. Rudimentos de los archivos de textos; El usuario escribe los archivos de textos mediante un procesador de palabras que le permitir almacenar la informacin pero no estrictamente en forma secuencial. El procesador tambin nos permite desplazarnos por todo el bloque de informacin y permitirnos realizar modificaciones. Mientras el usuario avance rpidamente en la lectura de registro lograra ver mas archivos. Lectura de un archivo de texto Crea el siguiente archivo de texto uitlizando un editor de texto cualquiera: 1.2 2512 2.4 1324 3.2 547 Escribe un programa en C que lea este archivo y calcule la suma de los productos de los nmeros de la primera columna por los de la segunda.

1.2 * 2512 + 2.4 *1324 + 3.2 * 547 El programa debe valer para cualquier archivo con este formato y escribir el resultado en el monitor. Utiliza el depurador para comprobar el orden en que se van leyendo los datos del archivo. El orden es (elige una respuesta): 1. 2. 3. 4. De arriba hacia abajo y De arriba hacia abajo y De abajo hacia arriba y De abajo hacia arriba y de izquierda a derecha (1.2 -> 2512 -> 2.4 -> 1324 ...) de derecha a izquierda (2512 -> 1.2 -> 1324 -> 2.4 ...) de derecha a izquierda de izquierda a derecha

A continuacin puedes estudiar tres soluciones ligeramente diferentes, dependiendo de cmo se utiliza la funcin fscanf. Puedes comprobar que el nmero de formatos en el segundo argumento debe coincidir con el de variables. Solucin 1

#include void main () { FILE * f; int a2, a4, a6; double a1, a3, a5, suma; f = fopen ("numeros.txt", "r"); // Un formato y una variable fscanf (f, fscanf (f, fscanf (f, fscanf (f, fscanf (f, fscanf (f, "%lf", &a1); "%d", &a2); "%lf", &a3); "%d", &a4); "%lf", &a5); "%d", &a6);

fclose (f); suma = a1*a2 + a3*a4 + a5*a6; printf ("Suma = %.0lf\n", suma); }

Nombre ReadAllText(String) ReadAllText(String, Encoding)

Descripcin Abre un archivo de texto, lee todas sus lneas y, a continuacin, cierra el archivo. Abre un archivo, lee todas sus lneas con la codificacin especificada y, a continuacin, cierra el archivo

2.3 ARCHIVO DE ESTRUCTURAS: INTRODUCCIN, DECLARACIN, APERTURA Y MANIPULACIN (CON EJEMPLO):

ESTRUCTURA: Un archivo es el mdulo bsico de informacin manejado por el Sistema Operativo. El Sistema Operativo es un conjunto de programas cuya funcin es administrar los recursos del Sistema de Cmputo. Por ejemplo, un programa fuente es almacenado como un archivo. Primero es introducido en la memoria RAM por medio de un programa editor, y despus es almacenado como un archivo de texto en un medio de almacenamiento permanente (cinta, disco flexible, disco duro). Una vez que el programa fuente ha sido compilado, el programa resultante de la compilacin viene a ser un archivo binario. En Pascal, un archivo es una secuencia de elementos que pertenecen al mismo tipo o estructura, esto es que un archivo puede ser una secuencia de caracteres, nmeros o registros, por lo que su representacin lgica puede hacerse como una secuencia de mdulos del mismo tamao, tal como se presenta en la siguiente figura.

En el vocabulario de manejo de archivos, a cada elemento de un archivo se le llama registro. En Pascal, la numeracin de los registros empieza con el nmero CERO , por lo que al elemento_1 se le llamar registro 0, al elemento_2 registro 1, y as sucesivamente hasta llegar a la marca de fin de archivo EOF. Turbo Pascal difiere significativamente de Pascal estndar por la forma en que maneja los archivos. En Pascal estndar, los archivos son formalmente definidos independientemente del medio en que residan. Este mtodo de definicin fue inspirado por los archivos de tarjetas perforadas y cintas magnticas, las cuales eran los medios de almacenamiento comnmente usados cuando Pascal fue definido por primera vez. Como resultado, todo acceso a cualquier archivo en Pascal estndar es secuencial( registro por registro ) tal como se realiza en las tarjetas perforadas y cintas magnticas. En Turbo Pascal los archivos son definidos como archivos de disco. Los discos son actualmente los dispositivos de almacenamiento ms utilizados en las microcomputadoras. Los mecanismos de acceso secuencial proporcionados por Pascal estndar son algunas veces inconvenientes e insuficientes para los archivos basados en discos de acceso aleatorio, por lo que Turbo Pascal provee nuevas estructuras y mecanismos de acceso a los archivos. La primera gran diferencia entre Turbo Pascal y Pascal estndar, es la forma en que enlazan los archivos a un programa. En Pascal estndar, se abren los archivos referenciando su nombre de archivo en el encabezado del programa, y se cierran cuando el programa termina. En Turbo Pascal, los archivos de disco deben enlazarse a una variable de archivo particular con el procedimiento: Assign(variable_archivo,nombre_archivo);

y deben ser preparados para procesarse ( abiertos ) con: reset(variable_archivo) o rewrite(variable_archivo) antes de ser utilizados. Adems, los archivos deben ser explcitamente cerrados por medio de close(variable_archivo), despus de que han sido utilizados, o se perdern los datos que estn en la memoria auxiliar (variable_archivo) . variable_archivo es el nombre de la memoria auxiliar (buffer), por medio de la cual el programa manejar los datos hacia o desde el archivo en disco. nombre_archivo es el nombre que identifica al archivo en el disco. reset abre un archivo existente para procesamiento y coloca el apuntador de registro en el primer registro (0). rewrite crea un nuevo archivo (o sobre-escribe en uno existente) y lo abre para procesamiento con el apuntador de registro colocado en el registro 0. En el caso de un archivo de tipo text, reset har que el archivo slo pueda ser usado para operaciones de lectura , mientras que rewrite slo permitir operaciones de escritura. Los nombres de archivo vlidos son cadenas de 1 a 8 caracteres seguidos por una extensin opcional consistente de un punto y hasta tres caracteres. A estos nombres tambin se les llama "nombres de archivo externo", puesto que son los nombres con que se graban en el disco.

Cita: typedef enum TSTADO{SOLTERO,CASADO,VIUDO}Tstado; typedef struct TCLIENTE{ int edad ; char nombre[51]; float saldo; Tstado estado; }TCliente;

Escritura: Cita: int escribir_bin(int fin,TCliente *clte){ FILE *archivo; int nex=0; archivo=fopen("DatosBanco.dat","wb");

if (archivo!=NULL) { nex+=fwrite(clte,sizeof(TCliente),fin+1,archivo); fclose(archivo); return nex; } return -1; }

Lectura: Cita: int leer_bin(int fin, TCliente *vector){ FILE *archivo; int nex=0; archivo=fopen("DatosBanco.dat","rb"); if (archivo!=NULL) { fseek(archivo,0,SEEK_SET); nex+=fread(vector,sizeof(TCliente),fin+1,archivo); fclose(archivo); return nex; } else return -1; }

#include //ahora debemos de incluir nuestra 02 estructura // 0 //para este ejemplo usaremos una estructura 3 llamada albail 0 4 0 //la cual contiene los siguientes datos 5 0 //nombre, folio, RFC, direccion, mail, horas trabajasdas, activida 6 realizada y su tipo de pago 0 7 0 struct 8 albanil { 0 char

9 1 0 1 1 1 2 1 3 1 4 1 5 1 6 1 7 1 8 1 9 2 0 2 1 2 2 2 3 2 4 2 5 2 6 2 7 2 8 2 9 3 0 3 1 3 2 3 3 3 4 3 5 3 6 3

nombre[50]; char folio[10]; char RFC[11]; char calle[20]; char CP[6]; char colonia[20]; char mail[50]; char horas[2]; char actividad[50]; char pago[4]; };struct albanil albanil;

//ahora dentro de nuestro main

int main() { FILE *ptr; //inicializaremo una variable a archivo como apuntador char archivo[50];//y tendremos una cadena archivo para guardar el archiv con el nombre que sedessee printf("Como quieres que se llame tu archivo "); scanf("%s",&archivo); printf("Dime tu numero de folio "); scanf("%s",albanil.folio ); printf("Dime tu nombre "); scanf("%s",albanil.n ombre); printf("Dime tu RFC "); scanf("%s",albani l.RFC); printf("Dime tu direccion "); scanf("%s",albanil. calle); printf("Dime tu codigo

7 3 8 3 9 4 0 4 1 4 2 4 3 4 4 4 5 4 6 4 7 4 8 4 9 5 0 5 1 5 2 5 3 5 4 5 5 5 6 5 7 5 8 5 9 6 0 6 1

postal "); scanf("%s",albanil.CP ); printf("Dime tu colonia "); scanf("%s",albanil.c olonia); printf("Dime tu correo electronico "); scanf("%s",albanil.mail); printf("Dime cuantas horas trabajaste "); scanf("%s",albanil.horas); printf("Dime en que trabajaste "); scanf("%s",albanil.acti vidad); printf("Dime cuanto te van a pagar "); scanf("%s",albanil.pago); ptr=fopen(archivo,"a"); fprintf(ptr,"folio %s\n",albanil.folio); fprintf(ptr,"nombre %s\n",albanil.nombre); fprintf(ptr,"RFC %s\n",albanil.RFC); fprintf(ptr,"calle %s\n",albanil.calle); fprintf(ptr,"cp %s\n",albanil.CP); fprintf(ptr,"colona %s\n",albanil.colonia); fprintf(ptr,"correo %s\n",albanil.mail); fprintf(ptr,"horas %s\n",albanil.horas); fprintf(ptr,"actividad %s\n",albanil.actividad); fprintf(ptr,"pago %s\n",albanil.pago); fclose(ptr); retur n 0;

2.4 ARCHIVOS SIN TIPO:

Todos los archivos utilizados hasta ahora suponen algn tipo de estructura. Si no se conoce la estructura del registro se debe utilizar un archivo sin tipo. Los archivos sin tipo son canales de E/S de bajo nivel, principalmente utilizados

para acceso directo a cualquier archivo de disco con independencia del tipo y estructura. Cualquier archivo de disco puede ser declarado como sin tipo. Turbo Pascal permite tratar un archivo como una serie de bloques sin necesidad de conocer el tipo de datos que contiene. La declaracin de un archivo sin tipo omite el tipo de archivo : Var nombre: file; Usando la declaracin de archivos sin tipo, no importa como se haya escrito originalmente el archivo. Los archivos de texto, archivos binarios, archivos de programas o cualquier otro, pueden ser declarados y abiertos como archivos sin tipo. Los archivos sin tipo tienen una longitud de registro por defecto de 128 bytes, y se transfieren directamente entre la variable registro y el archivo. El formato de los procedimientos Reset y Rewrite en archivos sin tipo difiere del ya conocido para archivos de texto y con tipo. Reset (nombre,bloque) Rewrite(nombre, bloque) nombre variable de tipo archivo Bloque un nmero de tipo word

Ejemplo: Reset(archivo,1); Prepara a un archivo para ser ledo y especfica que la longitud de registro es de 1 byte. Acceso a los archivos (sin tipo) El acceso al los archivos se realiza con los siguientes procedimientos: BlockRe BlockWr ad ite Formatos: BlockRead

Transfiere un bloque de datos de un archivo sin tipo hacia un buffer. Formato: BlockRead(arch,buffer,bloq ues,resul) arch archivo sin tipo buffer variable de cualquier tipo de longitud suficiente para acoger los datos transferidos bloques expresin que corresponde al nmero de bloques de 128 bytes a transferir. resul parmetro opcional que indica el nmero de bloques que se leyeron o escribieron realmente.

BlockWrite Transfiere un buffer de datos hacia un archivo sin tipo. Los archivos sin tipo son ms rpidos, debido a que los datos no necesitan ser organizados en lneas o estructuras; son simplemente bloques que se transfieren entre el disco y un buffer. El siguiente ejemplo muestra una de las aplicaciones que se les puede dar a los archivos sin tipo. La funcin del siguiente ejemplo es el de copiar el contenido de un archivo a una ruta especfica (idntico al comando Copy de MS-DOS).

Ejemplo: Program Copiar; Var fuente,destino : file; {archivo sin tipo} buffer : array[1..512] of byte; temp : string; leidos : integer; begin if ((ParamCount2)) then begin if (ParamCount0 do begin BlockWrite(destino,buffer,SizeOf(buffer),leidos); BlockRead(fuente,buffer,SizeOf(buffer),leidos) end; close(fuente); close(destino) end.

UNIDAD III: APUNTADORES: 3.1 DIRECCIONES DE MEMORIA:

Obtencin de direccin de memoria. Operador & Para almacenar una referencia a un objeto en un puntero se puede aplicar al objeto el operador prefijo &, que lo que hace es devolver la direccin que en memoria ocupa el objeto sobre el que se aplica. Un ejemplo de su uso para inicializar un puntero es:

int x =10; int * px = &x; Este operador no es aplicable a expresiones constantes, pues stas no se almacenan en ninguna direccin de memoria especfica sino que se incrustan en las instrucciones. Por ello, no es vlido hacer directamente:

int px = &10; // Error 10 no es una variable con direccin propia

Tampoco es vlido aplicar & a campos readonly, pues si estos pudiesen ser apuntados por punteros se correra el riesgo de poderlos modificar ya que a travs de un puntero se accede a memoria directamente, sin tenerse en cuenta si en la posicin accedida hay algn objeto, por lo que mucho menos se considerar si ste es de slo lectura. Lo que es s vlido es almacenar en un puntero es la direccin de memoria apuntada por otro puntero. En ese caso ambos punteros apuntaran al mismo objeto y las modificaciones a ste realizadas a travs de un puntero tambin afectaran al objeto visto por el otro, de forma similar a como ocurre con las variables normales de tipos referencia. Es ms, los operadores relacionales tpicos (==, !=, , =) se han redefinido para que cuando se apliquen entre dos punteros de cualesquiera dos tipos lo que se compare sean las direcciones de memoria que estos almacenan. Por ejemplo:

int x = 10; int px = &x; int px2 = px; // px y px2 apuntan al objeto almacenado en x Console.WriteLine( px == px2); // Imprime por pantalla True

En realidad las variables sobre las que se aplique & no tienen porqu estar inicializadas. Por ejemplo, es vlido hacer:

private void f() { int x; unsafe { int px = &x;} } Esto se debe a que uno de los principales usos de los punteros en C# es poderlos pasar como parmetros de funciones no gestionadas que esperen recibir punteros. Como muchas de esas funciones han sido programadas para inicializar los contenidos de los punteros que se les pasan, pasarles punteros inicializados implicara perder tiempo innecesariamente en inicializarlos. Acceso a contenido de puntero. Operador * Un puntero no almacena directamente un objeto sino que suele almacenar la direccin de memoria de un objeto (o sea, apunta a un objeto) Para obtener a partir de un puntero el objeto al que apunta hay que aplicarle al mismo el operador prefijo *, que devuelve el objeto apuntado. Por ejemplo, el siguiente cdigo imprime en pantalla un 10:

int x = 10; int * px= &x; Console.WriteLine(*px); Es posible en un puntero almacenar null para indicar que no apunta a ninguna direccin vlida. Sin embargo, si luego se intenta acceder al contenido del mismo a travs del operador * se producir generalmente una excepcin de tipo

NullReferenceException (aunque realmente esto depende de la implementacin del lenguaje) Por ejemplo:

int * px = null; Console.WriteLine(*px); // Produce una NullReferenceException No tiene sentido aplicar * a un puntero de tipo void * ya que estos punteros no almacenan informacin sobre el tipo de objetos a los que apuntan y por tanto no es posible recuperarlos a travs de los mismos ya que no se sabe cuanto espacio en memoria a partir de la direccin almacenada en el puntero ocupa el objeto apuntado y, por tanto, no se sabe cuanta memoria hay que leer para obtenerlo. 3.2 APUNTADORES: 1.-Un Apuntador es una variable que contiene una direccin de memoria, la cual corresponder a un dato o a una variable que contiene el dato. Los apuntadores tambin deben de seguir las mismas reglas que se aplican a las dems variables, deben tener nombre nicos y deben de declararse antes de usarse. Cada variable que se utiliza en una aplicacin ocupa una o varias posiciones de memoria. Estas posiciones de memoria se accesan por medio de una direccin.

3.3 APUNTADORES A ENTEROS:

int *p; int *p[10]; int (*p)[10]; int *p(void); int p(char *a); int *p(char *a); int (*p)(char *a); int (*p(char *a)) [10]; int p(char (*a)[]); int p(char *a[]); int *p(char a[]); int *p(char (*a)[]); int *p(char *a[]); int (*p)(char (*a)[]); int *(*p)(char (*a) []); int *(*p)(char *a[]); int(*p[10])(void); int (*p[10])(char * a); int *(*p[10])(char a);

p es un apuntador a un entero p es un arreglo de 10 apuntadores a enteros p es un apuntador a un arreglo de 10 enteros p es una funcin que devuelve un apuntador a entero p es una funcin que acepta un argumento que es un apuntador a carcter, devuelve un entero p es una funcin que acepta un argumento que es un apuntador a carcter, devuelve un apuntador a entero p es un apuntador a funcin que acepta un argumento que es un apuntador a carcter, devuelve un apuntador a entero p es una funcin que acepta un argumento que es un apuntador a carcter, devuelve un apuntador a un arreglo de 10 enteros p es un apuntador a funcin que acepta un argumento que es un apuntador a un arreglo de caracteres, devuelve un apuntador a entero p es un apuntador a funcin que acepta un argumento que es un arreglo de apuntadores a caracteres, devuelve un apuntador a entero p es una funcin que acepta un argumento que es un arreglo de caracteres, devuelve un apuntador a entero p es una funcin que acepta un argumento que es un apuntador a un arreglo de caracteres, devuelve un apuntador a entero p es una funcin que acepta un argumento que es un apuntador a un arreglo de apuntadores a caracteres, devuelve un apuntador a entero p es una funcin que acepta un argumento que es un apuntador a un arreglo de caracteres, devuelve un apuntador a entero p es un apuntador a una funcin que acepta un argumento que es un apuntador a un arreglo de apuntadores a caracteres, devuelve un apuntador a entero p es un apuntador a una funcin que acepta un argumento que es un arreglo de apuntadores a caracteres, devuelve un apuntador a entero p es una arreglo de 10 apuntadores a funcin, cada funcin devuelve un entero p es un arreglo de 10 apuntadores a funcin; cada funcin acepta un argumento que es un apuntador a carcter y devuelve un entero p es un arreglo de 10 apuntadores a funcin; cada funcin acepta un argumento que es un carcter, y devuelve un apuntador a entero

char *(*p[10])(char p es un arreglo de 10 apuntadores a funcin; cada funcin acepta un * a); argumentoque es un carcter, y devuelve un apuntador a carcter.

3.6 APUNTADORES A ARREGLOS Existe una estrecha relacin entre apuntadores y arreglos, tanto que pueden ser usados en forma casi indistinta. Una variable de tipo arreglo puede considerarse como un apuntadoral tipo del arreglo.

Los apuntadores pueden ser utilizados en cualquier operacin que involucre subndices de arreglos.

Ejemplo: #include #include int main() { int tabla[10],i,x,*pt,*ptr; pt = &tabla[0]; x = *pt; for (i=0; i y == 3;

Veamos las dos opciones de notacin para acceso de miembros en un ejemplo con estructuras anidadas: struct punto { int x; int y; }; struct line { struct punto p1; struct punto p2; } lin, *liptr = &lin; En las sentencias anteriores hemos definido dos tipos de estructuras; una instancia y un puntero a dicha instancia. En estas condiciones, las expresiones que siguen son equivalentes (1 y 6 son preferibles por legibilidad): lin.p1.x (lin.p1).x (*liptr).p1.x // L1.

((*liptr).p1).x liptr->p1.x (liptr->p1).x

// L6.

5 Ejemplo. float pi = 3.14159; struct { int x; char * str; float *arr[10]; struct punto pto; struct cuadro cuad; } str, *ptr = &str; Supuestas las declaraciones anteriores, a continuacin realizamos asignaciones a los miembros de str de dos formas: directamente y mediante expresiones del puntero ptr. Observe que segn lo indicado al respecto del espacio de nombres de estructuras, es perfectamente compatible el nombre str de estructura con el de uno de sus miembros (el puntero a carcter str.str). 5.1 Asignaciones directas: str.x = 30; str.str = "Hola mundo"; str.arr[0] = & pi; str.pto.x = 2; str.pto.y = 3; str.cuad.p1.x = 4; str.cuad.p1.y = 5; str.cuad.p2.x = 6; str.cuad.p2.y = 7; 5.2 Expresiones con puntero: ptr->x = 30; ptr->str = "Hola mundo"; ptr->arr[0] = & pi; ptr->pto.x = 2; str.pto.y = 3; ptr->cuad.p1.x = 4; ptr->cuad.p1.y = 5; ptr->cuad.p2.x = 6; ptr->cuad.p2.y = 7;

6 En el epgrafe relativo a la asociatividad y precedencia de operadores se ha sealado que los operadores: () [] -> . :: Llamada de funcin Subndices Acceso a miembro de estructura (mediante puntero) Acceso a miembro de estructura Acceso a miembro de clase

constituyen el orden ms alto en la jerarqua de precedencia, y que su asociatividad es de izquierda a derecha, por lo que hay que prestar especial atencin a las expresiones en que aparecen. Para resaltar la importancia de las reglas de precedencia, en los ejemplos que siguen se exponen algunas expresiones, referidas al ejemplo (5 como una explicacin de su significado. ++ptr->x Debido a la precedencia de operadores, equivale a ++(ptr->x). As pues, incrementa el miembro x, no el valor del puntero ptr. Resultado: str.x == 31 *ptr->x Del mismo modo, esta indireccin equivale a *(ptr->x), lo que resulta en un error, porque en el ejemplo indicado, ptr->x no es un puntero (es un int), y ya hemos visto [4.9.11] que el operando del operador de indireccin debe ser un puntero. *ptr->str En este caso, si es correcta la aplicacin del operador *; la expresin equivale a *(ptr>str), y ptr->str s es un puntero (a carcter); concretamente seala a la primera posicin de la cadena, es decir: *ptr->str == 'H' se puede evidenciar como sigue: printf("Letra \"%c\"\n", *ptr->str); // -> Letra "H" ++*ptr->str Se ha sealado que *ptr->str equivale a 'H'; ahora el compilador se enfrenta a la expresin: ++'H' == 'H'+1;. El resultado depende del contexto, por ejemplo, 'H' = 'H'+1; es un error ('H' no es un Lvalue). Sin embargo, la sentencia que sigue se compila correctamente y produce la salida indicada. printf("Letra \"%c\"\n", ++*ptr->str); // -> Letra "I" La explicacin es que el compilador pasa a printf el valor 'H'+1 (sin pretender ninguna otra asignacin), lo que, tras una conversin de tipo, se traduce en el carcter 'I' que sigue 'H' en la lista ASCII. *ptr++->str La expresin se traduce en: *((ptr++)->str). Si se utiliza la expresin que sigue, el resultado es el que se indica, pero cualquier posterior intento de utilizar ptr conduce a una catstrofe. printf("Letra \"%c\"\n", *ptr++->str); // -> Letra "H" ), as

La razn es que se enva a printf el valor *ptr->str, que produce la salida indicada y despus se produce el postincremento del puntero ptr, que queda apuntando a dios sabe donde, con lo que la utilizacin posterior seguramente producir el fallo del sistema por "Error grave". Nota: si str hubiese apuntado a una matriz de estructuras y la posicin actual no fuese la ltima, el efecto hubiese sido simplemente dejar str apuntando a la siguiente estructura de la matriz. *++ptr->str La expresin equivale a *(++ (ptr->str)). Nuevamente el resultado es correcto: ptr->str es un puntero p que seala al carcter 'H'; su incremento en 1 lo hace apuntar al segundo, por lo que si utilizamos la expresin que sigue se produce la salida indicada: printf("Letra \"%c\"\n", *++ptr->str); // -> Letra "o" *ptr->str++ Esta expresin equivale a (*(ptr->str))++. Es decir, 'H'++; nuevamente el resultado depende del contexto. En la expresin que nos viene sirviendo para control, produce la salida sealada, porque printf recibe como argumento un puntero a 'H' y el incremento se produce despus. printf("Letra \"%c\"\n", *ptr->str++); // -> Letra "H"

UNIDAD IV: UNIDADES. 4.1 SUBRUTINAS. Introduccin El movimiento del programa se basa en la llamada a etiquetas y a subrutinas. Esto nos da capacidad para decidir, temporizar o retardar, operar y/o ejecutar algoritmos. Por eso debemos de tener en cuenta las tcnicas ms comunes en la programacin de lenguaje ensamblador que nos permitirn hacer estas y muchas otras cosas. La mayora de los microcontroladores incluyen en su repertorio de instrucciones algunas que permiten saltar a una rutina y, cuando se completa su ejecucin, retornar al programa principal. El empleo de subrutinas aporta muchas ventajas entre las que se destacan las siguientes: Se pueden escribir como subrutinas secciones de cdigo y ser empleadas varias veces en el mismo programa. Dan a los programas un carcter modular, es decir, se pueden codificar diferentes mdulos para utilizarlos en cualquier programa. Se reduce notablemente el tiempo de programacin y la deteccin de errores, utilizando repetidamente una subrutina.

-

El cdigo es ms fcil de interpretar, dado que las instrucciones de las subrutinas no aparecen en el programa principal, slo figuran las llamadas (CALL).

Las instrucciones CALL y RETURN. Subrutinas La instruccin CALL (llamada a subrutina) consigue que la ejecucin del programa contine en la direccin donde se encuentra la subrutina a la que hace referencia. Es similar a GOTO pero coloca en la pila la direccin de la siguiente instruccin que se debe ejecutar despus de terminar con la subrutina. La subrutina finaliza con la instruccin RETURN (retorno de la subrutina) que retoma la direccin guardada en la pila y la coloca en el contador del programa PC continuando el flujo de control con la instruccin que sigue a CALL. En la familia PIC de gama media la pila tiene ocho niveles de memoria del tipo LIFO (Last In, First Out) (ltimo en entrar, primero en salir). Si se produce la llamada a una subrutina durante la ejecucin de otra subrutina, la direccin de retorno de esta segunda es colocada en la cima de la pila sobre la direccin anterior. Esta segunda direccin es la primera en salir de la pila mediante la instruccin RETURN. Con la pila de ocho niveles, una subrutina puede llamar a otra y sta, a su vez, llamar a otra hasta un mximo de ocho. Todo esto ya lo vimos anteriormente.

4.2 UNIDADES Y/O LIBRERIAS (CON EJEMPLO)

Para quienes estn interesados, les dejo una lista con el nombre de todas las libreras standard de C y las funciones que contiene cada una. Dej los ttulos de las libreras y las variables en ingls ya que quienes programamos nos llevamos mejor con ese idioma (al menos en el momento de la programacin en si) que con nuestro espaol de nacimiento. stdio.h ctype.h string.h math.h stdlib.h assert.h setjmp.h signal.h time.h

Input and Output: FILE *fopen(const char *filename, const char *mode) FILE *freopen(const char *filename, const char *mode, FILE *stream) int fflush(FILE *stream) int fclose(FILE *stream) int remove(const char *filename) int rename(const char *oldname, const char *newname) FILE *tmpfile(void) char *tmpnam(char s[L_tmpnam]) int setvbuf(FILE *stream, char *buf, int mode, size_t size) void setbuf(FILE *stream, char *buf)

int fprint(FILE *stream, const char *format, ) int sprintf(char *s, const char *format, ) vprintf(const char *format, va_list arg) vfprintf(FILE *stream, const char *format, va_list arg) vsprintf(char *s, const char *format, va_list arg) int fscanf(FILE *stream, const char *format, ) int scanf(const char *format, ) int sscanf(char *s, const char *format, ) int fgetc(FILE *stream) char *fgets(char *s, int n, FILE *stream) int fputc(int c, FILE *stream) int fputs(const char *s, FILE *stream) int getc(FILE *stream) int getchar(void) char *gets(char *s) int putc(int c, FILE *stream) int putchar(int c) int ungetc(int c, FILE *stream) size_t fread(void *ptr, size_t size, size_t nobj, FILE *stream) size_t fwrite(const void *ptr, size_t size, size_t nobj, FILE *stream) int fseek(FILE *stream, long offset, int orogin) long ftell(FILE *stream) void rewind(FILE *stream) int fgetpos(FILE *stream, fpos_t *ptr) int fsetpos(FILE *stream, const fpos_t *ptr) void clearerr(FILE *stream) int feof(FILE *stream) int ferror(FILE *stream) void perror(const char *s)

Character Class Tests: isalnum(c) isalpha(c) iscntrl(c) isdigit(c) isgraph(c) islower(c) isprint(c) ispunct(c) isspace(c) isupper(c) isxdigit(c)

String Functions: char *strcpy(s , ct) char *strncpy(s , ct , n) char *strcat(s , ct) char *strncat(s , ct , n) int strcmp(cs , ct) int strncmp(cs , ct ,n) char *strchr(cs , c) char *strrchr(cs , c) size_t strspn(cs , ct)

size_t strcspn(cs , ct) char *strstr(cs , ct) size_t strlen(cs) char *strerror(n) char *strtok(s , ct)

Mathematical Functions: sin(x) cos(x) tan(x) asin(x) acos(x) atan(x) atan2(x) sinh(x) cosh(x) tanh(x) exp(x) log(x) log10(x) pow(x,y) sqrt(x) ceil(x) floor(x) fabs(x) ldexp(x) frexp(x,double *ip) modf(x,double *ip) fmod(x,y)

Utility Functions: double atof(const char *s) int atoi(const char *s long atol(const char *s) double strrod(const char *s, char **endp) long strtol(const char *s, char **endp, int base) unsigned long strtoul(const char *s, char **endp, int base) int rand(void) void srand(unsigned int seed) void *calloc(size_t nobj, size_t size) void *malloc(size_t size) void *realloc(void *p, size_t size) void free(void *p) void abort(void) void exit(int status) int atexit(void (*fcn)(void)) int system(const char *s) char *getenv(const char *name) void *bsearch(const void *key, const void *base, size_t n, size_t size, int (*cmp)(const void *keyval, const void *datum)) void qsort(void *base, size_t n, size_t size, int (*cmp)(const void *, const void *)) int abs(int n)

long labs(long n) div_t div(int num, int denom) ldiv_t ldiv(long num , long denom)

Diagnostics: void assert(int expression)

Non-local Jumps: int setjmp(jmp_buf env) void longjmp(jmp_buf env, int val)

Signals: void (*signal(int sig, void (*handler)(int)))(int)

Data and Time Functions: *tp) clock_t clock(void) time_t time(time_t , *tp) double difftime(time_t time2 , time_t time1) time_t mktime(struct tm *tp) char *asctime(const time_t *tp) char *ctime(const time_t *tp) struct tm *gmtime(const time_t *tp) struct tm *localtime(const time_t *tp) size_t strftime(char *s, size_t smax, const char *fmt, const struct tm

4.3 ENCABEZADO (CON EJEMPLO)

ENCABEZADOS (*.H) Encabezado LIBMOUSE.H TEC.H BLT.H Funcin Encabezado con las declaraciones y la mayora de las rutinas de manejo del mouse Encabezado con el escudo del Instituto Tecnolgico de Nuevo Laredo y el escudo de ISC Encabezado de con rutinas de ventanas, marcos y letreros

PROGRAMAS DE ARCHIVOS

Programa ARCHIVO1.CPP ARCHIVO2.CPP ARCHIVO3.CPP ARCHIVO4.CPP ARCHIVO5.CPP ARCHIVO6.CPP ARCHIVO7.CPP ARCHIVO8.CPP ARCHIVO9.CPP ARCHIV10.CPP ARCHIVOS.CPP REFERENC.CPP REFEREN2.CPP ALIAS.CPP ALIAS2.CPP ARCH_SEC_OBJ.CPP

Funcin Capturar caracteres del teclado y grabarlos en un archivo de texto Lee caracteres grabados en un archivo de texto y los despliega en pantalla Captura cadenas del teclado y las graba en un archivo de texto Lee cadenas grabadas en un archivo de texto y las despliega en pantalla Almacena variables de diversos tipos en un archivo de texto Lee variables de diversos tipos desde un archivo de texto Graba registros completos (incluyendo sus campos) en un archivo secuencial binario Lee secuencialmente (uno por uno) los registros de un archivo binario Graba registros completos (incluyendo sus campos) en un archivo binario de acceso directo Lee registros completos (incluyendo sus campos) de un archivo binario de acceso directo Archivar y cargar una imagen Transmisin de estructuras por referencia a una subrutina Envo por referencia de un alias de un archivo Inicializar 3 archivos de ndice mediante una sola rutina que acepte por referencia los alias de los archivos as como sus registros de control correspondientes. Control de archivo secuencial con programacin orientada a objetos

4.4 DECLARACION (CON EJEMPLO) Declaracin de funciones Antes de empezar a utilizar una funcin debemos declararla. La declaracin de una funcin se conoce tambin como prototipo de la funcin. En el prototipo de una funcin se tienen que especificar los parmetros de la funcin, as como el tipo de dato que devuelve. Los prototipos de las funciones que se utilizan en un programa se incluyen generalmente en la cabecera del programa y presentan la siguiente sintaxis:

En el prototipo de una funcin no se especifican las sentencias que forman parte de la misma, sino sus caractersticas. Por ejemplo:

En este caso se declara la funcin cubo que recibe como parmetro una variable de tipo entero (numero) y devuelve un valor del mismo tipo. En ningn momento estamos especificando qu se va a hacer con la variable numero, slo declaramos las caractersticas de la funcin cubo. Cabe sealar que el nombre de los parmetros es opcional y se utiliza para mejorar la comprensin del cdigo fuente. De esta manera, el prototipo de la funcin cubo podra expresarse de la siguiente manera:

Los prototipos de las funciones son utilizados por el compilador para verificar que se accede a la funcin de la manera adecuada con respecto al nmero y tipo de parmetros, y al tipo de valor de retorno de la misma. Veamos algunos ejemplos de prototipos de funciones:

Las funciones de biblioteca se declaran en lo que se conocen como ficheros de cabecera o ficheros .h (del ingls headers, cabeceras). Cuando deseamos utilizar alguna de las funciones de biblioteca, debemos especificar el fichero .h en que se encuentra declarada la funcin, al inicio de nuestro programa. Por ejemplo, si deseamos utilizar la funcin printf en nuestro programa, debemos incluir el fichero stdio.h que contiene el prototipo de esta funcin. 4.5 CUERPO (CON EJEMPLO)

Cuerpo principal del programa Tambin se le llama bloque del programa, y es junto con la cabecera, la nica seccin obligatoria en un programa Pascal. Debe comenzar y finalizar con las palabras reservadas begin y end respectivamente. Muy imortante: Despus de la palabra end, siempre tiene que ir un punto que indica el final del programa. Entre begin y end se escriben una o ms sentencias, ya sean simples o compuestas. Las sentencias pueden ser varias: asignaciones, llamadas a procedimientos y funciones, sentencias selectivas (sentencias if), sentencias iterativas (sentencias for, while). Veamos un pequeo ejemplo: ... begin i := 0; while i