introducciÓn a la programaciÓn (008-2833) · 1.1 historia del computador 1.2 componentes del...
TRANSCRIPT
INTRODUCCIÓN A LA PROGRAMACIÓN (008-2833)
Unidad I: Introducción
1.1 Historia del Computador
1.2 Componentes del Computador
1.3 Términos Básicos
1.4 Sistemas de Numeración
Unidad II: Algoritmos
2.1 Pasos a seguir para la resolución de un problema
2.2 Definición y tipo de algoritmos
2.3 Diagramas de flujo
2.4 Variables
2.5 Estructuras de Control
Unidad III: Programación en Delphi
3.1 El entorno de desarrollo
3.2 Propiedades y eventos de los componentes en Delphi
3.3 Entrada y Salida
3.4 Tipos de Datos en Delphi
3.5 Operadores lógicos, aritméticos y relacionales
3.6 Programas secuenciales
Unidad IV: Control del programa
4.1 Instrucciones de transferencia de control
4.2 Vectores y matrices
4.3 Procedimientos y funciones.
Unidad V: Fundamentos avanzados de Programación en Delphi
5.1 Generalidades
5.2 Clases y Librería Interna.
5.3 Archivos y memoria permanente
Introducción a la Programación
2
TABLA DE CONTENIDO
Unidad I: Introducción
1.1 Historia de la Computación ........................................................................................... 4
1.1.1 La Computadora ............................................................................................................ 4
1.1.2 Prehistoria de la Computación ...................................................................................... 4
1.1.3 Generaciones de la Computadora.................................................................................. 5
1.2 Componentes del Computador ...................................................................................... 8
1.2.1 Hardware ....................................................................................................................... 8
1.2.2 Software ........................................................................................................................ 9
1.3 Términos Básicos ........................................................................................................ 11
1.4 Sistemas de Numeración ............................................................................................. 14
1.4.1 Sistema Binario ........................................................................................................... 14
1.4.2 Sistema Octal .............................................................................................................. 15
1.4.3 Sistema Hexadecimal .................................................................................................. 16
1.4.4 Conversiones entre Sistemas ....................................................................................... 17
Unidad II: Algoritmos
2.1 Pasos a seguir para la Resolución de un Problema ..................................................... 22
2.2 Definición y tipo de Algoritmos ................................................................................. 24
2.2.1 Medios de Expresión de un Algoritmo ....................................................................... 24
2.2.2 Pseudocódigo .............................................................................................................. 24
2.3 Diagramas de Flujos .................................................................................................... 26
2.3.1 Reglas para la construcción de un Diagrama de Flujo ................................................ 26
2.3.2 Simbología empleada en los Diagramas de Flujo ....................................................... 27
2.4 Variables ..................................................................................................................... 30
2.4.1 Operadores .................................................................................................................. 31
2.5 Estructuras de control .................................................................................................. 32
2.5.1 Estructuras de Control Selectivas................................................................................ 32
2.5.2 Estructuras de Control Iterativas ................................................................................. 37
Introducción a la Programación
3
Unidad III: Programación en Delphi
3.1 El entorno de desarrollo .............................................................................................. 45
3.1.1 La ventana principal .................................................................................................... 46
3.1.2 El inspector de objetos (object inspector) ................................................................... 46
3.1.3 El editor de código fuente ........................................................................................... 47
3.1.4 La ventana de programa (Forms) ................................................................................ 48
3.2 Propiedades y eventos de los componentes en Delphi ................................................ 48
3.2.1 Propiedades ................................................................................................................. 49
3.2.2 Eventos ........................................................................................................................ 50
3.3 Entrada y Salida .......................................................................................................... 50
3.3.1 Por consola .................................................................................................................. 51
3.3.2 Por formulario ............................................................................................................. 51
3.3.3 Métodos de conversión ............................................................................................... 53
3.4 Tipos de datos en Delphi ............................................................................................. 53
3.4.1 Declaración de variables en Delphi............................................................................. 54
3.5 Operadores lógicos, aritméticos y relacionales ........................................................... 55
3.1.1 Operadores aritméticos................................................................................................ 55
3.1.2 Expresiones y operadores relacionales........................................................................ 56
3.1.3 Expresiones y operadores lógicos ............................................................................... 57
3.1.4 Operadores de asignación y punto flotante ................................................................. 58
3.1.5 Precedencia de operadores .......................................................................................... 58
3.6 Programas secuenciales ............................................................................................... 58
Introducción a la Programación
4
UNIDAD I: INTRODUCCIÓN
1.1 Historia de la Computación
1.1.1 La Computadora
Es una colección de circuitos integrados y otros componentes relacionados capaz de efectuar
una secuencia de operaciones mediante un programa, de tal manera que recibe y procesa un
conjunto de datos de entrada para convertirlos en información útil.
1.1.2 Prehistoria de la Computación
Uno de los primeros dispositivos mecánicos para contar fue el ábaco, cuya historia se
remonta a las antiguas civilizaciones griega y romana, el cual tenía cuentas ensartadas en
varillas que, a su vez, estaban montadas en un marco rectangular. Al desplazar las cuentas
sobre las varillas, sus posiciones representaban valores determinados. Por supuesto, este
dispositivo no podía considerarse como una computadora, ya que carecía de un elemento
fundamental llamado programa.
Otros dispositivos mecánicos fueron la Pascalina, inventada por el francés Blaise
Pascal (1623 – 1662), y la máquina inventada por el alemán Gottfried Wilhelm Von Leibniz
(1646 – 1716), con las cuales los datos se representaban mediante las posiciones de los
engranajes, y los mismos se introducían manualmente estableciendo las posiciones finales de
la rueda, de forma similar a cómo se cuentan los kilómetros recorridos en el cuentakilómetros
de un automóvil.
En el siglo XIX Charles Babbage trabajaba en el proyecto de la “máquina de
diferencias”, es decir, aquella que realizaba una serie de sumas sucesivas, con la cual buscaba
solucionar el problema que implica la elaboración de tablas matemáticas ya que era una tarea
tediosa y propensa a errores. Sin embargo, en el año 1823 Charles Jaquard había inventado
un telar que podía reproducir patrones de tejidos leyendo la información codificada en
Introducción a la Programación
5
patrones de agujeros perforados en papel rígido. Esto sirvió de inspiración a Babbage para
que abandonase la máquina de diferencias y se dedicase a la “máquina analítica”, un
dispositivo que podría ser programado con tarjetas perforadas para efectuar cálculos con una
precisión de hasta 20 dígitos. Desafortunadamente, la tecnología de la época no bastaba para
hacer realidad sus ideas.
Unos 100 años después, concretamente en el año 1944, se construyó en la Universidad
de Harvard la MARK I, diseñada por un equipo encabezado por Howard E. Aiken, cuyo
funcionamiento estaba basado en dispositivos electromecánicos llamados relevadores.
En 1947 se construyó en la Universidad de Pensilvania la ENIAC (Electronic
Numerical Integrator And Calculator) por el equipo de diseño dirigido por John Mauchly y
John Eckert, la cual ocupaba todo un sótano de la universidad, tenía más de 18 mil tubos de
vacío, consumía 200 KW de energía y requería todo un sistema de aire acondicionado, la
cual tenía capacidad para realizar 5 mil operaciones aritméticas por segundo. Esta máquina
marcó el inicio de las generaciones de la computadora.
1.1.3 Generaciones de la Computadora
Se definen tomando en cuenta la forma en que fueron construidas, y la manera en que el ser
humano se comunica con ellas, además de las tecnologías empleadas.
1ª Generación: Tubos de Vacío (1947 – 1958)
• Utilizaban tubos de vacío para procesar la información.
• Empleaban tarjetas perforadas para realizar programas.
• La memoria principal consistía en un tambor magnético.
• Eran de un inmenso tamaño y gran peso.
• Costaban alrededor de US$ 10.000
• Surge el lenguaje máquina (código binario)
• Máquinas representativas: ENIAC y UNIVAC.
Introducción a la Programación
6
2ª Generación: Transistores (1958 – 1964)
• Uso de transistores para procesar la información.
• Reducción del tamaño y emisión de calor.
• Menor consumo eléctrico.
• Eran comercialmente accesibles.
• Las computadoras de ese período eran muy avanzadas para la época.
• Se define la programación de sistemas.
• Máquinas representativas: PHILCO 212 y UNIVAC M460.
3ª Generación: Circuitos Integrados (1964 – 1971)
• Uso de circuitos integrados (inventados en 1959) para procesar la información.
• Las computadoras son mucho más pequeñas y producen menos calor.
• Son enérgicamente más eficientes.
• Surge la multiprogramación.
• Máquina representativa: IBM 360.
4ª Generación: Microprocesadores (1971 – 1981)
• Uso del microprocesador (inventado en 1971) para procesar información.
• Desarrollo de las microcomputadoras y supercomputadoras.
• Reemplazo de las memorias con núcleos magnéticos por chips de silicio.
• Uso de los Sistemas Operativos.
5ª Generación: Inteligencia Artificial (1981 – 1990)
• Avances en el desarrollo del software y la robótica.
• Se crea la primera súper computadora con capacidad de proceso en paralelo.
• Desarrollo de sistemas expertos e inteligencia artificial.
• Uso del lenguaje natural.
• Almacenamiento en dispositivos magnético-ópticos extraíbles.
Introducción a la Programación
7
6ª Generación: Arquitectura Paralelo/Vectorial (1990 – 1999)
• Utilizan cientos de microprocesadores vectoriales trabajando en paralelo.
• Se crearon computadoras capaces de realizar millones de operaciones aritméticas en
punto flotante (teraflops) por segundo.
• Uso de las redes WWW y WAN para comunicar las computadoras entre sí.
• Uso de fibra óptica con gran ancho de banda y satélites para las comunicaciones.
• Desarrollo de tecnologías con inteligencia artificial distribuida, teoría de caos, holografía,
transistores ópticos, etc.
7ª Generación: LCD y Dispositivos Inteligentes (1999 – 2011)
• Aparecen las pantallas planas LCD2 y se hacen a un lado las de rayos catódicos.
• Se crea el Blu-Ray Disc, reemplazando al DVD.
• Almacenamiento de datos de alta densidad.
• Reemplazo de TV’s y equipos de sonido por dispositivos digitales.
• Aparecen las computadoras portátiles (laptops), dispositivos de bolsillo (PDA’s),
computadoras ópticas y cuánticas.
• Uso masivo de mensajería y correo electrónico.
• Tecnología de reconocimiento de voz y escritura, además de la realidad virtual y
dispositivos inalámbricos.
• Súper cómputo (procesadores paralelos masivos).
• Proliferación de los Smartphone y memorias compactas.
8ª Generación: Nuevas Tecnologías (2011 – Presente)
• Se inicia con el lanzamiento del Nintendo 3DS (25 de febrero de 2011), seguido por la
Sony PlayStation Vita (17 de diciembre de 2011).
• Empleo de tecnologías de última generación, como la estereoscopía y detección del
movimiento corporal.
• Mayor capacidad de almacenamiento en los dispositivos móviles.
• A futuro se plantea la desaparición de dispositivos físicos y de almacenamiento
mecánicos (disco duro, tarjeta madre), además del uso de la nanotecnología.
Introducción a la Programación
8
1.2 Componentes del Computador
Un computador está compuesto fundamentalmente por dos componentes básicos: Hardware
y software.
1.2.1 Hardware
Corresponde a todas las partes tangibles de la computadora, es decir, sus componentes
eléctricos, electrónicos, electromecánicos y mecánicos; cables, gabinetes o cajas, periféricos
de todo tipo y cualquier otro elemento físico involucrado.
Unidad Central de Procesamiento (CPU): Es el microprocesador. Está compuesta por la
ALU (Unidad Aritmético-Lógica), la cual realiza, como su nombre lo indica, operaciones
tanto lógicas como aritméticas, y la CU (Unidad de Control) que extrae las instrucciones de
memoria, las decodifica y las ejecuta.
Sus funciones principales son:
• Controlar y supervisar el sistema del ordenador.
• Desarrollar operaciones lógicas y controlar la secuencia de ejecución de instrucciones.
• Controlar el envío y recepción de datos de todas las unidades periféricas a la unidad de
memoria.
Memoria: Permite almacenar un conjunto de instrucciones. Se divide en:
• Principal: Permite almacenar temporalmente tanto los datos como los programas que la
CPU está procesando o va a procesar en algún momento.
o ROM (memoria de solo lectura): Viene pregrabada de fábrica con una serie de
programas. Se divide a su vez en las rutinas de arranque y de BIOS.
o RAM (memoria de acceso aleatorio): Es de lectoescritura, muy volátil, ya que
almacena los datos que están siendo utilizados por el usuario de la computadora.
Introducción a la Programación
9
• Secundaria: Conjunto de dispositivos y soportes de almacenamiento masivo de datos, el
cual es permanente pero de menor velocidad que la principal.
o Magnética: Disquete, disco duro, cinta magnética.
o Óptica: CD, DVD, Blu-Ray.
o Magneto-óptica: Disco Zip, Floptical, Minidisc.
o Estado Sólido o Flash: Pendrive, SD, MiniSD, MicroSD.
Periféricos: Aparato o dispositivo auxiliar e independiente conectado a la unidad central de
procesamiento de una computadora, el cual permite a la computadora comunicarse con el
exterior.
• Entrada: Teclado, ratón, touchpad, scanner, webcam, micrófono, cámara digital.
• Salida: Monitor, impresora, LED, videobeam, altavoz, auriculares, impresora 3D.
• Entrada/Salida: Pantalla táctil, impresora multifuncional, casco virtual.
• Almacenamiento: Tarjeta perforada, disco magnético, dispositivos ópticos, memoria
flash, almacenamiento de red (nube y servicio de alojamiento de archivos).
• Comunicación: Tarjetas de red, módems, routers, hubs, switchs, comunicación
inalámbrica (Bluetooth, Infrarrojo y WiFi).
Bus: Conjunto de cables y circuitos para la interconexión de los componentes, el cual permite
transferir datos entre los componentes de una o varias computadoras. La transferencia puede
ser en serie (bit a bit) y en paralelo (varios bits simultáneamente).
1.2.2 Software
Es el soporte lógico de una computadora digital, es decir, el conjunto de componentes lógicos
necesarios que hacen posible la realización de tareas específicas.
• Software Base o de Sistema: Permite que la información procesada por otros programas
se transformen en instrucciones entendibles por los componentes del hardware.
o Cargadores de programas: Cargan programas en memoria desde los ejecutables.
Ejemplo: execve() (para Unix).
Introducción a la Programación
10
o Sistema Operativo: Conjunto de programas que efectúan la gestión de los
procesos básicos de un sistema informático, permitiendo la normal ejecución del
resto de las operaciones. Ejemplo: Windows, Linux, Android, Macintosh.
o Controladores de Dispositivos: Permite al Sistema operativo interactuar con un
dispositivo periférico, proporcionando una interfaz para utilizar dicho dispositivo.
Ejemplo: Driver de impresora, micrófono o webcam.
o Herramientas de Programación: Son el compilador (traduce el código fuente de
un programa en lenguaje de alto nivel a bajo nivel o máquina), ensamblador
(traduce un fichero fuente en lenguaje ensamblador a código máquina), enlazador
(toma los primeros resultados de la compilación, los combina con algunas
funciones de librería y crea ejecutables), entre otros. Ejemplo: Las herramientas
del lenguaje Object Pascal (Delphi).
o Utilitarios: Son herramientas que realizan tareas de mantenimiento y soporte para
la construcción y ejecución de programas. Ejemplo: Antivirus, quemador.
o Entornos de Escritorio: Conjunto de programas que ofrecen una interacción
amigable y cómoda con la computadora. Éstos se relacionan con las GUI
(interfaces graficas de usuarios) que no son más que el grupo de imágenes y
objetos gráficos para representar la información y acciones disponibles de la
interfaz. Ejemplo: Aero, Windows Classic, Interfaz de Pantalla Táctil.
o Líneas de Comando: Son métodos que permiten a los usuarios dar instrucciones
a algún programa informático por medio de una línea de texto. Ejemplo: CMD de
Windows.
o BIOS: Sistema Básico de Entrada y Salida. Es un estándar de facto que define la
interfaz de firmware para computadoras IBM PC compatibles. Están integrados
en las Tarjetas Madres. Ejemplo: BIOS de la tarjeta madre DELL o INTEL.
o Hipervisor: El monitor de máquina virtual es una plataforma que permite aplicar
diversas técnicas de control de visualización para utilizar, al mismo tiempo,
distintos Sistemas Operativos. Ejemplo: Bluestacks (emulador Android para
Windows), o máquina virtual Windows para Linux.
o Bootloader: El gestor de arranque es un programa sencillo que no tiene la
totalidad de las funcionalidades de un Sistema Operativo, el cual está diseñado
Introducción a la Programación
11
exclusivamente para preparar todo lo que se necesita para iniciar un Sistema
Operativo. Ejemplo: Bootloader de Windows, el cual se carga durante la
visualización del logotipo.
• Software Productivo o de Aplicación: Son paquetes de órdenes e instrucciones que
permiten cumplir una función o tarea determinada.
o Paquetes integrados: Incluyen varias aplicaciones predefinidas, como un
procesador de texto, hojas de cálculo, manejador de base de datos, entre otros.
Ejemplo: Microsoft Office.
o Aplicación a medida: Ofrecen mayor potencial que los paquetes integrados,
debido a que los mismos fueron desarrollados para resolver un problema en
específico. Ejemplo: Sistema de citas para solicitud de pasaportes o manejo de
cuentas bancarias (aplicaciones web diseñadas para tal fin).
o App’s: Aplicación informática para dispositivos móviles o tablets con multitud
de funcionalidades. Ejemplo: Instagram.
1.3 Términos Básicos
• Bit: Su nombre se debe a la contracción de Binary Digit, es la mínima unidad de
información y puede ser un cero o un uno.
• Byte: Es la también conocida como el octeto, formada por ocho bits, que es la unidad
básica, las capacidades de almacenamiento en las computadoras se organiza en potencias
de dos, 16, 32, 64.
• Código Fuente: Es un conjunto de líneas de texto o instrucciones que debe seguir la
computadora para ejecutar dicho programa. Por tanto, en el código fuente de un programa
está descrito por completo su funcionamiento.
Introducción a la Programación
12
• Dato: Se refiere a cualquier cifra, letra o palabra que se suministra a la computadora
como entrada, la cual es almacenada en un determinado formato.
• Dispositivos de Entrada y Salida: En computación, entrada/salida, también abreviado
E/S o I/O (del original en inglés input/output), es la colección de interfaces que usan las
distintas unidades funcionales (subsistemas) de un sistema de procesamiento de
información para comunicarse unas con otras, o las señales (información) enviadas a
través de esas interfaces. Las entradas son las señales recibidas por la unidad, mientras
que las salidas son las señales enviadas por ésta.
• Firmware: Programa informático que establece la lógica de más bajo nivel que controla
los circuitos eléctricos de un dispositivo de cualquier tipo.
• Lenguaje de programación: Sistema de símbolos y reglas que permite la construcción
de programas con los que la computadora puede operar así como resolver problemas de
manera eficaz. Estos contienen un conjunto de instrucciones que permiten realizar
operaciones de entrada / salida, calculo, manipulación de textos, lógica / comparación y
almacenamiento / recuperación.
o Lenguaje Máquina: Son aquellos cuyas instrucciones son directamente
entendibles por la computadora y no necesitan traducción posterior para que la
CPU pueda comprender y ejecutar el programa. Las instrucciones en lenguaje
maquina se expresan en términos de la unidad de memoria más pequeña el bit
(dígito binario 0 ó 1).
o Lenguaje de Bajo Nivel (Ensamblador): En este lenguaje las instrucciones se
escriben en códigos alfabéticos conocidos como mnemotécnicos para las
operaciones y direcciones simbólicas.
o Lenguaje de Alto Nivel: Los lenguajes de programación de alto nivel (BASIC,
pascal, cobol, fortran, etc.) son aquellos en los que las instrucciones o sentencias
a la computadora son escritas con palabras similares a los lenguajes humanos (en
general en inglés), lo que facilita la escritura y comprensión del programa.
Introducción a la Programación
13
• Memoria Principal RAM: Acrónimo de Random Access Memory, (Memoria de Acceso
Aleatorio) es donde el ordenador guarda los datos que está utilizando en el momento
presente. Se llama de acceso aleatorio porque el procesador accede a la información que
está en la memoria en cualquier punto sin tener que acceder a la información anterior y
posterior. Esta memoria se actualiza constantemente mientras el ordenador está en uso y
que pierde sus datos cuando el ordenador se apaga. Presenta las siguientes unidades:
o BIT: puede tener valores de 0 y 1, es decir sistema binario
o NIBBLE: Cuarteto. 4 bits.
o BYTE: 8 bits.
o KILOBYTE (Kb): 210 bytes
o MEGABYTE (Mb): 210 Kilobyte = 220 Bytes
o GIGABYTE (Gb): 210 Megabyte = 230 Bytes
o TERABYTE (Tb): 210 Gigabyte = 240 Bytes
• Mnemotécnica: Es un sistema sencillo que emplea palabras que sustituyen el lenguaje
máquina, empleadas para recordar una secuencia de datos.
• Programa: Secuencia de instrucciones mediante las cuales se ejecutan diferentes
acciones de acuerdo con los datos que se estén procesando, el cual está desarrollado para
ser utilizado por la computadora.
• Programación: Es el proceso de diseñar, escribir, probar, depurar y mantener el código
fuente de programas computacionales. El código fuente es escrito en un lenguaje de
programación. El propósito de la programación es crear programas que exhiban un
comportamiento deseado. El proceso de escribir código requiere frecuentemente
conocimientos en varias áreas distintas, además del dominio del lenguaje a utilizar,
algoritmos especializados y lógica formal. Programar no involucra necesariamente otras
tareas tales como el análisis y diseño de la aplicación (pero si el diseño del código),
aunque si suelen estar fusionadas en el desarrollo de pequeñas aplicaciones.
Introducción a la Programación
14
1.4 Sistemas de Numeración
Es un conjunto de símbolos y reglas de generación que permiten construir todos los números
válidos. Se clasifican en:
• No-posicional: Los dígitos tienen el valor del símbolo utilizado, y no dependen de la
posición (columna) que ocupan.
• Posicional: También llamado ponderado, el valor de un dígito depende tanto del símbolo
utilizado como la ubicación que ocupa el número.
El sistema posicional más conocido es el decimal, en el cual las cantidades se
representan utilizando como base aritmética las potencias del número 10, constante de los
dígitos arábigos 0,1,2,3,4,5,6,7,8,9.
En el ámbito de la computación, se emplean los sistemas Binario, Octal y Hexadecimal.
1.4.1 Sistema Binario
Es aquel sistema de numeración en el que los números se representan utilizando solamente
las cifras 0 y 1. Éste es utilizado internamente por los circuitos digitales que conforman el
hardware de las computadoras actuales, ya que trabajan en dos niveles de voltaje (encendido:
1, apagado: 0).
Características:
• Es un sistema posicional que utiliza sólo dos símbolos para representar los números.
• Los agrupamientos se realizan de 2 en 2: Dos unidades de un orden forman la unidad del
orden superior siguiente.
• Utiliza una serie de múltiplos de bit que poseen nombre propio: Nibble o Cuarteto, Byte
u Octeto, Kilobyte (Kb), Megabyte (Mb), Gigabyte (Gb) y Terabyte (Tb).
Introducción a la Programación
15
Ventajas:
• La principal ventaja es su sencillez (en cuanto a hardware): Todos los sistemas
electrónicos pueden ser programados y se puede interpretar cualquier cosa, con los dígitos
binarios, ya que en un dispositivo es más fácil discernir entre dos estados (0 y 1) que entre
varios. Ejemplo: Una tarjeta perforada, donde hay un agujero es 1, donde no lo hay es 0.
• Sólo se necesitan 2 dígitos para su representación, lo que permite manejar información
más fácilmente.
• Se han desarrollado métodos matemáticos que permiten detectar y corregir fallos en la
transmisión de la información, cuando se cambian ceros por unos y viceversa.
Desventajas:
• Al ser basado en sólo dos dígitos, un número puede llegar a ser demasiado extenso e
incómodo de escribir. Por ejemplo, el número 1234 se escribe como 10011010010.
• No es un sistema que el ser humano esté acostumbrado a manejar.
Importancia: Este sistema tiene gran importancia porque ha permitido desarrollar
estructuras conceptuales que facilitan el diálogo entre el hombre y la computadora. Esto es
debido a que las memorias de los ordenadores constan de unidades cuyo estado de carga o
descarga es susceptible de ser representado con dos símbolos, como el 1 y el 0.
1.4.2 Sistema Octal
Es un sistema de numeración de base 8, siendo ésta una potencia exacta de 2 o de la
numeración binaria. Se representa mediante 8 dígitos diferentes, los cuales tienen,
naturalmente, un valor distinto dependiendo del lugar que ocupen, el cual viene determinado
por las potencias de 8.
Características:
• Tiene una base que es potencia de 2.
• Usa 8 dígitos: 0, 1, 2, 3, 4, 5, 6, 7.
• Relativamente tiene el mismo valor que en el sistema de numeración decimal.
Introducción a la Programación
16
• Cada una de sus cifras tiene posición relativa al punto decimal que, en caso de no
aparecer, se supone implícitamente a la izquierda del número.
Ventajas:
• No requiere utilizar otros símbolos diferentes de los dígitos.
• Por tener una base que es potencia exacta de 2, la conversión a binario o viceversa es
bastante simple.
Desventaja: Los sistemas de computación trabajan en bytes, y dado que un byte es un
conjunto de 8 dígitos, se opta por usar el sistema hexadecimal, por lo tanto la principal
desventaja del sistema octal es que, al existir el sistema hexadecimal, el uso de éste está
menos difundido.
Importancia: Su importancia radica en que, al ser una potencia exacta de 2, permite
representar cantidades de 3 a 6 bits utilizando 1 o 2 cifras octales correspondientes, en vez
de utilizar el sistema binario.
1.4.3 Sistema Hexadecimal
Es un sistema de numeración vinculado a la informática, ya que los ordenadores interpretan
los lenguajes de programación en bytes. A medida que los ordenadores aumentan su
capacidad de procesamiento, funcionan con múltiplos de 8, como 16 o 32.
Características:
• El sistema consta de 16 dígitos: Los números 0 al 9, y las letras A hasta F.
• Este sistema es abreviado como “Hex”.
• Utilizan el byte u octeto como unidad básica de memoria (en cada byte se pueden
representar hasta 128 valores diferentes).
• El uso actual del sistema está vinculado principalmente a la informática y lo que es
relacionado a la computación.
• Permite representar la misma línea de enteros a un byte.
Introducción a la Programación
17
Ventajas:
• La conversión entre binario y hexadecimal es tan sencilla como en el caso del octal. La
única diferencia es que los bits se reúnen en grupos de 4.
• El byte es la unidad de memoria más usada por los ordenadores y agrupan 8 bits:
o Para codificar un número de 8 bits se requieren 2 dígitos en hexadecimal.
o Para codificar una palabra de 16 bits, se requieren 4 dígitos Hex.
o Para codificar una palabra de 32 bits, se requieren 8 dígitos Hex, etc.
• Se pueden representar cantidades numéricas grandes en cifras más pequeñas, lo cual
facilita el uso del código ASCII y el PIN de los Blackberry, por ejemplo.
Desventaja: Al utilizar 16 dígitos puede ser bastante confuso (en especial cuando se usan las
letras).
Importancia: Permite la lectura de ciertos códigos informáticos y facilitan el procesamiento
en los ordenadores, ya que este sistema se utiliza universalmente para representar cantidades
fuera de una unidad digital.
1.4.4 Conversiones entre Sistemas
Se trata de la transformación del valor en un sistema al equivalente en otro. En este caso se
pueden dar tres escenarios:
Decimal a sistema potencia de 2: Si se trata de un número entero, se debe dividir dicho
número entre la base en la que se desea convertir (2, 8 o 16) y repetir el proceso con los
cocientes obtenidos hasta que el resultado sea menor a la base. Luego se unen los restos
obtenidos en el orden inverso a la división, encabezados por el último cociente, y con ello se
obtendrá el equivalente en el sistema deseado (desde otra perspectiva, se realizan divisiones
sucesivas hasta que el resultado sea 0, y luego se ordenan desde el último resto obtenido).
Cabe destacar que tales divisiones deben ser enteras, además si se trabaja con el sistema Hex
y el resto es mayor a 9, el mismo se deberá reemplazar por cualquiera de estas letras: A (10),
B (11), C (12), D (13), E (14) o F (15).
Introducción a la Programación
18
Ejemplo 1.1: (174)10 → ( ? )2
174 2
0 87 2 R: 10101110
1 43 2
1 21 2
1 10 2
0 5 2
1 2 2
0 1
Ejemplo 1.2: (9888)10 → ( ? )16
9888 16
9 618 16 R: 26A0
10 38 16
6 2 16
2 0
En el caso de los números fraccionarios, éstos se multiplican por la base en la que se
desea convertir, y se toma la parte entera del resultado, repitiendo el proceso con la parte
fraccionaria hasta que el resultado sea un número entero o hasta obtener suficientes
decimales, colocándose el resultado en el orden en que se extrajeron los dígitos.
Ejemplo 1.3: (0,90625)10 → ( ? )2
0,90625 × 2 = 1,8125
0,81250 × 2 = 1, 6250
0,62500 × 2 = 1,2500
0,25000 × 2 = 0,5000
0,50000 × 2 = 1,0000
Respuesta: 0,11101
Introducción a la Programación
19
Si hay números con parte entera y fraccionaria, se resuelven ambas partes de la forma
antes explicada. Por ejemplo, si se desea convertir el número (174,90625)10 a binario, se
realizan los procedimientos anteriores para obtener: (10101110,11101)2
Sistema potencia de 2 a decimal: En este caso se emplea el “teorema fundamental de la
numeración”, el cual dice que el valor en el sistema decimal de una cantidad expresada en
otro sistema cualquiera, viene dado por la fórmula:
…𝑋4 × 𝐵4 + 𝑋3 × 𝐵3 + 𝑋2 × 𝐵2 + 𝑋1 × 𝐵1 + 𝑋0 × 𝐵0 + 𝑋−1 × 𝐵−1 + 𝑋−2 × 𝐵−2…
O lo que es lo mismo:
…𝑋4 × 𝐵4 + 𝑋3 × 𝐵3 + 𝑋2 × 𝐵2 + 𝑋1 × 𝐵 + 𝑋0 +𝑋−1𝐵
+𝑋−2𝐵2
…
Donde X es un dígito del número a convertir, y B es la base original. Cuando el
subíndice es negativo hace referencia a los decimales de una fracción, siendo la posición 0 el
dígito más a derecha de la parte entera del número.
Ejemplo 1.4: (3221,03)8 → ( ? )10
3 × 83 + 2 × 82 + 2 × 81 + 1 × 80 + 0 × 8−1 + 3 × 8−2
3 × 512 + 2 × 64 + 2 × 8 + 1 × 1 +0
8+
3
64
1536 + 128 + 16 + 1 + 0 + 0,46875 = 𝟏𝟔𝟖𝟏, 𝟎𝟒𝟔𝟖𝟕𝟓
Entre sistemas potencia de 2: Este tipo de conversiones son mucho más sencillas, ya que
todos los sistemas involucrados comparten una misma base (2). La diferencia entre ellas
radica en la cantidad de bits necesarios para construir un dígito es el sistema deseado. Esto
se deduce del exponente asociado a la base, de tal forma que: Binario = 21, donde 1 indica
que se trabaja con 1 bit; Octal = 23 (3 bits construyen un dígito octal); y Hexadecimal = 24
(se necesitan 4 bits para construir un número Hex).
Para mayor facilidad en las conversiones, a continuación se muestran 2 tablas con los
números binarios versus su equivalente octal o hexadecimal:
Introducción a la Programación
20
Bin 000 001 010 011 100 101 110 111
Octal 0 1 2 3 4 5 6 7
Bin 0000 0001 0010 0011 0100 0101 0110 0111
Hex 0 1 2 3 4 5 6 7
Bin 1000 1001 1010 1011 1100 1101 1110 1111
Hex 8 9 A B C D E F
Si se desea convertir un número octal o hexadecimal en binario, se debe reemplazar
cada dígito por 3 o 4 bits (según el caso) de acuerdo a la tabla. De ser necesario, se eliminan
los ceros más a la izquierda (enteros) o derecha (decimales) del número, ya que éstos no
tienen ningún valor.
Ejemplo 1.5: (276,634)8 → ( ? )2
Octal 2 7 6 6 3 4
Bin 010 111 110 110 011 100
Respuesta: 010111110,110011100 = 10111110,1100111
Si por el contrario se desea convertir un número decimal a octal o hexadecimal, se
empieza a contar desde la coma la cantidad de bits necesaria (3: octal; 4: hexadecimal),
dirigiéndose a la izquierda para calcular los dígitos enteros que se requieren para construir el
número, y de la coma a la derecha cuando se trata de los números de punto flotante. De ser
necesario, se completa con ceros a la izquierda (enteros) o derecha (fraccionarios)
Ejemplo 1.6: (1101011,001101)2 → ( ? )16
0110 1011 0011 0100
Bin 0110 1011 0011 0100 Respuesta:
6B,34 Hex 6 B 3 4
Introducción a la Programación
21
Por su parte, no existe ninguna conversión directa entre octal y hexadecimal, sino que
la misma es transitiva, ya que requiere pasar primero por el sistema binario. Para ello, se
toma el número original y se convierte a binario, y el número resultante se convierte a la base
deseada.
Ejemplo 1.7: (ABC01)16 → ( ? )8
Se convierte primero a binario
Hex A B C 0 1
Bin 1010 1011 1100 0000 0001
Resultado parcial: 10101011110000000001
Ahora, el binario resultante se convierte a octal
Bin 010 101 011 110 000 000 001
Octal 2 5 3 6 0 0 1
Resultado final: 2536001
Introducción a la Programación
22
UNIDAD II: ALGORITMOS
2.1 Pasos a seguir para la Resolución de un Problema
Consiste en el proceso que, a partir de la descripción de un problema, expresado
habitualmente en lenguaje natural y en términos propios del dominio del problema, permite
desarrollar un programa para resolver dicho problema, llevándose a cabo los siguientes pasos:
a. Análisis previo del problema: Se debe analizar el funcionamiento del problema antes
de realizar cualquier algoritmo.
b. Definición de los requerimientos: Se identifican cuáles son las entradas y cuáles son las
salidas.
c. Identificación de los módulos: En este paso, se proponen las opciones de resolución,
identificando los procesos que serán necesarios para transformar los datos de entrada a
salidas. Es aquí donde el programador debe aprovechar su creatividad para escoger la
mejor solución.
d. Diseño del algoritmo: Se definen los pasos a seguir para la resolución del problema,
utilizando las herramientas adecuadas para tal fin (diagrama de flujo, pseudocódigo, etc.)
e. Desarrollo de la solución: Es la codificación. Se debe realizar en un lenguaje de
programación.
f. Ejecución y validación del programa: Se prueban distintas entradas para verificar que
el programa funciona de forma óptima.
Ejemplo 2.1: Sumar dos números enteros positivos y mostrar el resultado.
• Análisis previo del problema: Es un ejercicio matemático que consiste en una simple
suma de dos números enteros (sin decimales) mayores a cero. En este caso sólo se
requiere la operación suma y algún mecanismo para asegurar que los números sean
positivos.
• Definición de los requerimientos: Se deducen del mismo problema, teniéndose dos
valores como entrada (A y B), y como salida es la suma de los números (C).
Introducción a la Programación
23
• Identificación de los módulos: Se tiene el módulo de suma (C = A + B), y la validación
de las entradas (que sean positivas), lo que se logra con las condiciones A>0 y B>0.
• Diseño del algoritmo: Para este caso, se usará el pseudocódigo (estilo Pascal) que se
muestra a continuación:
procedimiento suma
inicio
leer entrada A;
leer entrada B;
si A es mayor a 0 y B es mayor a 0 entonces
establecer el valor de C como C ← A + B;
escribir salida C;
fin_si;
fin;
• Desarrollo de la solución: Aquí se emplea el lenguaje Object Pascal (Delphi):
procedure suma
begin
Read(A);
Read(B);
if (A>0) and (B>0) then
begin
C := A + B;
WriteLn(C);
end;
end;
• Ejecución y validación del programa: En esta ocasión se identifican dos casos posibles:
o Cuando A y B son positivos, se debe mostrar a C
o Cuando alguno de los números sea negativo o 0, no debe haber salida alguna.
Considerando esos casos, se presenta la siguiente tabla de pruebas:
Prueba Entradas Salida
1 A = -5 B = -4 C = 9
2 A = -5 B = -4 -
3 A = -5 B = -4 -
4 A = -5 B = -4 -
Si el programa ejecuta las salidas dadas, el mismo estará operando en forma exitosa.
Introducción a la Programación
24
2.2 Definición y tipo de Algoritmos
La palabra Algoritmo deriva del griego y latín dixit algorithmus, ésta a su vez de la
traducción en latín de la palabra árabe Alkhowuarizmi, nombre de un matemático y
astrónomo persa que vivió entre los años 780 y 850 D.C., quien escribió un tratado sobre
manipulación de números y ecuaciones en el siglo IX. Se trata de un conjunto finito de
instrucciones o reglas bien definidas y ordenadas que permiten resolver algún problema,
usadas directa e indirectamente en un sistema informático para llevar a cabo una tarea dada,
mediante pasos sucesivos, no ambiguos y, de ser posible, muy eficientes de forma tal que no
generan dudas a quien deba realizar dicha actividad.
2.2.1 Medios de Expresión de un Algoritmo
• Descripción de alto nivel: Se establece el problema, se selecciona un modelo
matemático y se explica de manera verbal, quizás con ilustraciones, pero omitiendo
detalles.
• Descripción formal: Por medio de un pseudocódigo.
• Implementación: Por medio de un lenguaje de programación.
2.2.2 Pseudocódigo
El pseudocódigo (falso lenguaje) es una descripción de alto nivel, compacta e informal, del
principio operativo de un programa informático. Éste utiliza las convenciones estructurales
de un lenguaje de programación verdadero, pero está diseñado para la lectura humana en
lugar de la lectura en máquina, y con independencia de cualquier otro lenguaje de
programación.
Sintaxis
En la actualidad, el pseudocódigo no obedece a las reglas de sintaxis de ningún idioma en
particular, por lo que no es de forma estándar sistemática pero, en caso de que se quiera
Introducción a la Programación
25
ejecutar, se debe llevar a forma tipo para que no genere ningún mensaje de error. Por lo
general se omiten las declaraciones de variables, a veces las llamadas a funciones, e incluso
los bloques de códigos (o código contenido dentro de un ciclo) pueden ser reemplazados por
una sentencia de una línea en lenguaje natural.
Dependiendo del escritor, el pseudocódigo puede variar mucho en su estilo, yendo
desde una imitación casi exacta de un lenguaje de programación real, en un extremo, hasta
al acercarse a una descripción en prosa del formato. Por ejemplo, el ejercicio mostrado en el
punto anterior (ejemplo 2.1) fue realizado empleando un pseudocódigo estilo Pascal, pues es
el más cercano al Delphi, sin embargo éste puede ser representado en otros estilos, como
FORTRAN y C:
Estilo FORTRAN
programa suma
leer entrada A
leer entrada B
si A es mayor a 0 y B es mayor a 0
establecer el valor de C como C = A + B
escribir salida C
fin_si
fin
Estilo C
función suma {
leer entrada A;
leer entrada B;
si A es mayor a 0 y B es mayor a 0 {
establecer el valor de C como C = A + B;
escribir salida C;
}
}
Ventajas
• Es mucho más fácil de entender que el propio código en lenguaje de programación
convencional.
Introducción a la Programación
26
• Se trata de una descripción eficiente y con un entorno independiente de los principios
fundamentales de un algoritmo.
• Permite mejorar la calidad de solución de un problema.
• Si se siguen las reglas de indentación (tabulado), se pueden observar claramente los
niveles de la estructura del problema.
• Es ideal para principiantes en programación, ya que éstos están más cerca de codificar en
un lenguaje determinado que aquellos que se inician en esta modalidad con diagramas de
flujo.
2.3 Diagramas de Flujos
Un diagrama de flujo es la descripción gráfica de los algoritmos, usualmente pequeños,
debido a que abarcan mucho espacio y su construcción puede resultar ser muy laboriosa. Se
basa en la utilización de diversos símbolos para representar operaciones específicas, los
cuales se conectan por medio de flechas para indicar la secuencia de operación, y éstos se
someten a una normalización para la elaboración de un diagrama que debe ajustarse a un
patrón previamente definido.
Los diagramas de flujo son importantes para el diseñador porque ayudan a definir,
formular, analizar y solucionar problemas por medio de una representación pictórica de los
pasos de un proceso. En otras palabras, esta forma de interpretación ayuda al análisis y
comprensión del sistema, ya que permite conocer el objetivo de un proyecto, acción o fin.
2.3.1 Reglas para la construcción de un Diagrama de Flujo
• Debe indicar claramente dónde inicia y dónde culmina el programa.
• Cualquier camino de un diagrama de flujo debe llevar a la terminal o fin.
• Organizar los símbolos de tal forma que deben seguir visualmente el flujo de arriba abajo
e izquierda a derecha (como la lectura de un libro).
• En la medida de lo posible, colocar el diagrama en el centro de la hoja.
Introducción a la Programación
27
• Los símbolos dentro del diagrama de flujo se unen con flechas que indican la dirección
del flujo.
• Las líneas de flujo solamente pueden ser horizontales o verticales, nunca diagonales.
• No se deben cruzar las líneas de flujo, en tal caso se utilizarían conectores (pero evitar el
abuso de ellos).
• No deben quedar líneas de flujo sin conectar.
• Las líneas deben ser sólidas, no punteadas.
• No fraccionar el diagrama de flujo, salvo que se usen subprogramas.
• Todo texto escrito dentro de un símbolo debe ser legible y preciso, evitando el uso de
muchas palabras.
• No usar lenguaje de programación dentro de los símbolos.
• Sólo puede haber una entrada a los símbolos, salvo si se trata de un conector o un ciclo
(esta norma no es restrictiva, pues algunos autores permiten la entrada de más de un flujo,
sin importar el símbolo empleado).
• Sólo puede haber una salida de los símbolos, excepto las decisiones, las cuales deben
tener como mínimo 2 salidas.
• Debe haber consistencia en el uso de los símbolos, ya que hay instrucciones que pueden
ser representadas por varios de ellos (por ejemplo, la salida por pantalla).
2.3.2 Simbología empleada en los Diagramas de Flujo
Símbolo Nombre Descripción
Indicador de Flujo Indica el sentido de la ejecución de operaciones.
Terminal
Inicio y Fin de un Programa. También puede
representar una parada o interrupción programada
que sea necesaria realizar dentro del mismo.
Entrada/Salida
Estándar
Cualquier tipo de instrucción de datos en la memoria
desde los periféricos o registro de información
procesada en los mismos (se usa comúnmente como
entrada de datos).
Entrada Manual Representa el ingreso de datos por medio del teclado.
Introducción a la Programación
28
Símbolo Nombre Descripción
Salida Impresa
Es utilizado para representar la salida de información
por medio de la impresora.
Salida en Pantalla
Es utilizado para representar la salida o mostrar la
información por medio del monitor o pantalla.
Proceso
Cualquier tipo de operación que pueda originar
cambios en el valor de una variable.
Conector
Representa el enlace de actividades con otras dentro
de un procedimiento. A veces se utiliza para la unión
de varios flujos.
Página Siguiente
Es utilizado para enlazar dos partes de un diagrama
de flujo que no se encuentren en la misma página.
Decisión
Son operaciones lógicas o comparaciones de datos,
es decir, formula una pregunta o cuestión.
Iteración
Plantea instrucciones que se repiten un número
controlado de veces.
Archivo Temporal
Almacena temporalmente un documento por un
breve período de tiempo.
Archivo
Permanente Guarda un documento de forma permanente.
Base de Datos
Representa el guardado de datos en tablas diseñadas
para tal fin.
Subprograma
Representa la llamada a funciones o procesos
predefinidos.
Comentario Se usa para la documentación del algoritmo.
Ejemplo 2.2: Tomar el pseudocódigo del ejemplo 2.1 y elaborar su diagrama de flujo.
En este caso, se tiene lo siguiente:
• Dos entradas (A y B): Se puede usar tanto el símbolo de entrada/salida estándar como
el de entrada manual (para este ejemplo se utilizará el segundo)
• Una condición con respuesta positiva: Se usa el símbolo de decisión. Este símbolo tiene
2 salidas, una positiva y una negativa. Sólo se utilizará la positiva (la negativa igual
Introducción a la Programación
29
deberá ser conectada, pero no tendrá ninguna instrucción asociada). Esto se conoce como
condicional simple, lo cual será tratado con más detalle en el tema 2.5.
• Una operación suma: Se usa el símbolo de proceso.
• Una salida: Se puede usar el símbolo de entrada y salida estándar, salida impresa o
salida por pantalla (aquí se utilizará el último).
Tomando en cuenta las normas establecidas, se tiene el siguiente diagrama de flujo:
Nótese que se han añadido comentarios para colocar algunas notas sobre el algoritmo.
Esto resulta muy útil, pues al realizar una consulta posterior el programador podrá conocer
ciertas características o acotaciones que, de otra forma, serían difícil de interpretar.
Igualmente hay que resaltar la presencia del conector, ya que mejora el aspecto visual del
algoritmo. Se podría haber realizado la unión del flujo negativo de la condición directamente
sobre la flecha que va al terminal fin, ya que esto es igualmente válido (con esto se evitarían
usar conectores innecesariamente).
inicio
A
B
A>0
Y B>0
C ← A + B
C
fin
Sí
No
Ambas variables
son enteras
El valor de C se
muestra en pantalla
Introducción a la Programación
30
2.4 Variables
La variable es una posición de memoria donde se puede almacenar un valor para uso de un
programa, ya sea entero, número real, carácter, entre otros. Este valor es temporal, pues puede
ser reemplazado por otro a medida que se van ejecutando las instrucciones.
Por su parte están las constantes, cuyo valor es invariable durante la ejecución del
algoritmo. En ambos casos se requiere del uso de un identificador, el cual consiste en una
secuencia de caracteres alfanuméricos que permite asignar un nombre (preferiblemente
significativo) al referido espacio de memoria, ya que de no hacerlo se requeriría conocer la
dirección específica de la variable o constante, lo cual resulta muy complicado. Este nombre
o identificador se sujeta a las reglas que existen en el lenguaje, sin embargo, existen
observaciones que son comunes para cada lenguaje:
• Puede ir formado por una o más letras, o en combinación con números.
• Siempre deberán comenzar con una letra.
• No se permite el uso de caracteres especiales, excepto el “_” y el “@”.
• Preferiblemente, que sea mnemotécnico.
• No puede ser una palabra reservada del lenguaje (se trata en este caso de un
identificador predefinido que tiene un significado especial, no pudiéndose usar como
nombre de variable, a menos que sea precedido por el carácter “@”.
Las variables (o constantes) pueden ser:
• Numéricas: Almacenan sólo números.
o Acumuladora: Es aquella que se incrementa en forma no definida por la suma o
producto con otro valor a dicho campo. Su valor inicial suele ser 0 (suma) o 1
(producto).
• Alfanuméricas: Almacenan cualquier carácter.
• Lógicas: Almacenan los estados verdadero y falso.
• Compuestas: Combinación de varias variables de uno o más tipos.
Introducción a la Programación
31
2.4.1 Operadores
El operador es el símbolo utilizado en matemáticas o computación para indicar la operación
que se realiza entre los elementos que une o la relación que existe entre ellos.
• Aritméticos: +, –, *, / (DIV), MOD, ^. El operador módulo permite obtener el resto de
una división, por lo tanto se trata de un operador entero.
• Relacionales: <, ≤, >, ≥, =, < > (≠). La combinación de identificadores y/o expresiones
aritméticas enlazados a través de operadores relacionales se conoce como expresión
relacional.
• Lógicos: AND (Y), OR (O), NOT (NO) (!). La combinación de expresiones relacionales
conectadas por operadores lógicos se llama expresión lógica.
o El operador AND sólo retorna verdadero si ambas relaciones son verdaderas,
caso contrario retorna falso.
o El operador OR sólo retorna falso si ambas relaciones son falsas, caso contrario
retorna verdadero.
o El operador NOT retorna verdadero si el operando es falso, y viceversa.
Precedencia de Operadores
La siguiente tabla determina el orden de ejecución de los operadores, ordenados desde el más
hasta el menos prioritario:
Categoría Operador Ejemplo de Uso
Acceso a datos ( ), [ ], . a * (b + c)
Signo +, – -5
Negación NOT (NO o !) NOT(k>f)
Aritméticos *, / (o DIV), ^ 6*4 x MOD y
+, – 3 + 2
Relacionales <, ≤, >, ≥ rel1 < rel2
=, < > (≠) rel3 < > rel4
Lógicos AND (Y) b<c AND d>e
OR (O) b<c OR d>e
Asignación ← v ← 1
Introducción a la Programación
32
2.5 Estructuras de control
En un algoritmo, por lo general, las instrucciones son ejecutadas una después de la otra, en
el orden en que aparecen escritas. Esto se conoce como ejecución secuencial. Sin embargo,
hay ocasiones en que se requiere que ciertas condiciones se verifiquen y se tomen decisiones
de acuerdo a éstas, es decir, realizar acciones específicas que bien pudieran cambiar la
secuencia de ejecución de un programa o algoritmo. Esto se conoce como transferencia de
control, la cual puede realizarse mediante el uso de estructuras de selección o iterativas.
2.5.1 Estructuras de Control Selectivas
El control de decisión abarca desde verificar condiciones muy simples hasta estructuras muy
complejas, tomando decisiones basadas en ellas, lo que permite elegir la dirección del flujo
de información. Aquí existen tres estructuras de selección, a saber:
• Condicional Simple: Estructura de una sola selección. Ejecuta una acción si la respuesta
a la pregunta planteada es verdadera. Caso contrario, la ignora.
• Condicional Doble: Ejecuta una acción si la respuesta a la pregunta es verdadera, de ser
falsa ejecuta una acción distinta.
• Selección Múltiple: Ejecuta una entre muchas acciones diferentes, dependiendo del
valor de una expresión.
Condicional Simple
Consiste en una estructura de selección empleada para elegir si se ejecuta o no una acción.
Su funcionamiento es simple: Se evalúa una condición, si es verdadera ejecuta un código, si
es falsa, continúa con el algoritmo.
Introducción a la Programación
33
Diagrama de Flujo Pseudocódigo
…
si condición entonces
instrucciones;
fin_si
…
El ejercicio mostrado en el tema 2.3.2 (ejemplo 2.2) es una clara representación de una
estructura condicional simple.
Condicional Doble
Esta estructura de doble selección permite elegir entre dos opciones distintas: Ejecuta una
acción si la condición es verdadera o ejecuta una acción diferente si la condición es falsa.
Diagrama de Flujo Pseudocódigo
…
si condición entonces
instruc_si
sino
instruc_no;
fin_si
…
Nótese que antes del “sino” no se coloca el “;”
Ejemplo 2.3: Leer una calificación e indicar si el alumno está aprobado o reprobado.
variables
nota: entero;
procedimiento definitiva
inicio
leer entrada nota;
si nota es mayor o igual a 5 entonces
escribir salida 'aprobado'
sino
escribir salida 'reprobado';
fin_si;
fin;
instrucciones condición Sí
No
No Sí condición
instruc_si instruc_no
Introducción a la Programación
34
Como pudo observarse en el ejemplo, en esta oportunidad se realizan 2 acciones
distintas, dependiendo de la condición: Si el resultado es verdadero, se imprime la palabra
“aprobado”, de lo contrario se imprime “reprobado”. Es de resaltar que ambas acciones
son excluyentes entre sí, es decir, si se ejecuta una de ellas no puede ejecutarse la otra.
Condicional Múltiple
Prueba una variable o expresión por separado contra cada uno de los valores que puede
asumir, ya sea constantes o relaciones, lo que conduce a tomar distintas acciones.
Diagrama de Flujo Pseudocódigo
…
caso variable o expresión de
respA: instr_a;
respB: instr_b;
… respZ: instr_z
sino
instr_no;
fin_caso
…
inicio
nota
nota≥0
'aprobado'
fin
Sí No
nota es una
variable entera
'reprobado'
respA
var o exp
respB respZ
No
Sí
instr_a instr_no instr_b instr_z
…
…
Introducción a la Programación
35
Aquí pueden observarse varios aspectos:
• La condición a evaluar puede ser una variable, constante o expresiones algebraicas.
Sin embargo, el uso de expresiones relacionales en una selección múltiple puede verse
limitado por el lenguaje (por ejemplo, en Object Pascal está permitido, pero en C no).
• Se puede reemplazar la instrucción “caso variable o expresión de” por “según sea
variable o expresión hacer”, y el “sino” por “por defecto”. Esto queda a elección del
programador (pero se debe mantener la consistencia).
• La instrucción negativa es una sentencia por defecto, la cual se ejecuta si no se
cumplen los casos planteados. Sin embargo, ésta puede ser omitida.
Ejemplo 2.4: Modificar el ejercicio anterior para que el algoritmo indique si el alumno está
aprobado, va a reparación, o está reprobado.
En este caso, se tienen 2 opciones válidas (cuando la nota es mayor o igual a 5; y cuando
es mayor o igual a 2), y al no cumplirse ninguna de las anteriores, el alumno queda
automáticamente reprobado. Entonces, el algoritmo queda de la siguiente manera:
inicio
nota
nota
'aprobado'
fin
Sí
No
nota es una
variable entera
'reprobado' 'reparación'
nota≥5 nota≥2
Introducción a la Programación
36
variables
nota: entero;
procedimiento definitiva_2
inicio
leer entrada nota;
caso nota de
nota es mayor a 5: escribir salida 'aprobado'
nota es mayor a 2: escribir salida 'reparación'
sino
escribir salida 'reprobado';
fin_caso;
fin;
Estructuras Anidadas
Son aquellas que se encuentran dentro de otras estructuras de control. Por supuesto, se debe
tener cuidado con los niveles de anidamiento para no elaborar un algoritmo tan confuso.
Ejemplo 2.5: Modificar el algoritmo anterior para que emplee estructuras anidadas.
inicio
nota
nota≥5
'aprobado'
fin
Sí No
nota es una
variable entera
'reprobado' 'reparación'
nota≥2 Sí No
Esta estructura
está anidada
Introducción a la Programación
37
variables
nota: entero;
procedimiento definitiva_3
inicio
leer entrada nota;
si nota es mayor a 5 entonces
escribir salida 'aprobado'
sino
si nota es mayor a 2 entonces
escribir salida 'reparación'
sino
escribir salida 'reprobado';
fin_si;
fin_si;
fin;
Aquí se puede observar que existe una estructura de control doble dentro de otra. Esto
resulta útil cuando existen relaciones que involucren al menos 3 posibles respuestas, ya que
los operadores en programación son de tipo binario (es decir, de la forma operando1 –
operador – operando2), lo que implica que solamente se puede elegir entre 2 alternativas,
pudiéndose de esta forma realizar el descarte entre pares de opciones. Otra forma de hacerlo
es emplear la estructura caso, anteriormente explicada, e incluso se pueden jugar con
operadores lógicos para reducir el número de alternativas posibles.
2.5.2 Estructuras de Control Iterativas
Muchos problemas en la vida real son una ejecución repetida de un conjunto de tareas, es
decir, realiza una serie de iteraciones, ciclos o bucles (loops). En programación existen las
estructuras de control iterativas, las cuales permiten repetir porciones de algoritmo un
determinado número de veces. Este tipo de estructuras involucra tres partes básicas, a saber:
• Inicialización de la variable de control: La variable de control es aquella que, como su
nombre lo indica, lleva el control de la ejecución de un ciclo. Ésta debe tener siempre un
valor inicial con el que inicia la ejecución del primer bucle.
• Condición de repetición: Es la expresión relacional (o variable lógica) que define en
qué momento va a finalizar el ciclo.
Introducción a la Programación
38
• Actualización de la variable de control: Instrucción que permite modificar el valor de
la variable de control, de forma tal que en algún momento alcance aquel que indique el
fin de ejecución de los bucles.
Ciclo “Para”
Un contador es una variable especial que incrementa o decrementa, contando el número de
veces que el proceso ha detectado una ocurrencia determinada. Esto es importante saberlo,
puesto que el ciclo para maneja de manera automática todos los detalles de la repetición
controlada por contador, ya que incorpora los componentes del ciclo en una misma
instrucción, y se emplea cuando se conoce con certeza el número de iteraciones que deben
realizarse.
Diagrama de Flujo Pseudocódigo
…
para valor_inicial a valor_final hacer
instrucciones;
fin_para;
…
El funcionamiento es como sigue: Cuando la estructura para inicia su ejecución, la
variable de control se inicializa a un valor dado. A continuación, se verifica si éste es menor
o igual al valor final. Si se satisface esta condición, se ejecuta el conjunto de instrucciones
contenidas dentro del ciclo. A continuación, la variable de control se incrementa en 1 unidad
de forma automática, y el ciclo inicia otra vez hasta que se supere el valor final. Es allí cuando
se termina la ejecución del bucle y se continúa ejecutando el resto del algoritmo.
Observaciones:
1. Por defecto, el ciclo para es incremental (es decir, la variable de control aumenta
progresivamente). Si se desea tener un conteo regresivo, se debe añadir la palabra
decrementar a la instrucción, de esta forma:
para valor_inicial decrementar a valor_final hacer
final_de_ciclo
valor_inicial a
valor_final instrucciones
condición_cierta
Introducción a la Programación
39
2. Si la condición de continuación de ciclo resulta falsa al inicio, la porción del cuerpo del
ciclo no se ejecutará. En vez de ello, la ejecución seguirá adelante con el enunciado que
siga a la estructura para.
3. La variable de control con frecuencia se imprime o se utiliza en cálculos en el cuerpo de
un ciclo, pero esto no es necesario. Es común utilizar dicha variable para controlar la
repetición, aunque jamás se mencione la misma dentro del bucle.
4. En Object Pascal el incremento/decremento dentro de un ciclo para es unitario. Si se
desea hacer otro tipo de actualización (por ejemplo, de dos en dos) es recomendable
emplear una estructura de control diferente. Sin embargo, algunos lenguajes (como C)
permiten definir la manera en que la variable de control se actualiza.
Ejemplo 2.6: Elabore un algoritmo que imprima los números del 1 al 10.
variables
num: entero;
procedimiento conteo
inicio
para num←1 a 10 hacer
escribir salida num;
fin_para;
fin;
La ejecución es como sigue: Se inicia la variable num en 1, y como no supera el valor
final se ejecuta la instrucción del bloque, imprimiéndose el valor actual (en este caso 1).
Luego num se incrementa a 2 y se repite el ciclo. Cuando num vale 11, finaliza el algoritmo.
inicio
num fin
num≤10
num>10 num←1 a 10
Introducción a la Programación
40
Ciclo “Mientras”
Esta estructura de repetición le permite al programador repetir una acción, en tanto cierta
condición se mantenga verdadera. En otras palabras, realiza básicamente la misma función
que el ciclo para, sólo que aquí los componentes del ciclo son instrucciones separadas.
Diagrama de Flujo Pseudocódigo
…
valor_inicial;
mientras condición hacer
instrucciones;
fin_mientras;
…
Aquí se muestra con claridad el flujo de control en la estructura de repetición
mientras: La línea de flujo que parte del bloque instrucciones retoma a la decisión misma,
que es probada cada vez dentro del ciclo, hasta que de forma eventual la decisión se convierte
en falsa. Llegado este momento, se sale de la estructura y el control pasa al siguiente
enunciado del algoritmo.
En ocasiones, no se conoce con certeza el número total de ciclos, por lo que se debe
llevar a cabo una repetición controlada por centinela, ya que usa una variable que, al recibir
un valor específico, determina el final del ciclo.
Entre las sentencias dentro del cuerpo debe haber una que modifique la condición de
iteración del bucle, lo cual asegura la ejecución finita del mismo. De no haberla, o de estar
mal formulada, podría generarse lo que se llama un bucle infinito. Igualmente, una incorrecta
formulación de la variable de control (valor inicial inadecuado, inicialización dentro del
bucle) o su completa omisión, puede derivar en un error de sintaxis o ejecución.
Ejemplo 2.7: Modifique el algoritmo anterior para que use la estructura mientras.
Verdadero
Falso
valor_inicial
condición instrucciones
Introducción a la Programación
41
variables
num: entero;
procedimiento conteo_2
inicio
establecer el valor de num como num←1;
mientras num es menor o igual a 10 hacer
escribir salida num;
establecer el valor de num como num←num+1;
fin_mientras;
fin;
Ciclo “Repetir-Hasta”
La estructura repetir-hasta es otra construcción iterativa que se usa cuando el cuerpo de un
bucle se debe ejecutar al menos una vez.
Diagrama de Flujo Pseudocódigo
…
valor_inicial;
repetir
instrucciones;
hasta condición;
…
inicio
num fin
Verdadero
num←1
num≤10 Falso
num←num+1
Verdadero
Falso condición
instrucciones
valor_inicial
Introducción a la Programación
42
En para y mientras, el cuerpo del bucle se ejecuta sólo cuando la condición es
verdadera. En repetir-hasta la condición es verificada al final, de este modo el cuerpo del
bucle se ejecuta al menos una vez, y se repetirá mientras la condición sea falsa. Sin embargo,
en otros lenguajes existen variantes de este bucle, por ejemplo, en C no existe el repetir-
hasta, sino el hacer-mientras, con una estructura idéntica a la mostrada en la tabla, salvo
que allí el ciclo se ejecuta mientras la condición sea verdadera.
Ejemplo 2.8: Modifique el algoritmo anterior para que use la estructura repetir-hasta.
variables
num: entero;
procedimiento conteo_3
inicio
establecer el valor de num como num←1;
repetir
escribir salida num;
establecer el valor de num como num←num+1;
hasta num es mayor a 10;
fin;
inicio
num
fin
Verdadero
num←1
num>10 Falso
num←num+1
Introducción a la Programación
43
Instrucciones de Ruptura y Continuación
Se utilizan para modificar el flujo de control, causando una salida prematura del ciclo
(romper), o un reinicio del mismo (continuar) en la siguiente iteración.
Ejemplo 2.9: Modifique el ejemplo 2.6, para que emplee una instrucción de ruptura cuando
num sea igual a 5.
variables
num: entero;
procedimiento conteo_4
inicio
para num←1 a 10 hacer
si num = 5
romper
sino
escribir salida num;
fin_si;
fin_para;
fin;
En este caso, la salida serán sólo los números 1, 2, 3, 4, ya que al 5 se termina la
ejecución del algoritmo.
inicio
num
fin
num≤10
num>10
num←1 a 10
Sí num = 5
No
romper
Introducción a la Programación
44
Ejemplo 2.10: Modifique el ejemplo anterior para que emplee una instrucción de
continuación cuando num sea igual a 5.
variables
num: entero;
procedimiento conteo_4
inicio
para num←1 a 10 hacer
si num = 5
continuar
sino
escribir salida num;
fin_si;
fin_para;
fin;
En este caso, la salida serán los números del 1 al 10, a excepción del 5, ya que en ese
valor se reinicia el ciclo. Cabe decir que, en el caso de la estructura para, la variable de
control se incrementa.
inicio
num
fin
num≤10
num>10
num←1 a 10
Sí num = 5
No
continuar
Introducción a la Programación
45
UNIDAD III: PROGRAMACIÓN EN DELPHI
3.1 El entorno de desarrollo
Entorno de desarrollo integrado (EDI) o IDE en inglés (Integrated Development
Environment), es el ambiente de desarrollo de programas de Delphi. Se trata de un editor de
formularios que permite el desarrollo visual, un potente editor de textos que resalta la sintaxis
del código fuente, la paleta de componentes y el depurador integrado, además de una barra
de botones y un menú que permite la configuración de la herramienta y la gestión de
proyectos.
El entorno de programación típico consta en Delphi de cuatro ventanas que comparten
el espacio disponible de la pantalla. Cada una de estas ventanas puede modificarse, cerrarse
y volverse a abrir mediante el menú View. Estas ventanas fundamentales son:
• La ventana principal
• El inspector de objetos (object inspector)
• El editor de código fuente
• La ventana (o ventanas) de programa (Forms)
Introducción a la Programación
46
3.1.1 La ventana principal
La barra de programa del margen superior de la pantalla representa la ventana principal de
Delphi. Si se cierra, todas las otras ventanas también finalizan su servicio. En la barra de
menús de la ventana principal están disponibles todas las órdenes relacionadas con el
procesamiento de un proyecto concreto. La carga y almacenamiento de proyectos pertenecen
igualmente al menú, así como la presentación u ocultación de las distintas ventanas del
entorno de desarrollo.
También se encuentran aquí las órdenes para compilar y ejecutar un programa, además
de poder llamar a una parte de los programas externos suministrados con el paquete de
Delphi: el "Image Editor", el "Database Desktop", y el "BDE Config". El mayor espacio de
la ventana principal lo ocupa la paleta de componentes, que se encuentra dividida en
secciones temáticas a través de unas pestañas. Al situar el cursor sobre cada icono, saldrá un
mensaje indicando el tipo de acción que realiza.
3.1.2 El inspector de objetos (object inspector)
Los componentes vienen definidos por sus propiedades, y los eventos ante los que reaccionan
(se tratará este tema con más detalle en la sección 3.2). El inspector de objetos es una ventana
desde la cual se pueden ver y modificar la mayoría de las propiedades y eventos del
componente, ya que se listan en dicha ventana tanto las propiedades como los eventos por
orden alfabético.
La mitad derecha de la ventana contiene el valor actual de cada propiedad. Puede
tratarse de números, cadenas de caracteres, constantes determinadas, gráficos, textos,
punteros, etc. En el caso de estar visualizando la parte correspondiente a eventos, se observa
una lista con muchos de los eventos ante los cuales el componente reacciona (no todos,
Introducción a la Programación
47
algunos no son accesibles a través del inspector de objetos y hay que definirlos mediante
código).
3.1.3 El editor de código fuente
Delphi es una “Two-Way-Tool” (herramienta de dos vías), es decir, que lo que se va
programando visualmente, va apareciendo en forma de código en el editor de código fuente.
De la misma forma, si no se desea hacer uso de las capacidades de programación visual, se
puede simplemente escribir el código que se ejecutará (incluida la creación de ventanas, etc.).
El editor dispone de una ventana distinta por cada Unit de que disponga el programa,
seleccionándose una ventana u otra por medio de pestañas. Adicionalmente dispone de
posibilidad de copia al portapapeles, resaltado de palabras clave, inserción de puntos de
ruptura, índices, búsquedas, etc.
Introducción a la Programación
48
3.1.4 La ventana de programa (Forms)
Delphi hace fácil precisamente las tareas rutinarias, dejando para el programador la tarea
realmente importante de codificar el programa, no el entorno. El entorno (ventanas,
colocación de botones, listas, etc) se crea de forma puramente visual, es decir, simplemente
se coge con el ratón el componente deseado de la barra de herramientas de la ventana
principal y lo sitúa en la ventana sobre la que se desarrolla el programa (Form).
En el Form se puede reproducir el aspecto y el comportamiento de todo tipo de
ventanas, simplemente especificando las propiedades correspondientes y/o escribiendo
ampliaciones propias. De esta forma se caracteriza a la ventana a través de sus propiedades:
anchura, altura, coordenadas, estilo de los bordes, colores, eventos ante los que reacciona,
etc.
3.2 Propiedades y eventos de los componentes en Delphi
Un componente es cualquiera de los elementos que se pueden insertar en una ficha, tanto si
su función es visual como si no lo es. Un ejemplo puede ser RChart, usado para dibujar las
gráficas. Sin conocer exactamente el cómo realiza su función, el programador manipula una
serie de propiedades, métodos y eventos que caracterizan al componente, a través de los
cuales se maneja el componente en la forma deseada. Por supuesto el usuario puede crear sus
propios componentes y usarlos en distintas aplicaciones, de forma que la reusabilidad del
Introducción a la Programación
49
código es máxima. A los componentes que cuentan con una parte visual, como puede ser un
botón, se les denomina controles.
3.2.1 Propiedades
Los componentes, y de hecho todos los objetos de Delphi son de uso general, por lo que a la
hora de usarlos de alguna forma deben ser adecuados a las necesidades del desarrollador.
Para ello se emplean de las propiedades de cada objeto, mediante las cuales se establece el
título de una ventana, el tipo de letra de una etiqueta de texto o el color en el que aparecen
los distintos controles.
Se puede pensar en las propiedades como si fuesen variables pertenecientes a un
componente u objeto (luego se verá que no es así exactamente), de tal forma que, para acceder
a ellas, generalmente habrá que indicar no sólo el nombre de la propiedad, sino también a
qué objeto pertenece.
La modificación o consulta del valor de una propiedad puede diferir según la manera
de acceder a ella (mientras se está diseñando un form, en tiempo de diseño, o bien mediante
el código del programa, en tiempo de ejecución). Ciertas propiedades están sólo accesibles
en tiempo de ejecución, por lo que mientras se diseña la ficha éstas no aparecerán. Además
hay algunas propiedades que son de sólo lectura, por lo que su valor puede ser consultado,
pero no modificado, y otras que son sólo de escritura.
Aunque a primera vista, si se usa un componente prefabricado, las propiedades pueden
parecer simples variables, en la mayoría de las ocasiones una propiedad no es una variable,
y la modificación o consulta de su valor puede conllevar que internamente el componente
ejecute un cierto código.
Si por ejemplo existe un componente para comunicaciones serie que se encarga de
enviar mensajes a un ordenador remoto, tal vez se le puede asignar una cadena de caracteres
a una hipotética propiedad "Envia". De esta forma, con una simple asignación
Introducción a la Programación
50
(Envia:='Mensaje a mandar') se pondría en marcha todo el mecanismo implícito en el
componente para enviar el mensaje al ordenador remoto. Esta propiedad podría ser un
ejemplo de propiedad de sólo escritura, ya que sólo interesa mandar el mensaje al ordenador
remoto, sin conservar información acerca del mensaje, por lo que sería inapropiada su lectura.
3.2.2 Eventos
La programación en el entorno Windows se caracteriza por estar dirigida por eventos, de tal
forma que un programa no tiene por qué ejecutarse necesariamente de forma secuencial, sino
que ciertas porciones de código se ejecutarán cuando ocurra un cierto evento.
Para la informática, un evento es una acción que es detectada por un programa; éste, a
su vez, puede hacer uso del mismo o ignorarlo; es decir, son señales que el entorno recibe
desde distintos elementos, como puedan ser el ratón, el teclado o un temporizador. Estos
eventos son redirigidos a las aplicaciones, que en caso de aceptarlos deberán responder
adecuadamente de ellos. Por lo general, una aplicación cuenta con uno o más hilos de
ejecución dedicados a atender los distintos eventos que se le presenten.
Ciertos eventos pueden ser gestionados por el propio Windows, otros quedarán a cargo
del propio lenguaje que estemos usando, y un tercer grupo serán los que lleguen hasta el
programa. En Delphi prácticamente todo el código que se escribe irá asociado a algún evento.
Tomando el ejemplo del componente para comunicaciones serie, éste requeriría que se
ejecutara un evento cada vez que se recibiese un carácter por el puerto serie, de forma que se
escriba el código necesario para guardar el carácter en un archivo cada vez que se produjese
el evento. Normalmente los eventos a los que reaccionarán los componentes serán las
pulsaciones del teclado o el ratón, activaciones de los componentes, etc.
3.3 Entrada y Salida
Las operaciones de entrada y salida en Delphi son variadas dependiendo de la aplicación que
se está programando.
Introducción a la Programación
51
3.3.1 Por consola
Si es una aplicación de consola, los comandos de entrada y salida son los siguientes:
• Read(Var); El argumento es un identificador de las variables previamente declaradas.
Una variante es ReadLn, la cual luego de leer baja a la siguiente línea.
• Write(‘Mensaje’); Este comando imprime una salida y puede recibir muchos
argumentos. Éstos pueden ser mensajes literales (string, entre comillas simples), o el
nombre de una variable. Una variante es WriteLn, la cual luego de escribir la línea salta
a la siguiente.
Ejemplo:
program Project1;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
a: String;
begin
Write('Ingrese un nombre: ');
Read(a);
WriteLn('Tu nombre es: ' + a);
end.
3.3.2 Por formulario
Si es una aplicación con formularios y ventanas, eso depende de cuales sean los elementos
de entrada y cuales los de salida, a continuación una breve descripción de objetos (Más
comunes) y sus métodos de entrada y salida.
Introducción a la Programación
52
• Label: Este objeto es una etiqueta con rotulada como desee el programador, se suele usar
más para mostrar salidas que usarlo como una entrada, a menos que sea una variable
constante. Su método de Entrada como de salida es caption.
• Edit: Este es la famosa caja de texto, una de las más usadas para insertarle entradas a los
programas, el método que usa para el flujo de entrada y salida es text.
Ejemplo: (Entrada en Edit1, salida en Label2).
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm1 = class(TForm)
Edit1: TEdit;
Label1: TLabel;
Label2: TLabel;
Button1: TButton;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
Introducción a la Programación
53
procedure TForm1.Button1Click(Sender: TObject);
var
a: String;
begin
a := Edit1.Text;
Label2.Caption := 'Tu nombre es: ' + a;
end;
end.
3.3.3 Métodos de conversión
Todas las entradas y salidas (ya sea en consola o por formulario) deben ser en formato de
cadena (string). En este sentido, para realizar operaciones matemáticas se requiere trabajar
con variables numéricas. Existen varias funciones para convertir de cadena a otro tipo de
datos, y viceversa. Entre las más comunes están las siguientes 4:
• StrToInt(Argumento): Convierte una cadena a número entero.
• StrToFloat(Argumento): Convierte una cadena a número real (punto flotante).
• FloatToStr(Argumento): Convierte un número real en cadena.
• IntToStr(Argumento): Convierte un número entero en cadena.
3.4 Tipos de datos en Delphi
Se define como un conjunto de valores y operaciones definidas para las variables de ese tipo
en particular, los cuales se almacenan en forma diferente en la memoria de la computadora.
Los tipos de datos básicos en Delphi aparecen en la siguiente tabla:
Tipo Descripción Bits Rango de Valores
Byte Números enteros positivos de 1 Byte 8 0 a 255
Word Números enteros positivos de 2 Bytes 16 0 a 65535
Cardinal Números enteros positivos. Su tamaño
depende del S.O.
16 0 a 32767
32 0 a 65535
ShortInt Números enteros de 1 Byte 8 -128 a 127
Smallint Números enteros de 2 Bytes 16 -32768 a 32767
Integer Números enteros. Su tamaño depende del S.O. 16 -32768 a 32767
32 -2147483648 a 2147483647
Introducción a la Programación
54
Tipo Descripción Bits Rango de Valores
LongInt Números enteros de 4 Bytes 32 -2147483648 a 2147483647
Comp Números enteros de 8 Bytes 64 -9223372036854775808 a
9223372036854775807
Single Números fraccionarios de 7 a 8 decimales 32 1,5x10-45 a 3,4x1038
Real Números fraccionarios de 11 o 12 decimales 48 2,9x10-39 a 1,7x1038
Double Números fraccionarios de 15 a 16 decimales 64 1,0x10-324 a 1,7x10308
Currency Números fraccionarios de 4 decimales, 15
dígitos enteros 64
-922337203685477,5808 a
922337203685477,5807
Extended Números fraccionarios de 19 a 20 decimales 80 3,4x10-4932 a 1,1x104932
Boolean Valores lógicos 8
True y False ByteBool Valor booleano de 1 byte 8
WordBool Valor booleano de 2 bytes 16
LongBool Valor booleano de 4 bytes 32
Char Caracteres ANSI 8 Tabla ASCII
AnsiChar
WideChar Caracteres Unicode 16 ‘\u0000’ a ‘\uFFFF’
ShortString Cadena corta - Hasta 256 caracteres
AnsiString
String Cadena de caracteres - Ilimitado (256 en S.O. de 16
bits)
PChar Puntero a cadena ANSI terminada en null - -
PAnsiChar
PWideChar Puntero a cadena Unicode terminada en null - -
Pointer Puntero a cualquier variable - -
Variant Cualquier tipo de datos - -
3.4.1 Declaración de variables en Delphi
En la sección 2.4 se ha tratado el tema de variables. En esta oportunidad se mostrará la manera
en que éstas son declaradas en Delphi. Lo que se debe hacer es colocar dichas variables bajo
la palabra reservada var, usando primero el nombre, seguido por dos puntos, luego el tipo de
datos y se culmina la instrucción con un punto y coma. Así:
var:
v : Variant;
i : Integer;
d : Double;
s : String;
begin
v := 100;
Introducción a la Programación
55
i := 25000;
d := 123.456
s := 'Hola Mundo';
end;
Para declarar más de una variable de un mismo tipo, se deberán separar con comas, así:
i1, i2, i3 : Integer
3.5 Operadores lógicos, aritméticos y relacionales
El operador es el símbolo utilizado en matemáticas o computación para indicar la operación
que se realiza entre los elementos que une o la relación que existe entre ellos.
3.1.1 Operadores aritméticos
Los operadores aritméticos de C# se muestran en la siguiente tabla:
Operación Operador Expresión Algebraica Expresión en C#
Suma + Z + 7 Z + 7
Resta – A – B A – B
Producto * XY X * Y
División /
j/k ó j÷k j / k
DIV j DIV k
Módulo MOD r mod s r % s
El asterisco (*) indica producto. La barra diagonal y DIV realizan la misma función,
salvo que el primero trabaja con cualquier dato numérico, y el segundo solamente es para
enteros. Los operadores aritméticos son operadores binarios. La combinación de operandos
por medio de cualquiera de estos operadores se llama expresión algebraica o aritmética.
Delphi tiene el operador de módulo (MOD) que proporciona el residuo después de una
división de enteros, por lo tanto, 7MOD4 da como resultado 3, y 17MOD5 da como resultado
2. El módulo es un operador entero, es decir, que sólo puede ser utilizado con operandos de
tipo int. Cuando uno de los operandos es negativo, el resultado de MOD no está definido.
Introducción a la Programación
56
Las expresiones aritméticas deben ser escritas en una línea continua para facilitar la
escritura de programas en la computadora. Entonces, expresiones tales como “a dividido
entre b” deben ser escritas como a/b, y no como 𝒂
𝒃. Por su parte, los paréntesis se utilizan en
las expresiones de Delphi, de manera muy similar a como se usan en las expresiones
algebraicas. Por ejemplo, para multiplicar a por la cantidad b+c se escribe lo siguiente: a *
(b + c).
Consideraciones:
• El resultado de la operación a / b siempre será de tipo Extended, independientemente del
tipo de los operandos. Para los otros operadores aritméticos, el resultado siempre será
entero, a menos que uno de los operandos sea de un tipo distinto, por lo que el resultado
será de ese tipo en particular.
• El resultado de a DIV b es el valor redondeado de a / b, y en la dirección del cero al más
cercano entero.
• Cuando el divisor es cero ocurre un error en tiempo de ejecución.
• Los operadores + y - pueden ser también unarios, indicando el signo del número.
Igualmente, + también puede ser empleado en operaciones con cadena (su utilidad en ese
caso es distinta).
3.1.2 Expresiones y operadores relacionales
Las expresiones relacionales son aquellas que se forman con una combinación de
identificadores, constantes y expresiones aritméticas, todas enlazadas a través de un conjunto
de operadores relaciónales. Los siguientes, por ejemplo, son todas expresiones relacionales
válidas:
• 10
• (a-25) <= max
• b<=0
• (b*b -2*a) < (c*e)/2
Introducción a la Programación
57
Operadores relacionales
Algunos de los operadores relacionales son: < (menor que), <= (menor o igual que), > (mayor
que) y >= (mayor o igual que). La asociatividad de la evaluación es de izquierda a derecha.
Los operadores relacionales se usan para formar expresiones relacionales. Las expresiones
relacionales siempre producen un valor de verdadero o falso.
Operadores de igualdad
Los operadores de igualdad son: = (igual a) y <> (diferente a). La asociatividad de los
operadores es de izquierda a derecha. Éstos se pueden usar en expresiones relacionales.
Algunos ejemplos válidos del uso de los operadores de igualdad se presentan a continuación:
a = b n <> 10 b + c = c - d
3.1.3 Expresiones y operadores lógicos
Las expresiones relacionales conectadas por operadores lógicos se denominan expresiones
lógicas, ya que siempre producen un valor de verdadero o falso. El valor que retorna una
expresión lógica es de tipo Boolean, a saber: true y false. Delphi también provee operadores
lógicos, llamados conectores lógicos, los cuales se listan a continuación:
• AND Y
• OR O
• XOR O exclusivo
• NOT NO
Se pueden usar los operadores lógicos para combinar expresiones lógicas. Algunos
ejemplos se dan a continuación:
((a + 2) = max) AND (NOT(n <> 0))
((a = 3) XOR (max <> -1)) OR (i MOD 2 <> 0)
Introducción a la Programación
58
El operador lógico AND retorna el valor true sólo cuando ambos operandos son
verdaderos. El operador lógico OR retorna el valor false sólo si ambos operandos son falsos.
Por su parte, XOR devuelve true solamente cuando los operandos son diferentes (true y
false, o false y true), ya que al ser ambos iguales el resultado es false. El operador lógico
NOT retorna el opuesto del operando, es decir, retorna true si el operando es false, y
viceversa.
3.1.4 Operadores de asignación y punto flotante
La asignación de un valor implica que a una variable ubicada a la izquierda del operador, se
le asignará el valor situado a la derecha del mismo, reemplazando el valor que tenía con
anterioridad. En Delphi, la asignación se hace con :=, por ejemplo: a := b + c; En cuanto a
los números fraccionarios, su parte decimal se define con el punto: a := 5.8
3.1.5 Precedencia de operadores
Las reglas de precedencia de operadores son guías de acción que permiten a Delphi calcular
expresiones en una secuencia precisa, es decir, permite establecer qué operaciones se
ejecutan primero, qué otras operaciones se ejecutan posteriormente.
Categoría Operadores Ejemplo de Uso
Acceso a Datos ( ) [ ] . a * (b + c)
Unarios NOT + - (signo) -5 NOT(a)
Productos * / DIV MOD x MOD y
AND b<c AND d>e
Sumas + - 3 + 2
OR XOR b<c OR d>e
Relacionales = <> < > <= >= rel1 < rel2
Asignación := a := 5
3.6 Programas secuenciales
Son aquellos que no involucran ningún tipo de transferencia de control, es decir, parten de
un punto inicial y se ejecutan en secuencia hasta un punto final.
Introducción a la Programación
59
Como ya se mencionó, en Delphi se puede programar tanto en modo consola como en
modo formulario. Por ejemplo, un programa que permita la suma de 2 números se realiza de
la siguiente forma:
En modo consola
program Project1;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
a, b, c: Integer;
begin
WriteLn('Ingrese dos numeros:');
ReadLn(a);
ReadLn(b);
c := a + b;
WriteLn('La suma es' + IntToStr(c));
end.
En modo formulario
Aquí los programas suelen hacerse en el evento asociado a los botones.
procedure TForm1.Button1Click(Sender: TObject);
var
a, b: Integer;
begin
a := StrToInt(Edit1.Text);
b := StrToInt(Edit2.Text);
c := a + b;
Label1.Caption := IntToStr(c);
end;