ulises1307

SEGUNDA PARTE PROGRAMACION 1 Operadores De Asignación En principio puede resultar algo futil gastar papel en describir al operador IGUAL A ( = ) , sin embargo es necesario remarcar ciertas características del mismo . Anteriormente definimos a una asignación como la copia del resultado de una expresión ( rvalue ) sobre otra ( lvalue ) , esto implica que dicho lvalue debe tener LUGAR (es decir poseer una posición de memoria ) para alojar dicho valor . Es por lo tanto válido escribir a = 17; pero no es aceptado , en cambio 17 = a; /* incorrecto */ ya que la constante numérica 17 no posee una ubicación de memoria donde alojar al valor de a . Aunque parezca un poco extraño al principio las asignaciones, al igual que las otras operaciones , dan un resultado que puede asignarse a su vez a otra expresión . De la misma forma que (a + b) es evaluada y su resultado puedo copiarlo en otra variable : c = (a + b) ; una asignación (a = b) da como resultado el valor de b , por lo que es lícito escribir c = ( a = b ) ; Debido a que las asignaciones se evalúan de derecha a izquierda , los paréntesis son superfluos , y podrá escribirse entonces : c = a = b = 17; con lo que las tres variables resultarán iguales al valor de la constante . El hecho de que estas operaciones se realicen de derecha a izquierda también permite realizar instrucciones del tipo : a = a + 17 ; Significando esto que al valor que TENIA anteriormente a , se le suma la constante y LUEGO se copia el resultado en la variable . Como este último tipo de operaciones es por demás común , existe en C un pseudocódigo , con el fín de abreviarlas . Así una operación aritmética o de bit cualquiera (simbolizada por OP ) a = (a) OP (b) ; Puede escribirse en forma abreviada como: a OP= b ; Por ejemplo a += b ; /* equivale : a = a + b */ a -= b ; /* equivale : a = a - b */ a *= b ; /* equivale : a = a * b */ a /= b ; /* equivale : a = a / b */ a %= b ; /* equivale : a = a % b */ Nótese que el pseudooperador debe escribirse con los dos símbolos seguidos , por ejemplo += , y no será aceptado +(espacio) = . Los operadores de asignación están resumidos en la TABLA. Tabla de Operadores de Asignación Símbolo Descripción Ejemplo Orden De Evaluación = igual a a = b 13 op= pseudocodigo a += b 13 =?: asig.condicional a = (c>b)?d:e 12 Vemos de la tabla anterior que aparece otro operador denominado ASIGNACION CONDICIONAL . El significado del mismo es el siguiente : lvalue = ( operación relacional ó logica ) ? (rvalue 1) : (rvalue 2) ; de acuerdo al resultado de la operación condicional se asignará a lvalue el valor de rvalue 1 ó 2 . Si aquella es CIERTA será lvalue = rvalue 1 y si diera FALSO , lvalue = rvalue 2 . Por ejemplo, si quisiéramos asignar a c el menor de los valores a ó b , bastará con escribir : c = ( a < b ) ? a : b ; EXPRESIONES Y EVALUACIÓN DE OPERACIONES Orden de prioridad de operadores aritméticos Multiplicativos * Multiplicación / División % Resto en división entera Unarios ! Negación lógica (NOT) ~ Complemento en binario + Más Menos ++ Preincremento o postincremento Predecremento o postdecrement & Dirección * Valor en la dirección de sizeof Tamaño del operando en bytes new Espacio en memoria dinámica delete Desasigna espacio en memoria Prioridad * / % + - Evaluación secuencial de expresiones aritméticas 65.0 / 2 32.5 65 / 2 32 65 % 2 1 5 + 3 * 3 - 4 + 12 * 10 5 + 9 - 4 + 120 14 - 4 + 120 10 + 120 130 6 + 9 * 8 / 2 * 4 - 2 * 3 6 + 72 / 2 * 4 - 2 * 3 6 + 36 * 4 - 2 * 3 6 + 144 - 2 * 3 6 + 144 - 6 150 - 6 144 (63 -20) /(35 -15) 43 / 20 2 (63 -20.0) /(35 -15) 43.0 / 20 2.0 4.2 / 2 + 3.9 / 3 2.1 + 3.9 / 3 2.1 + 1.3 4.4 3 + sqrt(8 % 6 * 10 / 5) 3 + sqrt( 2 * 10 / 5) 3 + sqrt(20 / 5) 3 + sqrt(4) 3 + 2 5 (60 - 20) /35.0 -15 40 /35.0 - 15 1.142 - 15 -13.858 ESTRUCTURA DE UN PROGRAMA Anatomia de un Programa C Siguiendo la tradición, la mejor forma de aprender a programar en cualquier lenguaje es editar, compilar, corregir y ejecutar pequeños programas descriptivos. Analicemos por lo tanto el primer ejemplo. EJEMPLO 1 #include <stdio.h> main() { printf("Bienvenido a la Programación en lenguaje C n"; return 0; } Función Main() Dejemos de lado por el momento el análisis de la primer línea del programa, y pasemos a la segunda. La función main() indica donde empieza el programa, cuyo cuerpo principal es un conjunto de sentencias delimitadas por dos llaves, una inmediatamente después de la declaración main() " { ", y otra que finaliza el listado " } ". Todos los programas C arrancan del mismo punto: la primer sentencia dentro de dicha función, en este caso printf ("......". En el EJEMPLO 1 el programa principal está compuesto por sólo dos sentencias: la primera es un llamado a una función denominada printf(), y la segunda, return, que finaliza el programa retornando al Sistema Operativo. Recuérdese que el lenguaje C no tiene operadores de entrada-salida por lo que para escribir en video es necesario llamar a una función externa. En este caso se invoca a la función printf(argumento) existente en la Librería y a la cual se le envía como argumento aquellos caracteres que se desean escribir en la pantalla. Los mismos deben estar delimitados por comillas. La secuencia n que aparece al final del mensaje es la notación que emplea C para el carácter "nueva línea" que hace avanzar al cursor a la posición extrema izquierda de la línea siguiente. Más adelante analizaremos otras secuencias de escape habituales. La segunda sentencia (return 0) termina el programa y devuelve un valor al Sistema operativo, por lo general cero si la ejecución fue correcta y valores distintos de cero para indicar diversos errores que pudieron ocurrir. Si bien no es obligatorio terminar el programa con un return, es conveniente indicarle a quien lo haya invocado, sea el Sistema Operativo o algún otro programa, si la finalización ha sido exitosa, o no. De cualquier manera en este caso, si sacamos esa sentencia el programa correrá exactamente igual, pero al ser compilado, el compilador nos advertirá de la falta de retorno. Cada sentencia de programa queda finalizada por el terminador "; ", el que indica al compilador el fin de la misma. Esto es necesario ya que, sentencias complejas pueden llegar a tener más de un renglón, y habrá que avisarle al compilador donde terminan. Es perfectamente lícito escribir cualquier sentencia abarcando los renglones que la misma necesite, por ejemplo podría ser: printf("Bienvenido a la Programación" "en lenguaje C n"; Encabezamiento Las líneas anteriores a la función main() se denominan ENCABEZAMIENTO (HEADER) y son informaciones que se le suministran al Compilador. La primera línea del programa está compuesta por una directiva: " #include " que implica la orden de leer un archivo de texto especificado en el nombre que sigue a la misma ( <stdio.h> ) y reemplazar esta línea por el contenido de dicho archivo. En este archivo están incluidas declaraciones de las funciones luego llamadas por el programa (por ejemplo printf() ) necesarias para que el compilador las procese. Por ahora no nos preocupemos por el contenido del archivo ya que más adelante, en el capítulo de funciones, analizaremos exhaustivamente dichas declaraciones. Hay dos formas distintas de invocar al archivo, a saber, si el archivo invocado está delimitado por comillas (por ejemplo "stdio.h" el compilador lo buscará en el directorio activo en el momento de compilar y si en cambio se lo delimita con los signos <.......> lo buscará en algun otro directorio, cuyo nombre habitualmente se le suministra en el momento de la instalación del compilador en el disco ( por ejemplo C:TCINCLUDE). Por lo general estos archivos son guardados en un directorio llamado INCLUDE y el nombre de los mismos está terminado con la extensión .h. La razón de la existencia de estos archivos es la de evitar la repetición de la escritura de largas definiciones en cada programa. Nótese que la directiva "#include" no es una sentencia de programa sino una orden de que se copie literalmente un archivo de texto en el lugar en que ella está ubicada ,por lo que no es necesario terminarla con "; ". Para optimizar el código producido, los lenguajes en general y como parte de la máxima "Divide y Vencerás", colocan una serie de utilidades(funciones, tipos de datos, variables, etc.) en archivos separados, los cuales de pueden utilizar como si estuvieran en el programa que estamos diseñando. El C/C++ en particular trae una gran cantidad de archivos a incluir por medio de la directiva del compilador #include, la cual debe ser colocada preferiblemente al inicio del programa y siempre por fuera del ámbito de las funciones. Los archivos a incluir en el turbo C++ los puede encontrar en el nivel de ayuda del editor. Los siguientes serán los utilizados en el presente manual, y con esta sintaxis: #include <iostream.h> #include <conio.h> #include <string.h> #include <iomanip.h> #include <dos.h> #include <stdlib.h> #include <stdio.h> #include <math.h> #include <values.h> #include <ctype.h> #include <graphics.h> #include <fstream.h> Separadores de Instrucciones Cada lenguaje utiliza alguna convención para separar las diferentes instrucciones del mismo; en el lenguaje C el separador es el símbolo de punto y coma ;. Se debe colocar el punto y coma al final de cada instrucción (statement). En C/C++ el punto y coma marca el fin de una instrucción, es decir es su terminador. Se exceptúan las instrucciones del preprocesador (define, include, etc.), las cuales no llevan punto y coma al final. En tiempo de compilación el "compilador" revisará la sintaxis de las diferentes instrucciones y en caso de encontrar alguna con terminador inadecuado, esto es sin punto y coma, dará un error de sintaxis: " ; expected", es decir que esperaba un punto y coma y encontró otro carácter, en general este otro caracter lo encuentra en la instrucción siguiente, donde marcará el error y confundiendo al recién iniciado. Observe los punto y comas en los programas presentados en este capítulo. Comentarios La inclusión de comentarios en un programa es una saludable práctica, como lo reconocerá cualquiera que haya tratado de leer un listado hecho por otro programador ó por sí mismo, varios meses atrás. Para el compilador, los comentarios son inexistentes, por lo que no generan lineas de código, permitiendo abundar en ellos tanto como se desee. En el lenguaje C se toma como comentario todo caracter interno a los símbolos: /* */ . Los comentarios pueden ocupar uno o más renglones, por ejemplo: /* este es un comentario corto */ /* este otro es mucho más largo que el anterior */ Todo caracter dentro de los símbolos delimitadores es tomado como comentario incluyendo a " * " ó " ( " , etc. Operaciones de Entrada/Salida Un programa para que pueda trabajar, entre otras cosas, debe poder operar los datos que se proporcionan mediante un dispositivo de entrada y poder enviar los resultados después de procesados con la ayuda de un algoritmo a un dispositivo de salida. En la forma estándar o por defecto (default) el dispositivo de entrada será el teclado y el dispositivo de salida la pantalla o monitor. Instrucción de Escritura En Pantalla Para transferir valores de constantes, variables, expresiones algebraicas, o expresiones delimitadas como cadenas de caracteres de la memoria del computador a la pantalla, emplearemos la instrucción Printf() , en su forma por defecto, y la cual se encuentra en el archivo a incluir sodio.h. También se utiliza puts() para las cadenas de caracteres. Para lograr ejecutar un programa se deberán utilizar varias secuencias de teclas, las principales a necesitar e ir "memorizando" son las contenidas en la siguiente Tabla: Secuencias de teclas más utilizadas. Tecla Orden Del Menú F1 Ayuda del editor F2 Grabar en disco F3 Cargar desde disco F4 Ejecutar programa hasta el cursor F5 Hace zoom en la ventana activa F6 Cambia de ventana activa F7 Rastreo del programa con llamado de funciones F8 Rastreo del programa saltando funciones F9 Compila y enlaza el programa F10 Activa el menú principal F10 File New Comenzar un programa nuevo F10 File Change Dir Cambiar directorio actual F10 Window Close All Cerrar todas las ventanas F10 Help Index Índice alfabético de ayuda CTRL + F8 Marca punto en el cual detenerse ejecución CTRL + F9 Compilar y ejecutar(correr) CTRL + Y Borrar una línea CTRL + T Borrar una palabra o espacios Shift + Teclas Mover Marcar bloque Shift + Del Borrar bloque marcado Shift + Ins Restaurar bloque borrado CTRL + KV Mover bloque marcado CTRL + KC Copiar bloque marcado CTRL + KR Leer un archivo como bloque CTRL + KW Grabar un bloque como archivo CTRL + KP Imprimir bloque marcado ALT + 0 Lista ventanas abiertas ALT + 1 al 9 Activa ventana 1 al 9 ALT + F1 Pantalla ayuda anterior ALT + F3 Elimina ventana activa ALT + F4 Abre ventana de depuración ALT + F5 Cambia a ventana de ejecución del programa ALT + F7 Error anterior ALT + F8 Error siguiente ALT + F9 Compilar a archivo .OBJ ALT + X Salir(eXit) del editor del C++ Cuerpo del Programa Los programas en C/C++ deberán estar compuestos de al menos una función, la función main(), sin esta el programa no trabajará por sí solo. Cada función del programa, consta de la secuencia de instrucciones o algoritmo que la computadora deberá realizar. El algoritmo debe incluir identificadores, operadores y palabras claves. Todo algoritmo se desarrollará con tres tipos de instrucciones: Secuenciales, Selectivas y Repetitivas; el entendimiento de estas tres es el objetivo principal de este curso. De esta forma el algoritmo es simplemente la secuencia de pasos que interpretan un problema específico, en algún campo del saber, y que la computadora podrá ejecutar y de esta forma nosotros obtener los resultados deseados. El C++ es un lenguaje de formato libre. Los espacios en blanco adicionales y los caracteres de salto de línea no son relevantes para el compilador, excepto cuando se requieren para conservar identificadores y las palabras claves o dentro de variables de tipo de cadena. Las líneas del programa pueden tener una longitud máxima de hasta 127 caracteres, siendo preferible utilizar menos de los primeros 80 por motivos de presentación en las impresiones del código fuente. Recordar que la pantalla tiene en modo de texto 80 columnas. PROCESO DE CREACIÓN Y EJECUCIÓN DE UN PROGRAMA Probablemente este es el lugar más adecuado para explicar cómo se obtiene un fichero ejecutable a partir de un programa C++. Para empezar necesitamos un poco de vocabulario técnico. Veremos algunos conceptos que se manejan frecuentemente en cualquier curso de programación y sobre todo en manuales de C y C++. Fichero fuente y programa o código fuente: Los programas C y C++ se escriben con la ayuda de un editor de textos del mismo modo que cualquier texto corriente. Los ficheros que contiene programas en C o C++ en forma de texto se conocen como ficheros fuente, y el texto del programa que contiene se conoce como programa fuente. Nosotros siempre escribiremos programas fuente y los guardaremos en ficheros fuente. Ficheros objeto, código objeto y compiladores: Los programas fuente no pueden ejecutarse. Son ficheros de texto, pensados para que los comprendan los seres humanos, pero incomprensibles para los ordenadores. Para conseguir un programa ejecutable hay que seguir algunos pasos. El primero es compilar o traducir el programa fuente a su código objeto equivalente. Este es el trabajo que hacen los compiladores de C y C++. Consiste en obtener un fichero equivalente a nuestro programa fuente comprensible para el ordenador, este fichero se conoce como fichero objeto, y su contenido como código objeto. Los compiladores son programas que leen un fichero de texto que contiene el programa fuente y generan un fichero que contiene el código objeto. El código objeto no tiene ningún significado para los seres humanos, al menos no directamente. Además es diferente para cada ordenador y para cada sistema operativo. Por lo tanto existen diferentes compiladores para diferentes sistemas operativos y para cada tipo de ordenador. Librerías: Junto con los compiladores de C y C++, se incluyen ciertos ficheros llamados librerías. Las librerías contienen el código objeto de muchos programas que permiten hacer cosas comunes, como leer el teclado, escribir en la pantalla, manejar números, realizar funciones matemáticas, etc. Las librerías están clasificadas por el tipo de trabajos que hacen, hay librerías de entrada y salida, matemáticas, de manejo de memoria, de manejo de textos, etc. Hay un conjunto de librerías muy especiales, que se incluyen con todos los compiladores de C y de C++. Son las librerías ANSI o estándar. Pero también hay librerías no estándar, y dentro de estas las hay públicas y comerciales. En este curso sólo usaremos librerías ANSI. Ficheros ejecutables y enlazadores: Cuando obtenemos el fichero objeto, aún no hemos terminado el proceso. El fichero objeto, a pesar de ser comprensible para el ordenador, no puede ser ejecutado. Hay varias razones para eso: 1. Nuestros programas usaran, en general, funciones que estarán incluidas en librerías externas, ya sean ANSI o no. Es necesario combinar nuestro fichero objeto con esas librerías para obtener un ejecutable. 2. Muy a menudo, nuestros programas estarán compuestos por varios ficheros fuente, y de cada uno de ellos se obtendrá un fichero objeto. Es necesario unir todos los ficheros objeto, más las librerías en un único fichero ejecutable. 3. Hay que dar ciertas instrucciones al ordenador para que cargue en memoria el programa y los datos, y para que organice la memoria de modo que se disponga de una pila de tamaño adecuado, etc. La pila es una zona de memoria que se usa para que el programa intercambie datos con otros programas o con otras partes del propio programa. Veremos esto con más detalle durante el curso. Existe un programa que hace todas estas cosas, se trata del "link", o enlazador. El enlazador toma todos los ficheros objeto que componen nuestro programa, los combina con los ficheros de librería que sea necesario y crea un fichero ejecutable. Una vez terminada la fase de enlazado, ya podremos ejecutar nuestro programa. Errores Por supuesto, somos humanos, y por lo tanto nos equivocamos. Los errores de programación pueden clasificarse en varios tipos, dependiendo de la fase en que se presenten. Errores de sintaxis: son errores en el programa fuente. Pueden deberse a palabras reservadas mal escritas, expresiones erróneas o incompletas, variables que no existen, etc. Los errores de sintaxis se detectan en la fase de compilación. El compilador, además de generar el código objeto, nos dará una lista de errores de sintaxis. De hecho nos dará sólo una cosa o la otra, ya que si hay errores no es posible generar un código objeto. Avisos: además de errores, el compilador puede dar también avisos (warnings). Los avisos son errores, pero no lo suficientemente graves como para impedir la generación del código objeto. No obstante, es importante corregir estos avisos, ya que el compilador tiene que decidir entre varias opciones, y sus decisiones no tienen por qué coincidir con lo que nosotros pretendemos, se basan en las directivas que los creadores del compilador decidieron durante su creación. Errores de enlazado: el programa enlazador también puede encontrar errores. Normalmente se refieren a funciones que no están definidas en ninguno de los ficheros objetos ni en las librerías. Puede que hayamos olvidado incluir alguna librería, o algún fichero objeto, o puede que hayamos olvidado definir alguna función o variable, o lo hayamos hecho mal. Errores de ejecución: incluso después de obtener un fichero ejecutable, es posible que se produzcan errores. En el caso de los errores de ejecución normalmente no obtendremos mensajes de error, sino que simplemente el programa terminará bruscamente. Estos errores son más difíciles de detectar y corregir. Existen programas auxiliares para buscar estos errores, son los llamados depuradores (debuggers). Estos programas permiten detener la ejecución de nuestros programas, inspeccionar variables y ejecutar nuestro programa paso a paso. Esto resulta útil para detectar excepciones, errores sutiles, y fallos que se presentan dependiendo de circunstancias distintas. Errores de diseño: finalmente los errores más difíciles de corregir y prevenir. Si nos hemos equivocado al diseñar nuestro algoritmo, no habrá ningún programa que nos pueda ayudar a corregir los nuestros. Contra estos errores sólo cabe practicar y pensar. UNIDAD II INSTRUCCIONES FUNDAMENTALES (DE CONTROL) INSTRUCCIONES DE ENTRADA Y SALIDA DE DATOS Operaciones de Entrada/Salida Un programa para que pueda trabajar, entre otras cosas, debe poder operar los datos que se proporcionan mediante un dispositivo de entrada y poder enviar los resultados después de procesados con la ayuda de un algoritmo a un dispositivo de salida. En la forma estándar o por defecto (default) el dispositivo de entrada será el teclado y el dispositivo de salida la pantalla o monitor. Instrucción de Escritura en Pantalla Para transferir valores de constantes, variables, expresiones algebraicas, o expresiones delimitadas como cadenas de caracteres de la memoria del computador a la pantalla, emplearemos la instrucción printf() , en su forma por defecto, y la cual se encuentra en el archivo a incluir stdio.h. También se utiliza puts() para las cadenas de caracteres. Printf(“Texto y/o formato de salida”,variable o constante); Printf(“Texto y/o formato de salida”,variable o constante); Printf(“Texto y/o formato de salida”,operación aritmética); Printf(“Texto”); Printf(“Texto y/o formato de salida”,operación lógica) Printf(“Estado civil: “); Printf(“Salario: %d”, sal); Printf(“%d”,a>b); Printf(“%f”,123*23); Printf(“Francisco tiene %d años y Pedro %d”,ed1,ed2); Puts(“texto”); Puts(variable cadena); Puts(concatenación); Puts(“Nombre: “); Puts(“Reprobado”); Puts(Ed); Puts(a+b+”hola”); Instrucción de Lectura Para leer y almacenar valores a la memoria del computador, emplearemos la instrucción scanf() , en su forma por defecto, y la cual se encuentra en el archivo a incluir stdio.h. También se utiliza gets() para las cadenas de caracteres. Scanf(“formato”,&variable); Scanf(“formatos”,&var1,&var2…,&varn); Scanf(“%d”,&ed); Scanf(“%d %d %d”,&a,&b,&c); Scanf(“%f”,&sal); Scanf(“%s”,&nom); Gets(variable cadena); Gets(nom); INSTRUCCIONES DE SELECCIÓN: SIMPLES Y ANIDADAS Todo algoritmo se desarrollará con tres tipos de instrucciones: Secuenciales, Selectivas y Repetitivas; el entendimiento de estas tres es el objetivo principal de este curso. Proposición If - Else Esta proposición sirve para ejecutar ciertas sentencias de programa, si una expresión resulta CIERTA ú otro grupo de sentencias, si aquella resulta FALSA. Su interpretación literal sería: SI es CIERTA tal cosa, haga esto (la o las sentencias) , si no lo es saltará a la siguiente instrucción. El caso más sencillo sería : if(expresión) sentencia ; ó if(expresión) sentencia ; Cuando la sentencia que sigue al IF es única, las dos formas de escritura expresadas arriba son equivalentes . La sentencia sólo se ejecutará si el resultado de "expresión" es distinto de cero (CIERTO) , en caso contrario el programa salteará dicha sentencia , realizando la siguiente en su flujo. Veamos unos ejemplos de las distintas formas que puede adoptar la "expresión" dentro de un IF : if( a > b ) if( (a > b) != 0 ) las dos expresiones son idénticas, aunque a veces resulta más claro expresarla de la segunda manera, sobre todo en los primeros contactos con el lenguaje. if(a) if(a != 0) if(!a) if(a == 0 ) Las dos superiores son idénticas entre sí , al igual que las dos inferiores Obsérvese que (!a) dará un valor CIERTO sólo cuando a sea FALSO. (ver operador NEGACION en el capítulo anterior ) if( a == b ) if( a = b ) /* Error */ La primera es una expresión correcta , el IF se realizará sólo si a es igual a b. En cambio la segunda es un error , ya que no se está comparando a con b , sino ASIGNANDO el valor de esta a aquella . Sin embargo, a veces puede usarse como un truco (un poco sucio) de programacion , ya que primero se realiza la asignación y luego se evalúa el resultado de esta para realizar el IF , es entonces equivalente a escribir : a = b ; if(a) .................... con el ahorro de una linea de programa ( a costa de la legibilidad del mismo ). En casos más complejos que los anteriores, la proposición IF puede estar seguida por un bloque de sentencias : if(expresión) if(expresión) { { sentencia 1 ; sentencia 1 ; sentencia 2 ; sentencia 2 ; ............... ............. } } Las dos maneras son equivalentes, por lo que la posición de la llave de apertura del bloque queda librada al gusto del programador. El indentado de las sentencias (sangría) es también optativo, pero sumamente recomendable ,sobre todo para permitir la lectura de proposiciones muy complejas ó anidadas , como se verá luego. El bloque se ejecutará en su conjunto si la expresión resulta CIERTA. El uso del ELSE es optativo, y su aplicación resulta en la ejecución de una , ó una serie de sentencias en el caso de que la expresión del IF resulta FALSA. Su aplicación puede verse en el ejemplo siguiente : if(expresión) if(expresión) { { sentencia 1 ; sentencia 1 ; sentencia 2 ; sentencia 2 ; } } sentencia 3 ; else sentencia 4 ; { sentencia 5 ; sentencia 3 ; sentencia 4 ; } sentencia 5 ; En el ejemplo de la izquierda no se usa el ELSE y por lo tanto las sentencias 3, 4 y 5 se ejecutan siempre. En el segundo caso , las sentencias 1 y 2 se ejecutan solo si la expresión es CIERTA , en ese caso las 3 y 4 NO se ejecutarán para saltarse directamente a la 5 , en el caso de que la expresión resulte FALSA se realizarán las 3 y 4 en lugar de las dos primeras y finalmente la 5 . La proposición ELSE queda siempre asociada al IF más cercano, arriba de él . Es común también, en caso de decisiones múltiples, el uso de anidamientos ELSE-IF de la forma indicada abajo: if(exp.1) if(exp.1) sentencia1 ; sentencia1 ; else if(exp.2) else if(exp.2) sentencia2 ; sentencia2 ; else if(exp.3) else if(exp.3) sentencia3 ; sentencia3 ; else else sentencia5 ; sentencia5 ; Si bien se suele escribir según la modalidad de la izquierda , a la derecha hemos expresado las asociaciones entre los distintos ELSE é IF por medio del indentado del texto. Proposición switch El SWITCH es una forma sencilla de evitar largos, tediosos y confusos anidamientos de ELSE-IF . Supongamos que estamos implementando un Menú, con varias elecciones posibles. El esqueleto de una posible solución al problema usando if-else podría ser el siguiente: ________________________________________ #include <<stdio.h>> main() { int c ; printf("nMENU :" ; printf("n A = ADICIONAR A LA LISTA " ; printf("n B = BORRAR DE LA LISTA " ; printf("n O = ORDENAR LA LISTA " ; printf("n I = IMPRIMIR LA LISTA " ; printf("nnESCRIBA SU SELECCION , Y LUEGO <<ENTER>> : " ; if( (c = getchar()) != 'n' ) { if( c == 'A') printf("nUD. SELECCIONO AGREGAR" ; else if( c == 'B') printf("nUD. SELECCIONO BORRAR" ; else if( c == 'O' ) printf("nUD. SELECCIONO ORDENAR" ; else if( c == 'I' ) printf("nUD. SELECCIONO IMPRIMIR" ; else printf("naaUD. APRETO UN CARACTER ILEGAL" ) ; } else printf("n¡ UD. NO HA SELECCIONADO NADA !" ) ; } Como es fácil de ver, cuando las opciones son muchas, el texto comienza a hacerse difícil de entender y engorroso de escribir. El mismo programa, utilizando un SWITCH, quedaría mucho más claro de leer, y sencillo de escribir, como se aprecia en el EJEMPLO siguiente. #include <stdio.h> #include <conio.h> main() { int c ; printf("nMENU :" ; printf("n A = ADICIONAR A LA LISTA " ; printf("n B = BORRAR DE LA LISTA " ; printf("n O = ORDENAR LA LISTA " ; printf("n I = IMPRIMIR LA LISTA " ; printf("nnESCRIBA SU SELECCION , Y LUEGO <<ENTER>> : " ; c = getchar() ; switch (c) { case 'A' : printf("nUD. SELECCIONO AGREGAR" ; break ; case 'B' : printf("nUD. SELECCIONO BORRAR" ; break ; case 'O' : printf("nUD. SELECCIONO ORDENAR" ; break ; case 'I' : printf("nUD. SELECCIONO IMPRIMIR" ; break ; case 'n': printf("n¡ UD. NO HA SELECCIONADO NADA !" ) ; break ; default : printf("naaUD. APRETO UN CARACTER ILEGAL" ) ; break ; } } ________________________________________ El SWITCH empieza con la sentencia: switch (expresión) . La expresión contenida por los paréntesis debe ser ENTERA, en nuestro caso un carácter; luego mediante una llave abre el bloque de las sentencias de comparación. Cada una de ellas se representa por la palabra clave "case" seguida por el valor de comparación y terminada por dos puntos. Seguidamente se ubican las sentencias que se quieren ejecutar , en el caso que la comparación resulte CIERTA . En el caso de resultar FALSA, se realizará la siguiente comparación , y así sucesivamente . Prestemos atención también a la sentencia BREAK con la que se termina cada CASE. Una característica poco obvia del SWITCH, es que si se eliminan los BREAK del programa anterior , al resultar CIERTA una sentencia de comparación, se ejecutarán las sentencias de ese CASE particular pero TAMBIEN la de todos los CASE por debajo del que ha resultado verdadero. Quizás se aclare esto diciendo que , las sentencias propias de un CASE se ejecutarán si su comparación ú otra comparación ANTERIOR resulta CIERTA . La razón para este poco "juicioso" comportamiento del SWITCH es que así se permite que varias comparaciones compartan las mismas sentencias de programa, por ejemplo : ................. case 'X' : case 'Y' : case 'Z' : printf(" UD. ESCRIBIO X , Y , ó Z " ; break ; .................. La forma de interrumpir la ejecución luego de haber encontrado un CASE cierto es por medio del BREAK, el que dá por terminado el SWITCH . Al final del bloque de sentencias del SWITCH , aparece una optativa llamada DEFAULT , que implica : si no se ha cumplido ningún CASE , ejecute lo que sigue. Es algo superfluo poner el BREAK en este caso , ya que no hay más sentencias después del DEFAULT , sin embargo , como el orden en que aparecen las comparaciones no tiene importancia para la ejecución de la instrucción, puede suceder que en futuras correcciones del programa se agregue algún nuevo CASE luego del DEFAULT , por lo que es conveniente preverlo , agregando el BREAK , para evitar errores de laboriosa ubicación . Más adelante volveremos sobre otros usos del BREAK. INSTRUCCIONES DE REPETICIÓN: FIJA Y CONDICIONAL La mayoría de programas requieren que una determinada cantidad de instrucciones se ejecuten más de una vez. Hasta el momento la única forma de hacerlo sería o copiándolas varias veces, las instrucciones, o copiarlas dentro de una función e invocarla repetidamente. La instrucción Mientras(while) soluciona este problema, permitiendo ejecutar reiteradamente iteraciones (ciclos, bucles, lazos, rizos). De esta forma será posible "devolvernos" en la secuencia lógica del algoritmo. La Iteración While El WHILE es una de las tres iteraciones posibles en C . Su sintaxis podría expresarse de la siguiente forma : while(expresion) ó while(expresión) { proposición 1 ; proposición 1 ; proposición 2 ; ............... proposición n ; } Esta sintaxis expresada en palabras significaría: mientras (expresión) dé un resultado CIERTO ejecútese la proposición 1 , en el caso de la izquierda ó ejecútese el bloque de sentencias , en el caso de la derecha. Por lo general , dentro de la proposición ó del bloque de ellas , se modifican términos de la expresión condicional , para controlar la duración de la iteración . La Iteración Do - While Su sintaxis será : do { proposición 1 ; proposición 2 ; ............... } while (expresión) ; Expresado en palabras , esto significa : ejecute las proposiciones , luego repita la ejecución mientras la expresión dé un resultado CIERTO . La diferencia fundamental entre esta iteración y la anterior es que el DO-WHILE se ejecuta siempre AL MENOS una vez , sea cual sea el resultado de expresión. Iteración For El FOR es simplemente una manera abreviada de expresar un WHILE , veamos su sintaxis : for ( expresión1 ; expresión2 ; expresion3 ) { proposición1 ; proposición2 ; .............. } Esto es equivalente a : expresión1 ; while ( expresión2 ) { proposición1 ; proposición2 ; .............. expresion3 ; } La expresión1 es una asignación de una ó más variables , (equivale a una inicialización de las mismas ) , la expresión2 es una relación de algún tipo que , mientras dé un valor CIERTO , permite la iteración de la ejecución y expresión3 es otra asignación , que comúnmente varía alguna de las variables contenida en expresión2 . Todas estas expresiones , contenidas en el paréntesis del FOR deben estar separadas por PUNTO Y COMA y NO por comas simples . No es imprescindible que existan TODAS las expresiones dentro del paréntesis del FOR , pudiéndose dejar en blanco algunas de ellas , por ejemplo : for ( ; exp2 ; exp3) ó for (exp1 ; ; ) ó for ( ; ; ) Estas dos últimas expresiones son interesantes desde el punto de vista de su falta de término relacional , lo que implica que el programador deberá haber previsto alguna manera alternativa de salir del lazo ( probablemente mediante BREAK ó RETURN como veremos más adelante ) ya que sino , la ejecución del mismo es infinita ( ó tan larga como se mantenga encendida la computadora ) . APLICACIÓN DE ANIDAMIENTO DE INSTRUCCIONES Explicado y ejemplificado en los dos puntos anteriores

UNA CONTRIBUCION A LA PROGRAMACION EN C MANUAL DE PROGRAMACION 1 EN LA LICENCIATURA EN INFORMATICA SI TENES ALGUNA DUDA O TAREA QUE NECESITAIS PORFAVOR NO DUDEN EN PEDIR OVIO IN INTERCAMBIO,,, YO NO OFRESCO PROGRAMAS RAROS SINO LO BASICO PARA QUE TU MAESTRO NO SOSPECHE Y SAQUES BUENAS CALIFICACIONES,,,,,,,, INDICE Unidad I. Fundamentos del Lenguaje Introducción 3 Tipos de datos elementales 4 Palabras reservadas 4 Identificadores: Constantes y Variables 4 Modificadores de tipo 10 Operadores: Asignación, Aritméticos, Lógicos y Relacionales 11 Expresiones y evaluación de operaciones 15 Estructura de un programa 16 Proceso de creación y ejecución de un programa 20 Unidad II. Instrucciones Fundamentales (de control) Instrucciones de entrada y salida de datos 26 Instrucciones de selección: Simples y Anidadas 24 Instrucciones de repetición: Fija y Condicional 28 Aplicación de anidamiento de instrucciones 30 Unidad III. Funciones Internas 31 Definidas por el programador 33 Uso de parámetros 40 Ámbito de variables 42 Parámetros por valor 45 Parámetro por referencia 45 Recursividad 47 Unidad IV. Arreglos Conceptos 48 Unidimensionales 48 Multidimensionales 50 Unidad V. Apuntadores Conceptos 55 Declaración 55 Operaciones con apuntadores 57 Aritmética de apuntadores 57 Paso de apuntadores a funciones 57 Arreglos de apuntadores Apuntadores y funciones Unidad VI. Archivos Tipos de archivos: Texto y Binarios 60 Acceso a archivos: Secuenciales, Directos y Gestión de archivos UNIDAD I FUNDAMENTOS DEL LENGUAJE INTRODUCCIÓN El lenguaje de programación C está caracterizado por ser de uso general, con una sintaxis sumamente compacta y de alta portabilidad. Es común leer que se lo caracteriza como un lenguaje de "bajo nivel". No debe confundirse el término "bajo" con "poco", ya que el significado del mismo es en realidad "profundo", en el sentido que C maneja los elementos básicos presentes en todas las computadoras: caracteres, números y direcciones. Esta particularidad, junto con el hecho de no poseer operaciones de entrada-salida, manejo de arreglo de caracteres, de asignación de memoria, etc , puede al principio parecer un grave defecto; sin embargo el hecho de que estas operaciones se realicen por medio de llamadas a Funciones contenidas en Librerías externas al lenguaje en sí, es el que confiere al mismo su alto grado de portabilidad, independizándolo del "Hardware" sobre el cual corren los programas, como se irá viendo a lo largo de los siguientes capítulos. La descripción del lenguaje se realiza siguiendo las normas del ANSI C, por lo tanto, todo lo expresado será utilizable con cualquier compilador que se adopte; sin embargo en algunos casos particulares se utilizaron funciones Compilador ó Sistema Operativo-dependientes, explicitándose en estos casos la singularidad de las mismas. El concepto de programación estructurada como un enfoque científico a la programación de computadoras lo introdujeron E.W.Dijkstra y C.A.R.Hoare a fines de los años sesenta. Mediante el análisis matemático de la estructura de los programas, ellos mostraron que podemos evitar muchos errores de diseño de programas mediante un enfoque sistemático a la programación. Es fundamental en la programación estructurada el diseño adecuado de los algoritmos y el manejo de las estructuras de datos. La programación estructurada enfrenta el problema a resolver con la técnica del "Divide y Vencerás", dividiéndolo sucesivamente en partes más pequeñas, cada una de estas partes, estas reciben diversos nombres dependiendo del lenguaje utilizado: procedimientos, rutinas, métodos, funciones, subrutinas, bloques de código, etc.; en el lenguaje C/C++ las llamamos funciones. En general un programa es un conjunto de instrucciones las cuales le dicen a la computadora cómo ejecutar una tarea específica. Todos los lenguajes de programación consisten en secuencias de caracteres, o sea de letras, números, símbolos retornos de carro y espacios. Se puede definir un lenguaje de computadora como una secuencia de elementos, los cuales tienen un significado concreto y "entendible" por la misma. Estos elementos son: las palabras reservadas (keywords), los identificadores y los símbolos, la sintaxis del lenguaje definirá cómo se combinarán todos estos para producir un código ejecutable por el ordenador. TIPOS DE DATOS Tipos de Datos Primitivos en C++ TIPO RANGO DE VALORES unsigned char char enum unsigned int short int int unsigned long long float double long double 0 a 255 128 a 127 32,768 a 32,767 0 a 65,535 32,768 a 32,767 32,768 a 32,767 0 a 4,294,967,295 2,147,483,648 a 2,147,483,647 3.4 * (10** 38) a 3.4 * (10**+38) 1.7 * (10** 308) a 1.7 * (10**+308) 3.4 * (10** 4932) a 1.1 * (10**+4932) PALABRAS RESERVADAS Las palabras reservadas son las que provee el lenguaje de programación para realizar ciertas acciones, por lo tanto estas no pueden ser usadas como nombres de identificadores (variables, funciones, constantes, etc.). Estas palabras pueden ser diversas, dependerá del lenguaje de programación que se use, en este caso utilizamos C y algunas de las palabras reservadas en este son: main, break, while, for, swich, continue, printf, scanf, define, etc. IDENTIFICADORES: CONSTANTES Y VARIABLES Definicion de Variables Si yo deseara imprimir los resultados de multiplicar un número fijo por otro que adopta valores entre 0 y 9 , la forma normal de programar esto sería crear una CONSTANTE para el primer número y un par de VARIABLES para el segundo y para el resultado del producto. Una variable , en realidad , no es más que un nombre para identificar una (o varias) posiciones de memoria donde el programa guarda los distintos valores de una misma entidad . Un programa debe DEFINIR a todas las variables que utilizará , antes de comenzar a usarlas , a fin de indicarle al compilador de que tipo serán , y por lo tanto cuanta memoria debe destinar para albergar a cada una de ellas. Veamos el EJEMPLO 2: EJEMPLO 2 ________________________________________ #include <stdio.h> main() { int multiplicador; /* defino multiplicador como un entero */ int multiplicando; /* defino multiplicando como un entero */ int resultado; /* defino resultado como un entero */ multiplicador = 1000 ; /* les asigno valores */ multiplicando = 2 ; resultado = multiplicando * multiplicador ; printf("Resultado = %dn", resultado); /* muestro el resultado */ return 0; } ________________________________________ En las primeras líneas de texto dentro de main() defino mis variables como números enteros , es decir del tipo "int" seguido de un identificador (nombre) de la misma . Este identificador puede tener la cantidad de caracteres que se desee , sin embargo de acuerdo al Compilador que se use , este tomará como significantes sólo los primeros n de ellos ; siendo por lo general n igual a 32 . Es conveniente darle a los identificadores de las variables , nombres que tengan un significado que luego permita una fácil lectura del programa. Los identificadores deben comenzar con una letra ó con el símbolo de subrayado "_" , pudiendo continuar con cualquier otro caractér alfanumérico ó el símbolo "_" . El único símbolo no alfanumérico aceptado en un nombre es el "_" . El lenguaje C es sensible al tipo de letra usado ; así tomará como variables distintas a una llamada "variable" , de otra escrita como "VARIABLE". Es una convención entre los programadores de C escribir los nombres de las variables y las funciones con minúsculas, reservando las mayúsculas para las constantes. El compilador dará como error de "Definición incorrecta" a la definición de variables con nombres del tipo de : 4pesos $variable primer-variable !variable etc.etc NOTA: Los compiladores reservan determinados términos ó palabras claves (Keywords) para el uso sintáctico del lenguaje, tales como: asm, auto, break, case, char, do, for, etc. Si bien estas palabras están definidas para el ANSI C, los distintos compiladores extienden esta definición a OTROS términos, por lo que es aconsejable leer la tabla completa de palabras reservadas del compilador que se vaya a usar, para no utilizarlas en nombres de variables. Vemos en las dos líneas subsiguientes a la definición de las variables, que puedo ya asignarles valores (1000 y 2) y luego efectuar el cálculo de la variable "resultado". Si prestamos ahora atención a la función printf(), ésta nos mostrará la forma de visualizar el valor de una variable. Insertada en el texto a mostrar, aparece una secuencia de control de impresión "%d" que indica, que en el lugar que ella ocupa, deberá ponerse el contenido de la variable ( que aparece luego de cerradas las comillas que marcan la finalización del texto , y separada del mismo por una coma) expresado como un número entero decimal. Así, si compilamos y corremos el programa , obtendremos una salida : Salida Del Ejemplo 2 Resultado = 2000 Inicializacion de Variables Las variables del mismo tipo pueden definirse mediante una definición múltiple separándolas mediante " , " a saber : int multiplicador, multiplicando, resultado; Esta sentencia es equivalente a las tres definiciones separadas en el ejemplo anterior. Las variables pueden también ser inicializadas en el momento de definirse . int multiplicador = 1000, multiplicando = 2, resultado; De esta manera el EJEMPLO 2 podría escribirse: EJEMPLO 2 BIS ________________________________________ #include <stdio.h> main() { int multiplicador=1000 , multiplicando=2 ; printf("Resultado = %dn", multiplicando * multiplicador); return 0; } Obsérvese que en la primer sentencia se definen e inicializan simultáneamente ambas variables. La variable "resultado" la hemos hecho desaparecer ya que es innecesaria. Si analizamos la función printf() vemos que se ha reemplazado "resultado" por la operación entre las otras dos variables. Esta es una de las particularidades del lenguaje C : en los parámetros pasados a las funciones pueden ponerse operaciones (incluso llamadas a otras funciones) , las que se realizan ANTES de ejecutarse la función , pasando finalmente a esta el valor resultante de las mismas. El EJEMPLO 2 funciona exactamente igual que antes pero su código ahora es mucho más compacto y claro. Tipos de Variables Variables del Tipo Entero En el ejemplo anterior definimos a las variables como enteros (int). De acuerdo a la cantidad de bytes que reserve el compilador para este tipo de variable, queda determinado el "alcance" ó máximo valor que puede adoptar la misma. Debido a que el tipo int ocupa dos bytes su alcance queda restringido al rango entre -32.768 y +32.767 (incluyendo 0 ). En caso de necesitar un rango más amplio, puede definirse la variable como "long int nombre_de_variable" ó en forma más abreviada "long nombre_de_variable" Declarada de esta manera, nombre_de_variable puede alcanzar valores entre - 2.347.483.648 y +2.347.483.647. A la inversa, si se quisiera un alcance menor al de int, podría definirse "short int " ó simplemente "short", aunque por lo general, los compiladores modernos asignan a este tipo el mismo alcance que "int". Debido a que la norma ANSI C no establece taxativamente la cantidad de bytes que ocupa cada tipo de variable, sino tan sólo que un "long" no ocupe menos memoria que un "int" y este no ocupe menos que un "short",los alcances de los mismos pueden variar de compilador en compilador , por lo que sugerimos que confirme los valores dados en este parágrafo (correspondientes al compilador de Borland C++) con los otorgados por su compilador favorito. Para variables de muy pequeño valor puede usarse el tipo "char" cuyo alcance está restringido a -128, +127 y por lo general ocupa un único byte. Todos los tipos citados hasta ahora pueden alojar valores positivos ó negativos y, aunque es redundante, esto puede explicitarse agregando el calificador "signed" delante; por ejemplo: signed int signed long signed long int signed short signed short int signed char Si en cambio, tenemos una variable que sólo puede adoptar valores positivos (como por ejemplo la edad de una persona ) podemos aumentar el alcance de cualquiera de los tipos , restringiéndolos a que sólo representen valores sin signo por medio del calificador "unsigned" . Tabla de Variables del Tipo Número Entero Tipo Bytes Valor Mínimo Valor Máxima signed char 1 -128 127 unsigned char 1 0 255 unsigned short 2 -32.768 +32.767 unsigned short 2 0 +65.535 signed int 2 -32.768 +32.767 unsigned int 2 0 +65.535 signed long 4 -2.147.483.648 +2.147.483.647 unsigned long 4 0 +4.294.967.295 NOTA: Si se omite el calificador delante del tipo de la variable entera, éste se adopta por omisión (default) como "signed". Variables de Número Real o Punto Flotante Un número real ó de punto flotante es aquel que además de una parte entera, posee fracciones de la unidad. En nuestra convención numérica solemos escribirlos de la siguiente manera : 2,3456, lamentablemente los compiladores usan la convención del PUNTO decimal (en vez de la coma) . Así el numero Pi se escribirá : 3.14159 Otro formato de escritura, normalmente aceptado, es la notación científica. Por ejemplo podrá escribirse 2.345E+02, equivalente a 2.345 * 100 ó 234.5 De acuerdo a su alcance hay tres tipos de variables de punto flotante , las mismas están descriptas en la TABLA Tabla de Tipos de Variables de Punto Flotante Tipo Bytes Valor Mínimo Valor Máximo float 4 3.4E-38 3.4E+38 double 8 1.7E-308 1.7E+308 long double 10 3.4E-4932 3.4E+4932 Las variables de punto flotante son SIEMPRE con signo, y en el caso que el exponente sea positivo puede obviarse el signo del mismo. Variables de Tipo Caracter El lenguaje C guarda los caracteres como números de 8 bits de acuerdo a la norma ASCII extendida , que asigna a cada caracter un número comprendido entre 0 y 255 ( un byte de 8 bits) Es común entonces que las variables que vayan a alojar caracteres sean definidas como: char c ; Sin embargo, también funciona de manera correcta definirla como: int c ; Esta última opción desperdicia un poco más de memoria que la anterior ,pero en algunos casos particulares presenta ciertas ventajas . Pongamos por caso una función que lee un archivo de texto ubicado en un disco. Dicho archivo puede tener cualquier caracter ASCII de valor comprendido entre 0 y 255. Para que la función pueda avisarme que el archivo ha finalizado deberá enviar un número NO comprendido entre 0 y 255 ( por lo general se usa el -1 , denominado EOF, fin de archivo ó End Of File), en este caso dicho número no puede ser mantenido en una variable del tipo char, ya que esta sólo puede guardar entre 0 y 255 si se la define unsigned ó no podria mantener los caracteres comprendidos entre 128 y 255 si se la define signed (ver TABLA 1). El problema se obvia facilmente definiéndola como int. Las variables del tipo caractér también pueden ser inicializadas en su definición, por ejemplo es válido escribir: char c = 97 ; para que c contenga el valor ASCII de la letra "a", sin embargo esto resulta algo engorroso , ya que obliga a recordar dichos códigos . Existe una manera más directa de asignar un caractér a una variable ; la siguiente inicialización es idéntica a la anterior : char c = 'a' ; Es decir que si delimitamos un caracter con comilla simple , el compilador entenderá que debe suplantarlo por su correspondiente código numérico . Lamentablemente existen una serie de caracteres que no son imprimibles , en otras palabras que cuando editemos nuestro programa fuente (archivo de texto) nos resultará difícil de asignarlas a una variable ya que el editor las toma como un COMANDO y no como un caracter . Un caso típico sería el de "nueva linea" ó ENTER . Con el fin de tener acceso a los mismos es que aparecen ciertas secuencias de escape convencionales . Las mismas estan listadas en la TABLA y su uso es idéntico al de los caracteres normales , asi para resolver el caso de una asignación de "nueva linea " se escribirá: char c = 'n' ; /* secuencia de escape */ Tabla de Secuencias de Escape Código Significado Valor ASCII (Decimal) Valor Ascii (Hexadecimal) 'n' nueva línea 10 0x0A 'r' retorno de carro 13 0x0D 'f' nueva página 2 x0C 't' tabulador horizontal 9 0x09 'b' retroceso (backspace) 8 0x08 ''' comilla simple 39 0x27 '"' comillas 4 0x22 '\ ' barra 92 0x5C '? ' interrogación 63 0x3F 'nnn' cualquier carácter (donde nnn es el código ASCII expresado en octal) 'xnn' cualquier caracter (donde nn es el código ASCII expresado en hexadecimal) Tamaño de las Variables (Sizeof) En muchos programas es necesario conocer el tamaño (cantidad de bytes) que ocupa una variable, por ejemplo en el caso de querer reservar memoria para un conjunto de ellas. Lamentablemente, como vimos anteriormente este tamaño es dependiente del compilador que se use, lo que producirá, si definimos rigidamente (con un número dado de bytes) el espacio requerido para almacenarlas, un problema serio si luego se quiere compilar el programa con un compilador distinto del original. Para salvar este problema y mantener la portabilidad, es conveniente que cada vez que haya que referirse al TAMAÑO en bytes de las variables, se lo haga mediante un operador llamado "sizeof" que calcula sus requerimientos de almacenaje Está también permitido el uso de sizeof con un tipo de variable, es decir: sizeof(int) sizeof(char) sizeof(long double) , etc. Definicion De Nuevos Tipos ( Typedef ) A veces resulta conveniente crear otros tipos de variables , ó redefinir con otro nombre las existentes , esto se puede realizar mediante la palabra clave "typedef" , por ejemplo: typedef unsigned long double enorme ; A partir de este momento ,las definiciones siguientes tienen idéntico significado: unsigned long double nombre_de_variable ; enorme nombre_de_variable ; Constantes Aquellos valores que , una vez compilado el programa no pueden ser cambiados , como por ejemplo los valores literales que hemos usado hasta ahora en las inicializaciones de las variables (1000 , 2 , 'a' , 'n' , etc), suelen denominarse CONSTANTES . Como dichas constantes son guardadas en memoria de la manera que al compilador le resulta más eficiente suelen aparecer ciertos efectos secundarios , a veces desconcertantes , ya que las mismas son afectadas por las reglas de RECONVERSION AUTOMATICA DE TIPO vista previamente. A fin de tener control sobre el tipo de las constantes, se aplican la siguientes reglas : • Una variable expresada como entera (sin parte decimal) es tomada como tal salvo que se la siga de las letras F ó L (mayúsculas ó minúsculas) ejemplos : 1 : tomada como ENTERA 1F : tomada como FLOAT 1L : tomada como LONG DOUBLE • Una variable con parte decimal es tomada siempre como DOUBLE, salvo que se la siga de la letra F ó L 1.0 : tomada como DOUBLE 1.0F : tomada como FLOAT 1.0L : tomada como LONG FLOAT • Si en cualquiera de los casos anteriores agregamos la letra U ó u la constante queda calificada como UNSIGNED (consiguiendo mayor alcance) : 1u : tomada como UNSIGNED INT 1.0UL : tomada como UNSIGNED LONG DOUBLE • Una variable numérica que comienza con "0" es tomado como OCTAL asi : 012 equivale a 10 unidades decimales • Una variable numérica que comienza con "0x" ó "0X" es tomada como hexadecimal : 0x16 equivale a 22 unidades decimales y 0x1A a 26 unidades decimales. La forma de declarar una constantes e const tipodedato nombredeconstante = valor; Constantes Simbólicas Por lo general es una mala práctica de programación colocar en un programa constantes en forma literal (sobre todo si se usan varias veces en el mismo) ya que el texto se hace dificil de comprender y aún más de corregir, si se debe cambiar el valor de dichas constantes. Se puede en cambio asignar un símbolo a cada constante, y reemplazarla a lo largo del programa por el mismo, de forma que este sea más legible y además, en caso de querer modificar el valor, bastará con cambiarlo en la asignación. El compilador, en el momento de crear el ejecutable, reemplazará el símbolo por el valor asignado. Para dar un símbolo a una constante bastará, en cualquier lugar del programa (previo a su uso) poner la directiva: #define, por ejemplo: #define VALOR_CONSTANTE 342 #define PI 3.1416 MODIFICADORES DE TIPO Cuando dos ó mas tipos de variables distintas se encuentran DENTRO de una misma operación ó expresión matemática , ocurre una conversión automática del tipo de las variables. En todo momento de realizarse una operación se aplica la siguiente secuencia de reglas de conversión (previamente a la realización de dicha operación): • 1) Las variables del tipo char ó short se convierten en int • 2) Las variables del tipo float se convierten en double • 3) Si alguno de los operandos es de mayor precisión que los demás , estos se convierten al tipo de aquel y el resultado es del mismo tipo. • 4) Si no se aplica la regla anterior y un operando es del tipo unsigned el otro se convierte en unsigned y el resultado es de este tipo. Las reglas 1 a 3 no presentan problemas, sólo nos dicen que previamente a realizar alguna operación las variables son promovidas a su instancia superior. Esto no implica que se haya cambiado la cantidad de memoria que las aloja en forma permanente. Otro tipo de regla se aplica para la conversión en las asignaciones. Si definimos los términos de una asignación como,"lvalue" a la variable a la izquierda del signo igual y "rvalue" a la expresión a la derecha del mismo, es decir: "lvalue" = "rvalue" ; Posteriormente al cálculo del resultado de "rvalue" (de acuerdo con las reglas antes descriptas), el tipo de este se iguala al del "lvalue". El resultado no se verá afectado si el tipo de "lvalue" es igual ó superior al del "rvalue", en caso contrario se efectuará un truncamiento ó redondeo, según sea el caso. Por ejemplo, el pasaje de float a int provoca el truncamiento de la parte fraccionaria, en cambio de double a float se hace por redondeo. Las conversiones automáticas pueden ser controladas a gusto por el programador, imponiendo el tipo de variable al resultado de una operación. Supongamos por ejemplo tener: double d , e , f = 2.33 ; int i = 6 ; e = f * i ; d = (int) ( f * i ) ; En la primer sentencia calculamos el valor del producto (f * i) , que según lo visto anteriormente nos dará un double de valor 13.98 , el que se ha asignado a e. Si en la variable d quisiéramos reservar sólo el valor entero de dicha operación bastará con anteponer, encerrado entre paréntesis, el tipo deseado. Así en d se almacenará el número 13.00. También es factible aplicar la fijación de tipo a una variable, por ejemplo obtendremos el mismo resultado, si hacemos: d = (int) f * i ; En este caso hemos convertido a f en un entero (truncando sus decimales) OPERADORES: ASIGNACIÓN, ARITMÉTICOS, LÓGICOS Y RELACIONALES Si analizamos la sentencia siguiente: var1 = var2 + var3; estamos diciéndole al programa, por medio del operador +, que compute la suma del valor de dos variables , y una vez realizado ésto asigne el resultado a otra variable var1. Esta última operación (asignación) se indica mediante otro operador, el signo =. El lenguaje C tiene una amplia variedad de operadores, y todos ellos caen dentro de 6 categorias , a saber : aritméticos , relacionales, lógicos, incremento y decremento, manejo de bits y asignacion. Todos ellos se irán describiendo en los párrafos subsiguientes. Operadores Aritméticos Tal como era de esperarse los operadores aritméticos ,mostrados en la TABLA , comprenden las cuatro operaciones básicas , suma , resta , multiplicación y división , con un agregado , el operador módulo . Tabla de Operadores Aritméticos Símbolo Descripción Ejemplo Orden De Evaluación + SUMA a + b 3 - RESTA a - b 3 * MULTIPLICACION a * b 2 / DIVISION a / b 2 % MODULO a % b 2 - SIGNO -a 2 El operador módulo ( % ) se utiliza para calcular el resto del cociente entre dos ENTEROS , y NO puede ser aplicado a variables del tipo float ó double . Si bien la precedencia (orden en el que son ejecutados los operadores) se analizará más adelante, en este capítulo, podemos adelantar algo sobre el orden que se realizan las operaciones aritméticas. En la TABLA 4, última columna, se da el orden de evaluación de un operador dado. Cuanto más bajo sea dicho número mayor será su prioridad de ejecución. Si en una operación existen varios operadores, primero se evaluarán los de multiplicación , división y módulo y luego los de suma y resta . La precedencia de los tres primeros es la misma , por lo que si hay varios de ellos, se comenzará a evaluar a aquel que quede más a la izquierda . Lo mismo ocurre con la suma y la resta .. Para evitar errores en los cálculos se pueden usar paréntesis , sin limitación de anidamiento, los que fuerzan a realizar primero las operaciones incluidas en ellos . Los paréntesis no disminuyen la velocidad a la que se ejecuta el programa sino que tan sólo obligan al compilador a realizar las operaciones en un orden dado, por lo que es una buena costumbre utilizarlos ampliamente . Los paréntesis tienen un orden de precedencia 0, es decir que antes que nada se evalúa lo que ellos encierran. Se puede observar que no existen operadores de potenciación, radicación, logaritmación, etc, ya que en el lenguaje C todas estas operaciones ( y muchas otras ) se realizan por medio de llamadas a Funciones. El último de los operadores aritméticos es el de SIGNO . No debe confundírselo con el de resta, ya que este es un operador unitario que opera sobre una única variable cambiando el signo de su contenido numérico. Obviamente no existe el operador + unitario, ya que su operación sería DEJAR el signo de la variable, lo que se consigue simplemente por omisión del signo. Operadores Relacionales Todas las operaciones relacionales dan sólo dos posibles resultados: VERDADERO ó FALSO . En el lenguaje C, Falso queda representado por un valor entero nulo (cero) y Verdadero por cualquier número distinto de cero En la TABLA se encuentra la descripción de los mismos. Tabla de Operadores Relacionales Símbolo Descripción Ejemplo Orden De Evaluación < menor que (a < b) 5 > mayor que (a >b) 5 < = menor o igual que (a < = b) 5 >= mayor o igual que ( a >>= b ) 5 = = igual que ( a = = b) 6 ! = distinto que ( a != b) 6 Uno de los errores más comunes es confundir el operador relacional IGUAL QUE (= =) con el de asignación IGUAL A (=). La expresión a=b copia el valor de b en a, mientras que a = = b retorna un cero , si a es distinto de b ó un número distinto de cero si son iguales. Los operadores relacionales tiene menor precedencia que los aritméticos, de forma que a < b + c se interpreta como a < ( b + c ), pero aunque sea superfluo recomendamos el uso de paréntesis a fin de aumentar la legilibilidad del texto. Cuando se comparan dos variables tipo char el resultado de la operación dependerá de la comparación de los valores ASCII de los caracteres contenidos en ellas. Así el carácter a ( ASCII 97 ) será mayor que el A (ASCII 65 ) ó que el 9 (ASCII 57). Operadores Lógicos Hay tres operadores que realizan las conectividades lógicas Y (AND) , O (OR) y NEGACION (NOT) y están descriptos en la TABLA. Tabla de Operadores Lógicos Símbolo Descripción Ejemplo Orden De Evaluación && Y (AND) (a>b) && (c < d) 10 || O (OR) (a>b) || (c < d) 11 ! NEGACION (NOT) !(a>b) 1 Los resultados de la operaciones lógicas siempre adoptan los valores CIERTO ó FALSO. La evaluación de las operaciones lógicas se realiza de izquierda a derecha y se interrumpe cuando se ha asegurado el resultado. El operador NEGACION invierte el sentido lógico de las operaciones , así será !( a >> b ) equivale a ( a < b ) !( a == b ) " " ( a != b ) etc. En algunas operaciones suele usárselo de una manera que se presta a confusión , por ejemplo : ( !i ) donde i es un entero. Esto dará un resultado CIERTO si i tiene un valor 0 y un resultado FALSO si i es distinto de cero . Operadores de Incremento y Decremento Los operadores de incremento y decremento son sólo dos y están descriptos en la TABLA Tabla de Operadores de Incremento y Decremento Símbolo Descripción Ejemplo Orden de Evaluación ++ incremento ++i ó i++ 1 -- decremento --i ó i-- 1 Para visualizar rápidamente la función de los operadores antedichos , digamos que las sentencias : a = a + 1 ; a++ ; Tienen una acción idéntica, de la misma forma que a = a - 1 ; a-- ; es decir incrementa y decrementa a la variable en una unidad Si bien estos operadores se suelen emplear con variables int , pueden ser usados sin problemas con cualquier otro tipo de variable . Así si a es un float de valor 1.05 , luego de hacer a++ adoptará el valor de 2.05 y de la misma manera si b es una variable del tipo char que contiene el caracter 'C' , luego de hacer b-- su valor será 'B' . Si bien las sentencias i++ ; ++i ; son absolutamente equivalentes, en la mayoría de los casos la ubicación de los operadores incremento ó decremento indica CUANDO se realiza éste . Veamos el siguiente ejemplo : int i = 1 , j , k ; j = i++ ; k = ++i ; acá j es igualado al valor de i y POSTERIORMENTE a la asignación i es incrementado por lo que j será igual a 1 e i igual a 2 , luego de ejecutada la sentencia . En la siguiente instrucción i se incrementa ANTES de efectuarse la asignación tomando el valor de 3 , él que luego es copiado en k .

Solucion encontrada en dos laptops de marcas distintas una linux notebook y una hp laptop en fin Problemas:No corre el Beini completo. No botea por usb.Solucion: Paso_ 1 Instalar el beini con el unetbootin Normalmente en el disco duro junto a su sistema operativo de arranque. Paso_2 Instalar beini normalmente en una USB Paso_3 Dejar la usb preparada con el beini conectada a la computadora y arrancar el Beini que esta instalado en la pc y listo se ejecutara normalmente Esta es una solucion facil y sin Comandos