PDF de programación - Tema 9. Vectores y Matrices

Tema 9. Vectores y Matrices

OBJETIVO
En temas anteriores hemos declarado variables simples de tipo int, float, o de cualquier otro tipo sim-
ple. A menudo necesitaremos declarar una colección de variables, tales como 20 enteros. En este tema
veremos cómo podemos declarar arrays vectores y matrices, que reciben el nombre genérico de arrays.

Por otro lado, C no tiene datos predefinidos tipo cadena. En su lugar, C manipula cadenas de caracteres
mediante arrays de caracteres que terminan con el carácter nulo ASCII ('\0'). Una cadena se considera
como un vector de tipo char o unsigned char.

Bibliografía

• Joyanes Aguilar, J. “Programación en C++. Algoritmos, estructuras de datos y Objetos”. Capítulos 7 y

9. Ed. McGraw-Hill.

• Pont, M.J. “Software Engineering with C++ and CASE Tools”. Capítulo 7. Pointers and arrays. Ed.

Addison-Wesley.

CONTENIDOS



1. ¿Qué es un Array?

1.1. Elementos de un Array
1.2. Declaración de arrays
1.3. Asignación de valores fuera del array
1.4. Inicialización de un array

2. Matrices (arrays multidimensionales)

2.1. Inicialización de arrays multidimensionales

3. Cadena de caracteres

3.1. Lectura de cadenas
3.2. Manejo de cadenas

1
2
3
4
6
6
7
9
10
11

1. ¿Qué es un Array?
Un array es una colección de posiciones de almacenamiento de datos, todos ellas con el mismo tipo de
dato. Cada posición de almacenamiento se denomina elemento del array. Denominaremos vector a un
array unidimensional, y matriz a un array multidimensional.

Para declarar un vector escribimos el tipo de dato, seguido del nombre del vector y del subíndice. El sub-
índice es el número de elementos del vector, encerrado entre corchetes. Por ejemplo,

long vectorLargo[25];

declara un vector de 25 enteros largos, llamado vectorLargo. Cuando el compilador encuentra esta de-
claración reserva la memoria necesaria para los 25 elementos. Puesto que cada entero necesita 4 bytes,
esta declaración reserva 100 bytes contiguos de memoria, como se ilustra en la figura 9.1.

Vectores y Matrices



2


Figure 9.1. Declaración de un vector.

1.1. Elementos de un vector
Para acceder a los elementos del vector debemos tomar como base el nombre del vector. Los elementos
del vector de cuentan a partir de cero, por tanto el primer elemento es NombreVector[0]. En el ejemplo
anterior, VectorLargo[0] es el primer elemento del vector VectorLargo, VectorLargo[1] el segundo y
así sucesivamente.
Esto puede resultar confuso. El vector Vector[3] tiene tres elementos: Vector[0], Vector[1] y
Vector[2]. En general, Vector[n] tiene n elementos, que van desde el Vector[0] hasta el Vector[n-
1]. Por lo tanto, VectorLargo[25] se numera desde VectorLargo[0] hasta VectorLargo[25]. El listado
9.1 muestra cómo declarar un vector de 5 enteros e inicializarlos con un valor.



Programa 9.1: Uso de un vector entero

1: // Listado 9.1: Vectors
2: #include <stdio.h>
3:
4: int main()
5: {
6: int Vector1[5];
7: int i;
8: for ( i=0; i<5; i++) // 0-4
9: {
10: printf("Valor para Vector1[%d]: ", i);
11: scanf("%d", &Vector1[i]);
12: }
13: for (i = 0; i<5; i++)
14: printf("%d: %d\n", i, Vector1[i]);
15: return 0;
16: }

Salida

Valor para Vector1[0]: 1
Valor para Vector1[1]: 2
Valor para Vector1[2]: 3
Valor para Vector1[3]: 4
Valor para Vector1[4]: 5
0: 1
1: 2

Vectores y Matrices

3



2: 3
3: 4
4: 5

Análisis:
La línea 6 declara un vector llamado Vector1, que contiene cinco variables enteras. La línea 8 establece
un bucle que cuenta de 0 a 4, que es el adecuado conjunto de desplazamientos para un vector de cinco
elementos. Los sucesivos valores introducidos por el usuario son asignados a los correspondientes ele-
mentos del vector. El segundo bucle imprime cada uno de los valores del vector en la pantalla.

NOTA: los vectores cuentan desde 0, no desde 1. Este es el origen de muchos errores en programas C
escritos por principiantes. Siempre que utilices un vector, recuerda que un vector con 10 elementos
cuenta desde NombreVector[0] hasta NombreVector[9]. NombreVector[10] no se usa.

1.2. Declaración de vectores
Un vector puede tener cualquier nombre que cumpla los requisitos para ser nombre o identificador de
una variable, pero no puede tener el mismo nombre que otra variable o vector del mismo ámbito. Por lo
tanto, no podemos tener un vector llamado Tabla[5] y una variable llamada Tabla al mismo tiempo.

Podemos dimensionar el tamaño de un vector con una constante o con una enumeración. El listado 9.2
ilustra este hecho.

Programa 9.2: Uso de constantes y enumeraciones en arrays

1: // Listado 9.2
2: // Dimensionado de vectores con constantes y enumeraciones
3:
4: #include <stdio.h>
5: int main()
6: {
7: enum DiasSemana { Lunes, Martes, Miercoles, Jueves,
8: Viernes, Sabado, Domingo, DiasEnSemana };
9: int ArraySemana[DiasEnSemana] = { 10, 20, 30, 40, 50, 60, 70 };
10:
11: printf("El valor en viernes es: %d", ArraySemana[Viernes]);
12: return 0;
13: }



El valor en viernes es: 50

Salida

Análisis:
La línea 7 crea una enumeración llamada DiasSemana que tiene ocho miembros. Lunes es igual a cero,
y DiasEnSemana es igual a 7.

Vectores y Matrices



4

La línea 11 usa la constante enumerada viernes como índice del vector. Puesto que viernes vale 4, el
quinto elemento del vector, ArraySemana[4] se imprime en pantalla.

1.3. Asignación de valores fuera del vector
Cuando asignamos un valor a un elemento de un vector, el compilador calcula la posición de memoria
donde tiene que almacenar dicho valor a partir del subíndice. Supongamos que queremos asignar un va-
lor a ArrayLargo[5], que es el sexto elemento del vector. El compilador multiplica el subíndice (5) por el
tamaño del dato (int = 4 bytes). Después se desplaza desde el principio del vector tantos bytes como in-
dique el resultado de la multiplicación anterior (20), y escribe el nuevo valor en esa posición. Si tenemos
suerte, el programa fallará inmediatamente.
Si queremos asignar un valor a ArrayLargo[50], el compilador ignora el hecho de que dicho elemento no
existe. Solamente calcula el desplazamiento a realizar desde el primer elemento (200 bytes) y escribe el
valor en dicha posición. Esta posición puede estar reservada para otra variable, y escribir un valor en di-
cha posición puede tener resultados imprevistos. Si no es así, es posible que el programa falle más ade-
lante, y será difícil determinar el por qué ha fallado.

El compilador actúa como un ciego que cuenta por pasos la distancia desde una casa. Comienza en la pri-
mera casa, PaseoZorrilla[0]. Cuando le pedimos que vaya a la sexta casa del Paseo Zorrilla, él se dice:
“Debo ir cinco casas más allá. Cada casa mide cuatro pasos largos. Por tanto, debo andar 20 pasos”. Si le
pedimos que vaya a PaseoZorrilla[100] y el Paseo Zorrilla solo tiene 75 casas, él contará 400 pasos, y
con mucha probabilidad, se pare delante… ¡de un autobús! El listado 9.3 muestra lo que sucede cuando
escribimos valores más allá del final del vector.

PRECAUCIÓN: ¡No ejecutes este programa, puede bloquear tu ordenador!

Programa 9.3: Cuidado con el final de un vector

1: /* Listado 7.7
2: Ejemplo de lo que ocurre cuando escribimos mas alla
3: del final de un array */
4:
5: #include <stdio.h>
6: int main()
7: {
8: short calleUno[3];
9: short paseoZorrilla[20]; // array a rellenar
10: short calleDos[3];
11: int i;
12: for (i=0; i<3; i++)
13: {
14: calleUno[i] = -1; calleDos[i] = -2;
15: }
16:
17: for (i=0; i<=25; i++)
18: paseoZorrilla[i] = i;
19:
20: printf("Test 1: \n");
21: printf("paseoZorrilla[0] : %d \n", paseoZorrilla[0]);
22: printf("paseoZorrilla[20]: %d \n", paseoZorrilla[20]);
23:
24: printf("\nAsignando...");
25: paseoZorrilla[21] = 21;

Vectores y Matrices

5



26:
27: printf("\nTest 2: \n");
28: printf("paseoZorrilla[0] : %d\n", paseoZorrilla[0] );
29: printf("paseoZorrilla[20]: %d\n", paseoZorrilla[20]);
30: printf("paseoZorrilla[21]: %d\n", paseoZorrilla[21]);
31: for (i = 0; i<3; i++)
32: printf("calleUno[%d]: %d\n", i, calleUno[i]);
33:
34: for (i = 0; i<3; i++)
35: printf("calleDos[%d]: %d\n", i, calleDos[i]);
36:
37: return 0;
38: }

Salida del programa

Test 1:
paseoZorrilla[0] : 0
paseoZorrilla[20]: 20

Asignando...
Test 2:
paseoZorrilla[0] : 0
paseoZorrilla[20]: 20
paseoZorrilla[21]: 21
calleUno[0]: 20
calleUno[1]: 21
calleUno[2]: -1
calleDos[0]: -2
calleDos[1]: -2
calleDos[2]: -2

Análisis:

Primero se declaran dos vectores de tres enteros que actúan como centinelas alrededor de
paseoZorrilla. Estos vectores centinelas se inicializan con los valores -1 y -2. Si escribimos algo en la
memoria después del final de paseoZorrilla, alguno de los centinelas cambiará probablemente de valor.
Algunos ordenadores asignan memoria de arriba abajo (de direcciones altas a direcciones bajas) mientras
que otros lo hacen de abajo hacia arriba (de direcciones bajas a direcciones altas). Por esta razón, hemos
colocado centinelas a ambos lados de paseoZorrilla.
Después se asignan valores a los miembros de paseoZorrilla, pero el contador cuenta hasta los subín-
dices 20 y 21, que no existen en paseoZorrilla.
Podemos observar que al imprimir paseoZorrilla[20] se escribe sin ningún problema el valor 20. Sin
embargo, cuando se imprimen calleUno y calleDos, observamos que calleUno[0] ha cambiado. Esto
se debe que la zona de memoria de paseoZorrilla[20] coincide con la zona de memoria de
calleUno[0].

Vectores y Matrices



6

1.4. Inicialización de un vector
Se puede inicializar una vector de ti