Operaciones con arreglo

Los arreglos de una dimensión es un tipo de datos estructurados compuesto de un número de elementos finitos, tamaños fijos y elementos homogéneos.

Finitos, indica que tiene un último elemento, tamaño fijo significa que el tamaño del arreglo debe ser conocido en tiempo de compilación, homogéneo significa que todos los elementos son del mismo tipo.

Para acceder a un elemento en particular de un arreglo se usa un índice. El formato para declarar un arreglo unidimensional es:   

<tipo><nombre del arreglo>[tamaño]

Las operaciones válidas en arreglos son las siguientes:

• Lectura y Escritura

A continuación analizaremos las operaciones de lectura, escritura.

Lectura:

El proceso de lectura de un arreglo consiste en leer un valor en cada uno de sus componentes. Supongamos que se desea leer todos los elementos de un arreglo unidimensional Nombres[200] en forma consecutiva, utilizaríamos un ciclo repetitivo de la siguiente manera:

            String  Nombres[200]
            Hacer Desde C=0 Hasta 199
            Leer Nombres[C]
            Fin Desde

Escritura:

 El caso de la operación de escritura es similar al de lectura. Solo que en vez de leer el componente del arreglo lo escribimos.

Supongamos que se desea escribir los componentes del arreglo unidimensional Nombres[200] en forma consecutiva. Los pasos a seguir son:

            String Nombres[200]
            Hacer Desde C=1 Hasta 199
            Nombres[C] ← C
            Fin Desde

Al variar el valor de C se escribe el elemento del arreglo Nombres[200], correspondiente a la posición indicada por C, en otras palabras, cuando C=1 se almacenara el valor de C en la posición del arreglo Nombres[1], y así consecutivamente para todo el arreglo.

Acceso a los elementos del arreglo

Puedo acceder a un elemento por medio de un subíndice, por ejemplo si yo quiero acceder al primer elemento tendré que hacerlo de esta manera
    int N= arreglo[0];
En la variable N se almacenara el valor de 1, para acceder al segundo valor:
     N = arreglo[1];
En la variable N se almacenará el valor de 2, y así sucesivamente con los demás elementos.

Si nos damos cuenta tener un arreglo es mucho más ventajoso que tener definidas 4 variables.

Desventajas. En ocasiones, no podemos predecir con precisión el tamaño que un arreglo tendrá por lo que podemos definir un arreglo muy grande, lo que nos lleva a desperdiciar memoria, por ejemplo si defino un arreglo de 100 elemento (arreglo[100]), y sólo utilizo 5 posiciones de memoria, las demás 95 estarán desperdiciadas, la solución a este problema la podemos resolver usando punteros.

Ejemplo:

Se desea ingresar las notas finales de 10 alumnos de la materia de Introducción a la programación, para luego emitir un reporte del promedio de todas las notas.

#include <iostream.h> void main() { const int TAM = 10; int i, promedio=0; int arreglo[TAM]; for(i=0; i < TAM ; i++) { cout<<"Ingrese la nota del estudiante #"<<i+1<<" :\n"; cin>>arreglo[i]; } for(i=0; i < TAM ; i++) promedio = promedio + arreglo[i]; promedio = promedio / TAM ; cout<<"El promedio de las notas es: "<<promedio; }

No hubiera sido muy práctico manejar 10 variables diferentes para guardar las notas de los 10 alumnos, utilizando un arreglo se nos simplifican mucho las cosas.

Nota: Se puede declarar un arreglo dándole la dimensión o tamaño por un valor constante

const int TAM=10;
int arreglo[TAM];

si TAM no fuera constante el programa devolvería mensaje de error.

Declaración de una variable de tipo arreglo

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, unión 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' };

Arreglos

Un arreglo en C++ es un conjunto de datos que se almacena 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]

Ejemplo de arreglo

int a[5]; // Definición de un arreglo de 5 posiciones

void main()

{

            int i;

            // Pedimos el ingreso de 5 números

            for(i=0; i<4; i++)           //No olvidar que los arreglos van de 0 a longitud-1

            {

                        cout << Ingrese el elemento Nro: << i <<endl;

                        cin >> a[i];

}

// Los imprimimos

imprimir(a,5);

}

void imprimir(int b[], int tamano)

{

int i;

for(i=0; i<tamano; i++)

{

                        cout << Nro: << i <<” “<<b[i]<<endl;

}

}

Arreglos Unidimensionales y Bidimensionales

Arreglo unidimensional:

Un arreglo unidimensional es un tipo de datos estructurado que está formado de una colección finita y ordenada de datos del mismo tipo.Es la estructura natural para modelar listas de elementos iguales.El tipo de acceso a los arreglos unidimensionales es el acceso directo, es decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o posteriores, esto mediante el uso de un índice para cada elemento del arreglo que nos da su posición relativa.Para implementar arreglos unidimensionales se debe reservar espacio en memoria, y se debe proporcionar la dirección base del arreglo.

Arreglos bidimensionales:

Son estructuras de datos que agrupan muchos datos del mismo tipo, en donde cada elemento se puede trabajar individualmente y se puede referenciar con un mismo nombre. Se usan para representar datos que pueden verse como una tabla con filas y columnas.

Ejemplo:

#include <stdio.h>

int main()

{

int fila, columna;

int matriz[2][2];

for(fila=0; fila<2; fila++)

for(columna=0; columna<2; columna++)

printf(“%d”, matriz[fila][columna]);

return 0;

}