Apuntadores

Benemérita Universidad Autónoma de Puebla

UNIDAD REGIONAL ACATZINGO DE HIDALGO

ASIGNATURA: PROGRAMACION CONCURRENTE Y

PARALELA

MCC. JUDITH PEREZ MARCIAL

(INVESTIGACION ELABORADA)

POR

ALUMNA:

Jaqueline González López

17-SEPTIEMBRE-2012

OTOÑO 2012

CONTENIDO

Introducción…………………………………………………………..…… 3

Apuntadores…………………………………………………………. 4

Tipos de apuntadores y arreglos………………………………….. 7

Inicializacion de apuntadores………………………...……………. 9

Aritmética de apuntadores…………………………………………. 10

Apuntadores a cadenas de caracteres…………………………… 12

Apuntadores como parámetros de una función…………………. 13

Conclusión.…………………………………………………………………. 15

Bibliografía………………………………………………………………….. 16

INTRODUCCION

Si uno quiere ser eficiente escribiendo código en el lenguaje de programación C, se debe tener un profundo y activo conocimiento del uso de los apuntadores. Desafor-tunadamente, los apuntadores en C parecen representar una piedra en el camino de los principiantes, particularmente de aquellos que vienen de otros lenguajes de programación como Fortran, Pascal o Basic.

Es por ello que estudiaremos apuntadores bajo el lenguaje C, tipos de apuntadores y donde lo podemos implementar.

APUNTADORES

¿Qué es un apuntador?

Un apuntador es un objeto que apunta a otro objeto. Es decir, una variable cuyo va-lor es la dirección de memoria de otra variable.

No hay que confundir una dirección de memoria con el contenido de esa dirección de memoria.

int x = 25;

La dirección de la variable x (&x) es 1502

El contenido de la variable x es 25

Las direcciones de memoria dependen de la arquitectura de la computadora y de la gestión que el sistema operativo haga de ella.

En lenguaje ensamblador se debe indicar numéricamente la posición física de me-moria en que queremos almacenar un dato. De ahí que este lenguaje dependa de la máquina en la que se aplique.

En C no debemos, ni podemos, indicar numéricamente la dirección de memoria, si no que utilizamos una etiqueta que conocemos como variable (las variables tienen asociada una dirección de memoria). Lo que nos interesa es almacenar un dato, y no la localización exacta de ese dato en memoria.

Una variable apuntador se declara como todas las variables. Debe ser del mismo tipo que la variable apuntada. Su identificador va precedido de un asterisco (*):

int *punt;

Es una variable apuntador que apunta a variable que contiene un dato de tipo entero llamada punt.

char *car:

Es un apuntador a variable de tipo carácter.

Un apuntador tiene su propia dirección de memoria:

&punt

&car

Es decir: hay tantos tipos de APUNTADORES como tipos de datos, aunque también pueden declararse APUNTADORES a estructuras más complejas (funciones, struct, objetos (instancias de una clase), ficheros e incluso APUNTADORES vacíos (void) y APUNTADORES nulos (NULL).

Declaración de variables apuntador: Sea un fragmento de programa en C:

char dato; //variable que almacenará un carácter.

char *punt; //declaración de puntador a carácter.

punt = &dato; //en la variable punt guardamos la dirección de memoria

// de la variable dato; punt apunta a dato. Ambas son del mismo tipo, char.

int *punt = NULL, var = 14;

punt = &var;

printf(“%#x, %#x”, punt, &var) //la misma salida: misma dirección

printf(“\n%d, %d”, *punt, var); //salida: 14, 14

Hay que tener cuidado con las direcciones apuntadas:

printf(“%d, %d”, *(punt+1), var+1);

*(punt + 1) representa el valor contenida en la dirección de memoria aumentada en una posición

(int=2 bytes), que será un valor no deseado. Sin embargo var+1 representa el valor 15.

punt + 1 representa lo mismo que &var + 1 (avance en la dirección de memoria de var).

Al trabajar con APUNTADORES se emplean dos operadores específicos:

• Operador de dirección: & Representa la dirección de memoria de la variable que le sigue:

&fnum representa la dirección de fnum.

• Operador de contenido o in dirección: *. El operador * aplicado al nombre de un apuntador indica el valor de la variable apuntada:

float altura = 26.92, *apunta;

apunta = &altura; //inicialización del apuntador

printf(“\n%f”, altura); //salida 26.92

printf(“\n%f”, *apunta) ; //salida 26.92

No se debe confundir el operador * en la declaración del apuntador:

int *p; Con el operador * en las instrucciones:

*p = 27; printf(“\nContenido = %d”, *p);

Veamos con un ejemplo en C la diferencia entre todos estos conceptos

Es decir:

int x = 25, *pint;

pint = &x;

La variable pint contiene la dirección de memoria de la variable x. La expresión: *pint representa el valor de la variable (x) apuntada, es decir 25. La variable pint también tiene su propia dirección: &pint

TIPOS DE APUNTADORES Y ARREGLOS

Consideremos por qué tenemos que identificar el "tipo" de variable a la que apunta un puntero como en:

int *ptr;

Una de las razones para hacer esto es que una vez que ptr apunta a algo y si escri-bimos:

*ptr = 2;

El compilador sabrá cuantos bytes va a copiar en la posición de memoria a la que apunta ptr. Si ptr fuera declarado como un puntero a entero, se copiarían 4 bytes. De modo similar para números de punto flotante (float) y enteros dobles (doubles), se copiaría el número apropiado de bytes. Pero definir el tipo al que el apuntador apunta permite un cierto número de maneras interesantes en que el compilador puede interpretar el código. Por ejemplo, consideremos un bloque de memoria con-sistente en 10 números enteros en una fila. Eso es 40 bytes de memoria son reser-vados para colocar 10 enteros.

Digamos que ahora apuntamos nuestro apuntador entero ptr al primero de estos números enteros. Es más, supongamos que este primer entero está almacenado en la posición de memoria 100 (decimal). Entonces qué pasa cuando escribimos:

ptr + 1;

Ya que el compilador “sabe” que este es un apuntador (que su valor es una dirección de memoria) y que apunta a un entero (su dirección actual: 100, es la dirección donde se aloja un entero), añade 4 a ptr en lugar de 1, así que ptr apunta al siguiente entero, en la posición de memoria 104. Similarmente, si ptr fuera declarado como apuntador a entero corto, añadiría 2 en lugar de 1. Lo mismo va para los otros tipos de datos como flotantes, dobles o aún tipos definidos por el usuario como estructuras. No se trata obviamente del tipo “normal” de “adición” a la que estamos acostumbrados. En C, se le conoce como adición usando “aritmética de punteros”, algo que veremos un poco más adelante.

Igualmente, como ++ptr y ptr++ son equivalentes a ptr + 1 (aunque el momento en el programa cuando ptr es incrementado sea diferente), incrementar un apuntador usando el operador unitario de incremento ++, ya sea pre- o post-, incrementa la di-rección por la cantidad sizeof (tipo)3 donde “tipo” es el tipo de objeto al que se apun-ta (por ejemplo 4 si se trata de un entero).

Y ya que un bloque de 10 enteros acomodados contiguamente en la memoria es, por definición, un arreglo de enteros, esto nos revela una interesante relación entre arreglos y apuntadores.

Consideremos lo siguiente:

int mi_arreglo[] = {1,23,17,4,-5,100};

Tenemos entonces un arreglo conteniendo seis enteros. Nos referimos a cada uno de estos enteros por medio de un subíndice a mi_arreglo, es decir usando mi_arreglo[0] hasta mi_arreglo[5]. Pero podemos acceder a ellos de un modo al-ternativo usando un puntero de esta manera:

int *ptr;

ptr = &mi_arreglo[0]; /* apuntamos nuestro apuntador al primer entero de nuestro arreglo */

Y entonces podemos imprimir los valores de nuestro arreglo, ya sea usando la nota-ción de arreglos o

“desreferenciando” nuestro apuntador.

El siguiente código ilustra este concepto.

...