Professional Documents
Culture Documents
FACULTAD DE INGENIERIA
ESCUELA DE COMPUTACION
CATEDRATICO: ING. RAUL MARTINEZ RIVAS.
MATERIA: PROGRAMACIN I
UNIDAD IV.
ARREGLOS
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:
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)
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;
}
#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);
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.
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
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