INSTITUTO TECNOLOGICO

DE ZACATEPEC.
ALUMNA:
ARMAS MENA MARLEN.
DOCENTE:
PATRICIA ADRIANA
GUADARRAMA
INGENIERIA QUIMICA
VA


Arreglos unidimensionales
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, la cota superior y la inferior.

Los arreglos unidimensionales, son estructuras de datos

típicamente estáticas en la mayoria de los lenguajes de
programación, usan posiciones de memoria que están
contiguas y que se indexan de forma numérica.

En C++ los arreglos se declaran de la siguiente forma:

Tipodedato nombredelarreglo[tamañodelarreglo];

Como podemos ver, es similar a declarar una variable

convencional, solo que se coloca entre corchetes el número de

posiciones del arreglo, por lo que todas las posiciones serán del
mismo tipo.

Al trabajar cada noche arreglos hacemos referencia a cada

posición del arreglo a través de su número de índice, el cual
comienza a partir del cero.

Parra llenar todos los elementos del arreglo es común emplear

un ciclo que nos permita recorrer el arreglo desde la primera
hasta la última posición

Un ejemplo de un arreglo:

#include<stdio.h> //Biblioteca que se utilizara

int main(){ //Damos inicio del programa
//mediante un main, se abre llave.

char vocales[]={'a','e','i','o','u'}; //Se inicializa un arreglo,

// donde por igual se define
//lo que contiene el arreglo

for (int i=0; i<5; i++){ //Se inicia un ciclo for, dentro
// de el se definió la variable i, que
//será el contador, donde nos dice que
// empezara desde la posición 0, dará 5
// valores del arreglo.

printf ("%c\n", vocales [i]); //Nos dice que mostrara un

//mensaje en pantalla donde nos dirá
//los valores que contiene el arreglo
} //Se cierra llave, del ciclo for.

} //Se cierra llave, finaliza el main.

#include <stdio.h> //Libreria principal del programa

#include<conio.h> //Libreria para poder utilizar la funcion getch
using namespace std; //Sirve para la entrada y salida de datos del
programa
int main (){ //Inicio de funcion princial de c
int numeros[]={'1','2','3','4','5'}; //se define vector que indica
que son 5 elementos
int suma=0; //declara la variable, que almacena el resultado de
la suma del vector
for (int i=0; i<5; i++){ //ciclo que desde i=0 hasta el numero 5
suma+=numeros[i]; //inicializa la suma, para que realice la
operacion
} //fin del ciclo
count<<"La suma de los vectores", <<suma>>endl; //mostrara
en pantalla la suma de los valores del vector
getch();//Funcion

getch

} //Finaliza funcion principal

Arreglos multidimensionales
En C++ podemos concebir un arreglo como una variable que
almacena a otras variables. Podemos hacer arreglos de cualquier
tipo de variable, incluso de otros arreglos. Cuando hacemos que
cada locación de un arreglo contenga otro arreglo, estamos
hablando de arreglos de dos dimensiones que son más
comúnmente llamados matrices.

Declaración de una matriz

Arreglos de más de dos dimensiones
Dimensiones máximas

Declaración de una matriz

Como ya se decía, las matrices las podemos ver como un arreglo de
arreglos o un arreglo de dos dimensiones. Un arreglo sencillo de
enteros de tamaño N se puede declarar como int arr[N];. Si
queremos hacer un arreglo de de tamaño M de arreglos de tamaño
N de enteros entonces habría que hacer algo como int mat[M][N];.

Si buscamos una representación gráfica un arreglo y de una matriz

entonces podríamos pensar en un arreglo como una lista (o un
renglón) y una matriz como una tabla.

Nota que el arreglo arr está declarando N variables y la matriz mat

está declarando N M variables, es decir, está declarando M arreglos
de tamaño N cada uno. Nos referimos al primer arreglo como
mat[0][]; y al primer elemento del primer arreglo como mat[0][0];.
Si queremos referirnos al quinto elemento del tercer arreglo sería
mat[2][4];. Nótese que no podemos hacer algo como cout <<
mat[x] pues nos estaríamos refiriendo a todo un arreglo, no a un
solo elemento.

Nota que siempre puedes referirte a los arreglos como las

columnas o como las filas de manera prácticamente indistinta, pero
es muy importante que mantengas el mismo criterio en todo el
programa. Si estás manejando int mat[x][y] como una matriz de x
columnas por y filas tienes que manejarlo así siempre en tu
implementación y del mismo modo, si quieres considerar esa
misma matriz como una matriz de x filas por y columnas tienes que
mantenerte así siempre. Lo mismo si quieres considerarlo como un
arreglo de x arreglos de tamaño y
o al revés.

Arreglos de más de dos dimensiones

Siempre puedes declarar arreglos de más de dos dimensiones.

Puedes agregar hasta 8 dimensiones en un mismo arreglo. Esta
clase de implementaciones son útiles en diferentes situaciones,
por ejemplo, si quieres representar un calendario en donde
debas guardar algún dato para cada día de cada mes de algunos
años, en este ejemplo puedes usar un arreglo de tres
dimensiones.

Nota que puedes seguir la misma forma de pensamiento que te

propongo sobre verlo como un arreglo de arreglos de arreglos de
alguna clase de variable. Nota que todos los elementos de estos
arreglos multidimensionales de estos ejemplos son de tipo entero,
aunque puedes hacerlo de cualquier otro tipo.

Dimensiones máximas

No sólo hay que considerar que máximo podemos declarar un arreglo

de ocho dimensiones. Tienes que recordar siempre la cantidad de
memoria que estás utilizando entonces es muy probable que esa no
sea una respuesta correcta.

Ejemplo:

Ejemplo:

#include<iostream> //libreria
using namespace std; //se usa en todas las bibliotecas estándar,
//de modo que todas las funciones y clases
//estándar se declaran y definen en ese espacio.

int main(){ //punto de inicio de su ejecución

//1 2 3 //De esta manera se realizara el arreglo

//4 5 6

int multi [2][3]={{1,2,3},{456}}; //Con los arreglos multidimensionales,

van dos
//corchetes y en el primero va numero de filas
//Del otro lado las columnas, despues daremos
//un igual inicializando los arreglos.

count <<multi[1][1]<<end1; //Con esto mandaremos a imprmir el

arreglo, desde la
//posicion/cordenada, ejemplo en el lado de
//la fila 0 y columna 2, significa que nos dara
//como valor 3 porque se encuentra
//en la cordenada

return 0; //retorna un valor

} //fin de la ejecucion

 En un complejo industrial se desea incentivar a los

encargados de turnos de producción. A cada encargado le
corresponde un turno. Hay 18 turnos, y por cada uno de ellos
40 operarios. Para evaluar a los encargados se ha hecho una
encuesta entre los trabajadores. Se les ha pedido que evalúen
a su encargado de 0 a 10 siendo el 5 el aprobado. Los
resultados están almacenados en un array tipo Nota[turno,
operario] donde turno indica el número de turno y operario el
número de operario dentro del turno. Desarrollar un
programa que determine en qué turnos todos los operarios
del mismo han aprobado al encargado.

Nota: generar un archivo que contenga los datos a partir de

un programa auxiliar que genere los datos y los guarde en un
archivo de nombre evaluacion.dat. La generación de datos
será pseudoaleatoria pero de forma “dirigida” para poder
comprobar el funcionamiento del programa. Sabiendo que
cada turno tiene 40 empleados, dejaremos una generación
pseudoaleatoria entre 0 y 10 para todos los turnos excepto
los número 3 y 18 (asociados a los datos 81 a 120 y 681 a
720), en los que los datos generados se deberán encontrar
entre 5 y 10, de modo que sabemos de antemano que todos
los empleados de los turnos nº3 y nº18 "han aprobado" a su
encargado.

TDA: Tipos de Datos Abstractos

TDA (Tipo de Datos Abstractos): Un tipo de dato abstracto
(TDA) o Tipo abstracto de datos (TAD) es un modelo
matemático compuesto por una colección de operaciones
definidas sobre un conjunto de datos para el modelo. Cuando se
usa en un programa de computación, un TDA es representado
por su interfaz, la cual sirve como cubierta a la correspondiente
implementación. La idea es que los usuarios de un TDA tengan
que preocuparse sólo por la interfaz, pero no por la
implementación, ya que esta puede ir cambiando con el tiempo
y, si no existiera encapsulación, afectar a los programas que
usan el dato. Esto se basa en el concepto de Ocultación de
información, una protección para el programa de decisiones de
diseño que son objeto de cambio.
La solidez de un TDA reposa en la idea de que la
implementación está escondida al usuario. Solo la interfaz es
pública. Esto significa que el TDA puede ser implementado de
diferentes formas, pero mientras se mantenga consistente con
la interfaz, los programas que lo usan no se ven afectados.
Hay una diferencia, aunque a veces sutil, entre el Tipo de Dato
Abstracto y la Estructura de Dato usada en su implementación.
Por ejemplo, un TDA de una lista puede ser implementado
mediante un Arreglo o una Lista Enlazada o hasta un Árbol
binario de búsqueda. Una lista es un Tipo de Dato Abstracto con
operaciones bien definidas (agregar elemento, agregar al final,
agregar al principio, recuperar, eliminar, etc) mientras una lista
enlazada es una estructura de datos basada en punteros o
referencias (dependiendo del lenguaje) que puede ser usada
para crear una representación de una Lista.

Para separar la interfaz del TDA, es decir aquellas funciones y tipos

que el programador "usuario" utilizará, de los detalles de
implementación, vamos a utilizar los archivos headers de C. Es decir,
los .h.

Interfaz: declarada en el archivo .h

Implementación: declarada en el .c
Y el programa de prueba o cliente deberá símplemente incluir el .h
#include "lista.h"

Definiendo la interfaz
Dentro del .h vamos a definir:
Los tipos: typedef y structs
Los "prototipos" de las funciones (es decir, las firmas, pero no la
implementación de las funciones).
Ahora, existe un "truco" que se utiliza en estos casos, porque, por un
lado necesitamos exponer un tipo de dato (es decir un typedef y un
struct), pero por otro lado, no podemos definir la representación
interna de los structs, es decir, qué miembros o datos tendrá y de qué
tipo.

Para esto:
En el .h
Se define un "struct" vacío
Se define un "typedef" de puntero al struct
Todas las funciones van a hacer referencia al tipo "typedef"
Luego el .c va a definir un nuevo struct con el mismo nombre que el
definido en el .h de esta forma se va a "sobrescribir" el original vacío
por el nuevo que sí tendrá los datos.

Bibliografias
Arreglos Unidimensionales y Bidimensionales - En C++ los
arreglos se declaran de la siguiente forma: - StuDocu

Arreglos unidimensionales en C++ – Sistemasumma.com

Arreglos unidimensionales en C++ – Sistemasumma.com
Arreglos.pdf (ugto.mx)
Programación II - Implementación de un TDA en C
(google.com)