BotonMenu
BotonIndice

Visita : http://www.conoce3000.com
Paypal : https://www.paypal.me/conoce3000/1

PASCAL CON FREE PASCAL

PASCAL CON FREE PASCAL

PASCAL CON FREE PASCAL


7. INTRODUCCIÓN A LOS PUNTEROS Y VARIABLES DINÁMICAS.
7.3. VARIABLES DINÁMICAS DE DATOS ENTEROS Y REALES. (PUNTEROS CON TIPO)
7. INTRODUCCIÓN A LOS PUNTEROS Y VARIABLES DINÁMICAS.
7.3. VARIABLES DINÁMICAS DE DATOS ENTEROS Y REALES. (PUNTEROS CON TIPO)
7. INTRODUCCIÓN A LOS PUNTEROS Y VARIABLES DINÁMICAS.
7.3. VARIABLES DINÁMICAS DE DATOS ENTEROS Y REALES. (PUNTEROS CON TIPO)

SIGUIENTE

SIGUIENTE

SIGUIENTE


‒ Variables dinámicas de tipos de datos enteros y reales.

Los tipos de datos pointer, son conocidos como punteros sin tipo, ya que este tipo de dato permite sólo almacenar direcciones de memoria sin estar asociado a un tipo de dato en particular. Pero el compilador permite crear punteros con un tipo de dato específico, que permite definir cómo será la variable dinámica cuando sea creada, a este tipo de datos se les conoce como punteros con tipo.

Para declarar variables de punteros con tipo, de un de tipo de dato integer y double, se usa el operador ^, del siguiente modo:

VAR
  PunteroInt:^integer;
  PunteroDou:^Double;

Con esto hemos declarado dos variables punteros, PunteroInt contendrá la dirección de memoria para una variable dinámica de tipo integer, y PunteroDou contendrá la dirección de memoria para una variable dinámica de tipo double. Para crear o reservar un espacio en la memoria para estas variables dinámicas, se usa la rutina new del siguiente modo:

new(PunteroInt);
new(PunteroDou);

El procedimiento new recibe como parámetro un puntero que se haya definido con el operador ^, new se encargará de crear la variable dinámica en la memoria, para luego colocar en el puntero la dirección de memoria de la variable dinámica creada.

Esto también se puede hacer usando getmem(PunteroInt,2) ó getmem(PunteroDou,8), pero la diferencia está en que no es necesario indicar la cantidad de bytes que se van usar con la variable dinámica.

Para poder asignar valores o datos a las variables dinámicas creadas se usa el operador ^, del siguiente modo:

PunteroInt^:=1024;
PunteroDou^:=40.89;

Como se puede observar no es necesario hacer un solapamiento del tipo de dato, ya que al momento de definir las variables PunteroInt y PunteroDou, se les indico con el operador ^ el tipo de dato que tendrá la variable dinámica cuando sea creada, es decir la cantidad de bytes que usará la variable dinámica. A continuación el programa de ejemplo completo:


Descargar
{$codepage UTF8}

VAR
  PunteroInt:^integer; 
  PunteroDou:^double; 
BEGIN
  new(PunteroInt);
  new(PunteroDou);
  PunteroInt^:=1024;
  PunteroDou^:=40.89;
  Writeln(PunteroInt^);
  Writeln(PunteroDou^);
  Freemem(PunteroInt);
  Freemem(PunteroDou)
END.
Código fuente 4: Ejemplo del uso de new.
Descargar

Existe otra rutina que nos permite liberar o borrar una variable dinámica, la rutina es Dispose, se usa igual y hace exactamente lo mismo que freemem, pero no se puede usar con variables de tipo pointer, es decir sólo se puede usar con variables dinámicas que han sido creados con new. Freemem, siempre borrara la variable dinámica usando indistintamente un puntero sin tipo como un puntero con tipo. Las rutinas Freemem y Dispose, no colocan el valor Nil al puntero después que su variable dinámica es liberada o borrada.

Las variables antes mencionadas también se pudieron haber creado como tipos de datos, del siguiente modo:

TYPE
   PunteroInt:^integer;
   PunteroDou:^Double;
VAR
   Cantida:PunteroInt;
   Precio:PunteroDou;

De ese modo el programa se hace muy legible. Pero no es necesario crear nuestros propios tipos de datos, porque ya existen tipos de datos puntero que se pueden usar, para los tipos de datos enteros y reales ya conocidos, que son: PInt64, PInteger, PLongint, PSmallInt, PShortInt, PQWord, PCardinal, PLongWord, PWord, PByte para los enteros y PSingle, PDouble, PExtended y PCurrency para los Reales. A continuación un programa de ejemplo:


Descargar
{$codepage UTF8}

VAR
  Cantidad:PInteger; 
  Precio:PDouble; 
BEGIN
  new(Cantidad);
  new(Precio);
  Cantidad^:=1024;
  Precio^:=40.89;
  Writeln(Cantidad^);
  Writeln(Precio^);
  Freemem(Cantidad);
  Freemem(Precio)
END.
Código fuente 5: Uso de PInteger y PDouble.
Descargar

El compilador permite usar las variables dinámicas como arreglos de una dimensión, siempre y cuando usen punteros con tipo. Pero para ello se debe definir el tamaño adecuado del arreglo en bytes con el uso de la función getmem, de acuerdo al tamaño del tipo de dato que se está usando. Por ejemplo, si queremos una variable dinámica de 5 enteros del tipo de dato integer, entonces se debe especificar un tamaño de 10 bytes, y si queremos una variable dinámica de 5 enteros del tipo de dato longint, entonces se debe especificar un tamaño de 20 bytes, a continuación el programa de ejemplo:


Descargar
{$codepage UTF8}
VAR
 P01:PInteger;
 P02:PLongint;
 i:byte;  
BEGIN
 
 getmem(P01,10);
 P01[0]:=10;
 P01[1]:=20;
 P01[2]:=30;
 P01[3]:=40;
 P01[4]:=50;
 
 for i:=0 to 4 do Writeln(P01[i]);

 getmem(P02,20);
 P02[0]:=10;
 P02[1]:=20;
 P02[2]:=30;
 P02[3]:=40;
 P02[4]:=50;
 for i:=0 to 4 do Writeln(P02[i]);  
 
 Freemem(P01);
 Freemem(P02)
 
END.
Código fuente 6: Uso de variables dinámicas como arreglos.
Descargar

Como puede observar del ejemplo anterior, para acceder a las variables dinámicas se usan los punteros P01 y P02, usando entre corchetes el índice del elemento al que quieren acceder. Cada elemento de dichas variables dinámicas siempre se numeran empezando desde 0.

Los punteros sin tipo, tampoco se pueden usar con las rutinas read, readln, write y writeln, pero las variables dinámicas que usen estos punteros, si se pueden usar con estas rutinas y para ello sólo es necesario el uso del operador ^. Ejemplo:


Descargar
{$codepage UTF8}
VAR  
  P01:Pinteger;  
BEGIN 

  new(P01); 
  
  Writeln('Ingrese un numero:');Readln(P01^);
  Writeln('Numero ingresado:');Writeln(P1^)          

  Freemem(P01)
END.
Código fuente 7: Uso de variables dinámicas con Readln y Writeln.
Descargar

A diferencia del tipo de dato pointer, en este caso no es necesario hacer un solapamiento. En el caso de usar las variables dinámicas como arreglos entonces el uso de los elementos de este arreglo con las rutinas read, readln, write y writeln, se hacen como si fuera un arreglo común y corriente. Ejemplo:


Descargar
{$codepage UTF8}
VAR
 P01:PInteger;

 i:byte;  
BEGIN
 
 getmem(P01,10);
 Writeln('Ingrese 5 enteros:');
 for i:=0 to 4 do
   Begin
     Write('[',i,']:');
     Readln(P01[i])	 
   End;
 Writeln('Mostrando los 5 enteros');  
 for i:=0 to 4 do Writeln('[',i,']:',P01[i]);
 Freemem(P01)
 
END.
Código fuente 8: Uso de readln y writeln con variables dinámicas como arreglos.
Descargar

Las variables dinámicas que se utilizan como arreglos, también se pueden utilizar como arreglos de dos dimensiones, es decir, se puede crear una variable dinámica como un arreglo de dos dimensiones del siguiente modo:

getmem(P01,(m*n)*2);

Para acceder a un determinado elemento, debemos convertir las filas y columnas a un sólo índice, asumiendo que m son la cantidad de columnas del arreglo de dos dimensiones, entonces el elemento [i,j] será i*m+j, ejemplo:

i:=1;
j:=3;
P01[i*m+j]:=45;

A continuación un ejemplo, que es una adaptación del ejemplo: "Código fuente 6" del capítulo 5.2 Arreglos (Array):


Descargar
{$codepage utf8}
VAR
 MatrizA,MatrizB,MatrizC:^real;
 m,n:byte;
 i,j:byte;

BEGIN
 Writeln('Ingrese las dimensiones de las matrices a sumar (100 max) : ');
 Write('m :'); Readln(m);
 Write('n :'); Readln(n);
 
 getmem(MatrizA,m*n*8);
 getmem(MatrizB,m*n*8);
 getmem(MatrizC,m*n*8);
 
 Writeln('Ingrese los datos de la Matriz A :');
 for i:=0 to m-1 do
   for j:=0 to n-1 do
     Begin
       Write('MatrizA[',i,',',j,'] : ');              
       read(MatrizA[i*n+j])
     End; 
 Writeln('Ingrese los datos de la Matriz B :');
 for i:=0 to m-1 do
   for j:=0 to n-1 do
     Begin
       Write('MatrizB[',i,':',j,'] : ');       
        read(MatrizB[i*n+j])
     End;
//Sumando
 for i:=0 to m-1 do
    for j:= 0 to n-1 do      
      MatrizC[i*n+j]:=MatrizA[i*n+j]+MatrizB[i*n+j];
  
 Writeln('La suma es : ');
 for i:=0 to m-1 do
   Begin
     for j:=0 to n-1 do Write(MatrizC[i*n+j]:10:2);
     Writeln 
   End; 
   
  freemem(MatrizA);    
  freemem(MatrizB);    
  freemem(MatrizC)    
END.
Código fuente 9: Suma 2 matrices con variables dinámicas de tipo real.
Descargar

Al crear cada matriz mxn, se multiplica por 8 ya que ese, es el tamaño del tipo de dato real.


Última revisión: 10/12/2013.



SIGUIENTE
SIGUIENTE
SIGUIENTE



 
‒ Comentarios y sugerencias.

Agradezco de antemano, todo comentario, sugerencia, y donativo (a través de Paypal me), que ayude a mejorar los contenidos educativos de Conoce 3000. Además, cualquier pregunta o duda que tengas lo puedes hacer por este medio. Pero, todo contenido que pueda resultar ofensivo, malicioso, racista, sexista, discriminatorio, obsceno, vulgar será eliminado.


Comments System WIDGET PACK






PORTADA |  INTERESANTE |  APUNTES |  LIBROS |  GALERIA


Creative Commons License


Todos los textos, imágenes y videos de Conoce3000 estan colocados bajo una licencia : Creative Commons Reconocimiento-NoComercial 3.0 Unported License.