Programacion Desde Cero

.
Fu11dame11tos del desaiTollo de aplicaciones +

Pseudocódigo + Est1ucturas de control + Interfaces gráficas +
Proyecto en Visual Basic + Proyecto e11 C++
RU
..,.,.•
f'-...I,.,,·"'
' ' .
-~·.,....
, '
,
,'
.' ,;' 1'

1
,. ....
,. ,...,•' ....-
- SEGURIDAD 1
• "' / - SEGURIDAD / O-tr ERl\1E'T
- 208 PÁGINAS - 320 PÁGINAS
- ISBN 97&-987-1949-35-9 - ISBN 97&-987-1949-31-1
\¡
.·..
•~
. ~
••
... ~- "
- DESARROLLO / O-tr ERl\1E'T - MICRQSOFT / OFFICE

- 320 PÁGINAS - 320 PAGINAS
- ISBN 97&-987-1949-20.5 - ISBN 97&-987-1949-21-2
LLEGAMOS A TODO EL MUNDO VÍA >>OCA * y

e usershop.redusers.com \,+54 (011) 4 110-8700 [81 usershop@redusers.com -------+--;
• SÓLO VÁLIOO EN LA REl'ÚBLICA ARGENTINA 1/ ** VÁLIOO EN TOOO EL MUNDO EXCEPTO ARGENTINA
,
PROG . . . . ACION
DESDECER
RedUSERS
TÍTULO : Programación desde cero
AUTOR: Juan Carlos Casale
COLECCIÓN : Desde Cero
FORJv!ATO 19 x 15 cm
P AGINAS : 192
Copyright © MMXIV. Es una publicación de Fox Andina en coeclición con DALAGA S.A . Hecho el depósito que
marca la ley 11723 . Todos los derechos reseivados. Esta publicación no puede ser reproducida ni en todo
ni en parte, p or ningún medio actual o futuro sin el penniso previo y p or escrito de Fax .L>.ndina S .A . Su infrac-
ción está p enada p or las leyes 11723 y 25446 . La editorial no asume resp onsabilidad alguna p or cualquier
consecuencia derivada de la fabricación, funcionamiento y/o utilización de los servicios y productos que se
describen y/o analizan. Todas las marcas mencionadas en este libro son propiedad exclusiva de sus resp ec-
tivos dueños. Impreso en Argentina. Libro de edición argentina. Primera impresión realizada en Sevagraf,
Costa Rica 5226, Grand Bourg, Malvinas Argentinas, Pcia. de Buenos Aires en IV. MMXIV.
I SBN 978-987-1949-60-l
Casale, Juan Carlos

Programación desde cero / Juan Carlos Casale; coordinado p or Gustavo Carballeiro .
1a ed. - Ciudad Autónoma de Buenos Aires : F ox Andina; Buenos Aires: Dalaga, 201 4.
192 p . ; 19xl5 cm. - (Desde cero; 36)
ISBN 9 78-987- 1949-60 - l
l. Informática. l. Carballeiro, Gustavo, coord. 11. Titulo

CDD 004
>> www. red users .com

----
ENNlJISTRosmo PODRA ACCEDER A UNA PREVIE\VDIGITAL DE CADA LIBRO y TAl\IBIÉ N

OBTINIR, DEl\L~~RA GRATUITA, UNCAPÍTULO I NVIRSIÓNPDF, I L SUliL<\RIO COl\IPLITO
E ll\L<\GINIS A.~IPLLillASDE TAPA Y CONTRATAPA.
RedUSERS G redusers.com
Nuestros libros incluyen guías visuales, explicaciones paso a paso, recuadros
complementarios, ejercicios y todos los elementos necesarios para asegurar
un aprendizaje exitoso.
4 PRELll\ flNARES
El libro de un vistazo
Comenzaremos nuestro recorrido con una introducción al uso de pseu-
docódigo, y luego avanzaremos hacia la explicación de conceptos claves
como las variables, los operadores y las funciones. Finalmente, llevaremos
a cabo dos proyectos de puesta en práctica de la teoría aprendida.
que lo dirija hacia una ubicación esp ecifica

del programa. Para que este trab ajo se
realice correctamente, es importante
A lo largo de este capitulo introductorio que la información esté organizada y
conoceremos las generalidades del estructurada de forma adecuada.
desarrollo de aplicaciones y veremos
detalladamente las etap as de un proyecto .
Luego de haber recorrido teorías y

En este capítulo veremos cómo prácticas para el desarrollo de aplicaciones
representar algoritmos mediante el uso informáticas, veremos cómo comenzar a
de pseudocódigo, el lenguaje "común" plasmar todo el conocimiento adquirido

que podemos utilizar para cualquier sobre p seudocódigo en un lenguaje.
lenguaje de programación.
El funcionamiento del equipo se b asa en Aplicaremos los conocimientos adquiridos

la ejecución de los comandos a medida en Visual Basic. Utilizaremos el entorno
que se va leyendo el archivo (de arriba de desarrollo !D E de Visual Studio 20 10,
hacia ab ajo), hasta alcanzar un comando versión Visual Basic Express.

PROGRA1\1ACION DESDE CERO 5
Aquí veremos el desarrollo de código
fuente que tiene el reconocido lenguaje Luego de haber manejado estructuras

C++. Conoceremos un !DE gratuito de datos abstractas, vamos a adentrarnos
para aplicar los conocimientos adquiridos en el diseño de intetfaces gráficas,
y realizaremos algunos desarrollos. mediante pautas interesantes y útiles.
A lo largo de este manual, p odrá en contrar una serie de recuadros que le brindarán información
complementaria: curiosidades, trucos, ideas y consejos sobre los temas tratados. Para que pueda
distinguirlos en forma más sencilla, cada recuadro está identificado con diferentes iconos:
CURIOSIDADES :\ffi' lCIÓ N DATOS UTILIS smos

E IDEAS Y NOV"IDADES \VIB
www. redu sers.com <<

6 t!f:1#,-!-i PRELll\ flNARES
Contenido del libro

El libro de un vistazo ...................................... 4 R elacionales ............................................. 3 7
Información complementaria ........................ 5 Asignación de valores ................................... 38
Contenido del libro ......................................... 6 Entrada y salida de información ............... 42
Introducció n .................................................. 8 Resumen ....................................................... 4 3
•.,..,_,..-----
Actividades ................................................... 44
Introducción a la programación
Desarrollo de aplicaciones ............................ 1O Estructuras de programación
Interpretación de las aplic.aciones ........... 11 Estructuras de control ................................. 46
Etap as de un desarrollo ................................ 12 Estructuras condicionales ......................... 46
A) Análisis del problema ......................... 13 Estructuras repetith,as
B) Diseño de la solución ........................... 13 ,. --
o c1.c 1ca.s ................................................... :,:,
C) Traducción del diseño Datos estructurados ..................................... 58

a un lenguaje de prograniación ................. 16 Vectores ................................................... 59
D) Implementación y testeo Matrices ................................................... 63
del proyecto .............................................. 19 Subalgoritmos .............................................. 68
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 Funciones ................................................ 69
Actividades ................................................... 20 Proc.edimientos ........................................ 75
Resumen ....................................................... 77
*•
Pseudocódigo
Actividades ................................................... 78
Pseudocódigo: el lenguaje humano ............. 22

Tipos de datos ............................................... 24 Del pseudocódigo al lenguaje
Variables ........................................................ 26 de programación
Clasific.ación de las variables .................... 28 Lenguajes de programación ......................... 80
Normas de escritura ................................. 30 Tipos de len.guaje.s .................................... 80
Op eradores .................................................... 32 Intetfaces gráficas ........................................ 82
.~ritui étic.os ............................................... 32 Pseudocódigo y lenguajes
Lógicos ..................................................... 33 de programación ...................................... 86

PROGRAt\ 1ACION DESDE CERO (!J.jd,-fi 7
Resumen ....................................................... 87 Primera ap licación en C ++......................... 141

Actividades ................................................... 88 Tipos de datos en C++............................ 143
Declaración de variables ........................ 144
Inicialización de variables ...................... 146
Operadores ............................................. 150
Proyecto en l\'licrosoft Visual Basic Interactuar con el usuario .......................... 161
Creación de proyectos .................................. 90 Cout (salida estándar) ............................ 161
Variab les ........................................................ 96 Cin (entrada estándar) ........................... 164
Op eradores .................................................. 104 Estructuras de programación .................... 166
.~ritu1étic.os ............................................. 104 Estructura condicional.. .......................... 166
Lógicos ................................................... 105 Estructu.ra selectiva................................ 168
Relacionales ........................................... 106 Estructuras repetith,as ........................... 169
Estructuras de programación .................... 1O7 Eje rcitación ........................................... 173
Estructuras de control ............................ 107 Saltos de declaraciones .......................... 175
Datos e.struc.tu.rados ................................ 116 Datos estructurados ................................ 178
Uso de controles b ásicos ............................ 122 Resumen ..................................................... 183
Resumen ..................................................... 131 Actividades ................................................. 184
Actn~dades ................................................. 13 2
Confección de interfaces gráficas

Primer proyecto en C++ N ormas de diseño ....................................... 186
!D E SharpDevelop ...................................... 134 Fundan1entos del diseño ......................... 186
Introducción a C++ .................................... 136 Controles usuales ....................................... 188
Espacio de nombres ................................ 137 Componentes visuales ............................. 191
Conceptos básicos del código.................. 140 Resumen ..................................................... 192
main.cpp' .:x
.!. ¡• •
2 • Creado por SharpDevelop.
3 • Usuario: john
4 • Fecha: 01/08/2012
5 • Hora : 18:00 P·•·
6 •
7 Para cambiar esta plantilla use Herramientas I Opciones I Codificación I E,
8 •¡

8 PREL!l\flNARES
Introducción
En u11 1nu11do en constante innovación y descubrimiento,
es el desarrollo del software el que nos permite gestionar la
tecnología en hardware. Estos avances nos ofrecen un amplio
abanico de posibilidades laborales: podemos desempeñamos
co1no desarrolladores tanto en la industria de los videojue-
gos, como las aplicaciones web y sistemas informáticos de
organizaciones, entre otras opciones.
Si miramos hacia atrás, veremos que desde hace unos diez años
la era digital ha traído cambios revolucionarios, y que estos avan-
ces tecnológicos han afectado nuestra comunicación cotidiana.
Para dominar esta enorme variedad de dispositivos - smartphones,
computadoras, tablets, ultrabooks, etcétera- necesitamos desarro-
llar programas que nos permitan interach1ar con ellos.
Este libro está dirigido a todos aquellos que quieran iniciarse
en el mundo de la programación y conocer las bases necesarias
para crear su primer sofn-vare. A lo largo de su contenido, nos
plantearemos qué nos impulsa a comenzar tm desarrollo de apli-
caciones y qué partes lo constihlyen. Cuando conozcamos el
manejo y la confección de los programas, empezaremos a incur-
sionar en la lógica misma de la programación y podremos mo-
vemos en cualquier tipo de lenguaje.
En defmitiva, el contenido del libro no se dirige hacia tm (mi-
co camino, sino que se propone brindar las herramientas ne-
cesarias para que sea el lector quien elija sobre qué escenario
trabajar: escritorio, \oVeb, móvil, consola de videojuegos, etc.

/ / / / / / / / / / / / / //.
Introducción
a la programación
A lo largo de este capítulo introductorio, conoceremos
las generalidades del desarrollo de aplicaciones y veremos
detalladamente las etapas de un proyecto.
• Desarrollo de aplicaciones ......... 1O D) Implementación y testeo

Interpretación del pro)recto ............................... 19
de las aplicaciones ...................... 11
• Resumen ..................................... 19
• Etapas de un desarrollo ............. 12
A) ..\.oálisis del problema ............ 13 • Actividades ................................. 20
B) Diseño de la solucióo .............. 13
C) Traducción del diseño a
un lenguaje de programacióo ...... 16
10 l . INTRODUCCIÓN A LA PROGRAt\ 1ACIÓN
Desarrollo de aplicaciones
En la vida cotidiana nos encontramos con distintos desarrollos de aplica-
ciones, por ejemplo, el programa que controla nuestro teléfono móvil.
El mundo en su totalidad se rige por programas desarrollados mediante algún
lenguaje de programación, y todos los elementos electrónicos, en menor o
mayor grado, contienen aplicaciones específica s para cumplir su misión.
El desarrollo de tma aplicación podría defmirse como el proceso que
se realiza para encontrar distintas soluciones posibles a una situación
problemática, 1nediante la preparación de aplicaciones informáticas.
Este proceso implica la confección, prueba y posterior búsqueda de erro-
res en un programa informático. El primer paso será efectuar la progra-
mación lógica de la aplicación, es decir, la solución lógica del problema,
que subyace a cualquier lenguaje de programación. La aplicación desa-
rrollada se corresponderá con u110 de los tipos siguientes:
• Aplicaciones vveb : son muy comunes en organizaciones que desean

globalizar sus modelos de negocios o, simplemente, alcanzar la auto-
gestión para empleados, alumnos, docentes, etcétera.
• Aplicaciones 111óviles : se utilizan en equipos móviles, como teléfonos
celulares o tabletas. Suelen ser similares a las de escritorio, y permiten
realizar las mismas tareas, aunque el ingreso de datos es táctil y por voz.
• Aplicaciones de escritorio : fLmcionan sobre tm sistema operativo
de PC o notebook. Podemos encontrarnos con desarrollos muy costosos,
A medida que la tecnologia avanza, se suma "inteligencia" a distintos dispositivos, como hela -
deras, aspiradoras y lavadoras, que incluyen comunicación por \Vi-Fi y cámaras. Esto permite
que el usuario controle el dispositivo mediante un software instalado en su teléfono móvil.

PROGRAt\ 1ACION DESDE CERO 11
utilizados por grandes empresas; y con otros gratuitos y útiles que

pueden servirnos para diferentes tareas.
Interpretación de las aplicaciones

Debemos tener en cuenta la manera en que un sistema de cómputos
electrónico interpreta la información y có1no nosotros, co1no futuros
desarrolladores, lo vemos. Todo comienza por los famosos bits de datos.
Un bit representa la unidad de medida más pequeña en información di-
gital, y tiene dos estados: Oo 1; generalmente, el Ose represen-ta como
cerrado (o negativo) y el 1 como abierto (o positivo). Este protocolo bina-
rio es conocido como lenguaje de 111áquina .
Una aplicación envía Es procesada

información para en lenguaj e máquina
Retom a un resultado .
modificar una imagen 0 10 1111110 110 por
y pixelarla. el microprocesador .
Figura l. Una fo1ma sencilla de ver el funcionamiento

del programa en la computadora.
En la actualidad, la interacción entre los usuarios y las aplicaciones se

da por medio de interfaces, principalmente gráficas, es decir, de una
manera visual, a través de iconos, colores y fonnas. Existen ta1nbién
aplicaciones que utilizan otros sentidos: tacto (como por ejemplo la
www. redusers.com <<

12 l . INTRODUCCIÓN A LA PROGRAt\ 1ACIÓN
botonera de un ascensor o el panel de un microondas), oído e, incluso, olfa-

to. La interfaz debe contener algún software que interactúe con el hardware
del dispositivo, para, de esta forma, obtener el resultado deseado.
La interacción entre los usuarios y la aplicación también puede entender-
se como tm esquema de entrada/proceso/salida: la entrada es el ingreso
o comando de datos que vamos a realizar sobre un dispositivo (como, por
ej emplo, tocar la pantalla , escribir, mover el puntero del mouse, hacer el mo-
proceso es el trabajo, la interpretación
vimiento con un j oystick, etcétera). El
y el cálculo de la información ingresada (que puede ser un movimiento
del mouse, tma tecla pulsada). La salida es el resultado de las acciones
que se efectúan sobre la infonnación (por eje1nplo, se realizará una
acción en un juego, como disparar, se devolverá el resultado de un
cálculo, se ejecutará un video, etcétera).
Etapas de un desarrollo
Antes de continuar con cuestiones específicas, revisemos las tareas genera-
les por considerar en el desarrollo de una aplicación, en la siguiente figura:
Análisis Diseño Pseudocódigo
Test de ejecución Código (lenguaje

Comp ilación
de programación)
Errores
Errores
Figura 2. Etapas involucradas en el desruTollo de aplicaciones.

PROGRA1\1ACION DESDE CERO t!J.i 3;fi 13
En el proceso que vemos en el gráfico de la fij?ura 2, puede suceder que

debamos retroceder y volver a analizar o replantear algunas de las acciones.
Si bien este esquema nos será útil para la resolución de un desarrollo sencillo,
en caso de trabajar con sistemas amplios, deberemos incluir ciertas técnicas
de ingeniería de software. Repasemos los pasos expuestos en el esquema:
A) Análisis del problema

En primera instancia, tenemos el pedido de tm cliente, que determinamos
como requisito . Hay una situación que él desea solucionar o mejorar,
y que desembocará en la planificación de tm proyecto. Al haber aclarado
cuál es el fLmcionamiento o fm de la aplicación informática, debemos
realizar, como analistas, un releva111iento de la información implicada.
Cuando terminamos dicha tarea, podemos generar tm diagnóstico de
cómo encontramos los procesos actuales en los que se ve involucrada
la organización con respecto a la fL1tlrra herramienta informática.
B) Diseño de la solución
Luego de recolectar la información, ingresamos a la etapa de prototipado
o diseño del siste111a, en la que volcamos la recolección de datos para dar un
"rostro" a las aplicaciones. En esta fase estamos en condiciones de mostrarle a
nuestro cliente una propuesta teórica acerca de cómo funcionará el proyecto.
El término software libre a veces se confunde con freeware . Sin embargo, se trata de
conceptos distintos, ya que este último no tiene como condición ser gratuito. La deno-
minación de libre se debe a que son programas de código abierto (Open Source) , y es
en ese ptmto en donde reside la esencia de su libe1i ad.

14 l . Il\'TRODUCCIÓN A LA PROGRAt\ 1ACIÓN
Para el diseño de la aplicación, dividiremos el proceso en dos partes : por

un lado, el diseño de prototipos (interfaces gráficas de nuestro desarrollo);
por el otro, el diseño del funciona111iento (mecanismo interno de las opera-
ciones de desarrollo). Podremos crear la representación que refleje aspectos
del sistema mediante herramientas de modelado que nos facilitarán el dise-
ño, como mn, (Unified Modeling Language, lenguaje de modelado unificado).
Diseño de prototipos
El uso de propotipos nos facilitará la comtmicación con el usuario de
las aplicaciones, y nos permitirá conocer sus reacciones y apreciaciones.
El propotipo actuará no como producto fmal, sino como una maqueta me-
diante la cual podremos ver en detalle cómo es el ajuste entre las necesi-
dades del cliente y las características del producto.
Para crear formularios con controles, podemos utilizar las facilidades
que nos brindan algunos IDE (lntegrated Developrnent Environrnent o entor-
no de desarrollo integrado), como por ejemplo el de Visual Studio (www.
visualstudio.co111 ). Existen otras aplicaciones de maquetación que
pueden ser útiles, como l\lockingbird (https://go111ockingbird.co111),
1
Balsamiq C balsamiq.com), Pencil (pencil.evolus.vn) y l\ilicrosoft Visio

Chttp ://office.111icrosoft. co111/ es-ar/visio ).
Cliente No Cliente
Opción 1
Opción 2 o Costo 1
IS1 Costo 2
Opción 3 o Costo 3
Ximprimir)
( Registrar
Figura 3. Ejemplo de prototipo realizado con Mockingbird .

Diseño del funcionamiento

Como no podemos programar rápidamente en lenguaj e máquina (código
binario), necesitamos adaptar de alguna manera el lenguaj e humano a formas
lógicas que se acerquen a las tareas que puede realizar una computadora.
En el diseño de la solución utilizaremos algorit111os. Si bien encontrare-
mos múltiples defmiciones de lo que es tm algoritmo, nosotros trabajaremos
con la que brinda la RAE, en la que se hace referencia a un conjunto ordenado
y finito de operaciones que permite hallar la solución de un problema.
Por ej emplo, si deseamos vestir una remera, realizamos un proceso de selec-
ción entre tal o cual, y luego terminamos por hacer la selección deseada.
En un conjunto ordenado y fmito de operaciones, podríamos representar,
a través de un algoritmo, este proceso de selección y solución.
Elegir remera
Sí Vestirla
No
Sí Vestirla
No
Comprar
una nueva
Figura 4. Proceso de selección de una remera para vestir.

Esta representación de algoritmos se denomina diagrama de flujo

16 l . INTRODUCCIÓN A LA PROGRA1\1ACIÓN
En el desarrollo para ejecutar tma aplicación, esta serie de pasos

ordenados que deben seguirse para lograr la resolución de tm problema
(que conforman el algoritmo) debe ser traducida a sentencias ordenadas
de código de programación, que se ejecuten línea a línea.
Los algoritmos pueden ser representados por medio de diagramas
(como por ejemplo los diagramas de fluj o, tal co1no se observa en la
figura 4) o 1nediante la utilización de pseudocódigo , que veremos
con detenimiento en el capítulo 2 de este libro.
El pseudocódigo no es un lenguaj e de programación, sino un lenguaj e de
especificación de algoritmos, para lo cual utiliza una mezcla de lenguaj e co-
mún (protocolo humano) con instrucciones de programación. El obj etivo prin-
cipal es que el desarrollador se centre en la solución lógica del problema y
luego se enfoque en la sintaxis de un lenguaj e de programación en particular.
C) Traducción del diseño

a un lenguaje de programación
Existen muchos lenguaj es de programación para desarrollar, por medio
de un código (protocolo), sentencias algorítmica s que luego son traducidas
a lenguaj e máquina. Estos lenguaj es cumplen la función de intermediarios
entre el desarrollador y el hardware. Algunos son más rígidos y complicados
de aprender (como los de bajo ni,rel, que se codifican en lenguaj e máquina:
FORTRAN , ASSE.l\ffiLER , C), en tanto que otros son más comprensibles para
el lenguaj e humano (los de alto nivel: C++, Java , C#, PHP , Visual Basic).
Los diagramas de flujo son descripciones gráficas de algoritmos, que usan simbolos conecta •
dos mediante flechas para indicar secuencias de instrucciones. Su construcción es laboriosa y

son medianamente fáciles de leer para personas que no están involucradas en la programación .

PROGRAt\ 1ACION DESDE CERO t!Jj3;fi 17
Veamos las diferencias básicas que existen entre los distintos tipos
de lenguajes de programación:
• Lenguaje máquina : código interpretado directamente por el procesa-

dor. Las invocaciones a memoria, como los procesos aritmético-lógicos,
son posiciones literales de conmutadores físicos del hardvvare en su
representación booleana. Estos lenguajes son literales de tareas.
• Bajo nivel: instn1cciones que ensamblan los gn1pos de conmutadores;
son necesarios para expresar una mínima lógica aritmética y están
íntimamente vinculados al hardvvare. Estos lenguajes se encuentran
orientados a procesos compuestos de tareas, y la cantidad de instruc-
ciones depende de cómo haya sido diseñada la arquitectura del hard-
vvare. Como norma general, se encuentran disponibles a nivel firmvvare,
CMOS o chipset.
• Medio nivel : son aquellos que, basándose en los juegos de instruc-
ciones disponibles (chipset), penniten el uso de funciones a nivel
aritlnético. A nivel lógico, dependen de literales en ensamblador.
Están orientados a procedimientos co1npuestos de procesos.
• Alto nivel : permiten mayor flexibilidad al desarrollador (a la hora de
abstraerse o de ser literal), y un camino bidireccional entre el lenguaje
máquina y tma expresión casi oral entre la escrihira del programa y st1
posterior compilación. Están orientados a objetos.
A continuación, veremos el código fuente de dos lenguajes: e y Basic .
BASIC fhe diseñado en 1964, para facilitar el desaiTollo de programas de computación
a estudiantes y profesores que no se dedicai·an específicamente a las ciencias. Con los

años, el lenguaj e se popularizó e influyó en gran medida en otros, como Visual Basic.

18 l . INTRODUCCIÓN A LA PROGRA1\1ACIÓN
Se trata de ejemplos de cómo se vería el desarrollo en ellos. En el siguien-

te código veremos la declaración de variables en lenguaje C:
e
int mainO
{
/ * Declaración de variables */
int ano,dia;
int mes;
int total;
int i;
int sol;
}
En Basic, el código que aparece a continuación realiza lo siguiente:

en primer lugar, "limpia" la pantalla de cualquier texto, luego asigna
valores a las variables (como el nombre y un nú1nero ), y finaliza con
la impresión e11 pantalla del resultado.
BASIC
CLS
nombre1$="George Kemeny"
valor1=500
..
nombre2$="Euaene Kurtz"
.
valor2=350
PRINT nombre! $
PRINT valorl
PRINT nombre.2$
PRINT valor2

D) Implementación y testeo del proyecto

Una vez desarrollado y compilado el software , es momento de instalarlo.
A continuación, veremos qué aspectos debe1nos tener en cuenta en el
mome11to de Íl1stalar el sistema:
• Prueba o testing de la aplicación : este proceso implica someter el

softvvare a ciertas condiciones para demostrar si es válido o no. De esta
manera, podemos verificar si se ajusta a los requerimientos y validar
que las fLmciones se implementen correctamente. Los valores de cali-
dad que tienen mayor relevancia en las aplicaciones son: usabilidad ,
funcionalidad , fiabilidad , seguridad, eficiencia y 111anteni111iento.
• Capacitación y for111ación del usuario : debe encararse desde el
punto de vista de los usuarios. Puede ser útil preguntarles, durante
la capacitación, cómo hacían antes ciertos procesos o tareas. Depen-
diendo del tipo de actividad que se vaya a desempeñar, la capacita-
ción puede acompañarse con algLmos manuales de usuario.
A lo largo de este capítulo hemos visto el proceso de desarrollo de un sistema, y también

conocimos la comunicación que tiene el hardware con los programas intangibles y ab stractos.
Vimos que esta comunicación se desarrolla p or medio de un lenguaje máquina, que nos comu-
nicamos con el equipo electrónico p or medio de interfaces, y que el lenguaje de programación

permite indicar las acciones p or realizar, a través de algoritmos.

20 [!f:1#,-!-i l . INTRODUCCIÓN A LA PROGRA1\1ACIÓN
Actividades
TEST DE ..\UTOEV..\LU..\CIÓN
1 ¿Qué es un lenguaje de alto nivel?
2 ¿Qué es un algotitmo?
3 ¿Cómo se comunica el hard\vare con el sofuvare?
4 ¿Qué es el código binatio?
5 Desc1iba los pasos generales que ocwTen en el desatTollo de una aplicación.
Si tiene alguna consulta técnica relacionada con el contenido, puede contactarse

con nuestros expertos: profesor@redusers.com .

/ / / / / / / / / / / / / //,
Pseudocódigo
En este capítulo veremos cómo representar algoritmos mediante

el uso de pseudocódigo. Aprenderemos qué tipos de datos existen,
y trabajaremos con variables y operadores .
• Pseudocódigo: ..\ri t1n éti co s ................................. 3 2

el lenguaj e humano .................... 22 Lógicos ....................................... 33
Relacionales ............................... 3 7
• Tipos de datos ............................ 24
• Asignación de valores ............... .38
• Variables ..................................... 26 Entrada y salida de información... 42
Clasificación de las variables ........ 28
Normas de escritura ................... 30 • Resumen ..................................... 43
• Operadores ................................ .3 2 • Actividades ................................. 44

22 2. PSEUDOCÓDIGO
Pseudocódigo:
el lenguaje humano
Existen dos modos de representar algoritmos : mediante gráficos
(como los diagramas de flujo o los diagramas Nassi-Shneiderman) o por
medio de una sintaxis, como pseudocódigo. Las ventajas de utilizar un
pseudo-código, en vez de tm diagrama de flujo, son las siguientes:
• Ocupa menos espacio en la hoja de papel.

• Permite representar fácilmente operaciones repetitivas complejas.
• Simplifica el pasaj e de un pseudocódigo a un lenguaj e de programación.
• Permite observar con claridad los niveles que tiene cada operación.
El pseudocódigo posee una escritura similar a la de un lenguaj e de pro-

gramación, por lo tanto, contiene un determinado léxico. Se trata de letras
o caracteres que serán válidos para escribir las instrucciones que deseamos
transmitir. La sintaxis es la especificación de palabras clave en combinación
con otras que usaremos para formar las oraciones, mientras que la semántica
es el significado que les daremos a dichas frases . Una de las normas generales
que encontraremos es la estructura secuencial : una acción o instrucción que
sigue a otra en secuencia. Las tareas se suceden de tal modo que la salida de
una es la entrada de la siguiente, y así hasta el fin del proceso. En la figura 1,
vemos cómo se representa una estructura secuencial en pseudocódigo.
En los lenguaj es de programación, la inclentación es un tipo de notación secundaria utili-

zada para mej orar la legibilidad del código fuente, teniendo en cuenta que los intérpretes
raramente consideran los espacios en blanco entre las sentencias de un programa.

PROGRA1\1ACION DESDE CERO t!hi 3 '+-fi 23
Pseudocódigo Diagrama de tlttjo
Inicio
Inicio Acción 1
Acción 1
Acción 2
• Acc.ión 2
•
•
Acción N
•
Fin •
•
l
Acción N
Fin
"
Figura 1. Comparación de pseudocódigo y diagrama de flujo, que nos

ayuda a comprender el funcionamiento del código por desruTollar.
En la derecha, por medio de símbolos; y en la izquierda, de forma textual.
Para comprender más sobre el uso de pseudocódigo y la estructura secuen-

cial, realizaremos el siguiente ejemplo clásico : poner en marcha un automóvil.
W, ¿TE RESULTA ÚTIL?

Lo que estás leyendo es el fruto del trabajo de cientos de personas que ponen todo de si para lograr un mejor
producto. Utilizar versiones ''pirata" desalienta la inversión y da lugar a publicaciones de menor calidad .
NO ATENTES CONTR.A LA LECTURA. NO ATENTES CONTRA Tf. COMPRA SÓLO PRODUCTOS ORIG INALES.
r,IJ•"',lr.i"-f::~!r.-1< '.'," ;,·-,n,•r-~11:,r,·11~.i-,c,c¡,.·· ;·,i_, .._•,r-.~• .·,,,:t ·,·, 1·,·,··11,1, ,,-_,¡.-, ·, r1 ¡,j,,,-. ·,. j' •í'll· I _;j -1 :,•·r•·
ll:>'.'1';',.;, [1'1.!l.~-•-·I) . ·~ • ~'' ': · 1'1]!,li,j J .. t:., ' 'I• f '.,1!111 , j .l· I • ·_.,l:• I ·11 ,·. , , .,,:,". 1, ,11! ,_: t.r 1:' f:• ,, ,,: : ,:,, l,' ,,: [. :· 1 r,,j ,',•., ,,"

24 2. PSEUDOCÓDIGO
Inicio
!Presjo¡¡ar !.¡ pedal acelerador

IGuar ! la llave de posición
) Et:.tru.ctur.a" dearran ue
a girar la llave y
aso como má'Wno 3 veces
no arra~ l
mecánico
Fin
Figura 2. Podemos obse1var la explicación de pseudocódigo para ruTancar un automóvil.
En el ejemplo podemos observar que la estructura es secuencial, que se

indica el INICIO y FIN del programa, que en el margen izquierdo se deja tm
espacio llamado indentación para identificar fácilmente las estructuras,
y que cada instrucción comienza con un verbo.
Tipos de datos
Para representar la información o las reglas que permitan cambiar fórmulas
matemáticas a expresiones válidas de computación, hay que tener en cuenta
los tipos de datos. A nivel de la máquina, se representan como una serie de
bits (dígito 1 o O) y tienen un tipo asociado en la programación. Por ej emplo,
un dato puede ser una simple letra (como b) o un valor numérico (como 35).

- Numerioos
Simples Lógicos
- Alfanuméricos
Tipos de
datos
Arreglos
- (Vectores,
matrices\
Estructurados
- Registros
(def. por el
usuario) -- - .d..rchivoo
- Apuntadores
Figura 3. Tipos de datos. La categoría del dato dete1mina la naturaleza

del conjunto de valores que puede tomar una vruiable.
DATOS SIMPLES
T TIPO T DESCRIPCIÓN T EJDIPLO
Datos numéricos Representan valores escalares de forma numérica 500

y permiten realizar operaciones aritméticas 230
comunes ( +, - , x, f). 5000000
Datos Representan valores identificables de forma Texto

alfanwnéricos descriptiva. También pueden representar v@lor3s
números, pero no es posib le hacer operaciones texto 123 45
matemáticas con ellos. Estos datos se
representan entre comillas.

26 2. PSEUDOCÓDIGO
DATOS SIMPLES (CONTINUAOÓN)
Datos lógicos Solo pueden tener dos valores l +O=O

(verdadero o falso), ya que representan Falso
el resultado de la comparación entre otros datos
(numéricos o alfanuméricos) . !+ != !
Verdadero
O+l =O
Falso
2>3=0=Falso
3>2= 1=Verdadero
Tabla l. Lista comparativa de datos simples que podemos utilizar

en el desruTollo de código de ejemplo.
Variables
Los nombres que representan el valor de un dato, ya sea numérico o
alfanu1nérico, son variables. En esencia, u11a variable es un espacio en
la 1nemoria de la computadora, que permite almacenar temporalmente
un dato durante la ejecución de un proceso, y cuyo contenido puede
cambiar 1nientras corre un programa.
Para utilizar una variable, debemos darle un notnbre con el cual
identificarla dentro de u11 algoritmo. Es posible crear tantas variables
co1no sean necesarias. Así, por ejetnplo, pode1nos crear:
• A = 100 : variable tipo numérica A cuyo valor es 100.

• Ciudad = "Córdoba" : variable alfanumérica o de tipo carácter
Ciudad, cuyo valor es "Córdoba".

• 1\. = e + B : variable numérica A cuyo valor es la sl1ma de los valores

de las variables numéricas C y B. Es una variable calculada.
El valor que les damos a las variables se llama asignación . Se trata

del proceso que tendre1nos que efectuar cuando queramos grabar algo
en la variable o hacer una operación aritmética. La asignación consis-
te en el paso de valores a una zona de la 1nemoria, que puede ser una
variable. Dicha zona será reconocida con el nombre de la variable que
recibe el valor, y se puede clasificar de la siguiente forma:
• Si111ple: consiste en pasar lm valor constante a lma variable.

Dos ejemplos: a 15;
a = 15.
• Contador : sirve para verificar el número de veces que se realiza
lm proceso. Dos ejemplos: a a + 1; a= a + l.
• Acumulador : se utiliza como un sumador en un proceso.
Dos ejemplos: a a+ b ; a= a + b .
• De trabajo : puede recibir el resultado de u11a operación 1natemática
que involucre 1nuchas variables. Dos ejemplos: a e + b * 2 / 4;
a=c + b*2 / 4.
Por lo general, en el pseudocódigo que escribimos en papel, se utiliza la

flecha como símbolo de asignación ( ), pero también podemos usar el igual
(=) para representar esta acción.
Las constantes son declaraciones de datos a las que se les asigna un espacio en
la memoria para su almacenamiento. Estas declaraciones no cambian durante la eje-
cución del programa. Por ejemplo, podemos utilizar datos que deben tener un valor
único que no se modifique.

28 2. PSEUDOCÓDIGO
Clasificación de las variables

Ahora que ya hemos visto lo que significa la asignación de valores en varia-
bles, pasemos a estudiar a fondo la clasificación y las características de estas.
~
Numericas
Por su Lógicas
contenido
~
Alfanuméricas
Variables
~
De trabajo
Por su
uso Contadores
~
Acumuladores
Figura 4. La clasificación de las variables se dete1mina en fi.mción de su contenido y uso.
En la tabla 2 ve1nos las variables que podemos crear de acuerdo

a su contenido, ju11to con su descripción y ejemplo.
Los identificadores representan los datos de un programa, constantes, vruiables

y tipos de datos. Se trata de una secuencia de cru·acteres que suve pru·a identificru·
una posición en la memoiia de la computadora y obtener el acceso a su contenido.
Ejemplo : Nombre; Numero_ horas; Calificacion.

VARIABLES DE ACUERDO A CONTENIDO
T VARIABLE T DESCRIPCIÓN T EJDIPLO
Variables Ahnacenan valores numéricos Costo 2500

numéricas (positivos o negativos) , es decir: números IV A 0.15
del O al 9, signos (+ y -) y el punto decimal. PI 3.1416
Variables lógicas Solo pueden tener dos valores (cierto o Habilitado O

falso) , que r epr esentan el r esultado de una Habilitado 1
co mp aració n entre otros datos.
Variab les F ormadas por caracteres alfanuméricos Letra ' a '

alfanuméricas (letras, números y caracteres esp eciales).
Apellido 'ramos'
Dirección ' Rondeau 165'
Tabla 2. Tipos de variables que existen en función de su contenido.
En la tabla 3 se muestran las variables que podemos crear por su uso,

junto con su descripción y ej emplo .
VARIABLES DE ACUERDO A USO
T VARIABLE T DESCRIPCIÓN T EJDIPLO
Variab les Reciben el resultado de una operación Suma = a + b /c

de trabaj o matemática completa y se usan
normalmente dentro de un programa.
Contador es Llevan el co ntrol del número cuando se r ealiza Contador = Contador +1

una operació n o se cump le una co ndició n, co n
los incrementos generalmente de uno en uno .

30 t!f:1#,-!-i 2. PSEUDOCÓDIGO
VARIABLES DE ACUERDO A USO (CONTINUAOÓN)
Acumuladores Llevan la suma acumulativa de una serie Acu = Acu + Calculo

de valores que se van leyendo o calculando
progresivamente .
Tabla 3. Lista comparativa de los tipos de vruiables que existen en función de su uso.
Normas de escritura
Retomando las normas generales para escribir en pseudocódigo, de-
bemos tener en cuenta cómo vamos a crear o declarar estas variables en
nuestro programa. Dado que las expresiones se asemejan al lenguaje hu-
mano, podemos utilizar la palabra "variable." para declarar una de ellas :
Th"lCIO
\Tariable Nombre
\Tariable Edad
Nombre "Juan"
Edad 20
.Tvlostrar Nombre Y Edad
FIN
Como podemos observar en el ejemplo, no solo creamos o declaramos

la variable y le dimos un nombre, sino que también especificamos qué
tipo de dato se puede almacenar en ella y, luego, le asignamos tm valor.
El modelo que utilicemos dependerá del nivel de trabajo que queramos
realizar. Lo mejor sería dejar todo detallado en el pseudocódigo, para así,
después pasarlo al lenguaje de programación sin mayores inconvenientes.
Por ejemplo, la sintaxis sugerida sería:

PROGRAt\1ACION DESDE CERO 31
Variable Nombre_de_la_variable tipo_de_dato
Ejemplos válidos de nombres de variables :
Vruiable FechaNueva
Vruiable H123
Vru-iable Cantidad de Alumnos
Vru-iable Pedido.Almacen
Ejemplos no válidos de nombres de variables :
Vruiable lcontador
Vruiable p1imer-valor N
Algunos lenguajes de programación deben tener declaradas las

variables que se van a utilizar en todo el programa. De esta fonna,
al comenzar el programa, estarán declarados el nombre, el tipo
(numérica o alfanumérica) y el valor inicial.
Las variables también pueden inicializarse dándoles tm valor inicial.
Por defecto, todas las variables para las que no especifiquemos un valor
inicial valen cero si son de tipo numérica y nulo si son de tipo carácter/
texto. Cabe destacar que el tipo de dato nulo no es cero ni espacio en
blanco, es nulo (tma traducción podría ser vacío).
Pru·a dru· nombres a las vruiables, debemos saber que pueden tener hasta 40 c.ru·ac-
teres, deben empezru· obligato11amente con una letra (a-z o A-Z), no pueden contener
espacios en blanco; el resto de los dígitos pueden ser números, y es posible incluir
cru·acteres especiales (como el guion o el ptmto).

32 2. PSEUDOCÓDIGO
Operadores
En todos los casos en que precisemos realizar desarrollos para solucionar
algún inconveniente, nos veremos involucrados en la necesidad de efectuar
operaciones de distintos tipos : suma, resta, concatenación, procesos lógicos,
etcétera. Estos elementos se relacionan de modo diferente, con valores de
una o más variables o constantes. A continuación, veremos los operadores
que podemos utilizar en el pseudocódigo para manipular valores.
Aritméticos
Los operadores aritméticos permiten hacer operaciones matemáticas
con valores de variables, y pueden usarse con datos enteros o reales.
Los tipos que podemos encontrar son:
• +: suma
• -: resta
• *: multiplicación
• 1: división
• " : potenciación
• mod : resto de la división entera
Veamos algunos ej emplos de uso :
En el camino del desruTollo nos encontrru·emos con diferentes tipos de datos que
aceptan tener el valor NULO . Pueden tener referencias como NULL o null , dependien-
do del lenguaje. Esto se utiliza pru·a indicru· que el tipo de dato no tiene ningún valor
asignado y, frecuentemente, se aplica en bases de datos.

Expresión Resultado
7/ 2 3.5
12 mod 7 5
4+2 *5 14
Es importante tener en cuenta la prioridad de los operadores aritmé-

ticos. Todas las expresiones entre paréntesis siempre se evalúan primero.
Aquellas con paréntesis anidados se evalúan desde adentro hacia afuera
(el paréntesis más interno se evalúa primero). Dentro de tma misma expre-
sión, los operadores se evalúan en el siguiente orden:
1) " (potenciación)
2) *, ! , mod (multiplicación, división, módulo)
3) +, - (suma, resta)
Los operadores que se hallan en una misma expresión y con igual nivel
de prioridad se evalúan de izquierda a derecha. Ejemplos :
4 +2 * 4 = 12
23 * 2 / 5 = 9.2
3 + 5 * (10 - (2 + 4)) = 23
2.1 * (1 .5 + 12.3) = 2.1 * 13.8 = 28.98
Lógicos
Los operadores lógicos se utilizan para establecer relaciones entre valores
lógicos, que pueden ser el resultado de una expresión relacional. Por lo gene-
ral, pueden tomar dos valores para indicar su estado : 1 (Verdadero o True ) y O
(Falso o False). Los tipos de operadores lógicos que podemos encontrar son:
• Al\iD : y
e OR : O
.,
• NOT : negac1on, no

34 [-1-i#,-!.j 2. PSEUDOCÓDIGO
Figura 5.
En este ejemplo de operadores lógicos,
T significa verdadero YF, falso·
Las vruiables son a=l O, b=20 y c=30.
Podemos ver que tanto la primera expresión como la segunda son ver-
daderas y, por eso, el resl1ltado fmal también lo es. Las posibles combina-
ciones lógicas que encontraremos con los diferentes operadores se mues-
tran en las siguientes tablas.
El operador .41\ITI cumple una condición y la otra. Supongamos que crea-
mos las variables ED.l ill y ALTUR.4 y, en la primera parte, preglmtamos en
pseudocódigo si ED.l ill es mayor que 18 y ALTURA es menor que 1.70.
Esta expresión devolverá el resultado verdadero solo si ambas son verdaderas.
(Edad> 18) AND (Altura< 1.70)

Veamos qué sucede si las variables toman los siguientes valores :
Una cadena o string es una sucesión de cru·acteres que se encuentran delimitados

~
por comillas ( ""). La longitud de la cadena es la cantidad de cru·acteres que la for-

man, incluyendo los espacios, que son un cru·ácter más. Por ejemplo: "Sudamé1ica,
Argentina" es una cadena de longitud 2 1.

• (Edad 21) AND (Altura 1.90): el resultado sería verdadero .

• (Edad 12) AND (Altura 1.90): el resultado sería falso
• (Edad 21) AND (Altura 1.50): el resultado sería falso
OPERADOR AND
Verdadero AND Verdadero Verdadero
Verdadero Falso Falso
Falso Verdadero Falso
Falso Falso Falso
Tabla 4. En la aplicación del operador ANTI, el hecho de que alguna

de las condiciones sea falsa hará que el resultado también lo sea.
El operador OR u O se utiliza para preguntar acerca de una condición u otra;

el resultado será verdadero siempre y cuando alguna expresión también lo sea.
OPERADOROR
T CONDIOÓN 1 T OPERADOR T CONDIOÓN 2 T RESULTADO
Verdadero OR Verdadero Verdadero
Verdadero Falso Verdadero
Falso Verdadero Verdadero
Falso Falso Falso
Tabla 5. Operador oR: el resultado solo será falso si ambas condiciones son falsas.

36 2. PSEUDOCÓDIGO
Supongamos que creamos las variables EstadoCivil y Sueldo, y,

en la primera parte, pregu11tamos en pseudocódigo si EstadoCivil es
igual a e (entendiéndose que e es Casado) o si Sueldo es mayor que 2000 .
Esta expresión devolverá verdadero si alguna de las dos es verdadera.
(EstadoCivil = 'C') OR (Sueldo > 2000)
e (EstadoCivil 'C') OR (Sueldo 1000) : el resultado sería verdadero

e (EstadoCivil 'S') OR (Sueldo 2100) : el resultado sería verdadero.
e (EstadoCivil 'S') OR (Sueldo 1500) : el resultado sería falso.
El operador NOT o NO se usa para preguntas de negación en las condiciones

deseadas. El resultado será opuesto al de su estado original.
Supongamos que creamos la variable Sexo, donde guardamos Iv1asculino o

Femenino, y queremos preguntar por aquellas variables que NO son Femenino.
NO (Sexo ="Femenino")
• Sexo "Masculino" : el resultado será verdadero .

• Sexo "Femenino" : el resl1ltado será falso .
PRIORIDADES DE RESOLUCIÓN
T OPIRADORIS LÓGICOS T DESCRIPCIÓN T EJDIPLO
l) NOT Negación (NO) !) ( )

2) AND Producto lógico (Y) 2) A
3) 0 R Suma lógica (O) 3) *, !, mod, NOT
4) +, -, A."\/D
5) > , <, >= , <=, <>, =, OR
Tabla 6. P1i0Iidades en la resolución de operaciones ruitméticas.

PROGRAt\ 1ACION DESDE CERO t!J.i 3;fi 37
Relacionales
Se utilizan para establecer una relación entre dos valores. Al co1npa-
rar estos valores entre sí, se produce un resultado verdadero o falso .
Los operadores relacionales comparan valores del mismo tipo, numéricos
o cadenas. Tienen igual nivel de prioridad en su evaluación.
OPERADORES RELACIONALES
T OPERADOR T COl\lPLDIINIO T OPERADOR T COl\lPLDIINIO
< >= l\,í enor que l\,í ayor o igual que
<= > l\,í enor o igual que l\,í ayor que
> <= ::vlayor que l\,í enor o igual que
>= < l\,í ayor o igual que l\,í enor que
= Igual que Distinto de (diferente)
..!. Distinto de (diferente) Igual que
Tabla 7. Los operadores relacionales tienen menor prioridad que los aritméticos.
Veamos algLmos ejemplos y sus correspondientes resultados:
• 25 <= 25: verdadero

• 25 <> 25: falso
• 50 <= 100 : verdadero
• Si a = 10, b = 20, c = 30
• a + b > c: falso
• a - b < e : verdadero
• a-b = e : falso
• a* b <> e: verdadero

38 2. PSEUDOCÓDIGO
Y veamos ahora algunos eje111plos no lógicos :
• a<b<c
• T > 5 < 30: no es lógico porque tienen diferentes operandos.
Cuando se comparan caracteres alfanuméricos, se lo hace de uno

en uno, de izquierda a derecha. Si las variables son de distinta longitud,
pero exactamente iguales, se considera que la de menor longitud es menor.
Los datos alfanuméricos son iguales si y solo si tienen la misma longitud y
los mismos componentes. Las letras minúsculas son mayores que las mayús-
culas, y cualquier carácter numérico es menor que cualquier letra mayúscula
o minúscula. Teniendo en cuenta esta explicación, la sintaxis de prioridad es
la siguiente: carácter numérico < mayúsculas < minúsculas . Ej emplos:
• "A" < "B" : verdadero

• "AAAA''"> "AAA" : verdadero
• " B"> "AAAA" : verdadero
• "C" < "c" : verdadero
• "2"< " 12" : falso
Asignación de valores
Como hemos visto anteriormente, para que una variable tome
un valor, debemos asigi1árselo en pseudocódigo por medio de = o J3 .
La cooperación de asignación le permite a la computadora evaluar una expre-
sión matemática y almacenar el resultado final en una determinada variable.
La sintaxis que podemos utilizar para la asignación es la siguiente:
Nombre_de_la_ vruiable expresión o vruiable
Para la construcción de un enunciado de asigi1ación, es preciso

co11siderar ciertas reglas :

• Toda variable del lado derecho debe estar defmida.

• Solo la variable de la izquierda puede cambiar de valor cuando
antes tenía tm valor asignado.
• Las variables del lado derecho conservan su valor.
Si la variable de la parte izquierda está también en la derecha,
cambia de valor por aparecer en la izquierda.
ASIGNACIÓN A VARIABLES
· · · · T CARACTIRIS O
T ASIGNAOONARIThlETICA T ASIGNAOON LOGICA CADENA DE CARACTIRIS
Variable varl, var2, Variable varl, var2, Variable vCad, car tipo texto
var3 tipo numérico var3 tipo lógico
varl 3+4*2 varl 5 < 2 car 'S'
var2 0.65 / 0.2 var2 7 >= 3 vCad '25 de diciembre

de 1998'
var3 var l / var2 var3 var l o var2
Tabla 8. En la asignación a vruiables, el símbolo indica que el valor de la prute

derecha del enunciado se le asigna a la vruiable de la izquierda.
~ ASIGNACIÓN DESTRUCTIVA
~
Cuando decimos que toda asignación es destn1ctiva, significa que el valor previo que
tiene la vruiable se pierde y se reemplaza por el nuevo valor asignado. Así, cuando
se ejecuta la secuencia B 25 / B 100 / B 77, el valor final que toma B es 77,
ya que los valores 25 y 100 son destntidos.

40 2. PSEUDOCÓDIGO
ALGORITMO c.Jci>La, el áru Encabezado: empezar con la palabra

1 - " ..
AI.GOR!Th10 seguida por una descripción
ade.cuada al problema a resolver.
Il<1Cl0 Inicio del algoritmo: indicar el inicio

del algoritmo / código.
constante lij>o real =3.1416 Declaración de variables y constantes:

variable Radio, .'-.rea tipo re.al definir los valores que no cambian en el
transcurso del algoritmo. Definir las
variables que sean necesarias para resolver
el problema, identificindolas oon nombre
y determinando sus tipos de datos.
Radie 5
Are~ ~adlb Radio
Instruociones: cada instruoción puede
~lOSTRAR .'-.rea
ser cilculos o sentencias para procesar
FlN o mostrar infonnación.
Figura 6. En este esquema, el valor de Radio se asigna por código como 5.
Hemos visto el inicio de la codificación en pseudocódigo, el uso de

variables y operadores, y la asignación de valores. A continuación veremos un
esquema que nos ilustrará, mediante un ej emplo sencillo, cómo se confeccio-
naría un pseudocódigo para presentar en un caso concreto. Para ca pturar un
valor que el usuario pueda ingresar, podemos utilizar las palabras LEER
o l\ilOSTRAR. En el caso de LEER, ca pturaremos un valor para la aplica ción;
mientras que MOSTRAR dará un resultado. Podemos verlo en la figura 7.
Pasemos a un ej emplo más específico, donde debamos hacer un algoritmo
que nos permita calcular el sueldo básico de una persona. Para esto, es nece-
sario ingresar por teclado la tarifa horaria y el número de horas trabaj adas.
En las asignaciones debemos tener en cuenta los símbolos + e &, que utili-
zaremos para unir o concatenar datos. Dependiendo del tipo de lenguaj e que
vayamos a utilizar, usaremos el símbolo indica do para conca tenar.
En los siguientes ej emplos usaremos el +:
• Expresión: "Pseudo"+ "código" . Resultado : "Pseudocódigo"

• Expresión: "3"+ "4567" . Resl1ltado : "34567"
• Expresión: "Hola "+ "¿qué tal?" . Resultado : "Hola ¿qué tal?"

PROGRA1\1ACION DESDE CERO t!hi 3 '+-fi 41
Il<1Cl0 Inicio del algoritmo: indicar el inicio

del algoritmo / código.
constante lij>o real =3.1416 Declaración de constantes y variables:

variable Base, Altura, .'-.rea tipo re definir los valores que no cambian en el
transcurso del algoritmo y las variables que
sean necesarias para resolver el problema,
identificindolas oon un nombre
LEER Base, Altura v determinando sus ti os de datos.
.'-.rea <- Base "Altura
Instruociones: cada instrucción puede
~lOSTRAR .'-.rea ser citcuto o sentencia para procesar
o mostrar infonnación.
FlN
Figura 7. En este esquema de pseudocódigo vemos usos de LEER y l'vIOSTRAR ,
' • •
• -
' ' .. - F.n r-.:thP.1:::iéln· Pm p n:::ir r.n n 1:::i p :::il:::ihr :::i
.AJ.GOR!Th10 seguida por una descripción
ade.c uada al problema a resolver.
Il<1Cl0 Inicio del algoritmo: indicar el inicio del

algoritmo / código.
-
constante C-0st0Hora tipo re.al= 9.5 Declaración de variables y constantes:
variable CantidadHoras,
Sueldo tipo re.al
- declaración de constantes. Definir los valores
que no cambian en el transcurso
del algoritmo. Definir las variables que sean
LEER Cantidad.Horas
- necesarias para resolver problema,
identificindoias oon un nombre
Sueldo <- Cantidad.Horas'CostoHora v detenninando sus tioos de datos.
Instrucciones: cada instrucción puede

~lOSTRAR Sueldo
- ser cilculos o sentencias para procesar
FlN
o mostrar información.
Figura 8. En este esquema, la fórmula del sueldo es:

Sueldo = Costo hora. x Ca.n tida.d de horas
En casos más complej os, debemos utilizar determinadas estructuras.

A continuación las veremos en detalle.

42 2. PSEUDOCÓDIGO
Entrada y salida de información

Para procesar los datos que va1nos a obtener de parte del usuario,
debemos asigi1arlos a variables. Para esto, utilizamos la instrucción
LEER o, también, INGRESAR . Por ejemplo:
vruiable vru·Numero tipo numero

LEER vru·Numero
Dicha instrucción le pide al usuario que ingrese un valor que luego será
asignado a la variable vru·Numero .
vruiable Edad, Peso tipo numero

vruiable Sexo tipo texto
LEER Edad, Peso, Sexo
Esto representa la lectura de tres valores que se van a almacenar en las varia-
bles Edad, Peso y Sexo. Con el código anterior, hemos capturado información para
nuestro programa utilizando pseudocódigo. Si deseamos mostrar un resultado
en tm mensaje, usamos la instrucción IMPRIMIR o :tvIOSTR.<\R . Por ejemplo :
IMPRIMIR"Hola" // MOSTRAR"Hola"
Cuando en pseudocódigo queremos mostrar en pantalla el mensaje

"Hola", debemos recordar que la palabra tiene que ir entre comillas, porque
pertenece a una cadena de texto.
vruiable A tipo numero B 520

I:tvIPRI:tvIIR A // :tvIOSTR.<\R A
De esta forma, podemos mostrar en la pantalla el valor que está almacena-

do en la variable A (en este caso, el número 520).
vru-iable A, B, Promedio tipo numero
A 15

B7
Promedio fi (A + B) / 2
I:tv1PRI:tv1IR"El valor del promedio es:", Promedio
//MOSTRAR"El valor del promedio es:", Promedio
Esta instrucción muestra el mensaje que está entre comillas y, luego,

el valor de la variable promedio. La coma separa el mensaje de la variable,
y el resultado de Promedio es 11 . De este modo, lo que se verá en pantalla
será el mensaje que sigue : El valor del promedio es: 11 .
También tenemos la posibilidad de mostrar un mensaje cuando le solicita-
mos algún dato al usuario, por medio del comando LEER:
vruiable edad tipo numero fi O

LEER"Ingrese su edad", edad
El valor de la variable que le pedimos al usuario se asigna a edad.

Esta instn1cción se verá de la siguiente forma en la pantalla:
Ingrese su edad ?
Hasta aquí hemos visto la manera de declarar y utilizar las variables con
sus tipos de datos, el uso de los diferentes operadores, y cómo tomar los
valores que ingresa el usuario y mostrar la información. A continuación, en el
capítulo 3 , aprenderemos a realizar la parte "inteligente", que nos permitirá
resolver diferentes sih1aciones que puedan presentarse en la programación.
En este capítulo hemos aprendido a creru· algo1itrnos por medio de pseudocódigo,

el lenguaje "común" que podemos utilizar para cualquier lenguaje de programación.

44 2. PSEUDOCÓDIGO
Actividades
1 ¿Qué no1mas debemos tener en cuenta en el rumado de pseudocódigo?
2 ¿Cuál es la diferencia entre contador, acumulador y vruiable?
3 ¿Pru·a qué se usan los operadores ruitméticos? ¿Y los lógicos?
4 ¿Cómo se emplea la asignación en pseudocódigo?
5 En pseudocódigo, ¿cuáles son las palabras que podemos utilizru·

pru·a indicru· a los usuru'Íos que esc11ban algo y, luego, capturru·lo?


///////////////,
Estructuras de
.,
programac1on
El funcionamiento del equipo se basa en la ejecución de los comandos
a medida que se va leyendo el archivo (de arriba hacia abajo), hasta
alcanzar un comando que lo dirija hacia una ubicación específica del
progran1a. Para que este trabajo se realice correctan1ente, es in1portante
que la infom1ación esté organizada y estn1ctlrrada de fom1a adecuada.
• Estructuras de control. .............. 46 • Subalgoritmos ............................68

Estructuras condicionales ........... 46 Funciones .................................. 69
Estructuras repetitivas o cíclicas ... 55 Procedimientos ........................... 75
• Datos estructurados .................. .58 • Resumen ..................................... --

,,
\ ;ectores ...................................... 59
Matrices ..................................... 63 • Actividades ................................. i8
46 3. ESTRUCTURAS DE PROGRAt\ 1ACIÓN
Estructuras de control
Las estructuras de control son formas de trabaj o que, mediante el manej o
de variables, permiten realizar procesos específicos para solucionar proble-
mas. Las que esh1vimos utilizando anteriormente son estructuras secuen-
ciales , es decir, instrucciones en orden, que se suceden una a otra.
- Asignación
Secuenciales Entrada
- Salida
- Simp les
Estructuras
Condicionales Dobles
Algorítmicas
- lvlúltip les
- Para
Cíclicas lvlientras que
- Repita hasta
Figura 1. Las estructuras de control se clasifican de acuerdo con su complejidad.
Estructuras condicionales
En las estruchlras condicionales se compara una variable con otros
valores para que, sobre la base del resultado, se siga un curso de acción
dentro del programa. La comparación puede hacerse con otra variable o
con una constante, según sea necesario. Existen tres subtipos básicos:
simples , dobles y múltiples .

Estructuras condicionales simples

Las estn1chrras condicionales simples se conocen como estructuras
de toma de decisión y tienen la siguiente sintaxis:
Si <condición> entonces
Instrucción/es
Fin Si
• Si : indica el comando de comparación.

• Condición : indica la condición por evaluar.
• Instrucción : son las acciones por realizar cuando se cumple o no la condición.
Vea1nos un ejemplo en pseudocódigo: preguntare1nos si la edad de

una persona es mayor o igual a 18 años; si esta condición se cu1nple,
mostraremos el mensaje "Es mayor".
Th"lCIO
, , ariable edad tipo numero
edad 15
/!Podemos utilizar LEER edad si deseamos
que un usuario ingrese por teclado el valor
Si edad >= 18 entonces
l\{OSTRAR "Es mayor"
Fin Si
FIN
Por lo general, en las anotaciones en fonna de co1nentario, tanto en

pseudocódigo como en algu11os lenguajes de programación, podemos
encontrar que anteceden los signos de barras: 11.
Si desea1nos comparar valores de variables, podemos considerar
el siguiente ejemplo: contamos con la altura de dos personas, A y B.
Si la persona más alta es A, mostrare1nos un mensaje.

48 3. ESTRUCTURAS DE PROGRA1\1ACIÓN
Th"lCIO
, , ariable alturaA, alturaB tipo real
alturaA 1.5
alturaB 1.9
/!Podemos utilizar LEER alturaA, alturaB si deseamos
que un usuario ingrese por teclado los valores
Si alturaA >= alturaB ento nces
iVIOSTRAR "L a pe.rson a m ás alta es A"
Fin Si
FIN
Otro ejemplo que podemos tomar para tm cálculo con variables es el

siguiente: sumamos dos valores y, si el resultado de la operación es mayor
que 50, informamos " El valor es ALTO" . Veamos el código :
Th"lCIO
Variable nu1neroA, nu1ner0B tipo nu1nero
numeroA 15
numeroB 20
/!Podemos utilizar LEER numeroA, numeroB si deseamos
que un usuario ingrese por teclado los valores
Si (numeroA + numero B) > 50 ento nces
iVIOSTR;\R "El valo r es ALTO"
Fin Si
FIN
El pseudocódigo pe1mite representar fácilmente las operaciones repetitivas complejas,

agilizar el pasaje a lenguaj e de programación formal, y mostrar los niveles y estructuras.

Estructuras condicionales dobles

Las estructuras condicionales dobles permiten elegir entre dos opcio-
nes, en fLmción del cumplimiento o no de tma determinada condición.
Tienen la siguiente sintaxis:
Instrucción/es
Sino
Instrucción/es
Fin Si
• Si : indica el comando de comparación.

• Condición : indica la condición que se va a evaluar.
• Entonces : precede a las acciones por realizar si se cumple la condición.
• Instrucción : son las acciones que se realizarán cuando se cu1nple
o no la condición.
• Sino : precede a las acciones por realizar cuando no se cumple la con-
dición. Dependiendo de si la comparación es cierta o falsa, es posible
realizar tma o más acciones.
A continuación utilizaremos los ejemplos anteriores, pero aplicados a

esta estructura. Por ejemplo, si la edad es mayor o igual que 18, mostrare-
mos "Es mayor de edad", en caso contrario, "Es menor de edad" :
Th"lCIO
, , ariable edad tipo numero
edad 15
Si edad >= 18 entonces
l\{OSTRAR "Es mayor de edad"
Sino
l\{OSTRAR "Es menor de edad"
Fin Si
FIN

Comparemos dos valores de variables, por ejemplo, las alhiras de los

sujetos A y B. Si el más alto es A debemos mostrar "La persona más alta es
A"; de lo contrario , "La persona más alta es B" .
Th""ICIO
, , aria ble alturaA, alturaB tipo real
alturaA 1.5
alturaB 1.9
Si alturaA >= alturaB entonces
iVIOSTRAR "L a pe.rson a m ás alta es A"
Sino
iVIOSTRAR "L a person a m ás alta es B"
Fin Si
FIN
A veces, cuando realizamos tm cálculo con variables, debemos alterar

nuestro mensaje en fLmción del rest1ltado. Como ejemplo, st1memos dos
valores. Si el total es mayor que 50, informaremos "El valor es ALTO"; en
caso contrario , "El valor es BAJO" . Veamos el código :
Th""ICIO
Variable nu1neroA, nu1ner0B tipo nu1nero
numeroA 15
numeroB 20
/!Podemos utilizar LEER numeroA, numeroB
si deseamos que un usuario ingrese por teclado los valores
Si (nume.roA + nume.ro B) > 50 e.ntonces
iVIOSTR;\R "El valor es ALTO"
Sino
iVIOSTRAR "El valor es BAJO"
Fin Si
FIN

El siguiente código comprobará, al introducir tm número por teclado,

si es tm número positivo o negativo.
Th"lCIO
Variable Num tipo numero O
ESCRIBIR "Escriba un nú1n ero: "
LEER Num
Si Num >= O e.ntonce.s
l\{OSTRAR "Es positivo"
Sino
.. .
l\{OSTRAR "Es neaativo"
Fin S i
FIN
Al introducir un número por teclado, el siguiente código verificará si se

trata de par o impar:
Th"lCIO
Variable Num tipo numero O
ESCRIBIR "Escriba un nú1n ero: "
LEER Num
S i num = int( num / 2 ) * 2 entonces
l\'10 STRAR "Es par"
Sino
l\{OSTRAR "Es impar"
Fin S i
FIN
Estructuras condicionales múltiples o anidadas

Estas estructuras de comparación son decisiones especializadas
que permiten comparar una variable con distintos resultados posibles,
ejecutando una serie de instrucciones específicas para cada caso. Tie-
11e11 la siguie11te sÍ11taxis:

52 r•:.1:1+fJ 3. ESTRUCTURAS DE PROGRA1\1ACIÓN
Instrucción/es
Sino
Instrucción/es
Sino
Instrucción/es
Sino
... y así sucesivamente ...
Fin Si
Fin Si
Fin Si
Realizaremos un algoritmo que pida la altura de una persona. Si es menor o

igual a 150 cm, mostrará "Persona de altura baja"; si está entre 151 y 170, mos-
trará "Persona de altura media"; y si es mayor que 171, mostrará "Persona alta".
Th"lCIO
Variable Altura tipo nu1nero
ESCRIBIR "¿Cuál es tu altura?:"
LEER Altura
Si Altura <= 150 entonces
l\iIOSTRAR "Persona de altura baj a"
Sino
Si Altura <= 170 entonces
l\lOSTRAR "Persona de altura media"
Sino
Si Altura > 170 e.ntonces
l\iIOSTRAR "Persona alta"
Fin S i
Fin S i
Fin S i
FIN

También podemos utilizar estructuras de comparación múltiple en

aquellos casos en que sea preciso evaluar una variable con distintos
resultados posibles, ejecutando para cada caso una serie de instruccio-
nes específicas. La sintaxis es la siguiente:
En_Caso_ De <condición> haga

Caso 1: Instrucci ón/e.s
Caso 2: Instrucción/es
Sino
Instrucci ón/e.s
Fin Caso
También podemos encontrar la siguiente sintaxis para pseudocódigo,

que representa la misma estn1chrra:
Segun_Sea <condici ón> hacer

Sino
Instrucción/es
Fin_Segun
Veamos otro ejemplo de uso de esta estn1chrra. En este caso, el usuario

deberá ingresar un valor numérico comprendido entre 1 y 5. Como res-
puesta, el algoritmo mostrará el mismo número, pero en formato de texto:
Th"ICIO
Variable nu1n tipo nu1nero
ESCRIBIR "Ingre.se un valor e.ntre 1 y 5: "

LEERnum
En_Caso_De num haga
Caso 1: l\lOSTRAR " Uno"
Caso 2: l\lOSTRAR " Dos"
Caso 3: l\lOSTRAR " Tre.s"
Caso 4: l\lOSTRAR " Cuatro"
Caso 5: l\llOSTRAR " Cinco"
Sino
l\lOSTRAR "No ingresó un valor compre.ndido e.ntre 1 y 5"
Fin Caso
FIN
También podríamos solicitarle al usuario que ingrese tm número esta-

blecido entre 1 y 7 para que el algoritmo dé como resultado el correspon-
diente día de la semana (1=Ltmes, 2=:tviartes, 3=:tviiércoles, 4=Jt1eves,
5=Viernes, 6=Sábado, 7=Domingo).
Th-iCIO
ESCRIBIR " Ingrese un valor entre 1 y 7: "
LEERnum
En_Caso_De num haga
Caso 1: l\lOSTRAR " Lune.s"
Caso 2: l\lOSTRAR "J\llartes"
Caso 3: l\lOSTRAR "J\ll iércole.s"
Caso 4: l\lOSTRAR " Jueves"
Caso 5: l\lIOSTRAR "Viernes"
Caso 6: l\llOSTRAR "Sábado"
Caso 7: l\lOSTRAR " Domingo"
Sino
l\lOSTRAR "No ingresó un valor comprendido entre 1 y 7"
Fin Caso
FIN

Hemos visto las estructuras de control utilizadas para preguntar se-

cuencialmente sobre alguna condición o caso. Podemos utilizar las senten-
cias Si-FinSi para condiciones simples de tma sola respuesta, y Si-Si no-FinSi
para condiciones dobles con dos posibles respuestas. También podemos
anidar las expresiones Si, tma dentro de otra, con el objetivo de resolver
condiciones complejas o que deben ir cumpliéndose tma dentro de otra.
Por último, es posible usar Segun_Sea para preguntar por una determinada
condición y, dependiendo de su valor o estado, realizar cierta acción.
Estructuras repetitivas o cíclicas

Se utilizan en aquellas situaciones cuya solución requiere un 1nismo
conju11to de acciones que se puedan ejecutar u11a cantidad específica
de veces. Esta cantidad puede ser fija, si se encuentra previa1nente de-
terminada por el desarrollador, o variable, si actúa en fu11ción de algún
dato dentro del programa. A continuación, veremos en detalle los tipos
de estructuras repetitivas o cíclicas.
Ciclos con número determinado de iteraciones

Para- Hasta- Paso-Hacer : son
aquellos ciclos en los que el número de itera-
ciones se conoce antes de ejecutarse el ciclo. La forma de esta estructura
es la siguiente:
Para <variable> <expresiónl> hasta <expresión2> paso <expresión3> hacer

Instrucción/es
Fin Para
Dado un valor inicial expresiónl asignado a la vruiable , esta se irá

aumentando o disminuyendo de acuerdo con la expresión3, hasta llegar
a la expresión2 . Si se omite el paso, la variable aumentará de tmo en tmo.
Veamos un ejemplo de aplicación de esta estructura. Realizaremos un
algoritmo que muestre los números de tmo en tmo hasta 10:

Th"lCIO
Variable contador tipo numero O
Para contador 1 hasta 10 paso 1 hacer
iVIOSTR;\R Contado r
Fin Para
FIN
Veamos un ejemplo similar al anterior, pero esta vez solicitando a un

usuario que ingrese valores para luego sl1marlos:
Th"lCIO
Variable i tipo numero O
Variable suma tipo numero O
Variable num tipo numero O
ESCRIBIR ("Ingrese 10 núme.ro que de.sea sumar")
Para i 1 hasta 10 hacer
ESCRIBIR ("logre.se un núme.ro: ")
LEERnum
suma suma+num
//En este caso estamos utilizando un acumulador
Fin Para
iVIOSTRAR ("El resultado es", suma)
FIN
Ciclos con número indeterminado de iteraciones

A medida que programemos diferentes algoritmos para resolver situacio-
nes, necesitaremos estructuras que repitan un número de iteraciones que no
se conoce con exactitud, ya que depende de un dato dentro del programa.
La estructura Mientras Que repetirá u11 proceso durante N veces,
y N es una cantidad fija o variable. Para hacerlo, la instrucción se vale
de lma condición que es la que debe cumplirse para que se siga ejecutando;
cuando la condición ya no se cumple, el proceso deja de ejecutarse.

La sintaxis de esta estructura es la siguiente:
Ivfientras Que <condición> hacer

Instiu cción/es 1 - Acción 1
Instiu cción/es N - Acción N
Fin Ivfienti·as
Vea1nos un ejemplo de uso, aplicando un algoritmo que muestre

los nú1neros de uno en uno hasta 20:
Th'lCIO
, , aria ble contado r tipo numero
contador 1
iVIientras Que contado r < 21 h acer
iVIOSTR;\R contador
contador contador + 1
Fin iVIientras
FIN
La estructura Repetir Hasta es similar a la anterior, ya que repite el proceso

una cierta cantidad de veces . Pero, a diferencia de Ivfienti·as Que, lo hace hasta
que la condición se cumpla, y no mientras se cumple .
En p seudocódigo encontramos diferentes palabras que expresan la misma acción . Por ejem -
plo, para mostrar datos podemos utilizar: MOSTRAR, ESCRIBIR , IMPR.IivIIR o PRil\l'f.
En el caso de querer obtener datos, usamos PEDIR o LEER· Es recomendable emplear una
sinta,"<is homogénea y hacer uso de una sola palabra para la acción que deseamos expresar.

Por otra parte, esta estructura permite realizar el proceso cuando menos
una vez, ya que la condición se evalúa al final; en tanto que, con Iv1ientras Que ,
puede que nunca llegue a entrar si la condición no se cumple desde un prin-
cipio. La forma de la estructura Repetir Hasta es la siguiente:
Repetir
Instrucción/es 1 - Acción 1
Instrucci ón/es N - Acci ón N
H asta que <condición>
Veamos un ejemplo de uso de esta estructura, donde realizaremos un

algoritmo que pregLmte al usuario tm número comprendido en el rango
de 1 a 5. El algoritmo debe validar el número de manera que no continúe
la ejecución del programa hasta que no se escriba tm valor correcto:
Th"lCIO
ESCRIBIR "Escriba un numero de 1 a 5"
Repetir
LEERnum
Instrucción/es N - Acción N
Hasta que (num >= 1) Y (num < 5)
FIN
Datos estructurados
En los casos anteriores, utilizamos datos simples que representaban un
número, tm carácter o tma cadena/texto. No obstante, a veces necesitamos
procesar una colección de valores que estén relacionados entre sí por algún
método; por ej emplo : una lista de precios, los meses del año, cotizaciones a lo

largo de tma semana, etcétera. El procesamiento de estos datos utilizando

otros simples es muy difícil, porque deberíamos crear, por ejemplo, tma
variable para cada valor. Por ese motivo se han defmido en la programa-
ción varias estructliras de datos que son tma colección caracterizada por
alguna organización y por las operaciones que se defmen en ella. Veremos
dos estructl!ras: vectores y matrices.
Vectores
Un vector es un conjunto de elementos del mismo tipo de dato que
comparten tm nombre com(m. Podemos homologarlo a tma variable
que puede almacenar más de tm valor al mismo tiempo. Se trata de tm
conjunto ordenado por elementos de posición (de Oa N) y homogéneo,
porque sus elementos son todos del mismo tipo de dato. Los vectores
también reciben el nombre de tablas, listas o arrays, ya que gráfica-
1nente se representan como u11a tabla. Un vector de tipo numérico con
u11a dimensión de cinco espacios podría ser el siguiente:
5 20 -1 10 36
U11 vector de tipo alfanu1nérico con u11a dimensión de cinco espacios

podría ser el que aparece a continuación:
Un valor ABCD @unvalor Unvalor200 Texto
Al igual que cualquier variable, un vector debe tener un nombre:
vecA 5 20 -1 10 36
vecB Un valor ABCD @wivalor Unvalor200 texto

Los elementos que están en el vector A y en el B ocupan u11a determi-

nada posición, como puede observarse:
l 2 3 4 5
vecA 5 20 .¡ 10 36
l 2 3 4 5
vecB Un valor ABCD @unvalor Unvalor200 texto
De esta manera podemos saber la ubicación de los elementos o datos

dentro de una estructura como el vector. Por ejemplo, si deseamos cono-
cer qué hay en el vector A en la ubicación 2 (el valor 20), y que hay en
el vector B ("Unvalor200"), hacemos lo siguiente:
Iv10STRAR vecA(2) //Nos mostrará el valor 20

Iv10STRAR vecB(2) //Nos mostrará el valor Unvalor200
Luego de ver cómo fLmciona en parte tm vector, necesitamos conocer

cómo se realiza su declaración en pseudocódigo. La sintaxis es la siguiente:
No olvidemos que el vector siempre debe ser dimensionado. Esto significa que debemos in-
dicarle a la computadora que reseive los espacios de memoria necesarios para los elemen-
tos del vector. En algunos lenguajes, si dejamos el vector sin valores, no podremos hacer
uso de él, y eso traerá serios inconvenientes. Por ejemplo: Variable vecX Otipo nume ro .

Vruiable nombreVector (dimensión vector) tipo dato
Como podemos observar, la declaración es igual a la de una variable,

pero debemos tener cuidado de ingresar la dimensión del vector entre
paréntesis " ( ) " y el tipo de dato que será este vector. Al ser una variable,
es un tipo de dato creado en memoria y temporal. Veamos un ejemplo de
cómo crear y cargar tm vector con los datos anteriormente vistos en vecA:
Th"lCIO
, , aria ble vecA (5) tipo numero
vecA(l) 5
vecA(2) 20
vecA(3) -1
vecA(4) 10
vecA(5) 36
FIN
La asignación de valores a los elementos de un vector se realiza indi-

cando el espacio de orden con el sigi10 para asigi1ar el valor, de igual
manera que con las variables simples. Es posible realizar la carga de vec-
tores con datos predeterminados en código con estructuras de control
repetitivas, como Mientras o Hacer-Hasta . Por ejemplo, si deseamos realizar
la carga de 30 valores a un vector, el pseudocódigo será el siguiente:
Th"lCIO
' 'ariable vecEje.mplo (30) tipo numero
Variable i tipo numero O
Para i 1 hasta 30 hacer
vecEjemplo(i) i
Fin Para
l\iIOSTRAR "' 'ector
. ..
caraado"
FIN

62 r•:.1:1+fJ 3. ESTRUCTURAS DE PROGRA1\1ACIÓN
En este ejemplo, la variable i sería "indicador" del espacio en el vector y,

además, el valor por asignar. En el que se presenta a continuación, dejaremos
que el usuario determine la dimensión del vector sobre el que quiere trabajar.
Por eso, tomaremos un valor de dimensión y se lo asignaremos al vector:
Th""ICIO
V ariable i, num tipo numero O
ESCRIBIR "logre.se la cantidad de valore.s: ", num
' 'ariable vecEjemplo (num) tipo numero
P ara i 1 hasta num hacer
vecEjemplo(i) i
Fin Para
l\lOSTRAR "''ector
. ..
caraado"
FIN
Ahora veamos un ejercicio más complejo. Deberemos leer un vector de

N componentes y hallar la suma y el promedio de sus elementos (sabemos
que el promedio se encuentra al dividir la suma de todos los elementos por
la cantidad de estos). Llamaremos a nuestro vector vecCalculo y su dimensión
será determinada por el usuario. De acuerdo con el esquema que vimos an-
teriormente, tendremos lo siguiente: una repetitiva para la carga del vector,
otra para el proceso y otra para mostrar los datos del vector.
Th""ICIO
Variable i, suma, promedio, dimensión, numero tipo numero O
ESCRIBIR "Escriba la cantidad de valores a calcular:", dimensión
' 'ariable vecCalculo(dime.nsión) tipo numero
H acer i 1 hast a dimensión
ESCRIBIR "Ingrese un núme.ro: ", numero
vecCalculo(i) numero
Fin Hacer
//Con esta estructura cargamos el vector de valores
-
Hacer i 1 hasta dimensión

suma suma + vecCalculo(i)
Fin Hacer
//Con esta estructura sumamos todos los valores del vector
promedio suma / 2
l\lOSTRAR "La suma de los elementos del vector es: ", suma
l\lOSTRAR "El promedio es: ", promedio
FIN
Hasta aquí hemos visto el uso de un vector en pseudocódigo, el benefi-

cio que nos ofrece su estructura para trabajar o registrar varios datos y las
distintas operaciones que nos permite realizar. Pasemos a analizar con el
mismo detalle las estructuras matriciales.
Matrices
Las matrices son estructuras que contienen datos homogéneos, es de-
cir, del mismo tipo. Así como antes utilizamos tm indicador o índice para
posicionarnos y almacenar algún valor, en el caso de las matrices utiliza-
remos dos índices que determinarán la posición de fila y columna.
Columna l Columna2 Columna3 Columna4

Fila!
----------------
t-------1------1--------
----------------
Fl1a2
Fila3
Fila4
~--~---~-------~
Figura 2. En esta representación tenemos una matriz de dimensión .tvI * N,
en donde M es el número de columnas y N, el número de filas.
En el ejemplo, la dimensión es M=4 y N=4 . Por lo tanto, el número total

de elementos de la matriz es 4*4; es decir, 16 posiciones para utilizar.

Al igual que un vector, una matriz debe tener un nombre. La sintaxis es:
Vruiable nombreiv1atJiz (cantidad de filas, cantidad de columnas) tipo de dato
matEj emplo
Figura 3. En esta representación de matriz, la sintaxis sería :

Varia.ble matEjemplo (4, 4) tipo texto •
Una vez que le hayamos asignado datos a la matriz, notaremos que,

para referin1os a alguno de sus ele1nentos, tendremos que conocer,
precisamente, en qué fila y colu1nna reside.
1 ? 3 4
1 Lwies 5000
2
3 Fuente
'
Ultimo
4
matEj emplo
Figura 4. En esta representación de matriz, la referencia de datos sería :

1natEjemplo( 1, 1) "Lu11es", matEjemplo( 1,3) "Fuente",
matEje1nplo(3,2) 5000 y 1natEjemplo(4,4) '
"Ultüno" .
Además de cargar los valores de manera independiente, debemos tener

en cuenta, al igual que los vectores que utilizaremos, las estructuras repe-
titivas para recorrer las matrices. Por ejemplo:

Th"lCIO
Variable ifila, icolumna tipo numero O
, , ariable varPalabra tipo texto
' ' ariable m atEje.mplo (4, 4) tipo texto
P ara ifila 1 hasta 4 hacer
P ara icolumna 1 hasta 4 hacer
ESCRIBIR "Ing rese un v alo r: "
matEj emplo (ifila, icolumna) varP alabra
Fin Para
Fin Para
l\lIOSTRAR "l\latriz
. ..
caraada"
FIN
En este ejemplo, la variable fila comienza en el valor 1, luego se da inicio

a la repetitiva con la columna desde 1 hasta 4. El bucle de las columnas debe
terminar todo Sl l recorrido para que comience el siguiente valor de fila.
1 2 3 4
1 LU!íe-s- -~ - -
2 -
3 •
--
4 ::'!tima-
matEjemplo
Figura 5. En el recorrido de esta matriz, podemos notar los valores

que van tomando los índices.
Una matriz también puede recorrerse por columnas. Al programar, no

siempre podremos predefmir el tamaño de la matriz. Por ese motivo nece-
sitamos solicitarle al usuario que ingrese la cantidad de filas y columnas
con las que quiere dimensionarla. Por ejemplo:

Th"lCIO
, , ariable varPalabra tipo texto
ESCRIBIR "Ingres e la cantidad de filas: ", ifila
ESCRIBIR "Ingrese la cantidad de columnas: ", icolumna
, , ariable matEje.mplo (ifila, icolumna) tipo texto
Para icolumna 1 hasta icolumna hacer
Para ifila 1 hasta ifila hacer
ESCRIBIR "Ingrese un v alor: "
matEj emplo (ifila, icolumna) varPalabra
Fin Para
Fin Para
l\lOSTRAR "1"1atriz . ..
caraada"
FIN
De esta manera, pudimos experimentar cómo cargar tma matriz y ob-

servar que el recorrido es muy similar al de los vectores. Sin embargo,
deberemos tener en cuenta que se debe indicar la fila y la columna de la
posición de los elementos. Por ejemplo:
Th"lCIO
' 'ariable matEje.mplo (4, 4) tipo texto
Para ifila 1 hasta 4 hacer
Para icolumna 1 hasta 4 hacer
J\IIOSTRAR "El valor es: ", matEjemplo(ifila, icolumna)
Fin Para
Fin Para
FIN
Para avanzar en el manejo de matrices, veremos tm caso en el que cal-

cularemos valores entre matrices. Haremos una suma entre matrices, sien-
do matA y matB dos matrices de igual dimensión ( MxN) :

Th"lCIO
, , ariable matA (3, 4) tipo numero
, , ariable matB (3, 4) tipo numero
, , ariable matC (3, 4) tipo numero
//Carga de matriz A
matA(l,1) 10
matA(l,2) 8
matA(l,3) 3
matA(l,4) O
matA(2,1) 7
matA(2,2) -3
matA(2,3) 33
matA(2,4) 45
matA(3,1) 9
matA(3,2) 15
matA(3,3) 71
matA(3,4) 29
//Carga de matriz B
matB(l,1) 1
matB(l,2) 6
matB(l,3) 9
matB(l,4) 69
matB(2,1) 14
matB(2,2) 22
matB(2,3) 56
matB(2,4) 7
matB(3,1) 3
matB(3,2) 5
matB(3,3) 80
matB(3,4) 1
//Cálculo y asignación a matriz C
Para icolumna 1 hasta 4 hacer
matC(ifila, icolumna) mat..\
(ifila, icolumna) + matB(ifila, icolumna)
Fin Para
Fin Para
FIN

Hasta aquí hemos visto el uso de las estructuras complejas que se

almacenan en la memoria, los vectores y las matrices, que serán útiles
para guardar datos de manera temporal. Con toda esta información po-
dremos realizar el procesamiento de datos, tanto por cálculo como por
manejo de texto.
A continuación, aprendere1nos a automatizar algunas acciones comu-
nes que podemos utilizar en nuestro desarrollo.
Subalgoritmos
Cuando comencemos a practicar el desarrollo de aplicaciones, en nuestro
algoritmo habrá cálculos o rutinas que pueden repetirse varias veces. En los
próximos párrafos aprenderemos a simplificar la repetición de estos procesos.
En general, un proble1na co1nplejo puede resolverse de 1nanera
eficiente si se divide en procesos pequeños. Esto implica que el proble-
ma original será resl1elto por medio de varios módulos, cada lmo de los
cuales se encargará de solucionar algu11a parte determinada. Esos módu-
los se conocen con el nombre de subalgoritmos , es decir, algoritmos
cuya fu11ción es resolver u11 subproblema.
Los subalgoritlnos se escriben solo una vez y, luego, se puede hacer
referencia a ellos desde diferentes pu11tos de un pseudocódigo. De esta
forma, se reutiliza el código y se evita la duplicación de procesos.
En programación, las variables locales son aquellas que se encuentran dentro de un

subprograma, ya sea tm procedimiento o tma función, y son distintas de las que están
en el algoritmo principal. El valor se confina al subprograma en el que están declaradas.
En cambio, las globales son las que se definen o están declaradas en el algoritmo princi-
pal, y tienen efecto tanto en él como en cualquiera de sus subprogramas.

Es importante tener en cuenta que los sub- LOSSUBALGORITMOS

algoritmos son independientes entre sí; esto
quiere decir que se pueden escribir y verificar FACILITAN LA
en forma separada. Por eso, será más fácil lo- LOCALIZACIÓN DE
calizar y modificar un error en la codificación
ERRORESEN
sin tener que rehacer varias partes.
Existen dos clases de subalgoritmos : LA CODIFICACIÓN
las funciones y los procedi111ientos, que
también encontraremos con los nombres de
subrutinas o subprogramas . Al utilizar
procedimientos y fLmciones, veremos que se
establece tm límite para el alcance de las variables; algtmas tendrán efecto
y valor solo en el subalgoritmo, y otras, en el algoritmo principal.
También es posible especificar que tma variable tenga efecto en el algorit-
mo principal y en todos los subalgoritmos. Esto se conoce como á111bito
de las variables , que pueden ser: locales, privadas o públicas .
Los subalgoritmos pueden recibir valores del algoritmo principal ( pará-
nietros), trabajar con ellos y devolver un resultado al algoritmo principal.
Un subprograma puede invocar o llamar a otros o a sus propios subprogra-
mas, y puede llamarse a sí mismo, lo que se conoce como recursi,,idad .
Funciones
Desde el punto de vista matemático, una función es una expresión
que toma tmo o más valores llamados argumentos y produce tm resultado
único. Algtmos ejemplos de fLmciones matemáticas son los logaritmos y
las fLmciones trigonométricas (seno, coseno, etcétera).
En el ambiente de la programación de algoritmos, las funciones tienen
exactamente el mismo significado. Se realizan ciertos cálculos con una o más
variables de entrada, y se produce un único resultado, que podrá ser numé-
rico, alfanumérico o lógico. Es decir, una función puede devolver como resul-
tado una cadena, un número o un valor de tipo lógico. Esto hace que, en los
lenguaj es de programación, debamos especificar el tipo de la función.

La función será nu111érica cuando de-

LAS FUNCIONES
vuelva un número y alfanumérica cuando
NUMÉRICAS devuelva u11a cadena. En el caso de las fun-
DEPENDEN DE LOS
ciones numéricas, existen subdivisiones que
está11 dadas por los tipos de datos soporta-
TIPOS DE DATOS dos por algú11 lenguaje.
SOPORTADOS Veamos un ejemplo de la función mate-
1nática sen(x) . En este caso, la fu11ción se
llatna sen (seno) y el argu1nento o valor que
se le pasa para que lo procese es x . Así,
sen(90º)= 1 . Este valor, como es único, se de-
nomina función; es decir, no existe ningún otro nútnero que la función
pueda procesar y devolver 1, 1nás que 90°.
Cuando utilicemos esta función en un pseudocódigo y necesitemos el
valor del sen(90º), deberemos asignarlo a tma variable de la siguiente forma:
variable valor tipo numero O

valor sen(90)
En este caso, la variable valor será 1, por lo que nuestra función es

numérica. Es así como se llama a las fLmciones desde tm pseudocódigo,
asignándolas siempre a una variable que contendrá el valor devuelto por
la fLmción. Si no hacemos esta asignación, la fLmción no podrá ejecutarse,
porque no tendrá tm espacio o lugar donde descargar el rest1ltado. Por lo
tanto, la llamada a una función tendrá la siguiente sintaxis:
variable función (parámetros)
Veamos un ej emplo : si a la función IvIBS, que devuelve el nombre del mes,

le pasamos el valor numérico correspondiente, el resultado será:
vruiable nombre_mes tipo texto

nombre_mes Iv1ES(2) //Esto devolvería "Febrero"

La función es de tipo texto, ya que devuelve una cadena como resultado en

la vruiable nombre mes .
Hasta aquí hemos visto cómo llamar a una función. Ahora veremos cómo
escribirla. Las funciones y los procedimientos no se escriben en el algorit-
mo principal, ya que, en programación, existen espacios destinados a ellos.
Todas las funciones y los procedimientos que utilicen un algoritmo podrán
escribirse antes o después del algoritmo principal.
Una función se identifica 1nediante su nombre, de la mis1na 1nanera
que, cuando escribimos un algoritlno, utilizamos Inicio y Fin para in-
dicar dónde comienza y dónde termina. A continuación, veamos có1no
sería la sii1taxis:
Función nombre_funcion (parámetros)

Instrucción/es
Fin función
Todas las fLmciones deV11elven tm solo valor. Siempre debemos indicar

a la fLmción, mediante tma instrucción, que deV11elva el valor al algoritmo
principal; recordemos que la función será llamada desde un algoritmo.
Esto se debe hacer en el cuerpo de la función cuando tengamos el resultado.
Tomando como ejemplo la función :tvffiS, vere1nos cómo se escribe
el algoritlno principal, cómo se llama y se declara la función:
El léxico es 1m conj1mto de palabras de 1ma lengua, región, colectivo, actividad, etcé-

tera (por ejemplo, léxico técnico). La sintaxis es el orden y modo en que se relacionan
las palabras dentro de 1ma oración o las oraciones dentro de un discurso. Por último,
la semántica es el componente de la gramática que interpreta la significación de los
en1mciados generados por la sintaxis y el léxico.

Th"lCIO
variable numero_mes tipo numero
variable nombre_me.s tipo texto
ESCRIBIR " Ingrese el número del mes y Je mostraremos el nombre del mes"
ESCRIBIR " Debe ingre.sar un núme.ro e.ntre 1 y 12: ", numero_me.s
Si numero mes>12 o numero mes<l entonces
l\lOSTRAR " Debe ingresar un valor e.ntre 1 y 12"
Sino
nombre_mes llamar l\1ES(numero_mes)
l\lOSTRAR "El mes correspondiente es: ", nombre_mes
FinSi
FIN
FUNCION l\lES (variable valor tipo numero)

variable nombre tipo texto
Según sea valor
Caso 1:
Nombre= "Enero"
Caso 2:
Nombre= "Febrero"
Caso 3:
Nombre= "l\larzo"
Caso 4:
Nombre= "Abril"
Caso 5:
Nombre= "l\layo"
Caso 6:
Nombre= " Junio"
Caso 7:
Nombre= " Julio"
Caso 8:
Nombre= "Aaosto"..
.
Caso 9:
Nombre= "Setiembre"
Caso 10:
Nombre= " Octubre"

Caso 11:
Nombre= "Noviembre"
Caso 12:
Nombre= "Diciembre"
Fin Según
l\'IES nombre
//Indicamos a la función que devuelva el resultado
al algoritmo principal la variable nombre
FINFUNCION
Es preciso tener en cuenta cómo se pasan los valores desde el algoritmo

principal a la función. En este caso, cuando se llama a la función, se escribe:
nombre_ mes :tvffiS (numero_ mes)
El valor que se envía a la función MES de la variable numero_ mes to1na

un valor comprendido entre 1 y 12. Cuando se llama a la función, este
valor debe ser recibido por ella; en este caso, en el cuerpo de la función
se coloca entre paréntesis el nombre de la variable que recibirá el valor:
Función :rvrns (valor)
Si se pasan varios valores, todos deben ser recibidos en SllS correspon-

dientes variables, o habrá lm error en la codificación. La fLmción toma el
valor pasado desde el algoritmo y lo guarda en la variable valor para proce-
sarlo. Luego de obtener lm resultado (en este caso el valor de nombre_ mes) ,
se le ordena a la función que devuelva ese valor al algoritmo principal:
:tvlES no1nbre
Sintaxis : nombre funcion resultado
En los lenguaj es de programación, se utiliza una palabra reservada para

devolver valores : retum. En pseudocódigo también podemos usar devolver.

En resumen, podemos decir que la función devuelve un solo valor y

que, para funcionar, debe recibir uno o varios valores desde el algoritmo
principal, realizar el proceso y devolver el resl1ltado.
Veamos otro ejemplo. Diseñaremos el algoritmo para realizar la raíz
cuadrada de lm valor numérico:
Th"lCIO
variable num, resultado tipo numero O
ESCRIBIR "Ingrese un número :", num
iVIientras num < = O
iVIOSTR;\R "Ingrese un nú1nero positivo"
ESCRIBIR "logre.se un número :", num
Fin iVIientras
resultado RAIZ(num)
iVIOSTRAR "L a raíz cuadrada es:", resultado
FIN
FUNCION RAIZ (variable valor tipo nume.ro)

variable varRaiz tipo numero
v arRaiz v alor A 1/2
RAIZ , ,arRaiz
FINFUNCION
Llamamos RAIZ a la fLmción que escribimos, la cual debe obtener lm

valor que se pasará desde el algoritmo principal. El número del cual que-
remos calcular la raíz cuadrada lo elevamos a la potencia 1/2 y, luego,
devolvemos el resultado al algoritmo principal.
Tomando como referencia esta fLmción RAIZ, las variables globales son
num y resultado, y las locales son: valor y varRaiz . Estas dos últimas solo
existen en la función RAIZ, y, si en el algoritmo principal tratamos de uti-
lizarlas o mostrarlas, no obtendremos nada, ya que para el algoritmo son
locales y no existen. Las variables num y resultado son globales, puesto que
están disponibles en el algoritmo principal y, también, en la fLmción RAIZ.

Una variable local de tm subprograma no tiene ning(m significado en el

algoritmo principal y en otros subprogramas. Si tm subprograma asigna tm
valor a una de sus variables locales, este no será accesible a otros subpro-
gramas, es decir que no podrán usar este valor. Las variables globales tie-
nen la ventaja de compartir información de diferentes subprogramas.
Para terminar con el tema de funciones, veremos un ej emplo sencillo que
nos permite diseñar tma fLmción que calcule la media de tres números :
Th"lCIO
variable numero l , numero2, numero3 tipo numero O
variable prom tipo numero O
ESCRIBIR "Ingrese tres valores:", numero!, numero2, numero3
prom PROl\lIEDIO(numerol, numero2, numero3)
lVIOSTRAR "El promedio es:", prom
FIN
FUNCION PROJVU:DIO(variable valorl, valor2,valor3 tipo numero)

variable promedio tipo numero O
promedio (valorl + valor2 + valor3) / 3
PR01\1EDIO promedio
FINFUNCION
Hasta aquí hemos visto que las fLmciones se utilizan para devolver como
resultado un valor. En ocasiones, necesitaremos devolver más de un resulta-
do o, también, ejecutar las mismas líneas de código varias veces en tm algo-
ritmo, como una ordenación. En estas situaciones, la fLmción no es apropia-
da, y utilizaremos los procedi111ientos , también llamados subrutinas .
Procedimientos
Un procedi111iento es un conjunto de sentencias o instrucciones que
realizan tma determinada tarea y que pueden ser ejecutados desde más de
un punto del programa principal. Este tiene una llamada y, cuando se ej ecuta

totalmente , vuelve al punto desde donde fue llamado y se ej ecuta la siguien-

te instrucción. El procedimiento se escribe como cualquier otro algoritmo,
ya que solo existen diferencias en las partes inicial y final. Para nombrar los
procedimientos, hay que seguir las mismas reglas que para las variables.
El obj etivo de los procedimientos es ayudar en la modularidad del progra-
ma y evitar la repetición de instrucciones, porque estas pueden escribirse en
un procedimiento y, en lugar de repetirlas, llamar al procedimiento cuantas
veces sean necesarias. Desde el programa principal es posible pasar valores al
procedimiento que los utilizará para realizar un determinado proceso. Los va-
lores que se pasan a un procedimiento se llaman parámetros , de igual forma
que en las funciones.
La sintaxis para la declaración de un procedimiento es la siguiente :
Procedimiento Nombre_procedimiento (parámetros)

Instrucción/es
Fin Procedimiento
La llamada a un procedimiento se hace por su nombre:
Nombre_procedimiento(parámetros)
También es posible que no se pase ningún parámetro al procedimiento,

en cuyo caso la llamada se escribe de la siguiente manera:
Nombre_procedimientoO
Pode1nos utilizar procedünientos, por ejemplo, para dibujar recua-

dros en la pantalla, mostrar 1nensajes de error, realizar procesos con
1nás de un resultado, o colocar en un procedüniento las líneas de códi-
go que se repiten varias veces en un algoritmo. Cuando necesitamos de-
volver más de un valor en un procedimiento, las variables que devuelvan los
resultados deben figurar en la lista de parámetros. Veamos un ej emplo para
ca lcular el cociente y resto de la división entre dos números :

Th"lCIO
variable numero..\, numeroB tipo numero O
ESCRIBIR " Ingrese los valores a calcular : ", numeroA,
nu1ner0B D1""1S10:K (nu1neroA, nu1ner0B, P, Q)
iVIOSTR;\R P , Q
FIN
P rocedilniento D1""1S10:K (variable dividendo, divisor, cociente.,resto tipo nu1nero)

cociente dividendo / divisor
resto dividendo - cociente * resto
Fin Procedimiento
Al llamar al procedimiento división en el algoritmo principal, debemos

pasar en su sintaxis los números del dividendo y del divisor, representados
por numeroA y numeroB. También especificaremos las variables en las que se
devolverán los resultados de cociente y resto, P y Q. La sintaxis será:
DIVISION (numeroA, numeroB, P , Q)
El procedimiento recibe los valores numeroA en dividendo y numeroB en

divisor, y se colocan las variables en las que se pasarán al programa prin-
cipal el cociente y el resto. P recibirá el valor de cociente y Q, el del resto.
Cuando necesitamos devolver más de un valor, los parámetros del pro-
cedimiento deben ser los valores que se pasen al procedimiento y, luego,
las variables en las que se recibirán los resl1ltados.
Hemos visto cómo ordenar nuestra info1mación cuando utilizamos pseudocódigo,

mediante estJ11cturas de control y datos estJ11cturados.

Actividades
1 ¿Cómo están subdivididas las estiucturas condicionales?
2 ¿En qué consisten las esbucturas repetitivas?
3 ¿Qué son los vectores?
4 ¿En qué se diferencian las matiices de los vectores?
5 ¿Por qué son útiles los subalgo1itmos?
EJERCICIOS PRÁCTICOS
1 Haga tm pseudocódigo que imprima todos los números naturales que hay,
desde la tmidad hasta tm valor indicado por teclado.
2 Imp1ima diez veces la se1ie de números del 1 al 1O y haga un pseudocódigo

que cuente las veces que aparece una letJ·a en una frase ingresada por teclado.
3 Inti·oduzca dos números por teclado y, mediante un menú, calcule suma,

resta, multiplicación y división enti·e ellos.


1//////////////.
Del pseudocódigo
al lenguaje
de programación
A lo largo de los capítulos anteriores recorrimos conceptos,
teorías y prácticas para el desarrollo de aplicaciones informáticas.
Aquí co1ne112aremos a ver có1no plasmar todo el conocimiento
adquirido sobre pseudocódigo en el código fuente de un lenguaje.
• Lenguaj es de programación ......80 • Resumen .....................................8i

Tipos de leoguajes .......................80
• Actividades .................................88
• Interfaces gráficas .....................82
Pseudocódigo y lenguajes
de programadón ......................... 86
80 4. DEL PSEUDOCÓDIGO AL LENGUAJE DE PROGRA1\1ACIÓN
Lenguajes de programación
En los capítulos siguientes nos adentrare1nos en dos lenguajes
de programación, Visual Basic y C++, y comenzaremos a aplicarles lo
aprendido sobre pseudocódigo, para dar así nuestros prüneros pasos
en un código fuente para el desarrollo de aplicaciones.
Los lenguajes de programación son defmidos como tm idio111a
artificial diseñado para expresar cómputos, que pueden ser llevados
a cabo por equipos electrónicos, tales como computadoras, tablets,
smartphones, etcétera. El uso de este lenguaje máquina, que vimos
con anterioridad, nos permitirá crear programas o aplicaciones que
controlen el comportamiento fisico y lógico de un dispositivo
electrónico (expresados en algoritmos de precisión) y, además, establecer
la comtmicación humano-máquina.
La escritura de un lenguaje de programación está formada por un con-
jtmto de símbolos, reglas sintácticas y reglas semánticas, que defmen la
estn1ctlira y el significado de sus elementos y expresiones, tal como las
reglas ortográficas lo hacen con el lenguaje humano.
Tipos de lenguajes
Existen lenguajes sólidos, duros, visuales, amigables y específicos
en la programación de código fuente. Vea1nos la variedad que hay
y cuáles son sus diferencias:
La palabra baj o no implica que el lenguaje sea inferior a un lenguaje de alto nivel, sino que se
refiere a la reducida abstracció n entre el lenguaj e y el hardware. Estos lenguaj es se utilizan
para programar controladores de dispositivos, tales como placas de video, impresoras u otros.

• Lengua.je 111áquina: tanto las invocaciones a memoria como los

procesos aritmético-lógicos son posiciones literales de conmutado-
res fisicos del hardware en su representación booleana. Estos len-
guajes so11 literales de tareas.
• Lenguaje objeto : lenguaj e o juego de instrucciones codificado al cual es
traducido un lenguaj e fuente por medio de un compilador. Es un lenguaj e
máquina directamente comprensible por una computadora.
• Lenguajes de bajo nivel : ensamblan los grupos de co11mutadores
necesarios para expresar una mínima lógica aritlnética, y están ínti-
mamente vinculados al hardware. Estos lenguajes están orientados
a procesos , y el diseño de la arquitectura de hard\ovare. determinará
la cantidad de instrucciones.
• Lenguajes de medio ni,,el : basándose en los juegos de instrucciones
disponibles (chipset), permiten el uso de funciones a nivel aritmético,
pero a nivel lógico dependen de literales en ensamblador.
Están orientados a procedimientos . Ejemplos: e , Basic.
• Lenguajes de alto ni,,el : le permiten al programador tener una máxima
flexibilidad a la hora de abstraerse o ser literal, y ofrecen un camino
bidireccional entre el lenguaj e máquina y una expresión casi oral entre
la escritura del programa y su posterior compilación. Estos lenguaj es están
orientados a objetos , que se componen de propiedades cuya naturaleza
emerge de procedimientos. Ej emplos : C++ , Fortran , Cobol , Lisp.
• Lenguajes de aplicaciones : no permiten una bidireccionalidad concep-
tual entre el lenguaj e máquina y los lenguaj es de alto nivel, ni tampoco
la literalidad a la hora de invocar conceptos lógicos. Se basan en librerías
creadas en lenguaj es de alto nivel. Permiten la creación de nuevas libre-
rías, pero propietarias y dependientes de las suministradas por la aplica -
ción. Están orientados a e,,entos que surgen cuando las propiedades de
un obj eto interactúan con otro. Ej emplo : Visual Basic para aplicaciones .
• Lenguajes de redes : se basan en un convenio de instrucciones
independientes de la 1náquina y dependientes de la red a la que
están orientadas. Se dividen en descriptivos (HTl\iIL, ~ n,, VML)
y cliente-servidor ( Java , PHP ) .

En general, hablamos de lenguajes de alto nivel y de ba_jo nivel , agn1-

pando en ellos todos los tipos que vimos antes. Para comprender mejor
este punto, podemos generalizar estos conceptos diciendo que el lenguaje
de bajo nivel es el que más se asemeja al lenguaj e 111áquina, en tanto
que el de alto nivel se ase1neja al lenguaje humano y, por medios
visuales, 110s pe11nite crear 11uestros desmTollos.
Por último, además de los lenguajes que permiten la comtmicación
usuario-máquina, existen también algunos programas especiales llamados
traductores (co111pilador, intérprete) que convierten las instrucciones
escritas en código fuente a un lenguaje máquina que el equipo electrónico
pueda comprender y procesar.
Interfaces gráficas
Las interfaces gráficas nos permiten comunicamos con u11 disposi-
tivo. Gracias a la evolución de las interfaces de comunicación usuario-
1náquina, existen 1nedios gráficos para la interacción con los diferentes
co1nponentes de un equipo (por ejemplo, el manejo de impresora,
1nouse, monitor, etcétera).
En la confección de interfaces gráficas hay ciertas normas por cu1n-
plir, y los componentes utilizados en una interfaz tienen u11a nomencla-
tura detenninada. Vea1nos en la siguiente tabla una lista de los contro-
les que podemos encontrar en distintos lenguajes de programación:
CONTROLES DE LAS INTERFACES GRÁFICAS
T TIPO T COl\lPONENTE
Comandos • Botón de comando

• l\,íenú contextual
• l\,íenú (y submenú)
• l\,íenú desplegable

CONTROLES DE LAS INTERFACES GRÁFICAS (CONTINUAOÓN)
Entrada/ - C asilla de verifica ción

salida de datos - Lista
- Lista desplegable ( ComboBox )
- Botón de opción ( Radio B utto n )
- C aja de texto (TextBox )
- GridView (D ataGri~
- Barra de desplazamiento ( Scro llbar)
Informativos - C aja de texto (TextBox o cuadro de texto)

- Etiqueta (Labe l)
- Icono
- Barra de estado ( StatusB ar )
- Glob o de ayuda (Bailoon Help )
- Barra de progreso ( P rogress B ar)
- Barra de titulo
- Slider
- Spinner
- Huu ( H eads - up )
- !nfobar
- Sp lash screen
- Throbber
- Toast
- Tooltip
Contenedores - V entanaiF ormiF orma

- Barra de menú ( MenuBar)
- Pestaña (Tab)
- Panel
- Cuadro (Frarne/F ie ldset)
- Barra de herramientas
- Acordeón
- Rl'bbon
- Disclosure widget ( Expansor o Combutcon)
Gráfica - C aja de imagen ( PictureBox )

- Imagen ámage )

CONTROLES DE LAS INTERFACES GRÁFICAS (CONTINUAOÓN)
De navegación · Vista de árb ol ( TreeView )

· Vista en lista ( ListView )
• Barra de direcciones
• Breadcrumb
• Hipervinculo
Yentanas • Acere.a de (Abo utBox)

especiales • Cuadro de diálogo ( DialogBox )
• Cuadro de diálogo de archivos
• Inspector \Vindow
· :.'vlodal \Vindow
. Ventana de paleta
Tabla l. Componentes que podemos encontrar con más frecuencia

dentro de las interfaces gráficas .
Cabe destacar que estos controles sirven tanto para aplicaciones de

escritorio como vveb. En la figura 1 vemos los controles más utilizados
en las aplicaciones de Visual Basic.
_,__
l _ _ _ __, • '•
·-
...•-=• - •••
-
~
' ~ll.i Jr.
• h""'ll ~---
... u,,...-.
\ ....
l!l ..:i,-...
11! ~
1--: ,~rito.
"'.! COl'8kh
- 011t1:T~W
A uW
4 l_.uW
..-,.......
::· ......,_
•• M,u.ff. . . . .
.licóM•~ c_.,..06fl
---
c.,.,.,..,,.f«lt,..<....,
~°"._..,,
WJ ........
., ,.....
'°,4 . _ , ...... l.11111*-'"'
o o- , .......... 10- . .
• a 11
\,. lMITlf, o.:_ A,(111.t ,.._ ,....,_ ~

\ ,_.._
Figura 1. Controles comunes en el IDE de Visual Studio , donde podemos

destacar Button , Label y TextBox , entre otros .

Antes de determinar las reglas de diseño de las interfaces gráficas,

es ün portante considerar el ámbito en el que vamos a trabajar. Esto se
debe a que, dependiendo de si es una aplicación de escritorio, 1nóvil o
web, las reglas no serán iguales, sino que deberán ajustarse en función
del producto que queramos desarrollar.
A continuación veremos las normas generales que podemos utilizar
al incursionar en el diseño de interfaces gráficas:
• Anticipación : una buena aplicación intentará predecir las necesidades

y los deseos de los usuarios.
• Autonomía : el usuario debe verse incentivado a investigar y sentir que
tiene el control de la interfaz. No obstante, hay quienes se sienten más
cómodos en tm entorno explorable, que no sea demasiado grande o res-
trictivo. Para maximizar el rendimiento de un negocio, debemos maximi-
zar la eficacia de todos los usuarios, y no solo de tm grupo de ellos.
• Coherencia : si quere1nos que nuestra aplicación sea coherente,
es preciso realizar varias pruebas con sus futuros usuarios, para así
aseguran1os de que el diseño sea el indicado.
• Eficiencia : debemos lograr que la aplicación potencie la experiencia
del usuario y le facilite sus tareas, en vez de buscar la potenciación
del equipo informático.
• Aprendizaje: lo ideal sería que el usuario pudiera sentarse delante
del sistema y saber cómo utilizarlo sin necesidad de aprendizaje.
G raphic User Interface o interfaz gráfica de usuario es un conjunto de fo1mas que

posibilitan la interacción usuario-máquina por medio de elementos gráficos e imágenes.
Cuando hablamos de elementos gráficos nos referimos a botones, iconos, ventanas,
tipos de letras , etcétera, que representan fi.mciones, acciones e info1mación.

• Comunicación: es preciso mantener informado al usuario sobre el estado

del sistema, mediante cuadros de diálogo, etiquetas, colores e iconos, y
escribiendo mensaj es de ayuda concisos que resuelvan los inconvenientes.
A lo largo del desarrollo y el diseño de interfaces gráficas, deberemos

considerar reglas determinadas en función de las aplicaciones, el usuario
y el tipo de negocio al que nos dirigimos.
Pseudocódigo y lenguajes
de programación
Las nomenclahrras hacen referencia a tma lista de nombres de alg(m
tipo de objetos. En programación se utilizan para reglamentar abrevia-
ciones que hagan referencia a componentes y, así, saber a qué estamos
llamando desde el código fuente; por ejemplo, si estamos haciendo refe-
rencia a tm botón o a tma caja de texto con su nombre particular.
NOMENCLATURA DE CONTROLES
TTIPODECONTROL T NOl\lINCLATURA TUSO
B otón de comando / Btn Ejecuta un comando o una acción.

Buttoo
Casilla de verificación / chic Presenta una opción de tipo

CheckBox Verdadero o Falso.
Lista desplegabl e / Cbo Combina un cuadro de texto

ComboBox y uno de lista.
Etiqueta / Label Lb! Presenta texto que el usuario no puede

modificar; tampoco interactuar con él.
Caja de lista / ListBox Lst Ofrece una lista de elementos

entre los que el usuario puede elegir.

NOMENCLATURA DE CONTROLES (CONTINUAOÓN)
Caja de imagen / Pie Presenta mapas de bits, iconos o

Picture Box metarchivos de Windows, y otros tipos
de archivos gráficos compabbles.
También ofrece texto o actúa como
contenedor visual para otros controles.
Botón de opción / Opt Forma parte de un grupo de opciones

RadioButton y presenta varias alternativas, entre las
que el usuario solo puede elegir una.
Caja de texto / txt Proporciona un área para escnbir

TextBox o presentar texto.
Forma / Form / Fnn Contenedor de controles.

Formulario / Ventana
Tabla 2. Nomenclatura de controles comunes.
En general, utilizando el nombre en inglés podremos identificar fácil-

mente a qué control nos estamos refrriendo. Las interfaces gráficas son
elementos fundamentales para representar una aplicación adecuada e
inhlitiva y, así, lograr que el usuario se sienta cómodo al transitarla.
A lo largo de este capitulo hemos visto las generalidades del traspaso de pseudocódi-
go a 1m lenguaje de programación . Conocimos con detalle los tipos de lenguajes que
existen y vimos cómo están compuestas las interfaces gráficas.

Actividades
1 ¿Qué diferencias hay entre los lenguajes de programación de bajo,

medio y alto nivel?
2 ¿A qué está otientada la programación en cada uno de estos lenguajes?
3 ¿Qué tipos de componentes puede haber en una interfaz gráfica?
4 Desctiba las seis notmas generales de diseño de interfaces gráficas.
5 ¿Para qué se utilizan las nomenclaturas?


///////////////,
Proyecto en
Microsoft Visual Basic
A continuación, comenzaremos a aplicar, en Visual Basic,
los conocimientos que fuimos adquiriendo. Utilizaremos el entorno
de desarrollo IDE (Integrated Development Environment) de Visual
Studio 2010, versión Visual Basic Express.
• Creación de proyectos ...............90 Estructuras de cootrol.. ............. 107

Datos estructurados .................. 116
• Variables.....................................96
• Uso de controles básicos ......... 122
• Operadores ............................... 104
Aritinéticos ............................... 104 • Resumen................................... 13 1
Lógicos ..................................... 105
Relacionales ............................. 106 • Actividades............................... 132
• Estructuras de programación .. 107

90 5. PROYECTO EN i\flCROSOFT VISUAL BASIC
Creación de proyectos
Para co1nenzar debemos conocer qué es un proyecto o solución en
Visual Basic. Un proyecto está compuesto por u11 conju11to de carpetas
y archivos que nos permitirán armar una aplicación, en donde se abna-
cenan códigos fuente, librerías, interfaces, etcétera.
Para crearlo debemos tener en cuenta el siguiente paso a paso , que
to1nare1nos como etapa principal para todos los instructivos que pre-
sentaremos a lo largo del capítulo.
PAP. CREACIÓN DE UN PROYECTO 6 -~
EjecuteVisual Studio y, desde Archivo' baga die en Nuevo proyecto .

01 Puede hacerlo desde la interfaz principal o utilizando las tedas CTRL+N.
lt,dwo ld"itw Vtt Otpun, ~ 01bH Ht"~' ~ \'tnttnt Ar¡,,ud.t

.,i]Nw.'O~ C.t-11
. . Nu,rw title-b- ~ ,.... . .,.
J--
~ Mw.o fl'fO)'l(-10. tq.......
,;l .... """""""" C.l•O j jQ' 2010 Profes9onal

'!!j .tt.nr~- b,... ~ $ . .......0
!¡¡ COM<bt 11 ,,.,.,to ck • . . . -
_; .,.,,ctw,.o_ lri rmac 0n or,tt,~ r va
' ' u
Comenz.,r
Las DLL (Dynamic-Link Library) son archivos que tienen en su estructura un código ejecutable
cargado b ajo la demanda de un programa informático p or parte del sistema operativo .

• Dentro de ' ' isu al Basic, seleccione Aplicación de Windo,vs Fom1s

02 y haga clic en Aceptar .
--
.....
,, .:_,
1il •
·--- ...,,_
'~ --·••11
_111..,._ ... _,,~
~ , . , . . t N,.IIM 1pkM1• 11(W1
--.
0.,.,tt.,l'i"IIJU
o......,. .. ~
...,,.._ ..,...,.
l11tft,..
: : ;i --
.............., ;s -...-
Ap arecer á un nuevo formulario y se agregar án los archivos necesarios

03 para el proyecto a la ve.ntana Explorador de soluciones .
Si es su prilner proyecto, recibirá el no1nbre de Windo\vsApplicationl
En el 1no1nento de gua rdarlo, elija el no1nbre y haga clic en Guardar .
La no1nenclatura adecuada sería PRY, que proviene de proyecto,
por eje1nplo p1yP1imeraAplicacion
~ •im~lud~
c..i.,u,._,.ltOW~fflOJ [.~•no,.
!;,... , 11 c..,...

92 5. PROYECTO EN 1111CROSOFT VISUAL BASIC
De esta forma hemos creado nuestro primer proyecto. En el IDE,

encontraremos diferentes herramientas que nos permitirán realizar las
tareas y administrar el proyecto. Para esto, en la siguiente guía visual
veremos cuáles son las características generales del IDE.
GV. CARACTERÍSTICAS GENERALES DEL IDE !!'!'P
m 1
-
T.... 1Ml•.....- •....... f -
.. c......-.c-
~
@
. ,... ' • •
., ............
B c.......
i;
c.-... •
""I
A
A
....
o...,-,c..
,......
,._
... ......
·--
•!
~
~
-~,..,.,..
,. ---
; 11
"" ............ t.'ª""
,.._ ........
---
~-
- r..,,;,_,.,.,....,_,..I..,...
e
•
........ ,
...,._
•A
• -·-
,.....
·,'- '""•
1-•-
~~
...__
. '.
~ """"-~•
= e,"'-w
,..,,,_
.,r_
~
- -
~.....
l~ +•~-• ,..,...,,, .l:
"':c!:::
..•::
· .=:
• .:::
'-:::
....
Atdfot.._w ¡t
c.... •
:J______________J.:..:'·:•:'·:- :.:·:·:·:=:-: ._...J
~
.._,, ttCMw,,i-.,.._
01 CUADRO DE HERRAlv lIEN TAS : proporciona las herramientas disponibles

durante el diseño para colocar controles en un formulario. Además del diseño
predeterminado, permite crear uno personalizado seleccionando Agregar
Ficha en el menú contextual y añadiendo los controles a la ficha resultante.
02 SOLAPA DISEÑ ADOR DE FOR.iv ll JLARIOS : permite agregar controles,

gráficos e imágenes a un formulario. Cada formulario tiene su propia solapa
Diseñador de formulario .
•
PROGRAt\1ACION DESDE CERO 93
• VENTANA EXPLORADOR DE SOLUC!Ol\lES : permite acceder a los distintos

03 formularios, componentes, clases, etcétera, que componen el proyecto.
Desde ella se puede ver el diseño gráfico de dichos formularios (botón \ ! er
Diseñador) y editar el código que contienen (botón Ver Código). Los botones
están situados en la parte superior de la ventana, debajo de la barra de títulos.
04 VENTANA PROPIEDADES : enumera las propiedades del objeto seleccionado

y su valor. Además, muestra el significado de la propiedad mediante una
breve descripción. Permite agrupar las propiedades de acuerdo con un tipo y
ordenarlas alfabéticamente. Con el botón Rayo podemos visualizar los eventos
correspondientes al objeto seleccionado.
Teniendo en cuenta estas características, podremos administrar

mejor nuestro desarrollo, ubicando fácilmente las diferentes herramientas
y ventanas, tanto al momento de diseñar la interfaz como en la escritu-
ra del código fuente.
Veamos ahora los tipos de archivo que se van a generar en la creación
de proyectos en Visual Basic .
Un !DE es un entorno de programación que ha sido empaquetado como un programa de

aplicación. Consiste en un editor de código, un compilador, un depurador y un constructor
de interfaz gráfica. Algunos son, entre otros: Eric (http://eric-ide.p)'i hon-projects.org ),
l\•I ono (1n onodevel op.co1n ), \Vingware (www.wingware.com )y Visual Studio (http:/ /
msdn.1nicrosoft.com/libra ry/Jn s l 6S088.aspx ) . Instalaremos Visual Studi o desde
\V\V\v.1nicrosoft.co1n/visualst udio/lata1n .

ARCHIVOS GENERADOS EN VISUAL STUDIO
T EXTINSIÓN DE ARCHIVO T DESCRIPCIÓN
.SL1'" Se utiliza para archivos de solución que enlazan

uno o más proyectos; ahnacena información global.
Es similar al archivo de grupo Visual Basic (vb ),
que aparece en versiones anteriores de Visual Basic.
.Sl:O Se utiliza p ara archivos que acompañan los registros

de solución y las personalizaciones agregadas.
Este archivo guarda nuestra configuración, como puntos
de interrupción y elementos de tareas, p ara que sean
recuperados cada vez que abramos la solución.
. VBPROJ Proyecto en Visual Basic.
.CSPROJ Proyecto en C# .
. VB Archivo con código Visual Basic.
.es Archivo con código C# .
.DLL Librería de código .
Tabla 1. Archivos generados por cada proyecto que creemos en Visual Studio.
Microsoft Vi rtual Acade1ny es un sistema de aprendizaje que busca generar actuali-

zación y entrenamiento constante, simulando una academia virtual. Es posible selec-
cionar can·eras y acceder a mucha info1mación de productos Microsoft.

• .. • • p
G,.., »....,,u,r,c:U :...1
• U:llot«H • • ,,. ..~ -if.~-:•.
"' ,-,,A-t•Apiuc•.. n M nun11
''""
r, J>Pi•
~ lm•9W1ec
lJ ,...,om,.,t-',bcioll,iln M) NJ.:04.:0 a t.1 croco•
Ji Mu,ru ~ ~ ",,...1 :,t
av.... ~.-t.C:.ft-"'k.e<IOf\Jl,IIO M.:t)~9a.
4 G1upott1dt1Qq•
f(ff!llc
.. {quipo
lt Dfl(O foc.11101
t..t D!KO locfll (0.1
.,1 UniCLfddeDWlN(Ck)
't NaoScovt
l"I, •••
P•MI Ck: concrct •
_. PtPf.ltffl de: tt<<lfJ(
1)·4,._DW.tJU
""
- . ~-----'----------'
Figura l. Al guardar el proyecto, se crea esta estiuctura

de almacenamiento de archivos y carpetas.
Cada proyecto es una única aplicación almacenada en su propia carpeta.

Dentro de ella se encuentra el archivo de configuración del proyecto y los
archivos reales XML, que contienen las referencias a todos los elementos,
formularios y clases, además de las opciones de compilación.
En Visual Studio, cada objeto o componente tiene propiedades , méto-
dos y eventos . Por ejemplo, el contenedor por defecto en los proyectos
Windo,vs Form (para aplicaciones de escritorio) posee las propiedades
Name (nombre que asignaremos al objeto o componente) y Text (texto que
aparecerá en dicho componente). En todos los controles encontraremos la
propiedad Name , donde asignamos el nombre del control, aplicando la no-
menclatura recomendada. Por ej emplo, si agregamos un control TextBox ,
en su propiedad Name podríamos asignarle txtEj emplo.
Para saber más acerca de las propiedades de los controles, podemos diri-
girnos al ~ISDN de Microsoft (http://msdn.microsoft.com )o a la página de
la iVIVA (Microsoft Virtual Academy, ,nnv.microsoftvirtualacademy.com ).

Variables
Tal como vimos en el capítulo 2 , las variables son uno de los elementos
más importantes en el desarrollo de programas y reciben el nombre de iden-
tificadores . Antes de continuar con su declaración, debemos conocer cuáles
son los tipos de datos que podemos utilizar en aplicaciones de Visual Basic.
TIPOS DE DATOS EN VISUAL BASIC
T TIPO DE DATO T DESCRIPCIÓN T INTERVALO DE VALORIS
Byte Números enteros. O a 255 (sin signo)
Booleao Valores lógicos. True o False
Ioteger Números enteros. -2 .1 47 .4 83 .6 4 8 a 2 .1 47 .4 83 .6 47

(con signo)
Long :Kúmeros enteros. -9 .223 .3 72.036.854 .775.808

a 9 .223.372.036.854 .775.807
(9,2 ... E+ 18 t ) (con signo)
Single (ponto flotante Números decimales. -3,4028235E+38 a - l,40 1298E-45

de precisión sencilla) t para los valores negativos;
l,40 1298E-45 a 3,4028235E+38
t para los valores positivos
Double (punto flotante :Kúmeros decimales. - 1,797693 1348623 1570E+308

de precisión doble) a -4,94065645841 246544E-324
t para los valores negativos;
4,9406564 584 l 246544E-324
a 1,797693 134 8623 1570E- 308
t para los valores positivos

TIPOS DE DATOS EN VISUAL BASIC (CONTINUAOÓN)
String (longitnd Cadena de caracteres. O a 2.000 millones de caracteres

variable) Unicode aproximadamente
Date Fechas ,v horas. 0:00:00 (medianoche) del 1 de enero

de 0001 a 11 :59:59 p.m. del 31 de
diciembre de 9999.
Tabla 2. T ipos de datos en Visual Basic.
En el siguiente enlace de MSDN se muestran todos los tipos de datos

que podemos encontrar: http://msdn.microsoft.com/es-es/library/
47zcea,v7(,, ,,s.100).aspx. Para continuar con el paso a paso anterior,
en donde comenzamos con la creación del proyecto, vamos a trabaj ar con
algunas propiedades de la interfaz y el código fuente de este lenguaje.
Para hacerlo, abrimos el proyecto pryPrimeraAplicacion y realiza1nos
lo siguiente en la interfaz gráfica asignando las propiedades del Fo1m :
A) Propiedad NAAIB = fimPtincipal
B) Propiedad T ext = Ejemplo de Variables
Luego continuamos con el siguiente paso a paso .
En la programación existen tres tiempos fundamentales. El tie mpo de ejecución , en el que se

ejecuta la aplicación y se llevan a cabo acciones sobre ella; el tie mpo de diseño , en el cual el
desarrollador asigna controles o formatos sobre la interfaz gráfica; y por tÜtimo, el tie mpo de
código , cuando el desarrollador está trabajando en el código fuente.

PAP. PRIMEROS PASOS EN EL CÓDIGO ..

-~
Agregue dos botones de co1nando y asígneles: al cont rol Buttonl,
01 btnConstante (en Name) y Constante (en Text); y al control
Button2, btnVariable (e.o Name) y Variable (e.o Text).
---- ... _._r
,_
.l
~
·- -
•..e
_
·---
C.•
-
"'·...~-
~·. ··~
·-
........
-
.,a--
•- - ~
t. --;-
·--
.~-
m-
-
.. ·--
-- -., .---
--..-,.... -...-·
,_.,..,.._
_---_
o-
,'-
·--
e ••
-.
,-.
uu
,_
·-__
,, ·- '~ .,_ --
'•
·--
:
Seleccione el frmFrincipal ypresione la tecla F7, o haga doble clic

O2 sobre él, y ent rará a tie1npo de código.Verá que ha ingresado en un evento
llamado Forml Load .
...
·-
,............__
,._
,,.n..,,
JI
•
•
Dentro del código, cree las variables del proyecto que se ve en la imagen.
03 __. _ ...
- ----.
· --- ·- -.....
--
,
.o,-....-
4 •- ...
'
' . - -· ,_ ..
.
.,- ......
.
·--
"
·--
-
'
.....
...-
'
- - -
-- .....
.. .
- --.. ~ I •••
-...-.
......
.....
... .,._ ..,._
·-
'
·--~
......
----•VM--._._
11 .,, .,. • ·-
,_
••
... -- -
• •
...
~l-
- · •-
,> j .... ._ _ _ ..,._
•~
-
..__...
u-
' . -
a.-....,_
O4 Vaya al modo de diseño, baga doble die sobre el botón de comando de

constante btnConstante
Por defecto, se mostrará el evento
y acceda al tiempo de diseño de dicho botón.
btnConstante Click cuando el
usuario ejecute el botón izquierdo del mouse sobre dicho control o la acción
de pulsar. Para utilizar las variables en toda la aplicación, dedárelas en
el sector Declaraciones .
,_1 .. -r-... ,. · - ·- ... •
,,..11, <hu
OUI Vat'Valw ,U I • ~
..,.lvi,u s.. ,.,..l_'--(M:tWc'f As jylu ti u ... , . . . , ~ ...
........
..... Hltrv4 • t,H
v.....,11.,. •
1~
, __
t
,
,_
l wu Ce 11u
, •
,, .,...clll
,, Mor ..,,....oo,
•
• En el área para escribir código de btnConstante_Click , codifique un

05 MessageBox para mostrar el valor de la constante . .,ll terminar de codificar,
para probar la aplicación, presione F5 o vaya al menú Depurar/Iniciar
Depuración, o baga die en Inicio.
·---
----- . -- --~ ·-
"' -
·--
,
e ••
---
e·-
•.
.. -- ---
... _.__
_- _,,__ __
---
•;
.,,
----
11
<-••---
--
u
•-·
.• _,_
·-
. ·-
·-· 1:>•- .1• - · -- - - - -
-·-
--
-·----
·-
\,.
'-
·- ·- - - - e - .....
--
Haga c lic sobre Constante para ver el siguiente resul tado.

06 ~·
-
.. _
--
e--•
.....
c.---
_
·-·- ~-·-· ~· .......... --......... ...
- - --- ·----
- -"I •
···-- _
,.,,. '''"'
otf'l'
.,..,
"
*º
,.
·--............J - · ~ ----- ---

• -"'1 o
• • ,,.,_.._
• ''
.............,,.....,
#
_,,..,
·---
........ 1 ..__..,..,, __.,.
·-·-. -•---p,a -~
~
1
1.......... .(
"
... e-. ..... ....
,_'lf..,
--...,...,......,__ _____
_...,._,..__..,_ ..... _... .,..,. ..
O

PROGRA1\1ACION DESDE CERO t!hi 3 \-fi 101
Al fmalizar el ejemplo, desearemos guardar el proyecto. Sin embargo,

en futuros proyectos es preferible ir haciendo grabaciones en forma
constante. En el momento de almacenar, podemos hacerlo desde el
menú Archivo/Guardar todo, seleccionando el icono desde la barra de
he1Tamie11tas o pulsa11do las teclas CTRL+MAYUS+s .
Gwa,chr P'O)'Mto
Ubucio11: C:\UtlmJQUl•\Datk:Op
Horrbu;: de: •• ,ohtción; pryPrimcr""'''•ti~Ñ
Figura 2. Proceso de guardado. Debemos ver si la casilla Ubicación tiene

la dirección de carpetas apropiada y, en caso de querer tener todo agrupado,
si la opción Crear directorio para la solución está marcada.
Ahora veamos cómo asignamos valores a una variable, con el ej emplo

pryPrimeraAplicacion . En el botón btnVruiable hacemos doble clic con el bo-
tón izquierdo del mouse sobre él, y nos enviará al código fuente en el evento
Click. Allí escribimos lo siguiente:
var,7alor=150
l\il essageBox.Sho,v("El valor de la variable es: " & var,7alor)
Una de las propiedades frecuentes en los controles de Visual Studio es Text . Puede especi-
ficar o deternúnar el texto mostrado en un control, en especial, los de tipo Lab el YTextBox.
Asi también, en los Form de Windows Forms determina la barra de título correspondiente.

102 5. PROYECTO EN 1'flCROSOFT VISUAL BASIC
Para continuar con el ej emplo, asignaremos diferentes valores en

tiempo de ejecución, es decir, el usuario pondrá un valor que cargaremos
a varValor . Para esto, agregaremos en el proyecto:
1) Un control caja de texto ( TextBox ), al que le asignaremos : Name: txtCarga .

2) Jlmto a txtCarga, lm botón de comando (Button) con las propiedades
Name: btnAsignar y Text:Asignar.
3) El siguiente código nos servirá para asignar valores a la variable:
Private Sub btnAsignar_ Click(ByVal sender As System.

Object, By\Tal e As System.EventArgs) Handles btnAsignar.Click
var\'alor = txtCarga.Text
..
txtCaraa.Text = ""
l\{essageBox.Sho,v("Se asignó el valor: " & var\7alor)
EndSub
4) El mecanismo sería: ingresar un dato numérico en txtCarga y, luego,

hacer clic en btnAsignar, donde se muestra el valor que tiene varValor
y blanquea cualquier dato que esté en txtCarga.
El error de conversión indica que estamos intentando grabar un tipo

de dato que no corresponde a la variable declarada (en este caso, lm texto
en lma variable de tipo numérico).
La instrucción MessageBox como clase - es decir, que podemos utilizar en cualquier len-
guaje que emplee el framework J\1ET- muestra un cuadro de mensaje que puede contener
texto, botones y símbolos, para informar e instruir al usuario de una aplicación.

ot. CDfllW. A& Oecf.Nl

Ola ..,-1,'.alo,- "' tJot,....
' "
• OtpUIIIMn '""°'" 111, lf
,.,.IY.tU ,.. "oral_l.Ni( I_.., ,.. S)'U• • • t Al S,,t.ta. ......) .,....1.. ,.,.,.... Leeió
• w,.w.s.,,.... ·u
~. . . . '·"
1 , ,.. ..
-.
11'1f"V• lor . .., .
.l. .... ~....~.....

.. ... . ...,..
• bol:qi,dó.Sc~,..
• .....
........
fllli (bH
o~ w • uo."41 ·• .,., .., ir..- no•<na4.-,

s, ...,......... ~ ·· -
•w:
H ras cr a la sexnc ;,-15 • ,s :áGr 1sz; oc:aramsv pf;;¡;Q 1 •
,.......~ ............ 0!'9"" .. , - ~ - - - • - . , . , . . , . . '"'º
a.......... .._. ........ .... •
.... ..
........... .......,........... .,.,....... .. .....,......,.,,.._UI Nla..
..... ....... ., ...
. .....c...~ ..... 1~,r..t-•.-ll:1i.,..,..,.......11~ ....... CIIIIII!,,
......
,
.... 1 --·!~
-
....,.. .. ..
~ :
.... ..... .............. Jc..t . . .
• •
____,.
!fil _ . _, 11 ~ • ....._ i... - , !\, r,. & lf' ,_ !JI _...._. • ~...,., • lnW • I• lf\ Tu
,•-, ,..,r ,~u , .. ~ M
Figura 3. El en·or de conversión aparece cuando ingresamos un valor

que no es numérico o dejamos la caja de texto en blanco.
Revisando el ejemplo utilizado, podemos determinar cómo es la sintaxis

en Visual Basic para la declaración de variables :
[Public I Prívate] Const Nombre [As Tipo] = Expresión

[Public I Prívate] Dim Nombre [As Tipo]
Publices opcional, e indica que la constante es pública y está disponible

en todos los módulos. Private es opcional, e indica que la constante es pri-
vada y está disponible en el módulo donde se declaró.
Como podemos apreciar, Visual Basic tiene una palabra reservada para
las constantes, Const. En este caso, debemos modificar la declaración de la
constante de nuestro primer proyecto. Así, deberíamos escribir el siguien-
te código en la zona de declaraciones:
Const conIVA As Decimal = 0.21

Operadores
Veamos ahora cómo es el trabajo con operadores en Visual Basic.
Aritméticos LOS OPERADORES

Como hemos visto, los operadores
aritméticos so11 utilizados para realizar ARITMÉTICOS
cálculos 1natemáticos, y van acompañados SE UTILIZAN PARA
de variables y constantes para formar
expresiones que reton1an u11 valor. REALIZAR CÁLCULOS
Por ejemplo, es posible sumar el sueldo base :tv1ATEMÁTICOS
con la remuneración y restarle los aportes.
Los operadores aritméticos que se utilizan
en Visual Basic son los siguientes: + (suma), -
(resta), * (multiplicación), 1 (división), (división
entera), Mod (módulo) y " (exponenciación).
Veamos tm ejemplo de cómo sería el código en Visual Basic para cal-
cular un sueldo base de $4000 (este valor puede variar), un aporte del
13% (este valor es fijo) del sueldo base, y tma remtmeración por $500
(este valor puede variar).
Dim varSuel doBase As Intege.r = 4000

Const conAporte As Decimal = 0.13
Dim varRemuneraci on As Intege.r = 500
Dim varSueldoNeto As Integer = O
varSuel doNeto= varSuel doBase + varRemuneraci on

- (varSueldoBase * conAporte)
J\ll essageBox.Sho,v("El suel do neto es: " & varSuel doNeto)

~ ...11 ..,,.,,111, 1....1,,..10,, FormJ .rll X ~'" "' ~11 •0,_,>l.,11 •

,J {K'.l,ml CV'Cl'III») •1 i lood .
.,,¡PubHe Cl11 u t., t
1+
•
1 J (je~~VJitbble:yOp,ttad CM'~ o ' ll!I !l
- - -
1 • A~ sy~tttl,t\CntNg~) H~nd lc; ")'
qH111b 6t c-t.lldoltt MNOCOt
1
1
a,.,....,._........ 1 ¡
(1 i lM':kl O 1'180 el: 3980
1 A<tph r
1 ::
Figura 4. Interfaz y resultado del ejemplo, donde se muestra,

en una ventana de diálogo, el código que generamos.
Lógicos
Los operadores lógicos permiten conectar expresiones y determinar su
veracidad o falsedad. Producen resultados de tipo ,,erdadero o falso.
En Visual Basic, son And ( conjunción lógica), Or ( disyunción lógica) y Not (nega-
ción). En el ej emplo que veremos a continuación, vamos a comparar variables
booleanas (que almacenan verdadero o falso) y utilizar las operaciones lógi-
ca s para ver los resultados que podemos obtener:
Dim varDl, varD2, varD3 As Boolean

varDl = True
varD2 = True
varD3 = varDl AND varD2
l\il essageBox.Sho,v("El resultado es: , TERDADERO")
Recordemos que, como vimos en pseudocódigo, en el operador .IU\lD

deben cumplirse todas las condiciones para que su resultado sea verdadero.
En el próximo ej emplo veamos el uso de OR:

Dim varDl, varD2, varD3 As Boolean

varDl = True
varD2 = False
varD3 = varDl OR varD2
l\lessageBox.Sho,v("El resultado es: ,TERDADERO")
Relacionales
Los operadores de relación son utilizados para realizar comparacio-
nes entre expresiones. Visual Basic provee los siguientes: = (igualdad),
<> (desigualdad), < (menor que), > (mayor que), <= (menor o igual que),
>= (mayor o igual que).
Estos operadores son usados en las estructuras de control de un programa,
y los veremos en el próximo tema por desarrollar; pero antes, es importante
conocer los signos de concatenación. Antes hemos defmido concatenar
como la acción de unir dos expresiones alfanuméricas en un solo elemento.
Por ej emplo, en Visual Basic utilizaremos :
, , ariablel = "Juan"+ " " + "Carlos"

, , ariable2 = "XYZ" & 666
A la Vruiablel se le asignan las cadenas "Juan" espacio "Carlos".

A la Vruiable2 se le asigna la cadena "XYZ" y el valor entero 666.
Otro operador utilizado en el lenguaj e es el punto , que sirve para conectar
obj etos con propiedades y métodos, y recuperar y almacenar datos en
variables creadas a partir de tipos de datos definidos por el usuario.
TxtDomicilio .Text = "BUENOS AIRES"

Persona.Edad = 30

El operador = se emplea para comparar y asignar:
If a = b Then
•••
End If
d = e + 47
Estructuras de programación
Como vimos en pseudocódigo, para realizar un algoritmo que resuelva
tma sih1ación dada debemos utilizar estn1ch1ras de control que nos permitan
preguntar por una condición o realizar determinadas acciones repetidas
veces. A continuación, veremos su aplicación en el código fuente.
Estructuras de control
Las estn1ch1ras de operación de programas constih1yen tm grupo de
formas de trabajo que, mediante el manejo de variables, permiten realizar
ciertos procesos específicos para solucionar los problemas.
Estructuras condicionales
Las estructuras condicionales comparan una variable con otros valores
para que, sobre la base del resultado de esta comparación, se siga un curso
de acción dentro del programa. En Visual Basic vamos a utilizar las siguientes
palabras reservadas para estructuras condicionales : If-Then-End If y Select Case.
• Estructuras condicionales si111ples :

La estruch!ra If-then-End If permite ejecutar instrucciones en forma
condicional, donde tendremos una condición que se puede cumplir
o no, y el resultado será verdadero o falso. Dependiendo de esto,

tendremos que realizar u11a o varias instrucciones de código.

A continuación, compararemos la sintaxis en pseudocódigo con
la de Visual Basic, para to1nar co1no eje1nplo.
Pseudocód igo Visual Basic
Si<condición> entonces If condición then

Instrucción/es Instrucción/es
Fin Si End lf
Instrucciones : acciones por realizar 11 : indica el comando de comparación.
cuando se cumple o no la condición. Condición : es una expresión que se analiza
y, en caso de ser verdadera, se ejecuta el
bloque de instrucciones comprendido entre
las palabras If Y End If .
Ahora utilizaremos tm ejemplo que teníamos en pseudocódigo, trans-

formándolo a código de Visual Basic. Contamos con la variable Edad, en
la cual el usuario ingresará tm valor, y debemos pregtmtar si este es ma-
yor o igual que 18. Si el resultado es verdadero, debe aparecer un mensaje
que indique "Mayor de edad". Asignaremos el valor 19 a la variable Edad
variable Edad tipo numero Dim Edad as Integer

Edad 19 Edad=l9
SiEdad>=l8 entonces If Edad>=l8 then
:\10S TRAR "::vlayor de edad" 11essageBox.Show(''A,1ayor de edad")
Fin Si End lf
Las estructuras en sí son muy parecidas; solo debemos estar atentos a

la nomenclatura del lenguaj e que utilicemos para nombrar sus condicionales
simples. Cuando escribimos If en Visual Basic y presionamos dos veces la
tecla TAB, automáticamente se completa todo el bloque lf-Then-End If:

If True Then
End If
Vemos que se escribe automáticamente True en donde debemos ingresar

la condición que deseamos corroborar.
• Estructuras condicionales dobles:

Permiten elegir entre dos opciones, en función del cumplimiento o no
de una determinada condición. En Visual Basic tienen la siguiente sintaxis :
If condición Then
Instrucci ón/es
Else
Instrucci ón/es
End If
De esta forma, podemos realizar acciones si las opciones de resultado

son verdaderas o falsas . Continuando con el ej emplo anterior, indicaremos
cuándo la variable Edad es mayor que 18 y cuándo no.
variable Edad tipo numero Dim Edad as Integer

Edad 19 Edad=19
S iEdad>= 18 entonces IfEdad>= 18 then
l\-1ostrar "'l\-1ayor de edad" l\-1essageBox.Show (''l\-1ayor de edad")
Sino Else
l\-1ostrar "'l\-1enor de edad" l\-1essageBox.Show (''l\-1enor de edad")
Fin Si Endlf

• Estructuras condicionales 111últiples o anidadas :

Son decisiones especializadas que nos permiten comparar una variable y
sus posibles valores. Dependiendo de estos valores, se ej ecutará el bloque
de instrucciones apropiado. La sintaxis de estas estructuras es la siguiente :
If condición then
Instrucción/es
Else
If condición then
Instrucción/es
Else
If condición then
Instrucción/es
Else
Instrucción/es
End If
End If
End If
Veamos un ej emplo. Deseamos saber si la variable varlnte1valo está com-

prendida entre ciertos valores. Dependiendo de esto, indicaremos que, si
varlnte1valo está entre O a 20, es un valor "bajo"; entre 21 y 50 es "medio";
entre 51 y 80 es "alto"; y entre 81 a 100 es "excesivo" .
Para que vayamos expe1imentando las teclas rápidas del lenguaje de programa-
ción, revisemos un listado que nos será muy útil: F2 (exantinador de objetos), F5
(ejecuta el proyecto), F8 (ejecuta sentencia a sentencia), F9 (punto de depuración),
CTRL+El\1TER (detiene la ejecución de tm programa).

A continuación, veamos la codificación correspondiente, Sllponiendo

que el usuario ingresa el valor 66:
varlnte.n ,alo = 66
If varlnten ,alo >=O AND varlnten ,alo <=20 then
l\lessageBox.Sho,v("'' alor Bajo")
Else
If varlnten ,alo >=21 AND varlnten ,alo <=50 then
J\ll essageBox.Sho,v("'' alor l\ledio")
Else
If varlnten ,alo >=51 AND varlnten ,alo <=80 then
J\ll essageBox.Sho,v("'' alor Alto")
Else
J\ll essageBox.Sho,v("'' alor Excesivo")
End If
End If
End If
Otra de las estructuras que podemos utilizar para realizar este tipo de
condicionales múltiples es el select case, que en pseudocódigo vimos como
según sea. Veamos la sintaxis en ambos :
Segun_ Sea <condición> hacer Select Case Variable

Caso 1 : Instrucción/es Case Constante!
Caso 2 : Instrucción/es Instrucción 1O
Caso 3 : Instrucción/es Case Constante2
Sino Instrucción20
Instrucción/es Case Else
Fin_ Segun lnstrucciónNO
End Select
Apliquemos esta instrucción para resolver el ej emplo anterior:

Dim varNumero As Intege.r

varNume.ro = 66
Select Case varNumero
Case Is <= 21
l\{essageBox.Sho,v("El valor es Bajo")
Case Is <= 51
l\{essageBox.Sho,v("El valor es l\{edio")
Case Is <= 81
l\{essageBox.Sho,v("El valor es Alto")
Case Else
l\{essageBox.Sho,v("El valor es Excesivo")
End Select
La estructura condicional múltiple Select Case es tm If anidado más desen-

vuelto, desde el punto de vista de la claridad del código que escribimos. Para
este ej emplo, también podemos utilizar la siguiente forma de comparación:
Select Case varNumero

Case Is < 21
l\{essageBox.Sho,v("El valor es Bajo")
Case 21 to 50
l\{e.ssageBox.Sho,v("El valor es l\{edio")
Case 51 to 80
l\{e.ssageBox.Sho,v("El valor es Alto")
Case Else
l\{e.ssageBox.Sho,v("El valor es Excesivo")
End Select
Hasta aquí revisamos las estructuras de control utilizadas para pre-

gu11tar secuencialmente sobre alguna condición o caso. En este lenguaje
de progra1nación utilizaremos If-Else-End If para condiciones sünples o
múltiples, y la est1uctura Select Case , que es 1nuy útil para algunos tipos
de condiciones 1núltiples.

Estructuras repetitivas o cíclicas

Repasaemos cómo repetir partes de un programa mientras cierta condi-
ción se cumpla o sea verdadera. La estructura de control repetitiva Do Loop le
permite a nuestro desarrollo reiterar la ej ecución de un bloque de instruccio-
nes hasta que se cumpla cierta condición. La sintaxis tiene dos variantes :
Do \Vhile condición
InstruccionesO
Loop
En este caso se analiza la condición. Si es verdadera, se ej ecutará el bloque

de instrucciones delimitado entre Do y Loop, y el proceso se repetirá otra vez,
siempre que el resultado de la condición sea verdadero.
Do
Instrucci ones O
Loop \Vhile Condición
La diferencia que existe entre estas estructuras es el orden en el que se

ej ecutan los bloques de instrucciones algorítmicas. En un caso se analiza la
condición y luego se ej ecuta el bloque de instrucciones, y en el otro se ej ecu-
ta el bloque de instrucciones y, luego, se analiza la condición. Otras estructu-
ras repetitivas que podemos encontrar son:
Do Until Condición
InstruccionesO
Loop
En esta estructura se analiza la condición. Si es falsa, se ej ecuta el bloque

de instrucciones, y el proceso se repite hasta que la condición sea verdadera.

Do
Instrucci onesO
Loop Until Condición
Para esta instrucción repetitiva, se ej ecuta el bloque de instrucciones y,

luego, se analiza la condición. Si esta es falsa, se repite el proceso otra vez
hasta que la condición sea verdadera. Veamos ahora una estructura repetitiva
muy útil, que en pseudocódigo equivaldría a la sintaxis Hacer-Hasta . En el len-
guaj e se utiliza Foro For Each. La instrucción For-Next ejecutará en un detenni-
nado número de veces un bloque de código. Veamos la sintaxis :
For Variable= Valorl To Valor2 Step I ncre1nento

Instrucci onesO
Next
El bloque de instrucciones que se repite está delimitado por

las instrucciones For y Next. La sintaxis Vruiable es una variable de tipo
nu1nérico que toma valores entre Valorl y Valor2 . Por cada vez que el
bloque se ejecuta, el valor de Vruiable se incre1nenta en el valor especifi-
cado en Incremento, que puede ser positivo o negativo. Veamos tm ejem-
plo donde debemos sumar un número cinco veces:
Dim i, respue.sta As Intege.r

For i = 1 To 5
re.spuesta = i + i
Next
En este ejemplo, la repetitiva ejecutará cinco veces desde i= l hasta 5

y acumulará la st1ma en la variable respuesta . Si la variable i iniciara en O,
entonces se ejecutaría 6 veces.

Revisando estas diferentes estructuras, podemos concluir que las estruc-

hiras repetitivas se usan cuando queremos realizar tma acción, mientras sea
necesario cumplir o no una condición determinada . A continuación, veamos
una tabla comparativa de ellas.
TIPOS DE ESTRUCTURAS REPETITIVAS
T ESTRUCTURA T DESCRIPOÓN DE USO
Do W"hile condición Ejecutará tantas veces el bloque de código en función

lnstroccionesO de una condición, ya sea verdadero o falso.
Loop
Do Primero ejecutará el bloque de instrucciones

lnstruc.c ionesO y luego evaluará la condición.
Loop \Vbile Condición
Do Until Condición Ejecutará tantas veces el bloque de código en función

lnstroccionesO de una condición, hasta que sea verdadera.
Loop
Do Primero ejecutará el bloque de instrucciones

lnstruc.c ionesO y luego evaluará la condición.
Loop l:ntil Condición
For Variable = Valorl To Realizará una acción, a veces en la condición,

Valor2 Ste p Incremento hasta cmnplirla; las instrucciones serán ejecutadas
lnstroccionesO cada vez que ingrese.
~ext
T abla 3. Comparativa y desciipción de las esbu cturas repetitivas.

Datos estructurados
Los tipos de datos estructurados son espacios en la memoria que
serán utilizados 1nientras la aplicación sea ejecutada, y se borrarán de
la memoria en el momento de finalizar el programa. Los vectores y las
matrices son las estructuras que utilizare1nos para almacenar informa-
ción de manera temporal y 1nanipular estos datos.
Matrices
Las matrices so11 las est1ucturas que tie11e11 u11 co11ju11to de eleme11-
tos relacionados lógicamente entre sí. Sus elementos deben ser referi-
dos 1nedia11te u11 solo nombre y u1111ú1nero lla1nado índice, para así
poder distii1guirlos. Los ele1ne11tos so11 seguidos desde el h1dice cero
hasta el índice de valor superior.
a 11 a 12 a lj
a in
ª 21 ª22 a 2i ... a 2.n
A =
a il ª ,2 a
• . .. a. U1
a !!il a f':">.2 a !'!ij ... a rr.r:
Figura 5. Ejemplo de una matJiz teó1ica, donde se esc1ibió el

elemento A compuesto por innumerables valores.
Cada número de la matriz se denomina elemento , y se disti11gue de

los demás por la posición que ocupa (es decir, la fila y la columna a la
que pertenece). Veamos algunos eje1nplos en lenguaje de programación.
Declaramos u11a 1natriz para almacenar la cantidad de horas trabajadas
por día de lunes a vien1es:

Dim Dias(5) As Integer
Esta matriz tiene seis elementos, y los índices están en el rango de cero
a cinco. Su declaración es más simple y útil que declarar seis variables dife-
rentes, es decir, seis espacios en la memoria donde se pueda asignar un valor
numérico. La sintaxis para declarar una matriz de tipo vector (es decir, una
matriz de una sola dimensión o unidimensional) es la siguiente :
DimVector(5) As Integer
Esta sería la sintaxis para declarar una matriz de tres dimensiones :
Dim Matriz(5, 5, 3) As Integer
Para asignar valores a u11a 1natriz, tan solo debemos indicar el espa-
cio que desea1nos utilizar, por eje1nplo:
Dias(O) =6
La posición O de Dias se almacenará en el valor 6. Cuando estamos mane-

jando estas estructuras, también podemos asignar valores al declararlas :
Dim PersonasO As Stiing = {"l'v1arcio","Cesar","John", "Agustina"}
Es un proceso por el cual el compilador detennina el tipo de dato en una variable

local, declarada sin explicitar su tipo. De esta manera, el tipo de dato es inferido a
partir del valor inicial provisto a la variable. Por ejemplo, en Visual Basic se infiere el
tipo Object si se declara una variable sin tipo de dato.

La cantidad de elementos asignados determina el tamaño de la estructura.

Según esta declaración, se trataría de una matriz de una dimensión o un vec-
tor, que cuenta con cuatro posiciones.
Nombre de Matriz: Personas

Posición o 1 2 3
Dato ilvlarcio Cesar John Agustina
Figura 6. Declaración de una matiiz simple. Contiene cuati·o

datos que son texto, y la posición inicia en O.
Cuando hablamos de dimensión dentro de u11a 1natriz, hacemos

referencia a un índice que nos indica la dirección específica de ele1nen-
tos dentro de ella. Supongamos que tenemos una matriz que contiene
el total de horas trabajadas por día. En este caso, crearemos u11a estruc-
tura que tenga como dimensión la cantidad de días, donde se guarden
las horas trabajadas. Por otro lado, si tenemos la necesidad de guardar
el total de horas trabajadas por empleado, debemos utilizar u11a 1natriz
que tenga dos ditnensiones para altnacenar: el no1nbre de las personas
y su total de horas trabajadas. Veamos los ejemplos en código:
Ej emplo 1: Dim HorasTrabajadas(n) As Integer
Ej emplo 2: DimTotalHorasTrabajadas(n, n) As Integer
El QBASIC, originado por contracción del nombre QuickBasic, es una variante del len-
guaje de programación BASIC. Provee de un !DE avanzado, e incluye un depurador con
características tales como evaluación de expresiones y modificación de código.

lvlatriz unidimensional
1 (O) 1 ( 1) 1 (2) (3)
Matriz bidimensional
(0,0) (0,4)
(1,0)
(3,0) (4,4)
lvlatriz tridimensional
(2,0,0) (2,0,4)
(0,1 ,0
(1,0,0) (1 ,0,4)
(0,1 ,0
'0,0,0) (0,0,4)
~.V--'• (2.4.4)
,0,1 ,0)
(0,3,0 (1,4,4)
,0,3,0) (0,4,4)
Figura 7. Dimensiones de diferentes matiices y representaciones

de sus equivalencias en la memo1ia de un equipo.
El máximo es de 32 dimensiones . Es importante que este1nos aten-

tos al agregar estas dimensiones, ya que el espacio total necesario irá
au1nentando de 1nanera considerable.
Almacenamiento de información
Podemos crear matrices que no contengan información, o en la misma
declaración cargar información sobre ellas. Veamos cómo se crea una matriz
que no tiene elementos, declarando tma de st1s dimensiones en - 1:

Dim matDosDimensiones (-1, 3) As Integer
Conociendo las matrices de longih1d cero, veamos cómo podemos re-

llenar una matriz con valores iniciales, pero aplicando ahora un literal de
111atriz. Este se encuentra formado por tma lista de valores separados por
comas que se encierran entre llaves ({}).
Cuando se crea una matriz utilizando un literal de matriz, se puede pro-
porcionar el tipo de la matriz o usar la inferencia de tipos para determinarlo.
Ambas opciones se muestran en el código siguiente :
Dim matNumeros = Ne,v IntegerO {1, 2, 4, 8}

Dimmat, 7alores = {"a", "valor", "b", "texto"}
Las declaraciones explícitas del tipo de los elementos de una matriz se

crean utilizando un literal de matriz. Los valores de este se deben ampliar
al tipo de los elementos de la matriz. En el siguiente ej emplo, podemos ver
cómo se crea una matriz de tipo Double a partir de una lista de enteros :
Dim matD atos As Double() = {! , 2, 3, 4, 5, 6}
Hasta aquí hemos visto la asignación de valores en la declaración de es-

truchiras. Ahora veremos cómo recorrer tma matriz y guardar información en
ella por medio de un código.
Variable vecEjemplo (30) tipo numero Dim vecEjemplo(30) As Integer

Variable i tipo numero O Dim indice As Integer = O
Para i1 hasta 30 hacer For indice = 1 To 30
vecEjemplo(i) i vecEjemplo(indice) = indice
Fin Para N ext
l\,íostrar "Vector cargado" l\,íessageBox .Show(''Vector cargado")

En el ejemplo de Visual Basic, creamos un vector con 31 posiciones y

cargamos los valores de la variable índice, con lo cual quedan cargados
valores del 1 al 30. Para asignar valores en u11 sector específico de este
ejetnplo, podría1nos realizar lo siguiente:
vecEjemplo(lO) = 150
En el código anterior indicamos que, en la posición 1O de vecEjemplo ,

vamos a grabar el valor 150. Si deseamos mostrar la información de esta
posición u otra, podemos realizarlo de la siguiente manera:
Iv1essageBox.Sho\v("El valor en la posición es:" & vecEjemplo(lO))
Recorrido de información
Para ver la información secuencial de una estructura, ya sea unidimensio-
nal (vector) o de varias dimensiones, debemos realizar la siguiente codificación:
Variable matEjemplo (4, 4) tipo texto Dim matEjemplo (4, 4) As String
matEjemplo( l,l) "Lunes" matEjemplo(l,1) = "Lwies"

matEjemplo( l,3) "Fuente" matEjemplo(l,3) = "Fuente"
ma1Ejemplo(3,2) 5000 matEjemplo(3,2) = 5000
matEj emplo(4,4) "Ultimo" matEjemplo(4,4) = "Ultimo"
Variable i61a, icohnnna tipo numero O Dim i61a, icohnnna As Integer

Para icolumna 1 hasta 4 hacer For i61a= 1 to 4
l\,íostrar matEjemplo(i61a, icohnnna) For icohnnna = 1 to 4
Fin Para l\,íessageBox .Show(matEjemplo(i61a,
Fin Para icohnnna))
Next
Next

Cabe destacar que estaremos mostrando mensajes por la cantidad de

veces que entremos en los datos de la matriz. En este caso, encontraremos
que son cuatro filas y cuatro columnas, que nos darán un resultado de
16 espacios, constituyendo así 16 ventanas. Para evitar esto, podemos
aplicar el código de eje1nplo que aparece a continuación y, así, 1nostrar
solo los espacios que contienen valor:
For ifila = 1 To 4
For icolumna = 1 To 4
If matEje.mplo(ifila, icolumna) <> Nothing Then
l\llessageBox.Show(matEjemplo(ifila, icolumna))
End If
Next
Next
En el código ve1nos únicamente aquellos espacios que contienen va-

lores distintos a 11ada (Nothing ) . De esta forma, tanto en pseudocódigo
como en código del lenguaje, el recorrido de la información almacenada
en una estructura de datos (tal como una matriz) debe iniciarse con un
índice que indique la fila o columna. Si la dimensión de dicha 1natriz
fuese tres, podríamos crear índices X, Y y Z para recorrerlos.
Uso de controles básicos

Hacemos referencia a controles básicos no porque sean los más
sencillos, sÍ110 por ser los más utilizados.
Realizando los pasos vistos anterionnente, creare1nos un proyecto
nuevo en el cual veremos algunas características principales del form
(forma o formulario).

PROGRAt\1ACION DESDE CERO (!J.jd,-fi 123
GV: PROPIEDADES DE UN FORM ( ~
-..e- ,~-· ....

,._ . . ._
~_,.....
,.. ..,
,-,.,.,u.,
• 1 1111 ,
.,
,·
-·
~1111~"''°
..... ""...... ,..~ .....
LM!f"•
..,_
~
......
,
f\'101t
,
...••
.....
.....
~ -••llloO•~
,....,"",_,.
,......
--
Aaa,et.eN,,,.,
tti.,~,
....\!! ...s-r•~ ........ ... •
-·- .,•.
JJcc, .........
,..... ,_
.........,..,""' ·-·,••... -tlD
.,
,; .......
- --......
.....,........
' ..
.,;
-
••
n .. ,_-· -·· •
--~ -... ... ... ,.,i,rf-1.oll ...
S.-c.C.......
, t; .. ~·
CD ...,edt1Mlt •••
+ hll,i,__,~
e,_
,-,1,(T,hl'll.'1"\
....
,...
,_
~ T......, fM
,'....•.,...,NI.,
~
C)
•
,_
,.....
tl r..i~9'fllll"•'
..•.
COlnltCMt,...2tlo
,_ ,
--
-~ -....... ,.,. ··- .... -·-
,
...........
_., .,
'r.,.,..,.
,.,,.,.~
,
o,
11!1
\.
• ,,....,_
'"~'
'•• """' .. ...
,
o..,~i.,......
{11.iH
f,m
,•••
Moc.....ttS.111 S. - -- -·
,_,
01 (NAl\/IE) : nombre del control para identificar en el código.

P or defecto vere1n os Forml.
}JA){Jlv[IZEBOX : si asignamos el valor de esta propiedad en Falso,

02 no apa recerá en el fo n n .
Mll\iJMIZEBOX: si asignamos el valor de esta propiedad en Falso,

03 no apa recerá en el fonn .
STARTP OSITION : indica la posición del form en la pantalla del usuario.

04 Por ejemplo, cada vez que se ejecute el programa, la propiedad
ubicará el form en el centro de la pantalla del usuario.
CenterScreen
05 TEXT: en el caso del fonn , es pa ra 1n ostra r texto en la barra de títulos.
06 CANCELBUTTON : si establece1n os esta p ropiedad con un botón de co1nando,

este se activa cuando se p resiona ESC.
07 BACKGROUNTIIMAGE : penn ite asigna r una ilnage.n de fondo.
•
•
o8 BACKCOLOR : permite asignar el color de fondo.
09 ACCEPTBUTTON : si establece1nos esta propiedad con un botón de co1nando,

este se activa cuando se presiona E:l\lTER.
Continuando con el paso a paso de la página 100, desarrollaremos un caso

práctico más complej o para ver cómo se utilizan estas herramientas y, así,
poder aplicar las variables que aprendimos antes. Asignemos las propieda-
des del Fo1m1 de la siguiente manera:
a) (Name): fimP1incipal
b) StartPosition: CenterScreen
e) Text: Pantalla P1incipal
d) MaximizeBox: False
e) Iv1inirnizeBox: False
PAP. COMPORTAMIENTO DE LA INTERFAZ li

y asígneles:a Buttonl, btnAceptar (en Name) y Aceptar
Inserte dos botones
01 (en Text );a Button2 ,btnCancelar (en Name) y Cancelar (en Tex().
-.. ,,, ..
--~ ··-
.·--
. i... ...- - . . •
-·-
~ . ~. =-:_-:_-:_--;::¡¡;¡:;,
--- ··-
.--
-
"e .__
e-
.,
O•t-
,_
·-
• -h
·-
·- --
·-
º'""'
t •• '"
-
•
• AcceptButton asigne btnAceptar ,

02 A las propied ades de
ya CancelButton, bt11Cancelar.
--·-
.----
.- __
_.,........,... . .. ·-·. ·-· ·- . -- __..._
·--
·- ·-
- ·-
...--
........·-
..·-
~
~
---.
.-,..·--
"
·---. ,-
- - ,---
--
•-·"u ... 4 ...
--...... -·....··---
- -·•
·-. ·-
-;¡ _,..,
' ....... --............. -·-

··- ·- -·-
·- ________
----- -~--- ...
,.
L \ •
8::;...
f do6
,,,... .
En el diseño visual en btnAceptar baga doble d ie con el botón

03 izquierdo del mouse o presione
Ubíquese en el evento
F 7 para ingresar a tiempo de código.
Click de btnAceptar y escriba el código.
·--,...-
c . - .. -
- -a-··-
.......................
.............,,,_
...·-·
-,. ...
• ••
,_., - -
.,
. . . .,....('111-.UWO,c) -
- - · - - - o..l
.. Jr'Otff
......__...,i
• tWol • ._ ..,..
•
126 5. PROYECTO EN 1'flCROSOFT VISUAL BASIC
• Ingrese en el evento C lick de b tnCa11celar y escriba End ,

O4 palabra reservada que cerrará y descargará la aplicación de 1ne1noria.
Compile presionando F5 o desde el 1nenú Depurar, y pruebe la aplicación.
'"111n• S.- btMC.-.>tW'..Cll<k(..,Vd Stft6tf' .\1 s,n. .. ai •~:.. 1,.v,1 • ~ S

...u ..g..-• •• s"-("',.....,,w,,,.o .. 1 b,pt &, u -,t-º)
(M . . .
- . ,.J..,.i.
1,.. ,,...'""
~~
SUb bt..Canc.el.w-_cu,1i:(l)'.V• l c.tndtl" -.e Sy,t. .. Cb'Kl, e,,v.i."'
.
Realice una carga de datos en un vector para grabar el D1'"1 y no1nbre de una
05 persona. Dibuje dos etiquetas ( Lab el) y dos cajas de texto para asignarles
las siguientes propiedades: a Lab ell, lb lDN I (en Name) y DNI
(en Text); aLab el2, lblNon1bre (en Name) y Nombre (en Text); a
TextBoxl , txtDNI (e.o Name); y aTextBox2 , txtNon1bre (e.o Name ).
' _ :-ia;i11..
_,_ - - •f -•---
=:.:::i
..i.:::, ·=
•,;-=-~ ---- -·-
...
· -
·-
~-
~-- -
-
__ ....,.. ¡¡¡
.·--
~-
m-
.·--
·-
-·- --
o -_ _
a,,
. .... -............
,, --·
-
,......
-~-
\.
·-
,_
·- ...... -•t•
...-_
··-- -~---~-
--
-..--
...
-
•
• Ingrese al código del proyecto y en la zona de Declaracio11es

O6 cree un vector de cuatro espacios, tipo cadena de texto.
--..
~ W -"'"'°~C.llol'"1~1 • - ,.,. 'f•-·
~ -~.i...-. ,1 ...... 6(_""-" ,
, "fN,I • &o i ,-1
""'""ª--
..-1,.._,. M k-C-.d....,JUó <.,...l ..... .U ~ ". . , .,...1 1 .. trl j
Para corroborar que el usuario cargue todos los datos en los controles
TextBox, debe realizar algunos controles de acceso :
• Deshabilite la caja de texto txtNombre y el botón btnAceptar .

• Cuando ingrese datos en txtDNI, se habilitará txtNombre .
• Cuando ingrese datos en txtNombre, se habilitará btnAceptar.
Veamos cómo sería el código. Seleccione en tiempo de diseño el botón

txtNombre en su propiedad Enabled igual a False (el control estará inhabilitado).
Luego seleccione el btnAceptar y proceda a realizar el punto anterior.
. --
, ,_....,
. --
_ __
....... ..
•4•
- --- ··-
--'".--
- ... --
•
-~·
--·-· ·-·
_____ ..
..,__WI,.......
,
-·-·
Figura 8. Controles inhabilitados, como deben aparecer al ser ejecutada la aplicación.

U11a vez que hayamos corroborado la carga correcta de los usuarios,

haremos doble clic con el botón izquierdo del 1nouse sobre txtDNI para
acceder al evento TextChanged . Para controlar el acceso de datos a la
caja de texto, podemos ingresar en el evento el siguiente código:
If txtDNI.Text <> Nothing Then

txtNombre.Enabled = True
End If
Al ejecutar la aplicación e intentar cargar datos en DNI notaremos

que, cuando borra1nos la información dentro de la caja txtDNI ,
txtNombre quedará habilitado. Para solucionar este problema, solo
debetnos agregar un si no (else) en la estructura condicional:
If txtDNI.Text <> Nothing Then

txtNombre.Enabled = True
Else
txtNombre.Enabled = False
End If
Cuando utilicemos un proyecto de Windows Form en el IDE de Visual Stu-

dio, se introducirá, por defecto, una interfaz FORMl. Esta interfaz FOR..l\•I es
referenciada en diferentes textos como Forma , Ventana o Formulario . El
principal obj etivo con el que cumple es contener o agrupar controles para el
uso de aplicaciones.

Si todavía quedara algu11a parte que se necesita codificar, ingresare-

mos u11 dato en txtNombre y habilitaremos el botón btnAceptar . De esta
forma, el código fmal sería:
If txtNombre.Text <> Nothing Then

btnAceptar.Enabled = True
Else
btnAceptar.Enabled = False
End If
Hasta aquí hemos logrado controlar el ingreso de datos sobre el form.

Ahora necesitaremos desplazarnos por los distintos espacios del vector que
hemos creado. El código será el que se ha desarrollado en el capítulo de matri-
ces. En la sección de declaraciones de variables vamos a escribir lo siguiente:
Dim indice As Integer = O
Y en btnAceptar_Click ingresaretnos este código:
vecPersona(O) = txtDNI.Text & " - " & txtNombre.Text

indice = indice + 1
l\il essageBox.Sho,v(vecPersona(indice))
Con la propiedad Enabled podemos habilitar o deshabilitar controles en tiempo de ej ecu-

ción. El uso de esta propiedad nos permite deshabilitar un control para restringir su uso.
Por ej emplo, puede deshabilitarse un botón para evitar que el usuario haga clic sobre él.

De esta forma, vamos a garantizar que se carguen todos los espacios

del vector. Es importante controlar la cantidad de datos ingresados, de
lo contrario, aparecerá el siguiente error: "El índice está fuera de los
límites del arreglo". Para que esto no suceda, debemos contar la cantidad
de veces que se cargaron datos en el vector y, tma vez que se completen
todos, detener la aplicación e informar al usuario que ya no puede gra-
bar más información. Por ejemplo:
If indice <= 3 Then

'Cargar datos en un Vector
vecPe.rsona(indice) = txtDNI.Text & " - " & txtNombre.Text
l\ilessageBox.Sho,v(vecPersona(indice))
'Lilnpiar los controles
txtDNI.Text = ""
txtDNI.FocusO
txtNombre.Text = ""
indice = indice + 1
Else
l\ilessageBox.Sho,v("''ector Completo")
txtDNI.Text = ""
txtDNI.Enabled = False
txtNombre.Text = ""
End If
También hay que tener en cuenta que, al cargar un dato , todos los datos
quedarán cargados en el form. Por eso, es bueno limpiar la interfaz cada
vez que se ingrese al evento click del botón.

PROGRAt\ 1ACION DESDE CERO t!J.i 3;fi 13 1
Ahora bien, si nos preguntamos cómo podemos mostrar la información,

veremos que hay varias maneras de hacerlo. Por ahora, lo haremos agregan-
do una caj a de texto y asignándole a TextBox3 las siguientes propiedades:
(Name)=txlli-1ostrar y :rv1u!tiline=T1ue . La propiedad multiline nos permitirá ampliar
el tamaño de la caj a de texto en horizontal. Luego, para mostrar la informa-
ción del vector, ingresamos el siguiente código :
txtl\ilostrar.Text = txtl\lostrar.Text & " - "

& vecPersona(indice) & Chr(13) & Chr(lO)
De esta forma, hemos conocido los controles más usuales : TextBox (caj a de
texto) y Label (etiqueta). Además, aprendimos las propiedades para habilitar
controles, cómo mostrar la información de un vector en un control y de qué
manera utilizar los botones de comando jtmto a propiedades del formulario.
Hemos aprendido cómo se utiliza el lenguaje de programación Visual Basic p ara la creación
de proyectos y cómo se aplican las variables en el código fuente. Luego vimos cómo aplicar
matrices y comparamos la sinta,"'(is del lenguaje con pseudocódigo. También tuvimos una
introducción b ásica a tres controles: T extBox, Lab el y Button, que utilizamos en conjunto con
algunos operadores y estructuras de datos, para lograr la confección de algoritmos.

Actividades
1 ¿Cómo se realiza la asignación de valores a las variables en Visual Basic?
2 ¿Cuál es la fotma de identificar controles en el código fuente?
3 ¿Cómo es la sintaxis para declarar una variable booleana?
4 ¿Cómo es la sintaxis para declarar un vector en Visual Basic?
5 ¿Es co11'ecto afumar que en Visual Basic se declara una esttuctura de dato
como vector al utilizar el siguiente código: = Dim vector(2,2) As Integer?


/ / / / / / / / / / / / / //,
Primer proyecto
enC++
A continuación, abordaremos el desarrollo de código fuente
que tiene el reconocido lenguaje C++. Conoceremos un IDE
gratuito para aplicar los conceptos adquiridos anteriormente,
y realizare1nos algunos desarrollos .
• !DE SharpDevelop.................... 134 Cío (entrada estáodar) .............. 164
• Introducción a C++ .................. 136 • Estructuras de programación ... 166

Espacio de oombres .................. 137 Estructura condicional .............. 166
Conceptos básicos del código .... 140 Estructura selectiva.................. 168
Estructuras repetitivas .............. 169
• Primera aplicación en C++ ...... 14 1 Ejercitación .............................. 173
Tipos de datos en C++ .............. 143 Saltos de dedaraciooes ............. 175
Declaración de variables ........... 144 Datos estructurados .................. 178
Inicialización de variables ......... 146
Operadores ............................... 150 • Resumen................................... 183
• Interactuar con el usuario ....... 16 1 • Actividades ............................... 184

Cout (salida estáodar) ............... 161
134 6. PRl!\ 1ER PROYECTO EN C++
IDE SharpDevelop
Como vimos antes, el IDE (entorno de desarrollo integrado) nos penniti-
rá utilizar diferentes herramientas que faciliten el manejo de tmo o varios
lenguajes de programación. SharpDe,,elop C#Develop) es un entorno
gratuito que puede utilizar los frame.\.vorks de Java, :tvlicrosoft y otros,
y que pennite aplicar múltiples lenguajes de programación.
#Develop es un IDE libre para C#, \TB.NET, Boo y proyectos en Microsoft.
,~~v.icsharpcode.net
NET. Es de código abierto y se puede descargar desde
(la versión de estas imágenes es SharpDe,,elop 4.2 ).
...
,_.ffll.,_
,.. ...,..._...•• ,, 1'n
,.. ~ .......
•. X Nfl,,,,,• Wtflt
iC#CC
• • o..
·• ·
· •
t
)t
.,......... ~·-·"""'"•»..,:Cl•,......
... ........ ....._
~ - . . - a , M .... 19"
9,~,...~~
.......,,., .,
ao(UIK(lat - - ~
.,_ de WON J. w w l i ~
Nt.-,.-.., •
HcrfflMC MediflctdO ~-
~
•
Jl.'f?,'!)11
Jl.W/lOll
mlluro!D hf6.·»u
e:,.......-~ O.~~----
(;.JJMn,c:..adlori ui~'".tan•~•~f
C..J.lsert,JtautOe,c,.-c.,~'",.a:s~,r,
IEllldl •UIJO'll C: ..._..I< ...... °"'"""""''~it..J'ftb.,,,.. .....
- ...
·••
Figura l. Interfaz gráfica del IDE, donde podemos apreciar

algunas similitudes con el que utilizamos en Visual Studio.
Al instalar la aplicación, por defecto estará en inglés; podemos configurarla

en español: para hacerlo, debemos ir al menú TOOLS/OPTIONS y seleccionar
Spanish . A la hora de iniciar un desarrollo dentro de SharpDevelop, podemos
crear diferentes tipos de arcbi,,os , como clases, archivos vacíos, interfaces,
templates, etcétera. La creación de soluciones contiene uno o varios proyec-
tos, como utilizábamos en Visual Studio. En el caso de SharpDevelop, se crea
primero una solución y, luego, pueden agregarse los proyectos necesarios.

GV. CARACTERÍSTICAS GENERALES DEL IDE t ~
----
- ~ ,, ,u .... . ,. . ~
..
::i--
__
--
... ¡JJ •
...,._-
1 ~..,._~
·-
- .,,;
__ ....
,,.\-tlftt•
JI .....
.
'•
· .•- • i.t • •·
_..,.
• ... , -
,-•u
u.
O o ,,-•
,,.
Jl.-1' O _, , _... ..._M ........ '-"" l ... 11,
..,
.. u - 1
- •
•
-~ , ••,,, ·••4"4 ..........,,.

1- o....-
-· ----ff------1-am
....
01 CUADRO DE PROYECTOS Y HERRAlvilEl\l'fAS: aquí están los archi vos

i nvolucrados en el proyecto y aquellos controles que pode1n os i nsertar
dependiendo del tipo de progra1n a que este1n os diseñando.
BOTOl\lES DE DEPURACIÓN : incluyen el botón Inicio, que compila

02 el proyecto; Pausa, que detiene la compilación o ejecución del programa;
yDete11er el progra1na , que lo descarga de 1n e1n oria.
03 ENTORNO DE CÓDIGO : en caso de ser proyectos con diseño, se incluye el entorno

de desarrollo.
04 CUADRO DE CLASES. PROPIEDADES. COl\l'fEl\lEDOR O AYUDA : abarca las

clases involucradas en el proyecto, las propiedades que tienen los distintos
elementos que vayamos utilizando y un buscador de elementos de ayuda.
O5 CUADRO DE ERRORES,TAREASY SALIDA DE DATOS : errores que pueden

encontrarse en las sentencias del código fuente. Aquí también podemos configurar
el seguiln iento de tareas y ver las salidas de datos por 1n edio del IDE.

Cada uno de estos cuadros puede configurarse como cualquier IDE,

y es posible ubicarlos en diferentes lugares. La imagen que muestra la
guía visual corresponde a la manera en que veremos el entorno por defecto.
Es importante tener en cuenta que existen otros entornos grahlitos, como
l\ilono De,,elop Chttp://111onodevelop.co111).
Introducción a C++
Como vimos en capíhllos anteriores, pode1nos utilizar un lenguaje
de programación 1nuy didáctico y que nos permita dibujar el diseño de
las interfaces que se comu11ican con el usuario. En este caso, nos en-
contramos con un lenguaje más duro, que no posee un entorno gráfico,
sino que se caracteriza por tener u11 enton10 de texto o CLI CConiniand
Line Interface , o interfaz de comando de línea).
m' AdrninitttJdor: C:\Window$\sy$tem32\cmd.exe

M.il:t•o:;oft \li1ulo11 :; [Ucr:.ion Íl.1.'/601 J
Col1y1•i9ht (e:) 2HH9 Micro'"oft C:,0•1101•,Hion. Hr. ,-r.rvado:: todoo. lo o. rlr.rr.choo..
C:,use1·s,jcasale>dir
El volunen de la unidad C no tiene etiql1eta.
El 11~ncro de ~cric del vol11nc11 e:;: SA94 ·D390
2l1/U'//?.H12 HH:11 d . n. <DIH>

2~/0'//2012 08:11 ., . n . <DIR>
2"//lM/201'1 01,30 l). n. 1 . 07.4 .1·1111
'.h/Wi'/2012 09,?.4 P. n . <DIR> ?.004
09/0]/2011 10,09 ~1. n. <DIR> 2005
H9/~B/2011 1H:111 i\. n. <DIR> ?.00b
0?/05/2010 11,23 ~,. n. <DIR> 2007
lb/12/20111 11 : 33 ". n. <DIR> 20118
Ob/09/;rnt 1 11, ?.1 rt . n. <DIR> ?.009
".í,/06/2012 (,M: 11 P. n. <DIR> 2H1H
-'1:J/W,/2012 1 l : '11 ,1. n. (DIR> 21-111
.'//Hl,/2"112 lfl:!,h 11. n. <DIR> 2"112
lt /HS/2011 011,7,1 ,1 • n . <DIR> nppD,,t ,,
2!->/01 /201 2 1-11 : :19 }l. n. (DIR> App I icil.t ion o,,ta
13/10/2011 12: 18 . n. 128.1S8 hooknrt1•k:; - 13 - 10 11.htnl
Figura 2. Interfaz de comando de línea. En este caso,

entramos en la aplicación de consola de \.Vindo\.vs.
Antes de iniciar un programa, repasaremos algunas cuestiones importantes

para tener en cuenta al utilizar C++. En principio, debemos conocer el espacio
de nombres que nos permite usar sentencias de entrada y salida de datos.

Por otro lado, explicaremos lo fLmdamental que debemos escribir (que

es main) y veremos que C++ está orientado a tma programación en eventos,
aunque podamos adaptarlo a diferentes metodologías de desarrollo.
Espacio de nombres
La instn1cción using namespace especifica que los 1niembros de un
namespace serán utilizados frecuente1nente en un programa por desa-
rrollar. Esto permite al desarrollador tener acceso a todos los miembros
del namespace y escribir instrucciones 1nás concisas. Por eje1nplo, vea-
mos a qué hacen referencia los espacios de nombre que utilizamos en
C++ por defecto y cómo sería si no los usáramos.
#incl ude <iostream>

int main O
{
std::cout <<"hola mundo"<<std::endl;
return O;
}
//Sin utilizar el espacio de nombre std
#include <iostream>
using name.space std;
int main O
{
//al usar el namespace ya no hace falta escribir
std::cout <<"hola mundo"<<endl;
return O;
}
//Utilizando el espacio de nombre std
Veremos qué quiere decir cada sintaxis del código que escribimos ante-
riormente. La idea principal es conocer cómo se escribiría el código en C++
utilizando espacios de nombres que simplificarán la codificación.

138 6. PRll\1ER PROYECTO EN C++
Podemos codificar nuestros propios espacios de nombres. Por ejemplo,

en C++ crearemos tmo llamado calcular y le agregaremos variables varX,
varY y varF . Veamos el código :
namespace calcular {
int varX, varY;
float varF(int a) {
// ...
}
}
Con este espacio de nombre, para utilizar la variable varX que está en el
namespace calcular , el desarrollador deberá codificar lo siguiente:
calcular::varX = calcular::varF(5);
Si utilizáramos de esta forma la sintaxis, deberíamos escribir reiteradas

veces la palabra calcular. En cambio, si usamos el espacio de nombre,
quedaría de la siguiente forma:
using namespace calcular;

varX = varF(5);
Se trata de un !DE diseñado principalmente para C# y otros lenguaj es .l\1ET, que permite
a los desarrolladores escribir aplicaciones de escritorio y web ASP .N""ET en Linux, \Vindows
y Macos. Facilita la existencia de una base de código único para todas las plataformas.

Veamos cómo desarrollamos la codificación si usamos dos espacios

de 1101nbres:
// namespaces
#include <iostream>
using namespace std;
namespace prime.ro
{
int var = 5;
}
namespace segundo
{
double var = 3.1416;
}
int main O {
cout << primero ::var << endl;
cout << segundo::var << endl;
return O;
}
Como podemos observar, cada espacio de nombre es propietario de su

variable , y en la codificación podemos utilizarlas como queramos.
En C++ hay código estándar en el namespace std. Podemos utilizarlo nombrándolo en el

encabezado del proyecto como using namespace std , o bien podemos utilizar en nuestro
código constantemente std:: y realizar las llamadas a las fi.mciones que necesitemos.
Todas las librerías estándares de C++ están incorporadas en std .

Conceptos básicos del código

Es recomendable repasar la tabla 1, donde encontraremos la estn1chrra
básica que podemos realizar en el código de C++:
ESTRUCTURA BÁSICA DE C++
T TIPO T DESCRIPCIÓN
// Representa en C ++ los comentarios que podemos agregar en

el lenguaje de programación, que no tienen ningún efecto sobre
el comportamiento del programa.
#iod ude Las lineas que comienzan con wi nwneral (#) son direc.tivas p ara
el preprocesador . En este e.aso, la direc.tiva # inc lude le indica
al preprocesador incluir el archivo iostream estándar.
l ostream Este archivo especifico incluye las declaraciones de la norma básica

de la biblioteca de entrada-salida en C ++, y se ha incluido debido
a que su funcionalidad será utilizada más adelante en el programa.
us ing namespace std; Todos los elementos básicos de las bib lioteca s en C ++ se declaran
dentro de lo que se llama wi espacio de nombres. Por eso, si
queremos acceder a su funcionalidad, declaramos con esta expresión
para poder utilizarla. Esta linea es muy frecuente en C ++ p ara que
los programas utilicen las bib lioteca s estándares.
iot maio O Esta linea corresponde al comienzo de la definición de la función

princ ipal. Se trata de l punto po r e l cual to dos los programas e n
C ++ comienzan su ejecución, independientemente de su ubicación
dentro del código fuente.
Cout<<"l:saodo C++!"; Cout es la secuencia de salida estándar en C++. El significa do de toda

la declaración es insertar wia secuencia de caracteres. Cout se declara
en iostream, que es el estándar de archivos en el espacio de nombres;
debemos incluir esa referencia específica y declarar que vamos a utilizar
ese espacio de nombres a principio del código.

ESTRUCTURA BÁSICA DE C++ (CONTINUAOÓN)
. Este carácter se utiliza para marcar el final de la declaración

'
y debe incluirse al término de todas las declaraciones de expresión de
todos los programas en C ++.
Return O; La sentencia return hace que la función principal llegue a su fin,

y puede estar seguida por un código (el código de retorno devuelve
un valor cero). En el código de retorno de O para el main de la función
se interpreta que el programa funcionó como se esperaba, sin ningún
error durante su ejecución.
Tabla l. Estructura básica de C ++ que utilizaremos

en nuestros proyectos de programación.
Inmediatame nte después de main Oestá el cuerpo de la función principal

entre llaves {}, que es lo que hace la función cuando se ej ecuta. Ahora que
conocemos la estructura de la programación en C++, podemos reconocer las
diferentes sentencias y sectores importantes en el desarrollo del lenguaj e.
Primera aplicación en C++

Para crear nuestra primera aplicación en C++ para consola (CLI), vamos a
ej ecutar SharpDevelop. Desde el menú Archivo haremos clic en Nuevo y selec-
c ionare mos Solución. En el cuadro de diálogo Nuevo proyecto seleccionaremos
el lenguaj e de programación C++ y, en el cuadro contiguo, Aplicación de
consola. En Nombre e scribire mos p1yP1imera.Aplicacion .
A continuación, veremos una interfaz gráfica parecida a la de la figura 2.
Veamos un ej emplo en el siguiente código :
!*
* Creado por SharpDevelop.
*

142 r•:.1:1:fi 6. PRii\1ER PROYECTO EN C++
* Para cambiar esta plantilla use Herramientas 1

Opc.iones I Codificac.ión I Editar Encabezados Estándar
*!
using namespace System;
int main(array<Syste.m::String "> "args)
{
Console::\ VriteLine(L"Hello \ Vorld");
return O;
}
Para seguir en nuestro proyecto, debemos compilar este código presionan-

do F5 o hacer clic sobre el botón Inicio de depw·ación ; veremos como resultado
una ventana de consola que muestra el mensaj e "Hello World" y se cierra.
Luego modificaremos este código, agregando el espacio de nombre std, para
poder ingresar y mostrar datos, y también la librería iostream .

#include <iostream>
Vamos a utilizar las estructuras básica s que vimos antes para leer el men-
saj e en pantalla, y reemplazaremos el código que hay en main por el siguiente:
// l\1ostramos por salida estándar un mensaje personalizado

cout << "l\1i primera aplicación en C++!";
return O;
Para poder apreciar la aplicación, agregaremos u11a palabra reservada

de C++, getcharO, de modo que, al presionar ENTER, cerrará la ventana
de consola. El código es: getcharO;.

Tipos de datos en C++

Continuaremos con nuestra primera aplicación de C++, pero esta vez
agregaremos la declaración de variables y muestra de información en la venta-
na, y observaremos qué tipos de datos podemos utilizar.
Como ya hemos visto, al crear una variable , disponemos de un espacio de
memoria donde podemos almacenar cierta información, pero debemos indicar
qué tipo de información será. Por ejemplo, almacenar una letra, un número
entero o un booleano. Veamos cuáles son los tipos de datos fundamentales en
C++ y el rango de valores que se pueden representar con ca da uno de ellos.
TIPOS DE DATOS EN C++
T NOl\IBRE T DESCRIPCIÓN T TAl\lAÑO T RANGO
Char Carácter 1 byte signed - 128 to 127

o entero pequeño. unsigned O to 255
Sbort l ot Entero corto. 2 bvtes

, signed -32768 to 32767
wisigned O to 65535
Iot Entero. 4 bytes signed -21 47483648

to 21 47483647
unsigned O to 4294967295
Long iot Entero largo. 4 bytes signed -2 147483648 to

21 47483647
unsigned: O to 4294967295
Bool Boolean. 1 byte true o false

Puede adquirir uno
de dos valores:
True o False.
Float Punto flotante. 4 bvtes

, +!- 3.4e +!- 38 (-7 dígitos)
Dooblé Doble precisión 8 bytes +!- 1.7e +!- 308 (-15 digitos)
de punto flotante.

144 6. PRl!\1ER PROYECTO EN C++
TIPOS DE DATOS EN C++ (CONTINUAOÓN)
Long doublé Doble largo 8 bvtes

, +!- l. 7e +!- 308 (- 15 dígitos)
de precisión de
pwito flotante.
wchar t Carácter amplio . 2 o 4 bytes 1 carácter amplio
Tabla 2. Tipos de datos en C++ que podemos utilizar en el desruTollo de aplicaciones.
Los valores de las columnas y Rango dependerán del sistema

Tamaño
donde se compile el programa, y son los que se encuentran en la mayoría
de los sistemas de 32 bits. A continuación, desarrollaremos la declaración
de variables necesaria para aplicar a nuestro primer proyecto de C++.
Declaración de variables
Para utilizar una variable en C++, primero debemos declarar qué tipo de
datos deseamos y, luego, sus respectivos nombres. En la sintaxis para decla-
rar una nueva variable se escribe la especificación del tipo de datos ( int, bool,
float , etc.), seguido de un identificador de variable válido. Por ej emplo :
int varX;
float varP;
char c aracter;
char cadena(lO);
También podemos realizar, como en Visual Basic, la declaración conse-

cutiva de variables:
int varX, varY, varZ;

Veremos que en C++ podemos asignar o no signos positivos o negativos

en la declaración de variables. Los tipos de datos char, short, long e int pueden
ser con o sin signo (positivo o negativo) en función del rango de números
necesarios para ser representados. Las declaraciones con signo pueden repre-
sentar los valores tanto positivos como negativos, mientras que los tipos sin
signo solo representan valores positivos hasta el cero. Por ej emplo :
unsigned short int varNumeroDe, 7eces;

signed int varl\il iSaldo;
En caso de que declaremos una variable sin especificar signed o unsigned,

C++ por defecto especifica rá la primera. Por lo tanto, en el caso de la variable
varMiSaldo, podríamos haberlo hecho de la siguiente forma:
int variv1iSaldo;
Continuando con nuestra primera aplicación en C++, utilizaremos algunas

variables para realizar una tarea matemática y mostrarlo en pantalla:

#include <iostream>
int mainO
{
//Declaramos variables :
int varA, varB;
int resultado;
//Instrucciones:
varA = 7;
varB = 2;
varA = varA + 1;
re.sultado = varA - varB;
//Mostramos el resultado :
cout << re.sultado;

146 6. PRii\1ER PROYECTO EN C++
//Terminamos el programa:
getcharQ;
return O;
{
De esta forma, veremos el resultado en una ventana de consola. Al igual

que en Visual Basic, las variables tienen un ámbito donde pueden operar:
serán globales o locales dependiendo del lugar en donde se declaren.
Como vimos antes, las variables globales pueden llamarse desde cualquier
lugar del proyecto, mientras que las locales solo pueden llamarse cuando los
bloques de código estén comprendidos por llaves ( {}).
Inicialización de variables
Cuando declaremos variables locales y no asignemos un valor en el mo-
mento de crearlas, estas tendrán un valor indeterminado. Desde C++, vere-
mos dos maneras posibles de almacenar un valor concreto cuando las decla-
remos. La primera, conocida como inicialización c-like, se logra añadiendo un
signo igual ( =) seguido del valor que deseamos inicializar:
identificador de tipo de dato = valor inicial;
Por ejemplo, si queremos declarar una variable int inicializada con el valor
O en el momento que lo declaramos, podríamos escribir:
int varA = o·
'
La segunda posibilidad implica inicializar las variables como constructor

de inicialización y encerrar el valor inicial entre paréntesis :
Identificador de tipo de dato (valor inicial);

Por ejemplo :
int vara (O);
Aplicaremos estas formas de inicialización en el ejemplo anterior de nues-

tro primer proyecto, para así ahorramos tm par de líneas de código:

#include <iostream>
int mainO
{
//Declaramos variables :
int varA = 7;
int varB(2);
int rP~n ltarlo;
//Instrucciones :
varA = varA + 1;
resultado = varA - varB;
//Mostramos el resultado :
cout << resultado;
//Terminamos el programa:
getcharQ;
return O;
}
Para practicar en C++ lo que vimos en estos párrafos, vamos a codificar

tm nuevo ejemplo que muestre el tamaño en bytes de cada tipo de dato.
Repetiremos los mismos pasos que realizamos al crear nuestra primera
aplicación, pero en la opción Nombre , esta vez, colocaremos p1yTipoDeDatos .
A continuación, en el cuadro de código, realizaremos lo siguiente:


#include <iostream>
int mainO
{
//Sacamos el tamaño de cada tipo :
cout << "El tamaño del int es:\t\t" << sizeof(int) << " bytes.";
cout << "El tamaño del short es :\t" << sizeof(short) << " bytes.";
cout << "El tamaño del long es:\t" << sizeof(long) << " bytes.";
cout << "El tamaño del char es :\t\t" << sizeof(char) << " bytes.";
cout << "El tamaño del float es:\t\t" << sizeof(float) << " bytes.";
cout << "El tamaño del double es :\t" << sizeof(double) << " bytes.";
//Sacamos por salida estándar un mensaje :
cout << "Terminó el programa";
getcharQ;
return O;
}
Para ver el resl1ltado fmal, debemos compilar con F5 o haciendo clic

en Iniciar depw·ación .
Figura 3. Resultado del ej emplo que codificamos antes,

mostrando el espacio que ocupa cada tipo de dato.
Cabe destacar que existen ciertas palabras reservadas, como sizeoff, cout y
bytes , que provienen de las librerías base de C++. Más adelante veremos qué
uso darle a cada una de ellas. Además del uso de variables y la asignación de
su tipo de dato, también podemos declarar constantes si agregamos al pro-
yecto anterior las siguientes líneas de código, antes del getcharO:


#include <iostream>
#define FINAL 25
int mainO
{
// .. . Todas las instrucciones anteriores :
int y = O;
//Definimos el valor constante :
const float PI= 3.1416;
cout << "La constante PI contiene: "<< PI << endl;
//Sacamos por salida estándar un mensaj e :
cout << "Termino el programa : " <<FINAL<< endl;
getcharQ;
return O;
}
A la hora de declarar, existen dos posibilidades : una antes del main con la
palabra #define, y otra con la palabra const A continuación, vamos a trabajar
con mayor detenimiento en cada una de estas declaraciones.
Constantes literales
Son las constantes más frecuentes y se usan para expresar valores particu-
lares dentro del código fuente de un programa. Las hemos utilizado previa-
mente al dar valores a las variables o al expresar los mensajes que queríamos
mostrar en los programas. Por ej emplo, cuando escribimos :
varA = 3;
El 3 en esta instrucción de código fue una constante literal. Las constantes

literales pueden dividirse en números enteros, números de punto flotante,
caracteres, cadenas de texto y valores booleanos.

Constantes definidas
En este lenguaj e podemos declarar nombres de constantes con el coman-
do #define, sin tener que declararlas dentro de una función. Podemos utilizar-
las en el encabezado del programa y llamarlas desde cualquier proceso.
Su sintaxis es la siguiente :
#define valor del identificador
Por ej emplo :
#defin e PI 3.14159
#de.fine cabecera "Empresa";
Constantes declaradas
Al igual que vimos en Visual Basic, encontraremos que la sintaxis const
representa la declaración de constantes con un tipo específico, de la misma
manera en que lo haría con una variable :
const int varCantHoj as = 100;

const c.har varLetra = 'x';
Como vimos en capítulos anteriores, podemos tratar a las constantes

igual que a las variables normales, salvo por sus valores, que no pueden
ser modificados después de su defmición.
Operadores
Hasta el momento vimos cómo se utilizan los operadores en Visual Basic.
Ahora podremos practicarlos en C++, considerando su importante diferencia
en cuanto a codificación y manejo de librerías. A continuación, haremos un
recorrido por los distintos operadores que encontramos en C++ y veremos
ejemplos prácticos que nos permitirán conocer mejor su funcionamiento.

Operadores de asignación
El operador de asignación carga un dato a una variable. Si quisiéramos
establecer que la variable A contuviera el valor 3, su sentencia de código sería :
varA = 3;
La parte de la izquierda del operador de asignación ( =) se conoce como

el lvalue (valor de la izquierda), y la derecha, como el 1value (valor derecho).
El valor izquierdo tiene que ser una variable, mientras que el derecho puede
ser una constante, una variable, el resultado de una operación o cualquier
combinación de ellos. Debemos recordar que las asignaciones se realizan
de derecha a izquierda, y nunca al revés. Veamos el siguiente ej emplo :
int var..\, varB; / / var..\: , varB:

varA = 10; / / varA: 10, varB:
varB = 4; / / varA: 10, varB: 4
v arA = v arB; / / v arA: 4, v arB: 4
varB = 7 ; / / varA: 4, varB: 7
En el código, varA es igual a 4 y varB es igual a 7. Las variables no se vieron

afectadas por la modificación al final de varB, a pesar de que se declaró varA =
varB, es decir, debido a la regla de la asignación de derecha a izquierda.
Operadores aritméticos
En C++, la forma de aplicación de estos operadores no cambia. Los tipos
que podremos utilizar son: + (suma), . (resta), * (multiplicación), / (división)
y % (módulo). Antes de pasar a algunos ej emplos, veamos de qué se trata el
operador módulo. Cuando hablarnos de módulo nos referimos a la operación
que presenta el resultado de una división de dos valores. Por ej emplo :
int varA = 11 % 3 ·
'
Como resultado obtendremos el número 2, ya que 2 es el residuo de

la división de 11 por 3.

Operadores de asignación compuesta

Para modifica r el valor de una variable mediante la realización de una
operación, podemos utilizar operadores de asignación compuesta. La tabla
siguiente detalla ca da uno de ellos :
OPERADORES DE ASIGNACIÓN COMPUESTA
T EXPRESIÓN T ES [QUIVALINTE A
valor += incremento; valor = valor + incremento;
a-= ~-
-, a= a - 5;
a /= b· a = a / b·
' '
precio *= wúdad + 1; precio = precio* (wúdad + !);
Tabla 3. Operadores de asignación compuesta, propios del lenguaje de programación.
También podemos encontrarnos con más operadores, tales como : += -=

' '
*=, != , %= , >>=, <<= , &=, "= y ¡-. A continuación, veamos un modelo en código
en el cual debemos generar una aplicación de ej emplo y codificar lo siguiente :

#include <iostream>
int mainO
{
int varA, varB=3;
varA = varB;
varA+=2; //Equivale a=a+2
cout << varA;
getcharQ;
return O;
}

Operadores para aumentar o disminuir un valor

En varios lenguajes de programación encontraremos signos o conjuntos
de signos que nos serán útiles para realizar acciones determinadas. Algunas
de las expresiones, como la de incremento ( ++) y el operador de disminución
(--), nos permiten aumentar o disminuir en tmo el valor almacenado de tma
variable. Sus equivalentes serían: a += 1 y b -= 1.
Por ej emplo, podemos realizar la acción de incrementar un valor en 1
mediante cualquiera de estas tres opciones equivalentes : e++;, c+=l; y c=c +l;.
Operadores relacionales y de igualdad

Como vimos antes, para hacer una comparación entre dos expresiones
podemos utilizar operadores relacionales o de igualdad.
El resultado de una operación relacional es un valor booleano,
que solo puede ser verdadero o falso.
Quizá necesitemos comparar dos expresiones, por ejemplo, para
saber si son iguales o si una es mayor que otra. En ese caso utilizaremos
alguno de los siguientes operadores: = (igual a), != (no es igual a),
> (mayor que), < (menor que),>= (mayor o igual a), <= (menor o igual a).
Ej emplos de código :
(4=7) / /Se evalúa como falso.

(8>1) / /Se evalúa como verdadera.
(9!=2) / /Se evalúa como verdadera.
(7>=7) / /Se evalúa como verdadera.
(6<6) / /Se evalúa como falsa.
Desde luego, en vez de utilizar valores constantes, podemos recurrir

a expresiones, variables u otro tipo de operaciones que desee1nos com-
parar. Por ejemplo:

A=2·
'
B=3·
'
C=6·
'
A= 5)//Se evalúa como falso ya que no es igual a 5.
A*B>=C)//Se evalúa como ci erto, ya que (2* 3> = 6) es verdadera.
4+B>A*C)//Se evalúa como falso, ya que (3 +4> 2 * 6) es falsa.
((B=2)= A)//Se evalúa como verdadera.
Operadores lógicos
Como vimos, el operador lógico nos devuelve dos posibles resultados :
verdadero o falso. Comenzare1nos con uno de ellos, el operador !
(signo de admiración), que nos devolverá el valor booleano opuesto
a la evaluación de su operando.
Por ejemplo:
! (5= 5)//Se evalúa como falso porque la expresión

en su derecho (5=5) es cierta.
! (6<=4)//Se evalúa como verdadera, porque (6 <= 4) sería falsa.
! true//Se evalúa como falso.
! false//Se evalúa como verdadera.
Otros operadores lógicos que podemos utilizar en el lenguaje son

&& CAND) y 11 (OR) , que se utilizan en la evaluación de dos expresiones
para obtener un resultado relacional ú11ico. El operador && se corres-
ponde con la operación lógica booleana ANTI, que da como resultado
true si a1nbos operandos son verdaderos, y false en caso contrario.
En el listado que sigue, vemos una muestra de resultados para
el operador &&, que evalúa la expresión A, B && : operador && .

A B A&&B
true true true
true false false
false true false
false false false
El operador II se corresponde con la operación lógica OR booleana y da

como resl1ltado verdadero si cualquiera de SllS dos operandos es cierto,
y falso solo cuando ambos operandos también lo son. En el listado que sigue,
podemos ver los resultados posibles de A 11 B : operador 11 .
A B
true true true
true false true
false true true
false false false
El operador = (signo igual) no es equivalente al operador = (doble signo igual). Mien-

tras que el primero es un operador de asignación (establece el valor en su derecha a
la variable en su izquierda), el segundo es un operador de igualdad, que compara si
ambas expresiones de sus extremos son iguales entre sí.

Operadores condicionales
Evalúan tma expresión y devt1elven tm valor si esta es verdadera,
y otro distinto si es falsa. Su formato es:
Condición ? resultado 1: resultado2
Si la condición es cierta, la expresión devolverá resultado l ; de lo contrario,

resultado2 .
1 = 3 ? 2: 4 //D evuelve 4, 1 no es igual a 3.

7 = 5 + 2 ? 4: 3 //Devuelve 4, 7 es igual a 5+2.
4>2? a: b //Devuelve el valor de a, 4 es mayor que 2.
a>b?a:b //Devuelve el que sea mayor, a o b.
Por ejemplo, en C++ podemos escribir lo siguiente :
#include <iostream>
int main O
{
int varA,varB,varC;
varA=2·
'
varB=7·
'
vare = (varA>varB) ? varA : varB;
cout << varC;
getcharQ;
return O;
}

Operador coma (,)

Se utiliza para separar dos o más expresiones que se incluyen en un mis-
mo lugar. Cuando el conjunto de expresiones tiene que ser evaluado por un
valor, solo se considerará la expresión ubicada más a la derecha. Por ejemplo :
varA = (varB=3, varB+2);
Primero se asigna el valor 3 a varB, y luego varB+2 a la variable varA .

Finalmente, la variable varA contendría el valor 5, y varB, el valor 3.
Operadores bitwise o bit a bit

Se aplican en lenguajes de bajo nivel, ya que trabajan a nivel de bit.
:rviodifican las variables teniendo en cuenta los patrones de bits que repre-
sentan los valores almacenados.
OPERADORES TIPO BITWISE
T OPERADOR T EQUIVALINTE A T DESCRIPOÓN
& AND Bitwise A."\/D
OR Bitwise Inclusive O R
A
XOR Bitwise Exclusive OR
NOT Unary complement (bit inversion)
<< SHL Shift Left - mover a la izquierda
>> SHR Shift Right - mover a la derecha
Tabla 4. Operadores bitwise de los que disponemos

para activar o desactivar bits dentro de un entero.

158 6. PRI1\1ER PROYECTO EN C++
Una operación bit a bit o bit\vise opera sobre números binarios a nivel
de sus bits individuales. Es una acción prünitiva rápida, soportada di-
rectamente por los procesadores.
Operador de conversión explícita

Así como en otros lenguaj es contamos con funciones que nos permiten
convertir algunas variables a otros tipos de datos, en C++ utilizaremos los
paréntesis ( O) que encierran una expresión, por ejemplo:
int varA;
float varF = 3,14;
varA = (int) varF;
Con este código de ej emplo convertimos el número float 3 , 14 a un valor int

que sería 3. Los decimales se pierden, ya que el operador entre paréntesis es
entero y comprende números de esa índole. Otra forma de hacer lo mismo en
C++ es utilizar la notación funcional que precede a la expresión que se con-
vierte por el tipo, y encierra entre paréntesis a dicha expresión, por ej emplo:
varA = int (varF);
Operador sizeof
Ya hemos utilizado este operador en código de ej emplos anteriores. Acep-
ta un parámetro ( que puede ser un tipo o una misma variable) y devuelve el
tamaño en bytes de ese tipo u obj eto:
varA = sizeof(char);
En el ej emplo, Char es un tipo largo de un byte, por lo que asignamos el

valor 1 a varA, y la información que devolverá sizeof es tma constante que se

determinará antes de la ej ecución del programa. Anteriormente, lo aplicamos

a un ej emplo para establecer el tamaño de los tipos de datos :
cout << "El tamaño del int es:\t\t" << sizeof(int) << " bytes.";
cout << "El tamaño del short es:\t" << sizeof(short) << " bytes.";
Precedencia de los operadores

Si debemos codificar expresiones extensas, es decir, que contengan mu-
chos operadores, como vimos antes, podemos dudar acerca de qué sector de
nuestra sintaxis tiene que evaluarse primero. En la tabla que sigue se hace un
repaso de todos los operadores vistos.
ORDEN DE PRIORIDAD DE OPERADORES
TNIVEL T OPERADOR T DESCRIPCIÓN TAGRUPACIÓN
1 Alcance / ámbito Left-to-right
2 O[ ) . -> - -- dynanúc_cast static_cast Sufijo Left-to-right

reinterpret_c.ast const_c.ast typeid
3 ++ -- - ! sizeof new delete Unary (prefijo) Right-to-left
*& Indirecto y de
referencia (punteros)
+- Operador unary
4 (type) Convertir en tipo Right-to-left
5 .• ->* Puntero a member Left-to-right
6 *! % ]\,fultiplic.ación Left-to-right

ORDEN DE PRIORIDAD DE OPERADORES (CONTINUAOÓN)
7 +- Agregar Left-to-right
8 <<>> C ambiar Left-to -right
9 < > <= >= Relacionar Left-to-right
10 == I= Igualdad Left-to -right
11 & binvise AJ\'D Left-to-right
(\
12 bin,~se XOR Left-to -right
13 binviseOR Left-to-right
14 && logical AJ\'D Left-to -right
15 11 logical OR Left-to-right
16 - *-- ./-- %= +-- --- ...,...,_

, , - <<- - & -- Asignación Right-to -left
A= I=
17 Coma Left-to-right
Tabla 5. Aquí podemos observar los distintos tipos de operadores

y el orden en el que C++ prioriza cada uno de ellos.
La agrupación defme el orden de precedencia en el que los operadores

deben evaluarse, en caso de que, en tma misma expresión, haya varios
operadores del mismo nivel. Todos estos niveles de precedencia pueden
manipularse o hacerse más legibles, eliminando posibles ambigüedades
en el uso de los paréntesis. Hasta aquí hemos visto las declaraciones de
variables y constantes, y el uso de operadores, lo cual nos brindará las
herramientas necesarias para empezar a desarrollar aplicaciones de dis-
tinta envergadura. A continuación, veremos las estructuras que podemos
utilizar para darles sustento a nuestros algoritmos en C++.

PROGRAt\ 1ACION DESDE CERO 16 1
Interactuar con el usuario

Hasta este punto, el código de ejemplo que hemos visto no realiza
ninguna interacción con el usuario, salvo presionar la tecla ENTER _
Por eso, para enriquecer nuestras aplicaciones, debemos conocer cuáles
son los métodos de entrada y salida básicos que ofrecen las librerías de
C++. Estas librerías están incluidas en el archivo iostream , que declara-
mos en el encabezado de los desarrollos.
Cout (salida estándar)

La palabra reservada cout es utilizada por C++ para definir que deseamos
dar salida de información por pantalla. Se utiliza conjuntamente con el ope-
rador de inserción, que se escribe como << (dos signos "menor que").
#inc.Jude <iostream>
int main O
{
int varA=O;
cout << "L-a se.nte.nc1a
. d esa l"
1d a e.s.· " ,·
//1\il uestra la sentencia de salida, en la pantalla
cout << 120; //1\lue.stra el núme.ro 120 en la pantalla
cout << varA; //1\il uestra el contenido de varA en la pantalla;
getcharQ;
return O;
}
Como podemos ver y probar en código, la sintaxis << nos da la posibi-

lidad de introducir datos. Es importante tener cuidado cuando utilizamos
cadenas de caracteres, es decir, un texto que deseemos mostrar en pantalla,
porque debemos encerrar ese texto entre comillas ( "" ). Por ej emplo :

cout << "Prueba";

cout << Prueba;
En la primera sentencia se mostrará en pantalla la palabra Prueba , y en la

segunda se reconocerá Prueba como variable y se mostrará su contenido. Para
los textos debemos aplicar comillas dobles; ahora veremos que podemos utili-
zar el operador de inserción más de una vez en una sola sentencia :
cout <<"Estoy"<<"juntando"<<"varias cadenas";
Pero el procedimiento de conca tenar no nos será útil si deseamos utilizar

variables y textos. Veamos el ej emplo :
int varA ltnra=l RO;

int varPeso=90;
cout << "La altura es: " << varAltura << " . El peso es: " << varPeso;
Así, obtendríamos los siguientes resultados : "La altura es : 180" y "El peso
es : 90". Debemos tener en cuenta que cout no agrega un salto de línea des-
pués de su salida, a menos que lo indiquemos expresamente :
Este operador solo tiene un operando. Esto quiere decir que puede contener un objeto, varia-
ble u operando especifico del lenguaje. Por ejemplo: SizeofD / N ewO / DeleteO / (type)/ ++ /
-- / - / ! / + / - . Otro ejemplo Sizeof(short) / (int) variable / variable++ / --variable .

cout << "Esta es una sentencia." ;

cout << "Esta es otra frase." ;
Si deseamos realizar el salto de línea por medio de código, debemos tener

en cuenta que en C++ un carácter de nueva línea se puede especificar con
cout << "Primera sentencia ." ;

cout << "Segunda sentencia Tercera sentencia.";
El resultado será u11a oración por renglón. Para ver 1nejor este ejem-
plo, debemos codificarlo en C++. En este sistema también podemos en-
contrar la palabra reservada endl, que permite realizar el salto de línea.
Con el ejemplo anterior, el código sería:
cout << "Primera sentencia" << endl;

cout << "Segunda sentencia " << endl;
cout << "Tercera sentencia " << endl;
Figura 4. Resultado de todos los ejemplos que fuimos realizando en C++.
Hemos visto las opciones para mostrar información en pantalla desde C++;
ahora continuaremos con el ingreso de datos por medio de una aplicación.

Cin (entrada estándar)

El ingreso de datos estándares se da por medio del teclado, y la norma
para realizar su expresión es la palabra reservada cin y los símbolos >>
A continuación, veamos un ej emplo :
int edad;
cin >> edad;
Estas sentencias le solicitarán al usuario que ingrese el dato de edad, espe-

rará que lo haga y lo cargará en la variable. Cin tomará los valores ingresados
por teclado una vez que el usuario presione la tecla EN'TER
Recordando los tipos de variables, si utilizamos un tipo entero con cin, soli-
citando en este caso un número, lo que debemos ingresar es un valor numéri-
co. Si ingresamos otro tipo de valor, es probable que nos aparezca algún error
de conversión o desbordamiento de variable. Por eso debemos prestar mucha
atención en el tipo de variable que vayamos a utilizar para la aplicación.
Veamos el siguiente ej emplo :
int i;
cout << "Por favor, introduzca un valor entero :" ;
cin >> i;
cout << "El valor que ha introducido es" << i;
cout << ''y su doble e.s" << i * 2 << "\ n". ;
Las definiciones de variables de C# y de C++ son muy similares. En ambos lenguajes las va -
riables pueden ser declaradas solo locahnente en un método o como miembros de una clase.
En el caso de C#, no se ofrecen equivalentes a las variables globales o estáticas de C++.

También podemos utilizar cin para solicitarle al usuario dos datos, escri-
biendo esta sentencia en una única línea, por ej emplo :
cin >> varA >> varB;
El programa le solicitará al usuario tm valor para la primera variable,

y luego, otro para la siguiente.
Operaciones con cadenas de texto

Para obtener por pantalla lo que el usuario ingresa, podemos utilizar la
función cin. Es importante tener en cuenta que esta solo reconocerá lo escrito
hasta que aparezca un espacio. Debido a las complicaciones que esto trae en
las cadenas extensas de texto, se recomienda utilizar la función getlineO , que
permite capturar mayor cantidad de texto. Veamos un ej emplo :
#include <iostream>
#include <string>
int main O
{
string mystring;
cout << "¿Cuál es tu nombre?";
getline (cin, mystring);
cout << "Hola" << mystring << "." ;
cout << "¿Cuál es tu equipo favorito de fútbol?";
getline (cin, mystring);
cout << "Yo soy fanatico de " << mystring << " también!";
getcharQ;
return O;
}

Podemos ver que getline requiere dos parámetros: uno es la instrucción

cin y otro es la variable donde guardamos la información.
Ahora que ya hemos visto todas estas sentencias de entrada y salida de
información estándar en C++, podemos avanzar en las instrucciones que nos
serán útiles para realizar algoritmos más complej os.
Estructuras de programación
Ya sabemos cómo se pueden utilizar los datos en C++. Veamos ahora cómo
se pueden realizar diferentes acciones o tomar distintos rumbos en un algo-
ritmo de programación. Para hacerlo, vamos a usar sentencias parecidas a las
que esh1diamos anteriormente en las estructuras de control , y conocere-
mos las estructuras secuenciales y repetitivas. Es importante considerar que
en C++ no siempre se trabaj ará de manera secuencial, por lo que debemos
diferenciar los bloques de código con llaves {}.
Estructura condicional
La estructura condicional if se usa para ej ecutar una condición si la expre-
sión se cumple. Por ej emplo :
if (varX = 100)
cout << "varX es 100";
La estructura es parecida a otros condicionales que vimos anteriormente :
If (condición)
Instiucciones ...
Si necesitamos realizar más de una instrucción para que se ej ecute, debe-

mos especificar un bloque con las llaves :

if (varX = 100)
{
cout << "v arX es " ;
cout << varX;
}
Para conocer la veracidad o no de una condición y tomar medidas si esta

es verdadera o falsa, utilizamos la siguiente sintaxis :
if (condición)
Instiu cciones ...
else
Instiu cciones ...
if (varX = 100)
else
cout << "varX no es 100";
Para conca tenar o anidar las estiucturas i( primero debemos ver cómo es
la estn1chira:
if (condición)
Instiu cciones ...
elseif
Instiu cciones ...
else
Instiu cciones ...
#include <iostream>
#include <string>
int main O

{
int varX=O;
varX=7;
if (varX > O)
cout << "varX es positivo";
else if (varX < O)
cout << "varX es negativo";
else
getcharQ;
}
Si vamos a realizar más sentencias de instrucciones, es importante recor-

dar que tenemos que encerrarlas entre llaves <} .
Estructura selectiva
Se utiliza para valorar una condición y, dependiendo de su resultado,
se pueden dar distintos casos y resoluciones. Su sintaxis es la siguiente :
s,vitch (condición)
{
case constante:
instrucci ones ... ;
break;
case constante:
instrucciones ... ;
break;
default:
instrucciones ...
}

Notaremos que la estructura utiliza la palabra reservada break, que indica

el fin de las instrucciones del case. Veamos un ej emplo para comparar ambas.
Switch If-else
switch (x) { if (x = l) {
case 1: cout << "x es 1";
cout << "x es 1"; }
break; else if (x = 2) {
case 2: cout << "x es 2";
cout << "x es 2"; }
break; else {
default: cout << " El valor de x es desconocido";
cout << "El valor de x es desconocido"; }
}
Estructuras repetitivas
Son las que utilizamos para repetir acciones hasta lograr que se cumpla
una determinada condición.
,v hile/Loop
La sintaxis es :
\vlrile (expresión) instiucciones
Su función es repetir la declaración, siempre y cuando la condición esta-

blecida en la expresión sea verdadera. Por ej emplo, vamos a hacer un progra-
ma de la cuenta regresiva mediante un bucle \vhile:

int main O

{
int n;
cout << "Ingrese un número de inicio >> ";
cin >> n;
while (n>O)
{
cout << n << ", ";
--n;
}
cout << "¡Se terminó!";
return O;
}
Al iniciar el programa, se le pide al usuario que introduzca un núme-

ro de inicio para la cuenta regresiva, y así co1nienza el tiempo de bucle.
Si el valor especificado por el usuario cu1nple la condición n > o (don-
de n es mayor que cero), el bloque que sigue a la condición se ejecutará
y se repetirá 1nientras la condición ( n > o) continúe siendo verdadera.
Cuando se crea un bucle \vlrile, este debe terminar en algún momento.
Para eso, tenemos que escribir algLma instn1cción o método que determine
la condición como falsa; de lo contrario, el bucle se convertirá en lo que se
conoce como bucle infinito , es decir, girará dentro de sí para siempre.
En este caso he1nos incluido - n para disminuir el valor de la variable
Para la salida de info1mación en pantalla, podemos utilizar la función printf , usando

tma cadena dentro de esta fi.mción, de la siguiente fo1ma: printf( "Primera cadena" "
Segunda cadena");printf("Primera cadena"texto enmedio"Segunda cadena");p1intf
( "Esto es \"extraño\"");.

PROGRA1\1ACION DESDE CERO 17 1
que está siendo evaluada en la condición. UN BUCLE WHILE

De esta manera, eventualmente haremos
que la condición ( n > o) llegue a ser falsa SE CIERRA CUANDO
después de u11 cierto nú1nero de iteraciones LA CONDICIÓN
en el bucle.
SE DETERMINA
COMO FALSA
For/Loop
La sintaxis de esta estructura repetitiva es :
for (inicialización; condición; incremento)

instiucciones;
Su principal función es repetir las instrucciones mientras que la condi-

ción se cumpla (como lo hacía el \vhile/loop) y, además, proporcionar lugares
específicos para contener una inicialización y un incremento .
Este bucle está diseñado para realizar u11a acción repetitiva, utilizan-
do u11 contador que se declara e inicializa en la estructura e incrementa
su valor en cada iteración.
Repasemos qué significa cada parte de esta sintaxis:
• Inicialización : ajuste de valor inicial para tma variable de contador,

que se ejecuta solo una vez.
~ ESPACIO.DE NOMBRES
~
Así como en Visual Basic podemos utilizar namespace , el contenido de este nos per-
mite agrupar o utilizar tm conjtmto de clases a nivel global, los objetos o las fi.mciones
que le confieren un nombre. Por ejemplo, el espacio de nombre que se debe utilizar
en C++ es std ,. con la sintaxis using_
~

• Condición : se chequea a medida que el bucle se produce;

si es verdadera, el bucle continúa; si es falsa, se termina.
• Incremento : cada vez que chequea la condición, se lleva a cabo
lo especificado en el incremento o decremento de tma variable.
• Instrucciones : se ejecutan en cada entrada al bucle; puede ser
una sola sentencia o un bloque entre llaves.
A continuación, veamos cómo sería en código, haciendo referencia a la

condición del ejemplo anterior:

int main O
{
for (int n=lO; n>O; n--)
{
cout << n << ", ";
l
cout << "CUENTA FINALIZADA";
return O;
}
Tengamos en cuenta que tanto la inicialización como el incremento son

opcionales, por lo tanto, no es necesario declararlos para el uso de la estruc-
tura for. Dicha estructura también nos permite utilizar más de una expresión
dentro de los paréntesis que siguen al for, gracias al uso de comas. Veamos
un ej emplo en el cual podemos inicializar más de una variable :
for (n=O, i=lOO; n!=i ; n++, i--)

{
cout << n << ", ";
}
Hay que tener cuidado al utilizar coma o punto y coma, ya que estos últi-
mos dividen la expresión.

{
' .
for (n=O i=lOO · n'=i · n++ i--)
' ' '
Instrucciones ...
}
En el código vemos cómo queda dividida la expresión con comas, y punto

y coma. Esta condición pregunta si n es distinto de i; en el ca so de ser iguales,
el bucle se detendrá.
Ejercitación
En el ca so práctico que aparece a continuación, pondremos a prueba lo que
venimos aprendiendo. Utilizaremos el operador XOR y la función getlineO para
encriptar un texto que haya ingresado el usuario (incluyendo los espacios).
Primero crearemos u11 proyecto en SharpDevelop , con el nombre
Ej emploFOR. Luego codificaremos lo siguiente:

#include <string>
int mainO
{
int longitud;
const int NU1\IIER0=120; //Número máximo de caracteres.
char texto[NUl\lIEROJ,key;
cout << "Ingrese una oración:";
cin.getline(texto,120); //Toma el renglón del texto.
cout << "Ingrese la clave para encriptar (un dígito):";
cin >> kev •
·"
longitud=strlen(texto);
cout << "\ *** Texto encriptado ***";
for (int i=O;i<longitud;i++)
{

texto(i) = texto(i) " key; //XOR

}
cout << texto << endl;
cout << "\ *** T ex to decodificado***";
for (int i=O;i<longitud;i++)
{
texto [i) = texto [i) " key;
}
cout << texto << endl;
system("pause");
}
Antes de continuar con otras estructuras, revisemos lo realizado:
a) Utilizamos variables y constantes: recordemos que podemos

abreviar las variables en el caso de los ejemplos que vimos. En general
contienen un nombre completo, pero no es necesario que sea extenso;
eso dependerá del criterio de cada desarrollador.
b) Aplicamos sentencias de entrada y salida de datos : dentro de estas
últimas, una librería llamada string nos permite utilizar la función strlenO .
c) Utilizamos tma fLmción cíclica o bucle: el for, que nos permite
recorrer todo el texto y encriptarlo.
d) Aplicamos tma nueva palabra reservada: system("pause") .
El lenguaje C++ es case sensitive . Esto significa que un identificador escrito en letras
mayúsculas no es equivalente a otro con el mismo nombre esc1ito en minúsculas.
Así, por ejemplo, la variable RESULTADO no será lo mismo que resultado o Resultado .
Se trata de tres identificadores de vruiables diferentes.

PROGRAt\ 1ACION DESDE CERO ( !J.jd ,-fj 175
Esta palabra reservada muestra un texto en la consola que dice

"Presione cualquier tecla para continuar" y, así, permite ver el resultado.
El ejemplo quedaría como se observa en la figura siguiente:
Figura 5. Resultado del ejercicio, donde podemos ver

cómo se encripta un texto con C++.
Saltos de declaraciones
Los saltos de declaraciones son útiles en el momento de realizar al-
gunas instrucciones que considera1nos importantes, y cuando no nece-
sita1nos que continúe preguntándonos por una condición en un bucle.
Sentencia break
Utilizando la palabra break podemos dejar por concluido tm bucle, atm
si la condición no ha fmalizado. Es decir, podemos utilizarla para poner
fm a tm bucle infmito, o para forzarlo a terminar antes de su fm natural.
Es un lenguaj e de programación diseñado a mediados de los años 1980 por Bj arne Strous-
trup, cuya intención fue extender el exitoso lenguaje de programación C con mecanismos
que permitieran la manipulación de obj etos. En ese sentido, desde el punto de vista de los
lenguajes orientados a objetos, C++ es lub rido.

En el siguiente eje1n plo, va1nos a detener una cuenta regresiva antes de

su fm natural:
#include <iostream>
int main O
{
int n;
for (n= l O; n>O; n--)
{
cout << n << ", ";
if (n=3)
{
cout << "Cuenta regresiva abortada";
break;
}
}
getcharQ;
return O;
}
Podemos utilizar tma sentencia break en cualquier ptmto del código dentro
de un bucle. Recordemos que saldrá del bloque de código donde es utilizada,
y continuará con las sentencias que le siguen a la estructura repetitiva.
Sentencia continue
La instrucción continue realiza un salto en el bloque de código que
nos lleva al extremo de las instrucciones. Se utiliza en estructuras repe-
titivas para saltar algu11os procesos especificados y, así, continuar con
las iteraciones. En el eje1n plo que aparece a continuación, va1nos a sal-
tar el número 2 en la cuenta regresiva:


int main O
{
for (int n=lO; n>O; n--)
{
if (n=2) continue;
cout << n << ", ";
}
cout << "Finalizado";
return O;
}
Si pusiéramos a prueba este código, el resultado sería el siguiente:

10, 9, 8, 7, 6, 5, 4, 3, 1, Finalizado .
Sentencia goto
Esta sentencia puede usarse para hacer un salto a un sector del algoritmo
que estamos desarrollando. Es importante ser cuidadosos con ella, porque
puede hacer el salto y ej ecutar tipos incondicionales. El punto de destino es
rotulado por un texto seguido de dos puntos. En el siguiente ej emplo, vere-
mos un bucle "cuenta atrás" utilizando la sentencia ooto
o ·.
#include <iostream>
int main O
{
int n=lO;
loop:
cout << n << ", ";
n--;
if (n>O) goto loop;
cout << "Finalizó";
return O;
}

Función exit
Esta función puede encontrarse en otros lenguajes, y tiene como
objetivo finalizar el programa. Está en la librería cstdlib de C++, y
su est1uctura es la siguie11te:
void exit (int exitcode);
Datos estructurados
En esta sección aprenderemos a manej ar arrays, estructuras muy ú tiles
para utilizar y almacenar información en la memoria durante un período de
tiempo necesario en el desarrollo de nuestros programas .
l\tlanejo de arrays
Un ruTay es una serie de elementos homogéneos que se grabarán en espa-
cios continuos de memoria , a los cuales podemos acceder en forma indivi-
dual gracias a un índice. Su modo de representación se observa en la figura 6.
ilvlatriz unidimensional
(O) ( 1) (2) (3)
Figura 6. En este ejemplo podemos ver la forma correcta

de representar un array de cinco posiciones.
Cada ubicación en blanco representa un elemento en el ruTay y, si no le

defmimos ningún valor, este tomará por defecto el que indica el lenguaje.
Todos los elementos serán del mismo tipo de dato.
El índice en C++ inicia en Oa n; por eso, en el array que vimos en la
imagen es Oa 4, porque se obtienen cinco espacios para grabar datos.

A continuación, veamos cómo se declaran:
tipo nombre [elementos];
Como podemos notar, la declaración es similar a la de una variable que

usualmente utilizamos en C++. Veamos cómo se conforma su sintaxis :
• Tipo : se refiere a un tipo válido ( int, float, char ).

• Nombre : es tm identificador válido.
• Ele111entos : espacios que se declaran en el ruTay y siempre aparecen
entre corchetes.
Veamos una declaración en C++:
int rniAITay [5];
El elemento de campo encerrado entre corchetes representa el nú1ne-

ro de elementos de la matriz y debe ser u11 valor constante, ya que las
1natrices son bloques de memoria no dinámica, cuyo ta1naño tiene que
ser determinado antes de la ejecución.
Sintaxis de inicialización
Dentro de las funciones podemos declarar arrays locales. Estos no tendrán
un valor definido si no se inicializan por código, por lo tanto, su contenido
será indefinido hasta que les almacenemos un valor. En el caso de las matri-
ces globales y estáticas, los elementos se inicializan automáticamente con
valores por defecto; esto significa que estarán llenos de ceros.
En ambos casos, local y global, cuando se declara una matriz podemos
asignar valores iniciales a cada uno de sus elementos por los valores que
encierra entre las llaves. Veamos un ejemplo :
int miArray[5) = {1999, 64, 180, 20 1, 5138};

Para no provocar desbordamientos en el ruTay , no debemos agregar más

elementos entre paréntesis de los que hay declarados entre corchetes. Pode-
mos declarar arrays sin especificar su tamaño y asignar valores que a su vez
tomarán el tamaño de la cantidad de elementos agregados, por ejemplo :
int miArray[) = { 1999, 64 , 180, 20 1, 5 138};
Acceder a valores
Para acceder a estas estructuras, debemos especificar el índice donde está
almacenado el valor. Podemos acceder al ruTay de forma individual y, enton-
ces, leer o modificar los valores que queramos. La sintaxis es sencilla:
nombre [indice]
Por lo tanto, si deseamos grabar el valor 2 0 12 en el inicio del array,

la declaración sería la siguiente:
rniAITay[O] = 2 0 12;
Y si precisamos obtener un valor del ruTay , debemos asignarlo a una varia-

ble que sea del tipo de dato correspondiente a la estructura.
vru·A = rniAITay[O];
Las sentencias goto no deben usarse cuando se resuelven problemas mediante programación
estructurada. Existen mecanismos para hacer de otro modo todo aquello que pueda efectuarse
mediante goto. La metodologia de programación actual utiliza otras herramientas de saltos.

Co1no pode1nos ver, los corchetes representan dos tareas diferentes

que no debe1nos confundir: por un lado, especifican el ta1naño de las
1natrices que hayan sido declaradas; y por el otro, definen los índices
de ele1nentos de la matriz de honnigón.
int miArray[5); //Decl araci ón de un array

miArray[2) = 180; //Acceso a un dato/espacio del array
Revisemos las sintaxis válidas para trabajar con arrays en C++:
miAITay[O] = varA;
miAITay[varA] = 75;
varB = miAITay[varA+2];
miAITay[miAITay[varA]] = miAITay[2] + 5;
Arrays multidimensionales
Los arrays de arrays son estructuras bidimensionales muy parecidas a
las hojas de cálculo. Veamos en la figura 7 cómo podría ser su apariencia.
Ñlatriz bidimensional
(0,0) (0,4)
(1,0)
(3,0) (4,4)
Figura 7. En este ejemplo podemos ver la forma correcta

de representar un array de dos dimensiones.

El ruTay que vemos en la imagen representa tma estn1ctlrra de 4 por 5

( 4 filas y 5 columnas). Para declararlo, deberíamos escribir:
int miAITay[4](5);
Si queremos hacer referencia a un espacio dentro, debemos codificar lo

siguiente:
miAITay[2l[l j;
Si bien los arrays multidimensionales pueden tener más de un índice, de-

bemos tener cuidado, ya que, si tienen más dimensiones y espacios, mayor
será la cantidad de memoria requerida. Por ejemplo :
int miAITay[100](50](25](10);
Recorrer arrays
Es importante pasar por cada espacio de dato que hayamos declarado.
Dado que esta es una tarea repetitiva, podemos utilizar cualquiera de las
estructuras de bucle que ya conocemos. En el ejemplo que aparece a conti-
nuación, cargaremos datos en tm ruTay de 3x5 :

#define COLill1NA 5
#define FILA 3
int miArray [FILAl[COLill'INAJ;
int n,m;
int main O
{
for (n=O;n<COLill'INA;n++)
for (m=O;m<FILA;m++)
{

PROGRAt\ 1ACION DESDE CERO (!J.jd,-fi 183
miArray(n)(m)=(n+l )*(m+l );
cout<<"Fila: "<<n << " / ";
cout<<"Columna: "<<m << " / ";
cout<<"Dato: "<<miArray[n)[m);
cout<<endl;
}
getcharQ;
return O;
}
Fil,,: 0 / Co lunn,,: 0 / D,, to : 1

· il,,: 0 / Colunn,,: 1 / D,, lo : 2
):ilrt: 0 / Co lunn,:1: 2 / D.1to: ]
~~il,,: 1 / Co lunn ,J: 0 / D,,to: 2
F i 1o: 1 / Colurmi'I: 1 / O;,to: 4
Fil.:,: 1 / Co lunnil: 2 / D,1 to : 6
F i la: 2 / Colunnil: 0 / Dc1to: ]
IFila: ?. / Colunn,1: 1 / D.-, to : í,
Fil<l: 2 / Colunnil: ?. / D"t o: 9
· i 1,,: J / Cn lunn,,: 0 / o., t º : 1
Fil,,: ] / Cu lunn., ! 1 / D., to : 8
· i 1,, : J / Co lunn,,: 2 / D,, to : 12
Fil,,: 4 / Co lunn,1: 0 / D,1to: ~
~ i 1,,: 1 / Co lunn ,,: 1 / o., to : 10
Fi l ~ ~ 4 Colunn,l,~ 2 n~ t o~
''
/ /
Figura 8. Recorrido y carga de un array con estructuras repetitivas.
En este capítulo nos encontramos con un lenguaj e más "duro", pero que, en esencia de
programación, es similar a otros. Comenzamos utilizando un !DE gratuito, donde se pue-
den crear proyectos de consola y practicar la declaración de variables, j tmto con el uso
de operadores en C++. Luego aprendimos a capturar info1mación desde la consola y a
realizar todo el proceso de información necesario para devolverle al usuario los mensaj es
co11'espondientes. Finalmente, hicimos uso de las estructuras ruTay , que nos pe1miten
almacenar y manipular gran cantidad de datos en la memoria.

Actividades
1 ¿Qué ventajas se obtienen al utilizar C++ sobre otros lenguajes?
2 ¿Qué entotno gráfico utiliza el lenguaje C++?
3 ¿Cómo se declaran vruiables y constantes en C++?
4 ¿Qué significan #include y using ?
EJERCICIOS PR..\CTICOS
Realice un programa de consola con Shat-pDevelop que se llame Ejercitacionl .

Este deberá pennitirle al usuario acceder a datos y mostrar un resultado.
Considere lo siguiente:
• Genere 1ma serie de números aleatorios entre O y 1.
• La cantidad de números por generru· debe ser ingresada por consola
y utilizar variables numéricas.
• Utilice la función randO , que genera tm número entero aleatorio entre O y 32767.
La función se encuentra en math.h, por lo tanto, debe incluirla en el programa.
• Con la función atoi(chru· *) convie1i a 1ma cadena de cru·acteres en tm número entero.
Dicha función se encuentra en la librería stdlib.h ; no olvide que la directiva #include
incluirá tanto las librerías math.h como stdlib.h.


///////////////,
Confección de
interfaces gráficas
Luego de haber manejado estructuras de datos abstractas,
vamos a adentramos en el diseño de interfaces gráficas.
• Normas de diseño .................... 186 Componentes visuales ............... 191

Fundamentos del diseño ........... 186
• Resumen................................... 192
• Controles usuales..................... 188
186 APÉNDICE. C01''FECCIÓN DE INTERFACES GR/\F1CAS
Normas de diseño
En este capítulo veremos generalidades para la buena confección de inter-
faces, y recomendaciones que nos permitirán tener precaución al diseñar.
El estudio y desarrollo del diseño de interfaz prioriza el trabaj o de varias
disciplinas en función de un mismo obj etivo : comunicar y transmitir a tra-
vés de un medio electrónico. A partir del diseño de interfaces gráficas (GUI)
buscaremos que los usuarios de nuestro desarrollo puedan comunicarse con
el programa de manera efectiva, mediante una interfaz confortable que no
requiera esfuerzo para su comprensión. Los tipos de interfaces que podemos
encontrar en la actualidad son: interfaz gráfica de escritorio, interfaz de con-
sola, interfaz web, interfaz táctil e interfaz de consolas de videojuegos.
Fundamentos del diseño

Existen varios factores que influyen en la toma de decisiones sobre
el diseño de una interfaz; las siguientes preguntas nos ayudarán a en-
ca1ninar nuestra perspectiva:
• ¿Por qué y para qué?: cuál es el objetivo de nuestro diseño.

• ¿Para quién?: lo que vamos a diseñar puede ser para una persona
o un grupo, para una tarea genérica o específica, para auto1natizar
procesos, etcétera. Es fundamental conocer habilidades y experien-
cias del sector al que nos dirigimos.
• ¿Con qué tipo de recursos tecnológicos cuenta el usuario? ¿Es un desa-
rrollo para :tviac, PC, Linux?: estos datos nos ayudarán a comprender las
necesidades del usuario, y así evaluar cómo presentar la información,
en qué formato, qué lenguaje de programación utilizar, etcétera.
Estas preguntas nos servirán para fundamentar nuestros diseños gráficos,

y darles sentido y funcionalidad. El diseño de la interfaz debe garantizar un
sentimiento de seguridad que guíe y condicione al usuario, para así brindar
u11 control total sobre ella. Para generar estas condiciones, debemos

considerar distintos recursos (imágenes, sonidos, animaciones, videos)

y aplicarlos en su medida justa. No debe1nos considerar todos los gus-
tos individuales de tma persona que utilizará el desarrollo. Es importante
tener un cierto discernimiento para saber seleccionar adecuadamente las
características personalizadas. A continuación, veamos algtmos fLmda-
mentos que debemos tener en cuenta en el diseño de tma interfaz gráfica.
1) Sencillez : evitar la satliración de elementos y st1inclusión innecesa-

ria, ya que su fLmción es acompañar y gtiiar al usuario.
2) Claridad : la información debe ser fácil de loca lizar. Para eso, es nece-
sario establecer una organización, ya sea de manera lógica , j erárquica o
temática. Esto es fundamental porque, cuanto más información ubique-
mos en la pantalla, mayor será la distracción o confusión para el usuario.
3) Predictibilidad : para acciones igtiales, resultados igtiales.
4) Flexibilidad: el diseño de la interfaz debe ser claro y predecible

en cuanto a la mayor cantidad posible de plataformas.
5) Consistencia : lograr tma semejanza entre las diferentes interfaces

del sistema, estableciendo una organización según la fLmción de los
elementos. Para el usuario, es importante que la interfaz sea similar
en las distintas aplicaciones. Por ejemplo, en tma aplicación vveb,
la ubicación del listado de contenido suele estar del lado izquierdo.
6) Intuición : el usuario debe sentirse segL1ro y no tener que adivinar

ni pensar cómo ejecutar las acciones. Es importante que la aplicación
lo gtiíe para realizar su cometido, sin necesidad de un mapa de ruta.
• Dis111inuir las interacciones : es importante reducir y simplificar

la interacción del usuario, ya que su fm es el resultado que le brinda
el sistema. Por ejemplo: cuando el usuario utiliza Google, no lo hace

188 APÉNDICE. C01''FECCIÓN DE INTERFACES GR/\F1CAS
por el gusto de hacer clic en Buscar ni por el atractivo de su logo. Por eso,
cualquier interacción que Google incluya va a interponerse en la necesi-
dad del usuario. Actualmente, se ha reducido la interacción gracias a la
búsqueda inteligente porque, a medida que el usuario escribe sobre el
busca dor, van apareciendo los resultados posibles.
• Orden y presentación : la información debe mostrarse en forma
lógica, agrupando los campos similares. Por ejemplo: en la carga de
datos personales, debemos agn1par los datos del domicilio por tm
lado (dirección, código postal, ciudad) y los educativos por el otro.
7) Coherencia : todos los elementos utilizados (textos, gráficos,

colores) tienen que corresponder al contenido de la publicación.
8) Buen uso de controles : en diseño, es fundamental el uso correcto

de componentes visuales, como etiquetas de texto, campos de texto,
listas desplegables, casillas de opción, botones de opción y grillas de
resultados. Cada componente tiene un comportamiento y una utilidad
que no se deben alterar, para evitar confusión.
• Tamaño de los componentes : si modificamos su tamaño, estamos

afectando su grado de atención e importancia en relación al resto.
• Cantidad necesaria : hay que mantener un estándar de componentes.
Si deseamos implementar alguno que se diferencie con un funciona-
miento nuevo, es preciso educar a los usuarios sobre su manej o.
• Valores predeter111inados: para agilizar la carga de datos regula-
res, podemos configurar sus valores de manera predeterminada.
Controles usuales
En esta sección repasaremos aquellos controles más usuales que utili-
zaremos en los distintos desarrollos, y los compararemos en tres ámbitos
posibles: aplicación de escritorio, publicaciones vveb y dispositivos móviles.

• Etiqueta (Label) : tiene un uso informativo, ya que se utiliza para

presentar información en pantalla. Puede ser para titular la carga
de algún control o para dejar avisos en las interfaces. Es posible
1nodificar su contenido para mostrar u11 resultado, pero, en general,
se utilizan para etiquetar otros componentes.
Escritorio \Veb ~lóvil
En Visual Basic: En PHP: EnAndroid

Label.Text="ej emplo" <label>ejemplo<llabel> Android:label="ej emplo"
• Caja de texto (TextBox) : se emplea para ingresar valores a

una apli-
cación o solicitar el ingreso de datos a los usuarios. Es el componente
más frecuente para datos como nombre, apellido, búsquedas, etcétera.
En algLmos lengL1ajes podemos editar su tamaño de caracteres, el texto
en mayúscula o minúscula, su visualización en forma de contraseña,
etcétera. Veamos algu11os ejemplos:
Escritorio \Veb ~fóvil
En Visual Basic: En PHP: EnAndroid

TextBox.Text="" <textarea>ej emplo Se utiliza un método llamado
de texto</textarea> Input.
Enlace de ejemplo:
www. w 3 schools.com/tags!
Enlace de ejemplo:
http-J/android-developers.
lag_ textarea.asp
blogspot.com.ar/2009/04/
En PHPForm: creating-input-method.html
<input type="text"name="nombre"/>
• Casilla de verificación : brinda un conjunto de opciones para que

el usuario elija. Por lo general, lo encontramos como CheckBox, y la
propiedad que tiene es chequeado o no chequeado (marcado o no).

190 APÉNDICE. CONFECCIÓN DE ll\'TERFACES GR/\F1CAS
Las casillas de verificación funcionan independientemente una de otra;

así, el usuario puede activar varias al mismo tiempo, o ninguna.
En Visual Basic: En PHPFonn: Se utiliza un evento llamado

CheckBox. <input type="checkbox" onC!ick.
Checked= True name="vehicle" value="Bike" />
Una opción<br /> Enlace de ejemplo:
http-J/developer.android.com/
Enlace de ejemplo: guide/topics/mlcontrols/
www. w3schools.comlhtml/ checkbox.html
tryit.asp ?filename=t:t yhtml_ checkbox
• Botones de opción (OptionButton/RadioButton) : permiten

presentar a los usuarios un conjunto de dos o más opciones. A diferencia
de las casillas de verificación, deben funcionar siempre como parte de un
grupo; es decir, al activar un botón, los otros no podrán seleccionarse.
En Visual Basic: En PHPFonn: Se utiliza un RadioButtonGroup

OptionButton. <input type="radio" name="sexo" y luego la declaración de cada
Checked= True value="femenino" /> Femenino RadioButton.
Enlace de ejemplo: Enlace de ejemplo:

www. w3schools.comlhtml/ http-J/developer.android.com/
tryit.asp ?filename=t:t yhtml_radio guide/topics/mlcontrols/
radiobutton.html
• Listas desplegables (Co111boBox/ListBox) : pueden tener diferen-

tes configuraciones. En algunos casos, podemos establecer valores
predetenninados; en otros, podemos ingresar texto, ya sea para bus-
car dentro de la lista o para agregar un valor a ella.

En Visual Basic: En PHPForm: Se puede utilizar un

ComboBox. <select name="select"> control llamado Spinner
Items. <option value="Opción l " para presentar una lista
Add("Opción l ") selected>Option 1</option> con opciones.
Enlace de ejemplo: Enlace de ejemplo:

\V\VW .abbeyworkshop .comlhowto/ http://developer.android.com/
lamp/php-listboxlindex.html guide/topicsfm/controls!
spinner .html
• Grillas de datos (Grid) : son controles avanzados y se utilizan para

desplegar infonnación en pantalla. En el caso de algunas interfaces,
son utilizados para disponer otros compone11tes.
Escritorio \Veb ~lóvil
En Visual Basic: En PHP se puede hacer una En el caso de Android,

Se utiliza un control llamado combinación entre tabla, GridView es un tipo de
DataGridView. etiquetas y cajas de texto. visualización en pantalla.
• Botones de comando : se usan para darle órdenes particulares al

siste1na. La orden debe estar clara1nente indicada en el botón, ya sea
por su título de texto o por su icono.
Componentes visuales
Además de los componentes básicos, debemos tener en cuenta otros tipos
de objetos que nos servirán para ayudar al usuario con el uso de la aplicación.
• Iconos : son la representación gráfica de diferentes dimensiones,

en el rango de 16x16 a 128x128 pixeles. Por lo general, caracterizan

192 APÉNDICE. CONTICCIÓN DE INTERFACES GR/\F1CAS
u11a acción o u11 evento que deseamos ejemplificar (por ejemplo,

el icono de imprimir, el de u11 explorador de Internet, etcétera).
A la hora de seleccionar los iconos que representen las tareas
de nuestro desarrollo, debemos aseguramos de que el usuario
los reconozca. Para eso, tendremos que evaluar su impacto a través
de u11 test de usuarios.
• Imágenes : debemos estar atentos en su selección, ya que estas deben re-

presentar elementos que ayuden a la comprensión o uso de la aplicación.
• Ventanas: las aplicaciones de escritorio utilizan ventanas o formas ( Fo1m )

que contienen otros controles. Estas pueden tener diferentes formas,
colores y estilos. Dentro de las ventanas, los cuadros de diálogo se uti-
lizan para tareas específicas , como seleccionar un color, aplicar alguna
acción, seleccionar una imagen, etcétera.
• Contenedores : son componentes que nos permiten contener otros

componentes, por ejemplo: fichas ( Tabs ) , cuadros o marcos y cuadros
de grupo ( GroupBox ) . Se los utiliza para organizar, ordenar o seccionar
tma tarea con componentes de otras.
En este apéndice hemos visto una serie de pautas interesantes y útiles para comenzar a dise-
ñar interfaces gráficas. Al mismo tiempo, conocimos cómo se utilizan los controles de uso más
común, tanto en aplicaciones de escritorio, como en publicaciones web y dispositivos móviles.
Por tÜtimo, vimos otros tipos de objetos visuales, que completan la interfaz.

Programación desde cero
Presentamos tma obra ideal para introducirse en el mtmdo del desarrollo
y la programación de aplicaciones informáticas. El recorrido comienza
con una introducción al uso de pseudocódigo, y luego avanza hacia la
explicación de conceptos claves como las variables, los operadores y las
fLmciones. Finalmente, concluye con dos proyectos donde se pone en
práctica la teoría aprendida, uno en Visual Basic y otro en C++.
Dent1·0 del lib1·0 encont1·a1·á *:

Algoritmos y metodologías de desarrollo. / Pseudocódigo. / Variables, operadores y
datos estructurados. / Creación de un proyecto en lenguaje Visual Basic. / Creación
de un proyecto en lenguaje C++.
* Parte del contenido de este libro fue publicado previ amente en Introducción a la programación , de esta misma editorial.
Ot1·0s títulos de la colección:
l l •-e13il:..:1
1 l • c-1 ,:,..1:j l • c,:3;1:j
~ PHP ~ Java
' PHP+MySQL1
~
desde cero desde cero § desde cero
§
o
IS ¡
i 114 F -•-
$
e
i•
l t
!
ISBN 978-987-1949-60-1
reDUsers.com Profesor en LÍneA

en nuestro sitio p odrá encontrar noticias .4 nte cualquier consulta técnica
relacionadas y también participar relacionada con el libro, puede
RU de la comunidad de tecnologia más
importante de i unérica Latina.
contactarse con nuestros expertos:
profesor@redusers.com .

Programacion Desde Cero

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Programacion Desde Cero

Caricato da

Copyright:

Formati disponibili

.

Fu11dame11tos del desaiTollo de aplicaciones +

.' ,;' 1'

- DESARROLLO / O-tr ERl\1E'T - MICRQSOFT / OFFICE

LLEGAMOS A TODO EL MUNDO VÍA >>OCA * y

Casale, Juan Carlos

ISBN 9 78-987- 1949-60 - l

l. Informática. l. Carballeiro, Gustavo, coord. 11. Titulo

>> www. red users .com

ENNlJISTRosmo PODRA ACCEDER A UNA PREVIE\VDIGITAL DE CADA LIBRO y TAl\IBIÉ N

que lo dirija hacia una ubicación esp ecifica

Luego de haber recorrido teorías y

de pseudocódigo, el lenguaje "común" plasmar todo el conocimiento adquirido

El funcionamiento del equipo se b asa en Aplicaremos los conocimientos adquiridos

>> www. red users .com

Aquí veremos el desarrollo de código

fuente que tiene el reconocido lenguaje Luego de haber manejado estructuras

CURIOSIDADES :\ffi' lCIÓ N DATOS UTILIS smos

www. redu sers.com <<

Contenido del libro

C) Traducción del diseño Datos estructurados ..................................... 58

Pseudocódigo: el lenguaje humano ............. 22

>> www. red users .com

Resumen ....................................................... 87 Primera ap licación en C ++......................... 141

Confección de interfaces gráficas

www. redu sers.com <<

>> www. red users .com

• Desarrollo de aplicaciones ......... 1O D) Implementación y testeo

• Aplicaciones vveb : son muy comunes en organizaciones que desean

que el usuario controle el dispositivo mediante un software instalado en su teléfono móvil.

>> www. red users .com

utilizados por grandes empresas; y con otros gratuitos y útiles que

Interpretación de las aplicaciones

Una aplicación envía Es procesada

Figura l. Una fo1ma sencilla de ver el funcionamiento

En la actualidad, la interacción entre los usuarios y las aplicaciones se

www. redusers.com <<

botonera de un ascensor o el panel de un microondas), oído e, incluso, olfa-

Análisis Diseño Pseudocódigo

Test de ejecución Código (lenguaje

Figura 2. Etapas involucradas en el desruTollo de aplicaciones.

>> www. red users .com

En el proceso que vemos en el gráfico de la fij?ura 2, puede suceder que

A) Análisis del problema

www. redusers.com <<

Para el diseño de la aplicación, dividiremos el proceso en dos partes : por

Balsamiq C balsamiq.com), Pencil (pencil.evolus.vn) y l\ilicrosoft Visio

Figura 3. Ejemplo de prototipo realizado con Mockingbird .

>> www. red users .com

Diseño del funcionamiento

Figura 4. Proceso de selección de una remera para vestir.

www. redusers.com <<

En el desarrollo para ejecutar tma aplicación, esta serie de pasos

C) Traducción del diseño

dos mediante flechas para indicar secuencias de instrucciones. Su construcción es laboriosa y

>> www. red users .com

• Lenguaje máquina : código interpretado directamente por el procesa-

A continuación, veremos el código fuente de dos lenguajes: e y Basic .

BASIC fhe diseñado en 1964, para facilitar el desaiTollo de programas de computación

a estudiantes y profesores que no se dedicai·an específicamente a las ciencias. Con los

www. redusers.com <<

Se trata de ejemplos de cómo se vería el desarrollo en ellos. En el siguien-

En Basic, el código que aparece a continuación realiza lo siguiente:

>> www. red users .com