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.9. FILLCHAR, MOVE, REALLOCMEM.
7. INTRODUCCIÓN A LOS PUNTEROS Y VARIABLES DINÁMICAS.
7.9. FILLCHAR, MOVE, REALLOCMEM.
7. INTRODUCCIÓN A LOS PUNTEROS Y VARIABLES DINÁMICAS.
7.9. FILLCHAR, MOVE, REALLOCMEM.

SIGUIENTE

SIGUIENTE

SIGUIENTE


Las rutinas que explicaré son muy utilizadas con punteros, estas se encuentran dentro de la unidad system, por lo que no es necesario incluir la unidad con la palabra reservada Uses.

‒ 1. FillChar.

Esta rutina nos permite rellenar con un determinado valor de tipo byte o char el espacio de memoria ocupado por una variable sin tener en cuenta su estructura interna. Esta función tiene 3 parámetros, el primero es la variable que se va a rellenar, el segundo parámetro es el tamaño en bytes de la variable y el último parámetro es el valor de relleno, que puede ser de tipo byte o char. Ejemplo:


Descargar
{$codepage utf8}
VAR a:^byte;
    b:^char;
    i:byte;
    d:array [1..10] of byte;    
    e:array [1..10] of char;

BEGIN
  getmem(a,10);  
  fillchar(a^,10,5);
  for i:=0 to 9 do write(a[i]);
  
  Writeln;
  getmem(b,10);
  fillchar(b^,10,'A');
  for i:=0 to 9 do write(b[i]);
  
  Writeln;
  fillChar(d,10*SizeOf(word),5);
  for i:=1 to 10 do Writeln(d[i]); 
  
  Writeln;
  fillChar(e,10*SizeOf(word),65);
  for i:=1 to 10 do Writeln(e[i]);


  freemem(a);    
  freemem(b);    

END.
Código fuente 32: Ejemplo FillChar.
Descargar

Este procedimiento se usa principalmente para inicializar arreglos o variables dinámicas que se usan como arreglos, al utilizarse con variables de tipo string, ansistring, unicodestring, este procedimiento puede alterar el byte de longitud o su estructura interna, es por ello recomendado usar StringOfChar en estos casos.

Se debe tener presente que fillchar no toma en cuenta la estructura interna de las variables que se quieren rellenar con un determinado valor, por ejemplo si definimos el siguiente arreglo:

M:array [1..10] of word;

y luego usamos:

fillchar(M,10,5);

Fillchar lo que hará es colocar el valor 5, sólo a los primeros 10 bytes del arreglo, cuando el arreglo en realidad tiene 20 bytes, ya que el tipo word es de dos bytes, el segundo parámetro no indica los elementos de un arreglo, si no que indica la cantidad de bytes que se quieren rellenar con el valor indicado, y si mostramos el primer elemento del arreglo M[1], este nos mostrara el valor 85, ya que tomará los dos primeros bytes que hemos rellenado con el valor 5.($55 = 85). Debido a esta característica, fillchar tiene sus variantes que son fillbyte, fillword, fillDWord, fillQWord, en donde el primero se usa para rellenar un espacio de memoria de byte en byte, el segundo de 2 bytes en 2 bytes, el tercero de 4 bytes en 4 bytes y el último de 8 bytes en 8 bytes. Ejemplo:


Descargar
{$codepage utf8}
VAR

  p01:^byte;
  p02:^word;
  p03:^longword;
  p04:^qword;
  i:byte;
  n:byte;

BEGIN
  n:=5;
  getmem(p01,n*SizeOf(byte));
  getmem(p02,n*SizeOf(word));
  getmem(p03,n*SizeOf(longword));
  getmem(p04,n*SizeOf(qword));
  FillByte(p01^,n,25);
  FillWord(p02^,n,30);
  FillDWord(p03^,n,35);
  FillQWord(p04^,n,40);
  Writeln('   p01 p02 p03 p04');
  for i:=0 to n-1 do    
      Writeln(i:2,p01[i]:4,p02[i]:4,p03[i]:4,p04[i]:4);
  freemem(p01);    
  freemem(p02);    
  freemem(p03);    
  freemem(p04);    
END.
Código fuente 33: Ejemplo FillByte, FillWord, FillDWord y FillQWord.
Descargar

FillByte, FillWord, FillDWord y FillQWord, también se puede usar con arreglos dinámicos pero se debe colocar como primer parámetro el primer elemento del arreglo y no la variable. Ejemplo:


Descargar
{$codepage utf8}
VAR 
  p01:array of byte;
  p02:array of word;
  p03:array of longword;
  p04:array of qword;
  i:byte;
  n:byte;

BEGIN
  n:=5;
  SetLength(p01,n);
  SetLength(p02,n);
  SetLength(p03,n);
  SetLength(p04,n);
  FillByte(p01[0],n,25);
  FillWord(p02[0],n,30);
  FillDWord(p03[0],n,35);
  FillQWord(p04[0],n,40);
  Writeln('   p01 p02 p03 p04');
  for i:=0 to n-1 do    
      Writeln(i:2,p01[i]:4,p02[i]:4,p03[i]:4,p04[i]:4);

END.
Código fuente 34: Ejemplo FillByte, FillWord, FillDWord y FillQWord con arreglos dinámicos.
Descargar

‒ 2. Move.

Este procedimiento nos permite copiar el contenido de una variable a otra por bloques, sin tener en cuenta su estructura interna. Aunque el nombre hace pensar lo contrario, la variable del cual se toman los bytes para ser copiados no es borrado. El procedimiento Move tiene 3 parámetros. El primero es la variable que tiene los bytes a ser copiados. El segundo parámetro es la variable que recibirá los bytes previamente preparados para ser copiados, el tercer parámetro nos dice la cantidad de bytes que serán copiados. Ejemplo:


Descargar
{$codepage UTF8}
VAR p01:^byte;
    c01:array [0..9] of char;
    i:byte;    
	
BEGIN
  getmem(p01,10);
  fillchar(p01^,10,'A');
  for i:=0 to 9 do Write(Char(p01[i]));Writeln;
  fillchar(c01,10,'x');
  for i:=0 to 9 do Write(c01[i]);Writeln;
  Move(p01[5],c01[5],5);
  for i:=0 to 9 do Write(c01[i]);Writeln;
  freemem(p01)
END.
Código fuente 35: Ejemplo de Move.
Descargar

Lo que hace Move internamente es tomar la dirección de memoria que se le introduce en su primer parámetro, y desde esa dirección de memoria separa los bytes que se copiarán, en la otra dirección de memoria indicada en el segundo parámetro. En el ejemplo se le indica a Move que tome la dirección de memoria desde el elemento 5 de la variable p01, para copiar desde esa dirección en adelante 5 bytes y colocarlos en el arreglo c01 en la misma posición. Este método de copiar bytes es más rápido que usar un bucle for.

‒ 3. ReallocMem.

Es una función que nos permite cambiar el tamaño asignado a una variable dinámica, devolviendo una nueva dirección de memoria, si el tamaño a cambiar es menor entonces el contenido de la variable dinámica se truncará. Esta función sólo tiene 2 parámetros el primero es el puntero de la variable dinámica que se desea modificar, y el segundo la cantidad en bytes que se desea aumentar o disminuir, Ejemplo:


Descargar
{$codepage utf8}
VAR p:^byte;
    i:byte;

BEGIN
  getmem(p,10);
  fillchar(p^,10,9);
  for i:=0 to 9 do Write(p[i]);Writeln;
  p:=ReallocMem(p,15);
  fillchar(p[10],5,8);
  for i:=0 to 14 do Write(p[i]);Writeln;
  p:=ReallocMem(p,5);
  for i:=0 to 4 do Write(p[i]);Writeln;
  freemem(p)
END.
Código fuente 36: Ejemplo ReallocMem.
Descargar

Si el tamaño a cambiar es mayor, el contenido adicional no se inicializa a cero, el programador es responsable de inicializar esos datos. Esta función devuelve NIL, cuando no se pudo cambiar el tamaño de la variable dinámica, siempre y cuando se esté usando ReturnNilIfGrowHeapFails. ReallocMem no se usa con ansistring, unicodestring y arreglos dinámicos.


Ú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.








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.