ALRRAYS Y CADENAS DE CARACTERES

Los arrays son usados extensamente por los programadores para contener listas de datos
en la memoria, por ejemplo, los datos almacenados en un disco suelen leerse y ponerse
dentro de un array con el objetivo de facilitar la manipulación de dichos datos, ya que los
datos en memoria pueden ser modificados, clasificados, marcados para su eliminacion,
etc. para luego ser reescritos al disco. Otro ejemplo podría ser el de un menú de opciones
que se desplegarán dentro de una ventana para que el usuario pueda elegir una de éstas,
en tales casos y cuando las opciones son numerosas, solamente se ponen unas cuantas
de ellas dentro de la ventana pero se le da al usuario la oportunidad de poder subir y bajar
a su antojo para ver el resto de opciones que, aunque no se vean en la ventana, forman
parte del menú o array de opciones.
Array:
Un array es un conjunto de datos del mismo tipo ordenados en forman líneal uno después
de otro. Los componentes de un array se han de referenciar por medio del nombre del
array y un índice de desplazamiento para indicar el componente deseado.

Indices de un 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 dirijirnos a un hotel específico es
necesario saber el nombre del mismo, luego, si queremos llegar a una habitación
específica de dicho hotel necesitaremos, además del nombre del hotel, el número de
habitación deseado.
Dimensiones de un array
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.
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 en una lista compuesta de líneas o filas en
donde para referinos a una de ellas emplearemos un número para indicar la posición de la
misma dentro de la lista. Por ejemplo, consideremos el caso de la tabla o array
VentaSemanal, la cual está pensada para registrar las ventas de cada uno de los días de
la semana. De manera conceptual podemos ver el array como se muestra a continuación:
Nota: en C++ los arrays están basados en 0 ( cero ), es decir, el primer elemento de un
array se indexa mediante el 0, y el índice para el último de los elementos es igual al
número de componentes menos uno.

array: VentaSemanal

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

Si en el array VentaSemanal queremos que el elemento 4 ( por ejemplo ) contenga el

valor de 8987 lo podemos lograr con la instrucción: VentaSemanal[4] = 8987; y el estado
del array sería:

array: VentaSemanal

+------+
| dato |
|------|
| dato |
|------|
| dato |
|------|
| dato |
|------|
| 8987 | <--- componente 4
|------|
| dato |
|------|
| dato |
|------|

Array bidimensional
Una 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 4elementos. De manera
conceptual podemos ver el array como se muestra a continuación:

array: VentaSemanaQ

C O L U M N A S

+--- componente ( 0, 0 )
|
+------+------+------+------+
| dato | dato | dato | dato |
|------|------|------|------|
F | dato | dato | dato | dato |
|------|------|------|------|
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 )

Si en el array VentaSemanaQ queremos que el elemento de la fila 4, columna 3 ( por

ejemplo ) contenga el valor de 5000 lo podemos lograr con la
instrucción: VentaSemanaQ[4][3] = 5000; y el estado del array sería:
array: VentaSemanaQ

+--- componente ( 0, 0 )
|
+------+------+------+------+
| dato | dato | dato | dato |
|------|------|------|------|
| dato | dato | dato | dato |
|------|------|------|------|
| dato | dato | dato | dato |
|------|------|------|------|
| dato | dato | dato | dato |
|------|------|------|------|
| dato | dato | dato | 5000 | <-- componente ( 4, 3 )
|------|------|------|------|
| dato | dato | dato | dato |
|------|------|------|------|
| dato | dato | dato | dato |
+------+------+------+------+
|
+---- componente ( 6, 3 )

Declaración de arrays en C, C++

En C, C++ para declarar un array se emplea la sintaxis:

tipo identificador [tamaño] = { lista de inicialización } ;

donde,

 tipo se refiere al tipo de datos que contendrá el array. El tipo puede ser cualquiera
de los tipos estándar (char, int, float, etc.) o un tipo definido por el usuario. Es más, el
tipo del array puede ser de una estructura creada con: struct, union y class.

 identificador se refiere al nombre que le daremos al array.

 tamaño es opcional e indica el número de elementos que contendrá el array. Si un
array se declara sin tamaño, el mismo no podrá contener elemento alguno a menos
que en la declaración se emplee una lista de inicialización.

 lista de inicialización es opcional y se usa para establecer valores para cada uno
de los componentes del array. Si el array es declarado con un tamaño específico, el
número de valores inicializados no podrá ser mayor a dicho tamaño.

Ejemplos:
int intA[5];
long longA[5] = { 1, 2, 3, 4, 5 };
char charA[3] = { 'a', 'b', 'c' };

Interacciones dentro de un array (vector)

El termino Iterar se refiere al hecho de acceder (con el fin de leer o escribir) sobre cada
uno de los componentes de un array. Así, para poner un ejemplo reconsideremos el caso
de la tabla VentaSemanal (vista en una sección anterior), y que dicho sea de paso es un
array de 7 elementos de tipo double. Luego, vamos a mostrar como ejemplo un programa
completo en el cual se declara el array mencionado con valores inicializados, que serán
mostrados en pantalla y al final la suma de estos. Observe que la variable i usada para
iterar dentro del array va desde 0 hasta FILAS - 1 ( FILAS es el tamaño del array ).

Nota: por motivos de simplificación el programa está escrito al estilo de C estándar. Sin
embargo puede ser compilado y ejecutado en un compilador de C++.

#include <stdio.h>
#include <stdlib.h>

#define FILAS 7

int main()
{
 float ventas[FILAS] = {
123.50, 234.60, 345.45, 321.40, 345.00, 456.65, 0.0 };

float total = 0;
int i;

puts("Ventas de la semana");
puts("-------------------");

for (i=0; i<FILAS; i++) {

total += ventas[i];
printf( "%8.2f\n", ventas[i] );
}

puts("--------");
printf("%8.2f\n", total );

system("pause");
return 0;
}

Esta es la salida del programa:

Ventas de la semana
-------------------
123.50
234.60
345.45
321.40
345.00
456.65
0.00
--------
1826.60

Interacciones dentro de un array (matriz)

Con el fin de leer o escribir sobre cada uno de los componentes de una matriz se deben
crear dos ciclos de iteración. Así, para poner un ejemplo reconsideremos el caso de la
tabla VentaSemanaQ (vista en una sección anterior), y que dicho sea de paso es un array
de 4 x 4 elementos de tipo double. Luego, vamos a mostrar como ejemplo un programa
completo en el cual se declara el array mencionado con valores inicializados, que serán
mostrados en pantalla y al final la suma de estos. Observe que en este caso se utilizan
dos variables, una para iterar sobre las filas y otra para iterar sobre las columnas de la
matriz.

#include <stdio.h>
#include <stdlib.h>
//hola
#define FILAS 7
#define COLS 4

int main()
{
float VentaSemanaQ[FILAS][COLS] = {
123.50, 234.60, 345.45, 321.40,
345.00, 456.65, 123.50, 234.60,
345.45, 321.40, 345.00, 456.65,
123.50, 234.60, 345.45, 321.40,
345.00, 456.65, 123.50, 234.60,
345.45, 321.40, 345.00, 456.65,
0.0, 0.0, 0.0, 0.0 };

float totales[COLS] = { 0.0, 0.0, 0.0, 0.0 };

float grantotal = 0;

int f, c, t = 0 ; /* indices para filas, columnas y totales */

puts("Ventas de cuatro semanas");

puts("------------------------");

for (f=0; f<FILAS; f++) {

for (c=0; c<COLS; c++) {
totales[c] += ventas[f][c];
printf("%8.2f ", ventas[f][c] );
}
puts("");
}

puts("--------------------------------------");
for (t=0; t<COLS; t++) {
printf("%8.2f ", totales[t] );
grantotal += totales[t];
}
 printf("\n\nGran total: %10.2f\n", grantotal);
system("pause");
return 0;
}

Salida del programa:

Ventas de cuatro semanas

------------------------
123.50 234.60 345.45 321.40
345.00 456.65 123.50 234.60
345.45 321.40 345.00 456.65
123.50 234.60 345.45 321.40
345.00 456.65 123.50 234.60
345.45 321.40 345.00 456.65
0.00 0.00 0.00 0.00
--------------------------------------
1627.90 2025.30 1627.90 2025.30

Gran total: 7306.40