Contenido Unidad V Arreglos

INSTITUTO TECNOLOGICO DE ORIZABA
UNIDAD V.- ARREGLOS
Arreglos en C++
Un arreglo es una colección ordenada de variables del mismo tipo. Las variables que
pertenecen a un arreglo se conocen por el nombre de elementos. El término ordenado
significa que en la colección hay un primer elemento, un segundo elemento, un tercer
elemento, y así sucesivamente. Además, los elementos pueden a su vez organizarse en
subgrupos llamadas dimensiones.
En resumen, un arreglo:
•No es una variable; es un grupo de variables conocidas como elementos
•Cada elemento ocupa una posición dentro del grupo
•Todos los elementos son del mismo tipo
•El nombre del arreglo indica donde se localiza el grupo en la memoria de la computadora.
•Los arreglos se clasifican de acuerdo a las dimensiones que tengan
•Las dimensiones no tienen relación con el plano Cartesiano; nada que ver con matemática
•Las dimensiones indican como están organizados los elementos dentro del grupo
•Los arreglos de dos dimensiones pueden visualizarse como tablas
•Los valores que se guarden en el arreglo se almacenan en los elementos ya que los
elementos son las variables
Para crear arreglos en C++, hay que indicar el tipo de los elementos (ejemplo, int, char,
double, bool o un tipo definido por el programador)
2. el nombre del arreglo
3. la cantidad de dimensiones y sus tamaños; cada dimensión comienza con el signo
[ seguido por el tamaño de la dimensión y termina con el signo ]
Para crear un arreglo de una dimensión, el formato es el siguiente:
<tipo de los elementos> <nombre del arreglo> [ <tamaño primera dimensión> ]
Para determinar la cantidad de elementos en un arreglo, hay que multiplicar el tamaño de
cada una de las dimensiones indicados en la declaración. El tamaño debe ser un literal de
tipo entero o el nombre de una constante de tipo entero.
Para nombrar un elemento en un arreglo hay que indicar el nombre del arreglo, seguido de
tantas parejas de corchetes [ ] como dimensiones declaradas. Dentro de cada pareja de
corchetes tiene que haber un índice. La combinación de los índices indica la posición del
elemento dentro del grupo. El valor mínimo para un índice es 0. El valor máximo es uno
menos que el tamaño de la dimensión correspondiente en la declaración del arreglo.
Arreglo unidimensional
El subgrupo más pequeño posible se conoce como un arreglo de una dimensión. Un arreglo
unidimensional tiene una sola dimensión. En C#, la dimensión se maneja por medio de un
par de corchetes. A los arreglos de una dimensión también se les llama listas.
Ejemplo #1. Arreglo de una dimensión

Declaración
int a[3]; // forma una secuencia de tres elementos

Nombre del grupo
a Nombre de los elementos
a[0] → primer elemento
a[1] → segundo elemento
a[2] → tercer elemento
Operaciones con arreglos unidimensionales.

Para manejar un arreglo, las operaciones a efectuarse son:
Declaración del arreglo,

Creación del arreglo,
Inicialización de los elementos del arreglo, y
Acceso a los elementos del arreglo.
A continuación describiremos cada una de estas operaciones, en C#.
Declaración.
La declaración de un arreglo unidimensional consiste en establecer las características del
arreglo y sus elementos, por medio de la siguiente sintaxis:
<tipo> [ ] < identificador > ;
Donde:
tipo indica el tipo correspondiente a los elementos del arreglo ,
identificador es el nombre del arreglo, y
el par de corchetes, [ ], representa la dimensión del arreglo y encierra un número entero que
corresponde al número de elementos del arreglo.
Ejemplos:
int [ ] a ;
float [ ] distancia ;
Artículo [ ] art = new Artículo[ 3];
Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se debe a que,
durante dicha operación, no se reserva espacio en la memoria.
Creación.
La creación de un arreglo unidimensional consiste en reservar espacio de memoria para
todos sus elementos, utilizando la siguiente sintaxis:
< identificador > = new <tipo> [ tamaño ] ;
Donde:
new es el operador para gestionar espacio de memoria, en tiempo de ejecución,
tamaño es un número entero que representa el número de elementos del arreglo.
Ejemplos:
a = new int [10] ; // Se crea el arreglo a , con 10 elementos de tipo entero.
distancia = new float[ 5] ; // Se crea el arreglo distancia , con 5 elementos de punto flotante
y precisión sencilla .Artículo [] art = new Artículo[3];
Artículo [ ] art = new Artículo[ 3]; // Se crean 3 referencias a objetos de la clase Artículo
art[0]= new Artículo(); // Se crea el primer objeto del arreglo art
art[1]= new Artículo(); // Se crea el segundo objeto del arreglo art
art[2]= new Artículo(); // Se crea el tercer objeto del arreglo art
Las dos primeras operaciones de declaración y creación anteriores se pueden agrupar en

una sola instrucción, como se muestra enseguida:
int [ ] a = new int [10] ;
float [ ] distancia = new float[5] ;
Inicialización.
Un arreglo es un objeto que,cuando es creado por el compilador, se le asignan

automáticamente valores iniciales predeterminados a cada uno de sus elementos, de
acuerdo a los siguientes criterios:
Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.
Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.
Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.
Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es posible
agrupar las operaciones de declaración, creación e inicialización en una sola instrucción,
por ejemplo:
int [ ] a = { 1, 0,4,-6, 2,9, 23,455, 90,35 };
float [ ] distancia = { 2.50F, 286.45F, 46.75F, 30.62F, 93.00F };
string [ ] pato = { "Hugo", "Paco", "Luís" };
Acceso.
Se puede acceder a los valores de los elementos de un arreglo a través del nombre del
arreglo y un subíndice. El subíndice debe escribirse entre corchetes y representa la posición
del elemento en el arreglo. Así, podemos referirnos a un elemento del arreglo escribiendo el
nombre del arreglo y el subíndice del elemento entre corchetes. Los valores de los
subíndices empiezan en cero para el primer elemento, hasta el tamaño del arreglo menos
uno.
Ejemplo:
float [ ] distancia = new float[5] ; // Crea el arreglo distancia con 5 elementos.
float x = 25F, y = 10F ; // Crea dos variables de punto flotante y precisión sencilla.
distancia[0] = x + y ; // El valor asignado al primer elemento es 35.
distancia[1] = ++distancia[0] ; // Asigna 36 al segundo elemento.
distancia[2] = distancia[1] - distancia[0] + 4 ; // Asigna 5 al tercer elemento.
distancia[3] = distancia[2]-- ; // Asigna 5 al cuarto elemento
// y disminuye en 1 el valor del tercero.
distancia[4] = distancia[3] * distancia[2] ; // Asigna 20 al quinto elemento.
y = distancia[4] ; // Asigna a y el valor almacenado en el quinto elemento.
Aplicaciones.
Listas.
Resolvamos el problema de manejar dos listas: una con los nombres de un grupo de
alumnos y otra con una calificación para cada uno de los alumnos.
Primero se deberán leer los nombres de los alumnos y la calificación que corresponde a
cada uno de ellos y después habrá que desplegar dos columnas: una con los nombres de los
alumnos y la otra con sus respectivas calificaciones.
La lectura debe lucir de manera similar a la siguiente:
Número de alumnos: 30
Nombre [0] :
Calificación[0] :
Nombre [1] :
Calificación[1] :
Nombre [2] :
Calificación[2] :
...
...
Nombre [29] :
Calificación[29] :
El despliegue en el monitor luciría así:
No. Nombre Calif.

1 Hugo 100
2 Paco 90
3 Luís 95
... ...
30 Donald 70
El siguiente código corresponde a un programa que resuelve el problema.
// Lista.cs : Lee una lista de nombres y calificaciones correspondientes a un grupo de
// alumnos de una materia.
using System;
using C = System.Console;
public class Lista

{
public static void Main()
int nAlumnos;
C.Write("Número de alumnos: ");

nAlumnos = Convert.ToInt32(C.ReadLine());
string [ ] alumnos = new string[nAlumnos]; //Crea el arreglo de
//alumnos.
int [ ] calif = new int [nAlumnos]; // Crea el arreglo de calificaciones.
// Lee los elementos de los dos arreglos.
for(int i = 0; i < nAlumnos ; i++)

{
C.Write("Nombre del alumno [" + i + "] : ");

alumnos[i] = C.ReadLine( );
C.Write("Calificación [" + i + "] : ");

calif[i] = Convert.ToInt32(C.ReadLine( ));
// Despliega los valores de los dos arreglos.
C.WriteLine("No. Nombre Calif.");
for(int i = 0 ; i < nAlumnos ; i++)

{
C.Write(" " + (i+1) + ".- " + alumnos[ i] );

C.WriteLine(" " + calif[i] );
Vectores.
Otra de las aplicaciones de los arreglos es el manejo de vectores.

Los vectores son una forma de almacenar datos que permiten contener una serie de valores
del mismo tipo, cada uno de los valores contenidos tiene una posición asociada que se usará
para accederlos. Está posición o índice será siempre un número entero positivo.
En C la cantidad de elementos que podrá contener un vector es fijo, y en principio se define

cuando se declara el vector. Los vectores se pueden declarar de la siguiente forma:
tipo_elemento nombre[largo];
Esto declara la variable nombre como un vector de tipo_elementos que podrá contener
largo cantidad de elementos, y cada uno de estos elemento podrá contener un valor de tipo
tipo_elemento.
Por ejemplo:
double valores[128];
En este ejemplo declaramos un vector de 128 elementos del tipo double, los índices de los
elementos irían entre 0 (para el primer elemento y 127 para el último).
De la misma forma que con las otras declaraciones de variables que hemos visto se le puede
asignar un valor iniciar a los elementos.
O también se pueden declarar:
tipo_elemento nombre[largo]={valor_0, valor_1, valor_2};

En caso estamos asignadole valores a los primeros 3 elementos del vector nombre. Notar
que largo debe ser mayor o igual a la cantidad de valores que le estamos asignando al
vector, en el caso de ser la misma cantidad no aporta información, por lo que el lenguaje
nos permite escribir:
tipo_elemento nombre[]={valor_0, valor_1, valor_2};

Que declarará nombre como el vector de largo 3.
Para acceder a un elemento accederemos a través de su posición. Es decir:
tipo_elemento elemento;
...
elemento = nombre[2];
Asumiendo que tenemos el vector anterior definido estaríamos guardando valor_2 en
elemento.
Veamos algunos ejemplos:
/*
* Ejemplo : El producto escalar de dos vectores
*/
#include <stdio.h>
double producto_escalar(double v1[], double v2[], int d);
int main()
{
const int largo = 3;

double vector_1[] = {5,1,0};
double vector_2[] = {-1,5,3};
double resultado = producto_escalar(vector_1, vector_2, largo);
// imprime el resultado
printf("(%f, %f, %f) . (%f, %f, %f) = %f\n",
vector_1[0], vector_1[1], vector_1[2],
vector_2[0], vector_2[1], vector_2[2],
resultado);
return 0;
}
/* producto escalar entre dos vectores */

double producto_escalar(double v1[], double v2[], int d)
{
double resultado = 0;
int i;
for (i=0; i < d; i++) {
resultado += v1[i] * v2[i];
}
return resultado;
}
En el ejemplo anterior usamos los vectores de C para representar vectores matemáticos y
calcular el producto vectorial entre ellos. Una peculiaridad que se puede notar es que al
recibir un arreglo en una función no se especifica el largo, volveremos a esto en un capítulo
posterior.
Otra función clásica es la búsqueda de un máximo o mínimo, que podemos escribirla de la

siguiente manera:
int buscar_maximo(double valores[], int num_valores)

{
int maximo_pos = 0;
for (int i = 1; i < num_valores; i++) {
if (valores[i] > valores[maximo_pos]) {
maximo_pos = i;
}
}
return maximo_pos;
}
Otro ejemplo sencillo, calcular el promedio de los valores.
double promedio(double valores[], int largo)

{
double suma=0;
for (int i=0;i<largo;i++) {

suma+=valores[i];
}
return suma/largo;
}
Cuando una función recibe un vector por parámetro y cambia su contenido y el cambio es
permanente (se ve aún fuera de la función). Esto puede parecer extraño después del énfasis
que pusimos en resaltar que todos los parámetros de una función se reciben por valor, pero
se aclarará en el siguiente capitulo.
Mientras tanto usemos esto para definir una función que le aplique otra función que recibe
por parámetro a cada elemento del vector, guardando el resultado en el mismo vector y una
llamada de ejemplo a esta.
void cuadrados(double vector[], int largo)

{
for (int i=0;i<largo;i++) {
vector[i]=cuadrado(vector[i]);
}
}
...
double cuadrado(double valor) {
return valor*valor;
}
...
cuadrados(elementos,num_elem);
...
De la misma forma que venimos usando vectores de tipos básicos, podemos tener vectores
de vectores, estos se declaran de la siguiente forma:
int matriz[3][7];
int tabla[3][4]={ { 1, 2, 3, 4},
{ 5, 6, 7, 8}, /* los espacios y saltos de líneas no son tomados en cuenta */
{ 9,10,11,12} };
double v[2][2][2];
...
printf("tabla[0][1]: %i\n", tabla[0][3]); // Imprime 4
printf("tabla[2][0]: %i\n", tabla[2][0]); // Imprime 9
...
En este ejemplo tabla es un vector de longitud 3, cuyos elementos son vectores de longitud
4 de elementos de tipo int.
En resumen, suponiendo que v[n] es un vector de cualquier tipo de dato con n cantidad de
posiciones, al vector v se le aplican las siguientes reglas:
1.La primera posición siempre será v[0]

2.La última posición es v[n-1]
3.En versiones previas a C99 n es una constante definida antes de la declaración de v[n]
Arreglo bidimensional
Un arreglo de dos dimensiones se subdivide en arreglos de una dimensión. Un arreglo

bidimensional tiene dos dimensiones y es un caso particular de los arreglos
multidimensionales. En C#, las dimensiones se manejan por medio de un par de corchetes,
dentro de los que se escriben, separados por comas, los valores de las dos dimensiones.
Este tipo de arreglos al igual que los anteriores es un tipo de dato estructurado, finito
ordenado y homogéneo. El acceso a ellos también es en forma directa por medio de un par
de índices.
La representación en memoria se realiza de dos formas: almacenamiento por columnas o
por renglones.
Operaciones con arreglos bidimensionales.
Para manejar un arreglo, las operaciones a efectuarse son:
Declaración del arreglo,

Creación del arreglo,
Inicialización de de los elementos del arreglo, y
Acceso a los elementos del arreglo.
A continuación describiremos cada una de estas operaciones, en C#.
Declaración.
La declaración de un arreglo consiste en establecer las características del arreglo y sus
elementos, por medio de la siguiente sintaxis:
<tipo> [ , ] < identificador > ;
Donde:
tipo indica el tipo correspondiente a los elementos del arreglo ,
identificador es el nombre del arreglo, y
el par de corchetes y la coma, [ , ], representan las dimensiones del arreglo y encierra dos
números enteros, cuyo producto corresponde al número de elementos del arreglo.
Ejemplos:
double [ , ] matriz ;
int [ , ] ubicación ;
Rama [ , ] árbol; // Rama es una clase.
Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se debe a que,
durante dicha operación, no se reserva espacio en la memoria.
Creación.
La creación de un arreglo bidimensional consiste en reservar espacio en la memoria para
todos sus elementos, utilizando la siguiente sintaxis:
< identificador > = new <tipo> [ dim1, dim2 ] ;
Donde:
new es el operador para gestionar espacio de memoria, en tiempo de ejecución,
dim1 y dim2 son valores enteros que representan las dimensiones del arreglo.
El tamaño del arreglo es el resultado de multiplicar los valores de las dimensiones y

representa el número de elementos del arreglo.
Ejemplos:
matriz = new double [2, 3] ; // Se crea el arreglo matriz, con 6 elementos de tipo
//punto flotante y precición doble .
ubicación = new int[ 4,2] ; // Se crea el arreglo ubicación, con 8 elementos de
//tipo entero de 32 bits .
árbol = new Rama[5,2] ; // Se crea el arreglo arbol, con 10 objetos
//de la clase Rama.
Las operaciones de declaración y creación anteriores se pueden agrupar en una sola

instrucción, como se muestra enseguida:
double [ , ] matriz = new double [2,3] ;
int [ , ] ubicación = new int[4, 2] ;
Rama [ , ] alumno = new Rama[5,2] ;
Inicialización.
Un arreglo es un objeto que,cuando es creado por el compilador, se le asignan
automáticamente valores iniciales predeterminados a cada uno de sus elementos, de

acuerdo a los siguientes criterios:
Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.
Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.
Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.
Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es posible
agrupar las operaciones de declaración, creación e inicialización en una sola instrucción,
por ejemplo:
double [ , ] matriz = { {1.5, 0, 4, -6.5, 2 } , {2.3, 9, 3.5, 4.8, 6.2} };
int [ , ] ubicación = { {2, 4} , {6, 8} , {9, 10}, {5 , 1}};
string [ , ] funcionario = { {"Hugo", "jefe"} ,
{ "Paco", "operador "},
{ "Luís","ayudante"} };
Acceso.
Se puede acceder a los valores de los elementos de un arreglo bidimensional a través del
nombre del arreglo y dos subíndices. Los subíndices deben escribirse entre corchetes y
representa la posición del elemento en el arreglo. Así, podemos referirnos a un elemento del
arreglo escribiendo el nombre del arreglo y los subíndices del elemento entre corchetes. Los
valores de los subíndices empiezan en cero para el primer elemento, hasta el tamaño del
arreglo menos uno.
Ejemplo:
int [ , ] posición = new int[5, 10] ; // Crea el arreglo posición , con 50 elementos de tipo
entero.
int x;
posición[ 3, 5] = 3 ;
x = posición[ 3, 5] ;
Aplicaciones.
Matrices.
Una matriz es un arreglo rectangular de dos dimensiones, donde el acomodo de los

elementos está dispuesto en renglones y columnas.
Ejemplo 1:
Se debe controlar la ubicación de los asistentes a una sala de conferencias por medio de un
gafete que tiene escrito el nombre del asistente, la fila y la columna donde se ubica su
asiento.
El siguiente segmento de código muestra la solución con arreglos bidimensionales.
string [ , ] asistente = new string[10,12] ;
// Inicializa los valores de los nombres con cadenas vacías.
for(int i=0 ; i < 10 ; i++ ) // Controla la fila.
for(int j=0 ; j < 12 ; j++ ) // Controla la columna.
asistente[ i , j ] = " " ;
// Captura los nombres de todos los asistentes y les asigna sus asientos,
// en el orden en que van llegando.
asistente[ i , j ] = System.Console.ReadLine( );
// Despliega los nombres de todos los asistentes.
System.Console.WriteLine( asistente[ i , j ] );
Ejemplo 2 :
Dada la matriz A :
895
632
y la matriz B :
714
503
Elaborar un programa en C# para obtener la suma de ambas matrices: S = A + B
// SumMatrices.cs : Suma dos matrices de 2 renglones y 3 columnas.
using System;
using C = System.Console;
namespace Sumatrices
{
class Matriz
{
public static void Main()

{
const int r = 2, c = 3;
int i, j;
double[,] A = new double[r, c];

double[,] B = new double[r, c];
double[,] S = new double[r, c];
C.Clear();
// Lectura de valores para los elementos de A.
C.WriteLine("Suma de las matrices A y B de 2x3\n");

C.WriteLine("\nTeclee los valores de la Matriz A\n");
for (i = 0; i < r; i++)
for (j = 0; j < c; j++)

{
C.Write(" A[{0},{1}] = ",i,j);

A[i, j] = Double.Parse(Console.ReadLine());
}
// Lectura de valores para los elementos de B.
C.WriteLine("\nTeclee los valores de la Matriz B\n");
for (i = 0; i < r; i++)
for (j = 0; j < c; j++)

{
C.Write(" B[{0},{1}] = ", i,j);

B[i, j] = Double.Parse(Console.ReadLine());
// Suma y despliegue de la matriz resultado.
C.WriteLine("\nMatriz S = A+B\n");
for (i = 0; i < r; i++)

{
for (j = 0; j < c; j++)

{
S[i, j] = A[i, j] + B[i, j];

C.Write(" " + S[i, j]);
C.WriteLine();
Un arreglo de tres dimensiones se subdivide en arreglos de dos dimensiones los cuales a su

vez se dividen en arreglos de una dimensión. Un arreglo de cuatro dimensiones se
subdivide en arreglos de tres dimensiones los cuales a su vez se dividen en arreglos de dos
dimensiones los cuales a su vez se dividen en arreglos de una dimensión. La misma idea se
aplica en arreglos de más dimensiones.
Ejemplo #2. Arreglo de dos dimensiones

Declaración
char m[2][3]; // forma una tabla de dos filas y tres columnas
// cada fila es un arreglo de una dimensión
// la declaración indica que hay dos arreglos de una dimensión
Nombre del grupo
m → indica la localización del grupo en la memoria
Nombre de las filas
m[0] → primera fila → indica la localización de la fila dentro del grupo
m[1] → segunda fila → indica la localización de la fila dentro del grupo
Nombre de los elementos
m[0][0] → primer elemento
m[0][1] → segundo elemento
m[0][2] → tercer elemento
m[1][0] → cuarto elemento
m[1][1] → quinto elemento
m[1][2] → sexto elemento
Ejemplo #3. Arreglo de tres dimensiones

Declaración
double w[2][2][3]; // forma dos tablas de dos filas y tres columnas
// cada fila es una secuencia de tres elementos
// cada fila es un arreglo de una dimensión
// la declaración indica que hay dos arreglos de dos dimensiones
// los arreglos de dos dimensiones tienen a su vez dos arreglos de una dimensión
Programas
#include<stdio.h>
#include<conio.h>
void main ()
{
int num[20]={5,67,8,90,345,12,33,45,78,1,2,78,900,67,345,12,21,5,98,1000};
int i,dato;
clrscr();
printf("de un numero entero : \n");
scanf("%d",&dato);
for (i=0;i<=19;i++){
if (dato==num[i]){
textcolor(RED);
cprintf("\nEl %d se encuentra en la posicion %d del arreglo \n",dato,i);
}
else {
printf("\nEl %d NO se encuentra en la posicion %d del arreglo \n",dato,i);}}
getch();
}
#include<stdio.h>
#include<conio.h>
void main ()
{
int num[20]={5,67,8,90,345,12,33,45,78,1,2,78,900,67,345,12,21,5,98,1000};
int i,dato,bandera=0;
clrscr();
printf("de un numero entero : \n");
scanf("%d",&dato);
for (i=0;i<=19;i++){
if (dato==num[i]){
printf("\nEl %d se encuentra en la posicion %d del arreglo \n",dato,i);
bandera=1;
}
}
if (bandera==0){
printf("\nNO");
}
getch();
}
#include<stdio.h>
#include<conio.h>
void main ()
{
int num[20];
int i,dato,bandera;
char resp;
clrscr();
for (i=0;i<=19;i++){
printf("\nDame el elemento %d ",i);
scanf("%d",&num[i]);
}
do{
bandera=0;
printf("\nde un numero entero : \n");
scanf("%d",&dato);
for (i=0;i<=19;i++){
if (dato==num[i]){
printf("\nEl %d se encuentra en la posicion %d del arreglo \n",dato,i);
bandera=1;
}}
if (bandera==0){
printf("\nNO");}
printf("\nQuieres buscar otro número en el arreglo s/n");
resp=getch();
}while(resp=='s');
getch();}

Contenido Unidad V Arreglos

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Contenido Unidad V Arreglos

Cargado por

Copyright:

Formatos disponibles

INSTITUTO TECNOLOGICO DE ORIZABA

UNIDAD V.- ARREGLOS

Ejemplo #1. Arreglo de una dimensión

int a[3]; // forma una secuencia de tres elementos

Operaciones con arreglos unidimensionales.

Declaración del arreglo,

<tipo> [ ] < identificador > ;

tipo indica el tipo correspondiente a los elementos del arreglo ,

identificador es el nombre del arreglo, y

Artículo [ ] art = new Artículo[ 3];

< identificador > = new <tipo> [ tamaño ] ;

new es el operador para gestionar espacio de memoria, en tiempo de ejecución,

tamaño es un número entero que representa el número de elementos del arreglo.

a = new int [10] ; // Se crea el arreglo a , con 10 elementos de tipo entero.

art[0]= new Artículo(); // Se crea el primer objeto del arreglo art

art[1]= new Artículo(); // Se crea el segundo objeto del arreglo art

art[2]= new Artículo(); // Se crea el tercer objeto del arreglo art

Las dos primeras operaciones de declaración y creación anteriores se pueden agrupar en

int [ ] a = new int [10] ;

float [ ] distancia = new float[5] ;

Un arreglo es un objeto que,cuando es creado por el compilador, se le asignan

int [ ] a = { 1, 0,4,-6, 2,9, 23,455, 90,35 };

float [ ] distancia = { 2.50F, 286.45F, 46.75F, 30.62F, 93.00F };

string [ ] pato = { "Hugo", "Paco", "Luís" };

distancia[0] = x + y ; // El valor asignado al primer elemento es 35.

distancia[1] = ++distancia[0] ; // Asigna 36 al segundo elemento.

distancia[2] = distancia[1] - distancia[0] + 4 ; // Asigna 5 al tercer elemento.

distancia[3] = distancia[2]-- ; // Asigna 5 al cuarto elemento

// y disminuye en 1 el valor del tercero.

distancia[4] = distancia[3] * distancia[2] ; // Asigna 20 al quinto elemento.

y = distancia[4] ; // Asigna a y el valor almacenado en el quinto elemento.

La lectura debe lucir de manera similar a la siguiente:

El despliegue en el monitor luciría así:

No. Nombre Calif.

El siguiente código corresponde a un programa que resuelve el problema.

// Lista.cs : Lee una lista de nombres y calificaciones correspondientes a un grupo de

// alumnos de una materia.

public class Lista

public static void Main()

C.Write("Número de alumnos: ");

string [ ] alumnos = new string[nAlumnos]; //Crea el arreglo de

int [ ] calif = new int [nAlumnos]; // Crea el arreglo de calificaciones.

// Lee los elementos de los dos arreglos.

for(int i = 0; i < nAlumnos ; i++)

C.Write("Nombre del alumno [" + i + "] : ");

C.Write("Calificación [" + i + "] : ");

// Despliega los valores de los dos arreglos.

C.WriteLine("No. Nombre Calif.");

for(int i = 0 ; i < nAlumnos ; i++)

C.Write(" " + (i+1) + ".- " + alumnos[ i] );

Otra de las aplicaciones de los arreglos es el manejo de vectores.

En C la cantidad de elementos que podrá contener un vector es fijo, y en principio se define

O también se pueden declarar:

tipo_elemento nombre[largo]={valor_0, valor_1, valor_2};

tipo_elemento nombre[]={valor_0, valor_1, valor_2};

Para acceder a un elemento accederemos a través de su posición. Es decir:

Veamos algunos ejemplos:

double producto_escalar(double v1[], double v2[], int d);

const int largo = 3;

double resultado = producto_escalar(vector_1, vector_2, largo);

/* producto escalar entre dos vectores */

Otra función clásica es la búsqueda de un máximo o mínimo, que podemos escribirla de la

int buscar_maximo(double valores[], int num_valores)