 2003 Prentice Hall, Inc. All rights reserved. 1 Capítulo 4 - Arrays Índice del Capítulo 4.1Introducción 4.2Arrays 4.3Declaración de Arrays 4.4Ejemplos de uso de Arrays 4.5Paso de Arrays a Funciones 4.6Ordenación de Arrays 4.7Ejemplo: Cálculo de Media, Mediana y Moda usando Arrays 4.8Búsqueda en Arrays: Búsqueda Lineal y Búsqueda Binaria 4.9Arrays Multidimensionales

 2003 Prentice Hall, Inc. All rights reserved Introducción Arrays –Estructuras de datos consistente en elementos de datos relacionados del mismo tipo. –Entidad estática (mismo tamaño durante toda la ejecución del programa) Tipos –Basados en punteros (tipo C) –Arrays como objetos (C++)

 2003 Prentice Hall, Inc. All rights reserved Arrays Array –Grupo de localizaciones consecutivas de memoria –Mismo nombre y tipo ( int, char, etc.) Para hacer referencia a un elemento: –Especificamos nombre del array y número de posición (índice) –Formato: nombrearray[ número_posición ] –El primer elemento está en la posición 0 Array c de n elementos: c[ 0 ], c[ 1 ] … c[ n - 1 ] –Elemento n-ésimo en la posición n-1

 2003 Prentice Hall, Inc. All rights reserved Arrays Los elementos de un array son como otras variables –Asignación, impresión de un array de enteros c c[ 0 ] = 3; cout << c[ 0 ]; Número de posición=índice. –Índice= entero o expresión entera –Se pueden realizar operaciones sobre el índice c[ 5 – 2 ] es lo mismo que c[3]

 2003 Prentice Hall, Inc. All rights reserved Arrays c[6] Nombre del array (Notad que todos los elementos de este array tienen el mismo nombre, c) c[0] c[1] c[2] c[3] c[11] c[10] c[9] c[8] c[7] c[5] c[4] Número de posición del elemento dentro de array c Imprimo la suma de los 3 primeros elementos del array: cout << c[0] + c[1] + c[2] << endl; Divido el valor del 7º elemento por 2 y lo asigno a la variable x: x = c[6] / 2;

 2003 Prentice Hall, Inc. All rights reserved Declaración de Arrays Cuando se declaran arrays, hay que especificar: –Nombre –Tipo del array Cualquier tipo de datos –Número de elementos –tipo nombreArray [ tamañoArray ]; int c[ 10 ]; // array de 10 enteros float d[ 3284 ]; // array de 3284 floats Declaración de varios arrays del mismo tipo: –Lista separada por comas, como las variables int b[ 100 ], x[ 27 ];

 2003 Prentice Hall, Inc. All rights reserved Ejemplos de Uso de Arrays Inicialización de arrays –Lazo for Dar un valor inicial a cada elemento dentro de un lazo –Lista de inicialización Se especifica cada valor al declarar el array int n[ 5 ] = { 1, 2, 3, 4, 5 }; Si no hay suficientes valores iniciales, los más a la derecha se fijan a 0 Si hay demasiados valores iniciales: error de sintaxis –Para fijar todos los elementos al mismo valor int n[ 5 ] = { 0 }; –Si se omite el tamaño del array, la lista de valores iniciales determina su tamaño int n[] = { 1, 2, 3, 4, 5 }; 5 valores iniciales, por tanto array de 5 elementos

 2003 Prentice Hall, Inc. All rights reserved. Outline 8 1 // Fig. 4.3: fig04_03.cpp 2 // Declaración de array e Inicialización de elementos usando lazo for. 3 #include 4 5 using std::cout; 6 using std::endl; 7 8 #include 9 10 using std::setw; int main() 13 { 14 int n[ 10 ]; // n es un array de 10 enteros // inicializo los elementos del array n a 0 17 for ( int i = 0; i < 10; i++ ) 18 n[ i ] = 0; // fijo el elemento en la localización i a cout << "Elemento" << setw( 13 ) << "Valor" << endl; // imprimo contenidos de array n en formato tabular 23 for ( int j = 0; j < 10; j++ ) 24 cout << setw( 7 ) << j << setw( 13 ) << n[ j ] << endl; return 0; } Declaración de un array de 10 elementos enteros. Inicialización del array a 0 usando un lazo for. Nótese que el array tiene los elementos de n[0] a n[9].

 2003 Prentice Hall, Inc. All rights reserved. Outline 9 Elemento Valor

 2003 Prentice Hall, Inc. All rights reserved. Outline 10 1 // Fig. 4.4: fig04_04.cpp 2 // Inicialización del array en la declaración mediante lista de valores iniciales. 3 #include 4 5 using std::cout; 6 using std::endl; 7 8 #include 9 10 using std::setw; int main() 13 { 14 // uso lista de valores iniciales para inicializar array n 15 int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 }; cout << "Elemento" << setw( 13 ) << "Valor" << endl; // output contents of array n in tabular format 20 for ( int i = 0; i < 10; i++ ) 21 cout << setw( 7 ) << i << setw( 13 ) << n[ i ] << endl; return 0; } Nótese el uso de la lista de valores iniciales.

 2003 Prentice Hall, Inc. All rights reserved. Outline 11 Elemento Valor

 2003 Prentice Hall, Inc. All rights reserved Ejemplos de uso de Arrays Especificación del tamaño del array mediante una constante –Puede especificarse mediante una ¿variable constante? ( const ) const int size = 20; –Las constantes no pueden modificarse –Las constantes deben inicializarse al declararlas –También llamadas constantes con nombre o variables de sólo lectura

 2003 Prentice Hall, Inc. All rights reserved. Outline 13 1 // Fig. 4.5: fig04_05.cpp 2 // Especificación tamaño array con constante. Inicialización con cálculos. 3 #include 4 5 using std::cout; 6 using std::endl; 7 8 #include 9 10 using std::setw; int main() 13 { 14 // constante que especifica el tamaño del array 15 const int arraySize = 10; int s[ arraySize ]; // el array s tiene 10 elementos for ( int i = 0; i < arraySize; i++ ) // fijo los valores 20 s[ i ] = * i; cout << "Elemento" << setw( 13 ) << "Valor" << endl; // salida de contenido del array s en formato tabular 25 for ( int j = 0; j < arraySize; j++ ) 26 cout << setw( 7 ) << j << setw( 13 ) << s[ j ] << endl; return 0; } Nótese el uso de la palabra clave const. Sólo las variables const pueden especificar tamaños de arrays. El programa se vuelve más escalable cuando fijamos el tamaño del array usando una variable const. Podemos cambiar arraySize, y todos los lazos seguirán funcionando (de otro modo, tendríamos que actualizar cada lazo del programa).

 2003 Prentice Hall, Inc. All rights reserved. Outline 14 Elemento Valor

 2003 Prentice Hall, Inc. All rights reserved. Outline 15 1 // Fig. 4.6: fig04_06.cpp 2 // Uso de una variable constante correctamente inicializada. 3 #include 4 5 using std::cout; 6 using std::endl; 7 8 int main() 9 { 10 const int x = 7; // variable constante inicializada cout << "El valor de la variable constante x es: " 13 << x << endl; return 0; } El valor de la variable constante x es: 7 Inicialización correcta de la variable const.

 2003 Prentice Hall, Inc. All rights reserved. Outline 16 1 // Fig. 4.7: fig04_07.cpp 2 // Un objeto constante debe inicializarse. 3 4 int main() 5 { 6 const int x; // Error: x debe inicializarse 7 8 x = 7; // Error: no se puede modificar una variable constante 9 10 return 0; } d:\cpphtp4_examples\ch04\Fig04_07.cpp(6) : error C2734: 'x' : const object must be initialized if not extern d:\cpphtp4_examples\ch04\Fig04_07.cpp(8) : error C2166: l-value specifies const object const no inicializada causa un error de sintaxis. Intentar modificar la const es otro error.

 2003 Prentice Hall, Inc. All rights reserved. Outline 17 1 // Fig. 4.8: fig04_08.cpp 2 // Cálculo de la suma de las componentes de un array. 3 #include 4 5 using std::cout; 6 using std::endl; 7 8 int main() 9 { 10 const int arraySize = 10; int a[ arraySize ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int total = 0; // suma contenidos del array a 17 for ( int i = 0; i < arraySize; i++ ) 18 total += a[ i ]; cout << "La suma de los elementos del array es " << total << endl; return 0; } La suma de los elementos del array es 55

 2003 Prentice Hall, Inc. All rights reserved. Outline 18 1 // Fig. 4.9: fig04_09.cpp 2 // Gráfico de los valores de los elementos de un array con histogramas. 3 #include 4 5 using std::cout; 6 using std::endl; 7 8 #include 9 10 using std::setw; int main() 13 { 14 const int arraySize = 10; 15 int n[ arraySize ] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 }; cout << "Elemento" << setw( 13 ) << "Valor" 18 << setw( 17 ) << "Histograma" << endl; // para cada elemento del array n, imprimo una barra en histograma 21 for ( int i = 0; i < arraySize; i++ ) { 22 cout << setw( 7 ) << i << setw( 13 ) 23 << n[ i ] << setw( 9 ); for ( int j = 0; j < n[ i ]; j++ ) // imprimo una barra 26 cout << '*'; Imprime asteriscos correspondientes al tamaño del elemento n[i] del array.

 2003 Prentice Hall, Inc. All rights reserved. Outline cout << endl; // siguiente línea de salida } // fin de estructura externa return 0; } Elemento Valor Histograma 0 19 ******************* 1 3 *** 2 15 *************** 3 7 ******* 4 11 *********** 5 9 ********* 6 13 ************* 7 5 ***** 8 17 ***************** 9 1 *

 2003 Prentice Hall, Inc. All rights reserved. Outline 20 1 // Fig. 4.10: fig04_10.cpp 2 // Tirar un dado 6000 veces y totalizar resultados en un array. 3 #include 4 5 using std::cout; 6 using std::endl; 7 8 #include 9 10 using std::setw; #include 13 #include int main() 16 { 17 const int arraySize = 7; 18 int frecuencia[ arraySize ] = { 0 }; srand( time( 0 ) ); // semilla del generador de números aleatorios // tiro el dado 6000 veces 23 for ( int tirada = 1; tirada <= 6000; tirada++ ) 24 ++frecuencia[ 1 + rand() % 6 ]; // reemplaza el switch de // líneas de la Fig. 3.8 Reescribimos el programa visto de tirar un dado. Se usa un array en vez de 6 variables, y así el elemento puede actualizarse fácilmente (sin necesidad de un switch ). Se crea un número entre 1 y 6, que determina el índice de frecuencia[] que se debe incrementar.

 2003 Prentice Hall, Inc. All rights reserved. Outline cout << "Cara" << setw( 13 ) << "Frecuencia" << endl; // Imprime la frecuencia de los elementos 1-6 en formato tabular 30 for ( int cara = 1; cara < arraySize; cara++ ) 31 cout << setw( 4 ) << cara 32 << setw( 13 ) << frecuencia[ cara ] << endl; return 0; } Cara Frecuencia

 2003 Prentice Hall, Inc. All rights reserved. Outline 22 1 // Fig. 4.11: fig04_11.cpp 2 // Uso de arrays para totalizar resultados de encuestas. 3 #include 4 5 using std::cout; 6 using std::endl; 7 8 #include 9 10 using std::setw; int main() 13 { 14 // define los tamaños de los arrays 15 const int tamRespuestas = 40; // tamaño del array respuestas 16 const int tamFrecuencia = 11; // tamaño del array frecuencia // sitúa respuestas de la encuesta en array respuestas 19 int respuestas[ tamRespuestas ] = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 20 10, 1, 6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7, 21 5, 6, 6, 5, 6, 7, 5, 6, 4, 8, 6, 8, 10 }; // inicializa contadores de frecuencia a 0 24 int frecuencia[ tamFrecuencia ] = { 0 }; 25 Encuesta: calidad comida cafetería alumnos (1=horrible, 10=excelente). Nº encuestados: 40 alumnos

 2003 Prentice Hall, Inc. All rights reserved. Outline // para cada i, selecciono el valor de un elemento del array 27 // respuestas y uso ese valor como índice del array 28 // frecuencia para determinar el elemento a incrementar 29 for ( int i = 0; i < tamRespuestas; i++ ) 30 ++frecuencia[ respuestas[i] ]; // imprimo resultados 33 cout << "Puntuación" << setw( 17 ) << "Frecuencia" << endl; // imprimo frecuencias en formato tabular 36 for ( int puntuacion = 1; puntuacion < tamFrecuencia; puntuacion++ ) 37 cout << setw( 6 ) << puntuacion 38 << setw( 17 ) << frecuencia[ puntuacion ] << endl; return 0; } respuestas[i] es la puntuación (de 1 a 10). Esto determina el índice a incrementar en frecuencia[]. Puntuación Frecuencia

 2003 Prentice Hall, Inc. All rights reserved Ejemplos de uso de Arrays Uso de arrays para almacenar y manipular cadenas de caracteres o strings (más en capítulo 5) –Arrays de caracteres –Todas las cadenas terminan con null ( '\0' ) –Ejemplos char cadena1[] = "hola"; –Carácter null añadido implícitamente – cadena1 tiene 5 elementos char cadena1[] = { 'h', 'o', 'l', 'a', '\0’ }; –Los índices funcionan igual: cadena1[ 0 ] es 'h' cadena1[ 2 ] es 'l'

 2003 Prentice Hall, Inc. All rights reserved Ejemplos de uso de Arrays Entrada de teclado char cadena2[ 10 ]; cin >> cadena2; –Coloca la entrada del usuario en la variable Finaliza cuando encuentra el primer espacio en blanco Añade el carácter null –Si se introduce demasiado texto, los datos se escriben más allá del array Imprimir cadenas de caracteres –cout << string2 << endl; No funciona para otros tipos de arrays –Los caracteres se imprimen hasta que se encuentra el carácter null

 2003 Prentice Hall, Inc. All rights reserved. Outline 26 1 // Fig. 4_12: fig04_12.cpp 2 // Tratamiento de arrays de caracteres como cadenas. 3 #include 4 5 using std::cout; 6 using std::cin; 7 using std::endl; 8 9 int main() 10 { 11 char cadena1[ 20 ], // reserva 20 caracteres 12 char cadena2[] = "cadena literal"; // reserva 15 caracteres // lee cadena del usuario y la mete en array string2 15 cout << "Introduzca la cadena \"hola amigos\": "; 16 cin >> cadena1; // lee "hola" [el espacio finaliza la entrada] // imprimo cadenas 19 cout << “cadena1 es: " << cadena1 20 << "\ncadena2 es: " << cadena2; cout << "\ncadena1 con espacios entre caracteres es:\n"; 23 Dos formas distintas de declarar cadenas. cadena2 se inicializa y su tamaño se determina automáticamente. Ejemplos de lectura de cadenas del teclado y escritura de cadenas en pantalla.

 2003 Prentice Hall, Inc. All rights reserved. Outline // imprimo caracteres hasta alcanzar el nulo 25 for ( int i = 0; cadena1[ i ] != '\0'; i++ ) 26 cout << cadena1[ i ] << ' '; cin >> cadena1; // lee "amigos" 29 cout << "\ncadena1 es: " << cadena1 << endl; return 0; } Introduzca la cadena "hola amigos": hola amigos cadena1 es: hola cadena2 es: cadena literal cadena1 con espacios entre caracteres es: h o l a cadena1 es: amigos Puedo acceder a caracteres en una cadena usando notación de arrays. El lazo finaliza cuando se encuentra el carácter null.

 2003 Prentice Hall, Inc. All rights reserved Ejemplos de uso de arrays Arrays locales estáticos y automáticos –Estáticos Si son static, las variables locales guardan sus valores entre llamadas a funciones Visibles sólo en el cuerpo de la función Se pueden declarar arrays estáticos –Inicializados a cero static int array[3]; –Si no son estáticos (automáticos) Se crean (y destruyen) en cada llamada a la función

 2003 Prentice Hall, Inc. All rights reserved. Outline 29 1 // Fig. 4.13: fig04_13.cpp 2 // Los arrays estáticos se inicializan a cero. 3 #include 4 5 using std::cout; 6 using std::endl; 7 8 void staticArrayInit( void ); // prototipo de función 9 void automaticArrayInit( void ); // prototipo de función int main() 12 { 13 cout << "Primera llamada a cada función:\n"; 14 staticArrayInit(); 15 automaticArrayInit(); cout << "\n\Segunda llamada a cada función:\n"; 18 staticArrayInit(); 19 automaticArrayInit(); 20 cout << endl; return 0; } 25

 2003 Prentice Hall, Inc. All rights reserved. Outline // función para demostrar un array local estático 27 void staticArrayInit( void ) 28 { 29 // inicializa elementos a 0 la primera vez que se llama a la función 30 static int array1[ 3 ]; cout << "\nValores al entrar en staticArrayInit:\n"; // imprimo contenidos de array1 35 for ( int i = 0; i < 3; i++ ) 36 cout << "array1[" << i << "] = " << array1[ i ] << " "; cout << "\nValores al salir de staticArrayInit:\n"; // modifico e imprimo contenidos de array1 41 for ( int j = 0; j < 3; j++ ) 42 cout << "array1[" << j << "] = " 43 << ( array1[ j ] += 5 ) << " "; } // fin de función staticArrayInit 46 Array estático, se inicializa a cero la primera vez que se llama a la función. Se modifican los datos del array; los valores modificados permanecen.

 2003 Prentice Hall, Inc. All rights reserved. Outline // función para demostrar un array local automático 48 void automaticArrayInit( void ) 49 { 50 // inicializa los elementos cada vez que se llama a la función 51 int array2[ 3 ] = { 1, 2, 3 }; cout << "\n\nValores al entrar en automaticArrayInit:\n"; // imprime el contenido de array2 56 for ( int i = 0; i < 3; i++ ) 57 cout << "array2[" << i << "] = " << array2[ i ] << " "; cout << "\nValores al salir de automaticArrayInit:\n"; // modifico e imprimo contenidos de array2 62 for ( int j = 0; j < 3; j++ ) 63 cout << "array2[" << j << "] = " 64 << ( array2[ j ] += 5 ) << " "; } // fin de función automaticArrayInit Array automático, se vuelve a crear en cada llamada a la función. Aunque el array se modifica, se destruirá cuando la función finalice y los cambios se perderán.

 2003 Prentice Hall, Inc. All rights reserved. Outline 32 Primera llamada a cada función: Valores al entrar en staticArrayInit: array1[0] = 0 array1[1] = 0 array1[2] = 0 Valores al salir de staticArrayInit: array1[0] = 5 array1[1] = 5 array1[2] = 5 Valores al entrar en automaticArrayInit: array2[0] = 1 array2[1] = 2 array2[2] = 3 Valores al salir de automaticArrayInit: array2[0] = 6 array2[1] = 7 array2[2] = 8 Segunda llamada a cada función: Valores al entrar en staticArrayInit: array1[0] = 5 array1[1] = 5 array1[2] = 5 Valores al salir de staticArrayInit: array1[0] = 10 array1[1] = 10 array1[2] = 10 Valores al entrar en automaticArrayInit: array2[0] = 1 array2[1] = 2 array2[2] = 3 Valores al salir de automaticArrayInit: array2[0] = 6 array2[1] = 7 array2[2] = 8

 2003 Prentice Hall, Inc. All rights reserved Paso de arrays a funciones Se especifica el nombre sin corchetes –Para pasar el array miArray a miFuncion int miArray[ 24 ]; miFuncion( miArray, 24 ); –Se suele pasar el tamaño del array, pero no es necesario Útil para recorrer todos los elementos

 2003 Prentice Hall, Inc. All rights reserved Paso de Arrays a Funciones Los arrays se pasan por referencia –Las funciones pueden modificar los datos del array original –El valor del nombre del array es la dirección del primer elemento  La función sabe dónde está almacenado el array Puede modificar las localizaciones de memoria originales Los elementos individuales del array se pasan por valor –Como el resto de las variables –cuadrado( miArray[3] );

 2003 Prentice Hall, Inc. All rights reserved Paso de Arrays a Funciones Funciones que toman arrays –Prototipo de función void modificaArray( int b[], int arraySize ); void modificaArray( int [], int ); –Nombres opcionales en el prototipo Ambas toman un array de enteros y un entero –No es necesario indicar el tamaño del array entre corchetes El compilador lo ignora –Si declaramos un parámetro array como const No puede modificarse (error de compilación) void noModifica( const int [] );

 2003 Prentice Hall, Inc. All rights reserved. Outline 36 1 // Fig. 4.14: fig04_14.cpp 2 // Paso de arrays y elementos de un array a funciones. 3 #include 4 5 using std::cout; 6 using std::endl; 7 8 #include 9 10 using std::setw; void modificaArray( int [], int ); // aspecto extraño 13 void modificaElemento( int ); int main() 16 { 17 const int tamArray = 5; // tamaño de array a 18 int a[ tamArray ] = { 0, 1, 2, 3, 4 }; // inicializa a cout << "Efectos de pasar el array completo por referencia:" 21 << "\n\nLos valores del array original son:\n"; // imprimo el array original 24 for ( int i = 0; i < tamArray; i++ ) 25 cout << setw( 3 ) << a[ i ]; Sintaxis para aceptar un array en una lista de parámetros.

 2003 Prentice Hall, Inc. All rights reserved. Outline cout << endl; // paso array a a modificaArray por referencia 30 modificaArray( a, tamArray ); cout << "Los valores del array modificado son:\n"; // imprimo el array modificado 35 for ( int j = 0; j < tamArray; j++ ) 36 cout << setw( 3 ) << a[ j ]; // imprimo el valor de a[ 3 ] 39 cout << "\n\n\n" 40 << "Efectos de pasar un elemento del array por valor:" 41 << "\n\nEl valor de a[3] es " << a[ 3 ] << '\n'; // paso el elemento del array a[ 3 ] por valor 44 modificaElemento( a[ 3 ] ); // imprimo el valor de a[ 3 ] 47 cout << "El valor de a[3] es " << a[ 3 ] << endl; return 0; } Paso el nombre del array ( a ) y su tamaño a la función. Los arrays se pasan por referencia. Paso un elemento del array por valor; el original no puede modificarse.

 2003 Prentice Hall, Inc. All rights reserved. Outline // en función modificaArray, "b" apunta al 54 // array original "a" en memoria 55 void modificaArray( int b[], int tamañoDeArray ) 56 { 57 // multiplica cada elemento del array por 2 58 for ( int k = 0; k < tamañoDeArray; k++ ) 59 b[ k ] *= 2; } // fin de la función modificaArray // en función modificaElemento, "e" es una copia local del 64 // elemento del array a[ 3 ] pasado desde main 65 void modificaElemento( int e ) 66 { 67 // multiplica parámetro por 2 68 cout << "Valor en modificaElemento es " 69 << ( e *= 2 ) << endl; } // fin de la función modificaElemento Aunque se llame b, el array apunta al array original a. Puede modificar los datos de a. Los elementos individuales del array se pasan por valor, y los originales no pueden modificarse.

 2003 Prentice Hall, Inc. All rights reserved. Outline 39 Efectos de pasar el array completo por referencia: Los valores del array original son: Los valores del array modificado son: Efectos de pasar un elemento del array por valor: El valor de a[3] es 6 El valor en modificaElemento es 12 El valor de a[3] es 6

 2003 Prentice Hall, Inc. All rights reserved. Outline 40 1 // Fig. 4.15: fig04_15.cpp 2 // Demostración del calificador de tipo const. 3 #include 4 5 using std::cout; 6 using std::endl; 7 8 void intentaModificarArray( const int [] ); // prototipo de función 9 10 int main() 11 { 12 int a[] = { 10, 20, 30 }; intentaModificarArray( a ); cout << a[ 0 ] << ' ' << a[ 1 ] << ' ' << a[ 2 ] << '\n'; return 0; } 21 Parámetro array declarado como const. El array no puede modificarse, aún cuando se pasa por referencia.

 2003 Prentice Hall, Inc. All rights reserved. Outline // en función intentaModificarArray, "b" no puede usarse 23 // para modificar el array original "a" en main. 24 void intentaModificarArray( const int b[] ) 25 { 26 b[ 0 ] /= 2; // error 27 b[ 1 ] /= 2; // error 28 b[ 2 ] /= 2; // error } // fin de la función intentaModificarArray d:\cpphtp4_examples\ch04\Fig04_15.cpp(26) : error C2166: l-value specifies const object d:\cpphtp4_examples\ch04\Fig04_15.cpp(27) : error C2166: l-value specifies const object d:\cpphtp4_examples\ch04\Fig04_15.cpp(28) : error C2166: l-value specifies const object

 2003 Prentice Hall, Inc. All rights reserved Ordenación de Arrays Ordenación de datos –Una de las aplicaciones más importantes en computación –Virtualmente cualquier organización debe ordenar algunos datos y, en muchos casos, cantidades masivas de datos Banco: ordena por nº de cuenta Guía de teléfonos: ordena por apellido Ordenación de burbuja –Varias pasadas por el array –Se comparan parejas de elementos consecutivos Si están en orden creciente (o idéntico), no se cambian Si están en orden decreciente, se intercambian –Se repiten estos pasos para cada elemento

 2003 Prentice Hall, Inc. All rights reserved Ordenación de Arrays Ejemplo: –Vamos de izquierda a derecha, e intercambiamos elementos si es necesario Una pasada para cada elemento –Original: –Paso 1: (se intercambian los elementos) –Paso 2: –Paso 3: (no se necesitan cambios) –Paso 4: –Paso 5: –Los elementos menores “burbujean” hacia la izquierda (como el 2 en este ejemplo)

 2003 Prentice Hall, Inc. All rights reserved Ordenación de Arrays Intercambio de variables int x = 3, y = 4; y = x; x = y; ¿Qué sucede? –¡Tanto x como y son 3! –Se necesita una variable temporal Solución int x = 3, y = 4, temp; temp = x; // temp toma el valor 3 x = y; // x toma el valor 4 y = temp; // y toma el valor 3

 2003 Prentice Hall, Inc. All rights reserved. Outline 45 1 // Fig. 4.16: fig04_16.cpp 2 // Este programa ordena los valores de un array en orden ascendente. 3 #include 4 5 using std::cout; 6 using std::endl; 7 8 #include 9 10 using std::setw; int main() 13 { 14 const int tamArray = 10; // tamaño del array a 15 int a[ tamArray ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 }; 16 int temp; // localización temporal usada para intercambio de elementos del array cout << "Datos en orden original\n"; // imprimo el array original 21 for ( int i = 0; i < tamArray; i++ ) 22 cout << setw( 4 ) << a[ i ]; 23

 2003 Prentice Hall, Inc. All rights reserved. Outline // ordenación de burbuja 25 // lazo que controla el número de pasadas 26 for ( int paso = 0; paso < tamArray - 1; paso++ ) // lazo que controla el número de comparaciones por paso 29 for ( int j = 0; j < tamArray - 1; j++ ) // compara elementos consecutivos y los intercambia si 32 // el primer elemento es mayor que el segundo 33 if ( a[ j ] > a[ j + 1 ] ) { 34 temp = a[ j ]; 35 a[ j ] = a[ j + 1 ]; 36 a[ j + 1 ] = temp; } // fin de if 39 Se realiza una pasada por cada elemento del array. Si el elemento de la izquierda (índice j ) es mayor que el elemento a la derecha (índice j + 1 ), entonces los intercambiamos. Recordemos la necesidad de una variable temporal.

 2003 Prentice Hall, Inc. All rights reserved. Outline cout << "\nDatos en orden ascendente\n"; // imprimo el array ordenado 43 for ( int k = 0; k < tamArray; k++ ) 44 cout << setw( 4 ) << a[ k ]; cout << endl; return 0; } Datos en orden original Datos en orden ascendente

 2003 Prentice Hall, Inc. All rights reserved Caso de Estudio: Cálculo de Media, Mediana y Moda usando Arrays Análisis de resultados de una encuesta –Media Promedio (suma/número de elementos) –Mediana Valor en posición central de la lista ordenada 1, 2, 3, 4, 5 (3 es la mediana) Si el número de elementos es par, se toma el promedio de los dos del centro –Moda Respuesta (valor) más frecuente 1, 1, 1, 2, 3, 3, 4, 5 (1 es la moda)

 2003 Prentice Hall, Inc. All rights reserved. Outline 49 1 // Fig. 4.17: fig04_17.cpp 2 // Este programa introduce el tema de análisis de datos. 3 // Calcula la media, mediana y moda de los datos. 4 #include 5 6 using std::cout; 7 using std::endl; 8 using std::fixed; 9 using std::showpoint; #include using std::setw; 14 using std::setprecision; void media( const int [], int ); 17 void mediana( int [], int ); 18 void moda( int [], int [], int ); 19 void ordenaBurbuja( int[], int ); 20 void imprimeArray( const int[], int ); int main() 23 { 24 const int tamRespuestas = 99; // tamaño del array de respuestas 25

 2003 Prentice Hall, Inc. All rights reserved. Outline int frecuencia[ 10 ] = { 0 }; // inicializa array frecuencia // inicializa array respuestas 29 int respuestas[ tamRespuestas ] = 30 { 6, 7, 8, 9, 8, 7, 8, 9, 8, 9, 31 7, 8, 9, 5, 9, 8, 7, 8, 7, 8, 32 6, 7, 8, 9, 3, 9, 8, 7, 8, 7, 33 7, 8, 9, 8, 9, 8, 9, 7, 8, 9, 34 6, 7, 8, 7, 8, 7, 9, 8, 9, 2, 35 7, 8, 9, 8, 9, 8, 9, 7, 5, 3, 36 5, 6, 7, 2, 5, 3, 9, 4, 6, 4, 37 7, 8, 9, 6, 8, 7, 8, 9, 7, 8, 38 7, 4, 4, 2, 5, 3, 8, 7, 5, 6, 39 4, 5, 6, 1, 6, 5, 7, 8, 7 }; // procesa respuestas 42 media( respuestas, tamRespuestas ); 43 mediana( respuestas, tamRespuestas ); 44 moda( frecuencia, respuestas, tamRespuestas ); return 0; } 49

 2003 Prentice Hall, Inc. All rights reserved. Outline // calculamos el promedio de todos los valores respuesta 51 void media( const int resp[], int tamArray ) 52 { 53 int total = 0; cout << "********\n Media\n********\n"; // total de valores respuesta 58 for ( int i = 0; i < tamArray; i++ ) 59 total += resp[ i ]; // formateo e imprimo resultados 62 cout << setiosflags(ios::fixed) << setprecision( 4 ); cout << "La media es el valor promedio de los datos\n" 65 << "La media es igual al total de todos los datos\n" 66 << "dividido por el número de datos (" << tamArray 67 << ").\nEl valor medio para este caso es:\n" 69 << total << " / " << tamArray << " = " 70 ( total ) / tamArray 71 << "\n\n"; } // fin de función media 74 Aplicamos un molde para obtener el promedio con decimales (en vez de un entero).

 2003 Prentice Hall, Inc. All rights reserved. Outline // ordeno array y determino el valor del elemento mediana 76 void mediana( int resp[], int tam ) 77 { 78 cout << "\n********\n Mediana\n********\n" 79 << "El array de respuestas desordenadas es"; imprimeArray( resp, tam ); // imprimo array desordenado ordenaBurbuja( resp, tam ); // ordeno array cout << "\n\nEl array ordenado es"; 86 imprimeArray( resp, tam ); // imprime array ordenado // imprime elemento mediana 89 cout << "\n\nLa mediana es el elemento " << tam / 2 90 << “\ndel array de " << tam << " elementos ordenados." 91 << "\nPara este caso la mediana es " 92 << resp[ tam / 2 ] << "\n\n"; } // fin de función mediana 95 Ordeno el array pasándolo a una función. Esto hace que el programa sea modular.

 2003 Prentice Hall, Inc. All rights reserved. Outline // determina la respuesta más frecuente 97 void moda( int frec[], int resp[], int tam ) 98 { 99 int mayor = 0; // representa la mayor frecuencia 100 int valorModa = 0; // representa la respuesta más frecuente cout << "\n********\n Moda\n********\n"; // inicializa frecuencias a for ( int i = 1; i <= 9; i++ ) 106 frec[ i ] = 0; // calcula frecuencias 109 for ( int j = 0; j < tam; j++ ) frec[ resp[ j ] ]; // imprime títulos de columnas de resultados 113 cout << "Respuesta" << setw( 11 ) << "Frecuencia" 114 << setw( 19 ) << "Histograma\n\n" << setw( 55 ) 115 << " \n" << setw( 56 ) 116 << " \n\n"; 117

 2003 Prentice Hall, Inc. All rights reserved. Outline // salida de resultados 119 for ( int puntos = 1; puntos <= 9; puntos++ ) { 120 cout << setw( 8 ) << puntos << setw( 11 ) 121 << frec[ puntos ] << " "; // voy guardando los valores de moda y máxima frecuencia 124 if ( frec[ puntos ] > mayor ) { 125 mayor = frec[ puntos ]; 126 valorModa = puntos; } // fin del if // imprimo histograma de barras que representan el valor de frecuencia 131 for ( int k = 1; k <= frec[ puntos ]; k++ ) 132 cout << '*'; cout << '\n'; // comienza nueva línea de salida } // fin del for externo // imprimo el valor de la moda 139 cout << "La moda es el valor más frecuente.\n" 140 << "Para este caso la moda es " << valorModa 141 << " y ocurre " << mayor << " veces." << endl; } // fin de la función moda La moda es el valor que ocurre más a menudo (tiene el valor más alto en frec ).

 2003 Prentice Hall, Inc. All rights reserved. Outline // función que ordena un array mediante el algoritmo de la burbuja 146 void ordenaBurbuja( int a[], int tam ) 147 { 148 int temp; // variable temporal para intercambiar elementos // lazo para controlar el número de pasos 151 for ( int paso = 1; paso < tam; paso++ ) // lazo para controlar el número de comparaciones por paso 154 for ( int j = 0; j < tam - 1; j++ ) // intercambio elementos desordenados 157 if ( a[ j ] > a[ j + 1 ] ) { 158 temp = a[ j ]; 159 a[ j ] = a[ j + 1 ]; 160 a[ j + 1 ] = temp; } // fin de if } // fin de la función ordenaBurbuja 165

 2003 Prentice Hall, Inc. All rights reserved. Outline // imprimo el contenido del array (20 valores por fila) 167 void imprimeArray( const int a[], int tam ) 168 { 169 for ( int i = 0; i < tam; i++ ) { if ( i % 20 == 0 ) // comienzo nueva línea cada 20 valores 172 cout << endl; cout << setw( 2 ) << a[ i ]; } // fin de for } // fin de función imprimeArray

 2003 Prentice Hall, Inc. All rights reserved. Outline 57 ******** Media ******** La media es el valor promedio de los datos La media es igual al total de todos los datos dividido por el número de datos (99). El valor medio para este caso es: 681 / 99 = ******** Mediana ******** El array de respuestas desordenado es El array ordenado es La mediana es el elemento 49 del array de 99 elementos ordenados. Para este caso la mediana es 7

 2003 Prentice Hall, Inc. All rights reserved. Outline 58 ******** Moda ******** Respuesta Frecuencia Histograma * 2 3 *** 3 4 **** 4 5 ***** 5 8 ******** 6 9 ********* 7 23 *********************** 8 27 *************************** 9 19 ******************* La moda es el valor más frecuente. Para este caso la moda es 8 y ocurre 27 veces.

 2003 Prentice Hall, Inc. All rights reserved Búsqueda en Arrays: Búsqueda Lineal y Búsqueda Binaria Busco un valor clave dentro del array Búsqueda lineal –Compara cada elemento del array con el valor clave Comienza en un extremo y va hacia el otro –Útil para pequeños arrays desordenados Ineficiente Si la clave de búsqueda no existe, examina todos los elementos

 2003 Prentice Hall, Inc. All rights reserved Búsqueda en Arrays: Búsqueda Lineal y Búsqueda Binaria Búsqueda binaria –Sólo se usa con arrays ordenados –Se compara el elemento en la posición central con la clave Si son iguales, se encontró la clave Si clave < centro –Repite la búsqueda en la primera mitad del array Si clave > centro –Repite la búsqueda en la última mitad del array –Algoritmo termina cuando clave=elemento central subarray –Muy rápida Como mucho N pasos, donde 2 N > nº de elementos Un array de 30 elementos implica como mucho 5 pasos 2 5 > 30

 2003 Prentice Hall, Inc. All rights reserved. Outline 61 1 // Fig. 4.19: fig04_19.cpp 2 // Búsqueda lineal en un array. 3 #include 4 5 using std::cout; 6 using std::cin; 7 using std::endl; 8 9 int busquedaLineal( const int [], int, int ); // prototipo int main() 12 { 13 const int tamArray = 100; // tamaño del array a 14 int a[ tamArray ]; // crea array a 15 int claveBusqueda; // valor a buscar en a for ( int i = 0; i < tamArray; i++ ) // crea algunos datos 18 a[ i ] = 2 * i; cout << "Introduce un entero como clave de búsqueda: "; 21 cin >> claveBusqueda; // busca claveBusqueda en array a 24 int elemento = busquedaLineal( a, claveBusqueda, tamArray ); 25 Toma el array, la clave de búsqueda, y el tamaño del array.

 2003 Prentice Hall, Inc. All rights reserved. Outline // imprime resultados 27 if ( elemento != -1 ) 28 cout << "Valor encontrado en elemento " << elemento << endl; 29 else 30 cout << "Valor no encontrado" << endl; return 0; } // compara la clave con todos los elementos del array hasta encontrar 37 // su localización o hasta alcanzar el final del array; se devuelve 38 // el índice del elemento o –1 si no se encuentra 39 int busquedaLineal( const int array[], int clave, int tamDeArray ) 40 { 41 for ( int j = 0; j < tamDeArray; j++ ) if ( array[ j ] == clave ) // si la encuentro, 44 return j; // devuelvo localización de clave return -1; // clave no encontrada } // fin de función busquedaLineal Introduce un entero como clave de búsqueda: 36 Valor encontrado en elemento 18 Introduce un entero como clave de búsqueda: 37 Valor no encontrado

 2003 Prentice Hall, Inc. All rights reserved. Outline 63 1 // Fig. 4.20: fig04_20.cpp 2 // Búsqueda binaria en un array. 3 #include 4 5 using std::cout; 6 using std::cin; 7 using std::endl; 8 9 #include using std::setw; // prototipos de funciones 14 int busquedaBinaria( const int [], int, int, int, int ); 15 void imprimeCabecera( int ); 16 void imprimeFila( const int [], int, int, int, int ); int main() 19 { 20 const int tamArray = 15; // tamaño del array a 21 int a[ tamArray ]; // crea array a 22 int clave; // valor a localizar en a for ( int i = 0; i < tamArray; i++ ) // crea algunos datos 25 a[ i ] = 2 * i; cout << "Introduce un número entre 0 y 28: "; 28 cin >> clave; 29

 2003 Prentice Hall, Inc. All rights reserved. Outline imprimeCabecera( tamArray ); // busco la clave en el array a 33 int resultado = 34 busquedaBinaria( a, clave, 0, tamArray - 1, tamArray ); // imprimo resultados 37 if ( resultado != -1 ) 38 cout << '\n' << clave << " encontrada en el elemento " 39 << resultado << "del array" << endl; 40 else 41 cout << '\n' << clave << " no encontrada" << endl; return 0; } // función que realiza la búsqueda binaria en un array 48 int busquedaBinaria( const int b[], int claveBusqueda, int menor, 49 int mayor, int tam ) 50 { 51 int medio; // lazo hasta que el índice menor es mayor que el mayor 54 while ( menor <= mayor ) { // determino el elemento central del subarray en el que se busca 57 medio = ( menor + mayor ) / 2; 58 Determina elemento central

 2003 Prentice Hall, Inc. All rights reserved. Outline // imprimo subarray usado en esta iteración 60 imprimeFila( b, menor, medio, mayor, tam ); // si la clave de búsqueda está en el elemento central, devuelve medio 63 if ( claveBusqueda == b[ medio ] ) // coinciden 64 return medio; else // si la clave de búsqueda es menor que el elemento del medio, 69 // calculo el nuevo elemento mayor 70 if ( claveBusqueda < b[ medio ] ) 71 mayor = medio - 1; // busco en la mitad inferior del array // si la clave de búsqueda es mayor que el elemento del medio, 74 // calculo el nuevo elemento menor 75 else 76 menor = medio + 1; // busco en la mitad superior del array 77 } return -1; // clave de búsqueda no encontrada } // fin de la función busquedaBinaria Usa la regla de búsqueda binaria: Si clave=medio, coinciden Si es menor, busco en mitad inferior Si es mayor, busco en mitad superior El lazo calcula menor, mayor y medio dinámicamente. Si la búsqueda es en la mitad superior, menor será el elemento después de medio.

 2003 Prentice Hall, Inc. All rights reserved. Outline // imprime la cabecera para la salida 84 void imprimeCabecera( int tam ) 85 { 86 cout << "\nÍndices:\n"; // imprime cabeceras de columna 89 for ( int j = 0; j < tam; j++ ) 90 cout << setw( 3 ) << j << ' '; cout << '\n'; // comienza nueva línea de salida // salida de línea de caracteres - 95 for ( int k = 1; k <= 4 * size; k++ ) 96 cout << '-'; cout << endl; // comienza nueva línea de salida } // fin de función imprimeCabecera 101

 2003 Prentice Hall, Inc. All rights reserved. Outline // imprime una fila de salida mostrando la parte del array 103 // que está siendo procesada 104 void imprimeFila( const int b[], int menor, int medio, 105 int mayor, int tam ) 106 { 107 // lazo que recorre el array 108 for ( int m = 0; m < tam; m++ ) // imprime espacios si estamos fuera del rango del subarray actual 111 if ( m mayor ) 112 cout << " "; // imprime elemento central marcándolo con un * 115 else if ( m == medio ) // marca valor medio 118 cout << setw( 3 ) << b[ m ] << '*'; // imprime los demás elementos del subarray 121 else 122 cout << setw( 3 ) << b[ m ] << ' '; cout << endl; // comienza nueva línea de salida } // fin de función imprimeFila

 2003 Prentice Hall, Inc. All rights reserved. Outline 68 Introduce un número entre 0 y 28: 6 Índices: * * encontrado en el elemento 3 del array Introduce un número entre 0 y 28: 25 Índices: * * * 28 24* 25 no encontrado

 2003 Prentice Hall, Inc. All rights reserved. Outline 69 Introduce un número entre 0 y 28: 8 Índices: * * * 12 8* 8 encontrado en el elemento 4 del array

 2003 Prentice Hall, Inc. All rights reserved Arrays Multi-Dimensionales Múltiples índices –a[ i ][ j ] –Uso común: Representación de tablas con filas y columnas –Especificar un elemento: Especifico fila, y después columna –“Array de arrays” a[0] es un array de 4 elementos a[0][0] es el primer elemento de ese array Fila 0 Fila 1 Fila 2 Columna 0Columna 1Columna 2Columna 3 a[ 0 ][ 0 ] a[ 1 ][ 0 ] a[ 2 ][ 0 ] a[ 0 ][ 1 ] a[ 1 ][ 1 ] a[ 2 ][ 1 ] a[ 0 ][ 2 ] a[ 1 ][ 2 ] a[ 2 ][ 2 ] a[ 0 ][ 3 ] a[ 1 ][ 3 ] a[ 2 ][ 3 ] Índice de Fila Nombre array Índice de Columna

 2003 Prentice Hall, Inc. All rights reserved Arrays Multi-Dimensionales Para inicializarlos –Por defecto a 0 –Inicializadores agrupados mediante filas entre llaves int b[ 2 ][ 2 ] = { { 1, 2 }, { 3, 4 } }; int b[ 2 ][ 2 ] = { { 1 }, { 3, 4 } }; Fila 0Fila 1

 2003 Prentice Hall, Inc. All rights reserved Arrays Multi-Dimensionales Se referencian como los demás arrays cout << b[ 0 ][ 1 ]; –Imprime 0 –No se pueden usar comas en las referencias cout << b[ 0, 1 ]; Error de sintaxis Prototipos de funciones –Deben especificar tamaños de índices Primer tamaño no necesario, como con arrays de 1 dimensión –void imprimeArray( int [][ 3 ] );

 2003 Prentice Hall, Inc. All rights reserved. Outline 73 1 // Fig. 4.22: fig04_22.cpp 2 // Inicialización de arrays multidimensionales. 3 #include 4 5 using std::cout; 6 using std::endl; 7 8 void imprimeArray( int [][ 3 ] ); 9 10 int main() 11 { 12 int array1[ 2 ][ 3 ] = { { 1, 2, 3 }, { 4, 5, 6 } }; 13 int array2[ 2 ][ 3 ] = { 1, 2, 3, 4, 5 }; 14 int array3[ 2 ][ 3 ] = { { 1, 2 }, { 4 } }; cout << "Valores en array1 por filas son:" << endl; 17 imprimeArray( array1 ); cout << "Valores en array2 por filas son:" << endl; 20 imprimeArray( array2 ); cout << "Valores en array3 por filas son:" << endl; 23 imprimeArray( array3 ); return 0; } Notad los distintos estilos de inicialización. Los elementos del array2 son asignados a la primera fila y después a la segunda. Notad el formato del prototipo.

 2003 Prentice Hall, Inc. All rights reserved. Outline // función para imprimer el array con 2 filas y 3 columnas 30 void imprimeArray( int a[][ 3 ] ) 31 { 32 for ( int i = 0; i < 2; i++ ) { // para cada fila for ( int j = 0; j < 3; j++ ) // imprime valores de columna 35 cout << a[ i ][ j ] << ' '; cout << endl; // comienza nueva línea de salida } // fin de la estructura externa } // fin de la función imprimeArray Valores en array1 por filas son: Valores en array2 por filas son: Valores en array3 por filas son: Los lazos for suelen usarse para recorrer los arrays. Los lazos anidados son útiles para arrays multidimensionales.

 2003 Prentice Hall, Inc. All rights reserved Arrays Multi-Dimensionales Ejemplo: programa para guardar las notas de 4 exámenes realizados por 3 alumnos –Array multi-dimensional (tabla) –Las filas son los alumnos (3) –Las columnas son las notas (4) Exam1 Exam2 Alumno0 Alumno1

 2003 Prentice Hall, Inc. All rights reserved. Outline 76 1 // Fig. 4.23: fig04_23.cpp 2 // Ejemplo de array de 2 dimensiones. 3 #include 4 5 using std::cout; 6 using std::endl; 7 using std::fixed; 8 using std::left; 9 10 #include using std::setw; 13 using std::setprecision; const int alumnos = 3; // número de alumnos 16 const int examenes = 4; // número de exámenes // prototipos de funciones 19 int minimo( int [][ examenes ], int, int ); 20 int maximo( int [][ examenes ], int, int ); 21 double promedio( int [], int ); 22 void imprimeArray( int [][ examenes ], int, int ); 23

 2003 Prentice Hall, Inc. All rights reserved. Outline int main() 25 { 26 // inicializo notas de alumnos para 3 alumnos (filas) 27 int notasAlumnos[ alumnos ][ examenes ] = 28 { { 77, 68, 86, 73 }, 29 { 96, 87, 89, 78 }, 30 { 70, 90, 86, 81 } }; // imprimo array notasAlumnos 33 cout << "El array es:\n"; 34 imprimeArray( notasAlumnos, alumnos, examenes ); // determina las notas mayor y menor 37 cout << "\n\nNota mínima: " 38 << minimo( notasAlumnos, alumnos, examenes ) 39 << "\nNota máxima: " 40 << maximo( notasAlumnos, alumnos, examenes ) << '\n'; cout << setiosflags(ios::fixed) << setprecision( 2 ); 43

 2003 Prentice Hall, Inc. All rights reserved. Outline // calcula la nota media para cada alumno 45 for ( int persona = 0; persona < alumnos; persona++ ) 46 cout << "La nota media para el alumno " << persona 47 << " es " 48 << promedio( notasAlumnos[ persona ], examenes ) 49 << endl; return 0; } // busca la nota mínima 56 int minimo( int notas[][ examenes ], int alum, int tests ) 57 { 58 int notaMenor = 100; // inicializa a la nota más alta posible for ( int i = 0; i < alum; i++ ) for ( int j = 0; j < tests; j++ ) if ( notas[ i ][ j ] < notaMenor ) 65 notaMenor = notas[ i ][ j ]; return notaMenor; } // fin de la función minimo 70 Determina el promedio para un alumno. Pasamos el array/fila que contiene las notas del alumno. Notad que notasAlumnos[0] también es un array.

 2003 Prentice Hall, Inc. All rights reserved. Outline // busca la nota máxima 72 int maximo( int notas[][ examenes ], int alum, int tests ) 73 { 74 int notaMayor = 0; // inicializa a la menor nota posible for ( int i = 0; i < alum; i++ ) for ( int j = 0; j < tests; j++ ) if ( notas[ i ][ j ] > notaMayor ) 81 notaMayor = notas[ i ][ j ]; return notaMayor; } // fin de la función maximo // calculo la nota media de un alumno 88 double promedio( int notas[], int tests ) 89 { 90 int total = 0; // suma todas las notas de un alumno 93 for ( int i = 0; i < tests; i++ ) 94 total += notas[ i ]; return static_cast ( total ) / tests; // promedio } // fin de función maximo

 2003 Prentice Hall, Inc. All rights reserved. Outline // Imprime el array 101 void imprimeArray( int notas[][ examenes ], int alum, int tests ) 102 { 103 // Fijo alineación a la izquierda e imprimo cabeceras de columnas 104 cout << setiosflags(ios::left) << " [0] [1] [2] [3]"; // imprimo notas en formato tabular 107 for ( int i = 0; i < alum; i++ ) { // imprimo etiqueta de fila 110 cout << "\nnotasAlumnos[" << i << "] "; // imprimo notas de alumno i 113 for ( int j = 0; j < tests; j++ ) 114 cout << setw( 5 ) << notas[ i ][ j ]; } // fin del for externo } // fin de la función imprimeArray

 2003 Prentice Hall, Inc. All rights reserved. Outline 81 El array es: [0] [1] [2] [3] notasAlumnos[0] notasAlumnos[1] notasAlumnos[2] Nota mínima: 68 Nota máxima: 96 La nota media para el alumno 0 es La nota media para el alumno 1 es La nota media para el alumno 2 es 81.75