Embed Size (px)
Citation preview
Instituto Politécnico Nacional
14
Programación de bajo,
medio y alto nivel con
abstracción el Linux.
Seminario de titulación.
Javier Olvera Pérez
Contenido
Introducción ........................................................................................................................................... 2
CAPITULO 1: Requerimientos de los leguajes de programación. .................................................................... 4
Abstracción. ....................................................................................................................................... 4
Uso ................................................................................................................................................... 5
Ejemplo ............................................................................................................................................. 5
John Von Neumann (1903 – 1957) ........................................................................................................ 6
Linux: ............................................................................................................................................... 7
Hardware soportado ............................................................................................................................ 8
Capacidad de Conectividad y Convivencia ............................................................................................ 10
Sistema operativo Slax ....................................................................................................................... 12
Lenguaje de bajo medio y alto nivel. ..................................................................................................... 13
Lenguaje de bajo nivel ................................................................................................................... 14
Lenguaje de medio nivel ................................................................................................................. 14
Lenguaje de alto nivel .................................................................................................................... 15
CAPITULO 2: Lenguaje ensamblador. .................................................................................................... 16
Herramientas dentro de Slax para programación. ................................................................................... 16
Ensamblador. ................................................................................................................................... 19
Programas realizados. ........................................................................................................................ 21
CAPITULO 3: Lenguaje C. .................................................................................................................... 36
Lenguaje “C” .................................................................................................................................... 36
Programas realizados ......................................................................................................................... 65
CAPITULO 4 HTML ........................................................................................................................... 94
Cambio a HTML5 ............................................................................................................................. 94
Programas realizados ......................................................................................................................... 97
CAPITULO 5 JAVASCRIP ................................................................................................................ 113
Lenguaje JAVASCRIP .................................................................................................................... 113
Programas realizados ....................................................................................................................... 114
CAPITULO 6 PHP ............................................................................................................................ 137
Lenguaje PHP ................................................................................................................................ 137
Bibliografía ........................................................................................................................................ 142
INTRODUCCIÓN
Para poder adentrarnos a este tema iniciaremos con la siguiente pregunta, ¿Lenguajes de programación en Linux?, si bien GNU/LINUX Su desarrollo es uno de los ejemplos más prominentes de software libre; todo su código fuente puede ser utilizado, modificado y redistribuido libremente por cualquiera bajo los términos de la GPL (Licencia Pública General de GNU, en inglés: General Public License) y otra serie de licencias libres.1
A pesar de que Linux es, en sentido estricto, el núcleo del sistema operativo,2 parte fundamental de la interacción entre el hardware y el usuario (o los programas de aplicación) se maneja usualmente con las herramientas del proyecto GNU y con entornos de escritorio basados en GNOME, que también forma parte del proyecto GNU aunque tuvo un origen independiente. Sin embargo, una parte significativa de la comunidad, así como muchos medios generales y especializados, prefieren utilizar el término Linux para referirse a la unión de ambos proyectos. Para más información consulte la sección "Denominación GNU/Linux" o el artículo "Controversia por la denominación GNU/Linux".
Pero para muchos que apenas comienzan a adentrarse a la rama de informática suelen pensar que el mejor S.O. para realizar tal tipo de acciones seria Windows o su defecto Mac OS, debido a diferentes creencias las principales:
o Son las más populares. o El usuario está más asociado a estos dos S.O. o Se tiene mayor compatibilidad con softwares para creación de códigos. o Etc.
Pero en realidad GNU/LINUX dentro de la programación es mejor su constitución está realizada mediante los siguientes:
Linux está mayoritariamente programado en lenguaje C (definitivamente no en C++, que es un lenguaje un algo distinto). Las líneas de código fuente de Linux están así: • 71% de sus líneas de código están en lenguaje C • 15% de sus líneas de código están en lenguaje C++ El 14% de sus líneas de código restantes están en varios otros lenguajes (por orden de mayor número de líneas): • Shell (incluyendo ksh), • Lisp • ensamblador
• Perl • Fortran • Python • tcl • Java • yacc/bison • expect • lex/flex • awk • Objective-C • Ada • C shell • Pascal • sed. Como podrás darte cuenta, se necesitan muchos lenguajes de programación para programar un sólo sistema operativo. Igualmente Microsoft Windows está programado en C, C++, Ensamblador, y más recientemente .NET
Ahora bien, esto en si no es lo que nos permite del todo realizar una programación más práctica,
si no que mediante los móduloshabitualmente conocidos como programas es que hay una mayor
posibilidad de trabajar casi cualquier tipo de programación excepcionando ensamblador ya que
este es completamente diferente según el S.O.
Uno de los software dentro de Linux que es el más práctico para poder llevar a cabo una
programación sin importar el tipo de lenguaje que sea es GEANY.
GEANY siendo un editor de texto pequeño y ligero basado en Scintilla con características básicas de entorno de desarrollo integrado (IDE). Utiliza libreríasGTK para su funcionamiento. Está disponible para distintos sistemas operativos, como GNU/Linux, Mac OS X, BSD, Solaris y Microsoft Windows. Es distribuido como software libre bajo la Licencia Pública General de GNU.
Algunas de las ventajas que nos proporciona al momento de programar son:
Resaltado de sintaxis. Plegado de código. Autocompletado. Cierre automático de etiquetas XML y HTML. Muestra de consejos. Muchos tipos de archivos soportados tales como C, Java, PHP, Python, Perl, Pascal y
más.
Listas de símbolos. Código de navegación. Construir un sistema (conjunto de ejecuciones) para compilar y ejecutar el código Fácil gestión de proyectos. Soporte para plugins.
Otra herramienta con la que contamos es con NANO es el un sencillo editor de textos para el
terminal que viene instalado por defecto en Linux. No es tan potente como otros pero es mucho
más fácil de manejar. Así cualquier usuario por poco experimentado que sea es capaz de empezar
a usar Nano desde el primer momento gracias a las dos líneas de ayuda que mantiene en su parte
inferior.
Al ser un editor en modo texto, se suele usar sobretodo en entornos sin interfaz gráfica como Ubuntu Server, pero eso no impide que lo utilicemos en Ubuntu Desktop
CAPITULO 1: REQUERIMIENTOS DE LOS LEGUAJES DE
PROGRAMACIÓN.
ABSTRACCIÓN.
La abstracción consiste en aislar un elemento de su contexto o del resto de los elementos que lo
acompañan. En programación, el término se refiere al énfasis en el "¿qué hace?" más que en el
"¿cómo lo hace?" (Característica de caja negra). El común denominador en la evolución de
los lenguajes de programación, desde los clásicos o imperativos hasta los orientados a objetos, ha
sido el nivel de abstracción del que cada uno de ellos hace uso.
Los lenguajes de programación son las herramientas mediante las cuales los diseñadores de
lenguajes pueden implementar los modelos abstractos. La abstracción ofrecida por los lenguajes
de programación se puede dividir en dos categorías: abstracción de datos (pertenecientes a los
datos) y abstracción de control (perteneciente a las estructuras de control).
Los diferentes paradigmas de programación han aumentado su nivel de abstracción, comenzando
desde los lenguajes de máquina, lo más próximo al ordenador y más lejano a la comprensión
humana; pasando por los lenguajes de comandos, los imperativos, la orientación a objetos (POO),
la Programación Orientada a Aspectos (POA); u otros paradigmas como la programación
declarativa, etc.
La abstracción encarada desde el punto de vista de la programación orientada a objetos expresa
las características esenciales de un objeto, las cuales distinguen al objeto de los demás. Además de
distinguir entre los objetos provee límites conceptuales. Entonces se puede decir que
la encapsulación separa las características esenciales de las no esenciales, dentro de un objeto. Si
un objeto tiene más características de las necesarias estos resultarán difíciles de usar, modificar,
construir y comprender.
La misma genera una ilusión de simplicidad debido a que minimiza la cantidad de características
que definen a un objeto.
Durante años, los programadores se han dedicado a construir aplicaciones muy parecidas que
resolvían una y otra vez los mismos problemas. Para conseguir que sus esfuerzos pudiesen ser
utilizados por otras personas se creó la POO que consiste en una serie de normas para garantizar
la interoperabilidad entre usuarios de manera que el código se pueda reutilizar.
USO
A grandes rasgos, la abstracción, permite que dispongamos de las características de un objeto que
necesitemos. Si necesitamos el objeto Persona, podríamos poner nombre, edad, dirección, estado
civil, etc. Si lo necesitamos en un sistema administrativo, pero, si lo requerimos para el área
de biología, dentro de sus atributos quizá tengamos, ADN, RND, Gen x1, Gen x2, etc., y los
atributos antes mencionados no sean requeridos. En general, podemos decir que Persona cuenta
con todos los atributos mencionados aquí, pero por el proceso de abstracción excluimos todos
aquellos que no tienen cabida en nuestro sistema. Se define como un método por el cual se
rescatan los datos relevantes y se ignoran los irrelevantes.
EJEMPLO
Pensar en términos de objetos es muy parecido a cómo lo haríamos en la vida real. Una analogía
sería modelizar un coche en un esquema de POO. Diríamos que el coche es el elemento principal
que tiene una serie de características, como podrían ser el color, el modelo o la marca. Además
tiene una serie de funcionalidades asociadas, como pueden ser ponerse en marcha, parar o
aparcar.
Por poner otro ejemplo vamos a ver cómo modelizaríamos en un esquema POO una fracción, es
decir, esa estructura matemática que tiene un numerador y un denominador que divide al
numerador, por ejemplo 3/2. La fracción será el objeto y tendrá dos propiedades, el numerador y
el denominador. Luego podría tener varios métodos como simplificarse, sumarse con otra fracción
o número, restarse con otra fracción, etc.
Estos objetos son utilizables en los programas, por ejemplo en un programa de matemáticas se
puede hacer uso de objetos fracción y en un programa que gestione un taller de coches, objetos
coche. Los programas orientados a objetos utilizan muchos objetos para realizar las acciones que
se desean realizar y ellos mismos también son objetos. Es decir, el taller de coches será un objeto
que utilizará objetos coche, herramienta, mecánico, recambios, etc.
JOHN VON NEUMANN (1903 – 1957)
Nació en Budapest (Hungría), su nombre verdadero es Margittai Neumann János (los húngaros
colocan sus apellidos antes que el nombre) que se puede traducir como János Neumann de
Margitta, que se transformó en Jhohann Neumann von Margitta cuando se trasladó a Alemania
y que luego se lo recortaron quedándose en Johann von Neumann, para finalmente conocérsele
mundialmente como John von Neumann, al llegar a EE.UU.
Al comenzar la Segunda Guerra Mundial comenzó a trabajar para el Gobierno de los EE.UU,
hacia 1943 von Neumann empezó a interesarse por la computación para ayudarse en su trabajo,
en aquellos años había numerosas computadoras en construcción, como por ejemplo la Mark I
(Howard Aiken) o Complex Computer (George Stibiz), pero con la que von Neumann se involucró
fue el ENIAC (junto con John Presper Eckert y John W. Mauchly). Una vez finalizada la
construcción del ENIAC y viendo sus limitaciones, decidieron definir todo un nuevo sistema
lógico de computación basado en las ideas de Turing y se enfrascaron en el diseño y la
construcción de una computadora más poderosa el EDVAC (Electronic Discrete Variable
Arithmetic Computer). Pero hubo problemas legales con la titularidad de lo que hoy conocemos
como Arquitectura de von Neumann. Esto produjo que el diseño se hiciera público, al final
Eckert y Mauchly siguieron su camino y von Neumann regresó a Princeton con la idea de
construir su propia computadora.
En los años 50 construyó la computadora IAS, cuyo diseño ha sido una de las bases de la
computadora actual, conociéndose como "arquitectura de von Neumann". Otras de sus
contribuciones en computación fueron por ejemplo el uso de monitores para visualizar los datos y
el diagrama de flujo. También colaboró en el libro "Cibernética: control y comunicación en el
animal y en la máquina" escrito junto con Norbert Wiener, en donde se explica la teoría de la
cibernética.
LINUX:
Es uno de los tantos flavors de Unix. Se trata de un sistema operativo de 32 bits de libre distribución, desarrollado originalmente por Linus Torvalds, un estudiante de la universidad finlandesa de Helsinki, quien, en 1991, se abocó a la tarea de reemplazar a Minix, un clon de Unix de pequeñas proporciones y finalidad académica desarrollado años antes por Andrew Tannenbaun.
A medida que avanzaba en su desarrollo, Linus fue dejando el código fuente de las sucesivas versiones del kernel y utilidades de Linux a disponibilidad de los usuarios de Internet. Este fue sin duda un gran acierto, ya que hizo posible que una multitud de desarrolladores de todo el mundo se familiarizaran con el código, lo cual en primera instancia significó un gran aporte de sugerencias, evolucionado luego hacia un espectacular ejemplo de desarrollo distribuido de software: centenares de desarrolladores independientes, desde diferentes puntos del planeta tomaron a su cargo la producción de software para Linux, ya sea escribiéndolo desde cero o portándolo desde otras plataformas Unix. Esta modalidad de desarrollo continúa aún hoy y ha permitido a Linux alcanzar un alto nivel de desarrollo y madurez, así también como un amplio grado de aceptación.
Actualmente, Linux posee todas las características que pueden encontrarse en cualquier sistema
Unix moderno, incluyendo direccionamiento lineal de 32 bits, memoria virtual, multitarea
real, shared libraries, módulos de kernel cargables on-demand, soporte TCP/IP (incluyendo SLIP,
PPP, NFS, etc.), y sistema X-Windows (incluyendo servidores X para los adaptadores de video
más populares, y clones de Motif, OpenLook, NextStep y Windows95 como window managers).
DISPONIBILIDAD DE LINUX
Linux es distribuido bajo la Licencia General Pública de GNU, lo cual significa que puede ser distribuido, copiado y modificado gratuitamente, a condición de no imponer ninguna restricción en sucesivas distribuciones. En pocas palabras: Linux es un sistema operativo gratuito.
OBTENCIÓN DEL SOFTWARE
Si se dispone de una conexión eficiente y segura a la Internet (y de una buena cuota de paciencia), un paquete Linux completo (kernel + utilidades + aplicaciones) puede obtenerse gratuitamente de
muchos servidores FTP públicos; el único costo será en este caso el costo de la conexión a la Internet.
Otra opción es comprar alguno de los libros sobre Linux que han sido editados en los últimos tiempos, los cuales suelen venir acompañados de uno o dos CDs conteniendo el software; el costo de libros de ese tipo oscila entre los $50 y $120, aproximadamente.
Sin embargo, la mejor opción es adquirir alguna de las muchas ediciones en CD-ROM disponibles en el mercado; la mayoría de ellas incluye varios CDs conteniendo no solo el paquete Linux, sino también extractos de servidores FTP dedicados a Linux, con lo que se obtiene el beneficio adicional de varios megabytes de software. El costo en este caso varía según la edición de que se trate; cabe destacar, a manera de ejemplo, la edición InfoMagic, conformada por 6 CDs, con un costo aproximado de $40.
HARDWARE SOPORTADO
PROCESADOR
Linux fue inicialmente concebido como sistema operativo para computadoras personales con procesador Intel 80386 o superior, con al menos 8 Mbytes de RAM. Versiones más recientes (aún en estado experimental), han incorporado soporte para multiprocesamiento simétrico con hasta 16 procesadores siguiendo la especificación Intel MP.
Existe una versión de Linux para el procesador de 64-bits Alpha/AXP de DEC, y está siendo portado a procesadores PowerPC, Sparc, MIPS, y Motorola de la serie 68000.
DISPOSITIVOS
Linux puede ejecutarse en cualquier PC con arquitectura ISA, EISA, VESA Local Bus o PCI, e incluso en notebooks con tecnología PCMCIA, soportando gran parte del hardware usualmente usado en dichos sistemas: discos y CD-ROMS IDE; controladoras y dispositivos SCSI (Adaptec, NCR, BusLogic, etc.); tarjetas de video SuperVGA (Trident, Cirrus, ATI, etc.); tarjetas de sonido (SoundBlaster, AdLib, Logitech, etc.); controladoras Ethernet (NE2000, Intel, etc.); modems y mouses seriales; impresoras chorro de tinta y laser (Epson, HP, etc.); scanners (HP, Genius, Epson, etc.); etc.
SOFTWARE DISPONIBLE
Linux cuenta con el habitual conjunto de las intérpretes de comando y utilidades que son standard en ambientes Unix. En su mayoría son provenientes de GNU y, al igual que Linux en sí mismo y todo el software que a continuación se menciona, son de distribución libre y gratuita.
SOFTWARE PARA SERVICIOS INTERNET
En particular, en lo referido a software para Servicios Internet, cabe mencionar que en Linux está disponible exactamente el mismo software que utilizan (o de los cuales tomaron elementos) muchas de las versiones comerciales de Unix. Han sido portados a Linux sendmail (servidor de e-mail SMTP, en sus versiones IDA y v8); Taylor UUCP (transferencia de mail y news bajo protocolo UUCP); CERN NCSA y Apache (servidores de WWW); INN y Cnews (servidores de news); BIND (servidor DNS de Berkeley); etc.
También están disponibles versiones Linux de servidores PPP, SLIP, bootp, Telnet, FTP, Gopher, POP e IMAP, IRC
En lo referente a seguridad, puede mencionarse que el kernel de Linux tiene el soporte necesario para construir firewalls basados en filtrado de paquetes; también existe una versión para Linux de SOCKS, software de firewalling muy popular en los ambientes Unix.
HERRAMIENTAS DE DESARROLLO
Múltiples lenguajes de programación están disponibles bajo Linux. Sin duda el principal de ellos es GNU C/C++, pero también es posible desarrollar en Java, Objective-C, Pascal, LISP, BASIC, Perl, Ada, Eiffel, FORTRAN, Forth, Prolog, Oberon, Simula, Modula-2 y Modula-3, Smalltalk, y algunos otros.
Igualmente, existen varios motores de bases de datos que pueden utilizarse bajo Linux; algunos de ellos son motores relacionales (tales como mBase, Thypoon, MiniSQL, Ingres y Postgres), y
otros orientados a objetos (tal como LINCKS). La mayoría de ellos son de carácter experimental o académico, por lo que no igualan las prestaciones de los motores de base de datos comerciales, en especial las relacionadas con performance; sin embargo, el hecho de que su costo sea nulo hace que sea una opción a tener en cuenta al desarrollar un servidor de Intranet de pequeñas proporciones. Cabe mencionar nuestra muy favorable experiencia con un servidor Postgres utilizado actualmente en la UTN FC, el cual tiene, además, soporte para ser utilizado desde programas Java (vía la especificación JDBC) o desde aplicaciones Windows (vía un driver ODBC).
CAPACIDAD DE CONECTIVIDAD Y CONVIVENCIA
CONECTIVIDAD
Linux ofrece una variada gama de posibilidades a la hora de interconectarse con otros servidores.
Como es usual en plataformas Unix, Linux cuenta con soporte nativo de TCP/IP, incluyendo la capacidad para actuar como cliente o servidor NFS (Network File System).
El kernel incluye soporte para IPX, lo que le permite funcionar como ruteador en redes Novell; incluso es posible configurar un sistema Linux para aparentar ser un servidor Novell 3.11 y permitir a clientes DOS mapear directorios y utilizar impresoras utilizando el shell y comandos standard de Novell (NETx y CAPTURE). También es posible montar en el file system de una máquina Linux volúmenes de un servidor Novell y acceder a sus colas de impresión.
Por medio de la utilización del paquete Samba, Linux puede interactuar con servidores Windows NT y estaciones Windows For Workgroups y Windows95. Esto incluye la capacidad para acceder desde Linux a recursos compartidos desde maquinas Windows (directorios e impresoras), como también la posibilidad de exportar directorios e impresoras desde Linux y accederlas desde Windows.
CONVIVENCIA
Linux es capaz de convivir en el mismo disco duro con otros sistemas operativos tales como DOS, Windows u OS/2, permitiendo la selección en el arranque del sistema operativo a bootear. Además de soportar su sistema de archivos nativo (ext2fs), Linux tiene soporte para acceder en modo de lectura/escritura a sistemas de archivo FAT (DOS) y VFAT (Windows95) y en modo de solo lectura a sistemas de archivo NTFS (Windows NT).
DOCUMENTACIÓN Y SOPORTE
Existe una gran cantidad de bibliografía acerca de Linux, abarcando temas como la instalación y configuración del sistema operativo, administración de redes, uso del sistema y sus aplicaciones, instalación de sitios Internet y BBSs, etc. Todas las distribuciones importantes de Linux incluyen un juego completo de la documentación en línea (man pages) e instructivos muy completos y detallados (llamados HOW-TOs) acerca de temas puntuales tales como configuración de TCP/IP, servidores DNS, acceso PPP, impresión, firewalls, configuración de X-Windows, etc.
Debe tenerse en cuenta, además, que Linux es, fundamentalmente, un sistema Unix en el que se utiliza software Unix standard, por lo que resulta aplicable a su caso prácticamente toda la bibliografía y know-how existente sobre Unix. Son especialmente recomendables los volúmenes de la colección "A Nutshell Handbook" de O’Reilly & Associates, Inc. (ver referencias bibliográficas, más abajo).
La falta de soporte formal es uno de los temores usuales acerca de Linux. Esto es una verdad a
medias. En primer lugar, debido a que (por la razón dada en el párrafo anterior) cualquier
consultor en Unix puede convertirse en consultor Linux (y viceversa); y en segundo lugar, porque
como se mencionó al comienzo de éste informe, Linux es un producto de la Internet. Es más:
Linux no habría sido posible sin ella. Es resultado del esfuerzo combinado de mucha gente
alrededor del mundo en donde el principal componente ha sido el soporte mutuo. Existen
numerosos newsgroups y mailing-lists en donde todo administrador de un sistema Linux puede
recurrir para buscar la solución o pedir ayuda, con la certeza de que, aún en el peor de los casos,
será orientado en la dirección correcta.
SISTEMA OPERATIVO SLAX
Slax es un Live CD del sistema operativo GNU/Linux basada en la distribución Slackware. No
necesita ser instalado, es capaz de arrancar y funcionar desde una unidad de CD, siendo
innecesario el uso de un disco duro. Opcionalmente, dispone de un sistema mediante el cual el
contenido del CD se copia en la memoria RAM durante la ejecución de Slax, dejando libre la
unidad de CD/DVD para otros usos como ver un vídeo DVD, reproducir un CD de música, o
copiar/grabar algo al disco. La versión estándar de Slax y la edición Kill Bill usan KDE como su
escritorio, mientras que Popcorn utiliza XFCE. Fluxbox es una opción en todas las versiones
exceptuando Frodo, sin entorno gráfico y pensada para máquinas con poca memoria RAM.
Gracias a la utilización de archivos .mo (llamados modules o módulos), Slax es altamente
personalizable. Se pueden descargar e instalar "módulos" (programas como The Gimp, XMMS,
etc.) Mientras se usa Slax en modo live. Todo ello sin tocar o necesitar un disco duro pues es en la
memoria RAM dónde temporalmente se almacenan y ejecutan.
Slax se presenta como un sistema operativo, "Revolucionario", rápido y sobre todo compatible; es
una excelente alternativa para quienes desean conocer el mundo Slackware de manera segura,
pero a su vez potente, siendo además una alternativa "ligera" a quienes desea usar un livecd que
les consuma pocos recursos como Knoppix.
Slax es muy útil debido a sus características, como salvar la configuración, y para los usuarios
más avanzados se encuentran disponibles las fuentes del sistema y scripts que permiten crear una
distro propia basada en Slackware, mediante el sistema Linux Live. También contiene
herramientas más simples como myslax Creator que es un programa para Windows que permite
modificar una imagen existente de Slax así como sus opciones de arranque, wallpaper y
compatibilidad con Hardware defectuoso. La compatibilidad con hardware antiguo así como
moderno la hacen una de las distros más flexibles, como por ejemplo Compatibilizar con wifi,
entre otros más conocidos
CARACTERÍSTICAS PRINCIPALES
Slax ha participado en el desarrollo de los llamados sqlzma patches; el código implementa compresión 7-zip (LZMA) en el sistema de archivos squashfs. Además, squashfs ha evolucionado con el tiempo y ahora soporta tamaños de bloques mayores que antes. La combinación de estas dos mejoras hacen de Slax uno de los sistemas operativos mejor-comprimidos de la historia.
Todos los módulos para Slax son mucho más pequeños que cualquier otro paquete comprimido disponible hoy en día para cualquiera de las otras distribuciones de Linux, mientras que la velocidad de descompresión se mantiene usualmente más rápida que leyendo la totalidad de los datos desde disco.
Gracias al sistema de archivos AUFS, la parte inalterable de Slax (los datos y módulos del sistema) son sobrepuestos por un sistema de archivos escribible. Puede modificar todas las áreas del sistema de archivos en Slax sin ninguna restricción. Los cambios a las partes inalterables son transparentemente copiados a la zona escribible y se almacenan en memoria o en un directorio persistente en su disco o unidad flash. Slax está diseño para autodetectar si está corriendo sobre un medio escribible, y si lo detecta, Slax guardará todos sus cambios allí automáticamente.
En Slax, no estas limitado únicamente a un directorio home persistente, sino que la totalidad del sistema de archivos puede modificarse, así que podemos hablar de 'cambios persistentes' (en lugar del 'home persistente', utilizado por otras distribuciones live). Puedes modificar /bin/bash de la misma forma que ~/kderc.
Sistema XWindow, escritorio KDE con K-Office, navegador Internet, correo electrónico, Mensajería Instántanea, Grabación de CD/DVD y extracción de pistas, codificación de Audio y Vídeo, reproductores multimedia, todo esto y mucho más está incluido en Slax.
Hay versiones oficiales en 28 idiomas diferentes, incluyendo Catalán, Croata, Checo, Danés, Holandés, Estoniano, Finlandés, Francés, Gallego, Alemán, Griego, Hebreo, Húngaro, Islandés, Italiano, Lituano, Noruego, Noruego del Oeste (Nynorsk), Polaco, Portugués, Rumano, Ruso, Eslovaco, Esloveno, Español, Sueco y Turco.
LENGUAJE DE BAJO MEDIO Y ALTO NIVEL.
La solución de problemas mediante el uso de un computador nos lleva a desarrollar programas o
aplicaciones, la construcción de estos programas debe ser realizada mediante una metodología, los
pasos para la construcción de programas son:
1. Diseñar el algoritmo, consiste en analizar el problema y describir los instrucciones de forma
ordenada que resuelven el problema.
2. Codificar de forma sistemática la secuencia de instrucciones en un lenguaje.
3. Ejecutar y validar el programa en un computador (verificación) para codificar de forma
sistemática un algoritmo se necesita de un lenguaje.
Lenguaje de bajo nivel
Un lenguaje de programación de bajo nivel es aquel en el que sus instrucciones ejercen un control
directo sobre el hardware y están condicionados por la estructura física de la computadora que lo
soporta.
Complejidad Vs Dificultad
Dicho lenguaje es muy simple o nada complicado, pero estructurar programas a ese nivel es muy
difícil. Dado que este lenguaje viene dado por las especificaciones técnicas del hardware, no
permite una abstracción fuera de lo estipulado para el microprocesador de un ordenador.
Consecuentemente, es fácilmente trasladado a lenguaje de máquina.
La estructura de los lenguajes es como sigue:
0. Código Binario - Es el lenguaje básico, sólo admite positivo (1) o negativo (0). Todo sistema
informático está basado en este código, ya que el positivo quiere decir que se permite el paso de la
electricidad y el negativo no lo permite.
1. Lenguaje Máquina - Las invocaciones a memoria, como los procesos aritmético lógicos son
posiciones literales de conmutadores físicos del hardware en su representación booleana. Estos
lenguajes son literales de tareas.
2. Lenguajes de bajo nivel - Son instrucciones que ensamblan los grupos de conmutadores
necesarios para expresar una mínima lógica aritmética. Están íntimamente vinculados al
hardware. Por norma general están disponibles a nivel firmware, cmos o chip set. Estos lenguajes
están orientados a procesos. Los procesos se componen de tareas. Contienen tantas instrucciones
como la arquitectura del hardware así haya sido diseñada.
Por ejemplo: La arquitectura CISC contiene muchas más instrucciones a este nivel, que la RISC.
Son denominados como ensambladores de un hardware concreto, o kernel.
Lenguaje de medio nivel
Son aquellos que, basándose en los juegos de instrucciones disponibles (chip set), permiten el uso de funciones a nivel aritmético, pero a nivel lógico dependen de literales en ensamblador. Estos lenguajes están orientados a procedimientos. Los procedimientos se componen de procesos.
Ejemplos: C, Basic.
Es un lenguaje de programación informática como el lenguaje C, que se encuentran entre los lenguajes de alto nivel y los lenguajes de bajo nivel.
Suelen ser clasificados muchas veces de alto nivel, pero permiten ciertos manejos de bajo nivel. Son precisos para ciertas aplicaciones como la creación de sistemas operativos, ya que permiten un manejo abstracto (independiente de la máquina, a diferencia del ensamblador), pero sin perder mucho del poder y eficiencia que tienen los lenguajes de bajo nivel.
Una característica distintiva, por ejemplo, que convierte a C en un lenguaje de medio nivel y al Pascal en un lenguaje de alto nivel es que en el primero es posible manejar las letras como si fueran números (en Pascal no), y por el contrario en Pascal es posible concatenar las cadenas de caracteres con el operador suma y copiarlas con la asignación (en C es el usuario el responsable de llamar a las funciones correspondientes).
Lenguaje de alto nivel
Un lenguaje de programación de alto nivel se caracteriza por expresar los algoritmos de una manera adecuada a la capacidad cognitiva humana, en lugar de la capacidad ejecutora de las máquinas.
En los primeros lenguajes de nivel bajo la limitación era que se orientaban a un área específica y sus instrucciones requerían de una sintaxis predefinida. Se clasifican como lenguajes procedimentales.
Otra limitación de los lenguajes de nivel bajo es que se requiere de ciertos conocimientos de programación para realizar las secuencias de instrucciones lógicas. Los lenguajes de alto nivel se crearon para que el usuario común pudiese solucionar un problema de procesamiento de datos de una manera más fácil y rápida.
Por esta razón, a finales de los años 1950 surgió un nuevo tipo de lenguajes de programación que evitaba estos inconvenientes, a costa de ceder un poco en las ventajas. Estos lenguajes se llaman de tercera generación o de nivel alto, en contraposición a los de bajo nivel o de nivel próximo a la máquina
Ventajas e inconvenientes
Ventajas: o Genera un código más sencillo y comprensible. o Escribir un código válido para diversas máquinas y, posiblemente, sistemas operativos.
Inconvenientes o Reducción de velocidad al ceder el trabajo de bajo nivel a la máquina. o Algunos requieren que la máquina cliente posea una determinada plataforma.
Principales lenguajes de nivel alto. Matlab
VB.NET Ada
ALGOL BASIC
C Sharp FORTRAN
Java Lisp
Modula-2 Pascal
Perl PHP
PL/1 PL/SQL
Python Ruby
CAPITULO 2: LENGUAJE ENSAMBLADOR.
HERRAMIENTAS DENTRO DE SLAX PARA PROGRAMACIÓN.
Dentro de este Sistema Operativo (Slax) se encuentra “GEANY”, es un editor de texto utilizando
el toolkit GTK2 con las características básicas de un entorno de desarrollo integrado. Fue
desarrollado para proporcionar un pequeño y rápido IDE, que solo tiene pocas dependencias de
otros paquetes. Es compatible con muchos tipos de archivos y tiene algunas características
agradables.
Este es uno de las herramientas con las que se puede programar de la siguiente manera
(Programación con Pascal)
Encontramos con la siguiente ventana:
Figura 1: Ventana principal de GEANY
Ahora el siguiente paso que se debe hacer es; crear un proyecto, para eso vamos a mostrar un
ejemplo de cómo crear el proyecto (en este caso el típico Hola Mundo).
Para eso tenemos que apretar el botón que dice \Nuevo". Una vez apretado dicho botón nos
aparece una pestaña que dice \sin título" como muestra la siguiente:
Figura 2: Proyecto vacío
Ahora, para indicarle al IDE GEANY, que se quiere crear un proyecto en el lenguaje pascal, se
tiene que ir a la barra de herramientas e ingresar a:
Documento Establecer tipo de archivo Lenguajes de programación Archivo de
fuente Pascal
Como se indica: Figura 3: Como seleccionar el tipo de documento
Una vez hecho esto, se escribe el código fuente deseado (en este caso era el hola mundo), una vez
escrito dicho código,
Se aprieta el botón que dice \Guardar". Ya guardado el proyecto se debe compilar y ejecutar, para
eso se selecciona el botón \compilar", esto hace que compile el archivo .pas creado, si la
compilación se creó con éxito, muestra un mensaje informando que la compilación fue exitosa,
caso contrario, muestra un mensaje de error y un listado de los errores encontrados.
Ambos casos son mostrados en las siguientes figuras.
Figura 4: Compilación exitosa
Figura 5: Compilación no exitosa
Una vez hecho la compilación de forma exitosa, se presiona el botón \Ejecutar", y bueno el resto
es magia, se puede apreciar el programa en pleno funcionamiento.
ENSAMBLADOR.
Se refiere a un tipo de programa, informático que se encarga de traducir un fichero fuente escrito
en un lenguaje ensamblador, a un fichero objeto que contiene código máquina ejecutable
directamente por la máquina para la que se ha generado, en si la función de un ensamblador es
traducir un programa en lenguaje de ensamblador al código correspondiente en lenguaje de
máquina.
Ventajas para utilizarlo:
o Mayor control de la computadora.
o Independencia de lenguaje.
o La mayoría de las computadoras pueden ensamblar.
o Los programas hechos en lenguaje ensamblador son generalmente más rápidos y consumen
menos recursos del sistema.
Desventajas para no utilizarlo:
o Demasiado complejo.
o Comprensión más profunda de la computadora.
o Errores más frecuentes en el programa.
o Mayor tiempo de codificación.
o Difícilmente portable, es decir, un código escrito para un microprocesador en particular
necesita ser modificado muchas veces en su totalidad para poder ser usado en otro
microprocesador.
Tipos de ensambladores:
Ensambladores cruzados:
Se les denomina asi a los que utilizan en una computadora que posee el procesador diferente al
que tendrá las computadoras donde va a ejecutar el programa objeto producido.
Ensambladores residentes:
Son aquellas que permiten en la memoria principal de la computadora y cargar para su ejecución
al programa.
Micro ensamblador.
Al programa que indica al intérprete de instrucciones de la CPU como debe actuar se le denomina
microprograma. El programa que ayuda a realizar esta microprograma se llama micro
ensamblador.
Macro ensambladores.
Son ensambladores que permiten el uso de macroinstrucciones.
Ensambladores de una fase.
Leen una línea y la traducen directamente para producir una instrucción de lenguaje maquina o
la ejecuta si se trata de una pseudosinstrucción. Se construye la tabla de símbolos a medida que
aparecen las definiciones de variables, etiquetas, etc.
Ensambladores de dos fases.
Realiza la traducción en dos etapas: 1° fase leen el programa fuente y construyen la tabla de
símbolos, 2° fase vuelve a leer el programa fuente y pueden ir traduciendo totalmente pues
reconocen la totalidad de los símbolos.
PROGRAMAS REALIZADOS.
I. Programa 1 Código:
;segmentos de datos section .data mensaje dB "Hola pianola", 0xA longitudequ 14 ;Segmento de código section .Data global _start ;Define punto de inicio de código _start: movedx, longitud; longitud de cade por imprimir movecx, mensaje; dirección de la cadena por imprimir movebx, 1; requerimiento de la moveax, 4; interrupción de software int 0x80; solicitud de interrupción 80 en Hexadecimal movebx, 0; solicitud moveax, 1; de salida int 0x80; invocación de interrupción ;fin de programa
El código lo capturamos tanto en nano como en Geany y lo compilamos para que nos mostrara en pantalla el mensaje deseado
Código en pantalla y compilación.
Compilación
II. Programa 2
Código
;valores predefinidos para atención de servicios de la ;interrupción 80H SalidaSistemaequ 1 lecturaSistemaequ 3 escrituraSistemaequ 4 entradaEstandarequ 0 salidaEstandarequ 1 salidaErrorequ 3 section .data ;Seccion de datos predefinidos
nombredb "¿Cual es tu nombre?" longNombreequ $-nombre saludodb "Hola",0 longSaludoequ $-saludo section .bss ;seccion de datos variables sin iniciar memLecturaresb 20 ;reserva byte longMemLecturaequ $- memLectura section .text ;seccion de código global _start _start: movecx, nombre movedx, longNombre calldespliega movecx, memLectura movedx,longMemLectura callleeTeclado pusheax ;inserta el registro eax a la pila movecx, saludo movedx, longSaludo call despliega popedx ;Lo que hay en la pila lo copia a edx movecx, memLectura call despliega jmp salida despliega: ;Invocacion de la rutina despliega moveax, escrituraSistema movebx, salidaEstandar int 80H ret ; retorno al invocador leeTeclado: movebx, entradaEstandar moveax, lecturaSistema int 80H
ret salida: moveax, SalidaSistema xorebx, ebx int 80H
Código en pantalla y compilación:
III. Programa 3
Código
; Valores predefinidos para atención de servicios de la interrupción 80H salidaSistema equ 1 lecturaSistema equ 3 escrituraSistemaequ 4 entradaEstandarequ 0 salidaEstandarequ 1 salidaErrorequ 3 section .data ;Seccion de datos predefinidos mensajedb "inserte digito 1",0xA,0XD
longMensaje equ $-mensaje section .bss ;Seccion de datos variables sin iniciar dato1 resb 4 dato2 resb 4 resultadoresb 6 longResultadoequ $-resultado longDatoequ $-dato1 section .text ;seccion de código global _start _start: movecx,mensaje movedx,longMensaje calldespliega mov ecx,dato1 movedx,longDato callleeTeclado mov bl,0x32 mov [mensaje+0xF],bl mov ecx,mensaje mov edx,longMensaje call despliega mov ecx,dato2 movedx,longDato callleeTeclado moveax,[dato1] addeax,[dato2] mov [resultado],eax mov ecx,resultado mov edx,longResultado call despliega jmp salida despliega: ;invocación de la rutina despliega moveax,escrituraSistema movebx,salidaEstandar int 80H
ret ;retorno al invocador leeTeclado: movebx,entradaEstandar moveax,lecturaSistema int 80H ret salida: moveax,salidaSistema xorebx,ebx int 80H
Código en pantalla y compilación
IV. Programa 4
Código
; Valores predefinidos para atención de servicios de la interrupción 80H salidaSistema equ 1 lecturaSistema equ 3 escrituraSistemaequ 4 entradaEstandarequ 0
salidaEstandarequ 1 salidaErrorequ 3 section .data ;Seccion de datos predefinidos mensajedb "Roberto",0xA,0XD longMensaje equ $-mensaje section .bss ;Seccion de datos variables sin iniciar dato1 resb 4 dato2 resb 4 resultadoresb 6 longResultadoequ $-resultado longDatoequ $-dato1 section .text ;seccion de código global _start _start: movecx,mensaje movedx,longMensaje calldespliega mov ecx,dato1 movedx,longDato callleeTeclado movbl,'r' mov [mensaje+0x6],bl movbl,'o' mov [mensaje+0x5],bl movbl,'b' mov [mensaje+0x4],bl movbl,'e' mov [mensaje+0x3],bl movbl,'r' mov [mensaje+0x2],bl movbl,'t' mov [mensaje+0x1],bl movbl,'O' mov [mensaje+0x0],bl mov ecx,mensaje mov edx,longMensaje calldespliega
mov ecx,dato2 movedx,longDato callleeTeclado moveax,[dato1] mov [resultado],eax mov ecx,resultado mov edx,longResultado call despliega jmp salida despliega: ;invocación de la rutina despliega moveax,escrituraSistema movebx,salidaEstandar int 80H ret ;retorno al invocador leeTeclado: movebx,entradaEstandar moveax,lecturaSistema int 80H ret salida: moveax,salidaSistema xorebx,ebx int 80H
Código en pantalla y compilación
V. Programa 5
Código
%include"definiciones.inc" section .data ;seccion de datos predefinidos mensajedb "Inserte un digito" longMensajeequ $-mensaje section .bss ;seccion de datos variables sin iniciar dato resb 2 longDatoequ $-dato section .text ;seccion de código global _start _start: movecx,mensaje movedx,longMensaje call despliega movecx,dato movedx,longDato callleeTeclado mov ecx,0 mov cl,[dato] sub cl,'0' ciclo: pushecx movecx,dato movedx,longDato calldespliega moveax,[dato] deceax mov [dato],eax popecx loop ciclo
moveax,salidaSistema xorebx,ebx int 80H %include"definiciones.inc" section .data ;seccion de datos predefinidos mensajedb "Inserte un digito" longMensajeequ $-mensaje section .bss ;seccion de datos variables sin iniciar dato resb 2 longDatoequ $-dato section .text ;seccion de código global _start _start: movecx,mensaje movedx,longMensaje call despliega movecx,dato movedx,longDato callleeTeclado mov ecx,0 mov cl,[dato] sub cl,'0' mov dl,'1' mov [dato],dl ciclo: pushecx movecx,dato movedx,longDato calldespliega moveax,[dato] inceax mov [dato],eax popecx loop ciclo moveax,salidaSistema xorebx,ebx
int 80H Nota: Para la realización de este programa fue necesario la creación de otros dos para asi invocarlos, los cuales son los siguientes
Códigos anexos.
%include"definiciones.inc" section .data ;seccion de datos predefinidos mensajedb "Inserte un digito" longMensajeequ $-mensaje section .bss ;seccion de datos variables sin iniciar dato resb 2 longDatoequ $-dato section .text ;seccion de código global _start _start: movecx,mensaje movedx,longMensaje call despliega movecx,dato movedx,longDato callleeTeclado mov ecx,0 mov cl,[dato] sub cl,'0' mov dl,'1' mov [dato],dl ciclo: pushecx movecx,dato movedx,longDato calldespliega moveax,[dato] inceax mov [dato],eax popecx
loop ciclo moveax,salidaSistema xorebx,ebx int 80H %include"definiciones.inc" section .data ;seccion de datos predefinidos mensajedb "Inserte un digito" longMensajeequ $-mensaje section .bss ;seccion de datos variables sin iniciar dato resb 2 longDatoequ $-dato section .text ;seccion de código global _start _start: movecx,mensaje movedx,longMensaje call despliega movecx,dato movedx,longDato callleeTeclado mov ecx,0 mov cl,[dato] sub cl,'0' mov dl,'1' mov [dato],dl ciclo: pushecx movecx,dato movedx,longDato calldespliega moveax,[dato] inceax mov [dato],eax popecx loop ciclo
moveax,salidaSistema xorebx,ebx int 80H
Librería guardada con el nombre “definiciones.inc.
;Valores predefinidos para atención de servicios de la interrupción 80H salidaSistema equ 1 lecturaSistema equ 3 escrituraSistema equ 4 entradaEstandarequ 0 salidaEstandarequ 1 salidaErrorequ 3 despliega: ;invocación de la rutina despliega moveax,escrituraSistema movebx,salidaEstandar int 80H ret ;retorno al invocador leeTeclado: movebx,entradaEstandar moveax,lecturaSistema int 80H ret
Código en pantalla y compilación
VI. Programa 6
Código
%include"definiciones.inc" section .data ;seccion de datos predefinidos mensajedb "Olvidaste agregar un digito al invocar al programa",0xA longMensajeequ $-mensaje section .bss ;seccion de datos variables sin iniciar dato1 resb 2 dato2 resb 2 resultadoresb 2 longDatoequ $-dato1 section .text ;seccion de código global _start _start: popecx ;numero de argumentos cmp ecx,3 jne error ;si es igual a 1 entonces faltaron argumentos popebx ;Nombre del programa popecx ;primer argumento mov al,[ecx] mov [dato1],al ;dato1=primer valor
popecx ;segundo argumento mov al,[ecx] mov [dato2],al ;dato2=segundo valor mov eax,0 movbl,[dato1] mov al,[dato2] sub bl,'0' sub al,'0' addal,bl add al,'0' mov [resultado],al movecx,resultado movedx,longDato calldespliega ;movecx,enter ;movedx,longEnter ;calldespliega push ebx push ebx pushebx jmp salida error: movecx,mensaje movedx,longMensaje call despliega salida: pushebx moveax,salidaSistema xorebx,ebx int 80H
Código en pantalla y compilación
CAPITULO 3: LENGUAJE C.
LENGUAJE “C”
C es un lenguaje de programación de propósito general que ofrece economía sintáctica, control de
flujo y estructuras sencillas y un buen conjunto de operadores. No es un lenguaje de muy alto
nivel y más bien un lenguaje pequeño, sencillo y no está especializado en ningún tipo de
aplicación. Esto lo hace un lenguaje potente, con un campo de aplicación ilimitado y sobre todo,
se aprende rápidamente. En poco tiempo, un programador puede utilizar la totalidad del
lenguaje.
Este lenguaje ha sido estrechamente ligado al sistema operativo UNIX, puesto que fueron
desarrollados conjuntamente. Sin embargo, este lenguaje no está ligado a
ningún sistema operativo ni a ninguna máquina concreta. Se le suele llamar lenguaje de
programación de sistemas debido a su utilidad para escribir compiladores y sistemas operativos,
aunque de igual forma se puede desarrollar cualquier tipo de aplicación.
La base del C proviene del BCPL, escrito por Martin Richards, y del B escrito por Ken Thompson
en 1970 para el primer sistema UNIX en un DEC PDP-7. Estos son lenguajes sin tipos, al
contrario que el C que proporciona varios tipos de datos. Los tipos que ofrece son caracteres,
números enteros y en coma flotante, de varios tamaños. Además se pueden crear tipos derivados
mediante la utilización de punteros, vectores, registros y uniones. El primer compilador de C fue
escrito por Dennis Ritchie para un DEC PDP-11 y escribió el propio sistema operativo en C
C trabaja con tipos de datos que son directamente tratables por el hardware de la mayoría
de computadoras actuales, como son los caracteres, números y direcciones. Estos tipos de datos
pueden ser manipulados por las operaciones aritméticas que proporcionan las computadoras. No
proporciona mecanismos para tratar tipos de datos que no sean los básicos, debiendo ser el
programador el que los desarrolle. Esto permite que el código generado sea muy eficiente y de ahí
el éxito que ha tenido como lenguaje de desarrollo de sistemas. No proporciona otros mecanismos
de almacenamiento de datos que no sea el estático y no proporciona mecanismos de entrada ni
salida. Ello permite que el lenguaje sea reducido y los compiladores de fácil implementación en
distintos sistemas. Por contra, estas carencias se compensan mediante la inclusión de funciones de
librería para realizar todas estas tareas, que normalmente dependen del sistema operativo.
Originariamente, el manual de referencia del lenguaje para el gran público fue el libro de
Kernighan y Ritchie, escrito en 1977. Es un libro que explica y justifica totalmente el desarrollo
de aplicaciones en C, aunque en él se utilizaban construcciones, en la definición de funciones, que
podían provocar confusión y errores de programación que no eran detectados por el compilador.
Como los tiempos cambian y las necesidades también, en 1983 ANSI establece el comité X3J11
para que desarrolle una definición moderna y comprensible del C. El estándar está basado en el
manual de referencia original de 1972 y se desarrolla con el mismo espíritu de sus creadores
originales. La primera versión de estándar se publicó en 1988 y actualmente todos los
compiladores utilizan la nueva definición. Una aportación muy importante de ANSI consiste en
la definición de un conjunto de librerías que acompañan al compilador y de las funciones
contenidas en ellas. Muchas de las operaciones comunes con el sistema operativo se realizan a
través de estas funciones. Una colección de ficheros de encabezamiento, headers, en los que se
definen los tipos de datos y funciones incluidas en cada librería. Los programas que utilizan
estas bibliotecas para interactuar con el sistema operativo obtendrán
un comportamiento equivalente en otro sistema.
ESTRUCTURA BÁSICA DE UN PROGRAMA EN C
La mejor forma de aprender un lenguaje es programando con él. El programa más sencillo que se
puede escribir en C es el siguiente:
main ( )
{
}
Como nos podemos imaginar, este programa no hace nada, pero contiene la parte más importante
de cualquier programa C y además, es el más pequeño que se puede escribir y que se compile
correctamente. En él se define la función main, que es la que ejecuta el sistema operativo al
llamar a un programa C. El nombre de una función C siempre va seguida de paréntesis, tanto si
tiene argumentos como si no. La definición de la función está formada por un bloque de
sentencias, que está encerrado entre llaves {}.
Un programa algo más complicado es el siguiente:
#include <stdio.h>
main ( )
{
printf ("Hola amigos!\n");
}
Con el visualizamos el mensaje Hola amigos! en el terminal. En la primera línea indica que se
tengan en cuenta las funciones y tipos definidos en la librería stdio (standard input/output).
Estas definiciones se encuentran en el fichero header stdio.h. Ahora, en la función main se
incluye una única sentencia que llama a la función printf. Esta toma como argumento una
cadena de caracteres, que se imprimen van encerradas entre dobles comillas " ". El símbolo \n
indica un cambio de línea.
Hay un grupo de símbolos, que son tratados como caracteres individuales, que especifican algunos
caracteres especiales del código ASCII. Los más importantes son:
\a Alerta
\b Espacio atrás
\f Salto de página
\n Salto de línea
\r Retorno de carro
\t Tabulación horizontal
\v Tabulación vertical
\\ Barra invertida
\' Comilla simple
\" Comillas dobles
\OOO Visualiza un carácter cuyo código ASCII es OOO en octal
\xHHH Visualiza un carácter cuyo código ASCII es HHH en hexadecimal
Un programa C puede estar formado por diferentes módulos o fuentes. Es conveniente mantener
las fuentes de un tamaño no muy grande, para que la compilación sea rápida. También, al
dividirse un programa en partes, puede facilitar la legibilidad del programa y su estructuración.
Las diferentes fuentes son compiladas de forma separada, únicamente las fuentes que han sido
modificados desde la última compilación, y después combinados con las librerías necesarias para
formar el programa en su versión ejecutable.
TIPOS BÁSICOS Y VARIABLES
Los tipos de datos básicos definidos por C son caracteres, números enteros y números en coma
flotante. Los caracteres son representados por char, los enteros por short, int, long y los números
en coma flotante por float y double. Los tipos básicos disponibles y su tamaño son:
Char Carácter (normalmente 8 bits)
Short Entero corto con signo (normalmente 16 bits)
Int Entero con signo (depende de la implementación)
Unsigned Entero sin signo (depende de la implementación)
Long Entero largo con signo (normalmente 32 bits)
Float Flotante simple (normalmente 32 bits)
Double Flotante doble (normalmente 64 bits)
La palabra unsigned en realidad es un modificador aplicable a tipos enteros, aunque si no se
especifica un tipo se supone int. Un modificador es una palabra clave de C que indica que una
variable, o función, no se comporta de la forma normal. Hay también un modificador signed, pero
como los tipos son por defecto con signo, casi no se utiliza.
Las variables son definidas utilizando un identificador de tipo seguido del nombre de la variable.
Veamos el siguiente programa:
#include <stdio.h>
main ()
{
float cels, farh;
farh = 35.0;
cels = 5.0 * ( farh - 32.0 ) / 9.0;
printf ("-> %f F son %f C\n", farh, cels );
}
En el programa anterior se definen dos variables float, se asigna un valor a la primera y se
calcula la segunda mediante una expresión aritmética. Las asignaciones en C también son una
expresión, por lo que se pueden utilizar como parte de otra expresión, pero según que prácticas de
este tipo no son muy recomendables ya que reducen la legibilidad del programa. En la instrucción
printf, el símbolo %f indica que se imprime un número en coma flotante.
Hay un tipo muy importante que se representa por void que puede significar dos cosas distintas,
según su utilización. Puede significar nada, o sea que si una función devuelve un valor de tipo
void no devuelve ningún resultado, o puede significar cualquier cosa, como puede ser un puntero
a void es un puntero genérico a cualquier tipo de dato.
FUNCIONES
Un programa C está formado por un conjunto de funciones que al menos contiene la función
main. Una función se declara con el nombre de la función precedido del tipo de valor que retorna
y una lista de argumentos encerrados entre paréntesis. El cuerpo de la función está formado por
un conjunto de declaraciones y de sentencias comprendidas entre llaves. Veamos un ejemplo de
utilización de funciones:
#include <stdio.h>
#define VALOR 5
#define FACT 120
int fact_i ( int v )
{
int r = 1, i = 0;
while ( i <= v )
{
r = r * i;
i = i + 1;
}
return r;
}
int fact_r ( int v )
{
if ( v == 0 ) return 1;
else return v * fact_r(v-1);
}
main() {
int r, valor = VALOR;
if ( (r = fact_i(valor)) != fact_r(valor) ) printf("Codificación errónea!!.\n");
else if ( r == FACT ) printf("Codificación correcta.\n");
else printf("Algo falla!!.\n");
}
Se definen dos funciones, fact_i y fact_r, además de la función main. Ambas toman como
parámetro un valor entero y devuelven otro entero. La primera calcula el factorial de un número
de forma iterativa, mientras que la segunda hace lo mismo de forma recursiva.
Todas las líneas que comienzan con el símbolo # indican una directiva del pre compilador. Antes
de realizar la compilación en C se llama a un pre compilador cuya misión es procesar el texto y
realizar ciertas sustituciones textuales. Hemos visto que la directiva #include incluye el texto
contenido en un fichero en el fuente que estamos compilando. De forma parecida, #define nombre
texto sustituye todas las apariciones de nombre por texto. Así, en el fuente, la palabra VALOR
se sustituye por el número 5.
El valor que debe devolver una función se indica con la palabra return. La evaluación de la
expresión debe dar una valor del mismo tipo de dato que el que se ha definido como resultado. La
declaración de una variable puede incluir una inicialización en la misma declaración.
Se debe tener muy en cuenta que en C todos los argumentos son pasados 'por valor'. No existe
el concepto de paso de parámetros 'por variable' o 'por referencia'. Veamos un ejemplo:
int incr ( int v ) { return v + 1; }
main() {
int a, b;
b = 3;
a = incr(b);
/* a = 4 mientras que b = 3. No ha cambiado después de la llamada. */
}
En el ejemplo anterior el valor del parámetro de la función incr, aunque se modifique dentro de la
función, no cambia el valor de la variable b de la función main. Todo el texto comprendido entre
los caracteres /* y */ son comentarios al programa y son ignorados por el compilador. En un
fuente C los comentarios no se pueden anidar.
EXPRESIONES Y OPERADORES
Los distintos operadores permiten formar expresiones tanto aritméticas como lógicas. Los
operadores aritméticos y lógicos son:
+, - suma, resta
++, -- incremento, decremento
*, /, % multiplicación, división, módulo
>>, << rotación de bits a la derecha, izquierda.
& AND booleano
| OR booleano
^ EXOR booleano
~ complemento a 1
! complemento a 2, NOT lógico
==, != igualdad, desigualdad
&&, || AND, OR lógico
<, <= menor, menor o igual
>, >= mayor, mayor o igual
En estos operadores deben tenerse en cuenta la precedencia de operadores y las reglas de
asociatividad, que son las normales en la mayoría de lenguajes. Se debe consultar el manual de
referencia para obtener una explicación detallada. Además hay toda una serie de operadores
aritméticos con asignación, como pueden ser += y ^=.
En la evaluación de expresiones lógicas, los compiladores normalmente utilizan técnicas de
evaluación rápida. Para decidir si una expresión lógica es cierta o falsa muchas veces no es
necesario evaluarla completamente. Por ejemplo una expresión formada <exp1> || <exp2>, el
compilador evalúa primero <exp1> y si es cierta, no evalúa <exp2>. Por ello se deben evitar
construcciones en las que se modifiquen valores de datos en la propia expresión, pues su
comportamiento puede depender de la implementación del compilador o de la optimización
utilizada en una compilación o en otra. Estos son errores que se pueden cometer fácilmente en C
ya que una asignación es también una expresión.
Debemos evitar: if (( x++ > 3 ) || ( x < y ))
y escribir en su lugar: x++; if (( x > 3 ) || ( x < y ))
Hay un tipo especial de expresión en C que se denomina expresión condicional y está representada
por los operadores ? : . Su utilización es como sigue: <e> ? <x> : <y>. Se evalúa si e entonces x;
si no, y.
int mayor ( int a, int b ) {
return ( a > b ) ? TRUE : FALSE;
}
waste_time () {
float a, b = 0.0;
( b > 0.0 ) ? sin(M_PI / 8) : cos(M_PI / 4);
}
CONVERSIÓN DE TIPOS
Cuando escribimos una expresión aritmética a+b, en la cual hay variables o valores de distintos
tipos, el compilador realiza determinadas conversiones antes de que evalúe la expresión. Estas
conversiones pueden ser para 'aumentar' o 'disminuir' la precisión del tipo al que se convierten los
elementos de la expresión. Un ejemplo claro, es la comparación de una variable de tipo int con
una variable de tipo double. En este caso, la de tipo int es convertida a double
para poder realizar la comparación.
Los tipos pequeños son convertidos de la forma siguiente: un tipo char se convierte a int, con el
modificador signed si los caracteres son con signo, o unsigned si los caracteres son sin signo. Un
unsigned char es convertido a int con los bits más altos puestos a cero. Un signed char es
convertido a int con los bits más altos puestos a uno o cero, dependiendo del valor de la variable.
Para los tipos de mayor tamaño:
o Si un operando es de tipo double, el otro es convertido a double.
o Si un operando es de tipo float, el otro es convertido a float.
o Si un operando es de tipo unsigned long, el otro es convertido a unsigned long.
o Si un operando es de tipo long, el otro es convertido a long.
o Si un operando es de tipo unsigned, el otro es convertido a unsigned.
o Si no, los operando son de tipo int.
Una variable o expresión de un tipo se puede convertir explícitamente a otro tipo, anteponiéndole
el tipo entre paréntesis.
void cambio_tipo (void)
{
float a;
int b;
b = 10;
a = 0.5;
if ( a <=(float) b )
menor();
}
CONTROL DE FLUJO, SENTENCIA IF:
La sentencia de control básica es if (<e>) then <s> else <t>. En ella se evalúa una expresión
condicional y si se cumple, se ejecuta la sentencia s; si no, se ejecuta la sentencia t. La segunda
parte de la condición, else <t>, es opcional.
int cero ( double a )
{
if ( a == 0.0 )
return (TRUE);
else
return (FALSE);
}
En el caso que <e> no sea una expresión condicional y sea aritmética, se considera falso si vale 0;
y si no, verdadero. Hay casos en los que se deben evaluar múltiples condiciones y únicamente se
debe evaluar una de ellas.
SETENCIA SWITCH
Se puede programar con un grupo de sentencias if then else anidadas, aunque ello puede ser
farragoso y de complicada lectura. Para evitarlo nos puede ayudar la sentencia switch.
Su utilización es:
switch (valor) {
case valor1: <sentencias>
case valor2: <sentencias>
...
default: <sentencias>
}
Cuando se encuentra una sentencia case que concuerda con el valor del switch se ejecutan las
sentencias que le siguen y todas las demás a partir de ahí, a no ser que se introduzca una
sentencia break para salir de la sentencia switch. Por ejemplo:
ver_opcion ( char c )
{
switch(c){
case 'a': printf("Op A\n");
break;
case 'b': printf("Op B\n");
break;
case 'c':
case 'd': printf("Op C o D\n");
break;
default: printf("Op ?\n");
}
}
SETENCIA WHILE
Otras sentencias de control de flujo son las que nos permiten realizar iteraciones sobre un
conjunto de sentencias. En C tenemos tres formas principales de realizar iteraciones. La sentencia
while (<e>) <s> es seguramente la más utilizada. La sentencia, o grupo de sentencias <s> se
ejecuta mientras la evaluación de la expresión <e> sea verdadera.
long raiz ( long valor )
{
long r = 1;
while ( r * r <= valor )
r++;
return r;
}
Una variación de la sentencia while es: do <s> while ( <e> ); En ella la sentencia se ejecuta al
menos una vez, antes de que se evalúe la expresión condicional.
SETENCIA FOR
Otra sentencia iterativa, que permite inicializar los controles del bucle es la sentencia for ( <i>;
<e>; <p> ) <s>. La sentencia for se puede escribir también como:
<i>;
while ( <e> ) {
<s>;
<p>;
}
El ejemplo anterior se podría escribir como:
long raiz ( long valor )
{
long r;
for ( r = 1; r * r <= valor; r++ )
;
return r;
}
BREAK Y CONTINUE
Otras sentencias interesantes, aunque menos utilizadas son break y continue. break provoca que
se termine la ejecución de una iteración o para salir de la sentencia switch, como ya hemos visto.
En cambio, continue provoca que se comience una nueva iteración, evaluándose la expresión de
control. Veamos dos ejemplos:
void final_countdown (void)
{
int count = 10;
while ( count--> 1 )
{
if ( count == 4 )
start_engines();
if ( status() == WARNING )
break;
printf("%d ", count );
}
if ( count == 0 ){
launch();
printf("Shuttle launched\n");
}
else
{
printf("WARNING condition received.\n");
printf("Count held at T - %d\n", count );
}
}
d2 ()
{
int f;
for ( f = 1; f <= 50; f++ ) {
if ( f % 2 == 0 )
continue;
printf("%d",f );
}
}
DEFINICIÓN Y PROTOTIPOS DE FUNCIONES
Los programas sencillos, como los ejemplo planteados hasta ahora, normalmente no necesitan un
nivel de estructuración elevado. Pero cuando éstos crecen un poco necesitamos estructurarlos
adecuadamente para mantenerlos legibles, facilitar su mantenimiento y para poder reutilizar
ciertas porciones de código. El mecanismo C que nos permite esto son las funciones. Con los
compiladores, los fabricantes nos proporcionan un conjunto importante de funciones de librería.
A veces, nos puede interesar construir nuestras propias librerías. Ya hemos utilizado funciones,
pero veamos cómo debemos definirlas.
Los prototipos de funciones son una característica clave de la recomendación ANSI del C. Un
prototipo es una declaración que toma la forma:
tipo_resultado nombre_función ( tipo_parámetro nombre_parámetro ... );
int fact_i ( int v );
int mayor ( int a, int b );
int cero ( double a );
long raiz ( long valor );
void final_countdown ( void );
int main ( int argc, char **argv );
Observando el prototipo de una función podemos decir exactamente qué tipo de parámetros
necesita y que resultado devuelve. Si una función tiene como argumento void, quiere decir que no
tiene argumentos, al igual que si el resultado es void, no devuelve ningún valor.
En la vieja definición de Kernighan y Ritchie el tipo que devolvía una función se declaraba
únicamente si era distinto de int. Similarmente, los parámetros eran declarados en el cuerpo de la
función, en lugar de utilizar la lista de parámetros. Por ejemplo:
mayor ( a, b )
int a;
int b;
{
...
}
Las funciones al viejo estilo se compilan correctamente en muchos compiladores actuales. Por
contra, proporcionan menos información sobre sus parámetros y errores que afecten al tipo de
parámetros de llamada a las funciones no pueden ser detectados automáticamente. Por tanto, la
declaración de una función debe escribirse igual que su prototipo pero sin el punto y coma final.
El cuerpo de la función le sigue encerrado entre llaves.
En un programa que esté formado por distintas partes bien diferenciadas es conveniente utilizar
múltiples ficheros fuente. Cada fuente agrupa las funciones semejantes, como por ejemplo en un
compilador podríamos tener un fuente para el análisis léxico, otro para el sintáctico y otro para la
generación de código. Pero en un fuente necesitaremos funciones que se han definido en otro.
Para ello, escribiremos, un fichero de cabecera (header), que contendrá las declaraciones que
podemos necesitar en otros fuente. Así, en el fuente que implementa el analizador sintáctico
pondremos una línea #include "lexic.h". De esta forma al compilar el módulo sintáctico tendremos
todos los prototipos de las funciones del léxico y el compilador podrá detectar malas utilizaciones
de las funciones allí definidas.
CONSTRUCCIÓN DE TIPOS
Los datos del mundo real, normalmente no están formados por variables escalares de tipos los
tipos básicos. Por ejemplo, nos puede interesar saber cuántos módulos en C hemos escrito cada
semana, a lo largo del año. O también nos interesa tener los datos de cada planeta del Sistema
Solar, masa, posición, velocidad y aceleración, para un programa de simulación de la ley de
gravitación de Newton. Para resolver el primer caso, C nos permite declarar una variable que sea
de tipo vector. Para el segundo, podemos definir un registro para cada elemento.
Un vector es una porción de memoria que es utilizada para almacenar un grupo de elementos del
mismo tipo Un vector se declara: tipo nombre [tamaño];. Por ejemplo, int modulo[52];. Aquí
'modulo' es un vector de 52 elementos enteros.
main()
{
int f, modulo[52];
for ( f = 0; f< 52; f++ )
modulo[f] = 0;
...
}
Cada elemento de un vector es accedido mediante un número de índice y se comporta como una
variable del tipo base del vector. Los elementos de un vector son accedidos por índices que van
desde 0 hasta N-1 para un vector de N elementos. Los elementos de un vector pueden ser
inicializados en la misma declaración:
char vocal[5] = {'a', 'e', 'i', 'o', 'u' };
float n_Bode[5] = { 0.4, 0.7, 1, 1.6, 2.8 };
También podemos definir vectores multidimensionales. C no impone ninguna limitación al número
de dimensiones de un vector. Existe, en cambio, la limitación del tamaño de memoria que
podamos utilizar en nuestro ordenador. Por ejemplo, para la declaración de un vector
multidimensional podemos escribir:
int video[25][80][2];
El tamaño de la variable video es proporcional al tamaño del tipo int y al tamaño de cada
dimensión. Existe un operador C que nos permite obtener el tamaño de un tipo o de una variable.
Este es sizeof() y nos proporciona el tamaño en bytes.
if ( sizeof(video) == 80 * 25 * 2 * sizeof(int) )
printf("OK!\n");
else
printf("Algo no funciona.\n");
Un tipo vector muy utilizado es la cadena de caracteres (string). Si queremos asignar espacio para
un string podemos hacer:
char nombre[60], dirección[80];
Es un vector C pero con la particularidad de que el propio lenguaje utiliza un carácter especial
como marca de final de string. Así en un vector de caracteres de tamaño N podremos almacenar
una cadena de N-1 caracteres, cuyo último carácter estará en la posición N-2 y la marca de final
de string en la N-1. Veamos un ejemplo:
char servei[6] = "SCI";
La posición 0 contiene el carácter 'S'; la 1 el 'C'; la 2 el 'I'; la 3 el '\0', marca de final de string. El
resto de componentes no están definidas. En la inicialización de strings no se debe indicar el
final; ya lo hace el compilador. Para la manipulación de cadenas de caracteres ANSI proporciona
el fichero string.h que contiene las declaraciones de un conjunto de funciones proporcionadas con
la librería del compilador.
Un registro agrupa distintos tipos de datos en una misma estructura. Los registros son definidos
de la forma:
struct nombre{ lista de declaraciones };
Los campos de cada registro pueden ser tipos básicos u otros registros. Por ejemplo:
struct planeta {
struct 3D r, v, a;
double masa;
char nom[10];
};
struct 3D {
double x,y,z;
};
Los campos de cada registro son accesibles mediante el nombre del registro seguido de punto y el
nombre del campo, como por ejemplo venus.r.x = 1.0;. Cada campo se comporta como lo hace su
tipo básico. C no proporciona mecanismos de inicialización, ni copia de registros, por lo que debe
ser el programador el que los implemente.
A veces los datos se ajustan a series ordenadas en las cuales un elemento sigue, o precede, a otro.
Un caso típico son los días de la semana. Si se desea realizar iteraciones con los días de la semana
una forma es, por ejemplo, asignar un número a cada día con #define. C proporciona un
mecanismo compacto para realizar esto; son las enumeraciones. Una enumeración toma la forma:
enum nombre { lista de elementos };. Veamos un ejemplo:
void planning ( void )
{
enum diasemana {lunes, martes, miercoles,
jueves, viernes, sabado, domingo };
int dia;
for ( dia = lunes; dia <= viernes; dia++ )
trabajar(dia);
if ( dia == sabado )
salir();
}
A cada elemento de la enumeración se le asigna un valor consecutivo, comenzando por 0. Si se
desea que el valor asignado sea distinto se puede hacer de la siguiente forma:
enum puntos { t_6_25 = 3, t_zona = 2, t_libre = 1 };
Muchas veces es conveniente renombrar tipos de datos para que la escritura del programa se nos
haga más sencilla y la lectura también. Esto se puede conseguir con la palabra typedef. Con ella
damos un nombre a cierto tipo, o combinación de ellos.
typedef struct planeta PLANETA;
PLANETA mercurio, venus, tierra, marte;
Al igual que podemos inicializar las variables de tipos básicos en la misma declaración, también
lo podemos hacer con los registros. Los valores de cada campo de un registro van separados por
comas y encerrados entre llaves.
PLANETA mercurio = {{ 0.350, 0, 0 },
{ 0, 0, 0 },
{ 0, 0, 0 },
100,"Mercurio" };
CÁMBITO DE FUNCIONES Y VARIABLES.
El ámbito, o visibilidad, de una variable nos indica en qué lugares del programa está activa esa
variable. Hasta ahora, en los ejemplos que hemos visto, se han utilizado variables definidas en el
cuerpo de funciones. Estas variables se crean en la memoria del ordenador cuando se llama a la
función y se destruyen cuando la función termina de ejecutarse. Es necesario a veces, que una
variable tenga un valor que pueda ser accesible desde todas las funciones de un mismo fuente, e
incluso desde otros fuentes.
En C, el ámbito de las variables depende de dónde han sido declaradas y si se les ha aplicado
algún modificador. Una variable definida en una función es, por defecto, una variable local.
Esto es, que sólo existe y puede ser accedida dentro de la función. Para que una variable sea
visible desde una función cualquiera del mismo fuente debe declararse fuera de cualquier función.
Esta variable sólo será visible en las funciones definidas después de su declaración. Por esto, el
lugar más común para definir las variables globales es antes de la definición de ninguna función.
Por defecto, una variable global es visible desde otro fuente. Para definir que existe una variable
global que está definida en otro fuente tenemos que anteponer la palabra extern a su declaración.
Esta declaración únicamente indica al compilador que se hará referencia a una variable declarada
en un módulo distinto al que se compila.
Las variables locales llevan implícito el modificador auto. Este indica que se crean al inicio de la
ejecución de la función y se destruyen al final. En un programa sería muy ineficiente en términos
de almacenamiento que se crearan todas las variables al inicio de la ejecución. Por contra, en
algunos casos es deseable. Esto se consigue anteponiendo el modificador static a una variable
local. Si una función necesita una variable que únicamente sea accedida por la misma función y
que conserve su valor a través de sucesivas llamadas, es el caso adecuado para que sea declarada
local a la función con el modificador static. El modificador static se puede aplicar también a
variables globales. Una variable global es por defecto accesible desde cualquier fuente del
programa. Si, por cualquier motivo, se desea que una de estas variables no se visible desde otro
fuente se le debe aplicar el modificador static. Lo mismo ocurre con las funciones. Las funciones
definidas en un fuente son utilizables desde cualquier otro. En este caso conviene incluir los
prototipos de las funciones del otro fuente. Si no se desea que alguna función pueda ser llamada
desde fuera del fuente en la que está definida se le debe anteponer el modificador static.z
void contar ( void )
{
static long cuenta = 0;
cuenta++;
printf("Llamada%ld veces\n", cuenta );
}
Un modificador muy importante es const. Con él se pueden definir variables cuyo valor debe
permanecer constante durante toda la ejecución del programa. También se puede utilizar con
argumentos de funciones. En esta caso se indica que el argumento en cuestión es un parámetro y
su valor no debe ser modificado. Si al programar la función, modificamos ese parámetro, el
compilador nos indicará el error.
#define EULER 2.71828
const double pi = 3.14159;
double lcercle (const double r )
{
return 2.0 * pi * r;
}
double EXP ( const double x )
{
return pow (EULER, x );
}
double sinh (const double x )
{
return (exp(x) - exp(-x)) / 2.0;
}
Debemos fijarnos que en el ejemplo anterior pi es una variable, la cual no podemos modificar. Por
ello pi sólo puede aparecer en un único fuente. Si la definimos en varios, al linkar el programa se
nos generará un error por tener una variable duplicada. En el caso en que queramos acceder a ella
desde otro fuente, debemos declararla con el modificador extern.
Otro modificador utilizado algunas veces es el register. Este modificador es aplicable únicamente
a variables locales e indica al compilador que esta variable debe ser almacenada permanentemente
en un registro del procesador del ordenador. Este modificador es herencia de los viejos tiempos,
cuando las tecnologías de optimización de código no estaban muy desarrolladas y se debía indicar
qué variable era muy utilizada en la función. Hoy en día casi todos los compiladores realizan un
estudio de qué variables locales son las más adecuadas para ser almacenadas en registros, y las
asignan automáticamente. Con los compiladores modernos se puede dar el caso de que una
declaración register inadecuada disminuya la velocidad de ejecución de la función, en lugar de
aumentarla. Por ello, hoy en día, la utilización de este modificador está en desuso, hasta el punto
de que algunos compiladores lo ignoran. Se debe tener en cuenta que de una variable declarada
como register no se puede obtener su dirección, ya que está almacenada en un registro y no en
memoria.
PUNTEROS
Cada variable de un programa tiene una dirección en la memoria del ordenador. Esta dirección
indica la posición del primer byte que la variable ocupa. En el caso de una estructura es la
dirección del primer campo. En los ordenadores actuales la dirección de inicio se considera la
dirección baja de memoria. Como en cualquier caso las variables son almacenadas ordenadamente
y de una forma predecible, es posible acceder a estas y manipularlas mediante otra variables que
contenga su dirección. A este tipo de variables se les denomina punteros.
Los punteros C son el tipo más potente y seguramente la otra clave del éxito del lenguaje. La
primera ventaja que obtenemos de los punteros es la posibilidad que nos dan de poder tratar con
datos de un tamaño arbitrario sin tener que moverlos por la memoria. Esto puede ahorrar un
tiempo de computación muy importante en algunos tipos de aplicaciones. También permiten que una
función reciba y cambie el valor de una variable. Recordemos que todas las funciones C
únicamente aceptan parámetros por valor. Mediante un puntero a una variable podemos
modificarla indirectamente desde una función cualquiera.
Un puntero se declara de la forma: tipo *nombre;
float *pf;
PLANETA *pp;
char *pc;
Para manipular un puntero, como variable que es, se utiliza su nombre; pero para acceder a la
variable a la que apunta se le debe preceder de *. A este proceso se le llama indirección. Accedemos
indirectamente a una variable. Para trabajar con punteros existe un operador, &, que indica
'dirección de'. Con él se puede asignar a un puntero la dirección de una variable, o pasar como
parámetro a una función.
void prueba_puntero ( void ) {
long edad;
long *p;
p = &edad;
edad = 50;
printf("La edad es %ld\n", edad );
*p = *p / 2;
printf("La edad es %ld\n", edad );
}
void imprimir_string ( char string[] ) {
char *p;
for ( p = string; *p != '\0'; p++ )
imprimir_char(*p);
}
Definimos un vector de N_PLA componentes de tipo PLANETA. Este tipo está formado por un
registro. Vemos que en la función de inicialización del vector el puntero a la primera componente
se inicializa con el nombre del vector. Esto es una característica importante de C. La dirección de
la primera componente de un vector se puede direccionar con el nombre del vector. Esto es debido
a que en la memoria del ordenador, los distintos elementos están ordenados de forma ascendente.
Así, SSolar se puede utilizar como &SSolar[0]. A cada iteración llamamos a una función que nos
inicializará los datos de cada planeta. A esta función le pasamos como argumento el puntero a la
componente en curso para que, utilizando la notación ->, pueda asignar los valores adecuados a
cada campo del registro. Debemos fijarnos en el incremento del puntero de control de la iteración,
p++. Con los punteros se pueden realizar determinadas operaciones aritméticas aunque, a parte
del incremento y decremento, no son muy frecuentes. Cuando incrementamos un puntero el
compilador le suma la cantidad necesaria para que apunte al siguiente elemento de la memoria.
Debemos fijarnos que esto es aplicable sólo siempre que haya distintas variables o elementos
situados consecutivamente en la memoria, como ocurre con los vectores.
De forma similar se pueden utilizar funciones que tengan como parámetros punteros, para
cambiar el valor de una variable. Veamos:
void intercambio ( void ) {
int a, b;
a = 1;
b = 2;
swap( &a, &b );
printf(" a = %d b = %d\n", a, b );
}
void swap ( int *x, int *y ) {
int tmp;
tmp = *x;
*x = *y;
*y = tmp;
}
La sintaxis de C puede, a veces, provocar confusión. Se debe distinguir lo que es un prototipo de
una función de lo que es una declaración de una variable. Así mismo, un puntero a un vector de
punteros, etc...
int f1(); función que devuelve un entero
int *p1; puntero a entero
int *f2(); función que devuelve un puntero a entero
int (*pf)(int); puntero a función que toma y devuelve un entero
int (*pf2)(int *pi); puntero a función que toma un puntero a entero y devuelve un entero
int a[3]; vector de tres enteros
int *ap[3]; vector de tres punteros a entero
int *(ap[3]); vector de tres punteros a entero
int (*pa)[3]; puntero a vector de tres enteros
int (*apf[5])(int *pi); vector de 5 punteros a función que toman un puntero a entero y
devuelven un entero.
En los programas que se escriban se debe intentar evitar declaraciones complejas que dificulten la
legibilidad del programa. Una forma de conseguirlo es utilizando typedef para
redefinir/renombrar tipos.
typedef int *intptr;
typedef intptr (*fptr) ( intptr );
fptr f1, f2;
EL PREPROCESADOR.
El preprocesador es una parte del compilador que se ejecuta en primer lugar, cuando se compila
un fuente C y que realiza unas determinadas operaciones, independientes del propio lenguaje C.
Estas operaciones se realizan a nivel léxico y son la inclusión de otros textos en un punto del
fuente, realizar sustituciones o eliminar ciertas partes del fuente. Debemos tener en cuenta que el
preprocesador trabaja únicamente con el texto del fuente y no tiene en cuenta ningún aspecto
sintáctico ni semántico del lenguaje.
El control del preprocesador se realiza mediante determinadas directivas incluidas en el fuente.
Una directiva es una palabra que interpreta el preprocesador, que siempre va precedida por el
símbolo # y que está situada a principio de línea.
La directiva #define se utiliza para definir una macro. Las macros proporcionan principalmente
un mecanismo para la sustitución léxica. Una macro se define de la forma #define id secuencia.
Cada ocurrencia de id en el fuente es sustituida por secuencia. Puede definirse una macro sin una
secuencia de caracteres. Una macro se puede "indefinir" mediante la directiva #undef.
#define MSG01 "SCI-I-START: Starting system kernel\n"
#define MSG02 "SCI-I-STOP: Stopping system kernel\n"
void print_msg ( void ) {
if ( check_state() == START ) printf(MSG01);
else printf(MSG02);
}
El estado de una macro, si está definida o no, se puede comprobar mediante las directivas #ifdef
y #ifndef. Estas dos directivas se deben completar con una #endif y, el texto comprendido entre
ambas es procesado si la macro está definida. Todas las directivas deben ser completadas en el
mismo fuente y pueden ser anidadas.
#ifndef M_PI
#define M_PI 3.1415927
#endif
El preprocesador nos permite también incluir también otros ficheros en un fuente C. Esto se
consigue con la directiva #include. Esta puede tomar tres formas: #include , #include "fichero" y
#include macro. La diferencia entre la primera y la segunda está en el lugar dónde se buscará el
fichero en cuestión. Normalmente se utiliza la primera para ficheros proporcionados por la
librería del compilador y la segunda para ficheros creados por el programador.
FUNCIONES DE ENTRADA/SALIDA.
En este apartado y los siguientes vamos a ver algunas de las funciones más importantes que nos
proporcionan las librerías definidas por ANSI y su utilización. Como hemos visto hasta ahora, el
lenguaje C no proporciona ningún mecanismo de comunicación ni con el usuario ni con el sistema
operativo. Ello es realizado a través de las funciones de librería proporcionadas por el
compilador.
El fichero de declaraciones que normalmente más se utiliza es el stdio.h. Vamos a ver algunas
funciones definidas en él.
Una función que ya hemos utilizado y que, ella y sus variantes, es la más utilizadas para la
salida de información es printf. Esta permite dar formato y enviar datos a la salida estándar del
sistema operativo.
#include <stdio.h>
int printf ( const char *format [, argumentos, ...] );
Acepta un string de formato y cualquier número de argumentos. Estos argumentos se aplican a
cada uno de los especificadores de formato contenidos en format. Un especificador de formato
toma la forma %[flags][width][.prec][h|l] type. El tipo puede ser:
d, i Entero decimal con signo
O Entero octal sin signo
U Entero decimal sin signo
X Entero hexadecimal sin signo (en minúsculas)
X Entero hexadecimal sin signo (en mayúsculas)
F Coma flotante en la forma [-]dddd.dddd
E Coma flotante en la forma [-]d.dddd e[+/-]ddd
G Coma flotante según el valor
E Como e pero en mayúsculas
G Como g pero en mayúsculas
C Un carácter
S Cadena de caracteres terminada en '\0'
% Imprime el carácter %
P Puntero
Los flags pueden ser los caracteres:
+ Siempre se imprime el signo, tanto + como -
- Justifica a la izquierda el resultado, añadiendo espacios al final
blank Si es positivo, imprime un espacio en lugar de un signo +
# Especifica la forma alternativa
En el campo width se especifica la anchura mínima de la forma:
N Se imprimen al menos n caracteres.
0n Se imprimen al menos n caracteres y si la salida es menor, se anteponen ceros
* La lista de parámetros proporciona el valor
Hay dos modificadores de tamaño, para los tipos enteros:
L Imprime un entero long
H Imprime un entero short
Otra función similar a printf pero para la entrada de datos es scanf. Esta toma los datos de la
entrada estándar del sistema operativo. En este caso, la lista de argumentos debe estar formada
por punteros, que indican dónde depositar los valores.
#include <stdio.h>
int scanf ( const char *format [, argumentos, ...] );
Hay dos funciones que trabajan con strings. La primera lee un string de la entrada estándar y la
segunda lo imprime en el dispositivo de salida estándar.
#include <stdio.h>
char *gets ( char *s );
int puts ( char *s );
También hay funciones de lectura y escritura de caracteres individuales.
#include <stdio.h>
int getchar ( void );
int putchar ( int c );
Veamos, por ejemplo, un programa que copia la entrada estándar a la salida estándar del sistema
operativo, carácter a carácter.
#include <stdio.h>
main()
{
int c;
while ( (c = getchar()) != EOF )
putchar(c);
}
PROGRAMAS REALIZADOS
I. Programa 1
Código:
# include<stdio.h> # include<stdlib.h> int main(){ char op; float x,y,r; printf("Uso: calc dato1 operacion dato2\n"); printf("Inserte su operacion matematica\n"); scanf("%f %c %f",&x, &op, &y); if(op=='+'){
r=x+y; } else if(op=='-'){ r=x-y; } if(op=='x'){ r=x*y; } else if(op=='/'){ if(y==0){ printf("El resultado no esta definido\n"); } r=x/y; } printf("%f %c %f=%f\n",x, op, y, r); return(0); }
Código en pantalla:
Segundo código (llamdo a librería)
#include<stdio.h> #include<stdlib.h> int main(int argc, char**argv){
char op; char *dato1, *dato2, *operacion; float x,y,r; printf("orgc=%d\n", argc); if(argc!=4){ printf("Faltan argumentos\n"); exit(1); } dato1=(char*)malloc(4*sizeof(char)); dato2=(char*)malloc(sizeof(4)); operacion=(char*)malloc(sizeof(4)); dato1=argv[1]; operacion=argv[2]; dato2=argv[3]; x=atof(dato1); y=atof(dato2); op=operacion[0]; if(op=='+'){ r=x+y; } else if(op=='-'){ r=x-y; } if(op=='x'){ r=x*y; } else if(op=='/'){ if(y==0){ printf("El resultado no esta definido\n"); } r=x/y; } printf("%s %s %s=%f\n",dato1, operacion, dato2, r); //free(operacion); //libera memoria// //free(dato2); //libera memoria// //free(dato1); //libera memoria// return(0); }
Código en pantalla
Compilación
Compilación
II. Programa 2 Codigo
#include<stdio.h> int main() { int x,i,j,k; printf("los numeros pares e impares por medio de ciclos\n"); for(i=0;i<=4;i++) printf("%d\t", x=1+2*i); printf("\n"); for(j=0;j<=4;j++) printf("%d\t", k=2*j); return(0); }
Código en pantalla y compilación
III. Programa 3 Código :
#include<stdio.h> int main() { int x,i,j,k; printf("los numeros pares e impares por medio de ciclos\n"); for(i=0;i<=4;i++) printf("%d\t", x=1+2*i); printf("\n"); for(j=0;j<=4;j++) printf("%d\t", k=2*j); return(0); }
Código en pantalla
La compilación de veredicto
IV. Programa 4
Código
#include<stdio.h> int main() { int x[2][2]; int i,j,k; int y[2][2]; int r[2][2]; printf("Dame los valores de m1\n"); for(i=0;i<2;i++){ for(j=0;j<2;j++){ scanf("%d",&x[i][j]); } } printf("Dame los valores de m2\n"); for(i=0;i<2;i++){ for(j=0;j<2;j++){ scanf("%d",&y[i][j]); } } printf("Los valores de r son:\n"); for(i=0;i<2;i++){
for(j=0;j<2;j++){ r[i][j]=0; for(k=0;k<2;k++) { r[i][j]+=x[i][k]*y[k][j]; } } } for(i=0;i<2;i++){ for(j=0;j<2;j++){ printf("\n"); printf("%d\n", r[i][j]); } } return(0); }
Código en pantalla y compilación
V. Programa 5 Código
#include<stdio.h> #include<stdlib.h> int main()
{ int j,b,d; for(b=2;b<=10;b++){ for(d=1;d<=10;d++){ j=d*b; printf("el resultado es %d\n",j); } } return(0); }
Codigo en pantalla y compliacion.
VI. Programa 6 Código
#include<stdio.h> void suma(); int resta(); void multiplicacion(int op1,int op2); int division(int op1, int op2); int main() { int multiplicador, multiplicando, divisor, dividendo; printf("operaciones basicas\n"); suma(); printf("%d\n", resta());
printf("Inserte multiplicador y multiplicando\n"); scanf("%d %d", &multiplicador, &multiplicando); multiplicacion(multiplicador,multiplicando); printf("Inserte divisor y dividendo\n"); scanf("%d %d", &divisor, ÷ndo); printf("%d\n",division(divisor,dividendo)); return(0); } void suma() { int op1, op2; printf("Dame los dos digitos\n"); scanf("%d %d", &op1, &op2); printf("%d+%d=%d\n", op1, op2, op1+op2); } int division(int op1, int op2) { return op1/op2; } int resta() { int op1, op2; printf("Dame los dos digitos\n"); scanf("%d %d", &op1, &op2); return op1-op2; } void multiplicacion(int op1, int op2) { printf("%dX%d=%d\n", op1, op2, op1*op2); }
Codigo en pantalla y compilacion
VII. Programa 7 Código
#include<stdio.h> void agregaEspacio(int n); void agregaEnter(int n); void colocaSimbolo(char c); void lineaHorizontal(int n, char c); void portada (char *materia, char *trabajo, char *fecha); void imprimeCadena(char *cadena); int main() { int i=2; int j=4; int k=195; int l=1; int m=81; int n=80; agregaEnter(i); agregaEspacio(j); lineaHorizontal(k,'='); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(m); colocaSimbolo('*'); imprimeCadena("Instituto Politecnico Nacional"); colocaSimbolo('*'); agregaEspacio(n); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(m); colocaSimbolo('*'); portada("Una materia\t", "Practica 1\t", "Hoy"); colocaSimbolo('*'); agregaEspacio(74); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9');
agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j);
colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l);
agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9');
agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); colocaSimbolo('9'); agregaEspacio(193); colocaSimbolo('9'); agregaEnter(l); agregaEspacio(j); lineaHorizontal(k,'='); agregaEnter(l); return(0); } void agregaEspacio(int n) { int i; for(i=0 ;i<n;i++){ printf(" ");
} } void agregaEnter(int n){ int i; for(i=0 ;i<n;i++) { printf("\n"); } } void colocaSimbolo (char c){ printf("%c", c); } void lineaHorizontal(int n, char c) { int i; for(i=0 ;i<n;i++){ printf("%c",c); } } void imprimeCadena(char *cadena){ printf("%s", cadena); } void portada (char *materia, char *trabajo, char *fecha){ printf("%s", materia); printf("%s", trabajo); printf("%s", fecha); }
Código en pantalla y complicacion
VIII. Programa 8 Código de libreria
#include<stdio.h> #include<string.h> #define simbolo '+' #define margenX 4 #define margenY 2 void agregaEspacios(int n){ int i=0; for(i=0;i<n;i++){ printf(" "); } } void agregaEnters(int n){ int i=0; for(i=0;i<n;i++){ printf("\n"); } } void lineaSolida(int x){ int i; agregaEspacios(margenX); for(i=0;i<x;i++){ printf("%c", simbolo); } printf("\n"); } void lineaMediaVacia(int x){ int i=0; agregaEspacios(margenX); printf("%c", simbolo); agregaEspacios(x-2); printf("%c\n", simbolo); } void lineaMedia(int x,char*cadena){ int longitud;
agregaEspacios(margenX); printf("%c", simbolo); longitud=strlen(cadena); longitud=x-longitud-2; longitud/=2; agregaEspacios(longitud); printf("%s", cadena); agregaEspacios(longitud); printf("%c\n", simbolo); } void portada(int x,int y,char*programa,char*fecha){ int i; agregaEnters(margenY); i=x-(2*margenX); lineaSolida(i); lineaMediaVacia(i); lineaMedia(i,"Instituto Politecnico Nacional"); lineaMediaVacia(i); lineaMedia(i,"CET\"WALTER CROSS BUCHANAN\""); lineaMediaVacia(i); lineaMedia(i," Seminario de programacion"); lineaMediaVacia(i); lineaMedia(i,"Practica: "); lineaMediaVacia(i); lineaMedia(i,"Programa"); lineaMediaVacia(i); lineaMedia(i,programa); lineaMediaVacia(i); lineaMedia(i," Fecha"); lineaMediaVacia(i); lineaMedia(i,fecha); lineaMediaVacia(i); lineaSolida(i); }
Código de librería en pantalla
Codigo #include<stdio.h> #include<stdlib.h> #include "portada.h" void portada(int x,int y,char*materia,char*fecha); int main(){ portada(80,25,"Librerias y constantes","27/Feb/2014"); return 0; }
Código en pantalla
Compilación.
IX. Programa 9 Código
#include<stdio.h> #include<stdlib.h> #include "portada.h" void portada(int x,int y,char*materia,char*fecha); void porReferencia(int*contenido); void PorValor(int contenido); int main(){ int contenido=15; portada(80,25,"Apuntadores y paso de parametros"," 05/Mar/2014"); printf("\n\n para continuar presione enter \n"); getchar(); system("clear"); printf("Se imprimira el contenido de la variable %x\n",contenido); printf("se imprimira la direccion de la memoria en donde se guardo la variable %x\n", &contenido); printf("\n\n para continuar presione enter \n"); getchar();
system("clear"); printf("Demostracion de paso de parametros por valor\n"); printf("Antes de llamar a la funcion porValor: contenido=%d\n",contenido); PorValor(contenido); printf("Despues de llamar a la funcion porValor: contenido=%d\n",contenido); printf("\n\n\nDemostracion de paso de parametros por referencia\n"); printf("Antes de llamar a la funcion porReferencia: contenido=%d\n",contenido); porReferencia(&contenido); printf("Despues de llamar a la funcion porReferencia: contenido=%d\n",contenido); return 0; } void PorValor(int contenido){ contenido=9; printf("Dentro de la funcion porValor: contenido=%d\n",contenido); } void porReferencia(int*contenido){ *contenido=9; printf("Dentro de la funcion porReferencia: contenido=%d\n",*contenido); }
Código en pantalla
Complicación.
X. Programa 10 Código
#include<stdio.h> #include<stdlib.h> #include "portada.h" #define SALIR 3 #define ERROR 0 #define EXITO 1 void portada(int x, int y, char*materia,char*fecha); struct Tchica{ char*nombre; char*direccion; char*telefono;
}; void pausa(); void agregarChica(); void revisarAgenda(); int escribeArchivo(struct Tchica chica); struct Tchica leeArchivo(); void vaciaTeclado(); FILE*agenda; int main(){ int opcion; portada(80,25," Estructura y archivos"," 11/Mar/2014"); printf("\n\n Para continuar presione enter\n"); getchar(); system("clear"); do{ printf("\nAGENDA DE UNA PERSONA DE BUEN VER\n\tSeleccione una opcion\n"); printf("\t1 Revisar agenda\n"); printf("\t2 Agregar chica\n"); printf("\t3 Salir \n\t"); scanf("%d",&opcion); switch(opcion){ case 1:revisarAgenda(); pausa(); break; case 2:agregarChica(); pausa(); break; case 3:printf("\n Diviertete;), See you\n"); break; default:printf("\n Ajale, esa opcion no existe"); pausa(); break; } }while(opcion!=SALIR); return 0; } void agregarChica(){ struct Tchica chica; chica.nombre=(char*)malloc(sizeof(char)*50); chica.direccion=(char*)malloc(sizeof(char)*100); chica.telefono=(char*)malloc(sizeof(char)*20); vaciaTeclado(); printf("\n\tNombre de la chica:"); gets(chica.nombre); printf("\n\tDireccion de la chica:");
gets(chica.direccion); printf("\n\tTelefono de la chica:"); gets(chica.telefono); if(escribeArchivo(chica)==ERROR){ printf("\n\t No se pudo agregar a la chica\n"); } else{ printf("\n\tAgregaste otra chica a la lista!!!\n"); } } int escribeArchivo(struct Tchica chica){ agenda=fopen("agenda.csv","a+"); if(agenda==NULL){ printf("UPPS,tu agenda no se puede escribir\n"); return ERROR; } fprintf(agenda,"%s\n%s\n%s\n",chica.nombre,chica.direccion,chica.telefono); fclose(agenda); return EXITO; } void revisarAgenda(){ char temporal[20]; system("clear"); agenda=fopen("agenda.csv","r"); if(agenda==NULL){ printf("UPPS, tu agenda no se puede leer\n"); exit(1); } int numeroChicas=1; while(fgets(temporal,sizeof(temporal),agenda)!=NULL){ printf("Chica%d",numeroChicas); printf("\tNombre:%s\n",temporal); fgets(temporal,sizeof(temporal),agenda); printf("\tDireccion:%s\n",temporal); fgets(temporal,sizeof(temporal),agenda); printf("\tTelefono:%s\n\n",temporal); numeroChicas++; } printf("\nFin de Agenda\n"); vaciaTeclado();
} void pausa(){ vaciaTeclado(); printf("\n........Para continuar presiona enter\n"); getchar(); system("clear"); } void vaciaTeclado(){ char c; while((c=getchar())!='\n'&& c!=EOF); }
Codigo en pantalla
Complicación
(Enter)
Este menú es:
1. Revisar Agenda 2. Agregar chica 3. Salir
Opcion 1
Opcion 2
CAPITULO 4 HTML
CAMBIO A HTML5
HTML5 es la última evolución de la norma que define HTML. El término representa dos
conceptos diferentes
Se trata de una nueva versión del LENGUAJE HTML, con nuevos elementos, atributos y
comportamientos,
y un conjunto más amplio de tecnologías que permite a los sitios Web y las aplicaciones más
diversas y de gran alcance. Este conjunto se le llama HTML5 Y AMIGOS y, a menudo reducido
a sólo HTML5 .
Diseñado para ser utilizable por todos los desarrolladores de Open Web, esta referencia página
enlaza numerosos recursos sobre las tecnologías de HTML5, que se clasifican en varios grupos
según su función.
SEMÁNTICA : lo que le permite describir con mayor precisión cuál es su contenido.
CONECTIVIDAD : lo que le permite comunicarse con el servidor de formas nuevas e
innovadoras.
DESCONECTADO Y ALMACENAMIENTO : permite a páginas web almacenar datos,
localmente, en el lado del cliente y operar fuera de línea de manera más eficiente.
MULTIMEDIA : permite hacer vídeo y audio de ciudadanos de primera clase en la Web
abierta.
GRÁFICOS Y EFECTOS 2D/3D : permite una gama mucho más amplia de opciones de
presentación.
RENDIMIENTO E INTEGRACIÓN : proporcionar una mayor optimización de la velocidad
y un mejor uso del hardware del equipo.
DISPOSITIVO DE ACCESO : admite el uso de varios dispositivos de entrada y salida.
STYLING : deja a los autores escribir temas más sofisticados.
HTML5, en conjunto con CSS3, define los nuevos estándares de desarrollo web, tanto para
equipos de escritorio, como para dispositivos móviles y teléfonos celulares. Se abren las puertas
para nuevas opciones de diseño y dinámica de información.
Mucho se está hablando últimamente sobre esta nueva versión del conocido lenguaje HTML.
Para los que aún no lo saben y siempre temieron preguntar: HTML es el lenguaje de
programación madre y básico de todos los sitios web. Se trata de un conjunto de etiquetas que
sirven para dar formato a diferentes tipos de contenidos, sobre todo texto.
El HTML solamente formatea y muestra contenidos, y no tiene la capacidad de interactuar con
variables, bases de datos, etc.
Aún los sitios web más complejos, que utilizan grandes sistema de bases de datos y realizan
complejas tareas, envían al navegador (Internet Explorer, Chrome, etc.) puro código HTML.
HTML5 es una nueva versión de este lenguaje universal y, si bien aún está en fase de desarrollo,
ya podemos disfrutarlo en la mayoría de los navegadores. Google Chrome es pionero en soporte
HTML5 y es, actualmente, el navegador que brinda mayor soporte a esta versión de HTML.
¿Qué nos ofrece HTML?
Si bien representará una gran cantidad de mejoras, respecto a su versión anterior, éstas son las
más importantes:
Simplificación: El nuevo código ofrece nuevas formas, más sencillas, de especificar algunos
parámetros y piezas de código.
Contenido multimedia: Reproducción de audio y video sin necesidad de plug-ins
Animaciones: Posibilidad de mostrar contenidos de manera similar a Adobe Flash, pero
prescindiendo de este componente. HTML5 tendrá soporte nativo para una tecnología similar a
Flash.
Almacenamiento de datos del lado del cliente: Una diferencia fundamental entre las aplicaciones
de escritorio y web era la necesidad, de éstas últimas, de procesar la información y consultas en
bases de datos siempre en un servidor, haciendo que las aplicaciones sean más lentas y siempre
requeridas de una conexión a Internet constante. HTML5 permitirá almacenar y procesar
información en el cliente, convirtiendo a una aplicación web a una aplicación mucho más
parecida a una de escritorio.
Efectos y nueva versión de hojas de estilo CSS: La nueva versión de HTML acompañará a una
nueva versión de las hojas de estilo CSS, el CSS3. Se trata de nuevas posibilidades de formato,
como por ejemplo la implementación de sombras, bordes redondeados, etc.
Muchas de las cosas que, hasta ahora, solo podrían lograrse insertándolas como imágenes, podrán
realizarse con código. Esto no solo se traduce en una mejora de la velocidad y performance de un
sitio, sino también en nuevas e ilimitadas opciones de diseño.
Geo-locación: Los sitios web podrán saber la ubicación física de la persona que lo visita.
Tipografías no estándar: Hasta ahora, quizás la mayor limitación que enfrentábamos los
diseñadores era la imposibilidad de utilizar tipografías no-estándar en nuestros sitios web.
Prácticamente todos estaban limitados a aquellas que fueron impuestas por los navegadores
principales, como Arial, Times New Roman, Verdana, Tahoma, etc. ¡La implementación de
sistemas como Google Fonts hoy nos permite utilizar muchas más!
En resumen: HTML5 ofrecerá una serie de mejoras que permitirán el desarrollo de sitios web más
rápidos, más funcionales, y con nuevos diseños.
PROGRAMAS REALIZADOS
I. Programa 1 Código
<html> <Title>Primer archivo</Title> </head> <body> <p>Este es el texto que se muestra en<strong> pantalla</strong></p> </body> </html>
Codigo en pantalla y ejecución.
II. Programa 2 Código
<!DOCTYPE HTML><!--documento HTML5--> <html> <head> <Title>Primer archivo</Title> </head> <body> <header> <p class="logo"><a href="#">Logo</a></p> <nav><!--le dice la motor de busqueda que es el menu principal--> <ul> <li><a href="#">Menu 1</a></li> <li><a href="#">Menu 2</a></li> <li><a href="#">Menu 3</a></li> </ul> </header> <!--HTML5 elimina el uso de la etiqueta<div>de html 4--> <!--HTML5 al ser mas ordenado optimiza la lectura del sitio web--> <article><!--puede incluir articulos de sitio--> <header> <hgroup><!--permite agrupar 2 etiquetas--> <h1>Titulo 1</h1> <h2>Subtitulo de contenido 1</h2> </hgroup> </header> <section> <p>Este es el contenido de la seccion</p> </section> <aside><!--indica contenido que no es el principal del sitio--> <p>contenido tangencial del sitio</p> </aside> </article> <footer> <ul> <li><a href="#">Enlace 1</a></li> <li><a href="#">Enlace 2</a></li> <li><a href="#">Enlace 3</a></li> </ul> </footer> </body>
</html>
Codigo en pantalla y ejecución.
III. Programa 3 Código
<!DOCTYPE HTML><!--documento HTML5--> <html> <head> <body>
<p>Super<wbr>califragilistico<wbr>espialidoso<wbr></p><!--wbr no se cierra y permite agregar punto de ruptura en palabras grandes--> <p>Hoy es <time>2013-01-14</time></p> <p>El dia de<time datetime="2012-01-14"> ayer</time> me fui de farra</p> <!--la referencia de ayer para el buscador es 2012-01-14--> <!--los tipos de datos que reconoce el buscador son conocidos como microdatos y pueden obtenerse en schema.org/person--> <div itemscope itemtype="http://schema.org/Person/"> <p>Mi nombre es <span itemprop="name">Aquilino Cervantes</span></p><!--El buscador sabe que se trata de un nombre--> </div> <div itemscope itemtype="http://schema.org/Person/"> <p><span itemprop="streetAddress">Calle 608 unidad Aragon, Delegacion Gustavo A. Madero</span> <span itemprop="postalCode">06700</span></p><!--span organizador para hoja de estilos--> </div> </body> </head> </html>
Codigo en pantalla y ejecucion
Esta página a
IV. Programa 4 Código:
<!DOCTYPE HTML><!--documento HTML5--> <html> <head> <body> <video height="320" width="400" controls> <source src="elBaile.mp4"type="video/mp4"> <source src="elBaile.ogv"type="video/ogv"> <source src="elBaile.webm"type="video/webm"> Tu navegador no soporta el video, descarga uno como <a href="#">Google crome</a> </video> <audio controls><!--autoplay preload--> <source src="Duele.mp3"type="audio/mpeg"> <source src="Duele.ogg"type="audio/ogg"> <source src="Duele.wav"type="audio/wav"> </audio> </body> </head> </html>
Código en pantalla y ejecucion.
V. Programa 5
Codigo:
<!DOCTYPE html> <html> <head> <meta content="text/html; charset=utf-8"http-equiv="content-type"> <title>Hola html5</title> <style type="text/css"> body{ color:red; } nav{ color:green; } section{ color:brown; } article{ color:pink; } footer{ background-color:black; color:white; } aside{ background-color:#33ccff; margin-left:510px; } </style> </head> <body> <header>Header<br> <br> </header> <nav>Nav<br> <br> </nav> <section>Section<br> <br> <article>Article 1<br> </article> <article>Article 2</article> </section>
<br> <aside>Aside</aside> <br> <footer>Footer</footer> </body> </html>
Código en pantalla
Ejecución
VI. Programa 6
Código:
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>Mi segunda pagina con estilos</title> <link href="estilos/misEstilos.css" rel="stylesheet" type="text/css"> </head> <body> <h1>Mi segunda pagina web con estilos</h1><pre><p> Este texto aparecera tal y como esta escrito. <strong>sin etiqueta de salto de linea</strong> </p></pre> </body> </html> Código css body{ background-color:#FFCC66; font-family:Helvetica,sans-serif,Arial; font-size:2em; } h1{ color:blue; } p{ color:grey; } strong{ color:green; }
Código en pantalla y ejecución
Código en pantalla de librería css
VII. Programa 7 Código:
<!doctype html> <html><head> <meta charset="utf-8"> <title>otra pagina con estilos</title> <link href="estilos/misEstilos.css" rel="stylesheet"type="text/css"> </head> <body> <div id="pagina"> <header> <div class="tabla"> <div class="fila"> <div class="col_titulo"style="width:129px"> <img id="logoIPN"title="logoIPN"alt=""src="imagenes/ipn.png"> </div> <div class="col_titulo"style="width:490px"align="center"><pre> INSTITUTO POLITECNICO NACIONAL CET "Walter Cross Buchanan" Departamento de Unidades de Aprendizaje del Area Tecnologicas y de Especialidad </div></pre> <div class="col_titulo"style="width:142px">
<img id="logoCET"style="width:129px;height:150px;"title="logoCET"alt=""src="imagenes/cet.jpg"> </div></div> </header><br> <nav> <ul> <li><a href="#"class="welcome">Welcome</a></li> <li><a href="#"class="featured">Featured</a></li> <li><a href="#"class="people">People</a></li> <li><a href="#"class="music">Music</a></li> <li><a href="#"class="mixes">Mixes</a></li> <li><a href="#"class="videos">Videos</a></li> <li><a href="#"class="radio">Radio</a></li> </ul></nav><br><br> <section><br> <article> Elementos de la portada </article><br><br> </section><br> <div style="text-align:center;"> <footer>Redes de computo: Mantenimiento de hardware de red 2014</footer> </div> </div> </body> </html> Código Css #pagina{ margin-left:auto; margin-right:auto; width:800px; color:#660000; font-size:large; font-family:Calibri;} header{ border-top-color:#660000; border-right-color:#660000; border-bottom-color:#660000; border-left-color:#660000; border-top-width:medium; border-right-width:medium; border-bottom-width:medium; border-left-width:medium;
border-top-style:solid; border-right-style:solid; border-bottom-style:solid; border-left-style:solid;} div.tabla{ clear:none; overflow:auto;} div.fila{ clear:both;} div.col_titulo{ float:left; padding:5px; border-right-width:0px; border-left-width:0px; border-top-width:0px; border-bottom-width:1px;} nav{ color:#990000; border-top-width:thin; border-right-width:thin; border-bottom-width:thin; border-left-width:thin; border-top-color:#660000; border-right-color:#660000; border-bottom-color:#660000; border-left-color:#660000; border-top-style:solid; border-right-style:solid; border-bottom-style:solid; border-left-style:solid;} ul{ list-style-type:none; margin:0px; padding:0px; border-left-width:1px; border-left-style:solid; border-left-color:#ccc;} li{
display:inline;} a{ font-family:Arial,Helvetica,sans-serif; color:#000; text-decoration:none; font-size:0.9em; display:block; padding:6px; float:left; border-bottom-width:1px; border-bottom-style:solid; border-bottom-color:#CCC; background-color:#EAEAEA; border-top-width:1px; border-top-style:solid; border-top-color:#CCC; border-right-width:1px; border-right-style:solid; border-right-color:#CCC;} a:hover{ background-color:wheat; border-right-width:5px;} a.featured:hover{ background-color:black; color:white;} a.people:hover{ color:brown;} section{ color:#990000; left:15px; border-top-color:#660000; border-right-color:#660000; border-bottom-color:#660000; border-left-color:#660000; border-top-width:thin; border-right-width:thin; border-bottom-width:thin; border-left-width:thin; border-top-style:solid; border-right-style:solid; border-bottom-style:solid; border-left-style:solid; }
footer{ color:#990000; border-top-width:thin; border-right-width:thin; border-bottom-width:thin; border-left-width:thin; border-top-color:#660000; border-right-color:#660000; border-bottom-color:#660000; border-left-color:#660000; border-top-style:solid; border-right-style:solid; border-bottom-style:solid; border-left-style:solid;}
Codigo en pantalla
Ejecución
Codigo librería CSS
CAPITULO 5 JAVASCRIP
LENGUAJE JAVASCRIP
JavaScript es un lenguaje de programación que permite a los desarrolladores crear acciones en sus páginas web.JavaScript es un lenguaje que puede ser utilizado por profesionales y para quienes se inician en el desarrollo y diseño de sitios web. No requiere de compilación ya que el lenguaje funciona del lado del cliente, los navegadores son los encargados de interpretar estos códigos.
Muchos confunden el JavaScript con el Java pero ambos lenguajes son diferentes y tienes sus características singulares. JavaScript tiene la ventaja de ser incorporado en cualquier página web, puede ser ejecutado sin la necesidad de instalar otro programa para ser visualizado.
Java por su parte tiene como principal característica ser un lenguaje independiente de la plataforma. Se puede crear todo tipo de programa que puede ser ejecutado en cualquier ordenador del mercado: Linux, Windows, Apple, etc. Debido a sus características también es muy utilizado para internet.
Como síntesis se pude decir que JavaScript es un lenguaje interpretado, basado en prototipos, mientras que Java es un lenguaje más orientado a objetos.
es un lenguaje con muchas posibilidades, utilizado para crear pequeños programas que luego son insertados en una página web y en programas más grandes, orientados a objetos mucho más complejos. Con JavaScript podemos crear diferentes efectos e interactuar con nuestros usuarios.
Este lenguaje posee varias características, entre ellas podemos mencionar que es un lenguaje basado en acciones que posee menos restricciones. Además, es un lenguaje que utiliza Windows y sistemas X-Windows, gran parte de la programación en este lenguaje está centrada en describir objetos, escribir funciones que respondan a movimientos del mouse, aperturas, utilización de teclas, cargas de páginas entre otros.
Es necesario resaltar que hay dos tipos de JavaScript: por un lado está el que se ejecuta en el cliente, este es el JavaScript propiamente dicho, aunque técnicamente se denomina Navigator JavaScript. Pero también existe un JavaScript que se ejecuta en el servidor, es más reciente y se denomina LiveWire JavaScript.
PROGRAMAS REALIZADOS
I. Programa 1 Código:
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <link rel="stylesheet"type="text/css" href="estilos/estilo.css"> <script type="text/javascript"> function conquistar(){ var nombre,edad,respuesta; nombre=prompt("Hola!!!¿Cual es tu nombre?"); document.getElementById("respuesta").innerHTML="!!!Hola "+nombre+"!!!!"; edad=prompt("Te vez muy joven ¿Cuantos años tienes?"); if(edad<18){ /*si es menor de edad, ¡¡¡cuidado!!!*/ document.getElementById("respuesta").innerHTML=nombre+"!!! joven y hermosa, lindas cualidades!!!\n Cuidate mucho,bye"; } else{ document.getElementById("respuesta").innerHTML="Si o si,¿Verdad que si?"; respuesta=prompt("Guaauuuu, Luces estupendamente bien. ¿Te parece bien si nos encontramos nuevamente?"); if(respuesta=="si"||respuesta=="por supuesto") document.getElementById("respuesta").innerHTML="Es una cita "+nombre+" Guardare estos momentos hasta encontrarte. Bye"; else{ document.getElementById("respuesta").innerHTML="Esta bien "+ nombre +" Tal vez en otra ocacion pueda convencerte"; } } } </script>
<title>Aprendiz de seductor</title> </head> <body> <section> <p align="center"> <span id=titulo>Aprendiz de seductor</span><br> Si eres una chica linda, presiona el boton conquistar<br> <input type="button"onclick="conquistar()"value="conquistar"align="center"><br> <div align="center"id="respuesta"> </div> </p> </section> </body> </html> Código css: body{ margin-left:auto; margin-right:auto; width:800px; font-size:2em; font-family:calibri; background-color:#EBECE4; } #titulo{ font-size:3em; } Código en pantalla
Compilacion
II. Programa 2
Codigo
<!DOCTYPE HTML> <html> <head> <meta charset="utf-8"> <link rel="stylesheet"type="text/css"href="estilos/estilo.css"> <script type="text/javascript"> function sumar(){ var sumando1=parseFloat(prompt("insertar el sumando 1")); var sumando2=parseFloat(prompt("insertar el sumando 2")); var suma; suma=sumando1+sumando2; document.getElementById("respuesta").innerHTML="La suma es:"+suma; getchar(); } </script> <title>Prompt</title> </head> <body> <section> <p align="center"> <span id=titulo>Suma</span><br> Presione el boton, para realizar la suma<br> <input type="button"onclick="sumar()"value="sumar"align="center"> <div align="center"id="respuesta"> </div> </p> </section> </body> </html> Código css body{ margin-left:auto; margin-right:auto; width:800px; font-size:2em; font-family:calibri; background-color:#EBECE4; } #titulo{
font-size:3em; }
Código en pantalla
III. Programa 3 Codigo
<html> <div style="text-align: center;"> <body> <script type="text/javascript"> for (i = 1; i <= 6; i++){ document.write("<h" + i + ">Hola a todos " + i) document.write("</h" + i + ">") } </script> </div> </body> </html>
Codigo en pantalla
Compilacion.
IV. Programa 4 Código
<!DOCTYPE html> <html> <body> <script> document.write("<h1>Hola mundo!</h1><p>es un dia bonito</p>"); </script> </body> </html>
Codigo en pantalla
Compilacion
V. Programa 4 Codigo
div style="overflow: auto; width: 510px;"> <script>alert ('ups!!!')</script> <script>alert ('acabas de hacer el peor error de tu vida ')</script> <script>alert ('acabas de entrar a esta pagina que no te recomiendo')</script> <script>alert ('pero en fin jaja')</script> <script>alert ('ya me imagino como te debes sentir')</script> <script>alert ('aunque aun estamos comenzando ')</script> <script>alert ('cuando vayan pasando mas ventanas te daras un tiro en la cabeza')</script> <script>alert ('mmmmm')</script> <script>alert ('vamos por la 9!!')</script> <script>alert ('ahora la 10!')</script> <script>alert ('que no te gusta')</script> <script>alert ('que pena')</script> <script>alert ('ahora tendras que sufrir')</script> <script>alert ('que!!! ya te fastidiaste??')</script> <script>alert ('pero si apenas vamos por la quince ')</script> <script>alert ('pensaste que verias algo realmente genial verdad?')</script> <script>alert ('pues no es asi')</script> <script>alert ('que mas le podemos hacer')</script> <script>alert ('si cierras la ventana')</script> <script>alert ('eso seria una buena idea')</script> <script>alert ('upss!...')</script> <script>alert ('creo que no se puede ')</script> <script>alert ('jajajaja sufre')</script> <script>alert ('sabes porque hago esto')</script> <script>alert ('porque yo fui victima por pura curiosidad')</script> <script>alert ('y me paso lo mismo que a ti')</script> <script>alert ('estaba deseperado pero bueno')</script> <script>alert ('ya lo supere')</script> <script>alert ('jajaja')</script> <script>alert ('estaras furioso conmigo')</script> <script>alert ('no debiste entrar')</script> <script>alert ('ahora un ligero cuestionario')</script> <script>alert ('no un cuetionario, una afirmacion')</script> <script>alert ('a se me olvidaba presentarme')</script> <script>alert ('me llamo Roberto')</script> <script>alert ('y le voy a las chivas')</script> <script>alert ('y tu? todo bien con tu vida??')</script> <script>alert ('Tienes hermanas?')</script>
<script>alert ('me prestas una')</script> <script>alert ('espero que no este gorda')</script> <script>alert ('ni fea')</script> <script>alert ('ya fue mucha broma ')</script> <script>alert ('creo que aun no')</script> <script>alert ('no te desesperes te dare un tip')</script> <script>alert ('pero antes resuelveme esta preguna tengo una duda...')</script> <script>alert ('eres homosexual??')</script> <script>alert ('orale aceptaste')</script> <script>alert ('que dificil debe ser eso')</script> <script>alert ('yo no creo que seas homosexual')</script> <script>alert ('en verdad si eres homosexual??')</script> <script>alert ('por ultima vez')</script> <script>alert ('no creo que sea homosexual')</script> <script>alert ('que si lo eres')</script> <script>alert ('ya lo aceptaste muchas veces')</script> <script>alert ('si quieres te presento a alguien')</script> <script>alert ('se llama Agapito')</script> <script>alert ('jajaja ya estamos terminando')</script> <script>alert ('ohh si es cierto y por lo de el tip ')</script> <script>alert ('ahora si te lo digo')</script> <script>alert ('esto es facil')</script> <script>alert ('solo estabas apreado enter para avanzar mas rapido')</script> <script>alert ('pero bueno fuiste mi victima del dia')</script> <script>alert ('ya terminamos por fin!!')</script> <script>alert ('gracias por visitar a papa chivas!!')</script> <script>alert ('adiosiiiin!!!!')</script> <script> function flash() { if (control == 1) { window.status=yourwords; control=0; } else { window.status=""; control=1; } setTimeout("flash();",speed); } // --></script> <center> <p><img src="risa2.gif"></p> <p><img src="bebe.gif"></p> </center> </div>
Codigo en pantalla
Compilacion
VI. PROGRAMA #5 Código:
<html> <head> <script language='JavaScript' type='text/JavaScript'> //Made by 1st JavaScript Editor //http://www.yaldex.com first3=24; var fifteenth=0, sixteenth=0, seventeenth=0, eighteenth=0, nineteenth=1, twentieth=0, first2, second2;second3=first3+6; third3=first3+second3; fourth3=first3+second3+third3;fifth3=fourth3/third3*first3;sixth3=third3*first3/12*second3;seventh3=first3+second3/fifth3-16*fourth3; eighth3=sixth3*(first3-5)/third3+fourth3;ninth3=eighth3/seventh3+first3*third3-fourth3;tenth3=(ninth3+first3/third3*fourth3+second3*fifth3)/sixth3+eighth3-ninth3-1;eleventh3=Math.floor(tenth3) ;twelfth3=eleventh3-60; function third2(value){document.form1.fourth2.value=value; fifteenth=twelfth3,sixteenth =twelfth3,seventeenth =twelfth3,eighteenth=twelfth3; nineteenth=1;twentieth =twelfth3;} function fifth2(sixth2){first2=1; if(seventeenth || nineteenth){ seventeenth=twelfth3; nineteenth=twelfth3; second2=sixth2;}{ if(second2.indexOf(".")!=-1){ first2=twelfth3; }}} function fifteenth3(sixteenth3,seventeenth3){second2=document.form1.fourth2.value; if(seventeenth3=='.'){ fifth2('0'); if(first2==1){ second2+=seventeenth3; document.form1.fourth2.value=second2; twentieth=twelfth3; }} if(sixteenth3>=twelfth3&&sixteenth3<=9){ fifth2(''); if(second2==twelfth3&&first2==1)second2=''; second2+=sixteenth3; document.form1.fourth2.value=second2; twentieth=1;} if(seventeenth3=='-' || seventeenth3=='+' || seventeenth3=='/' || seventeenth3=='*'){ if(seventeenth)sixteenth=seventeenth3; else{ if(!eighteenth){ sixteenth=seventeenth3; fifteenth=second2; eighteenth=1; } else{ fifteenth=eval(fifteenth+sixteenth+second2); sixteenth=seventeenth3; document.form1.fourth2.value=fifteenth; } twentieth=twelfth3; seventeenth=1;}} if(seventeenth3=='1/x'){fifteenth=eval(1/second2);third2(fifteenth);} if(seventeenth3=='sqrt'){fifteenth=Math.sqrt(second2);third2(fifteenth);} if(seventeenth3=='exp'){fifteenth=Math.exp(second2);third2(fifteenth);} if(seventeenth3=='+/-')document.form1.fourth2.value=eval(-second2); if(seventeenth3=='=' && twentieth && sixteenth !='0')third2(eval(fifteenth+sixteenth+second2));
if(seventeenth3=='C')third2(twelfth3); if(document.form1.fourth2.value[0]=='.')document.form1.fourth2.value='0'+document.form1.fourth2.value;} </script> <title></title> </head> <body> <form name='form1'><TABLE bgcolor='#430086'><TR><TD><TABLE BORDER=1 cellspacing=5 cellpadding=0 bgcolor='red'><TR align=center><TD colspan=5> <input type='text' name='fourth2' value='0'></TD></TR><TR align=center><TD colspan=4><B><FONT COLOR='#FFFFFF'>Calculator</FONT></B></TD> <TD> <input type='Button' name='C' value=' C ' onclick="fifteenth3(11,'C')"></TD></TR><TR align=center><TD> <input type='Button' name='7' value=' 7 ' onclick="fifteenth3(7,'')"></TD><TD> <input type='Button' name='8' value=' 8 ' onclick="fifteenth3(8,'')"></TD><TD> <input type='Button' name='9' value=' 9 ' onclick="fifteenth3(9,'')"></TD><TD> <input type='Button' name='/' value=' / ' onclick="fifteenth3(11,'/')"></TD><TD> <input type='Button' name='sqrt' value='sqrt' onclick="fifteenth3(11,'sqrt')"></TD></TR><TR align=center><TD> <input type='Button' name='4' value=' 4 ' onclick="fifteenth3(4,'')"></TD><TD> <input type="Button" name="5" value=" 5 " onclick="fifteenth3(5,'')"></TD><TD><input type="Button" name="6" value=" 6 " onclick="fifteenth3(6,'')"></TD><TD> <input type="Button" name="*" value=" * " onclick="fifteenth3(11,'*')"></TD><TD> <input type="Button" name="exp" value="exp" onclick="fifteenth3(11,'exp')"></TD></TR><TR align=center><TD> <input type="Button" name="1" value=" 1 " onclick="fifteenth3(1,'')"></TD><TD> <input type="Button" name="2" value=" 2 " onclick="fifteenth3(2,'')"></TD><TD> <input type="Button" name="3" value=" 3 " onclick="fifteenth3(3,'')"></TD><TD> <input type="Button" name="-" value=" - " onclick="fifteenth3(11,'-')"></TD><TD> <input type="Button" name="1/x" value="1/x" onclick="fifteenth3(11,'1/x')"></TD></TR><TR align=center><TD> <input type="Button" name="0" value=" 0 " onclick="fifteenth3(0,'')"></TD><TD> <input type="Button" name="+/-" value="+/-" onclick="fifteenth3(11,'+/-')"></TD><TD> <input type="Button" name="." value=" , " onclick="fifteenth3(11,'.')"></TD><TD> <input type="Button" name="+" value=" + " onclick="fifteenth3(11,'+')"></TD><TD> <input type="Button" name="=" value=" = " onclick="fifteenth3(11,'=')"></TD></TR></TABLE></TD></TR></TABLE> </form> </body> </html>
Codigo en pantalla
Compilacion
VII. Programa 7 Codigo
<!DOCTYPE html> <html> <head> <meta content="text/html; charset=UTF-8"http-equiv="content-type"> <link rel="stylesheet"type="text/css"href="estilos/reloj.css"> <script type="text/javascript"src="scripts/relojAddEvent.js"></script> <title>Bucle opcional</title> </head> <body onload=mostrar()> <h1>Reloj digital</h1><pre><strong> Instrucciones:</strong>Para iniciar o detener la cuenta, presiona click sobre la etiqueta iniciar o detener el reloj. <strong><div id="Reloj">Iniciar reloj</div></strong> <span id="espacio"></span> </pre> </body> </html> Código css: body{ margin-left:auto; margin-right:auto; width:950px; font-size:2em; font-family:Calibri; background-color:#EBECE4; } h1, #Reloj, #espacio{ text-align:center; } Código js function mostrar(){ var enMarcha=0,paro; var tmp=document.getElementById('Reloj'); reloj(); tmp.addEventListener("click",function(){ if(enMarcha===0){
enMarcha=1; tmp.innerHTML="Detener Reloj"; paro=setInterval(reloj,1); } else{ enMarcha=0; tmp.innerHTML="Iniciar Reloj"; clearInterval(paro); } }); } function reloj(){ var h, hora, minutos, s, ms, tmp=document.getElementById('espacio'); h=new Date(); hora=h.getHours(); minutos=h.getMinutes(); ms=h.getMilliseconds(); s=h.getSeconds(); if(minutos<10) minutos='0'+minutos; if(s<10) s='0'+s; if(ms<10) ms='00'+ms; if(ms>10&&ms<100) ms='0'+ms; tmp.innerHTML=hora+"horas"+minutos+"minutos"+s+"segundos"+ms+"milisegundos"; }
Codigo en pantalla
Codigo de estilo en pantalla
Compilacion
CAPITULO 6PHP
LENGUAJE PHP
PHP (acrónimo recursivo de PHP: HYPERTEXT PREPROCESSOR) es un lenguaje de código abierto muy popular especialmente adecuado para el desarrollo web y que puede ser incrustado en HTML.
Bien, pero ¿qué significa realmente? Un ejemplo nos aclarará las cosas:
Ejemplo
< !DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Ejemplo</title>
</head>
<body>
<?php
echo "¡Hola, soy un script de PHP!";
?>
</body>
</html>
En lugar de usar muchos comandos para mostrar HTML (como en C o en Perl), las páginas de PHP contienen HTML con código incrustado que hace "algo" (en este caso, mostrar "¡Hola, soy un script de PHP!). El código de PHP está encerrado entre las etiquetas especiales de comienzo y final <?php y ?> que permiten entrar y salir del "modo PHP".
Lo que distingue a PHP de algo como JavaScript del lado del cliente es que el código es ejecutado en el servidor, generando HTML y enviándolo al cliente. El cliente recibirá el resultado de ejecutar el script, aunque no se sabría el código subyacente que era. El servidor web puede ser incluso configurado para que procese todos los ficheros HTML con PHP, por lo que no hay manera de que los usuarios puedan saber qué se tiene debajo de la manga.
Lo mejor de usar PHP es que es extremadamente simple para el principiante, pero a su vez ofrece muchas características avanzadas para los programadores profesionales. No sienta miedo de leer
la larga lista de características de PHP. En unas pocas horas podrá empezar a escribir sus primeros scripts.
Aunque el desarrollo de PHP está centrado en programación de scripts del lado del servidor, se puede utilizar para muchas otras cosas.
PHP se utiliza para generar páginas web dinámicas. Recordar que llamamos página estática a
aquella cuyos contenidos permanecen siempre igual, mientras que llamamos páginas dinámicas a
aquellas cuyo contenido no es el mismo siempre. Por ejemplo, los contenidos pueden cambiar en
base a los cambios que haya en una base de datos, de búsquedas o aportaciones de los usuarios,
etc.
El lenguaje PHP se procesa en servidores, que son potentes ordenadores con un software y
hardware especial. Cuando se escribe una dirección tipo
http://www.aprenderaprogramar.com/index.php en un navegador web como Internet Explorer,
Firefox o Chrome, ¿qué ocurre? Se envían los datos de la solicitud al servidor que los procesa,
reúne los datos (por eso decimos que es un proceso dinámico) y el servidor lo que devuelve es una
página HTML como si fuera estática.
El esquema es:
Petición de página web al servidor --> El servidor recibe la petición, reúne la información
necesaria consultando a bases de datos o a otras páginas webs, otros servidores, etc. --> El
servidor responde enviando una página web “normal” (estática) pero cuya creación ha sido
dinámica (realizando procesos de modo que la página web devuelta no siempre es igual).
En resumen:
Páginas estáticas: Petición --> Respuesta
Páginas dinámicas: Petición --> Procesado y preparación --> Respuesta
En un sitio dinámico, la información generalmente está contenida en una base de datos. Cada
vez que mostramos la página, como por ejemplo una página de noticas, buscamos en la base de
datos las últimas noticias que tenemos ingresadas para mostrar en el navegador del visitante.
Ahora bien, ¿cómo se consigue que la página vaya mostrando noticias nuevas? Simplemente
cargando las mismas en la base de datos, por ejemplo, a través de un formulario que rellena una
persona y que una vez relleno cuando pulsa “Enviar” implica que lo que haya escrito se guarde en
nuestra base de datos. De esta manera, cuando solicitamos la página web y el servidor consulte la
base de datos, encontrará esta nueva información y mostrará nuestra página de forma distinta a
como se veía anteriormente.
Por regla general este tipo de lenguaje suele ser utilizado para crear contenido dinámico y poder
interactuar con el usuario.
Veamos un ejemplo del contenido de una página web php similar al anterior, que habremos de
almacenar en un archivo que termina con la extensión .php y que contiene texto:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Ejemplo</title>
</head>
<body>
<?php
echo "Bienvenidos a aprenderaprogramar.com";
?>
</body>
</html>
Como podrás comprobar al igual que el anterior el contenido del archivo incluye código HTML y
en un momento dado aparece una etiqueta <?php que significa que ahí empieza el código PHP.
Por eso decimos que el código PHP está embebido (incluido) en código HTML.
Por tanto las páginas PHP contienen HTML con código PHP incluido en ellas para hacer "algo"
(en este caso, mostrar Bienvenidos a aprenderaprogramar.com. El código PHP está comprendido
entre etiquetas de comienzo y final especiales: <?php y ?>
Estas etiquetas especiales nos permitirán entrar y salir del "modo PHP". Le sirven al servidor
web para saber que tiene que interpretar el código incluido entre esas etiquetas como PHP.
Lo que distingue a PHP de JavaScript es que el código es ejecutado en el servidor, generando
HTML y enviándolo al cliente como si fuera una página web estática. El cliente recibirá los
resultados que el servidor devuelve después de interpretar el código PHP, sin ninguna posibilidad
de determinar qué código ha producido el resultado recibido. Es decir, a través de nuestro
navegador podríamos ver el código HTML, pero nunca el código PHP que dio lugar al resultado
HTML. El servidor web puede ser incluso configurado para que los usuarios no puedan saber si
estás o no utilizando PHP.
Lo mejor de usar PHP es que es extremadamente simple para el principiante, pero a su vez,
ofrece muchas características avanzadas para los programadores profesionales y más avanzados.
Con PHP puedes procesar la información de formularios, generar páginas con contenidos
dinámicos, o enviar y recibir cookies, entre muchas más cosas. PHP lo utilizan desde pequeñas
páginas web hasta grandes empresas. Muchas aplicaciones web están construidas usando PHP.
Podemos citar Joomla y Drupal (gestores de contenido de páginas web), osCommerce (tiendas on-
line para comercio electrónico), phpBB y SMF (sistemas de foros para páginas web), Moodle
(plataforma educativa para educación on-line), etc.
Entre las habilidades de PHP se incluye la creación de imágenes a partir de datos. Por ejemplo,
supongamos que tenemos una academia con 20 alumnos matriculados en un curso de informática,
50 alumnos matriculados en un curso de matemáticas y 30 alumnos matriculados en un curso de
química. Con PHP podemos generar automáticamente imágenes similares a esta:
PHP también puede utilizar y presentar resultados en otros estándares de datos o lenguajes
propios de los desarrollos web, como XHTML y cualquier otro tipo de ficheros XML. PHP puede
autogenerar éstos archivos y almacenarlos en el sistema de archivos en vez de presentarlos en la
pantalla, utilizando estos ficheros para generar contenido dinámico. Es decir, el contenido
dinámico puede surgir de otros sitios además de desde bases de datos.
También se puede interactuar con otros servidores usando cualquier protocolo. Por último, PHP
puede enlazarse con otros lenguajes muy potentes como Java.
DUMP
void var_dump ( mixed expresion [, mixed expresion [, ...]] )
Esta función despliega información estructurada sobre una o más expresiones que incluye sus
tipos y valores. Las matrices y los objetos son exploradas recursivamente con valores sangrados
para mostrar su estructura.
En PHP 5 todas las propiedades públicas, privadas y protegidas de los objetos serán devueltas en
la salida.
Sugerencia: Como con todo lo que presenta un resultado directamente en el navegador, se pueden
utilizar las funciones de control de salida para capturar el resultado de esta función y grabarlo -
por ejemplo - en una string.
BIBLIOGRAFÍA
http://es.wikipedia.org/?title=GNU/Linux
http://www.linux.org
https://www.slax.org/es/
http://en.wikipedia.org/wiki/Slax
http://www.desarrolloweb.com/articulos/2358.php
http://www.slideshare.net/elvin1202/lenguaje-de-programacion-de-alto-nivel
http://www.carlospes.com/minidiccionario/lenguaje_de_alto_nivel.php
http://parkeadores.angelfire.com/abstraccion2.htm
http://www.slideshare.net/Estefhany1/compiladores-interpretadores-y-lenguajes-de-bajo-medio-
y-alto-nivel
http://laurel.datsi.fi.upm.es/~ssoo/STR/Bajo_Nivel.pdf
http://www.geany.org
http://es.wikipedia.org/wiki/Geany
http://sliceoflinux.wordpress.com/2010/02/26/nano-sencillo-editor-de-textos-para-el-terminal/
http://www.monografias.com/trabajos4/lenguajec/lenguajec.shtml
http://www.slideshare.net/yesid19/elementos-basicos-del-lenguaje-c
http://www.monografias.com/trabajos7/html/html.shtml
http://wiki.cabal.mx/wiki/Lenguaje_Ensamblador_en_Linux
http://learnassembler.com
http://www.maestrosdelweb.com/editorial/¿que-es-javascript/
http://php.net/manual/es/langref.php
http://www.pablin.com.ar/computer/cursos/cursojs/js1.htm
