INTRODUCCIÓN A LA PROGRAMACIÓN (008-2833) · 1.1 Historia del Computador 1.2 Componentes del...

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


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


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


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.


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.


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.


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.


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).


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


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.


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.


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.


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).


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.


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.


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).


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


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:


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


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


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).


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.


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


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.


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.


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.


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


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


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.


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


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.


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.


…

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


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.


…

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

…

…


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


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


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


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


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.


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.


…

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


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


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.


…

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


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


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.


…

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


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;


inicio

establecer el valor de num como num←1;

repetir


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


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;


inicio


si num = 5

romper

sino


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


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;


inicio


si num = 5

continuar

sino


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


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)


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,


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.


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


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


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.


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.


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}


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


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;


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.


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


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)


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.


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;

INTRODUCCIÓN A LA PROGRAMACIÓN (008-2833) · 1.1 Historia del Computador 1.2 Componentes del...

Documents

Transcript of INTRODUCCIÓN A LA PROGRAMACIÓN (008-2833) · 1.1 Historia del Computador 1.2 Componentes del...