ARREGLOS EN C++

Expresado formalmente, un Array o Arreglo de datos, es una estructura de datos que permite almacenar un conjunto de datos del mismo tipo, definiendo el intervalo con un límite inferior y un límite superior, con un número denominado Índice hacemos referencia a cada elemento individual del arreglo. Se utilizará indistintamente el término Array o Arreglo.

Para comprender mejor los arrays, resulta muy útil la siguiente descripción gráfica.

La sintaxis para definir un arreglo en C++ es la siguiente:

TipoDato nombreArray[TamañoArray];

en donde,

TipoDato: Tipo de dato que tendrán los elementos del arreglo.
nombreArray: Nombre que asignamos para referirnos al arreglo.
TamañoArray: Valor entero que delimita el tamaño del arreglo.

 Declarando un Arreglo

Si deseamos declarar un arreglo llamado arrTemp con 5 elementos de punto flotante, debemos hacerlo de esta forma:

float arrCalif[5]; //Declara un arreglo de 5 elementos de punto flotante llamado arrCalif

También podemos declarar una arreglo sin límites predeterminados,

float arrCalif[ ]; //Declara un arreglo de elementos de punto flotante llamado arrCalif sin límite.

Accediendo a los elementos del Arreglo

Nota: Los índices de los arreglos se numeran a partir de 0, de modo que si un arreglo tiene por ejemplo 4 elementos, los índices serán 0, 1, 2, 3

Para acceder a un elemento del arreglo debemos usar el nombre del arreglo utilizando el índice del elemento que nos interesa. Por ejemplo, si queremos asignar los valores 2, 5, 8, -9, 100 al arreglo arrTemp lo haremos de la siguiente forma:

arrTemp[0] = 2;

arrTemp[1] = 5;

arrTemp[2] = 8;

arrTemp[3] = -9;

arrTemp[4] = 100;

Para que visualices lo que hemos hecho hasta el momento, apóyate en la siguiente imagen.

Acceso a los elementos de un Arreglo

 

Podemos recuperar de varias formas un elemento de un arreglo, pero el concepto siempre es el mismo, tomar el índice del elemento que nos interesa y asignarlo a una variable del mismo tipo. 

Por lo tanto en resumen un arreglo en C++ es un conjunto de datos que se almacenan en memoria de manera contigua con el mismo nombre. Para diferenciar los elementos de un arreglo se utilizan índices detrás del nombre del arreglo y encerrados por [ ].

EJEMPLO: int vector [10]; // array de 10 enteros: vector[0]..vector[9].

 

Arreglos unidimensionales en C++

En el lenguaje C++ un arreglo puede tener varias dimensiones, en esta ocasión hablaremos de los arreglos unidimensionales (una dimensión).

Arreglos Unidimensionales

Un arreglo unidimensional es una lista de valores guardados bajo el mismo nombre y del mismo tipo. Cada valor dentro del arreglo se le conoce como elemento del arreglo.

Para declarar un arreglo unidimensional en C++ se utiliza la siguiente línea de código:

tipo_dato identificador[tamaño];

En “tipo de dato” introduciremos que tipo de dato queremos (int, char, float.. etc) , luego en “identificador” introducimos como llamaremos a nuestro arreglo para ubicarlo e identificarlo de manera rápida. Y entre los corchetes colocaremos el tamaño que le demos a nuestro array. Quedando de esta manera:

int arreglo[3];

Ya que tenemos declarado nuestro arreglo necesitamos declarar cada uno de los elementos que lo conforman, para esto utilizamos lo siguiente:

Iniciamos con el nombre de nuestro arreglo en el apartado que dice arreglo, entre los corchetes colocaremos que parte del array utilizaremos, en C++ los valores se inician en 0, esto quiere decir que si nuestro arreglo es de tamaño 3, al hacer nuestro índice hay que tomar el 0 como valor inicial quedando [0] , [1] y [2] completando así nuestros 3 valores del tamaño antes mencionado.

En la parte “valor” asignaremos el valor que le daremos a ese elemento quedando de la siguiente manera:

 Ejemplo: el siguiente programa carga el arreglo sqrs con los cuadrados de los números del 1 al 10 y luego los visualiza .

La forma como se almacenan los valores en el arreglo es la siguiente:

sqrs[0] = 1*1

sqrs[1] = 2*2

sqrs[2] = 3*3

sqrs[3] = 4*4

sqrs[4] = 5*5

sqrs[5] = 6*6

sqrs[6] = 7*7

sqrs[7] = 8*8

sqrs[8] = 9*9

sqrs[9] = 10*10

ARREGLOS BIDIMENSIONALES

¿Qué es un “Arreglo bidimensional”?: Es una matriz de datos de tamaño m x n que contiene información almacenada del mismo tipo de datos (int, float, char, etc). Este tipo de arreglos necesita dos subíndices para ser declarado o para acceder a la información de un elemento en específico, a diferencia de una matriz unidimensional que solo necesita un subíndice. Un arreglo bidimensional es utilizado cuando queremos guardar mucha información sobre un tipo de dato en específico en distintas filas. Por ejemplo, si quieres crear una base de datos donde queremos guardar varios nombres, en un vector no se podría hacer pues solo podrías guardar un nombre, en cambio, con un arreglo bidimensional puedes guardar un nombre por fila, por lo tanto, si creamos varias filas podemos guardar varios nombres.

 

¿Cómo declarar un arreglo bidimensional?: La sintaxis para declarar un arreglo bidimensional es la siguiente:

Código:

tipo_dato nombre_arreglo [tamaño_fila][tamaño_columna];

Donde:

·         tipo_dato: Nos referimos al tipo de dato que estaremos manejando en el arreglo, puede ser char, int, float, etc.

·         nombre_arreglo: El nombre con el que identificaremos nuestra matriz.

·         tamaño_fila: La cantidad de filas que tendrá nuestra matriz.

·         tamaño_columna: La cantidad de columnas que tendrá nuestra matriz.

Por ejemplo, si queremos crear una matriz de 3 filas y 4 columnas de tipo de dato int y con nombre “matriz”, lo haríamos de la siguiente manera:

Código:

int matriz[3][4];

Esta matriz tendría 12 espacios para guardar información (3x4), y gráficamente lo veríamos de la siguiente manera:

Inicialización de un arreglo bidimensional: Podemos inicializar un arreglo bidimensional al momento de declararlo, indicando los valores que queremos entre corchetes y separados por coma, por ejemplo:

Código:

int matriz[4][5] = {1,2,3,4,5,6,7,8,9,10,11,12};

Y gráficamente los valores estarían guardados de la siguiente manera:

 

Ejercicio

Realizar un programa en el que se puedan guardar 5 nombres de máximo 20 caracteres. El usuario ingresará los nombres que quiere guardar y posteriormente se mostrarán los nombres que ingresó.

Programa

Código:

/* Introducción a Arreglos - Por Solución Ingenieril*/ #include <stdio.h> /* Declaración librerías*/ #include <stdlib.h> #include <string.h>   int main(){         int contador;//Variable contadora de ciclos         char nombre[5][20]; //Arreglo que guardara los nombres                 //Ciclo en el que solicitamos los nombres a ingresar         for(contador=0;contador<5;contador++){                printf("Ingresa un nombre: ");                gets(nombre[contador]);         }                 //Ciclo que imprime los nombres guardados         printf("\nNombres ingresados: \n");           for(contador=0;contador<5;contador++){                puts(nombre[contador]);         }                 return 0;              }

Resultados

 

PASOS DE ARREGLOS FUNCIONES

Por default, los arrreglos en C se pasan a una función como referencia y no como valor. Esto significa que todas las modificaciones que hagamos dentro de la función en C al arreglo que recibimos como parámetro, realmente se realizan en el arreglo original que se utilizó como argumento al momento de llamar a la función.

Al escribir una función en C, la forma de indicar que uno de los parámetros que se va a recibir es un arreglo de una dimensión, es decir de que tipo va a ser el arreglo y el nombre con el cual vamos a manipular dicho arreglo dentro de nuestra función seguido de corchetes que abren y cierran; nuestra función también debe recibir un segundo parámetro que nos indique el tamaño del arreglo, o dicho de otra forma, el número de elementos de los que consta nuestro arreglo, recordemos que como el arreglo se pasa a la función como referencia, lo que esta recibiendo la función en realidad es un apuntador al primer elemento del arreglo, pero no sabe en donde termina el arreglo, por eso es necesario que la función también reciba como parámetro el número de elementos del arreglo.

Por ejemplo, el prototipo de una función en C que va a regresar un entero y va a recibir un arreglo de 10 elementos de tipo entero sería algo asi:

int MiFuncion(int mi_arreglo[], int num_elemetos);

Para llamar a la función anterior, se pone como primer argumento el nombre del arreglo (sin corcehetes) y como segundo argumento el número de elementos del arreglo. Supongamos que tenemos un arreglo de 10 elementos de tipo entero llamado numeros y queremos guardar en una variable llamada «x» el valor que nos regresa la función «MiFuncion» al llamarla pasandole como argumentos el arreglo «numeros», haríamos algo como esto

x = MiFuncion(numeros, 10);

El siguiente programa solicita al usuario que ingrese 10 números de tipo entero y los almacena en un arreglo; después le pide que introduzca un número para que busque su posición dentro del arreglo..

El programa utiliza una función llamada BuscaNumero que recibe como parámetros el arreglo con los 10 números capturados, el número de elementos del arreglo (en este caso 10) y el número del cual se desea saber su posición dentro del arreglo.. La función regresa -1 si el número que se busca no se encuentra en el arreglo y en caso contrario, regresa la primera posición del arreglo que contiene dicho número.

El programa también utiliza una función llamada MuestraArreglo que no regresa valor alguno, sólo recibe como parámetros el arreglo y el número de elementos. Esta función imprime en pantalla los elementos del arreglo separados por un tabulador.

Para pasar a una función un arreglo de dos dimensiones, si debemos indicar el tamaño de la segunda dimensión del arreglo

Ejemplo:int MiFuncion(int mi_arreglo[][5], int num_elementos);

El siguiente programa le pide al usuario que introduzca 9 números y los almacena en un arreglo de dos dimensiones, en este caso una matriz de 3×3; posteriormente utiliza una función llamada ImprimeMatriz para mostrar como quedaron almacenados los números en la matriz. Dicha función recibe como parámetros, la matriz de 3×3 y el tamaño de la primera dimensión (normalmente la primera dimensión son filas y la segunda dimensión columnas).

VÍDEOS DE APOYO