Pascal/Turbo Pascal - Punteros @

Hola tengo un problema con la @ en los punteros. No entiendo muy bien para que sirve si es una asignacion o que es realmente.
Por ejemplo

Var
a:integer;
p:^integer;
begin
a:=9;
p:=@a; {aqui que es que p toma el valor de 9 o que apunta a a}

Muchas gracias!!!

Saludos Antonio.

- Me remito al Sistema de ayuda en castellano para Turbo Pascal 7.0
la puedes descargar de muchos sitios , entre otros de la siguiente direccion

http://es.geocities.com/pascal_codes

fichero:tp7ayuda.zip

Tambien puedes ver "antes" la ayuda en ingles del tp7 buscando operator @
- Si siges teniendo dudas postea de nuevo y veremos que se puede hacer.

----------------------------------------------------------------------------------------
Para ver el siguiente texto en formato original , usa copiar y pegar a un fichero de
texto .txt por ejemplo usa el notepad guarda el fichero y abrelo desde el DOS o con el
mismo EID . o instala el sistema de ayuda y lo ves desde alli directamente.
----------------------------------------------------------------------------------------

El operador @ ("posici¢n"): Operaci¢n de puntero
ßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßß
Se puede crear un puntero a una variable con el operador @.

Operador³Operaci¢n ³Tipo de los operandos ³Tipo del resultado
ÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ
@ ³Formaci¢n de ³Referencia a variable, ³Puntero (igual que nil)
³puntero ³identificador de ³
³ ³procedimiento o funci¢n³

@ es un operador unario. Para usar el operador @ con una variable procedural
se aplican unas reglas especiales.

El tipo del valor es el mismo que el tipo de nil, por tanto puede ser
asignado a cualquier variable puntero.

@ con una variable:
No es complicado usar @ con una variable ordinaria (no un par metro). Por
ejemplo, dadas las declaraciones:

type
TwoChar = array[0..1] of Char;
var
Int: Integer;
TwoCharPtr: ^TwoChar;

Esta sentencia hace que TwoCharPtr apunte a Int:
TwoCharPtr := @Int;

TwoCharPtr^ pasa a ser una reinterpretaci¢n del valor de Int, como si fuera
un array[0..1] of Char.

@ con un par metro por valor:
Aplicando @ a un par metro formal por valor se obtiene un puntero a la
posici¢n del stack que contiene el valor real.

Por ejemplo, sup¢ngase que Fred es un par metro formal por valor en un
procedimiento y FredPtr es una variable puntero.

Si el procedimiento ejecuta esta sentencia:
FredPtr := @Fred;

FredPtr^ hace referencia al valor de Fred.

Sin embargo, FredPtr^ no referencia a Fred propiamente dicho, referencia al
valor que se cogi¢ de Fred y se almacen¢ en el stack.

@ con un par metro por direcci¢n:
Aplicando @ a un par metro formal por direcci¢n se obtiene un puntero al
par metro actual (el puntero se coge del stack).

El tipo del valor puntero resultante se controla mediante la directiva del
compilador $T.

Por ejemplo, sup¢ngase lo siguiente:
- Uno es una par metro formal por direcci¢n de un procedimiento,
- Dos es una variable pasada al procedimiento como el par metro actual de
Uno
- UnoPtr es una variable puntero.

Si el procedimiento ejecuta esta sentencia
UnoPtr := @Uno;

UnoPtr es un puntero a Dos, y UnoPtr^ es una referencia a el propio Dos.

@ con un procedimiento o funci¢n:
Es posible aplicar @ a un procedimiento, funci¢n o m‚todo para producir un
puntero al punto de entrada de una rutina. El Turbo Pascal no ofrece un
mecanismo para usar este tipo de puntero.

El £nico uso de un puntero a procedimiento es pasarlo a una rutina en
lenguaje ensamblador o usarlo en una sentencia inline.

@ con un m‚todo:
Se puede aplicar @ a un identificador de m‚todo calificado para producir un
puntero al punto de entrada del m‚todo.

El operador @ asigna a la variable (que debe ser un tipo puntero) que está a la izquierda del := la dirección de memoria de la variable que está a continuación del operador, de forma tal que la variable puntero pueda reinterpretar el dato apuntado como si fuera del tipo de dato declarado para el puntero.

(¿me enredé?, espero que se entienda :S).

¿No se usa el símbolo ^?

El operador ^ tiene un significado diferente. Este operador sirve para acceder al dato que está en la dirección de memoria apuntada por el puntero y ese dato se interpreta igual a como está declarada la variable que está en esa dirección de memoria.

Saludos a todos.
_______________________________________________________________

@ es el unico operador asociado a los punteros @ tambien llamado (addr)
devuelve un puntero que apunta al operando , y es compatible con todos los
tipos de punteros ,permite hacer una reinterpretacion del tipo de datos.

@ cambia de significado aplicado a procedimientos , funciones y assember

observar que aunque no se pueden asignar punteros de tipos distintos se
puede hacer uando un puntero sin tipo.
si a un puntero sin tipo le damos una direccion , el compilador ignora el
tamaño ,?????por tanto no podemos recuperar nada de forma directa ¿¿¿¿
, pero podemos recuperarlo asignando el puntero sin tipo a otro con un nuevo tipo

IMPORTANTE:los punteros asignados apuntan a otra variable pero mantienen
su extructura interna si es de tipo word siempre sera de tipo word
aunque apunten a byte , ¡¡¡ con lo cual podemos recoger basura !!!.
-------------------------------------------------------------------

type x_mini=array[0..1]of char;
var
p1:^byte;
p2:^word;
p3:pointer;
p4:^x_mini; { no lo vamos a usar}
a:byte;
b:word;
mini:x_mini;

begin
---------------------------------------------------------
vamos a incrementar un byte desde un word
---------------------------------------------------------

a:=1;
b:=4;
writeln('a: ',a,' b:',b);
p1:=@a; { p1 de tipo byte apunta a a de tipo byte }
{ p2:=p1; no podemos pues p1 de tipo byte p2 de tipo word }
p3:=p1; { p3 es sin tipo (pointer) y apunta a p1 del tipo byte }
p2:=p3; { p2 del tipo word apunta a p3 que apunta a byte }
inc(p2^);
{se incrementa la var (a) desde p2 de tipo word pues apunta a p1 y este a(a)}
writeln('a: ',a,' b:',b);
p2:=@b; { ahora p2 apunta a word apuntando b }
p2:=@p2 { este es para vacilar p2 se apunta a si mismo }

--------------------------------------------------------------------------
en este otro ejemplo lo veremos mas claro ,vemos como hay una reinterpretacion
de datos, por ejemplo vamos a reinterpretar el array mini como array
pero con acceso desde word.
--------------------------------------------------------------------------

mini:='cd';
writeln('mini asignado directamente:',mini);
p2:=@mini;
p2^:=(98 shl 8)+97; { p2 ocupa dos bytes , los cambiamos por asscill a,b (invertidos)}
{
p2 sige siendo de tipo word pero con acceso a mini que es un array
de 2 caracteres
}
writeln('mini cambiado desde p2:',mini);
readln;
end.

Excelente programa, muy gráfico :).