UNIVERSIDAD DON BOSCO

FACULTAD DE INGENIERIA
ESCUELA DE COMPUTACION
CATEDRATICO: ING. RAUL MARTINEZ RIVAS.
MATERIA: PROGRAMACIN I
UNIDAD IV.
ARREGLOS

4.1 Definicin de tipos de datos

NUMERO
PAGINAS
1/12
ING. EN CC.

4.2 Vectores
4.3 Arreglos
4.4 Introduccin a punteros
4.5 Aplicaciones de estructuras estticas de datos
Objetivo: Explicar al estudiante lo que son vectores y arreglos como una herramienta de
programacin.
4.1 Definicin de tipos de datos.
Los tipos de datos en C++ pueden clasificarse como:

"enteros" (sin decimales)

"flotantes"(con decimales, tienen representacin con coma flotante)
"caracteres"(letras)
"booleanos o lgicos"(representan valores verdaderos o falsos)

Cada uno de los tipos tiene a su vez, por as decirlo, subtipos, que slo se diferencian por
agregar una cualidad al tipo de dato base, alterando el manejo del contenido de los datos; con
signo, sin signo, ms largos en memoria, menos largos en memoria, entre otros. Veamos
especificaciones y ejemplos de ellos:
1. Enteros
1. int
2. short int
3. long int
4. unsigned short int
5. unsigned int
6. unsigned long int
2. Flotantes
1. float (IEEE754 Simple)
2. double (IEEE754 Normal)
3. long double (IEEE754 Extendido)
3. Caracter
1. char
4. Booleano
1. bool

El modificador unsigned se puede aplicar a enteros para obtener nmeros sin signo (por
defecto los enteros contienen signo), con lo que se consigue un rango mayor de nmeros
naturales.
La Palabra Clave "void"
La palabra clave void define en C++ el concepto de no existencia, o no atribucin de un tipo en
una variable o declaracin. Como tal, puede ser usada para destacar que una funcin no recibe
parmetros, como en:
int funcion (void);
, aunque la tendencia actual es la de no colocar la palabra "void".
Adems se utiliza para determinar que una funcin no retorna un valor, como en:
void funcion (int parametro);
Cabe destacar que void no es un tipo. Una funcin como la declarada anteriormente no puede
retornar un valor por medio de return: la palabra clave va sola. No es posible una declaracin del
tipo:
void t;
En este sentido, void se comporta de forma ligeramente diferente a como lo hace en C,
especialmente en cuanto a su significado en declaraciones y prototipos de funciones.
Sin embargo, la forma especial void * puede utilizarse como un ajuste que convierte cualquier
variable a una "variable sin tipo", la cual puede slo ser accedida y utilizada bajo una operacin
de cast. Por ejemplo:
void * memoria;
Indica que memoria es un puntero a alguna parte, donde se guarda informacin de algn tipo. El
programador es responsable de definir estos "algn", eliminando toda ambigedad. Una ventaja
de la declaracin "void *" es que puede representar a la vez varios tipos de datos, dependiendo
de la operacin de cast escogida. La memoria que hemos apuntado en alguna parte, en el
ejemplo anterior, bien podra almacenar un entero, un flotante, una cadena de texto, o un
programa, o combinaciones de stos. Es responsabilidad del programador recordar qu tipo de
datos hay y garantizar el acceso adecuado.
Todo programa en C++ debe tener la funcin main() (a no ser que se especifique en tiempo de
compilacin otro punto de entrada, que en realidad es la funcin que tiene el main()
int main()
{}
La funcin main debe tener uno de los siguientes prototipos:
int main()
int main(int argc, char** argv)

La primera es la forma por defecto de un programa que no recibe parmetros ni argumentos. La

segunda forma tiene dos parmetros: argc, un nmero describiendo el nmero de argumentos
del programa (incluyendo el nombre del programa mismo), y argv, un puntero a un array de
punteros, de argc elementos, donde el elemento argv[i] representa el i-simo argumento
entregado al programa.
El tipo de retorno de main es int. Al finalizar la funcin main, debe incluirse el valor de retorno
(por ejemplo, return 0;, aunque el estndar prev solamente dos posibles valores de retorno:
EXIT_SUCCESS y EXIT_ERROR, definidas en el archivo cstddef), o salir por medio de la
funcin exit. Alternativamente puede dejarse en blanco, en cuyo caso el compilador es
responsable de agregar la salida adecuada.
4.2 Vectores.
Un array (tambin conocido como arreglo, vector o matriz) es un modo de manejar una gran
cantidad de datos del mismo tipo bajo un mismo nombre o identificador. Por ejemplo,
mediante la sentencia:
double a[10];
se reserva espacio para 10 variables de tipo double. Las 10 variables se llaman a y se accede a
una u otra por medio de un subndice, que es una expresin entera escrita a continuacin del
nombre entre corchetes [...]. La forma general de la declaracin de un vector es la siguiente:
tipo nombre[numero_elementos];
Los elementos se numeran desde 0 hasta (numero_elementos-1). El tamao de un vector
puede definirse con cualquier expresin constante entera. Para definir tamaos son
particularmente tiles las constantes simblicas. Como ya se ha dicho, para acceder a un
elemento del vector basta incluir en una expresin su nombre seguido del subndice entre
corchetes. En C no se puede operar con todo un vector o toda una matriz como una nica
entidad, sino que hay que tratar sus elementos uno a uno por medio de bucles for o while. Los
vectores (mejor dicho, los elementos de un vector) se utilizan en las expresiones de C como
cualquier otra variable. Ejemplos de uso de vectores son los siguientes:
a[5] = 0.8;
a[9] = 30. * a[5];
a[0] = 3. * a[9] - a[5]/a[9];
a[3] = (a[0] + a[9])/a[3];

4.3 Arreglos (array)

En el caso especfico de la palabra inglesa "array", no haremos la traduccin de la misma. En C,
nos referimos a un array como un conjunto de datos todos del mismo tipo, siendo la cadena de
caracteres un tipo especial de array pues se trata de un conjunto de datos de tipo char que
termina con un caracter nulo, a este tipo de cadenas tambin se les conoce como "cadenas
ASCII-Z" y ser la que trataremos en primer lugar. Empezamos por definir un array de tipo char

y especificamos el tamao del mismo con un nmero, llamado subndice, encerrado entre
corchetes. Este nmero le indica al sistema la cantidad de espacios para caracteres que
contendr la cadena en cuestin. Los elementos de un array se almacenan en forma contigua
en la memoria de la computadora y el subndice del primer elemento siempre es cero. El nombre
del array es una constante que representa la direccin del primer elemento del array. Veamos
un cdigo de ejemplo:

#include <stdio.h>
int main()
{
char cadena[6]; /* Define una cadena de caracteres */
cadena[0]='L';
cadena[1]='e';
cadena[2]='t';
cadena[3]='r';
cadena[4]='a';
cadena[5]='s';
cadena[6]=0; /* Caracter nulo, significa el fin del texto */
printf("La cadena es %s\n", cadena);
printf("La tercera letra de la cadena es: %c\n", cadena[2]);
printf("Una parte de la cadena es : %s\n", &cadena[3]);
return 0;
}
La variable cadena es por tanto una cadena que puede almacenar hasta seis caracteres,
tomando en cuenta que se requiere un espacio para almacenar el carcter nulo al final de la
cadena. El smbolo %s mostrado en los enunciados printf( ) le indica al sistema que despliegue
una cadena de caracteres empezando con el elemento subndice cero, que en el cdigo de
ejemplo es la letra L, y continuando hasta encontrar el carcter nulo. Observe que en los
enunciados printf( ) cuando se indica la variable cadena sin corchetes indica que se despliegue
la totalidad de la cadena, en tanto que al indicar la variable cadena con algn valor entre
corchetes se refiere a un solo elemento de la cadena, en este caso debemos utilizar en el
enunciado printf( ) el smbolo %c que le indica al sistema que despliegue un solo carcter. El
smbolo & especifica la direccin en memoria de cadena[3], este smbolo lo estudiaremos mas
adelante. Compile y ejecute el cdigo de ejemplo para mayor claridad en lo aqu expuesto.
Modifiquemos nuestro cdigo para estudiar algunas funciones nuevas:

#include <stdio.h>
#include <string.h>
int main()
{
char cadena1[17], cadena2[13], titulo[26], prueba[29];
strcpy(cadena1, "Pedro Picapiedra");
strcpy(cadena2, "Pablo Marmol");
strcpy(titulo, "- - -Los Picapiedra- - -");
printf("%s\n\n\n", titulo);
printf("Los personajes principales son: %s\n", cadena1);
printf("y : %s\n\n", cadena2);
if(strcmp(cadena1, cadena2) > 0)
strcpy(prueba, cadena1);
else
strcpy(prueba, cadena2);
printf("La cadena mas grande es: %s\n\n", prueba);
strcpy(prueba, cadena1);
strcat(prueba, " y ");
strcat(prueba, cadena2);
printf("%s son vecinos\n", prueba);
return 0;
}

arrays de tipo int

Veamos ahora como trabajar con un array de tipo int en el siguiente programa que calcula la
tabla del 5:

#include <stdio.h>
int main()
{
static char titulo[]="Esta es la tabla del 5:";
int espacios[10];
int indice;
for(indice=0; indice < 10; indice++)
espacios[indice] = 5*(indice+1);

printf("%s\n\n", titulo);
for(indice=0; indice < 10; indice++)
printf("5 x %2d = %4d\n", (indice+1), espacios[indice]);
return 0;
}
Las primeras novedades las encontramos en la lnea 5 en donde podemos ver que hemos
declarado un array de tipo char llamado titulo el cual no tiene especificado valor alguno dentro
de los corchetes, esto se hace as para dejar que el sistema calcule el espacio necesario para la
cadena especificada del lado derecho de la sentencia incluyendo el caracter nulo del final de la
cadena, adems se ha declarado como static para evitar que el sistema asigne a la variable del
array titulo como automtica y de esta manera se garantiza que la variable contenga la cadena
especificada una vez que se ejecute el programa. En la siguiente lnea se declara un nuevo
array de tipo int, es decir, tenemos aqu diez variables de tipo int llamadas espacios[0],
espacios[1], espacios[2], etc. adems de una variable convencional de tipo int llamada indice.
En primer lugar asignamos valores a cada uno de los elementos del array utilizando para ello un
bucle for, mas adelante utilizamos un segundo bucle para desplegar en orden cada uno de los
valores almacenados en los elementos del array, el resultado de la ejecucin de este programa
es el siguiente:

arrays y funciones
En la leccin Funciones mencionamos que haba una forma de obtener datos de una funcin
utilizando un array, esto lo podemos ver en el cdigo siguiente en donde se ha definido un array
de 15 variables llamado matriz, luego asignamos algunos datos a estas variables y
desplegamos en pantalla las primeras cinco. En la lnea 17 llamamos a la funcin denominada
una_funcion tomando todo el array como parmetro poniendo el nombre del array en el
parntesis de la funcin.

#include <stdio.h>
void una_funcion(int nombre_interno[ ]);
int main()
{
int indice;
int matriz[15];
for (indice = 0; indice < 15; indice++)
matriz[indice] = indice + 1;
for (indice = 0; indice < 5; indice++)
printf("Valor inicial asignado a matriz[%d] = %d\n",
indice, matriz[indice]);
printf("\n");
una_funcion(matriz);

/*Llama a la funcin denominada una_funcion*/

for (indice = 0; indice < 5; indice++)

printf("Nuevo valor asignado a matriz[%d] = %d\n",
indice, matriz[indice]);
return 0;
}
void una_funcion(int nombre_interno[ ])
{
int i;
for (i = 0 ; i < 5 ; i++)
printf("Valor de matriz[%d] al iniciar la funcion= %d\n",
i, nombre_interno[i]);
printf("\n");
for (i = 0 ; i < 15 ; i++)
/*Se suma 10 al valor de la variable i de la matriz*/
nombre_interno[i] += 25;
for (i = 0; i < 5; i++)
printf("Valor de matriz[%d] al salir de la funcion= %d\n",
i, nombre_interno[i]);
printf("\n");
}

La funcin una_funcion empieza en la lnea 25 y como se puede ver, prefiere llamar

internamente a la matriz con el nombre de nombre_interno, es adems necesario declarar el
array como de tipo int y especificar que se trata de un array incluyendo los corchetes, en este
caso dejamos que el sistema determine el tamao del array al no especificar ningn valor entre
los corchetes. Al regresar a la funcin principal main ( ) podemos comprobar lo que hemos dicho
al desplegar los nuevos valores asignados a las variables del array denominado matriz. Otra
forma de obtener datos de una funcin hacia el programa que la llama es utilizando un puntero,
tema que estudiaremos en la siguiente leccin, ah veremos que el nombre de un array es en
realidad un puntero hacia una lista de valores, pero antes de avanzar a la siguiente leccin
veamos la manera de trabajar con arrays m
Como podemos observar los arrays (arreglos), son muy extensos, hemos mostrado los ms
comunes de una forma clara para una mejor compresin del concepto.
4.4 Introduccin a punteros
El valor de cada variable est almacenado en un lugar determinado de la memoria,
caracterizado por una direccin (que se suele expresar con un nmero hexadecimal).
El ordenador mantiene una tabla de direcciones (ver Tabla 6.1) que relaciona el nombre de
cada variable con su direccin en la memoria. Gracias a los nombres de las variables
(identificadores), de ordinario no hace falta que el programador se preocupe de la direccin de
memoria donde estn almacenados sus datos.
Sin embargo, en ciertas ocasiones es ms til trabajar con las direcciones que con los propios
nombres de las variables.

El lenguaje C dispone del operador direccin (&) que permite determinar la direccin de una
variable, y de un tipo especial de variables destinadas a contener direcciones de variables.
Estas variables se llaman punteros o apuntadores (en ingls pointers).
As pues, un puntero es una variable que puede contener la direccin de otra variable.
Por supuesto, los punteros estn almacenados en algn lugar de la memoria y tienen su propia
direccin (ms adelante se ver que existen punteros a punteros). Se dice que un puntero
apunta a una variable si su contenido es la direccin de esa variable. Un puntero ocupa de
ordinario 4 bytes de memoria, y se debe declarar o definir de acuerdo con el tipo del dato al
que apunta. Por ejemplo, un puntero a una variable de tipo int se declara del siguiente modo:
int *direc;
lo cual quiere decir que a partir de este momento, la variable direc podr contener la direccin
de cualquier variable entera. La regla nemotcnica es que el valor al que apunta direc (es decir
*direc, como luego se ver), es de tipo int. Los punteros a long, char, float y double se
definen anlogamente a los punteros a int.

OPERADORES DIRECCIN (&) E INDIRECCIN (*)

Como se ha dicho, el lenguaje C dispone del operador direccin (&) que permite hallar la
direccin de la variable a la que se aplica. Un puntero es una verdadera variable, y por tanto
puede cambiar de valor, es decir, puede cambiar la variable a la que apunta. Para acceder al
valor depositado en la zona de memoria a la que apunta un puntero se debe utilizar eloperador
indireccin (*). Por ejemplo, supngase las siguientes declaraciones y sentencias,
int i, j, *p; // p es un puntero a int
p = &i; // p contiene la direccin de i
*p = 10; // i toma el valor 10
p = &j; // p contiene ahora la direccin de j
*p = -2; // j toma el valor -2
Las constantes y las expresiones no tienen direccin, por lo que no se les puede aplicar
el operador (&). Tampoco puede cambiarse la direccin de una variable. Los valores posibles
para un puntero son las direcciones posibles de memoria. Un puntero puede tener valor 0.
(equivalente a la constante simblica predefinida NULL). No se puede asignar una direccin
absoluta directamente (habra que hacer un casting). Las siguientes sentencias son ilegales:
p = &34; // las constantes no tienen direccin
p = &(i+1); // las expresiones no tienen direccin
&i = p; // las direcciones no se pueden cambiar
p = 17654; // habra que escribir p = (int *)17654;
Para imprimir punteros con la funcin printf() se deben utilizar los formatos %u y %p,
como se ver ms adelante.
No se permiten asignaciones directas (sin casting) entre punteros que apuntan a distintos

tipos de variables. Sin embargo, existe un tipo indefinido de punteros (void *, o punteros a
void), que puede asignarse y al que puede asignarse cualquier tipo de puntero. Por ejemplo:
int *p;
double *q;
void *r;
p = q; // ilegal
p = (int *)q; // legal
p = r = q; // legal
4.5 Aplicaciones de estructuras de datos
La operatoria o aritmtica de punteros tiene en cuenta el tamao de las variables que se
recorren. En el siguiente programa, y en la salida que ofrece por pantalla, se puede ver este
comportamiento de los punteros. Sea cual sea el tipo de dato del puntero y de la variable a la
que apunta, si calculo la resta entre dos punteros situados uno al primer elemento de un array y
el otro al ltimo, esa diferencia ser la misma, porque la resta de direcciones indica cuntos
elementos de este tipo hay (caben) entre esas dos direcciones. En nuestro ejemplo, todas esas
diferencias valen 9. Pero si lo que se calcula es el nmero de bytes entre la ltima posicin
(apuntada por el segundo puntero) y la primera (apuntada por el primer puntero), entonces esa
diferencia s depender del tamao de la variable del array.
#include <stdio.h>
void main(void)
{
char c[10], *pc1, *pc2;
short h[10], *ph1, *ph2;
float f[10], *pf1, *pf2;
double d[10], *pd1, *pd2;
long double ld[10], *pld1, *pld2;
pc1 = &c[0];
pc2 = &c[9];
ph1 = &h[0];
ph2 = &h[9];
pf1 = &f[0];
pf2 = &f[9];
pd1 = &d[0];
pd2 = &d[9];
pld1 = &ld[0];
pld2 = &ld[9];
printf(" pc2(%p) - pc1(%p) = %hd\n",pc2,pc1,pc2 - pc1);
printf(" ph2(%p) - ph1(%p) = %hd\n",ph2,ph1,ph2 - ph1);
printf(" pf2(%p) - pf1(%p) = %hd\n",pf2,pf1,pf2 - pf1);
printf(" pd2(%p) - pd1(%p) = %hd\n",pd2,pd1,pd2 - pd1);
printf("pld2(%p) - pld1(%p) = %hd\n",pld2,pld1,pld2 - pld1);
printf("\n\n");
printf("(long)pc2-(long)pc1=%3ld\n",(long)pc2-(long)pc1);

10

printf("(long)ph2-(long)ph1=%3ld\n",(long)ph2-(long)ph1);
printf("(long)pf2-(long)pf1=%3ld\n",(long)pf2-(long)pf1);
printf("(long)pd2-(long)pd1=%3ld\n",(long)pd2-(long)pd1);
printf("(long)pld2-(long)pld1=%3ld\n",(long)pld2-(long)pld1);
}
Que ofrece, por pantalla, el siguiente resultado:
pc2(0012FF89) - pc1(0012FF80) = 9
ph2(0012FF62) - ph1(0012FF50) = 9
pf2(0012FF4C) - pf1(0012FF28) = 9
pd2(0012FF20) - pd1(0012FED8) = 9
pld2(0012FECE) - pld1(0012FE74) = 9
(long)pc2 - (long)pc1 = 9
(long)ph2 - (long)ph1 = 18
(long)pf2 - (long)pf1 = 36
(long)pd2 - (long)pd1 = 72
(long)pld2 - (long)pld1 = 90

Un ejemplo ms sencillo podra ser el siguiente.

#include<iostream>
Int main()
{
Int a; int *ptrA;
A = 7;
Cout<<La direccion de a es <<&A<<El valor de ptrAes:<<ptrA;
Cout<< El valor de a es <<A<<El valor de prtA es<<*prtA;
Cout<<Muestra de que * y & son inversos<<uno del otro, &*ptrA = <<6*prtA
<<*&prtA=<<*&prtA<<ende;
Return 0;
}
Aclaracin las letras C que acompaa a cout es en minscula no en mayscula.
La salida que se obtiene del ejemplo anterior es:
La direccion de A es 006AFDF4
El valor de prtA es

006AFDF4

El valor de A es 7
El valor de *prtA es 7
Muestra de que * y & son inverso uno de otro.

11

&*prtA = 006AFDF4
*&ptrA = 006AFDF4

12