Universidad Nacional del Escuela Profesional de

Altiplano – Puno Ingeniería Civil

INTRODUCCIÓN

El objetivo del presente trabajo dar conocer algunas sentencias empleadas en el

programa de c++, identificar los procesos entre el lenguaje humano y el lenguaje de la
maquina.

Los programadores escriben instrucciones en diversos lenguajes de programación,

algunos de los cuales los comprende directamente la computadora, mientras que otros
requieren pasos intermedios de traducción. Es decir: así como los seres humanos:
empleamos para diferentes idiomas y para comprender mejor necesitamos una persona
experta en el idioma de nuestro emisor.

Un lenguaje de programación es un conjunto limitado de palabras y símbolos que

representan procedimientos, cálculos, decisiones y otras operaciones, estos lenguajes de
programación, requiere de un conjunto de pasos y procedimientos para alcanzar un fin en
común, el que la computadora ejecute las instrucciones correctas.

En el transcurso de este trabajo monográfico para su buen entendimiento acerca

de los lenguajes de programación abordaremos lo siguiente: algunas breves definiciones
de ls sentencias while, sentencia do- while, sentencia for, sentencia switch, yarreglos o
array, del mismo modo daremos a conocer sus diagramas y la sintaxis por los que están
compuestos, mostraremos un ejemplo de aplicación, para cada uno.
 Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil

SENTENCIA WHILE
El bucle while se puede leer como “haz”. Es una de las estructuras de repetición o
cíclica empleadas en la programación de algoritmos, que nos permite ejecutar una o varias
líneas de código de manera repetitiva sin necesidad de tener un valor inicial e incluso a
veces sin siquiera conocer cuándo se va a dar el valor final que esperamos, los ciclos
while, no dependen directamente de valores numéricos, sino de valores booleanos, es
decir su ejecución depende del valor de verdad de una condición dada, verdadera o falso,
nada más. De este modo los ciclos while, son mucho más efectivos para condiciones
indeterminadas, que no conocemos cuando se van a dar, con los cuales se debe tener claro
un principio, un final y un tamaño de paso.

1. Diagrama de flujo del ciclo while

Ilustración 1: Diagrama de flujo

2. Sintaxis del ciclo while en c++

Su sintaxis es simple, pues requiere tener clara una condición de parada. En
realidad, en la mayoría de los lenguajes de alto nivel la manera de escribir un ciclo
while (la sintaxis) es incluso muy similar, así que con tan solo tener bien clara una
condición de finalización para el ciclo tendremos prácticamente todo hecho.
Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil

While (condición de finalización)

{
. . . .
. . . .
Bloque de instrucciones. . . .
. . . .
. . . .
}

Ilustración 2: sintaxis de while

Vamos entonces a ver línea por línea el anterior código para comprender todo

Línea 1:

En esta línea está prácticamente todo lo esencial de un ciclo while. La sintaxis es

bastante simple. Tenemos al interior de los paréntesis una condición cualquiera,
es decir por ejemplo "==. >, <, >=, <=, !=" o algunas más que se nos puedan
ocurrir, esta condición que especifiquemos allí, es la que permitirá que el ciclo se
siga ejecutando hasta que en algún momento esta misma condición deje de
cumplirse, de esta forma si por ejemplo estamos verificando que un número
cualquiera == 98,el ciclo se ejecutara solo cuando número cualquiera sea igual a
98, en cuanto su valor cambie a cualquier otro el ciclo while finalizara y continuara
con el resto de la ejecución del programa. De esta forma, es evidente que la
condición que allí ingresemos siempre deberá tomar un valor booleano (true o
false).
Línea 2:

En la línea 2 tenemos una llave abriendo "{" lo cual como sabemos indica que allí
comienza un bloque de instrucciones que se ejecutaran cada vez que el ciclo de un
"giro". Esta llave no es del todo obligatoria, sin embargo si no la ponemos solo se
ejecutara dentro de nuestro ciclo while la primera línea inmediatamente posterior a la
declaración del ciclo, de modo que si deseamos que se ejecuten varias líneas dentro de
nuestro ciclo, debemos usar las llaves.

Línea 3 a 7:

En estas líneas es donde estarán todas las operaciones que queramos llevar a cabo
de manera iterativa durante la ejecución del ciclo, este bloque podrá tener la
cantidad de líneas necesarias incluso, como veremos más adelante dentro de estas
Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil
podría haber uno o más ciclos, así que podrías tener todo un programa dentro de
un ciclo.
Línea 8:

En esta última línea hacemos uso de la llave cerrando "}", una vez más como
seguramente ya debemos saber esta nos indica que allí termina el bloque del ciclo
while y se dará por terminada la ejecución de este para continuar ejecutando el
resto del algoritmo. (González, 2018)

3. Ejemplo aplicativo

Ilustración 3: Programación en c++

Ilustración 4: Ventana de c++

 Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil

SENTENCIA DO-WHILE
El ciclo do-while (Instrucción hacer – repetir mientras) es un tipo de estructura
nos permiten ejecutar una o varias líneas de código de forma repetitiva sin necesidad de
tener un valor inicial e incluso a veces sin siquiera conocer cuándo se va a dar el valor
final, hasta aquí son similares a los ciclos while, sin embargo el ciclo do-while nos permite
añadir cierta ventaja adicional y esta consiste que nos da la posibilidad de ejecutar primero
el bloque de instrucciones antes de evaluar la condición necesaria, de este modo los ciclos
do-while, son más efectivos para algunas situaciones específicas.

Lo que lo diferencia con el while es que en la estructura do-while la condición se evalúa

al finalizar el ciclo, esto hace que las instrucciones se ejecuten cuando menos una vez.

1. Diagrama de do- while en c++

Ilustración 5: Diagrama de flujo de do-while

2. Sintaxis del ciclo do- while en c++

La sintaxis de un ciclo do-while es un tanto más larga que la del ciclo while en C++, sin
embargo no se hace más complicado, de hecho solo debemos tener bien clara una
condición de finalización para el ciclo tendremos prácticamente todo terminado.
 Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil

Do
{
. . . .
. . . .
Bloque de instrucciones. . . .
. . . .
. . . .

} While (condición de finalización);

Ilustración 6: Sintaxis de do-while

Línea 1:

Esta línea es por decirlo así, la parte novedosa del ciclo do-while, esta expresión no evalúa
ninguna condición ni nada, simplemente da paso directo al bloque de instrucción y luego
permite la evaluación de la condición.
Línea 2:

En la línea 2 tenemos una llave abriendo "{" lo cual como sabemos indica que allí
comienza un bloque de instrucciones que se ejecutaran cada vez que el ciclo de un "giro".
Esta llave no es del todo obligatoria, sin embargo si no la ponemos solo se ejecutará dentro
de nuestro ciclo la primera línea inmediatamente posterior a la instrucción do, de modo
que si deseamos que se ejecuten varias líneas dentro de nuestro ciclo, debemos usar las
llaves
Línea 3 a 7:

En estas líneas es donde estarán todas las operaciones que queramos llevar a cabo de
manera iterativa durante la ejecución del ciclo, este bloque podrá tener la cantidad de
líneas necesarias incluso, como veremos más adelante dentro de estas podría haber uno o
más ciclos, así que podrías tener todo un programa dentro de un ciclo.
Línea 8:

En esta última línea hacemos uso de la llave cerrando "}", una vez más como seguramente
ya debemos saber esta nos indica que allí termina el bloque de instrucciones que se
ejecutarán de manera cíclica y se dará por terminada la ejecución de este para continuar
ejecutando el resto del algoritmo.
 Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil

Línea 9:

La línea 9 en el ciclo do-while, tiene la misma importancia y función que l alinea 1 en la

sección del ciclo while, cabe resaltar que simplemente evalúa la condición y define si se
cumple o no para seguir con la ejecución del ciclo o con la del resto del algoritmo, de este
modo podemos ver que el ciclo while y el do-while son muy similares, con la pequeña
diferencia en que en uno se evalúa la condición desde el principio y en la otra al final de
cada ciclo.

3. Ejemplo aplicativo

Ilustración 7: Programacion c++

Ilustración 8: ventana de programa

 Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil

SENTENCIA FOR
El bucle for se conoce como estructuras de control de flujo cíclicas o simplemente
estructuras cíclicas, se utiliza para repetir un conjunto de sentencias un número de veces
fijado de antemano estos ciclos, como su nombre lo sugiere, nos permiten ejecutar una o
varias líneas de código de forma iterativa, conociendo un valor especifico inicial y otro
valor final, además nos permiten determinar el tamaño del paso entre cada "giro" o
iteración del ciclo.

1. Diagrama de flujo del ciclo for

Ilustración 9: Diagrama de flujo para for

2. Sintaxis del ciclo for en c++

La sintaxis de un ciclo for es simple en C++, en realidad en la mayoría de los lenguajes

de alto nivel es incluso muy similar, con tan solo tener bien claros los 3 componentes del
ciclo for (inicio, final y tamaño de paso) tenemos prácticamente todo hecho. (learn c++,
2015)

For(int i=valor inicial; i<=valor final ; i= i+paso)

{
. . . .
. . . .
Bloque de instrucciones. . . .
. . . .
. . . .
}

Ilustración 10: Sintaxis de for

 Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil
Línea 1:

En esta línea está prácticamente todo lo esencial de un ciclo for. La sintaxis es simple,
tenemos una variable de control llamada i que es tipo entero (int), cabe notar que la
variable se puede llamar como nosotros lo deseemos y puede ser del tipo de queramos
también, sin embargo en la mayoría de los casos se usa la "i" como nombre y el entero
como tipo, pero somos libres de modificar esto a nuestro gusto. Esta variable "i" se le
asigna un valor inicial que puede ser cualquier número correspondiente al tipo de dato
asignado. Posteriormente lo que haremos será especificar hasta donde irá nuestro ciclo
por medio del valor final, ten en cuenta que cada uno de estos componentes es separado
por un punto y coma ";", también es importante saber que la condición final puede ser
cualquier cosa, mayor, menor, mayor o igual, menor o igual, sin embargo no tiene sentido
que la condición sea por ejemplo un igual, pues nuestra variable de control siempre va a
cambiar entre valores, menores o mayores que el valor final deseado, si fuera un igual no
tendríamos un error de sintaxis, pero nuestro for básicamente no haría nada de nada.
Finalmente el último componente de esta primera línea es el tamaño del paso, este
componente se especifica aumentando en la cantidad deseada la variable de control.
Línea 2:

En la línea 2 tenemos una llave abriendo "{" lo cual como seguramente ya sabrás indica
que allí comienza el bloque de instrucciones que se ejecutaran cada vez que el ciclo de
un "giro". Esta llave no es del todo obligatoria, sin embargo si no la ponemos solo se
ejecutara dentro de nuestro ciclo la primera línea inmediatamente posterior a la
declaración del ciclo, de modo que si deseamos que se ejecuten varias líneas dentro de
nuestro ciclo, debemos usar las llaves
Línea 3 a 7:

En estas líneas es donde estarán todas las operaciones que queramos llevar a cabo de
manera iterativa durante la ejecución del ciclo, este bloque podrá tener la cantidad de
líneas necesarias incluso, como veremos más adelante dentro de estas podría haber uno o
más ciclos, así que podrías tener todo un programa dentro de un ciclo.
Línea 8:
 Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil
En esta última línea hacemos uso de la llave cerrando "}", una vez más como seguramente
ya sabrás esta nos indica que allí termina el bloque del ciclo for y se dará por terminada
la ejecución de este para continuar ejecutando el resto del algoritmo.

No te preocupes si no comprendiste muy bien lo que acabo de escribir, estoy seguro que
con un par de ejemplos que veremos a continuación, te va a quedar todo claro

3. Ejemplo aplicativo

Ilustración 11: Programa c++ de la sentencia for

Ilustración 12: Ventana del programa

 Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil

SENTENCIA SWITCH

Una instrucción Switch son una estructura de control condicional, que permite que
una variable sea probada para la igualdad contra una lista de valores, cada valor se
denomina caso, las condicionales Switch, que permite definir múltiples casos que puede
llegar a cumplir una variable cualquiera, y qué acción tomar en cualquiera de estas
situaciones, incluso es posible determinar qué acción llevar a cabo en caso de no cumplir
ninguna de las condiciones dadas.

1. Diagrama de flujo de la sentencia switch

Ilustración 13: Diagrama de Switch

2. Sintaxis de la sentencia switch en c++

La sintaxis de un condicional Switch es bastante distinta a la de un condicional
típico, sin embargo es bastante intuitiva y fácil de comprender.

Veamos a continuación la estructura general

switch (opción) // donde

opción es la variable a comparar
{
case valor 1: // bloque de instrucciones 1;
break;
case valor 2:// bloque de instrucciones 2;
 Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil

break ;
case valor3: //Bloque de instrucciones 3;
break;
//Notese que valor 1 2 y 3 son los valores que puede
tomar la opción
// la instrucción break es necesaria, para no ejecutar
todos los casos.
default:// bloque de instrucciones por defecto,
// default, es el bloque que se ejecuta en caso de que no
se de ningún caso
}

Ilustración 14:sintaxis Switch

Vamos ahora a ver línea por línea el anterior código para comprender todo y quedar claros.

Línea 1:

Aquí, tenemos la declaración del condicional switch, estamos diciendo que lo que viene
a continuación es esto, entre los paréntesis, el switch recibe la variable que vamos a usar
para comparar en cada uno de los casos.

Línea 2:

En la línea 2 tenemos una llave abriendo "{" lo cual como hemos visto en secciones
anteriores, indica que allí comienzan los bloques de instrucciones que se ejecutarán para
cada caso.
Línea 3:

En esta línea tenemos una parte vital del condicional switch, aquí tenemos definido un
caso posible que puede cumplir nuestra variable, la sintaxis es simple, usamos la
instrucción "case" para indicar que allí comienza un caso, luego indicamos el valor que
puede tomar la variable, puede ser un número, una cadena de caracteres o lo que
necesitemos, de esto se siguen dos puntos ":" y después de estos ponemos la o las
instrucciones a ejecutar para este caso.
 Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil
Línea 4:

Esta línea contiene la instrucción break, es una instrucción simple, pero fundamental al
interior del condicional Switch, esta instrucción indica que hasta allí va el bloque de
instrucciones del caso inmediatamente anterior a este, de este modo evitamos que el
algoritmo ejecute los demás casos, a modo de ejercicio, podrías intentar ejecutar el código
del ejemplo que veremos más adelante y quitar las instrucciones break, con esto podrás
comprobar que si el usuario ingresa por ejemplo un 1, se ejecutarán todos los casos, es
por esto que el break es fundamental.
Línea 5 a 8

Estas líneas contienen una repetición de las instrucciones de las líneas 3 y 4,

evidentemente cada una contiene un caso distinto, ten en cuenta que se pueden definir
todos los casos que sean necesarios al interior del switch.

Líneas 9, 10 y 12

Estas líneas como deberías saber ya, contienen diferentes comentarios aclarativos sobre
el código, en caso de que no comprendas adecuadamente estas líneas.
Línea 11

Esta línea cambia un poco con respecto a las anteriores, sin embargo conserva la misma
esencia, en vez de poner el comando "case", usamos el comando "default", y luego los 2
puntos ":", notemos que no se pone ningún valor a evaluar, pues esta es la acción que se
ejecuta en caso de que no lleguemos a entrar en ninguno de los casos.
Línea 13:

En esta línea hacemos uso de la llave cerrando "}", una vez más como seguramente ya
sabrás esta nos indica que allí termina el bloque del condicional y se dará por terminada
la ejecución de este para continuar ejecutando el resto del programa.

No te preocupes si no comprendiste muy bien lo que acabo de escribir, estoy seguro que
con un par de ejemplos que veremos a continuación, te va a quedar todo claro
Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil
3. Ejemplo aplicativo

Ilustración 15: Programa en c++ con sentencia Switch

Ilustración 16: ventana para caso 3

Ilustración 17: Ventana para el caso 4

 Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil

ARREGLOS O ARRAY
Un arreglo en C++ es una colección ordenada de variables del mismo tipo. Las
variables que pertenecen a un arreglo se conocen por el nombre de elementos. que se
almacenan en memoria de manera contigua con el mismo nombre. Para difenciar los
elementos de un arreglo se utilizan índices detrás del nombre del arreglo y encerrados
por []. El elemento 5° (quinto) de un arreglo, es representado por el índice [4], ya que los
índices comienzan en 0. Esto significa que un arreglo de 10 elementos tendría los índices
del 0 al 9: [0...9]. (Paucar, 2013)

1. Índice de array
Los índices son números que se utilizan para identificar a cada uno de los componentes
de un array. A modo de ejemplo, podemos pensar que los índices son como los números
de habitaciones de un hotel, es decir, para poder dirigirnos a un hotel especifico es
necesario saber el nombre del mismo, luego, si queremos llegar a una habitación
especifica de dicho hotel necesitamos, además del nombre del hotel, el número de
habitación deseada. (Wikibooks, 2018)

2. Dimensionalidad
De acuerdo a la forma en que se construye o declara un array, éste puede ser clasificado
como: unidimensional, bidimensional y multidimensional. Los arrays que se emplean con
mucha más frecuencia son los estructurados a manera de vector ( array unidimensional )
y los estructurados a manera de matriz ( array bidimensional ), así, aunque en C++ se
pueden crear estructuras multidimensionales, en este capítulo solo trataremos con
vectores y matrices.

2.1. Array unidimensional

Una array uni-dimensional es aquel en donde los componentes son accesibles por
medio de uno y solamente un índice que apunte al componente requerido. Los arrays
de este tipo son conocidos también con el nombre de vectores. Conceptualmente,
podemos pensar en un array unidimensional como una lista compuesta de datos,
donde para referirnos a uno de ellos emplearemos un número para indicar la posición
del mismo dentro de la lista.
Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil

array: Venta Semanal

+------+
| dato | <-- componente 0, ( fila 0 )
|------|
| dato | <-- componente 1, ( fila 1 )
|------|
| dato | ...
|------|
| dato | ...
|------|
| dato | ...
|------|
| dato | ...
|------|
| dato | <-- componente 6, ( fila 6 )
|------|

2.2.Array bidimensional
Un array bi-dimensional es aquel en donde los componentes son accesibles por medio
de una pareja de índices que apunten a la fila y a la columna del componente
requerido. Los arrays de este tipo son conocidos también con el nombre de matrices.
Conceptualmente, podemos pensar en un array bidimensional como en una lista
compuesta de filas y columnas, en donde para referirnos a una de ellas emplearemos
un número para indicar la posición de fila y otro número para indicar la posición de
la columna del componente deseado. Por ejemplo, consideremos el caso de la tabla o
array VentaSemanaQ, la cual está pensada para registrar las ventas de cada uno de los
días de la semana por cuatro semanas, o sea, una tabla de 7 x 4 elementos. De manera
conceptual podemos ver el array como se muestra a continuación: (Wikibooks, 2018)

array: Venta SemanaQ

C O L U M N A S

+--- componente ( 0, 0 )
|
+------+------+------+------+
| dato | dato | dato | dato |
|------|------|------|------|
F | dato | dato | dato | dato |
 Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil

|------|------|------|------|
I | dato | dato | dato | dato |
|------|------|------|------|
L | dato | dato | dato | dato |
|------|------|------|------|
A | dato | dato | dato | dato |
|------|------|------|------|
S | dato | dato | dato | dato |
|------|------|------|------|
| dato | dato | dato | dato |
+------+------+------+------+
|
+---- componente ( 6, 3 )

3. Declarar un array
Para declarar un vector en C++, se deben seguir las mismas normas básicas que se siguen
para declarar una variable cualquiera, con un pequeño cambio en la sintaxis. Para declarar
un vector, arreglo o como lo quieras llamar, necesitaremos saber el tipo de los datos que
irán al interior de este, es decir, serán número enteros, o numero decimales o cadenas de
texto, etc. necesitamos también, como siempre, un nombre para el vector y un tamaño
máximo. La sintaxis para declarar un vector en C++ es la siguiente:

tipo_de_dato nombre_del_vector[tamanio];

Tenemos entonces, tal como mencioné antes, que para declarar un vector en C++,
debemos definirle un tipo de los datos, sea entero, float, string, etc., debemos darle un
nombre y al interior de los corchetes "[]" debemos poner el tamaño máximo que tendrá
el vector, es decir la cantidad máxima de datos que podrá contener (recuerda que en C++
esto es necesario hacerlo). Veamos un ejemplo en el cual pondré la declaración de varios
vectores de diferentes tipos y tamaños en C++. (Tutorialspotint, 2018)

int my_vector1[10];
float my_vector2[25];
string my_vector3[500];
bool my_vector4[1000];
char my_vector5[2];
Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil
4. Ejemplo aplicativo

Ilustración 18: Programación de Array en c++

Ilustración 19: Ventana del programa c++

 Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil

BIBLIOGRAFÍA Y WEB GRAFÍA

González, J. D. (abril de 2018). PreogramarYa. Obtenido de

https://www.programarya.com/Cursos/C++/Ciclos/Ciclo-while
learn c++. (2015). Obtenido de https://www.programiz.com/cpp-programming/do-
while-loop
Paucar, J. (marzo de 2013). slideshare. Obtenido de
https://es.slideshare.net/jhonnyspch/arreglos-c
Santi. (noviembre de 2005). Codigo fuente. Obtenido de
http://codigomaldito.blogspot.com/2005/11/arreglos-o-arrays-en-c.html
Tutorialspotint. (2018). Obtenido de
https://www.tutorialspoint.com/cplusplus/cpp_arrays.htm
Wikibooks. (julio de 2018). Obtenido de
https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Arrays_y_
cadenas_de_texto
https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Sentencias/while
https://profvanessaborjas.wordpress.com/2013/03/19/ejemplos-con-for-while-y-do-
while/
https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Sentencias/while
https://programacionfusa.wordpress.com/miprueba/sentencia-while/
https://msdn.microsoft.com/en-us/library/b0kk5few.aspx
 Universidad Nacional del Escuela Profesional de
Altiplano – Puno Ingeniería Civil

ÍNDICE

INTRODUCCIÓN....................................................................................................................... 1
SENTENCIA WHILE ............................................................................................................ 2
1. Diagrama de flujo del ciclo while ................................................................................... 2
2. Sintaxis del ciclo while en c++ ........................................................................................ 2
3. Ejemplo aplicativo ........................................................................................................... 4
SENTENCIA DO-WHILE ..................................................................................................... 5
1. Diagrama de do- while en c++ ........................................................................................ 5
2. Sintaxis del ciclo do- while en c++.................................................................................. 5
3. Ejemplo aplicativo ........................................................................................................... 7
SENTENCIA FOR .................................................................................................................. 8
1. Diagrama de flujo del ciclo for ....................................................................................... 8
2. Sintaxis del ciclo for en c++ ............................................................................................ 8
3. Ejemplo aplicativo ......................................................................................................... 10
SENTENCIA SWITCH ................................................................................................................ 11
1. Diagrama de flujo de la sentencia switch .................................................................... 11
2. Sintaxis de la sentencia switch en c++ ......................................................................... 11
3. Ejemplo aplicativo ......................................................................................................... 14
ARREGLOS O ARRAY ............................................................................................................... 15
1. Índice de array............................................................................................................... 15
2. Dimensionalidad ............................................................................................................ 15
2.1. Array unidimensional ........................................................................................... 15
2.2. Array bidimensional ............................................................................................. 16
3. Declarar un array .......................................................................................................... 17
4. Ejemplo aplicativo ......................................................................................................... 18
BIBLIOGRAFÍA Y WEB GRAFÍA .................................................................................... 19