c/c++ punteros. dirección. in dirección. aritmética de direcciones. Índice. revisando conceptos...

C/C++ Punteros. Dirección. In dirección. Aritmética de direcciones.

Índice. Revisando conceptos acerca de la

memoria. Las variables en los programas. Punteros y direcciones. Aritmética de punteros. Estructuras y Uniones. Extendiendo los conceptos a

funciones.


La memoria es un conjunto de celdas contiguas donde se almacenan datos.

La unidad de memoria más pequeña es el bit. El byte es un conjunto de 8 bits. Unidad de memoria.

El lugar (ubicación) de cada byte es único y es su dirección. Si los bytes son consecutivos la dirección se ira incrementando

secuencialmente.

Cada celda tiene dos valores asociados: Dirección y Contenido.

Memoria.

1 2 3 4 5 6 7 8 9 A B C D E F

1 0 1 1 0 0 1 1

171 186 137 99

10101011 10111010 10001001 1100011

Dirección:0xC100

Dirección +1: 0xC101Dirección + 3: 0xC103

Celda: Valor Decimal

Celda: Valor Binario


Variables

Una variable es una porción de memoria identificada por un nombre.

El tipo de dato define su representación binaria y longitud. Tiene tres valores asociados: Nombre, Contenido y Dirección.

Declaramos: “int n=1523, m=121;”

Contenido: n 1523 m 121

Dirección: &n C102 &m C100

Es contenido binario se codifica (bits) de acuerdo al tipo de variable.

0000000 01111001 00000101 11110011

Dirección: C100 Dirección: C102

Valor: 121 Valor: 1523


Tipos de Variables El tipo de variable establece:

Rango de valores que maneja. Codificación binaria del dato. Cantidad de memoria requerida.

En todos los casos la dirección de almacenaje es “&variable”.

Declaración Bytes Valor en Memoria Hexa Valor en Memoria Binario

char c = ‘X’; 1 58 1011000

char w[ ] = “hola”; 4+1 68 6F 6C 61 00 01101000 01101111 01101100

01100001 00000000

int n[5] = {555,444,333,222,111} 5x2=10 02 2B 01 BC 01 4D 00 DE 00 6F 00000010 00101011 00000001 10111100

00000001 01001101 00000000 11011110

00000000 01101111

long l[3] = {100,200,300} 3x4=12 00 00 00 64 00 00 00 C8 00 00 01 2C

00000000 00000000 00000000 01100100

00000000 00000000 00000000 11001000

00000000 00000000 00000001 00101100

float f = 3.141592 4 40 49 0F D8 1000000010010010000111111011000


Punteros Un puntero es una variable cuyo contenido es una dirección. Como todas las variable tiene nombre, contenido y dirección. Un puntero “apunta a”: un dato, un array, un objeto, una función, etc.

“int n;” declara una variable entera (16 bits / 2 bytes) “int *j;” declara un puntero tipo entero (solo almacena direcciones). “j” contiene una dirección donde comienza un entero. “*j” valor entero almacenado en la dirección apuntada por “j”

(indirección).

n contenido=“valor del entero” j contenido=“valor de la dirección”.

&n dirección del entero en “n” *j contenido en la dirección de “j”.

Valor *j=n 40j0xA010

Dirección: &j0xF234 Dirección: j &n 0xA010

Lugar: 2 byte donde esta

almacenado j

Lugar: 2 byte donde esta almacenado n

Representamos “int n=40, *j=&n;” suponemos que se almacenan:

n en la dirección 0xA010 y j en la dirección 0xF234


Algebra de punteros Los punteros se usan como cualquier otra variable. Su comportamiento es de acuerdo al tipo definido.

“long n[ ]={40,30,20,10}, *j=n;” j se inicializa con &n[0]

j &n[0] 0xA010 *j =40 j++ &n[1] 0xA014 *j =30 j+2 &n[3] 0xA01C *j =10

Si hacemos j=n;*(j+2) n[2] 20

Valor apuntado por j más 2 posiciones Como j es tipo long incrementará 8 (4*2) bytes El incremento depende del tipo.

j Tiene un lugar de memoria para su contenido. j esta almacenada en &j, ocupa 8/16/32/64 bits de acuerdo al micro.

40 30 20 10

Dirección:0xA010

Dirección +40xA014

Dirección + 12 0xA01C


Un puntero puede almacenar una dirección de otro puntero. El valor final apuntado puede obtenerse en forma directa. “int n, *j, **p”; hacemos “n=4562”; “j=&n”; “p=&j”; Supongamos que: &n 0x3021 &j 0x4310 Entonces: &p 0x4F02

Interpretación: Con el valor de p obtiene la dirección de j: *p &j Con el valor de j obtiene la dirección de n: *j &n Con el tipo de p interpreta el valor de n. Esta es la secuencia de **p

Punteros de Punteros

p 0x4310*p j 0x3021**p *j 4562

*(*(p)) 4562

*( j ) 4562

n 4562


Punteros de Punteros

**p=*j=n 4562

*p=j 0x3021

p 0x4310

*p=j 0x3021

p0x4310

Dirección: &p0x4F02

Dirección: &j=p0x4310

Lugar: 2 byte donde esta

almacenado p

Lugar: 2 byte donde esta almacenado j

Representación gráfica de doble indirección

**p=*j=n 4562

Dirección: &n=j0x3021

Lugar: 2 byte donde esta almacenado n

int n= 4562; &n 0x3021

int *j = &n; &j 0x4310

int **p =&j; &p 0x4F02


Uso de Punteros Ejemplo de un código, asignación y uso de punteros.

A pp se le asigno la dirección 0x14E

A jj se le asigno la dirección 0x130

A a1 se le asigno la dirección 0x1902

Compilador C (CodeWarrior)


Uso de Punteros Como obtiene el valor de **p.

Toma la dirección de p 0x14E



Uso de Punteros Sumemos “p += 2;”. El valor de **p queda.

Toma la dirección de p 0x14E



Introducción a Estructuras Cuando definimos arreglos agrupamos datos del mismo tipo. “int dni[40], *pv=dni;”

Asignará 40 * 2 = 80 bytes contiguos para almacenar los 40 enteros Con pv puedo navegar sobre el arreglo (array).

Si necesito asociar varios tipos de datos de una misma entidad (Registro)

Ejemplo: Registro de exámenes de un turno: Acta, Fecha, Materia, Legajo, Nombre, Nota.

Necesito 6 arreglos para los siete tipos de datos.

Cada arreglo esta en posiciones de memorias no vinculadas entre si.

Agregar una entidad implica hacerlo en cada uno y luego rescatar cada dato del lugar y posición adecuadas.

Para introducir el concepto de registro, debemos definir un nuevo tipo de datos (nuestro), que maneje los seis valores “juntos”, asociados y agrupados.


Estructuras Una definición global puede ser:

Lista de variables.

Nombre de la estructura.

Lista de campos miembros.

Referencia a campos miembros.

Array de estructuras.

Compilador C++ Microsoft 9.0


Estructuras Una definición más elaborada:

Para usar …

Salida: Acta: 123 Codigo de Materia: 43 Fecha:14/09/2009 A-1613/8 Apellido, Nombre calle, nro, piso, ... Nota:8.25 Compilador C++ Microsoft 9.0


Punteros a EstructurasFormas de inicializar.

Array de Punteros.

Uso de Punteros.

Cálculo de tamaños.

Salida.


Punteros a Punteros a Estructuras Más ejemplos.

Salida.

Punteros.

Direcciones.

Valores.


Punteros a Funciones. Sintaxis: <tipo_devuelto> ... (* nombre_puntero) (<parametros>) ...

<tipo_devuelto> es el tipo de vuelto por la función señalada por el puntero, podríamos decir que es el tipo de variable señalada por el puntero en último extremo. Puede ser void.

(* nombre_puntero) Esta parte es conocida como núcleo de la declaración. Sin los paréntesis de la declaración, cambia su sentido, ya que es considerada por el compilador como la declaración de una función.

<parametros> es la lista de los argumentos aceptados por la función señalada por el puntero.


Punteros a Funciones. Ejemplos.

c/c++ punteros. dirección. in dirección. aritmética de direcciones. Índice. revisando conceptos...

Documents