waliii

Motherboard DX58SO intel Extreme Series U$S 380 ---------------------------------------------------------------------------------------- Memoria Ram 1 de estas OCZ PC3-10666 ReaperX HPC Enhanced Bandwidth U$S 140 1 de estas OCZ DDR3 PC3-10666 Fatal1ty Edition U$S 159 1 de estas OCZ DDR3 PC3-16000 Reaper Low-Voltage Triple Channel U$S 160 ----------------------------------------------------------------------------------------- Disco rigido U$S 200 2 de estos y nunca mas !!! OCZ Colossus de 1 TB ------------------------------------------------------------------------------------------ Microprosesador intel i7 U$S 370.00 ------------------------------------------------------------------------------------------ Video 1 de estas Sapphire HD4890 1GB GDDR5 OC 1gb!!! U$S 117.00 1 de estas U$S 137.00 ------------------------------------------------------------------------------------------ Refrigeracion(mi parte favorita) DISIPADOR DE CPU THERMALTAKE MINI TYPHOON para el micro U$S 99.0 VENTILADOR PCI THERMALTAKE DE LED AZUL dicipador de ram U$S 20.0 DISIPADOR DE DISCO RIGIDO THERMALTAKE U$S 13.0 ------------------------------------------------------------------------------------------ Gabinte GABINETE THERMALTAKE SERIE ARMOR Jr. U$S 194.0 ------------------------------------------------------------------------------------------ eso fue todo ojala les haya gustado si les sirve comenten odejen puntines

AK 47= ¯̿¯¯¯̿̿¯̿̿'̿̿̿̿̿̿̿'̿̿'̿̿̿̿̿'̿̿̿)͇̿̿)̿̿̿̿ '̿̿̿̿̿̿\̵͇̿̿\ Simplemente= ک!мþℓعмэи†э Cigarrillo Malboro =(̅_̅_̅(̲̲̲̲̲̅̅̅̅̅̅(̅_̅_̲̅м̲̅a̲̅я̲̅l̲̅b̲̅o̲̅r̲̅o̲̅̅_̅_̅_̅()ڪے Ecualizador ıllıllı (Tu Nick) ıllıllı Pistolas /̵͇̿̿/̿̿'̿̿̿̿̿ ̿̿̿̿ (Tu Nick) ̿̿̿̿̿̿̿'̿̿̿̿̿'\̵͇̿̿\ Cruces ●±‡±● (Tu nick) ●±‡±● Parlantes |̲̅̅●̲̅̅|̲̅̅=̲̅̅|̲̅̅●̲̅̅| |̲̅̅●̲̅̅|̲̅̅=̲̅̅|̲̅̅●̲̅̅| Te Quiero ̿ ̿|̿ ̿ |̶͇̿ ̶͇̿ ͇̿ |͇̿ ͇̿ ͇̿ ͇͇̿|͇ |͇ ͇|||̶͇̿ ̶͇̿ ͇̿ |̿ ̿ ̿|͇̿ ͇̿ ͇̿ ̿| Una casita |̲̲̲͡͡͡ ̲▫̲͡ ̲̲̲͡͡π̲̲͡͡ ̲̲͡▫̲̲͡͡ ̲|̡̡̡ ̡ ̴̡ı̴̡̡ ̡͌l̡ ̴̡ı̴̴̡ ̡l̡*̡̡ ̴̡ı̴̴̡ ̡̡͡|̲̲̲͡͡͡ ̲▫̲͡ ̲̲̲͡͡π̲̲͡͡ ̲̲͡▫̲̲͡͡ ̲| Como poner de color una palabra deves escrivir esto ·$ y acontinuacion un numero 0 blanco 1 negro 2 azul 3 verde 4 rojo 5 bordo 6 roza 7 naranja 8amarillo 9 verde 10acuamarino 11 celeste 12 azul claro 13 roza claro 14 gris oscuro 15 gris 16 gris claro 37 anaranjado ejemplo mi nombre es ·$4 walii.lapalabra walii quedara en rojo para que el nik quede grueso se utiliza el siguiente codigo ·# para que quede subrayado se utiliza ·$ bye

Introducción Hasta ahora los programas que hemos visto eran lineales. Comenzaban por la primera instrucción y acababan por la última, ejecutándose todas una sola vez. . Lógico ¿no?. Pero resulta que muchas veces no es esto lo que queremos que ocurra. Lo que nos suele interesar es que dependiendo de los valores de los datos se ejecuten unas instrucciones y no otras. O también puede que queramos repetir unas instrucciones un número determinado de veces. Para esto están las sentencia de control de flujo. Bucles Los bucles nos ofrecen la solución cuando queremos repetir una tarea un número determinado de veces. Supongamos que queremos escribir 100 veces la palabra hola. Con lo que sabemos hasta ahora haríamos: #include <stdio.h> void main() { printf( "Hola\n"; printf( "Hola\n"; printf( "Hola\n"; printf( "Hola\n"; printf( "Hola\n"; ... (y así hasta 100 veces) } ¡Menuda locura! Y si queremos repetirlo más veces nos quedaría un programa de lo más largo. Sin embargo usando un bucle for el programa quedaría: #include <stdio.h> void main() { int i; for ( i=0 ; i<100 ; i++ ) { printf( "Hola\n" ); } } Con lo que tenemos un programa más corto El bucle For El formato del bucle for es el siguiente: for( dar valores iniciales ; condiciones ; incrementos ) { conjunto de intrucciones a ejecutar en el bucle } Vamos a verlo con el ejemplo anterior: ... for ( i=0 ; i<100 ; i++ ) ... En este caso asignamos un valor inicial a la variable i . Ese valor es cero . Esa es la parte de dar valores iniciales. Luego tenemos i<100 . Esa es la parte condiciones. En ella ponemos la condición es que i sea menor que 100, de modo que el bucle se ejecutará mientras i sea menor que 100. Es decir, mientras se cumpla la condición. Luego tenemos la parte de incrementos, donde indicamos cuánto se incrementa la variable. Como vemos, el for va delante del grupo de instrucciones a ejecutar, de manera que si la condición es falsa, esas instrucciones no se ejecutan ni una sola vez. Cuidado: No se debe poner un ";" justo después de la sentencia for, pues entonces sería un bucle vacío y las instrucciones siguientes sólo se ejecutarían una vez. Veamoslo con un ejemplo: #include <stdio.h> void main() { int i; for ( i=0 ; i<100 ; i++ ); /* Cuidado con este punto y coma */ { printf( "Hola\n" ); } } Este programa sólo escribirá en pantalla Hola una sola vez. Tambíen puede suceder que quieras ejecutar un cierto número de veces una sóla instrucción (como sucede en nuestro ejemplo). Entonces no necesitas las llaves "{}": #include <stdio.h> void main() { int i; for ( i=0 ; i<100 ; i++ ) printf( "Hola\n" ); } o también: for ( i=0 ; i<100 ; i++ ) printf( "Hola\n" ); Sin embargo, yo me he encontrado muchas veces que es mejor poner las llaves aunque sólo haya una instrucción; a veces al añadir una segunda instrucción más tarde se te olvidan las comillas y no te das cuenta. Parece una tontería, pero muchas veces, cuando programas, son estos los pequeños fallos los que te vuelven loco. En otros lenguajes, como Basic, la sentencia for es muy rígida. En cambio en C es muy flexible. Se puede omitir cualquiera de las secciones (inicialización, condiciones o incrementos). También se pueden poner más de una variable a inicializar, más de una condición y más de un incremento. Por ejemplo, el siguiente programa sería perfectamente correcto: #include <stdio.h> void main() { int i, j; for( i=0, j=5 ; i<10 ; i++, j=j+5 ) { printf( "Hola " ); printf( "Esta es la línea %i", i ); printf( "j vale = %i", j ); } } Como vemos en el ejemplo tenemos más de una variable en la sección de inicialización y en la de incrementos. También podíamos haber puesto más de una condición. Los elementos de cada sección se separan por comas. Cada sección se separa por punto y coma. While El formato del bucle while es es siguiente: while ( condición ) { bloque de instrucciones a ejecutar } While quiere decir mientras. Aquí se ejecuta el bloque de intrucciones mientras se cumpla la condición impuesta en while. Vamos a ver un ejemplo: #include <stdio.h> void main() { int contador = 0; while ( contador<100 ) { contador++; printf( "Ya voy por el %i, pararé enseguida.\n", contador ); } } Este programa imprime en pantalla los valores del 1 al 100. Cuando i=100 ya no se cumple la condición. Una cosa importante, si hubíesemos cambiado el orden de las instrucciones a ejecutar: ... printf( "Ya voy por el %i, pararé enseguida.\n", contador ); contador++; ... En esta ocasión se imprimen los valores del 0 al 99. Cuidado con esto, que a veces produce errores difíciles de encontrar. Do While El formato del bucle do-while es: do { instrucciones a ejecutar } while ( condición ); La diferencia entre while y do-while es que en este último, la condición va despues del conjunto de instrucciones a ejecutar. De esta forma, esas instrucciones se ejecutan al menos una vez. Su uso es similar al de while.

DATOS A TENER EN CUENTA Esta es una pregunta que nos hacemos cuando vamos a comprarnos un ordenador por primera vez o vamos a cambiar el que tenemos. Parece una pregunta de fácil solución, pero a veces las apariencias engañan y, además, el mercado nos ofrece una variedad de opciones, tanto en potencia como en capacidad y marcas, lo que hace más complicada la elección. La respuesta que damos a esta pregunta, en muchos casos es “lo ultimo y cuanto mas potente mejor”. Pero… ¿es correcta esta respuesta?. Bajo mi punto de vista, simplemente NO. Hay que tener en cuenta que con los componentes que hay en el mercado, en el 90% de los casos tenemos ordenadores muy por encima de nuestras necesidades y a los que raramente vamos a sacarles el rendimiento que pueden darnos. Hay dos preguntas básicas que debemos hacernos al elegir el ordenador que vamos a comprarnos. ¿Para que lo vamos a utilizar? Y ¿Cuánto queremos gastarnos?. Las dudas sobre marcas (que si INTEL o AMD, que si ATI o NVIDIA…), si bien son importantes en algunos casos (como veremos mas adelante), en ninguno de ellos es determinante la elección que hagamos entre ellos, sino mas bien entre que modelos vamos a elegir. En este tutorial vamos a ver diferentes configuraciones dependiendo del uso que vamos a hacer del ordenador, basándonos en un uso domestico y semiprofesional del mismo. Analizaremos igualmente las diferentes opciones que tenemos en los diferentes componentes. Estas opciones en muchos casos solo consiguen dificultar nuestra elección y elevar (a veces innecesariamente) el precio final de nuestro ordenador. La primera pregunta que nos surge es ¿me compro un ordenador de marca o un ordenador clónico?. Vamos a tratar de contestar a esta pregunta. La definición de ordenador clónico que solemos dar es “ordenador que se monta a partir de componentes de diferentes marcas”. Pues bien. Basándonos en esta definición TODOS los ordenadores personales son clónicos, ya que ninguna de las marcas de ordenadores (HP - Compaq, Packard Bell, IBM (en su gama de ordenadores personales), Fujitsu – Siemens, etc. fabrican los componentes que integran sus productos. A lo sumo, en algunos casos, un par de ellos (caso de los discos duros en IBM y Fujitsu – Siemens, lectores de DVD en el caso de HP y poco mas). Muchas veces hablamos de la ventaja de los ordenadores “de marca” en cuanto a calidad, servicio postventa, manuales, software. Vamos a tratar este punto por partes. La calidad de un ordenador viene determinada por dos factores. La calidad de los componentes y la calidad del montaje de los mismos. Bien, Intel NO hace dos fabricaciones diferentes, una para estas empresas y otra para el resto de sus clientes. Esta diferenciación de fabricaciones solo la encontramos el las placas base, que suelen ser por otra parte los mismos modelos que tienen para el resto del mercado, pero en muchos casos con otra nomenclatura. Es cierto que estas empresas pasan unos mayores controles de calidad, pero también es cierto que esto es menos relevante hoy en día que hace unos años. En el tema de los manuales estamos ante un echo parecido. Todos los componentes de un ordenador suelen venir con sus manuales, drivers, etc., por lo que este tema no justifica por si solo la diferencia de precio. En el tema del servicio postventa hay mucho que hablar, ya que en muchas ocasiones este consiste en la retirada del ordenador y en quedarnos sin el durante un periodo de tiempo en casi todos los casos superior al que nos da cualquier tienda de informática. Es cierto que el software que nos ofrecen estos ordenadores es bastante completo, pero también es cierto que en la mayoría de los casos es preinstalado y que cada vez esta más de moda (por el tema de acuerdos y costes) que este software no este soportado en cds, siendo algo complicado tanto su reinstalación en caso de que necesitemos recuperar alguno que no nos funcione bien como su actualización. Un claro ejemplo de esto es que el Windows y los drivers vengan en una partición del disco duro (con la disminución de capacidad real que esto implica) y accesibles a través de un cd de recuperación (en algunos casos ni tan siquiera nos suministran este cd), que casi siempre nos obliga a reinstalar todo el sistema para algo tan simple como reinstalar un driver de sonido. Además, mucho de este software adicional es shareware, con un periodo de caducidad. Un ordenador “clónico” suele venir sin software adicional, pero el software básico nos vendrá en cds independientes y de mas fácil manejo. Tendremos nuestro cd de Windows, nuestro cd con los drivers de la placa base y nuestros cds con los drivers de los demás componentes, por lo que la recuperación del sistema es bastante mas fácil y menos dependiente de los servicios técnicos (aquí quiero recordar que ninguna garantía incluye el software y mucho menos su reinstalación). Otra cuestión es que los ordenadores de marca son configuraciones cerradas, por lo que si queremos cambiar algo tendremos que pagar un extra por ello y además enfrentarnos a algunas incompatibilidades que no suelen darse en ordenadores “clónicos”. Visto este punto, vamos a ver con que nos encontramos para montar nuestro ordenador. GABINETE (CAJA). Consideraciones estéticas aparte, al comprar una caja debemos tener en cuenta tres factores fundamentales: Robustez, diseño interior y accesibilidad. Refrigeración (que cuente con ventiladores opcionales o bien la posibilidad de ponérselos). Fuente de alimentación. Este tema es de suma importancia, ya que tanto de su capacidad como de su calidad depende en buena medida tanto el rendimiento como la estabilidad e integridad de nuestro ordenador. Para un ordenador actual debemos partir como mínimo de una fuente de 450w, siendo aconsejable una de 500w. MICROPROCESADORES Aquí encontramos una amplia (y a veces liosa) gama, tanto en INTEL como en AMD. La primera dificultad con la que nos encontramos es la nomenclatura de los mismos. Mientras INTEL usa para identificar a sus micros la velocidad de relog del mismo, AMD ha optado por identificarlos por la relación que sus micros tienen con INTEL (salvo en la serie FX, que no tiene equivalente en INTEL), independientemente de su velocidad real. Para explicar esto habría que meterse en temas técnicos sobre la arquitectura de los micros. Baste decir que aunque ambos son micros para ordenadores personales basados en IBM, no usan la misma arquitectura, por lo que el rendimiento (a igualdad de velocidad) de un AMD es muy superior a la de un INTEL (la velocidad de reloj de un AMD 3000+ es de 1800 Mh). MICROPROCESADORES INTEL : Los microprocesadores INTEL actuales usan el socket 775 (de 775 contactos), en los que se han eliminado los tradicionales pines para sustituirlos por contactos, menos frágiles que los pines. Soportan tanto memorias DDR como DDR2. Todos soportan tanto 32 como 64 bits. Los P4 cuentan con Hyper Treading (permite dos subprocesos en paralelo). Soportan los estándares multimedia SSE, SSE2, SSE3 y MMX. Toda la gama INTEL cuenta con funcionalidad de desactivación de ejecución de bit, tecnología que evita el ataque de virus que provoquen desbordamiento de buffer (con XP SP2). GAMA INTEL CELERON D Aunque INTEL mantiene en su catálogo algunos Celeron con socket 478, no los incluyo en esta lista por estar destinados solo a montadores, ya que actualmente no se comercializan placas 478. La lista siguiente corresponde a micros con socket LGA775. Todos soportan la tecnología Intel 64 de 64 bits, tienen un bus frontal de 533 Mhz y soportan Bit de Desactivación. El orden es el siguiente: Numero/Arquitectura/Cache/Velocidad. 326 / 90nm / 256Kb L2 / 2.53Ghz 331 / 90nm / 256Kb L2 / 2.86Ghz 336 / 90nm / 256Kb L2 / 2.80Ghz 341 / 90nm / 256Kb L2 / 2.93Ghz 346 / 90nm / 256Kb L2 / 3.06Ghz 347 / 65nm / 512Kb L2 / 3.06Ghz 351 / 90nm / 256Kb L2 / 3.20Ghz 352 / 65nm / 512Kb L2 / 3.20Ghz 355 / 90nm / 256Kb L2 / 3.33Ghz 356 / 65nm / 512Kb L2 / 3.33Ghz 360 / 65nm / 512Kb L2 / 3.46Ghz 365 / 65nm / 512Kb L2 / 3.60Ghz PENTIUM 4 (NUCLEO SIMPLE) Todos los P4 utilizan el socket LGA775. Todos son micros de 64 bit, con la tecnología Intel 64 y soportan Bit de Desactivación. El orden es el siguiente: Numero/Arquitectura/Cache/Velocidad/Bus frontal/Hiper Threading/SpeedStep. 506 / 90nm / 1Mb L2 / 533Mhz / 2.66Ghz / No / No 511 / 90nm / 1Mb L2 / 533Mhz / 2.86Ghz / No / No 516 / 90nm / 1Mb L2 / 533Mhz / 2.93Ghz / No / No 524 / 90nm / 1Mb L2 / 533Mhz / 3.06Ghz / Si / No 521 / 90nm / 1Mb L2 / 800Mhz / 2.80Ghz / Si / No 531 / 90nm / 1Mb L2 / 800Mhz / 3.00Ghz / Si / No 541 / 90nm / 1Mb L2 / 800Mhz / 3.20Ghz / Si / No 551 / 90nm / 1Mb L2 / 800Mhz / 3.40Ghz / Si / No 630 / 90nm / 2Mb L2 / 800Mhz / 3.00Ghz / Si / Si 631 / 65nm / 2Mb L2 / 800Mhz / 3.00Ghz / Si / Si 640 / 90nm / 2Mb L2 / 800Mhz / 3.20Ghz / Si / Si 641 / 65nm / 2Mb L2 / 800Mhz / 3.20Ghz / Si / Si 650 / 90nm / 2Mb L2 / 800Mhz / 3.40Ghz / Si / Si 651 / 65nm / 2Mb L2 / 800Mhz / 3.40Ghz / Si / Si 660 / 90nm / 2Mb L2 / 800Mhz / 3.60Ghz / Si / Si 661 / 65nm / 2Mb L2 / 800Mhz / 3.60Ghz / Si / Si 670 / 90nm / 2Mb L2 / 800Mhz / 3.80Ghz / Si / Si PENTIUM D (DOBLE NUCLEO) Todos los Pentium D utilizan el socket LGA775 con Bus frontal a 800Mhz. Todos son micros de 64 bit, con la tecnología Intel 64, soportan Bit de Desactivación y todos menos el 820 soportan SpeedStep. El orden es el siguiente: Numero/Arquitectura/Cache/Velocidad/IVT (Intel Virtualization Technology). 820 / 90nm / 2 x 1Mb L2 / 2.80Ghz / No 830 / 90nm / 2 x 1Mb L2 / 3.00Ghz / No 840 / 90nm / 2 x 1Mb L2 / 3.20Ghz / No 915 / 65nm / 2 x 2Mb L2 / 2.80Ghz / No 920 / 65nm / 2 x 2Mb L2 / 2.80Ghz / Si 925 / 65nm / 2 x 2Mb L2 / 3.00Ghz / No 930 / 65nm / 2 x 2Mb L2 / 3.00Ghz / Si 935 / 65nm / 2 x 2Mb L2 / 3.20Ghz / No 940 / 65nm / 2 x 2Mb L2 / 3.20Ghz / Si 945 / 65nm / 2 x 2Mb L2 / 3.40Ghz / No 950 / 65nm / 2 x 2Mb L2 / 3.40Ghz / Si 960 / 65nm / 2 x 2Mb L2 / 3.60Ghz / Si PENTIUM Extreme Edition (DOBLE NUCLEO) Todos los Pentium Extreme Edition utilizan el socket LGA775. Todos son micros de 64 bit, con la tecnología Intel 64, soportan Bit de Desactivación y soportan Hyper threading. No soportan SpeedStep. El orden es el siguiente: Numero/Arquitectura/Cache/Bus frontal/Velocidad/IVT (Intel Virtualization Technology). 840 / 90nm / 2 x 1Mb L2 / 800Mhz / 3.20Ghz / No 955 / 65nm / 2 x 2Mb L2 / 1066Mhz / 3.46Ghz / Si 965 / 65nm / 2 x 2Mb L2 / 1066Mhz / 3.73Ghz / Si PENTIUM CORE 2 DUO (DOBLE NUCLEO) Todos los Pentium Core2 Duo utilizan el socket LGA775. Todos son micros de 64 bit, con la tecnología Intel 64 y usan la arquitectura de 65nm, , soportan Bit de Desactivación y soportan SpeedStep. La velocidad es por núcleo (1.80Gb = 2 núcleos de 1.80Gb) El orden es el siguiente: Numero/Cache/Bus frontal/Velocidad/IVT (Intel Virtualization Technology). E4300 / 2Mb L2 / 800Mhz / 1.80Ghz / No E6300 / 2Mb L2 / 1066Mhz / 1.86Ghz / Si E6400 / 2Mb L2 / 1066Mhz / 2.13Ghz / Si E6600 / 4Mb L2 / 1066Mhz / 2.40Ghz / Si E6700 / 4Mb L2 / 1066Mhz / 2.66Ghz / Si PENTIUM CORE 2 QUAD (CUATRO NUCLEOS) Todos los Pentium Core2 Quad utilizan el socket LGA775 con cuatro núcleos. Todos son micros de 64 bit, con la tecnología Intel 64 y usan la arquitectura de 65nm, , soportan Bit de Desactivación y soportan SpeedStep y IVT. La velocidad es por núcleo. El orden es el siguiente: Numero/Cache/Bus frontal/Velocidad. Q6600 / 8Mb L2 / 1066Mhz / 2.40Ghz PENTIUM CORE 2 Extreme Edition http://www2.udec.cl/~svasquez/images/intelcore2extreme.jpg Todos los Pentium Core2 Duo utilizan el socket LGA775. Todos son micros de 64 bit, con la tecnología Intel 64 y usan la arquitectura de 65nm, , soportan Bit de Desactivación, soportan SpeedStep y IVT. La velocidad es por núcleo. El orden es el siguiente: Numero/Núcleos/Cache/Bus frontal/Velocidad. X6800 / 2 / 4Mb L2 / 1066Mhz / 2.93Ghz QX6700 / 4 / 8Mb L2 / 1066Mhz / 2.66Ghz GAMA AMD Los microprocesadores AMD usan tres tipos diferentes de sockets. El 754 (754 pines), que lo usan solo los Sempron, el 939 (de 939 pines), compatible con memorias DDR y el AM2 (de 940 pines), compatible con memorias DDR2. Esta diferencia se debe a que los microprocesadores de AMD llevan incorporado el gestor de memoria en el micro de doble canal (128 bits), lo que hace que el uso de la memoria sea mucho mas optimizado que en los procesadores INTEL, al ser la comunicación entre el micro y la memoria directa, no existiendo prácticamente tiempo de latencia. La serie 64 son microprocesadores de 64 bits, pero implementan 32 bits de forma nativa. Todos soportan las instrucciones SSE, SSE2 y SS3 de 128 bits, MMX y las exclusivas de AMD 3D Now!. Tienen un ancho de banda para DDR de 72 bits (64 de datos + 8 de control) de hasta 6.4 Gbps, sin buffer y mediante la tegnologia HyperTransport de 16 + 16 bit consiguen un FBS de hasta 2000 Mhz, lo que les da un ancho de banda total de hasta 18.6 Gbps (dependiendo del modelo). Los Athlon 64 cuentan con EVP (protección mejorada antivirus), que trabaja junto con Windows XP SP2, Linux, Soliaris y BSD Unix, protegiendo el sistema evitando el ataque de virus que provoquen desbordamiento de buffer. AMD está reestructurando casi toda su gama y pasandola a socket AM2. Mantiene algunos Sempron en socket 754 para ensambladores, pero practicamente se ha dejado de distribuir las placas 754 y 939, por lo que, salvo en los Sempron, indico solo los procesadores con socket AM2 SEMPRON Los AMD Sempron, a pesar de ser el comienzo de la gama AMD, no son comparables en rendimiento a los INTEL Celeron, sino mas bien a los anteriores amd Athlon Y P4. Son procesadores que trabajan a 64bit y a 32 bit y todos tienen una velocidad FBS de 1600Mhz, con la tecnología HyperTransport. Nombre / Vel. Reloj / Men. Caché (L1-L2) Socket 754 2800+ / 1600Mhz / 128Kb - 256Kb 3000+ / 1800Mhz / 128Kb - 128Kb 3100+ / 1800Mhz / 128Kb - 256Kb 3300+ / 2000Mhz / 128Kb - 128Kb 3400+ / 2000Mhz / 128Kb - 256Kb Socket AM2 2800+ / 1600Mhz / 128Kb - 128Kb 3000+ / 1600Mhz / 128Kb - 256Kb 3200+ / 1800Mhz / 128Kb - 128Kb 3400+ / 1800Mhz / 128Kb - 256Kb 3500+ / 2000Mhz / 128Kb - 128Kb 3600+ / 2000Mhz / 128Kb - 256Kb 3800+ / 2200Mhz / 128Kb - 256Kb ATHLON 64 Los AMD Athlon 64, son los rivales del INTEL Pentiun 4. Son procesadores que trabajan a 64bit y a 32 bit y todos tienen una velocidad FBS de 2000Mhz, con la tecnología HyperTransport. Socket AM2 y memorias DDR2. Nombre / Vel. Reloj / Men. Caché (L1-L2) 3000+ / 1800Mhz / 128Kb - 512Kb 3200+ / 2000Mhz / 128Kb - 512Kb 3500+ / 2200Mhz / 128Kb - 512Kb 3800+ / 2400Mhz / 128Kb - 512Kb ATHLON 64 x2 Los AMD Athlon 64 x2, son los rivales del INTEL Core 2 Duo. Son procesadores de doble núcleo y ambos trabajan a 64bit y a 32 bit y todos tienen una velocidad FBS de 2000Mhz, con la tecnología HyperTransport. La memoria cache es independiente para cada núcleo. Socket AM2 y memorias DDR2. Nombre / Vel. Reloj / Men. Caché (L1-L2) 3600+ / 1900Mhz / 128Kb x2 - 512Kb x2 3800+ / 2000Mhz / 128Kb x2 - 512Kb x2 4000+ / 2100Mhz / 128Kb x2 - 1Mb x2 4000+ / 2000Mhz / 128Kb x2 - 512Kb x2 4200+ / 2200Mhz / 128Kb x2 - 512Kb x2 4400+ / 2200Mhz / 128Kb x2 - 1Mb x2 4400+ / 2300Mhz / 128Kb x2 - 512Kb x2 4600+ / 2400Mhz / 128Kb x2 - 512Kb x2 4800+ / 2400Mhz / 128Kb x2 - 1Mb x2 4800+ / 2500Mhz / 128Kb x2 - 512Kb x2 5000+ / 2600Mhz / 128Kb x2 - 512Kb x2 5200+ / 2600Mhz / 128Kb x2 - 1Mb x2 5400+ / 2800Mhz / 128Kb x2 - 512Kb x2 5600+ / 2800Mhz / 128Kb x2 - 1Mb x2 ATHLON 64 FX Es difícil encuadrar a los AMD Athlon 64 FX con la gama de INTEL (salvo quizás con los Core 2 Extreme Edition). Son procesadores de doble núcleo y Quad de doble socket de conexión directa (DSDC), con un ancho de banda de hasta 25.6Gbps. Todos tienen una velocidad FBS de 2000Mhz, con la tecnología HyperTransport y memorias DDR2. No tienen relación en su denominación con INTEL (al contrario del resto de la gama), solo una relación FXxx, donde xx representa la velocidad de estos (a xx mayor, mayor velocidad). Nombre / Vel. Reloj / Men. Caché (L1-L2) / Socket Fx62 / 2800Mhz / 2 / 128Kb x2 - 1Mb x2 / AM2 Fx70 / 2600Mhz / 4 / 128Kb x2 - 1Mb x2 / Socket F (1207Fx) Fx72 / 2800Mhz / 4 / 128Kb x2 - 1Mb x2 / Socket F (1207Fx) Fx74 / 3000Mhz / 4 / 128Kb x2 - 1Mb x2 / Socket F (1207Fx) Llegados a este punto, es conveniente hacer unas aclaraciones sobre los microprocesadores de doble núcleo. Tienen la gran ventaja de que cuando ejecutamos varias tareas a la vez, la carga de estas se reparte entre los núcleos y, en programas preparados para ello, ejecutan parte del programa en un núcleo y parte en el otro. Esto supone una gran ventaja en cuanto a rapidez, PERO SOLO CON PROGRAMAS QUE ESTEN DISEÑADOS PARA SOPORTAR ESTA FUNCION. En la actualidad están preparados para esta función Windows XP Profesional SP2 y la mayoría de los programas de diseño 2D – 3D, así como varios de tratamiento fotográfico (Photoshop, EDStudio, Autocad..), pero en la actualidad ningún juego esta preparado para ejecutarlo en doble núcleo, por lo que no se conseguirá ninguna mejora en estos. Además, debemos tener muy en cuenta que el calor generado por estos micros es muy superior al generado por un micro de núcleo único. Esto hace que sea muy delicado (hasta peligroso) hacer overclocking en estos micros. REFRIGERACION. Este es un apartado de suma importancia para la vida de nuestro ordenador. Normalmente tendremos suficiente con el disipador que nos viene con el micro, pero si deseamos sacarle el máximo rendimiento es conveniente sustituir este por uno de mayor poder de disipación. A mayor rendimiento el micro generará mayor temperatura y tendremos que disipar más. MEMORIAS. Hay dos tipos de memorias disponibles actualmente: DDR (184 contactos), en 400 Mhz (DDR400 – PC3200) DDR2 (240 contactos), en 400 Mhz (DDR2-400 – PC2-3200), 533Mhz (DDR2-533 – PC2-4200), 667 Mhz (DDR2600 – PC2-5300) y 800 Mhz (DDR2-800 – PC2-6400). La elección entre un tipo de memoria y otro viene determinado por la placa base que usemos y la cantidad de la misma (expresado en Mb), de la aplicación que vayamos a darle a nuestro ordenador y de la capacidad de la placa base. TARJETA GRAFICA. Imagenes de dos graficas. A la izquierda una AGP, a la derecha una PCIExpress. Existen en el mercado dos grandes marcas de chipset en gráficas, NVIDIA y ATI (adquirida hace poco por AMD). Ambas marcas tienen modelos que cubren todas las necesidades del mercado, y que van desde los 64 Mb hasta los 1024 Mb. Los soportes para estas tarjetas son de dos tipos: AGP, con un ratio de transferencia de hasta 8x (velocidad de 533 Mhz y 2 Gb/s) y PCIexpress, con un ratio de transferencia de 16x (para una tasa de transferencia punto a punto de 4 Gb/s en modo bidireccional, lo que lo convierten en 16 Gb/s). Las AGP tienden a desaparecer, por lo que la oferta en estas es cada vez menor. La elección entre una u otra dependerá de la placa base que tengamos y la capacidad y modelo del uso que le vayamos a dar. Para aplicaciones ofimáticas e Internet, con una VGA de 64 Mb tendremos mas que suficiente, mientras que para aplicaciones 3D, edición de video, edición fotográfica y, sobre todo, para juegos nos interesará una VGA lo más potente posible. PLACA BASE. La elección de la placa base vendrá determinada por el tipo de microprocesador que vayamos a tener, ya que dependiendo del socket que tenga el micro deberemos utilizar un tipo de placa base u otro, no siendo compatibles entre sí. Estamos ante el principal componente de nuestro ordenador, tan importante o mas que el micro, ya que de la placa base dependerá que podamos sacarle al mismo todo su rendimiento. En las placas base, el precio va más ligado a la calidad de la misma que a las prestaciones y esto es algo que debemos de tener muy en cuenta. Un punto muy importante es la estabilidad en el rendimiento, ya que es mejor una placa que no de grandes picos a otra que en un momento dado nos de un gran pico, pero que luego también nos de una gran bajada. Esto suele ocurrir en bastantes placas de marcas económicas, así como en modelos económicos de las primeras marcas (a veces el marketing se impone). Dado que dentro de una misma marca existen varios modelos con diferentes prestaciones (y muy diferentes precios), debemos hacer nuestra elección con sumo cuidado y teniendo muy en cuenta el uso que vayamos a darle al ordenador. En la actualidad se están poniendo de moda un tipo de placas denominadas SLI, que consisten en placas con doble PCIexpress 16x para VGA. Sobre este tipo de placas me gustaría hacer una aclaración. Los fabricantes suelen tener esta misma placa, pero con un solo slot para gráfica, con las mismas prestaciones y a un precio bastante inferior, ya que las placas SLI son bastante caras. Este tipo de placa esta pensado sobre todo para trabajar en programas de diseño, con 2 tarjetas gráficas y 1 o 2 monitores, trabajando en una y mostrando el resultado en otro. Si tenemos esto en cuenta, la diferencia de precio final puede rondar los 500 euros, por lo que si no pensamos conectar dos monitores o usar las ultas prestaciones de SLI es preferible decantarnos por otro modelo de placa base que nos de el mismo rendimiento (por ejemplo, la ASUS A8N-SLI y la ASUS A8N-E en realidad son la misma placa, solo que la primera es SLI y el precio de la primera es casi el doble que la segunda). Las placas base actuales tienen incorporados hasta 10 puertos USB 2.0, tarjeta Ethernet, tarjeta de sonido (en la mayoria de los casos 5.1 y en las placas de gama alta, de hasta 8.1) y dependiendo del modelo, conexión WIFI y Firewire. DISCO DURO. Es donde vamos a grabar el SO y donde vamos a almacenar nuestros datos, por lo que el tamaño del mismo (que actualmente va desde los 80 Gb hasta los 400 Gb) dependerá de la cantidad de información que pensemos guardar. Existen dos tipos de discos, dependiendo de la conexión: IDE y SATA. En la actualidad todas las placas base vienen preparadas para discos SATA, por lo que es la opción mas lógica, ya que su tasa de transferencia es muy superior. OTROS COMPONENTES. En este apartado debemos meter el lector – regrabador de DVD, lector de tarjetas de memoria flash, disquetera y tarjeta de sonido. En este ultimo tema es importante que sepamos que (naturalmente dependiendo de la calidad de la placa base) la calidad de las tarjetas de sonido integradas en placa base suele ser bastante elevada, por lo que en la mayoría de los casos tendremos bastante con esta. COMPATIBILIDADES. Esta es una palabra clave. ¿Qué es la compatibilidad entre los diferentes componentes que forman el ordenador?. Cada tipo de microprocesador tiene un tipo de socket diferente (775 en el caso de INTEL, 754 en el caso de los Sempron y 939 y AM2 en el caso de AMD), por lo que cuando compramos la placa base, esta se tiene que adaptar al micro que queremos, pero no termina ahí la cosa. Debemos estudiar detenidamente las especificaciones de la placa base y comprobar los siguientes puntos: Que, dentro del socket elegido, soporte el tipo de micro que queremos en cuanto a velocidad. Que la VGA sea compatible con la placa base (AGP o PCIe). Que el tipo de memoria, así como la cantidad, velocidad y capacidad de los módulos los soporte la placa base. Este punto necesita un poco mas de explicación. Las placas para INTEL pueden llevar tanto módulos DDR como DD2, las placas para AMD llevan módulos DDR las 754 y las 939 y módulos DDR2 las AM2. Asimismo, debemos comprobar el número de slot que tiene, la capacidad máxima de los mismos y las frecuencias que soportan. Muchas placas con Dual Channel tienen 4 slots de memoria, pero la configuración no es libre. Soportan un modulo, dos en Dual Channel y 4 en Dual Channel, pero NO soportan tres módulos, por lo que si queremos 3072 Mb tendremos que poner 2 módulos de 1024 y otros dos de 512. Esto se debe a la configuración del bus de datos de la memoria, ya que una vez activado el Dual Channel (se activa al conectar dos módulos en los bancos 0 y 2), los módulos tienen que ir de dos en dos. Asimismo, las placas suelen soportar varias frecuencias, pero no todas. Muchas placas para DDR2 soportan módulos DDR2-667, y DDR2-800. Este es un punto que debemos comprobar muy bien, ya que nos ahorraremos algún dinero y bastantes problemas. Si vamos a cambiar el disipador debemos asegurarnos de que es el adecuado para el socket de nuestra placa base. EJEMPLOS DE CONFIGURACION. Vamos a dar unos cuantos ejemplos de configuración basándonos en el uso al que vaya destinado el ordenador. INTERNET, OFIMATICA Y REPRODUCIR MUSICA Y VIDEOS Y JUEGOS POCO PESADOS Este es un uso que no requiere grandes requisitos en el sistema, por lo que puede ser una configuración bastante económica. MICRO.- Podemos decantarnos por un INTEL Celeron o bien por un AMD Sempron. Además, tampoco necesitamos que sean excesivamente potentes. REFRIGERACION.- Tendremos suficiente con el disipador que trae el micro. PLACA BASE.- Con una placa base de gama media tendremos suficiente. MEMORIA.- Para este uso, con 512 Mb tendremos suficiente. VGA.- Con una VGA de 128 Mb iremos bien. También podemos elegir una placa base con la VGA incorporada. DISCO DURO.- Dependiendo de lo que pensemos almacenar, con un disco de entre 80 Gb y 160 Gb tendremos suficiente. OTROS COMPONENTES.- Lector – regrabador de DVD, disquetera, lector de tarjetas. LO ANTERIOR MAS EDICION DE VIDEO Y FOTOGRAFIA MICRO.- Podemos decantarnos por un INTEL P4 o bien por un AMD Sempron o Athlon 64. REFRIGERACION.- Casi siempre tendremos suficiente con el disipador que trae el micro. PLACA BASE.- Nos decantaremos por una placa base de gama media – alta. MEMORIA.- Para este uso, con 2048 Mb tendremos suficiente. Es interesante que sea Dual Channel VGA.- Con una VGA de 256 Mb iremos bien. No es recomendable una VGA incorporada en placa base. DISCO DURO.- Dependiendo de lo que pensemos almacenar, con un disco de entre 200 Gb y 300 Gb tendremos suficiente. Debemos tener en cuenta que la edición de video necesita mucho disco duro OTROS COMPONENTES.- Lector de DVD, regrabador de DVD, disquetera, lector de tarjetas, probablemente necesitemos una capturadota de video si pensamos pasar cintas de VHS a DVD. DISEÑO GRAFICO MICRO.- Podemos decantarnos por un INTEL P4 D o bien por un AMD Athlon 64 X2 o FX (para esta configuración si vamos a notar bastante el doble núcleo. A ser posible a partir de 3500 Mh. REFRIGERACION.- Es conveniente sustituir el disipador por uno de más potencia. PLACA BASE.- Deberíamos elegir una placa base de gama alta. Para este uso estaría justificado el uso de una placa base SLI. MEMORIA.- Para este uso, con 2048 Mb tendremos una memoria adecuada, pero mejor 4096. Muy recomendable Dual Channel y a ser posible DDR2. VGA.- Con una VGA de 512 Mb iremos bien. Es conveniente PCIe. Para este uso concreto, las prestaciones de NVIDIA son algo superiores a las de ATI. DISCO DURO.- Dependiendo de lo que pensemos almacenar, a partir de 200 Gb. OTROS COMPONENTES.- Lector de DVD, regrabador de DVD, disquetera, lector de tarjetas. EDICION DE VIDEO, EDICION DE SONIDO Y JUEGOS DE ULTIMA GENERACION Quizás sea esta la configuración mas exigente en algunos apartados, como la elección de la VGA. MICRO.- Podemos decantarnos por un INTEL P4 o bien por un AMD Athlon 64 o FX. Si vamos a realizar varias tareas a la vez, podemos elegir un micro de doble núcleo. A partir de 3500 Mh REFRIGERACION.- Es conveniente sustituir el disipador por uno de más potencia. PLACA BASE.- Necesitaremos una placa base de gama alta y alto rendimiento. Algunos fabricantes tienen placas específicamente diseñadas para juegos, como es el caso de la serie LANParty de DFI, con un rendimiento optimizado para juegos de última generación. MEMORIA.- Para este uso, con 2048 - 4096 Mb tendremos suficiente. Debe ser Dual Channel y a ser posible DDR2. VGA.- Con una VGA de 512 - 1024 Mb iremos bien. Muy recomendable PCIe. DISCO DURO.- Dependiendo de lo que pensemos almacenar, a partir de 200 Gb. OTROS COMPONENTES.- Lector – regrabador de DVD, disquetera, lector de tarjetas. En esta configuración nos puede interesar recurrir a una tarjeta de sonido adicional del tipo Sound Blaster Audigy Pro.

Curso completo de c para recien iniciados primero un compilador http://downloads.sourceforge.net/project/dev-cpp/Binaries/Dev-C%2B%2B%204.9.9.2/devcpp-4.9.9.2_setup.exe?use_mirror=ufpr LENGUAJE C El lenguaje C es uno de los más rápidos y potentes que hay hoy en día. Algunos dicen que está desfasado y que el futuro es Java. No se si tendrá futuro pero está claro que presente si tiene. No hay más que decir que el sistema operativo Linux está desarrollado en C en su práctica totalidad. Así que creo que no sólo no perdemos nada aprendiendolo sino que ganamos mucho. Para empezar nos servirá como base para aprender C++ e introducirnos en el mundo de la programación Windows. Si optamos por Linux existe una biblioteca llamada gtk (o librería, como prefieras) que permite desarrollar aplicaciones estilo windows con C. No debemos confundir C con C++, que no son lo mismo. Se podría decir que C++ es una extensión de C. Para empezar en C++ conviene tener una sólida base de C. Existen otros lenguajes como Visual Basic que son muy sencillos de aprender y de utilizar. Nos dan casi todo hecho. Pero cuando queremos hacer algo complicado o que sea rápido debemos recurrir a otros lenguajes (c++, delphi,...). PECULIARIDADES Una de las cosas importantes de C que debes recordar es que es Case Sensitive (sensible a las mayúsculas o algo así). Es decir que para C no es lo mismo escribir Printf que printf. Conviene indicar también que las instrucciones se separan por ";". COMPILADORES DE C Un compilador es un programa que convierte nuestro código fuente en un programa ejecutable. El ordenador trabaja con 0 y 1. Si escribiéramos un programa en el lenguaje del ordenador nos volveríamos locos. Para eso están lenguajes como el C. Nos permiten escribir un programa de manera que sea fácil entenderlo por una persona (el código fuente). Luego es el compilador el que se encarga de convertirlo al complicado idioma de un ordenador. En la practica a la hora de crear un programa nosotros escribimos el código fuente, en nuestro caso en C, que normalmente será un fichero de texto normal y corriente que contiene las instrucciones de nuestro programa. Luego se lo pasamos al compilador y este se encarga de convertirlo en un programa. Si tenemos el código fuente podemos modificar el programa tantas veces como queramos (sólo tenemos que volver a compilarlo), pero si tenemos el ejecutable final no podremos cambiar nada (realmente sí se puede pero es mucho más complicado y requiere más conocimientos). EL EDITOR El compilador en sí mismo sólo es un programa que traduce nuestro código fuente y lo convierte en un ejecutable. Para escribir nuestros programas necesitamos un editor. La mayoría de los compiladores al instalarse incorporan ya un editor; es el caso de los conocidos Turbo C, Borland C, Visual C++,... Pero otros no lo traen por defecto. No debemos confundir por tanto el editor con el compilador. Estos editores suelen tener unas características que nos facilitan mucho el trabajo: permiten compilar y ejecutar el programa directamente, depurarlo (corregir errores), gestionar complejos proyectos,... Si nuestro compilador no trae editor la solución más simple en MS-Dos puede ser usar el edit, en windows el notepad. Pero no son más que editores sin ninguna otra funcionalidad. Otra posibilidad es un entorno de desarrollo llamado RHIDE, un programa muy útil que automatiza muchas de las tareas del programador (del estilo del Turbo C y Turbo Pascal). Si queremos una herramienta muy avanzada podemos usar Emacs, que es un editor muy potente, aunque para algunos puede parecer muy complicado. Estos dos programas están disponibles tanto en Linux como en MS-Dos. PRIMER PROGRAMA: HOLA MUNDO En un alarde de originalidad vamos a hacer nuestro primer programa: hola mundo. Nadie puede llegar muy lejos en el mundo de la programación sin haber empezado su carrera con este original y funcional programa. Allá va: #include <stdio.h> int main() { printf("Hola mundo\n"; return 0; } Nota: Hay mucha gente que programa en Windows que se queja de que cuando ejecuta el programa no puede ver el resultado. Para evitarlo se puede añadir antes de return 0; la siguiente línea: system("PAUSE"; Si esto no funciona prueba a añadir getch(); ¿Qué fácil eh? Este programa lo único que hace es sacar por pantalla el mensaje: Hola mundo Vamos ahora a comentar el programa línea por línea (Esto no va a ser más que una primera aproximación). #include <stdio.h> #include es lo que se llama una directiva. Sirve para indicar al compilador que incluya otro archivo. Cuando en compilador se encuentra con esta directiva la sustituye por el archivo indicado. En este caso es el archivo stdio.h que es donde está definida la función printf, que veremos luego. int main() Es la función principal del programa. Todos los programas de C deben tener una función llamada main. Es la que primero se ejecuta. El int (viene de Integer=Entero) que tiene al principio significa que cuando la función main acabe devolverá un número entero. Este valor se suele usar para saber cómo ha terminado el programa. Normalmente este valor será 0 si todo ha ido bien, o un valor distinto si se ha producido algún error. Se puede usar la definición 'void main()', que no necesita devolver ningún valor, pero se recomienda la forma con 'int' que es más correcta. A lo largo de la realización de ejercicios verás muchos ejemplos que se usan 'void main' y falta el return 0; del final, el código funciona correctamente pero puede dar un 'warning' al compilar. { Son las llaves que indican el comienzo de una función, en este caso la función main. /* Aquí va el cuerpo del programa */ Esto es un comentario, no se ejecuta. Sirve para describir el programa. Conviene acostumbrarse a comentar los programas. Un comentario puede ocupar más de una línea. Por ejemplo el comentario: /* Este es un comentario que ocupa dos filas */ es perfectamente válido. printf( "Hola mundo\n" ); Aquí es donde por fin el programa hace algo que podemos ver al ejecutarlo. La función printf muestra un mensaje por la pantalla. Al final del mensaje "Hola mundo" aparece el símbolo '\n'; este hace que después de imprimir el mensaje se pase a la línea siguiente. Fíjate en el ";" del final. Es la forma que se usa en C para separar una instrucción de otra. Se pueden poner varias en la misma línea siempre que se separen por el punto y coma. return 0; Como se ha indicado el programa al finalizar develve un valor entero. Como en este programa no se pueden producir errores la salida siempre será 0. La forma de hacer que el programa devuelva un 0 es usando return. Esta línea significa 'finaliza la función main haz que devuelva un 0. } ...y cerramos llaves con lo que termina el programa. Todos los programas finalizan cuando se llega al final de la función main. COMO SE HACE Primero debemos crear el código fuente del programa. Para nuestro primer programa el código fuente es el del listado anterior. Arranca el programa, crea un nuevo fichero o proyecto elige la opcion Console Application llámalo por ejemplo primero.c. y copia el código anterior. Ahora, tenemos que compilar y ejecutar el programa (F9). ALGO MAS SOBRE LOS COMENTARIOS Los comentarios se pueden poner casi en cualquier parte. Excepto en medio de una instrucción. Por ejemplo lo siguiente no es válido: pri/* Esto es un comentario */ntf( "Hola mundo" ); GARRAFAL No podemos cortar a printf por en medio, tendríamos un error al compilar. Lo siguiente no daría error (al menos usando DJGPP), pero es una fea costumbre: printf( /* Esto es un comentario */ "Hola mundo" ); Y por último tenemos: printf( "Hola/* Esto es un comentario */ mundo" ); Que no daría error, pero al ejecutar tendríamos: Hola /* Esto es un comentario */ mundo porque /* Esto es un comentario */ queda dentro de las comillas y C lo interpreta como texto, no como un comentario. Busca los errores en este programa: int main() { /* Aquí va el cuerpo del programa */ Printf( "Hola mundo\n" ); return 0; } Solución: Si lo compilamos posiblemente obtendremos un error que nos indicará que no hemos definido la función 'Printf'. Esto es porque no hemos incluído la dichosa directiva '#include <stdio.h>'. (En algunos compiladores no es necesario incluir esta directiva, pero es una buena costumbre hacerlo). Si lo corregimos y volvemos a compilar obtendremos un nuevo error. Otra vez nos dice que desconoce 'Printf'. Esta vez el problema es el de las mayúsculas que hemos indicado antes. Lo correcto es poner 'printf' con minúsculas. Parece una tontería, pero seguro que nos da más de un problema. IMPRIMIR EN PANTALLA: printf La función printf, sirve para sacar información por pantalla. Para utilizar la función printf en nuestros programas debemos incluir la directiva: #include <stdio.h> al principio de programa. Como hemos visto en el programa hola mundo. Si sólo queremos imprimir una cadena basta con hacer (no olvides el ";" al final): printf( "Cadena" ); Esto resultará por pantalla: Cadena Lo que pongamos entre las comillas es lo que vamos a sacar por pantalla. Si volvemos a usar otro printf, por ejemplo: #include <stdio.h> int main() { printf( "Cadena" ); printf( "Segunda" ); return 0; } Obtendremos: CadenaSegunda Este ejemplo nos muestra cómo funciona printf. Para escribir en la pantalla se usa un cursor que no vemos. Cuando escribimos algo el cursor va al final del texto. Cuando el texto llega al final de la fila, lo siguiente que pongamos irá a la fila siguiente. Si lo que queremos es sacar cada una en una línea deberemos usar "\n". Es el indicador de retorno de carro. Lo que hace es saltar el cursor de escritura a la línea siguiente: #include <stdio.h> int main() { printf( "Cadena\n" ); printf( "Segunda" ); return 0; } y tendremos: Cadena Segunda También podemos poner más de una cadena dentro del printf: printf( "Primera cadena" "Segunda cadena" ); Lo que no podemos hacer es meter cosas entre las cadenas: printf( "Primera cadena" texto en medio "Segunda cadena" ); esto no es válido. Cuando el compilador intenta interpretar esta sentencia se encuentra "Primera cadena" y luego texto en medio, no sabe qué hacer con ello y da un error. Pero ¿qué pasa si queremos imprimir el símbolo " en pantalla? Por ejemplo imaginemos que queremos escribir: Esto es "extraño" Si para ello hacemos: printf( "Esto es "extraño"" ); obtendremos unos cuantos errores. El problema es que el símbolo " se usa para indicar al compilador el comienzo o el final de una cadena. Así que en realidad le estaríamos dando la cadena "Esto es", luego extraño y luego otra cadena vacía "". Pues resulta que printf no admite esto y de nuevo tenemos errores. La solución es usar \". Veamos: printf( "Esto es \"extraño\"" ); Esta vez todo irá como la seda. Como vemos la contrabarra '\' sirve para indicarle al compilador que escriba caracteres que de otra forma no podríamos. Esta contrabarra se usa en C para indicar al compilador que queremos meter símbolos especiales. Pero ¿Y si lo que queremos es usar '\' como un carácter normal y poner por ejemplo Hola\Adiós? Pues muy fácil, volvemos a usar '\': printf( "Hola\\Adiós" ); y esta doble '\' indica a C que lo que queremos es mostrar una '\'. Esto no ha sido mas que una introducción a printf. POSICIONANDO EL CURSOR: gotoxy Esta función sólo está disponible en compiladores de C que dispongan de la biblioteca <conio.h> Hemos visto que cuando usamos printf se escribe en la posición actual del cursor y se mueve el cursor al final de la cadena que hemos escrito. Pero ¿qué pasa cuando queremos escribir en una posición determinada de la pantalla? La solución está en la función gotoxy. Supongamos que queremos escribir 'Hola' en la fila 10, columna 20 de la pantalla: #include <stdio.h> #include <conio.h> int main() { gotoxy( 20, 10 ); printf( "Hola" ); return 0; } (Nota: para usar gotoxy hay que incluir la biblioteca conio.h). Fíjate que primero se pone la columna (x) y luego la fila (y). La esquina superior izquierda es la posición (1, 1). BORRAR LA PANTALLA: clrscr Es necesario saber cómo se borra la pantalla. Pues es tan fácil como usar: clrscr() (clear screen, borrar pantalla). Esta función nó solo borra la pantalla, sino que además sitúa el cursor en la posición (1, 1), en la esquina superior izquierda. #include <stdio.h> #include <conio.h> int main() { clrscr(); printf( "Hola" ); return 0; } Este método sólo vale para compiladores que incluyan el fichero stdio.h. Ejercicio 1: Busca los errores en el programa. #include <stdio.h> int main() { ClrScr(); gotoxy( 10, 10 ) printf( Estoy en la fila 10 columna 10 ); return 0; } Solución: • ClrScr está mal escrito, debe ponerse todo en minúsculas, recordemos una vez más que el C diferencia las mayúsculas de las minúsculas. Además no hemos incluído la directiva #include <conio.h>, que necesitamos para usar clrscr() y gotoxy(). • Tampoco hemos puesto el punto y coma ( después del gotoxy( 10, 10 ). Después de cada instrucción debe ir un punto y coma. • El último fallo es que el texto del printf no lo hemos puesto entre comillas. Lo correcto sería: printf( "Estoy en la fila 10 columna 10" ); Ejercicio 2. Escribe un programa que borre la pantalla y escriba en la primera línea su nombre y en la segunda su apellido: Solución: #include <stdio.h> #include <conio.h> int main() { clrscr(); printf( "Gorka\n" ); printf( "Urrutia" ); return 0; } También se podía haber hecho todo de golpe: #include <stdio.h> #include <conio.h> int main() { clrscr(); printf( "Gorka\nUrrutia" ); return 0; } Ejercicio 3. Escriba un programa que borre la pantalla y muestre el texto "estoy aqui" en la fila 10, columna 20 de la pantalla: Solución: #include <stdio.h> #include <conio.h> int main() { clrscr(); gotoxy( 20, 10 ); printf( "Estoy aqui" ); return 0; } INTRODUCCIÓN AL TRABAJO CON TIPO DE DATOS Cuando usamos un programa es muy importante manejar datos. En C podemos almacenar los datos en variables. El contenido de las variables se puede ver o cambiar en cualquier momento. Estas variables pueden ser de distintos tipos dependiendo del tipo de dato que queramos meter. No es lo mismo guardar un nombre que un número. Hay que recordar también que la memoria del ordenador es limitada, así que cuando guardamos un dato, debemos usar sólo la memoria necesaria. Por ejemplo si queremos almacenar el número 400 usaremos una variable tipo int que ocupa sólo 16 bits, y no una de tipo long que ocupa 32 bits. Si tenemos un ordenador con 32Mb de Ram parece una tontería ponernos a ahorrar bits (1Mb=1024Kb, 1Kb=1024bytes, 1byte=8bits), pero si tenemos un programa que maneja muchos datos puede no ser una cantidad despreciable. Además ahorrar memoria es una buena costumbre. (Por si alguno tiene dudas: No hay que confundir la memoria con el espacio en el disco duro. Son dos cosas distintas. La capacidad de ambos se mide en bytes, y la del disco duro suele ser mayor que la de la memoria Ram. La información en la Ram se pierde al apagar el ordenador, la del disco duro permanece. Cuando queremos guardar un fichero lo que necesitamos es espacio en el disco duro. Cuando queremos ejecutar un programa lo que necesitamos es memoria Ram. VARIABLES A las variables no se les puede dar cualquier nombre. No se pueden poner más que letras de la 'a' a la 'z' (la ñ no vale), números y el símbolo '_'. No se pueden poner signos de admiración, ni de interrogación... El nombre de una variable puede contener números, pero su primer carácter no puede serlo. Ejemplos de nombres válidos: camiones numero buffer a1 j10hola29 num_alumnos Ejemplos de nombres no válidos: 1abc nombre? num/alumnos Tampoco valen como nombres de variable las palabras reservadas que usa el compilador. Por ejemplo: for, main, do, while. Por último es interesante señalar que el C distingue entre mayúsculas y minúsculas. Por lo tanto: Nombre nombre NOMBRE serían tres variables distintas. EL TIPO int En una variable de este tipo se almacenan números enteros (sin decimales). El rango de valores que admite es -32767 a 32767. Cuando definimos una variable lo que estamos haciendo es decirle al compilador que nos reserve una zona de la memoria para almacenar datos de tipo int. Para guardarla necesitaremos 16 bits de la memoria del ordenador (216=32767). Para poder usar una variable primero hay que declararla (definirla). Hay que decirle al compilador que queremos crear una variable y hay que indicarle de qué tipo. Por ejemplo: int numero; Esto hace que declaremos una variable llamada numero que va a contener un número entero. ¿Pero dónde se declaran las variables? Tenemos dos posibilidades, una es declararla como global y otra como local. Por ahora vamos a decir que global es aquella variable que se declara fuera de la función main y local la que se declara dentro: Variable Global Variable Local #include <stdio.h> int x; int main() { } #include <stdio.h> int main() { int x; } La diferencia práctica es que las variables globales se pueden usar en cualquier procedimiento. Las variables locales sólo pueden usarse en el procedimiento en el que se declaran. Como por ahora sólo tenemos el procedimiento (o función, o rutina, o subrutina, como prefieras) main esto no debe preocuparnos mucho por ahora. Cuando estudiemos cómo hacer un programa con más funciones aparte de main volveremos sobre el tema. Sin embargo debes saber que es buena costumbre usar variables locales que globales. Ya veremos por qué. Podemos declarar más de una variable en una sola línea: int x, y; Mostrar variables por pantalla Vamos a ir u poco más allá con la función printf. Supongamos que queremos mostrar el contenido de la variable x por pantalla: printf( "%i", x ); Suponiendo que x valga 10 (x=10) en la pantalla tendríamos: 10 Empieza a complicarse un poco ¿no? Vamos poco a poco. ¿Recuerdas el símbolo "\" que usábamos para sacar ciertos caracteres? Bueno, pues el uso del "%" es parecido. "%i" no se muestra por pantalla, se sustituye por el valor de la variable que va detrás de las comillas. ( %i, de integer=entero en inglés). Para ver el contenido de dos variables, por ejemplo x e y, podemos hacer: printf( "%i ", x ); printf( "%i", y ); resultado (suponiendo x=10, y=20): 10 20 Pero hay otra forma mejor: printf( "%i %i", x, y ); ... y así podemos poner el número de variables que queramos. Obtenemos el mismo resultado con menos trabajo. No olvidemos que por cada variable hay que poner un %i dentro de las comillas. También podemos mezclar texto con enteros: printf( "El valor de x es %i, ¡que bien!\n", x ); que quedará como: El valor de x es 10, ¡que bien! Como vemos %i al imprimir se sustituye por el valor de la variable. Asignar valores a variables de tipo int La asignación de valores es tan sencilla como: x = 10; También se puede dar un valor inicial a la variable cuando se define: int x = 15; También se pueden inicializar varias variables en una sola línea: int x = 15, y = 20; Hay que tener cuidado con lo siguiente: int x, y = 20; Podríamos pensar que x e y son igual a 20, pero no es así. La variable x está sin valor inicial y la variable 'y' tiene el valor 20. Veamos un ejemplo para resumir todo: #include <stdio.h> int main() { int x = 10; prinft( "El valor inicial de x es %i\n", x ); x = 50; printf( "Ahora el valor es %i\n", x ); } Cuya salida será: El valor inicial de x es 10 Ahora el valor es 50 Importante! Si imprimimos una variable a la que no hemos dado ningún valor no obtendremos ningún error al compilar pero la variable tendrá un valor cualquiera. Prueba el ejemplo anterior quitando int x = 10; Puede que te imprima el valor 10 o puede que no. El tipo Char Las variables de tipo char sirven para almacenar caracteres. Los caracteres se almacenan en realidad como números del 0 al 255. Los 128 primeros (0 a 127) son el ASCII estándar. El resto es el ASCII extendido y depende del idioma y del ordenador. Consulta la tabla ASCII en el anexo. Para declarar una variable de tipo char hacemos: char letra; En una variable char sólo podemos almacenar solo una letra, no podemos almacenar ni frases ni palabras. Eso lo veremos más adelante (strings, cadenas). Para almacenar un dato en una variable char tenemos dos posibilidades: letra = 'A'; o letra = 65; En ambos casos se almacena la letra 'A' en la variable. Esto es así porque el código ASCII de la letra 'A' es el 65. Para imprimir un char usamos el símbolo %c (c de character=caracter en inglés): letra = 'A'; printf( "La letra es: %c.", letra ); resultado: La letra es A. También podemos imprimir el valor ASCII de la variable usando %i en vez de %c: letra = 'A'; printf( "El número ASCII de la letra %c es: %i.", letra, letra ); resultado: El código ASCII de la letra A es 65. Como vemos la única diferencia para obtener uno u otro es el modificador (%c ó %i) que usemos. Las variables tipo char se pueden usar (y de hecho se usan mucho) para almacenar enteros. Si necesitamos un número pequeño (entre -127 y 127) podemos usar una variable char (8bits) en vez de una int (16bits), con el consiguiente ahorro de memoria. Todo lo demás dicho para los datos de tipo int se aplica también a los de tipo char . Una curiosidad: letra = 'A'; printf( "La letra es: %c y su valor ASCII es: %i\n", letra, letra ); letra = letra + 1; printf( "Ahora es: %c y su valor ASCII es: %i\n", letra, letra ); En este ejemplo letra comienza con el valor 'A', que es el código ASCII 65. Al sumarle 1 pasa a tener el valor 66, que equivale a la letra 'B' (código ASCII 66). La salida de este ejemplo sería: La letra es A y su valor ASCII es 65 Ahora es B y su valor ASCII es 66 El modificador Unsigned Este modificador (que significa sin signo) modifica el rango de valores que puede contener una variable. Sólo admite valores positivos. Si hacemos: unsigned char variable; Esta variable en vez de tener un rango de -128 a 128 pasa a tener un rango de 0 a 255. El tipo Float En este tipo de variable podemos almacenar números decimales, no sólo enteros como en los anteriores. El rango de posibles valores es del 3,4E-38 al 3,4E38. Declaración de una variable de tipo float: float numero; Para imprimir valores tipo float Usamos %f. float num=4060.80; printf( "El valor de num es : %f", num ); Resultado: El valor de num es: 4060.80 Si queremos escribirlo en notación exponencial usamos %e: float num = 4060.80; printf( "El valor de num es: %e", num ); Que da como resultado: El valor de num es: 4.06080e003 El tipo Double En las variables tipo double se almacenan números reales del 1,7E-307 al 1,7E308. Se declaran como double: double numero; Para imprimir se usan los mismos modificadores que en float. Cómo calcular el máximo valor que admite un tipo de datos Lo primero que tenemos que conocer es el tamaño en bytes de ese tipo de dato. Vamos a ver un ejemplo con el tipo INT. Hagamos el siguiente programa: #include <stdio.h> int main() { int num1; printf( "El tipo int ocupa %i bytes\n", sizeof(int) ); } En mi ordenador el resultado es: El tipo int ocupa 4 bytes. Como sabemos 1byte = 8bits. Por lo tanto el tipo int ocupa 4*8=32 bits. Ahora para calcular el máximo número debemos elevar 2 al número de bits obtenido. En nuestro ejemplo: 2^32=4.294.967.296. Es decir en un int se podría almacenar un número entre 0 y 4.294.967.296. Sin embargo esto sólo es cierto si usamos un tipo unsigned (sin signo, se hace añadiendo la palabra unsigned antes de int). Para los tipos normales tenemos que almacenar números positivos y negativos. Así que de los 4.294.967.296 posibles números la mitad serán positivos y la mitad negativos. Por lo tanto tenemos que dividir el número anterior entre 2 = 2.147.483.648. Como el 0 se considera positivo el rango de números posibles que se pueden almacenar en un int sería: -2.147.483.648 a 2.147.483.647. Resumen: 1. Obtenemos el número de bytes. 2. Multiplicamos por ocho (ya lo tenemos en bits). 3. Elevamos 2 al número de bits. 4. Dividimos entre 2. Overflow: Qué pasa cuando nos saltamos el rango El overflow es lo que se produce cuando intentamos almacenar en una variable un número mayor del máximo permitido. El comportamiento es distinto para variablesde números enteros y para variables de números en coma flotante. Con números enteros En mi ordenador y usando DJGPP bajo Dos el tamaño del tipo int es de 4bytes(4*8=32bits). El número máximo que se puede almacenar en una variable tipo int es por tanto 2.147.483.647 (ver apartado anterior). Si nos pasamos de este número el que se guardará será el siguiente pero empezando desde el otro extremo, es decir, el -2.147.483.648. El compilador seguramente nos dará un aviso (warning) de que nos hemos pasado. #include <stdio.h> int main() { int num1; num1 = 2147483648; printf( "El valor de num1 es: %i\n", num1 ); } El resultado que obtenemos es: El valor de num1 es: -2147483648 Comprueba si quieres que con el número anterior (2.147.483.647) no pasa nada. Con números en coma flotante El comportamiento con números en coma flotante es distinto. Dependiendo del ordenador si nos pasamos del rango al ejecutar un programa se puede producir un error y detenerse la ejecución. Con estos números también existe otro error que es el underflow. Este error se produce cuando almacenamos un número demasiado pequeño (3,4E-38 en float). Resumen de los tipos de datos en C Esto es algo orientativo, depende del sistema. Tipo Datos almacenados Nº de Bits Valores posibles (Rango) Rango usando unsigned char Caracteres 8 -128 a 128 0 a 255 int enteros 16 -32.767 a 32.767 0 a 65.535 long enteros largos 32 -2.147.483.647 a 2.147.483.647 0 a 4.294.967.295 float Nums. reales (coma flotante) 32 3,4E-38 a 3,4E38 double Nums. reales (coma flotante doble) 64 1,7E-307 a 1,7E308 Esto no siempre es cierto, depende del ordenador y del compilador. Para saber en nuestro caso qué tamaño tienen nuestros tipos de datos debemos hacer lo siguiente. Ejemplo para int: #include <stdio.h> int main() { printf( "Tamaño (en bits) de int = %i\n", sizeof( int )*8 ); return 0; } Ya veremos más tarde lo que significa sizeof. Por ahora basta con saber que nos dice cual es el tamaño de una variable o un tipo de dato. Ejercicios Ejercicio 1. Busque los errores: #include <stdio.h> int main() { int número; número = 2; return 0; } Solución: Los nombres de variables no pueden llevar acentos, luego al compilar número dará error. #include <stdio.h> int main() { int numero; numero = 2; printf( "El valor es %i" Numero ); return 0; } Solución: Falta la coma después de "El valor es %i". Además la segunda vez numero está escrito con mayúsculas. Constantes con nombre Las constantes son aquellos datos que no pueden cambiar a lo largo de la ejecución de un programa. #include <stdio.h> int main() { int radio, perimetro; radio = 20; perimetro = 2 * 3.1416 * radio; printf( "El perímetro es: %i", perimetro ); return 0; } radio y perimetro son variables, su valor puede cambiar a lo largo del programa. Sin embargo 20, 2 y 3.1416 son constantes, no hay manera de cambiarlas. El valor 3.1416 no cambia a lo largo del programa , ni entre ejecución y ejecución. Sólo cambiará cuando edites el programa y lo cambies tu mismo. Esto es obvio, y no tiene ningún misterio así que no le des vueltas. Sólo quería indicarlo porque en algunos libros le dan muchas vueltas. Supongamos que tenemos que hacer un programa en el que haya que escribir unas cuantas veces 3.1416 (como todos sabreis es PI). Es muy fácil que nos confundamos alguna vez al teclearlo y al compilar el programa no tendremos ningún error, sin embargo el programa no dará resultados correctos. Para evitar esto usamos las constantes con nombre. Al definir una constante con nombre estamos dando un nombre al valor, a 3.1416 le llamamos PI. Estas constantes se definen de la manera siguiente: #define nombre_de_la_constante valor_de_la_constante Ejemplo: #include <stdio.h> #define PI 3.1416 int main() { int radio, perimetro; radio = 20; perimetro = 2 * PI * radio; printf( "El perímetro es: %i", perimetro ); return 0; } De esta forma cada vez que el compilador encuentre el nombre PI lo sustituirá por 3.1416. A una constante no se le puede dar un valor mientras se ejecuta, no se puede hacer PI = 20;. Sólo se le puede dar un valor con #define, y sólo una vez. Tampoco podemos usar el scanf para dar valores a una constante: #define CONSTANTE 14 int main() { ... scanf( "%i", CONSTANTE ); ... } eso sería como hacer: scanf( "%i", 14 ); Esto es muy grave, estamos diciendo que el valor que escribamos en scanf se almacene en la posición 14 de la memoria, lo que puede bloquear el ordenador. Las constantes se suelen escribir en mayúsculas sólo se puede definir una constante por fila. No se pone ";" al final. Las constantes nos proporcionan una mejor comprensión del código fuente. Mira el siguiente programa: #include <stdio.h> int main() { int precio; precio = ( 4 * 25 * 100 ) * ( 1.16 ); printf( "El precio total es: %i", precio ); return 0; } ¿Quien entiende lo que quiere decir este programa? Es difícil si no imposible. Hagámoslo de otra forma. #include <stdio.h> #define CAJAS 4 #define UNIDADES_POR_CAJA 25 #define PRECIO_POR_UNIDAD 100 #define IMPUESTOS 1.16 int main() { int precio; precio = ( CAJAS * UNIDADES_POR_CAJA * PRECIO_POR_UNIDAD ) * ( IMPUESTOS ); printf( "El precio total es: %i", precio ); return 0; } ¿A que ahora se entiende mejor? Claro que sí. Los números no tienen mucho significado y si revisamos el programa un tiempo más tarde ya no nos acordaremos qué cosa era cada número. De la segunda forma nos enteraremos al momento. También podemos definir una constante usando el valor de otras. Por supuesto las otras tienen que estar definidas antes: #include <stdio.h> #define CAJAS 4 #define UNIDADES_POR_CAJA 25 #define PRECIO_POR_UNIDAD 100 #define PRECIO_POR_CAJA UNIDADES_POR_CAJA * PRECIO_POR_UNIDAD #define IMPUESTOS 1.16 int main() { int precio; precio = ( CAJAS * PRECIO_POR_CAJA ) * ( IMPUESTOS ); printf( "El precio total es: %i", precio ); return 0; } #define tiene más usos aparte de éste, ya los veremos en el capítulo de directivas. ¿Qué es un operador? Un operador sirve para manipular datos. Los hay de varios tipos: de asignación, de relación, lógicos, aritméticos y de manipulación de bits. En realidad los nombres tampoco importan mucho; aquí lo que queremos es aprender a programar, no aprender un montón de nombres. Operador de asignación Este es un operador que ya hemos visto en el capítulo de Tipos de Datos. Sirve para dar un valor a una variable. Este valor puede ser un número que tecleamos directamente u otra variable: a = 3; /* Metemos un valor directamente */ o a = b; /* Le damos el valor de una variable */ Podemos dar valores a varias variables a la vez: a = b = c = 10; /* Damos a las variables a,b,c el valor 10 */ También podemos asignar a varias variables el valor de otra de un sólo golpe: a = b = c = d; /* a,b,c toman el valor de d */ Operadores aritméticos Los operadores aritméticos son aquellos que sirven para realizar operaciones tales como suma, resta, división y multiplicación. Si quieres saber cómo usar funciones matemáticas más complejas (exponentes, raíces, trigonométricas) vete al capítulo correspondiente. Operador (+) : Suma Este operador permite sumar variables: #include <stdio.h> int main() { int a = 2; int b = 3; int c; c = a + b; printf ( "Resultado = %i\n", c ); } El resultado será 5 obviamente. Por supuesto se pueden sumar varias variables o variables más constantes: #include <stdio.h> int main() { int a = 2; int b = 3; int c = 1; int d; d = a + b + c + 4; printf ( "Resultado = %i\n", c ); } El resultado es 10. Podemos utilizar este operador para incrementar el valor de una variable: x = x + 5; Pero existe una forma abreviada: x += 5; Esto suma el valor 5 al valor que tenía la variable x. Veamos un ejemplo: #include <stdio.h> int main() { int x, y; x = 3; y = 5; x += 2; printf( "x = %i\n", x ); x += y; /* esto equivale a x = x + y */ printf( "x = %i\n", x ); } Resultado: x = 5 x = 10 Operador (++) : Incremento Este operador equivale a sumar uno a la variable: #include <stdio.h> int main() { int x = 5; printf ( "Valor de x = %i\n", x ); x++; printf ( "Valor de x = %i\n", x ); } Resultado: Valor de x = 5 Valor de x = 6 Se puede poner antes o después de la variable. Operador (-) : Resta/Negativo Este operador tiene dos usos, uno es la resta que funciona como el operador suma y el otro es cambiar de signo. Resta: x = x - 5; Para la operación resta se aplica todo lo dicho para la suma. Se puede usar también como: x -= 5;. Pero también tiene el uso de cambiar de signo. Poniendolo delante de una variable o constante equivale a multiplicarla por -1. #include <stdio.h> int main() { int a, b; a = 1; b = -a; printf( "a = %i, b = %i\n", a, b ); } Resultado: a = 1, b = -1. No tiene mucho misterio. Operador (--) : Decremento Es equivalente a ++ pero en vez de incrementar disminuye el valor de la variable. Equivale a restar uno a la variable. Operador (*) : Multiplicación y punteros Este operador sirve para multiplicar y funciona de manera parecida a los anteriores. También sirve para definir y utilizar punteros, pero eso lo veremos más tarde. Operador (/) : División Este funciona también como los anteriores pero hay que tener cuidado. Si dividimos dos número en coma flotante (tipo float) tenemos las división con sus correspondientes decimales. Pero si dividimos dos enteros obtenemos un número entero. Es decir que si dividimos 4/3 tenemos como resultado 1. El redondeo se hace por truncamiento, simplemente se eliminan los decimales y se deja el entero. Si dividimos dos enteros el resultado es un número entero, aunque luego lo saquemos por pantalla usando %f o %d no obtendremos la parte decimal. Cuando dividimos dos enteros, si queremos saber cual es el resto (o módulo) usamos el operador %, que vemos más abajo. Operador (%) : Resto Si con el anterior operador obteníamos el módulo o cociente de una división entera con éste podemos tener el resto. No funciona más que con enteros, no vale para números float o double. Cómo se usa: #include <stdio.h> int main() { int a, b; a = 18; b = 5; printf( "Resto de la división: %d \n", a % b ); } Operadores de comparación Los operadores de condición se utilizan para comprobar las condiciones de las sentencias de control de flujo (las estudiaremos en el capítulo sentencias). Cuando se evalúa una condición el resultado que se obtiene es 0 si no se cumple y un número distinto de 0 si se cumple. Normalmente cuando se cumplen devuelven un 1. Los operadores de comparación son: == igual que se cumple si son iguales != distinto que se cumple 1 si son diferentes > mayor que se cumple si el primero es mayor que el segundo < menor que se cumple si el primero es menor que el segundo >= mayor o igual que se cumple si el primero es mayor o igual que el segundo <= menor o igual que se cumple si el primero es menor o igual que el segundo Veremos la aplicación de estos operadores en el capítulo Sentencias. Pero ahora vamos a ver unos ejemplos: #include <stdio.h> int main() { printf( "10 > 5 da como resultado %i\n", 10>5 ); printf( "10 > 5 da como resultado %i\n", 10>5 ); printf( "5== 5 da como resultado %i\n", 5==5 ); printf( "10==5 da como resultado %i\n", 10==5 ); } No sólo se pueden comparar constantes, también se pueden comparar variables. Operadores lógicos Estos son los que nos permiten unir varias comparaciones: 10>5 y 6==6. Los operadores lógicos son: AND (&&, OR (||), NOT(!). Operador && (AND, en castellano Y): Devuelve un 1 si se cumplen dos condiciones. printf( "Resultado: %i", (10==10 && 5>2 ); Operador || (OR, en castellano O): Devuelve un 1 si se cumple una de las dos condiciones. Operador ! (NOT, negación): Si la condición se cumple NOT hace que no se cumpla y viceversa. Ver el capítulo Sentencias, sección Notas sobre las condiciones para más información. Introducción a los bits y bytes En esta sección voy a describir lo que son los bytes y los bits. No voy a descubrir nada nuevo, así que la mayoría se podrán saltar esta sección. Supongo que todo el mundo sabe lo que son los bytes y los bits, pero por si acaso allá va. Los bits son la unidad de información más pequeña, digamos que son la base para almacenar la información. Son como los átomos a las moléculas. Los valores que puede tomar un bit son 0 ó 1. Si juntamos ocho bits tenemos un byte. Un byte puede tomar 256 valores diferentes (de 0 a 255). ¿Cómo se consigue esto? Imaginemos nuestro flamante byte con sus ocho bits. Supongamos que los ocho bits valen cero. Ya tenemos el valor 0 en el byte. Ahora vamos a darle al último byte el valor 1. 00000001 -> 1 Este es el uno para el byte. Ahora vamos a por el dos y el tres: 00000010 -> 2 00000011 -> 3 y así hasta 255. Como vemos con ocho bits podemos tener 256 valores diferentes, que en byte corresponden a los valores entre 0 y 255. Operadores de bits Ya hemos visto que un byte son ocho bits. Pues bien, con los operadores de bits podemos manipular las variables por dentro. Los diferentes operadores de bits son: Operador Descripción | OR (O) & AND (Y) ^ XOR (O exclusivo) ~ Complemento a uno o negación >> Desplazamiento a la derecha << Desplazamiento a la izquierda Operador | (OR): Toma los valores y hace con ellos la operación OR. Vamos a ver un ejemplo: #include <stdio.h> int main() { printf( "El resultado de la operación 235 | 143 es: %i\n", 235 | 143 ); } Se obtiene: El resultado de la operación 235 | 143 es: 239 Veamos la operación a nivel de bits: 235 -> 11101011 143 -> 10001111 | 239 -> 11101111 La operación OR funciona de la siguiente manera: Tomamos los bits dos a dos y los comparamos si alguno de ellos es uno, se obtiene un uno. Si ambos son cero el resultado es cero. Primero se compara los dos primeros (el primero de cada uno de los números, 1 y 1 -> 1), luego la segunda pareja (1 y 0 -> 1) y así sucesivamente. Operador & (AND): Este operador compara los bits también dos a dos. Si ambos son 1 el resultado es 1. Si no, el resultado es cero. #include <stdio.h> int main() { printf( "El resultado de la operación 170 & 155 es: %i\n", 170 & 155 ); } Tenemos: El resultado de la operación 170 & 155 es: 138 A nivel de bits: 170 -> 10101010 155 -> 10011011 & 138 -> 10001010 Operador ^ (XOR): Compara los bits y los pone a unos si son distintos. 235 -> 11101011 143 -> 10001111 ^ 100 -> 01100100 Operador ~ (Complemento a uno): Este operador acepta un sólo dato (operando) y pone a 0 los 1 y a 1 los 0, es decir los invierte. Se pone delante del operando. #include <stdio.h> int main() { printf( "El resultado de la operación ~152 es: %i\n", ~152 ); } El resultado de la operación ~152 es: 103 152 -> 10011000 ~ 103 -> 01100111 Operador >> (Desplazamiento a la derecha): Este operador mueve cada bit a la derecha. El bit de la izquierda se pone a cero, el de la derecha se pierde. Si realizamos la operación inversa no recuperamos el número original. El formato es: variable o dato >> número de posiciones a desplazar El número de posiciones a desplazar indica cuantas veces hay que mover los bits hacia la derecha. Ejemplo: #include <stdio.h> int main() { printf( "El resultado de la operación 150 >> 2 es: %i\n", ~152 ); } El resultado de la operación 150 >> 2 es: 37 Veamos la operación paso a paso. Esta operación equivale a hacer dos desplazamientos a la derecha: 150 -> 10010110 Número original 75 -> 01001011 Primer desplazamiento. Entra un cero por la izquierda, el cero de la derecha se pierde y los demás se mueven a la derecha. 37 -> 00100101 Segundo desplazamiento. NOTA: Un desplazamiento a la izquierda equivale a dividir por dos. Esto es muy interesante porque el desplazamiento es más rápido que la división. Si queremos optimizar un programa esta es una buena idea. Sólo sirve para dividir entre dos. Si hacemos dos desplazamientos sería dividir por dos dos veces, no por tres. Operador << (Desplazamiento a la izquierda): Funciona igual que la anterior pero los bits se desplazan a la izquierda. Esta operación equivale a multiplicar por 2. Operador Sizeof Este es un operador muy útil. Nos permite conocer el tamaño en bytes de una variable. De esta manera no tenemos que preocuparnos en recordar o calcular cuanto ocupa. Además el tamaño de una variable cambia de un compilador a otro, es la mejor forma de asegurarse. Se usa poniendo el nombre de la variable después de sizeof y separado de un espacio: #include <stdio.h> int main() { int variable; printf( "Tamaño de la variable: %i\n", sizeof variable ); } Tambíen se puede usar con los especificadores de tipos de datos (char, int, float, double...). Pero en éstos se usa de manera diferente, hay que poner el especificador entre paréntesis: #include <stdio.h> int main() { printf( "Las variables tipo int ocupan: %i\n", sizeof(int) ); } Otros operadores Existen además de los que hemos visto otros operadores. Sin embargo ya veremos en sucesivos capítulos lo que significa cada uno. Orden de evaluación de Operadores Debemos tener cuidado al usar operadores pues a veces podemos tener resultados no esperados si no tenemos en cuenta su orden de evaluación. Vamos a ver la lista de precedencias, cuanto más arriba se evalúa antes: Precedencia () [] -> . ! ~ ++ -- (molde) * & sizeof (El * es el de puntero) * / % (El * de aquí es el de multiplicación) + - << >> < <= > >= == != & ^ | && || ?: = += -= *= /= , Por ejemplo imaginemos que tenemos la siguiente operación: 10 * 2 + 5 Si vamos a la tabla de precedencias vemos que el * tiene un orden superior al +, por lo tanto primero se hace el producto 10*2=20 y luego la suma 20+5=25. Veamos otra: 10 * ( 2 + 5 ) Ahora con el paréntesis cambia el orden de evaluación. El que tiene mayor precedencia ahora es el paréntesis, se ejecuta primero. Como dentro del paréntesis sólo hay una suma se evalúa sin más, 2+5=7. Ya solo queda la multiplicación 10*7=70. Otro caso: 10 * ( 5 * 2 +3 ) Como antes, el que mayor precedencia tiene es el paréntesis, se evalúa primero. Dentro del paréntesis tenemos producto y suma. Como sabemos ya se evalúa primero el producto, 5*2=10. Seguimos en el paréntesis, nos queda la suma 10+3=13. Hemos acabado con el paréntesis, ahora al resto de la expresión. Cogemos la multiplicación que queda: 10*13=130. Otro detalle que debemos cuidar son los operadores ++ y --. Estos tienen mayor precedencia que las demás operaciones aritméticas (+, -, *, /, %). Por ejemplo: 10 * 5 ++ Puede parecer que primero se ejecutará la multiplicación y luego el ++. Pero si vamos a la tabla de precedencias vemos que el ++ está por encima de * (de multiplicación), por lo tanto se evaluará primero 5++=6. 10*6=60. Es mejor no usar los operadores ++ y -- mezclados con otros, pues a veces obtenemos resultados inesperados. Por ejemplo: #include <stdio.h> int main() { int a, b; a = 5; b = a++; printf( "a = %i, b = %i\n", a, b ); } Este ejemplo en unos compiladores dará a = 6, b = 5 y en otros a = 6 y b = 6. Por favor si podeis, escribidme diciendo qué valores os salen a vosotros y qué compilador usais. Para asegurarse lo mejor sería separar la línea donde se usa el ++ y el =: #include <stdio.h> int main() { int a, b; a = 5; a++; b = a; printf( "a = %i, b = %i\n", a, b ); } Ejercicios Ejercicio 1: En este programa hay un fallo muy gordo y muy habitual en programación. A ver si lo encuentras: #include <stdio.h> int main() { int a, c; a = 5; c += a +5; } Solución: Cuando calculamos el valor de 'c' sumamos a+5 ( =10 ) al valor de 'c'. Pero resulta que 'c' no tenía ningún valor indicado por nosotros. Estamos usando la variable 'c' sin haberle dado valor. En algunos compiladores el resultado será inesperado. Este es un fallo bastante habitual, usar variables a las que no hemos dado ningún valor. Ejercicio 2: ¿Cual será el resultado del siguiente programa? #include <conio.h> #include <stdio.h> int main() { int a, b, c; a = 5; b = ++a; c = ( a + 5 * 2 ) * ( b + 6 / 2 ) + ( a * 2 ); printf( "%i, %i, %i", a, b, c ); } Solución: El resultado es 156. En la primera a vale 5. Pero en la segunda se ejecuta b = ++a = ++5 = 6. Tenemos a = b = 6. Ejercicio 3: Escribir un programa que compruebe si un número es par o impar. Solución: #include <stdio.h> int main() { char palabra[100]; int a; a = 124; if ( a % 2 == 0 ) printf( "%d es par\n", a ); else printf( "%d es impar\n", a ); printf( "\n" ); system( "pause" ); return 0; } Fichero: cap5_ejercicio3.c Para comprobar si un número es par o impar podemos usar el operador '%'. Si al calcular el resto de dividir un número por 2 el resultado es cero eso indica que el número es par. Si el resto es distinto de cero el número es impar. Este es un operador que ya hemos visto en el capítulo de Tipos de Datos. Sirve para dar un valor a una variable. Este valor puede ser un número que tecleamos directamente u otra variable: a = 3; /* Metemos un valor directamente */ o a = b; /* Le damos el valor de una variable */ Podemos dar valores a varias variables a la vez: a = b = c = 10; /* Damos a las variables a,b,c el valor 10 */ También podemos asignar a varias variables el valor de otra de un sólo golpe: a = b = c = d; /* a,b,c toman el valor de d */ Operadores aritméticos Los operadores aritméticos son aquellos que sirven para realizar operaciones tales como suma, resta, división y multiplicación. Si quieres saber cómo usar funciones matemáticas más complejas (exponentes, raíces, trigonométricas) vete al capítulo correspondiente. Operador (+) : Suma Este operador permite sumar variables: #include <stdio.h> int main() { int a = 2; int b = 3; int c; c = a + b; printf ( "Resultado = %i\n", c ); } El resultado será 5 obviamente. Por supuesto se pueden sumar varias variables o variables más constantes: #include <stdio.h> int main() { int a = 2; int b = 3; int c = 1; int d; d = a + b + c + 4; printf ( "Resultado = %i\n", c ); } El resultado es 10. Podemos utilizar este operador para incrementar el valor de una variable: x = x + 5; Pero existe una forma abreviada: x += 5; Esto suma el valor 5 al valor que tenía la variable x. Veamos un ejemplo: #include <stdio.h> int main() { int x, y; x = 3; y = 5; x += 2; printf( "x = %i\n", x ); x += y; /* esto equivale a x = x + y */ printf( "x = %i\n", x ); } Resultado: x = 5 x = 10 Operador (++) : Incremento Este operador equivale a sumar uno a la variable: #include <stdio.h> int main() { int x = 5; printf ( "Valor de x = %i\n", x ); x++; printf ( "Valor de x = %i\n", x ); } Resultado: Valor de x = 5 Valor de x = 6 Se puede poner antes o después de la variable. Operador (-) : Resta/Negativo Este operador tiene dos usos, uno es la resta que funciona como el operador suma y el otro es cambiar de signo. Resta: x = x - 5; Para la operación resta se aplica todo lo dicho para la suma. Se puede usar también como: x -= 5;. Pero también tiene el uso de cambiar de signo. Poniendolo delante de una variable o constante equivale a multiplicarla por -1. #include <stdio.h> int main() { int a, b; a = 1; b = -a; printf( "a = %i, b = %i\n", a, b ); } Resultado: a = 1, b = -1. No tiene mucho misterio. Operador (--) : Decremento Es equivalente a ++ pero en vez de incrementar disminuye el valor de la variable. Equivale a restar uno a la variable. Operador (*) : Multiplicación y punteros Este operador sirve para multiplicar y funciona de manera parecida a los anteriores. También sirve para definir y utilizar punteros, pero eso lo veremos más tarde. Operador (/) : División Este funciona también como los anteriores pero hay que tener cuidado. Si dividimos dos número en coma flotante (tipo float) tenemos las división con sus correspondientes decimales. Pero si dividimos dos enteros obtenemos un número entero. Es decir que si dividimos 4/3 tenemos como resultado 1. El redondeo se hace por truncamiento, simplemente se eliminan los decimales y se deja el entero. Si dividimos dos enteros el resultado es un número entero, aunque luego lo saquemos por pantalla usando %f o %d no obtendremos la parte decimal. Cuando dividimos dos enteros, si queremos saber cual es el resto (o módulo) usamos el operador %, que vemos más abajo. Operador (%) : Resto Si con el anterior operador obteníamos el módulo o cociente de una división entera con éste podemos tener el resto. No funciona más que con enteros, no vale para números float o double. Cómo se usa: #include <stdio.h> int main() { int a, b; a = 18; b = 5; printf( "Resto de la división: %d \n", a % b ); } Operadores de comparación Los operadores de condición se utilizan para comprobar las condiciones de las sentencias de control de flujo (las estudiaremos en el capítulo sentencias). Cuando se evalúa una condición el resultado que se obtiene es 0 si no se cumple y un número distinto de 0 si se cumple. Normalmente cuando se cumplen devuelven un 1. Los operadores de comparación son: == igual que se cumple si son iguales != distinto que se cumple 1 si son diferentes > mayor que se cumple si el primero es mayor que el segundo < menor que se cumple si el primero es menor que el segundo >= mayor o igual que se cumple si el primero es mayor o igual que el segundo <= menor o igual que se cumple si el primero es menor o igual que el segundo Veremos la aplicación de estos operadores en el capítulo Sentencias. Pero ahora vamos a ver unos ejemplos: #include <stdio.h> int main() { printf( "10 > 5 da como resultado %i\n", 10>5 ); printf( "10 > 5 da como resultado %i\n", 10>5 ); printf( "5== 5 da como resultado %i\n", 5==5 ); printf( "10==5 da como resultado %i\n", 10==5 ); } No sólo se pueden comparar constantes, también se pueden comparar variables. Operadores lógicos Estos son los que nos permiten unir varias comparaciones: 10>5 y 6==6. Los operadores lógicos son: AND (&&, OR (||), NOT(!). Operador && (AND, en castellano Y): Devuelve un 1 si se cumplen dos condiciones. printf( "Resultado: %i", (10==10 && 5>2 ); Operador || (OR, en castellano O): Devuelve un 1 si se cumple una de las dos condiciones. Operador ! (NOT, negación): Si la condición se cumple NOT hace que no se cumpla y viceversa. Ver el capítulo Sentencias, sección Notas sobre las condiciones para más información. Introducción a los bits y bytes En esta sección voy a describir lo que son los bytes y los bits. No voy a descubrir nada nuevo, así que la mayoría se podrán saltar esta sección. Supongo que todo el mundo sabe lo que son los bytes y los bits, pero por si acaso allá va. Los bits son la unidad de información más pequeña, digamos que son la base para almacenar la información. Son como los átomos a las moléculas. Los valores que puede tomar un bit son 0 ó 1. Si juntamos ocho bits tenemos un byte. Un byte puede tomar 256 valores diferentes (de 0 a 255). ¿Cómo se consigue esto? Imaginemos nuestro flamante byte con sus ocho bits. Supongamos que los ocho bits valen cero. Ya tenemos el valor 0 en el byte. Ahora vamos a darle al último byte el valor 1. 00000001 -> 1 Este es el uno para el byte. Ahora vamos a por el dos y el tres: 00000010 -> 2 00000011 -> 3 y así hasta 255. Como vemos con ocho bits podemos tener 256 valores diferentes, que en byte corresponden a los valores entre 0 y 255. Operadores de bits Ya hemos visto que un byte son ocho bits. Pues bien, con los operadores de bits podemos manipular las variables por dentro. Los diferentes operadores de bits son: Operador Descripción | OR (O) & AND (Y) ^ XOR (O exclusivo) ~ Complemento a uno o negación >> Desplazamiento a la derecha << Desplazamiento a la izquierda Operador | (OR): Toma los valores y hace con ellos la operación OR. Vamos a ver un ejemplo: #include <stdio.h> int main() { printf( "El resultado de la operación 235 | 143 es: %i\n", 235 | 143 ); } Se obtiene: El resultado de la operación 235 | 143 es: 239 Veamos la operación a nivel de bits: 235 -> 11101011 143 -> 10001111 | 239 -> 11101111 La operación OR funciona de la siguiente manera: Tomamos los bits dos a dos y los comparamos si alguno de ellos es uno, se obtiene un uno. Si ambos son cero el resultado es cero. Primero se compara los dos primeros (el primero de cada uno de los números, 1 y 1 -> 1), luego la segunda pareja (1 y 0 -> 1) y así sucesivamente. Operador & (AND): Este operador compara los bits también dos a dos. Si ambos son 1 el resultado es 1. Si no, el resultado es cero. #include <stdio.h> int main() { printf( "El resultado de la operación 170 & 155 es: %i\n", 170 & 155 ); } Tenemos: El resultado de la operación 170 & 155 es: 138 A nivel de bits: 170 -> 10101010 155 -> 10011011 & 138 -> 10001010 Operador ^ (XOR): Compara los bits y los pone a unos si son distintos. 235 -> 11101011 143 -> 10001111 ^ 100 -> 01100100 Operador ~ (Complemento a uno): Este operador acepta un sólo dato (operando) y pone a 0 los 1 y a 1 los 0, es decir los invierte. Se pone delante del operando. #include <stdio.h> int main() { printf( "El resultado de la operación ~152 es: %i\n", ~152 ); } El resultado de la operación ~152 es: 103 152 -> 10011000 ~ 103 -> 01100111 Operador >> (Desplazamiento a la derecha): Este operador mueve cada bit a la derecha. El bit de la izquierda se pone a cero, el de la derecha se pierde. Si realizamos la operación inversa no recuperamos el número original. El formato es: variable o dato >> número de posiciones a desplazar El número de posiciones a desplazar indica cuantas veces hay que mover los bits hacia la derecha. Ejemplo: #include <stdio.h> int main() { printf( "El resultado de la operación 150 >> 2 es: %i\n", ~152 ); } El resultado de la operación 150 >> 2 es: 37 Veamos la operación paso a paso. Esta operación equivale a hacer dos desplazamientos a la derecha: 150 -> 10010110 Número original 75 -> 01001011 Primer desplazamiento. Entra un cero por la izquierda, el cero de la derecha se pierde y los demás se mueven a la derecha. 37 -> 00100101 Segundo desplazamiento. NOTA: Un desplazamiento a la izquierda equivale a dividir por dos. Esto es muy interesante porque el desplazamiento es más rápido que la división. Si queremos optimizar un programa esta es una buena idea. Sólo sirve para dividir entre dos. Si hacemos dos desplazamientos sería dividir por dos dos veces, no por tres. Operador << (Desplazamiento a la izquierda): Funciona igual que la anterior pero los bits se desplazan a la izquierda. Esta operación equivale a multiplicar por 2. Operador Sizeof Este es un operador muy útil. Nos permite conocer el tamaño en bytes de una variable. De esta manera no tenemos que preocuparnos en recordar o calcular cuanto ocupa. Además el tamaño de una variable cambia de un compilador a otro, es la mejor forma de asegurarse. Se usa poniendo el nombre de la variable después de sizeof y separado de un espacio: #include <stdio.h> int main() { int variable; printf( "Tamaño de la variable: %i\n", sizeof variable ); } Tambíen se puede usar con los especificadores de tipos de datos (char, int, float, double...). Pero en éstos se usa de manera diferente, hay que poner el especificador entre paréntesis: #include <stdio.h> int main() { printf( "Las variables tipo int ocupan: %i\n", sizeof(int) ); } Otros operadores Existen además de los que hemos visto otros operadores. Sin embargo ya veremos en sucesivos capítulos lo que significa cada uno. Orden de evaluación de Operadores Debemos tener cuidado al usar operadores pues a veces podemos tener resultados no esperados si no tenemos en cuenta su orden de evaluación. Vamos a ver la lista de precedencias, cuanto más arriba se evalúa antes: Precedencia () [] -> . ! ~ ++ -- (molde) * & sizeof (El * es el de puntero) * / % (El * de aquí es el de multiplicación) + - << >> < <= > >= == != & ^ | && || ?: = += -= *= /= , Por ejemplo imaginemos que tenemos la siguiente operación: 10 * 2 + 5 Si vamos a la tabla de precedencias vemos que el * tiene un orden superior al +, por lo tanto primero se hace el producto 10*2=20 y luego la suma 20+5=25. Veamos otra: 10 * ( 2 + 5 ) Ahora con el paréntesis cambia el orden de evaluación. El que tiene mayor precedencia ahora es el paréntesis, se ejecuta primero. Como dentro del paréntesis sólo hay una suma se evalúa sin más, 2+5=7. Ya solo queda la multiplicación 10*7=70. Otro caso: 10 * ( 5 * 2 +3 ) Como antes, el que mayor precedencia tiene es el paréntesis, se evalúa primero. Dentro del paréntesis tenemos producto y suma. Como sabemos ya se evalúa primero el producto, 5*2=10. Seguimos en el paréntesis, nos queda la suma 10+3=13. Hemos acabado con el paréntesis, ahora al resto de la expresión. Cogemos la multiplicación que queda: 10*13=130. Otro detalle que debemos cuidar son los operadores ++ y --. Estos tienen mayor precedencia que las demás operaciones aritméticas (+, -, *, /, %). Por ejemplo: 10 * 5 ++ Puede parecer que primero se ejecutará la multiplicación y luego el ++. Pero si vamos a la tabla de precedencias vemos que el ++ está por encima de * (de multiplicación), por lo tanto se evaluará primero 5++=6. 10*6=60. Es mejor no usar los operadores ++ y -- mezclados con otros, pues a veces obtenemos resultados inesperados. Por ejemplo: #include <stdio.h> int main() { int a, b; a = 5; b = a++; printf( "a = %i, b = %i\n", a, b ); } Este ejemplo en unos compiladores dará a = 6, b = 5 y en otros a = 6 y b = 6. Por favor si podeis, escribidme diciendo qué valores os salen a vosotros y qué compilador usais. Para asegurarse lo mejor sería separar la línea donde se usa el ++ y el =: #include <stdio.h> int main() { int a, b; a = 5; a++; b = a; printf( "a = %i, b = %i\n", a, b ); } Ejercicios Ejercicio 1: En este programa hay un fallo muy gordo y muy habitual en programación. A ver si lo encuentras: #include <stdio.h> int main() { int a, c; a = 5; c += a +5; } Solución: Cuando calculamos el valor de 'c' sumamos a+5 ( =10 ) al valor de 'c'. Pero resulta que 'c' no tenía ningún valor indicado por nosotros. Estamos usando la variable 'c' sin haberle dado valor. En algunos compiladores el resultado será inesperado. Este es un fallo bastante habitual, usar variables a las que no hemos dado ningún valor. Ejercicio 2: ¿Cual será el resultado del siguiente programa? #include <conio.h> #include <stdio.h> int main() { int a, b, c; a = 5; b = ++a; c = ( a + 5 * 2 ) * ( b + 6 / 2 ) + ( a * 2 ); printf( "%i, %i, %i", a, b, c ); } Solución: El resultado es 156. En la primera a vale 5. Pero en la segunda se ejecuta b = ++a = ++5 = 6. Tenemos a = b = 6. Ejercicio 3: Escribir un programa que compruebe si un número es par o impar. Solución: #include <stdio.h> int main() { char palabra[100]; int a;

Un diodo orgánico de emisión de luz, también conocido como OLED (acrónimo del inglés: Organic Light-Emitting Diode), es un diodo que se basa en una capa electroluminiscente formada por una película de componentes orgánicos que reaccionan, a una determinada estimulación eléctrica, generando y emitiendo luz por sí mismos. Existen muchas tecnologías OLED diferentes, tantas como la gran diversidad de estructuras (y materiales) que se han podido idear (e implementar) para contener y mantener la capa electroluminiscente, así como según el tipo de componentes orgánicos utilizados. Las principales ventajas las pantallas OLEDs son: más delgados y flexibles, más contrastes y brillos, mayor ángulo de visión, menor consumo y, en algunas tecnologías, flexibilidad. Pero la degradación de los materiales OLED han limitado su uso por el momento. Actualmente se está investigando para dar solución a los problemas derivados de esta degradación, hecho que hará de los OLEDs una tecnología que puede reemplazar la actual hegemonía de las pantallas LCD (TFT) y de la pantalla de plasma. Por todo ello, OLED puede y podrá ser usado en todo tipo de aplicaciones: pantallas de televisión, pantalla de ordenador, pantallas de dispositivos portátiles (teléfonos móviles, PDAs, reproductores MP3...), indicadores de información o de aviso, etc. con formatos que bajo cualquier diseño irán desde unas dimensiones pequeñas (2" hasta enormes tamaños (equivalentes a los que se están consiguiendo con LCD). Mediante los OLEDs también se pueden crear grandes o pequeños carteles de publicidad, así como fuentes de luz para iluminar espacios generales. Además, algunas tecnologías OLED tienen la capacidad de tener una estructura flexible, lo que ya ha dado lugar a desarrollar pantallas plegables o enrollables, y en el futuro quizá pantallas sobre ropa y tejidos, etc. --------------------------------------------------------------------------------------- Una de las cosas mas asombrosas es que estas pantallas no superan los 2 mm de espesor no es broma --------------------------------------------------------------------------------------- otra de sus supercaracteristicas es que es COMPLETAMENTE flexible ---------------------------------------------------------------------------------------- es capas de soportar golpes a diferencia de las pantallas tft y lsd aca un video que lo prueva link: http://www.videos-star.com/watch.php?video=f8S8tbQMp2k link: http://www.videos-star.com/watch.php?video=TDuP8PtDJbE ---------------------------------------------------------------------------------------- imaginen verse un boca-river en el reloj