Manual basico de_lenguje_c
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

Manual basico de_lenguje_c

on

  • 909 views

 

Statistics

Views

Total Views
909
Views on SlideShare
909
Embed Views
0

Actions

Likes
0
Downloads
2
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Manual basico de_lenguje_c Document Transcript

  • 1. ESCUELA POLITECNICA NACIONAL FACULTAD DE INGENIERIA DE SISTEMAS MANUAL DE LENGUAJE C
  • 2. TABLA DE CONTENIDOSCAPITULO ITIPOS DE DATOS Representación de los tipos de datos Caracteres Enteros Los flotantes Tipo de dato void Caracteres con barra invertidaCAPITULO IIOPERADORES Operadores aritméticos Operadores de comparación Operadores lógicos Operadores a nivel de bits El operador ? Operadores de asignación La coma como operador Operadores de incremento y decremento Operadores de puntero * y & Operador en tiempo de compilación sizeof Los operadores de punto y flecha Los paréntesis y los corchetes como operadores Resumen de precedenciasCAPITULO IIITIPOS DE DATOS DERIVADOS Arreglos Variables de tipos punteroCAPITULO IVEVALUACION DE EXPRESIONES y ASIGNACION DINAMICA DE MEMORIA Evaluación de expresiones Asignación dinámica de memoria
  • 3. CAPITULO VVARIABLES Variables locales Parámetros formales Variables globales Clases de almacenamiento Inicialización de variablesCAPITULO VISENTENCIAS DE CONTROL Valores true y false La sentencia while La sentencia do-while La sentencia for La sentencia if-else La sentencia switch La sentencia break La sentencia continue La sentencia exit La sentencia gotoCAPITULO VIIINTRODUCCION A LA PROGRAMACION ORIENTADA A OBJETOS Generalización vs especialización Funcionalidad propuesta
  • 4. GENERALIDADESUna de las características fundamentales que se busca actualmenteen un lenguaje de programación es que sea portable, esto es, queun programa elaborado en una máquina con características propiaspueda ser corrido, realizando mínimas correcciones en otra máquinadiferente.La estrategia de portabilidad es bastante importante ya que nosayuda a mantener nuestros programas, a través de múltiplesplataformas hardware. Esta estrategia influye directamente endecisiones económicas y sociales, puesto que nos ahorra un cambiobrusco en la concepción de un lenguaje por parte de los programa-dores que pasan a través de diferentes generaciones de lenguajes.Pero C no se queda ahí, actualmente es el lenguaje universal, y suuniversalidad se debe bastante a la gran acojida mundial que atenido el sistema operativo UNIX, el cual incluye en su conjuntode herramientas básicas al compilador C.En un principio, al igual que otros lenguajes, no existía unconjunto de estándares definidos para C. Pero en 1983, el insti-tuto de estándares americano ANSI definió los estándares de C. Deesta manera, todos los compiladores principales de C ya hanimplementado el estándar ANSI.Ahora, las grandes casas de hardware ofrecen al cliente como unabuena estrategia de venta, la capacidad de poder correr uncompilador C que cumpla con los estándares dados por el institutoANSI.Hace pocos años C pasó a ser el núcleo de lo que hoy es ellenguaje C++, por lo que C++ es ahora un superconjunto de C. Estainclusión es una gran ventaja para los programadores que trabajanen C y que están introduciéndose a la programación orientada aobjetos ofrecida por C++.
  • 5. 1 INTRODUCCIONCero es un punto de partida en C, pues C usa cero para indicarfalso, sus arrays comienzan con cero, y cero es el valor deretorno de una operación exitosa en una función.C es poderoso debido a la cuidadosa inclusión de las estructurascorrectas de control y los tipos de datos. Es un lenguaje quetiene un conjunto compacto de palabras reservadas.C no es un lenguaje fuertemente estructurado, en el sentido dePascal y Algol 68, y esto se puede observar en la imposibilidad deinclusión de funciones anidadas. Es relativamente flexible en laconversión de datos, aunque no realice conversión automática detipos de datos con la facilidad de PL/I.C es un lenguaje de propósito general, pero que no ofrece multi-programación, paralelismo, sincronización, o programación parasistemas especiales; para estos propósitos existen compiladores Ccon estas características particulares.C es un lenguaje de programación de empleo general, siendoconsiderado como un lenguaje de "bajo nivel" relativo, estosignifica que C trabaja con la misma clase de objetos que lamayoría de las computadoras: caracteres, números y direcciones,que pueden ser combinados con los operadores aritméticos ylógicos, utilizados normalmente en las máquinas.C no contiene funciones para trabajar directamente con elementoscomo por ejemplo funciones de entrada-salida: No existen proposi-ciones implícitas "READ" o "WRITE" como las que existen en ellenguaje Pascal, ni métodos propios para el acceso a archivos.Todos estos mecanismos de alto nivel deben ser aportados porfunciones llamadas explícitamente.Un programa realizado en C, cualquiera que sea su tamaño, constade una o más "funciones" que especifican las operaciones decálculo que han de realizarse. Las funciones de C son similares alas funciones y subrutinas de otros lenguajes de programación.La palabra "main" identifica el nombre de la función principal quesiempre debe existir si se desea ejecutar un programa y lasinstrucciones contenidas entre llaves ({ y }) especifican el─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 6. 2cuerpo de la función; estas instrucciones se cumplen en formasecuencial, el momento en que se invoca el nombre de la funciónque las contiene. La función "main" es inmediatamente ejecutada alcorrer el programa ya compilado:─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 7. 3 CAPITULO I TIPOS DE DATOS1.1 REPRESENTACION DE LOS TIPOS DE DATOS.El lenguaje de programación C tiene una serie de datos básicos losmismos que siempre estarán guardados en una serie de bits. Porejemplo un caracter (char en C) se guarda en un byte (8 bits). Elalmacenamiento depende del tipo de máquina con el que trabajamos,generalmente son máquinas de 16 bits o de 32 bits. En lasiguiente tabla se tiene estos tipos de datos: ╔═══════════════════════════════════════════════╗ ║ maquinas de ║ ║tipo representa a 16 bits 32 bits║ ╟───────────────────────────────────────────────╢ ║char caracteres 8 8 ║ ║int enteros 16 32 ║ ║short enteros cortos 16 16 ║ ║long enteros largos 32 32 ║ ║unsigned enteros sin signo 16 32 ║ ║float flotantes 32 32 ║ ║double flotante doble 64 64 ║ ║ precisi≤n ║ ║void generico 0 0 ║ ╚═══════════════════════════════════════════════╝1.2 LOS CARACTERESLos caracteres se guardan en ocho bits, o un byte, enumerados dela manera inversa como se presenta a continuación: 7 6 5 4 3 2 1 0 +-+-+-+-+-+-+-+-+la representación de "a" (0x61) en binario es: ┌─┬─┬─┬─┬─┬─┬─┬─┐ │0│1│1│0│0│0│0│1│ └─┴─┴─┴─┴─┴─┴─┴─┘─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 8. 4Los caracteres representan todos los dados en el código ASCII, hoyen día se hace uso del ASCII EXTENDIDO, que se guarda en 8 bits,del bit 0 al bit 7. Con el código ASCII extendido se puederepresentar un total de 256 caracteres, que van desde el 0 al 255.Este código representa a caracteres de control, del 0 al 31, acaracteres tipográficos como las letras mayúsculas, las minús-culas, los dígitos, símbolos, etc.La representación del código ASCII generalmente hace referencia asus caracteres, por ejemplo, el alfabeto, tiene los caracteres dela "a" a la "z", la letra "a" tiene el código decimal 97, que enhexadecimal es 0x61. Esto permite operaciones como suma, resta,etc., por ejemplo "a" + 1 equivale a 97 + 1 que da como resultado"b". "5" - "0" equivale a restar 53 - 48 lo que nos da el código 5(un caracter de control).1.3 LOS ENTEROSDe acuerdo a su alcance tienen diferentes formas de representaciónen C:1.3.1 Enteros (int). Estos se guardan en 1 palabra (dos bytes),el bit más significativo (el 15) es de signo (0 positivo, 1negativo), los otros 15 bits (del 0 al 14) son bits de datos: ┌──┬──┬──┬──┬──┬──┬──┬──┐ ┌──┬──┬──┬──┬──┬──┬──┬──┐ │15│14│13│12│11│10│ 9│ 8│ │ 7│ 6│ 5│ 4│ 3│ 2│ 1│ 0│ └──┴──┴──┴──┴──┴──┴──┴──┘ └──┴──┴──┴──┴──┴──┴──┴──┘el rango de valores que se puede contener un entero es: -215 <= entero <= 215 - 1que es lo mismo que: -32768 <= entero <= 32767Esta representación es para compiladores de 16 bits. Para compi-ladores de 32 bits como Watcom C, se tiene un bit de signo, el 31,y 31 bits de datos, del 0 al 30, lo que da un rango de valores: -231 <= entero <= 231 - 1─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 9. 51.3.2 Enteros cortos (short). Para compiladores de 16 bits y 32bits, un entero corto coincide con la definición y rango dado paraenteros (int).1.3.3 Enteros Largos (long).- Para máquinas de 16 y 32 bits losenteros largos se almacenan en 4 bytes, igualmente el bit mássignificativo (el 31) será el bit de signo, mientras que los 31restantes serán de datos (del 0 al 30), con lo que tenemos unrango de valores entre -231 y 231-1.1.3.4 Enteros sin signo (unsigned).- Para máquinas de 16 bits losenteros sin signo se almacenan en 2 bytes, y para máquinas de 32bits se almacenan en 4 bytes. Como su nombre lo dice, no se tomaen cuenta el bit de signo, es decir que todos los bits son dedatos, con esto tenemos un rango de valores entre 0 y 216 paramáquinas de 16 bits, y entre 0 y 232 para máquinas de 32 bits.1.4 LOS FLOTANTESLos valores de punto flotante se refieren a aquellos en que debenestar presentes el punto decimal, y expontes con base 10, que sonlos números reales como por ejemplo: 1.3456 3.14657 0.8754 1.2e-34 1.2e-20 representa a 0.12*10-19El rango de valores que puede tomar el tipo flotante, está entre10-37 y 10+37. Los números de punto flotante (float y double)representan internamente a la mantiza, que es la parte fracciona-ria, y al exponente. Para el último ejemplo, en la mantizaencontramos el valor 12 (la parte fraccionaria) y el exponente es-19.Tanto float como double tienen el mismo rango de valores, sinembargo double da una mayor precisión en la mantiza, teniendohasta diez dígitos de precisión frente a seis dados por floatA continuación se indica una tabla con los tipos de datos básicos:Tipo Tamaño(bits) Rango─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 10. 6──────────────────────────────────────────────────────────────char 8 bits -128 a 127int 32 -32768 a 32767unsigned int 16 0 a 65535long int 32 -2,147,483,648 a -2,147,483,647float 32 seis dígitos de precisióndouble 64 diez dígitos de precisiónlong double 128 diez dígitos de precisión──────────────────────────────────────────────────────────────El diagrama que se muestra a continuación representa las formas enque podemos combinar los tipos de datos elementales con lasrespectivas extensiones para obtener nuevos tipos de datos; porejemplo el grupo de enteros está conformado por el tipo de datoelemental int y también por unsigned int, short int y long int.tipo elemental >─┐ ├───────────────────────┬──────char ├───unsigned──────>─────┘ ├───────────────────────┬───────int │ │ ├──────────short──────>─┤ │ │ ├──────────unsigned───>─┤ │ │ ├──────────long───────>─┘ │ ├───────────────────────────────float ├────────────────────────┬──────double └──────────long───────>──┘1.5 TIPO DE DATO VOIDEs tipo de dato void no especifica un tipo de dato fijo, sino quepuede adaptarse a cualquier tipo dada una circunstancia específi-ca. Veamos algunas declaraciones de variables y funciones tipovoid:void *p; Indica que p es un puntero genérico, nos es útil paraguardar en memoria objetos cuyos tipos de datos nos sean descono-cidos.─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 11. 7void fun1(); es una función que no retornará ningún valor, porejemplo, en "dos.h" existe la función clrscr(), que se limita aborrar todo lo que esté en pantalla, esta función realizará estatarea sin necesidad de retornar valor alguno.int fun2(void); indica que no se requiere colocar argumentos deentrada, como por ejemplo una función para obtener la fecha delsistema, date(), no se requiere de argumento alguno.void *fun3(); esta función devolverá un puntero genérico, se loestudiará detenidamente cuando se revise las funciones malloc ycalloc.1.6 CARACTERES CON BARRA INVERTIDAEl incluír entre comillas los carateres es suficiente paraimprimir en pantalla una salida, por ejemplo la siguiente cadenade caracteres: "hola, mundo", sin embargo es necesario que sepueda incluír dentro de esta cadena de caracteres, algunoscontroles, es por ello que C dentro de cadenas nos permiteutilizar códigos de control por medio de la barra invertida . Porejemplo, al imprimir el mensaje enterior, si queremos que haya unsalto de línea (nueva línea) luego de la impresión, el formato dela cadena sería: "hola, mundo n", donde n es el orden de saltode línea. Veamos una tabla de códigos de barra invertida: codigo significado ──────────────────────────────────── b espacio atrás f salto de página n salto de línea r salto de carro t tabulación horizontal " imprime comillas imprime comilla simple 0 caracter nulo imprime barra invertida v tabulación vertical a alerta o constante octal x constante hexadecimal ─────────────────────────────────────────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 12. 8La manera de representar el caracter nulo es 0, en realidadpodemos extendernos para que ### sea la impresión del caractercuyo código ASCII esté dado por ###, por ejemplo para obtener unsonido de la computadora 007.─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 13. 9 CAPITULO II OPERADORESUna de las mejores características de C es la cantidad de opera-dores que posee y los diversos niveles en los que actúa:2.1 OPERADORES ARITMETICOSSe tienen los siguientes operadores aritméticos ya conocidos enotros lenguajes: + operador binario de suma - operador binario de resta * operador binario de multiplicación / operador binario de división % operador binario de resto de divisiónEl operador - se lo puede utilizar también como operador unarioque hace negativo a un número. Generalmente casi todos estosoperadores nos permiten realizar las operaciones aritméticasbásicas, adicionalmente se tiene el operador % que es el resto deuna división, por ejemplo, la respuesta a la operación 7%4 es 3(entero), el resultado de 9 % 3 es 0, el de 5 % 2 es 1, 1 % 8 dará1, etc.1.2 OPERADORES DE COMPARACIONLos operadores binarios de comparación son: > mayor que < menor que == igual que >= mayor o igual que <= menor o igual que != no es igual queEstos operadores compararán dos expresiones, el resultado será unvalor entero, 0 si no cumple con la relación de comparación, o 1si la cumple, por ejemplo si la relación x < y es verdadera,tendremos que se devuelve un valor entero 1, caso contrario, elvalor será 0. Veamos algunos ejemplos:─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 14. 10 si a = 10 y b = 15 entonces ( a < b ), ( a <= b ), ( a != b ) darán todos 1, en cambio que ( a > b ) ( a >= b ) y ( a == b ) darán todos 0.1.3 OPERADORES LOGICOSLos operadores lógicos son: ! es la negación (operador unario) && es el operador binario lógico de intersección (and) || es la operador binario lógico de unión (or)El operador ! invierte el resultado de una expresión cuando hasido verdadera o falsa. Para los ejemplos anteriores tendremos que!( a > b ) dará un 1 y !( a < b ) dará un 0.Veamos las tablas de funcionamiento (o tablas de verdad) de laintersección (&&) y unión (||): && | 0 1 || | 0 1 0 | 0 0 0 | 0 1 1 | 0 1 1 | 1 1se puede realizar operaciones mas complejas entre relaciones como: (( a > b ) && !(1 == 2)) || (b == a) ((0) && !(0)) || (0) (0 && 1 ) || 0 0 || 0 01.4 OPERADORES A NIVEL DE BITSC soporta un completo juego de operadores a nivel de bits. Dadoque el lenguaje se diseño para sustituir al ensamblador en muchastareas de programación, era importante permitir todas las opera-ciones que se pueden hacer en ensamblador.Estas operaciones se refieren a la comprobación, asignación odesplazamiento de los bits reales que componen un byte o unapalabra, que corresponden a los tipos estándar de C char e int.Las operaciones a nivel de bits no se pueden usar sobre otros─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 15. 11tipos. La tabla de la siguiente página lista los operadores quese aplican a las operaciones a nivel de bits.Los operadores &, | y ~ a nivel de bits están basados en la mismatabla de verdad que sus equivalentes lógicos, excepto que trabajanbit a bit.Para el caso de XOR, el resultado es verdad si uno y sólo uno delos operandos es verdad Operador Acción & (Y) | (O) ^ (XOR) ~ Complemento a uno (NOT) >> Desplazamiento a la derecha << Desplazamiento a la izquierdaComo ejemplo, se detalla una función que leerá un caracter delpuerto del modem, utilizando la función leer_modem() y pondrá elbit de paridad a cero:char car_del_modem(void){ char c; c = leer_modem(); /*obtener un caracter del puerto del modem */ return( c & 127)}El bit de paridad, el cual se utiliza para indicar que el resto delos bits del byte no han cambiado, utiliza el bit más signifi-cativo de cada byte, que es el octavo bit.Al realizar un AND (Y) entre un byte que tenga los bits de 1 a 7en uno y el bit ocho en cero y el byte recibido por el modem, laparidad se pone a cero. La expresión c & 127 da como resultadoesta operación. En el ejemplo se supone que en c se ha recibidoel carácter "A" con el bit de paridad a uno:Bit de paridad│V1 1 0 0 0 0 0 1 c conteniendo "A" con paridad a 1─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 16. 120 1 1 1 1 1 1 1 127 en binario&───────────────────── hacer Y a nivel de bits0 1 0 0 0 0 0 1 "A" sin paridadLa operación OR (O) bit a bit siendo la inversa de (Y), pone losbits a uno. Cualquier bit del operando que esté puesto a 1 haceque el correspondiente bit de la variable se ponga a uno.Recuerde que los operadores relacionales y lógicos siempreproducen un resultado que es 0 ó 1.Los operadores de desplazamiento >> y <<, mueven todos los bits deuna variable a la derecha o a la izquierda según se especifique.La forma general de una sentencia de desplazamiento a la derechaes: variable >> número de posiciones en bitsLa sentencia de desplazamiento a la izquierda es: variable << número de posiciones en bitsA medida que se desplazan los bits hacia un extremo se va relle-nando con ceros por el extremo opuesto, recuerde que un desplaza-miento no es una rotación, es decir que los bits que salen por elun extremo no ingresan al otro.Las operaciones de desplazamiento de bits pueden ser muy útilescuando se decodifica la entrada a través de dispositivos externos,como los convertidores D/A, y en la lectura de información deestado. Se pueden utilizar también para operaciones rápidas demultiplicación y división entre enteros. Un desplazamiento a laizquierda equivale a una multiplicación por 2 y uno a la derechauna división por 2Ejemplo de desplazamiento.#include "stdio.h"{ unsigned int i; int j; i = 1;─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 17. 13 /* desplazamientos a la izquierda */ for (j=0; j<4; j++) { i = i << 1; /* desplazar i a la izquierda en 1, que es lo mismo que multiplicarlo por 2 */ printf("desplazamiento a la izquuierda %d: %dn",j,i); }}El operador de complemento a uno (~) cambia el estado de cada biten la variable especificada, es decir, los 1 se ponen a 0 y los 0a 1.Los operadores a nivel de bits se usan a menudo en rutinas decifrado. Si se quiere que un archivo parezca ilegible, basta conllevar a cabo en él algunas operaciones a nivel de bits.1.5 EL OPERADOR ?C contiene un operador muy potente que se usa para sustituirciertas sentencias en la forma if-then-else. El operador ternario? toma la forma general: Exp1 ? Exp2 : Exp3donde Exp1, Exp2 y Exp3 son expresiones. y ? actúa de la siguienteforma: Evalúa Exp1. Si es cierta, evalúa Exp2 y toma ese valorpara la expresión, Si Exp1 es falsa, evalúa Exp3 tomando su valorpara la expresión. Por ejemplo:x = 10;y = x>9 ? 100 : 200;a y se le asigna el valor de 100. Si x hubiera sido menor que 9, yse habría recibido el valor de 200. Este mismo código escrito conla sentencia if-then-else es:x = 10;─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 18. 14if (x>9) y = 100;else y = 200;1.6 EL OPERADOR DE ASIGNACIONAl igual que otros lenguajes, en C las operaciones más básicas secomplementan con la sentencia más simple, la de asignación (porejemplo a = b + c). Sin embargo en C, = es un operador (así comolos operadores aritméticos), es decir que a=b+c es una expresiónantes que solo una sentencia de asignación. El tener a = como unoperador, nos permite tener operaciones complejas tales como: a = b + c = d + 2; equivale a c = d + 2; a = b + c;Igualmente esta característica del igual (=) nos permite quepodamos construír operadores compuestos: a = a + b equivale a a += b a = a - b a -= b a = a & 0x0F a &= 0x0FEsta composición de operadores se permite entre los operadoresbinarios aritméticos y de manipulación de bits ( + - * / & | ^ <<>> ).1.7 LA COMA COMO OPERADORComo operador, la coma encadena varias expresiones. La parteizquierda del operador coma siempre se evalúa como void. Estosignifica que la expresión de la parte derecha se convierte en elvalor de la expresión total separada por coma. Por ejemplo: x = (y=3, y+1);primero asigna el valor de 3 a y y luego asigna el valor de 4 a x Los paréntesis son necesarios debido a que el operador coma tienemenor precendencia que el operador de asignación.1.8 OPERADORES DE INCREMENTO Y DECREMENTO─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 19. 15Los operadores de incremento (++) y decremento (--) nos permitenoptimizar operaciones de suma o resta en 1 x = x + 1 es igual a x += 1 e igual que ++x o x++ x = x - 1 es igual a x -= 1 e igual que --x o x--La diferencia entre ++x o x++ es que en el primer caso la variablese incrementa antes de su utilización, en cambio que en el segundocaso, la variable se incrementa luego de su utilización, igualcosa ocurrirá con el decremento. Ejemplo: p[++s] = 2 equivale a s += 1 p[s] = 2 p[++s] = 2 equivale a p[s] = 2 s += 11.9 OPERADORES DE PUNTERO & y *Un puntero es la dirección de memoria de una variable. Unavariable puntero es una variable específicamente declarada paracontener un puntero a su tipo específico. El primer operador depunteros es &, un operador monario que devuelve la dirección dememoria del operando, por ejemplo: m = &cont;coloca en m la dirección de memoria de la variable cont. No tienenada que ver con el valor de cont.El segundo operador de punteros es * que es complementario de &.Es un operador monario que devuelve el valor de la variableubicada en la dirección que se especifica. Por ejemplo, si mcontiene la dirección de memoria de la variable cont, entonces: q = *m;colocará el valor de cont en q.Las variables que vayan a contener punteros se declararán comotales. Las variables que vayan a mantener direcciones de memoria o punteros, deberán declararse colocando un * delante del nombre─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 20. 16de la variable. Esto indica al computador que va a contener unpuntero a ese tipo de variable. Por ejemplo, para declarar c comopuntero a caracter podemos escribir char *c;Aquí, c no es un caracter, sino un puntero a un caracter. El tipode dato al que apunta un puntero, en este caso char, se denominatipo base del puntero, así, un puntero a caracter (o cualquierpuntero en general) tiene un tamaño sufuciente para guardar unadirección tal como esté definida por la arquitectura de lacomputadora que se utilice.1.10 EL OPERADOR DE TIEMPO DE COMPILACION sizeofEl operador sizeof es un operador monario de tiempo de compilaciónque devuelve la longitud, en bytes, de la variable o delespecificador de tipo entre paréntesis al que precede. Porejemplo, suponiendo que los enteros son de 2 bytes y los float de8 bytes, entonces float f; printf("%f", sizeof f); printf("%d", sizeof int);mostrará 8 2Recuerde que para calcular el tamaño de un tipo, el nombre deltipo debe ir entre paréntesis1.11 LOS OPERADORES PUNTO (.) y FLECHA (->)Estos operadores referencian elementos individuales de lasestructuras y de las uniones. Las estructuras y las uniones sontipos de datos compuestos que se pueden referenciar bajo un solonombre.El operador punto se usa cuando se trabaja realmente con laestructura o la unión, el operador flecha se usa cuando se usa un─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 21. 17puntero a una estructura o una unión. Por ejemplo, dada laestructura global:struct empleado{ char nombre [80]; int edad; float sueldo;} emp;struct empleado *p = &emp; /* en p, la dirección de emp */Se escribirá el siguiente código para asignar el valor 123,34 alelemento sueldo de la estructura emp: emp.sueldo = 123.23;Sin embargo, la misma asignación usando un puntero a la estructuraemp sería: p->sueldo = 123.23;1.12 LOS PARENTESIS Y LOS CORCHETES COMO OPERADORESLos paréntesis son operadores que aumentan la precedencia de lasoperaciones que contienen.Los corchetes llevan a cabo el indexamiento de arrays. Dado unarray, la expresión entre corchetes proporciona un índice para elarray, como en el ejemplo de la siguiente página, se asignaprimero el valor X al cuarto elemento (recuerde que los arraysen C comienzan en el elemento cero) del array c y luego se imprimeese elemento.#include "stdio.h"char c[80];void main (void)─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 22. 18{ c[3] = X; printf("%c", c[3]);}1.13 RESUMEN DE PRECEDENCIASLa siguiente tabla lista la precedencia de todos los operadoresdel lenguaje C, Observe que todos los operadores menos losmonarios y ?, asocian de izquierda a derecha. Los operadoresmonarios (*,&,) y el ? asocian de derecha a izquierda.──────────────────────────────────────────────────────────────Mayor precedencia () [] → . ! ~ ++ -- - (tipo) * & sizeof * / % = - << >> < <= > >= == != & ^ | && || ? = += -= *= /=Menor precedencia ,───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 23. 19 CAPITULO III TIPOS DE DATOS DERIVADOSC nos permite construír a partir de datos elementales otros máscomplejos. Algunos ya los tenemos definidos por el lenguaje,mientras que otros se derivan de los tipos fundamentales.3.1 ARRAY (ARREGLOS)Son tablas de datos del mismo tipo.Declaración.Se necesitarán de cuatro elementos: * nombre del array * tipo * dimensión o cantidad de elementos que lo componen * clase de almacenamiento en memoriaEjemplos: int tab[100];En este ejemplo se ha declarado un array de tipo entero de nombretab que tendrá 100 elementos enteros (tab[0]..tab[99]); elalmacenamiento en memoria queda implícito, pues será de tipoexterno o automático). static char texto[32];En este ejemplo, el tipo ya no es implícito, la clases de ubica-ción posibles de una array en memoria son la externa, estática yautomática.Un array puede ser considerado como una variable o como un todo.Considerada como un todo, es una colección de variables de un tipodado, en que cada uno de los elementos de la colección estádestinado a contener un valor concreto. Si t es el nombre delarray de la tabla entonces: • t[0] es el primer elemento de esta colección.─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 24. 20 • t[i] es el elemento (i-1)-ésimo de la colección y además es una variable de determinado tipo.Si en cambio t se considera como un identificador de un todo, elidentificador t nos permite señalar la dirección donde comienza elalmacenamiento de la tabla. La dirección igual puede obtenerseutilizando el operador & ; es decir &t[0] es lo mismo que t. Siqueremos buscar la dirección i entonces podemos obtenerla sea como&t[i] o como t+i.Valores iniciales de los elementos de un array.Si el almacenamiento de memoria para el array es externo oestático, entonces sus valores iniciales también podrán serdeclarados en el momento de la compilación. Se deberá especificarlos elementos de la lista separados por comas y encerrando lalista entre llaves, quedando por lo tanto opcional la declaracióndel total de elementos del array que, como en los siguientesejemplos, se calculará automaticamente: static char letra[] = {t,e,x,t,o}; static int digito[] = { 0,1,2,3,4,5,6,7,8,9 };En caso de haberse especificado el número total de elementos delarray, los valores iniciales que se especifican deben estar en unnúmero igual o menor al número total explícito: short pares[5] = { 2,4,6 }; donde: pares[0] = 2 pares[1] = 4 pares[2] = 6 pares[3] = 0 pares[4] = 0Tablas multidimensionalesPara la definición de tablas multidimensionales solo necesitamosjuntar los operadores [] que sean necesarios. En el siguienteejemplo tenemos una tabla de 10 tablas de 20 enteros cada una: int t2d[10][20] ;Además se comporta como una tabla bidimensional donde 10 es elnúmero de líneas y 20 el número de columnas. El acceso a un─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 25. 21elemento se obtiene con los índices internos, los mismos que debenvariar entre 0 y la dimensión menos 1.Si queremos inicializar una tabla multidimensional procedemos dela misma manera como se explicitó anteriormente: long t2d [5][4] = { { 0,1,2,3 } /* t2d[0][] */ { 4,5,6,7 } /* t2d[1][] */ { 8,9,10,11 } /* t2d[2][] */ } ; int t3d [2][2][2] = {{ { 1,2 } /* t3d[0][0][] */ { 3,4 } /* t3d[0][1][] */ } { { 5,6 } /* t3d[1][0][] */ { 7,8 } /* t3d[1][1][] */ }} ;El siguiente ejemplo, en cambio inicializa la primera columna a 1: int tab[3][2] = {{1},{1},{1}} ; /* fig.1 */y tiene un comportamiento diferente a: int tab[3][2] = { 1,1,1 } ; /* fig.2 */ fig.1 fig.2 1 | 0 1 | 1 1 | 0 1 | 0 1 | 0 0 | 03.2 VARIABLES DE TIPOS PUNTERO (POINTER)Un puntero (pointer) es una dirección de memoria en cuya localidadestá almacenado un valor correspondiente a un dato. Para el manejode punteros en C se tienen dos operadores: & se refiere a la dirección de un dato.─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 26. 22 * se refiere al contenido de un dato.DeclaraciónEs necesario que una variable de tipo puntero señale a algún tipodefinido: int *ptri ; /* ptri es un puntero a un número entero */El operador de tipo puntero * puede solo aplicarse a expresionesde tipo puntero. El momento de declarar, no se tiene todavía enclaro a qué objeto apuntar, pues se conoce únicamente su tipo, espor ello que también se permite dar un valor inicial. En elsiguiente ejemplo: int i, *p, t[100] ;la variable i está declarada como entero, p como un puntero a unentero, y t un array de 100 enteros. Serán correctas las siguien-tes instrucciones de asignación: p = &i ; /* p apunta al entero i */ *p = 0 ; /* el valor 0 es asignado a i */Para la puesta a 0 de todos los elementos de la tabla t: for (i=0 ; i<99 ; i++ ) t[i]=0;también puede hacerse de las siguiente manera utilizando elpuntero: for ( p=&t[0] ; p < &t[100] ; p++ ) *p=0 ;o también: for ( p=t ; p < t+100 ; p++ ) *p=0 ;Operaciones con punterosExiste una forma equivalente de lograr las direcciones de unarray, tomando en cuenta la última declaración del array t[100] de100 enteros:─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 27. 23 t es equivalente a &t[0] t+i es equivalente a &t[i] t[i] es equivalente a *(t+i)Es por ello que se permiten operaciones como p++ y t+100.Una constante no puede ser asignada como valor a una variable,salvo en el caso de cero: p = 0 ; /* puntero vacío */En tal caso el puntero no apunta a ningún lado.En cambio la adición o substracción (como ya se vio) del valor deuna variable o constante entera son operaciones válidas: p++ (quees lo mismo que p=p+1), y añade 2 al valor actual de p, ya que pseñala a un entero en memoria (un entero se almacena en 2 bytes),la operación p++ debe señalar al entero siguiente. Si se ubieradeclarado como un puntero a double, entonces se añadiría 8 alvalor actual de p. Otras operaciones como p-=2 y p+=(i+5) tambiénson correctas.Esto indica que el valor añadido es convertido en múltiplo deltamaño del objeto al cual señala el puntero afectado por opera-ciones de incremento o decremento. Las otras operaciones aritmé-ticas y lógicas no están permitidas. ( * / % & | ^ ~ ). Operacio-nes como: int *p, *q ; p = 1; q = 2; if (p < q); ....son inválidas ya que en este caso se realiza una operación decomparación con punteros.─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 28. 24 CAPITULO IV EVALUACION DE EXPRESIONES y ASIGNACION DINAMICA DE MEMORIA4.1 EVALUACION DE EXPRESIONESPara el estudio de evaluación de expresiones en C, primero debemosobservar las prioridades de los operadores, las mismas que se danen el siguiente cuadro, donde los operadores () [] -> . son demáxima prioridad mientras que el de menor prioridad será eloperador coma. ┌────────────────────────────────────────────────┬───────────┐ │ () [] -> . │ izq. a der│ │ ! ~ ++ -- - * & (TIPO) sizeof │ der. a izq│ │ * / % │ izq. a der│ │ + - │ izq. a der│ │ << >> │ izq. a der│ │ < <= > >= │ izq. a der│ │ == != │ izq. a der│ │ & │ izq. a der│ │ ^ │ izq. a der│ │ | │ izq. a der│ │ && │ izq. a der│ │ || │ izq. a der│ │ ? | │ izq. a der│ │ = += -= *= /= %= >>= <<= &= |= ^= │ der. a izq│ │ , │ izq. a der│ └────────────────────────────────────────────────┴───────────┘La primera consideración a tomar en cuenta para la evaluación deexpresiones es que las expresiones (que no sean de asignación) seevalúan de izquierda a derecha, tomando en cuenta la tabla deprioridad de operadores, por ejemplo: a + b * c es equivalenta a a + (b * c) b / c + b * c es equivalente a (b / c) + (b * c)─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 29. 25La segunda consideración, para los operadores unarios y deasignación, la evaluación va de derecha a izquierda. Por ejemploen la siguiente asignación: a = a / d + b * c;primero se evalua la a /d luego b * c, seguimos con la suma deestas dos expresiones evaluadas, y por último, luego de haberevaluado la expresión de la derecha procedemos a la asignación.Para el caso de asignaciones múltiples, la evaluación será dederecha a izquierda, en el siguiente ejemplo, primero se evaluaráa + b cuyo resultado se asigna a k, el valor asignado a k seasigna luego a j, y este valor se asigna por último a i. i = j = k = a + b; Veamos otros ejemplos: x = x + b * c; es equivalenta a x += b * c; x = x * (b + c); es equivalente a x *= b + c; x = x * b + c; es equivalente a x = (x * b) + c;4.2 ASIGNACIÓN DINAMICA DE MEMORIAUn aspecto importante de C es la signación dinámica de memoria quese necesitan para algunos casos. Por ejemplo, cuando declaramosuna variable tipo entero, y un punetero a entero: int a; /* a variable entera */ int *pa; /* pa es un puntero a un entero */En el primer caso, para la variable entera a, no es necesario queel programador cree el espacio donde se guardará el valor asignadoa tal variable, el espacio está creado. Para el segundo caso, eldel puntero a entero *pa, en cambio tenemos dos opciones:a) Como el puntero es una dirección a un objeto específico, entonces tenemos la opción de que el puntero apunte a una dirección donde esté un entero, en este caso es a: pa = &a ; /* &a quiere decir la dirección de a */─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 30. 26b) La segunda opción es crear el espacio donde se guarde el valor apuntado por pa. Para esto C nos proporciona tres funciones: calloc, malloc y realloc. Si con estas tres funciones se nos permite la reserva de espacios de memoria, también debemos tener capacidad de liberar espacios de memoria, esto lo haremos con la funsión free.Estas cuatro funciones (malloc, calloc, realloc y free) seencuentran en la librería stdlib.h.4.2.1 La función malloc()#include "stdlib.h"void *malloc(tam);unsigned int tam;Supongamos que se requiere reservar memoria para guardar un númeroentero, el mismo que será señalado por pa, el formato pararealizar dicha operación de reserva de memoria es el siguiente: pa = (int *)malloc(sizeof(int)) ;entonces se puede realizar operaciones de asignación como lasiguiente: *pa = 5;. Esta operación no es posible realizar sin lareserva de memoria previa. La operación de reserva de memoriapuede ser generalizada como sigue: ptr = (tipo *)malloc(sizeof(tipo)) ;En realidad, esta operación puede resultar confusa, sería naturalque se reserve memoria de longitud dada solamente de la siguientemanera: ptr = malloc(sizeof(tipo)) ;Lo que pasa es que malloc() reserva memoria contínua de longituddada por sizeof(tipo), lo que devuelve es un puntero a void,(puntero genérico). Esto implica que (tipo *) hace un casting(conversión de tipo) para adaptar la reserva de memoria al tipo depuntero correcto.─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 31. 27La expresión (tipo *)malloc(sizeof(tipo)) puede ser llamada enforma más simple si declaramos una macro como la que sigue: #define MALLOC(x) ((x*)malloc(sizeof(x))) ;De esta manera la operación de reserva para la variable ap sería: ap = MALLOC(int) ;4.2.2 La función calloc()#include "stdlib.h"void *calloc(num,tam);unsigned int num;unsigned int tam;calloc(), se caracteriza porque guarda una serie de espacios, cadauno de los cuales tiene una longitud dada, además que estosvalores reservados son inicializados con ceros.Para la utilización de calloc debemos conocer dos informaciones,la primera sobre el número de elementos (n), y la segunda sobre lalongitud del tipo de elemento (sizeof(tipo)). Como la funciónsigue entregando un puntero a void es necesario seguir utilizandoel casting. Por tanto el formato es el siguiente: ptr = (tipo *)calloc(n,sizeof(tipo)) ;Así mismo es posible, que por medio de una macro, simplificar lallamada a esta función, la macro podría ser: #define CALLOC(n,x) ( (x *)calloc(n,sizeof(x)) ) ;Para nuestro ejemplo podríamos concluír una equivalencia: ap = MALLOC(int) ; es equivalente a ap = CALLOC(1,int) ;4.2.3 Punetros Nulos (NULL)A los punteros no les podemos asignar valores como:─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 32. 28 ap = 21 ; /* asignación incorrecta */En cambio es posible asignarle un valor cero, esto significa queel puntero no señala a ninguna parte: ap = 0 ; es equivalente a ap = NULL ;NULL es una constante predefinida para punteros, que indicadirección nula.Este valor resulta cuando fracasa el llamado a las funcionesmalloc y calloc, generalmente cuando se solicita más memoria de ladisponible, por ejemplo, en la siguiente expresión: ap = MALLOC(int) ;Si la memoria disponible es menor a la solicitada entonces apseñalará a NULL.4.2.4 Liberación de Bloques de Memoria (free)#include "stdlib.h"void *free(ptr);void ptr;De la misma manera como reservamos memoria es también necesarioliberarla, pues si hemos asignado memoria en forma dinámica,cuando retiremos la referencia a ese espacio, se mantendrá y noestará disponible, es decir se ha convertido en basura.Si no vamos a seguir utilizando ese espacio de memoria entoncesdebemos liberarlo, esto lo conseguiremos con la función free, cuyoformato es: free(ptr);4.2.5 realloc()#include "stdlib.h"─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 33. 29void *realloc(ptr,tam);void *ptr;unsigned int tam;Esta función cambia el tamaño de la memoria apuntada por ptr. Lalongitud del nuevo tamaño está especificada por tam, pudiendotomar valores mayores o menores al anteriormente asignado.─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 34. 30 CAPITULO V VARIABLESLas variables son posiciones en memoria representados por identi-ficadores que almacenan valores de un tipo determinado, y cuyotiempo de vida y modo de almacenamiento está determinado por dóndey cómo se declaren.Un programa en C, el momento de correrse tiene el siguiente mapade memoria:┌─────────────┐│ │ direcciones de retorno de funciones, estado del│ pila │ CPU, variables locales (automßticas).├─────────────┤│ monton │ se utiliza para la asignaci≤n dinßmica de│ (heap) │ memoria (manejo de punteros).├─────────────┤│ variables ││ globales │├─────────────┤│ c≤digo del ││ programa │└─────────────┘Los identificadores se componen de letras (A, B, .. , Z, a, b, .., z) y dígitos (0,1,..9), pero siempre deben comenzar con unaletra o subrayado.C diferencia las letras mayúsculas de las minúsculas, es decir queel identificador de función malloc() es diferente a MALLOC().La declaración de una variable tiene la siguiente forma: <clase> <tipo> <lista de identificadores> ; Por ejemplo: auto int i,j,k; float fi,fj,fk;─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 35. 31Primeramente hemos definido las variables i,j,k, todas ellas detipo entero y cuya clase es automática. En el segundo caso se hadeclarado la lista de variables fi,fj,fk de tipo float, quedandoexplícita la clase.Según donde se declare una variables, éstas puenen ser: 1) Variables locales (dentro de funciones). 2) Parámetros formales (argumentos de funciones). 3) Variables Globales (fuera de funciones).5.1 VARIABLES LOCALESSon todas las variables que se declaran dentro de una función. Sutiempo de vida es el tiempo que dure la ejecución de dichafunción, luego de lo cual se destruye. Esto, en cuanto a funcio-nes, pero también son locales las variables que se crean dentro debloques (un bloque queda delimitado por { }). Veamos dos ejemplos:┌─────────────┐ ┌───────────────────┐│ en funci≤n: │ │en bloque: ││ │ │ ││ func1() │ │... ││ { │ │if (condicion) ││ int x ; │ │ { ││ ... │ │ int array[20] ; ││ } │ │ ... ││ │ │ } ││ func2() │ └───────────────────┘│ { │ fig. 2│ int x ; ││ ... ││ } │ fig. 1└─────────────┘En el caso de la figura 1, tenemos dos funciones, en ambas sedeclara una variable x, la variable x de func1 nada tiene que vercon la variable x de func2, son totalmente independientes. Para─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 36. 32el caso de la figura 2 tenemos una declaración dentro de unbloque, int array[20]; esta variable local se creará en formaautomática si y solo si se ejecuta el respectivo bloque, sihacemos referencia a esta variable fuera del bloque, entoncesobtendremos un error.Las variables locales también pueden declararse como: auto int x;pero esto es innecesario, pues toda variable que no es global eslocal o automática, es por ello que la palabra reservada auto, quesignifica automática, local, casi no es utilizada.Hemos dicho que una variable local está creada mientras dura laejecución de la función donde se las declara, esto impide que selas pueda inicializar en tiempo de compilación, es por ello que siqueremos inicializar o mantener su valor sin que se destruya,podemos declararlas con la palabra reservada static: static int x = 5 ; static float fx ;Esto implica que durante la ejecución del programa se va amentener el espacio en memoria para las variables estáticas enlugar de crearse o destruírse automáticamente, pero el acceso aellas es solo por medio de las funciones donde se las declare.5.2 PARAMETROS FORMALESLos parámetros formales son los argumentos de una función, si esque una función tiene argumentos como en el siguiente caso: int suma(a,b); int a,b; { return (a+b); }─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 37. 33En este ejemplo los parámetros formales son a y b, sus tipos sondeclarados luego de la declaración de la función.5.3 VARIABLES GLOBALESLas variables globales se mantienen durante todo el programa ypueden ser llamadas y cambiadas en cualquier parte de él (como lasvariables en BASIC), la declaración de una variable global debehacerse desde fuera de las funciones, por ejemplo:int cuenta; /* cuenta es variable global */main() { ... cuenta = 100 ; func() ; /* el valor de cuenta ahora es de 101 */ ... }func() { ... ++cuenta; /* cuenta adquire un nuevo valor (101)*/ ... }5.4 CLASES DE ALMACENAMIENTOExisten 4 clases de almacenamiento en memoria para las variables:extern, static, register, auto, las que a continuación sondescritas.5.4.1 extern─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 38. 34Cuando tenemos varios módulos de programación, y necesitamos endeterminado módulo utilizar variables globales que fueron decla-radas en otro, debemos volver a declarar las mismas variables perode clase extern. Supongamos que en el módulo princip.c tenemoslas siguientes declaraciones:princip.c int cuenta; /* cuenta es variable global */ main() { ... }y en el módulo auxil.c necesitamos utilizar la variable globalcuenta declarada en princip.c, entonces tenemos la siguientedeclaración:auxil.c extern int cuenta; func() { ... }5.4.2 staticLas variables estáticas, son variables permanentes, como lasglobales, pero su contenido es conocido sólo si se llama a lafunción donde fueron declaradas. Las variables estáticas puedenser locales o globales. Ya se explicó las variables estáticaslocales. Sobre las variables estáticas globales, podemos decirque solo pueden ser reconocidas y utilizadas únicamente en elarchivo o módulo donde fueron declaradas.5.4.3 registerLas variables register, residen en uno o varios de los registrosdel CPU, no están en la memoria principal de la máquina. En unamáquina con procesador de 16 bits (una PC,XT,AT, etc) una variablede clase register puede tener hasta 16 bits de longitud, es decirpuede ser un char (8 bits), un int, unsigned int, etc.Las variables register pueden ser locales o parámetros formales,no pueden ser globales. Se caracterizan por ser sumamente─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 39. 35veloces, auque son limitadas en su número y longitud. Un ejemplode declaración es el siguiente: potencia(m,e); int m; register int e;5.4.3 autoLas variables automáticas (auto) son las variables locales, y noes necesario la utilización de esta palabra clave por razonesanteriormente expuestas en el estudio de variables locales. Sellaman automáticas porque se crean y se destruyen automáticamenteal correr el bloque donde fueron declaradas.5.5 INICIALIZACION DE VARIABLESLa inicialización de variables permite que éstas tengan un valoral momento de compilación del programa. La inicialización devariables solo es posible para variables globales y estáticas.Observemos los siguiente ejemplos: char ch = a ; int primero = 0 ; static float balance = 123.23 ;Mas adelante, en el estudio de tipos de datos derivados nosextenderemos en formas más complejas de inicialización. CAPITULO VI SENTENCIAS DE CONTROLC tiene una serie de sentencias de control. Para control de bucleso lazos: while, for, do-while. Sentencias condicionales: if yswitch. Funciones que afectan al control de flujo: break,continue y goto.6.1 VALORES true y falseLas pruebas condicionales se basan en expresiones que seanverdaderas o falsas, en C un valor falso es un valor 0, y unverdadero es un valor diferente de 0. Por ejemplo si a==b, esfalso, es decir, a es diferente de b, entonces el resultado de─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 40. 36esta expresión será 0 (flase), caso contrario será un valordiferente de 0, para este caso es 1 (true).6.2 LA SENTENCIA whileLa sentencia while ejecuta las sentencias dentro de un bloquemientras sea verdad una condición y tiene el siguiente formato: while (condición) { sentencias } ;Como vemos, antes de que se ejecuten las sentencias dentro delbloque, debe confirmarse la condición. Esta condición es unaexpresión booleana cuyo resultado será true o false. Veamos elsiguiente ejemplo donde se imprimen los cuadrados del 1 al 10: int a; a = 1; while (a<=10) { printf(" %2d %3d n" , a , a*a ); a++; }En caso de que al inicio del bucle while, el valor de a no fuera 1sino 11, el bloque correspondiente al bucle no se hubieraejecutado ni una sola vez.6.3 LA SENTENCIA do-whileEn el bucle while primero se confirma un condición antes deproceder con la ejecución de sentencias, en do-while ocurre queprimero se ejecuta sentencias y luego se verifica condición, estonos dice que sentencias al menos se ejecutará una vez, el formatoes el siguiente: do─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 41. 37 { sentencias } while(condición) ;La salida del siguiente ejemplo: int a; a = 11; do { printf(" %2d %3d n" , a , a*a ); a++; } while (a<=10) ; será: 11 121por cuanto aunque no cumpla con la condición, al menos va aejecutarse un vez. Si en lugar de la asignación a = 11; tendría-mos la asignación a=1; el ejemplo planteado es equivalente alejemplo dado en while.6.4 LA SENTENCIA forEl formato de la sentencia for es el siguiente: for(inicialización ; condición ; incremento ) { sentencias } ;Donde sentencias se ejecuta un número de veces determinado por losargumentos de for. La inicialización es por lo general unasentencia de asignación para la variable de control, condición esla expresión booleana de terminación, incremento es la forma comose incrementa la variable inicializada. Para nuestro ejemplo: int a; for (a=1 ; a<=10 ; a++) { printf(" %2d %3d n",a,a*a) ;─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 42. 38 }La variable de control es a. Un bucle infinito (sin salida),utilizando for sería: for (;;) printf("bucle infinitob");En la sentencia for, podemos utilizar el operador coma para más deuna variables de control. Por ejemplo en el siguiente ejemplo secopia la cadena s en r, pero en reversa: reverse(s,r) char *s, *r ; { int i,j ; for ( i=strlen(s)-1,j=0 ; i>0 ; j++,i-- ) { r[i] = s[j]; } r[j] = 0; }Aquí podemos ver que existen dos variables de control, i y j, i vadisminuyendo de valor, y j va aumentando. Se ejecutará la únicasentencia, r[i] = s[j], mientras i sea mayor que 0.Un bucle (while, do-while, for) no necesariamente tiene cuerpo,por ejemplo, un bucle de retardo: for( i=0 ; i<1000 ; i++ ) ;no tiene ninguna sentencia de ejecución, lo único que hace esaumentar la variable de control, lo que produce un retardo.6.5 LA SENTENCIA if-elseLa sentencia if ejecuta las sentencias1 en caso de que la condi-ción de un valor true o verdadero, caso contrario (else) ejecutarásentencias2. El formato es:─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 43. 39 if (condición) { sentencias1; } else { sentencias2; }Para el caso de sentencias de condición anidadas, else siemprecorresponde al último if: if (condición1) if (condición2) { sentencias1 ; } else { sentencias2 ; }el último else corresponde al if de condición2.6.6 LA SENTENCIA switchEn if, condición podía tener solo dos valores true o flase, sinembargo, son muchos los casos en que una condición adquiere nvalores (valor1, valor2, etc), debiendo tener sentencias diferen-tes para cada caso, veamos el formato: switch (condición); { case valor1: sentencias1; break; case valor2: sentencias2; break;─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 44. 40 ... case valorn sentenciasn; break; default: sentenciasd }Default ejecutará un conjunto de sentencias cuando han falladotodos los valores posibles. Si la condición es uno de los valorespropuestos (valor1, valor2,... ,valorn), se ejecutarán lassentencias respectivas hasta encontrar un break.La sentencia switch sólo puede comprobar la igualdad, en cambioque if puede evaluar expresiones relacionales y lógicas.6.7 LA SENTENCIA break La sentencia break tiene dos usos:1) finaliza un case dentro de un switch (como ya lo vimos en el estudio de la sentencia switch).2) forzamos la salida de cualquiera de los bucles estudiados (while, do while, for), dejando de lado las condiciones de repetición y el resto de sentencias que se encuentren luego del break en el bloque de repetición.6.8 LA SENTENCIA continueSi break forza la terminación de un bucle, continue obliga a quese vuelva a evaluar la condición del bucle para que pueda volversea ejecutar el bloque de repetición, esto, dejando de lado lassentencias que sigan a continuación de continue; en el siguienteejemplo, se obliga a leer un dígito o un caracter: char ch; for (;;); { ch = getchar();─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 45. 41 if (ch>32 && ch<127) break else { if ( ch<=32 ) continue else printf("ascii extendido"); } }6.9 LA SENTENCIA exit()La función exit() obliga a la terminación de un programa. Puedetener como argumento a 0, exit(0), que significa terminaciónnormal, en caso de que tenga como argumento a un número diferentede 0, se supone que puede acceder a analizar el error con eseargumento.6.10 LA SENTENCIA gotoEl formato de goto es: goto <etiqueta> ;y el de etiqueta es: <nombre-etiqueta>:La sentencia goto nos permite dar un salto a la parte del programadonde se encuentre la etiqueta respectiva. Un programa debidamenteestructurado debe evitar la utilización del goto, de hecho es la"sentencia prohibida" en la programación estructurada.─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 46. 42 CAPITULO VII INTRODUCCION A LA PROGRAMACION ORIENTADA A OBJETOS "Si no se conoce con exactitud qué es lo que un programa contemplará, es mejor es no comenzar a escribirlo"Tenemos una empresa que es a la vez un conglomerado de variasempresas. El software debe reconocer las demandas existentes dedicha empresa así como la evolución a nuevas necesidades, razónsuficiente como para utilizar las técnicas orientadas a objeto enla programación.En un primer acercamiento, se han establecido los siguientesobjetivos: * Un sistema de control de inventario. * Un sistema de ventas. * Una base de datos del personal. * Una consolidación de los datos relevantes de las tres partes anteriores.Un primer problema que se encuentra, la incertidumbre al no quedarclaramente expuestas las necesidades de la empresa. Esta situacióncambiará con el tiempo. Un proceso continuo de especificaciones,implementación y refinamiento de las especificaciones es el métodoque siguen las técnicas orientadas a objeto. Una de las ventajasde estas técnicas, es que el tiempo que el programador utilizapara reescribir código, ahora se lo utilizará en mejorar lasaplicaciones.Lo primero que debemos hacer, es descomponer los estados requeri-dos como existen en la actualidad:El sistema de inventario requerirá de ítemes.El sistema de ventas requerirá de vendedores y distribuidores queharán constar las ordenes.La base de datos del personal implicará la existencia de gente quetrabaje para la empresa.─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 47. 43Por hoy vamos a ignorar -no olvidar- la consolidación, que es lainterrelación de todos los aspectos anteriores.Los sistemas orientados a objeto tratan con objetos que son elanálogo de las cosas del mundo real. Los objetos son autocon-tenidos, resultan de datos y métodos para manipular esos datos: objetos([datos],[métodos])El mayor concepto que está atado a la programación orientada aobjeto es el modelamiento, es decir que el trabajo del programadores construir modelos de software de las cosas del mundo real. Siese trabajo se lo realiza en forma correcta, muchos de losproblemas encontrados en la interacción de esos objetos, dejaránde ser problema, lo que nos llevará a una situación diferente queno se la puede encontrar en los lenguajes tradicionales.En el diseño orientado a objeto, si el primer nivel de lasoperaciones específicas del objeto están correctamente concebidas,entonces el segundo nivel será relativamente fácil de implementar.Esto ocurre porque las operaciones de la aplicación global sonconstruidas desde operaciones basadas en subcomponentesespecíficos de la aplicación. Se facilitan las cosas si seexplotan las bondades de bajo nivel, y si no se logra hacerlo,entonces es mejor reimplementarlas.Nos resultan familiares las librerías de los compiladores C, lasmismas que nos ofrecen operaciones de bajo nivel con las queconstruimos funciones primitivas. Estas funciones para serutilizadas, así como las operaciones de bajo nivel de las libre-rías, deben estar bien implementadas y documentadas.Retornando a la empresa, tomaremos las tres secciones planteadaslas que serán descompuestas. Para hacerlo debemos hacer unacuidadosa examinación de las interrelaciones entre ellas.Primero, el control de inventario es básicamente un contenedor deítemes de inventario. Cada ítem es un objeto con algún datoasociado aún desconocido. Pero podemos asumir algunas cosasprevias: * Existen cierto número de ítemes en stock para cada ítem. * Cada ítem tiene un número de inventario o número parte.─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 48. 44 * Cada ítem es comprado a uno o mas distribuidores. * Hay una historia de compras y ventas para cada ítem.Segundo, el control de ventas es un contenedor de ventas indivi-duales. Para cada venta debe haber: * Una orden del cliente. * Información acerca de la entrega final. * Información acerca del pago.Y, tercero, la base de datos de los empleados, tiene una colecciónde empleados individuales, que contendrá como mínimo: * Dirección del empleado. * Información del impuesto. * Historial del empleo y descripción del trabajo.Lo primero que debemos observar son las similitudes entre cadaobjeto para que sean explotadas. Para este caso, por ejemplo, elsistema de inventario conoce de distribuidores, el sistema deventas conoce de clientes y el sistema de empleados conoce deempleados. Cada uno de esos objetos (clientes, distribuidor yempleados) son personas, con nombre y dirección. Por lo tanto,debe haber un tipo de objeto general en el sistema, un objeto quedefine la característica general de cada uno de esos elementos,las características que todos ellos tienen en común. Podemos decirque esos elementos son clases de otro objeto más general, al quellamaremos entidad.En la POO cada objeto está definido como una clase que pueda servista como un padrón para la creación de objetos específicos quetengan un comportamiento similar.Las clases son agrupadas en jerarquías, que contemplarán clasesmuy generales, hasta aquellas que aplicarán las características aclases específicas. Por ejemplo, tenemos la clase "carnívoro",que tiene las características específicas para todos los animalescarnívoros, es decir trata por igual a perros y leones, porque lacaracterística común de los carnívoros es que comen carne. A un─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 49. 45nivel más bajo, entonces ya sabremos que los perros son muydiferentes de los leones, entonces para describir estas clases, yano será necesario repetir las características de los carnívoros,solo será necesario describir las características específicas.En este punto ya nos vamos aproximando a una estructura de laCompañía de Comercio, la que por lo menos contiene tres coleccio-nes distintas de objetos, una para inventario, otra para ventas yotra para personal. Estas colecciones actúan de la misma manera,es decir que debemos manipular una lista de sus respectivos tipos,y dando un significado uniforme para acceder a ellos. Cada uno deesos subtipos tienen una organización única para un propósitoindividual, sin embargo, todos utilizan la clase entidad paramantener información acerca de las varias clases de gente con lasque se debe tratar.Esto permite que asumamos dos cosas importantes acerca de lasoperaciones del sistema. Los tres grupos de información soncolecciones de datos que operan de la misma manera. No importaque sea un ítem de inventario, un registro de vendedor, o unregistro de empleado, serán recuperados de una colección, elmecanismo para recuperación es el mismo. Al nivel mas alto, laaplicación puede ser esperada para saber que esas son coleccionesy para saber como acceder a sus contenidos. Segundo, hay unaclase objeto, Entidad, que agrupa a personas tales como vendedo-res, empleados y distribuidores. Esta clase define cosas genera-les para todas las personas, desde compañías hasta personasreales. Por lo tanto deberían contener cosas como: * El nombre de la persona o compañía. * La dirección de la persona o compañía.Debemos tener presente que un objeto Entidad no determina si esuna real o una compañía. Ello ocurrirá cuando tengamos clases másdetalladas de entidades para hacer esta distinción. Laprogramación orientada a objeto nos permite el desarrollo desoftware en forma de top-down sin los temores irritantes sobre laintegración final de los módulos que acompañan a este método en laprogramación tradicional. Parece que vamos necesitar un objetogeneral llamado Colección, que debe comportarse de una manerauniforme. Todos los accesos a las bases de datos especializadasse realizará a través de esa colección, y todos los accesos songarantizados que se harán de la misma manera. Ahora es cuando─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 50. 46podemos ignorar al nivel superior y comenzar una descomposiciónmás detallada de cada elemento de la base de datos.Previo a la resolución de los problemas de la compañía, deben serdireccionados algunos problemas tácticos del programador. Real-mente no hay problemas, pero hay límites dentro de los que elprogramador debe operar, y en los que debe definir con exactitudla responsabilidad de hacer en ese momento. La primera área es lainformación que debe manejar y la que no debería manejar. Lasegunda es que funcionalidad el programador puede asumir en esteinstante y cual puede ser postergada para otro momento.Generalización vs. especializaciónAntes de empezar a diseñar los componentes de la base de datosespecializada, las responsabilidades del programador deben serclaramente delineadas. Por ejemplo, para el ítem de inventario,debe haber un número de parte y una descripción. No todos tienencolor y talla. La POO nos permite definir lo que es común paratodos los objetos y que es particular para unos pocos. La POOpermite al diseñador posponer la especialización hasta que laestructura general ha sido construida. Una regla general sevuelve vital en la POO: Ignorar casos especiales hasta que nopuedan ser ignorados mas.Algunos programadores comienzan buscando las peculiaridades de lainformación, ha tal punto que llegan a tener información que nopuede ser relacionada, en lugar de tener una colección de infor-mación coherente sin excepciones y con rasgos comunes. Laespecialización es el último paso a ser desarrollado, luego detener todas las similitudes del sistema a ser explotado. Despuésde que el diseño del sistema general ha sido llevado a cavo yluego de que las excepciones han sido conocidas entonces e imple-mentadas, continúa un proceso de búsqueda de excepciones rarashasta que el cliente encuentra sus propios errores. Debemosgeneralizar bien para que podamos mejorar y aumentar la especia-lización al sistema sin afectar cualquier trabajo desarrolladopreviamente.Funcionalidad Pospuesta.En la programación tradicional, primero creamos las estructuras dedatos, y luego creamos las funciones para manipular dichas─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN
  • 51. 47estructuras de datos. En POO, esto no ocurre. Cuando se crea unanueva estructura u objeto se marca el fin de la responsabilidadcorriente del programador─────────────────────────────────────────────────────────────────Manual del Lenguaje C Laboratorio de Sistemas - EPN