Embed Size (px)
Citation preview
TEMA 5
Datos estructurados
5.1.1. Arrays unidimensionales
Antonio L. Carrillo
2
5.1. Arrays 5.1.1. Arrays Unidimensionales.
- Concepto, Definiciones de tipo array, y declaración de arrays - Acceso a los elementos de un array - Inicialización de arrays - Observaciones (operaciones permitidas y no permitidas). - Arrays en funciones.
5.1.2. Búsqueda y Ordenación. 5.1.3. Arrays Multidimensionales.
- Concepto. Declaración. - Acceso a los elementos.
- Inicialización de arrays multidimensionales (matrices, cubos,…) - Arrays multidimensionales en funciones.
5.2. Estructuras y Arrays de estructuras
Tema 5: DATOS ESTRUCTURADOS
3
Arrays Unidimensionales (en C++): Introducción
Un array representa un conjunto, de tamaño determinado (y definido en tiempo de compilación), de elementos de un mismo tipo (de dato). Los arrays son útiles en aquellas situaciones en que necesitamos almacenar y manipular una colección de valores, y acceder a ellos de forma parametrizada, normalmente para aplicarles un proceso iterativo. Por ejemplo, podríamos estar interesados en almacenar las notas de los 50 alumnos de un curso y, posteriormente, calcular la media de todas las notas, y luego contar cuantos aprueban (porque superan esa nota media).
En este caso, el programador puede definir un nuevo tipo de dato (un tipo concreto de array: con espacio para 50 valores, todos ellos de tipo float), y posteriormente, crear una variable de ese tipo donde poder ya guardar las notas. Para ello, usaremos el tipo array de la biblioteca estándar de C++ del año 2011 (C++11), por lo que habrá que incluir la biblioteca con ese nombre:
à #include <array> También puede ser necesario modificar algún parámetro en el entorno de programación, para indicar que se desea usar ese estándar.
4
Arrays Unidimensionales (en C++): Introducción
Un tipo array concreto se especifica o define utilizando typedef (indicando así que estamos definiendo un nuevo tipo de dato), seguido de una descripción de las características de dicho tipo, y de un nombre con el que identificarlo a partir de ese momento.
Las carácterísticas del nuevo tipo se describen utilizando la palabra array, e indicando cómo son sus valores: el nº de elementos, y el tipo base de todos ellos (el mismo para todos). Dicho tipo base puede ser simple o compuesto, predefinido o definido por el programador. El nº de elementos debe ser una constante, conocida en tiempo de compilación.
Cuando posteriormente se declare una constante o variable de este tipo, se obtendrá espacio en memoria para almacenar tantos elementos como tamaño indique ese tipo array; y se podrá acceder a cada uno de esos elementos o componentes del array, a través de la posición que ocupe, sabiendo que: - la posición de la primera componente (donde estará el primer valor) es la 0, - y la de la última componente coincidirá con el nº máximo de elementos del array, menos uno (o sea, si hay 50 elementos, la posición del último será la 49).
5
• ACCESO a cada elemento: - Mediante un índice (posición): variable_array[indice]
- Los índices (o posiciones) van desde 0 hasta el TAMAÑO-1.
typedef array< tipo_elemento, TAMAÑO> nombre_Tipo_Array
Un array es una colección de datos del mismo tipo, con el mismo nombre, y a los que se accede por su posición.
• DEFINICIÓN de un nuevo Tipo array:
Arrays Unidimensionales (en C++): Declaración y Acceso
constante
cte, vble, o expresión
nombre_Tipo_Array variable_array;
• DECLARACIÓN de una Variable de tipo array:
#include <array> using namespace std;
6
• EJEMPLO:
• VENTAJAS de su uso frente a variables aisladas:
- Podemos referirnos a todos los elementos a la vez (al declararlos,
al pasarlos a una función, etc).
- Permite resolver problemas de forma sencilla y compacta.
a a[0] a[1] a[2] a[3] a[4]!
typedef array<int, 5> TAenteros
TAenteros a;!
Arrays Unidimensionales: Declaración y Acceso
0 1 2 3 4
7
¿Cómo se ALMACENAN en MEMORIA? Todos los elems CONTIGUOS.
c a Elemento 0 1 2 3 4 0 1 2 3 4 Dirección 1000 1001 1002 1003 1004 1000 1002 1004 1006 1008
Suponemos que ambos arrays comienzan en la posición 1000, que un short ocupa 2 bytes y un char ocupa 1 byte (cada número de posición indica 1 byte).
EJEMPLOS: Arrays Unidimensionales: Declaración y Acceso
typedef array<char, 5> TAcaracteres;
TAcaracteres c; // Declara un array de 5 caracteres, // desde c[0] hasta c[4]
typedef array<short, 5> TAnumeros;
TA5short a; // Declara un array de 5 short, // desde a[0] hasta a[4]
8
q Inicialización y asignación:
Ø Inicialización en la declaración:
- Completa
- Incompleta
Ø Asignación en ejecución: - A un elemento
- A todos los elementos
Tarray vector1 = {{8,5,3,0,1}};
Tarray vector2 = {{8,5}}; 10
? 5 8
2
vector2
3
? ?
4
vector2[3] = 7;
for(i=0;i<=4;i++) vector2[i] = i;
Arrays Unidimensionales: Inicialización
typedef array<int,5> Tarray;
10
3 5 8
2
vector1
3
1 0
4
10
? 5 8
2
vector2
3
? 7
4
10
2 1 0
2
vector2
3
4 3
4
9
q Se permite la asignación y la comparación completa de arrays:
q A todos los efectos, cualquier elemento de un array se puede procesar como una variable del mismo tipo del elemento:
q A diferencia de otros lenguajes de programación, C no chequea que los índices estén dentro del rango válido para el array:
typedef array<int,3> Tarray; Tarray a, b={10,20,30}; ... a = b;
for(i=0; i<=2; i++) a[i] = b[i];
int suma=0; cin >> a[2]; // machaca el 30 cout << a[0]; // imprime el 10 suma += a[1]; // suma el 20 //NO SE PUEDE: cout << a; NI TAMPOCO: cin >> a; //HAY QUE ESCRIBIR O LEER CADA ELEMENTO, UNO A UNO.
a[3]= 100; b[5]= 100;
ERROR: solo existen las posiciones 0, 1 y 2 à Nos salimos del array à ¿qué pasará?
Arrays Unidimensionales: observaciones
10
• El paso de arrays como parámetros a una función se realiza como si fuesen datos simples, y por tanto, se pueden: - pasar por valor (si se tratan de parámetros de Entrada)
- pasar por referencia (si son parám. de Salida, o de Entrada/Salida) - incluso se puede devolver un array como valor de retorno
• En la LLAMADA a una función, si un argumento actual es un array (ya sea de E., de S., o de E/S), se pone sólo el nombre del array (sin corchetes)
• En la CABECERA de una función, si el array es un: • Parám. de ENTRADA (la función sólo necesita conocer los valores)
à NO se pone el & • Parám. de SALIDA, o de E/S (la función puede modificar los valores)
à SI se pone el &
Arrays Unidimensionales en Funciones
11
• Ejemplo: Definción de función que calcule y devuelva, como parámetro de salida, el vector suma de 2 vectores (de 100 valores como maximo, de tipo float cada uno), recibidos como parámetros de entrada. Suponga que los arrays tendrán el mismo tamaño, pero no tiene por qué coincidir con el tamaño máximo reservado (es decir, no tienen por qué estar llenos los arrays de entrada):
typedef array<int,100> Tarr; ... void suma_arrays(Tarr a1, Tarr a2, int tam, Tarr & suma ) {
for (int i=0; i < tam; i++ )
suma[i] = a1[i] + a2[i];
} • Si en la función se necesita conocer el tamaño ocupado de un array (la cantidad
de elementos a considerar del array), se le deberá pasar como parámetro (tam, en el ejemplo).
Arrays Unidimensionales: como Argumentos en Funciones
12
... /* calcular producto escalar de dos vectores */ const int TMAX = 10; //Tamaño máximo de los vectores typedef array<int, TMAX> Tarray;
Tarray leer_vector1( int tam ); // lo devolverá con el return
void leer_vector2( Tarray & vec, int tam ); // lo dev. como param.Sal.
int prod_escalar( Tarray v1, Tarray v2, int tam ); //---------------------------------------------------
int main() { Tarray v1, v2; int prod; /* supongamos, por ejemplo, que ahora mismo queremos
trabajar sólo con 6 valores de los 10 que cabrían */
cout << “INTRODUCE 6 VALORES 1er VECTOR: ”;
v1 = leer1_vector( 6 ); cout << “INTRODUCE 6 VALORES 2º VECTOR: ”;
leer2_vector( v2, 6 ); // prod = prod_escalar( v1, v2, 6 ); cout << “\n Prod. Escalar = ” << prod; ...
}
Arrays Unidimensionales: como Argumentos en Funciones
13
Arrays Unidimensionales: como Argumentos en Funciones
/* Cálculo de la varianza de N números σ2= E(X2) - E(X)*E(X) donde E() es la esperanza matemática (la media) */ typedef array<double,10> Tarr; // Devuelve esperanza array float media( Tarr a, int tam) { int i; double = 0.0; for( i=0; i<tam; i++ ) s = s + a[i]; return (s/tam); } // array al cuadrado void potencia( Tarr a1[], Tarr & a2[], int tama){ int i; for( i=0; i<tama; i++ ) a2[i] = a1[i] * a1[i]; }
int main() { Tarr v1,v2; double m1,m2; int i, n; do{ cout<<“Tamaño(max.10)?”; cin >> n; }while(n>10); for( i=0; i<n; i++ ) { cout <<“Intro elem ”<< i; cin >> v1[i]; } m1 = media(v1,n); potencia(v1,v2,n); m2 = media(v2,n); cout << “Varianza= ”; cout << m2-(m1*m1); }
