Punteros y Variables
 

Buenas a todos.
Me he fijado que se utiliza mucho esta construcción:

Código Delphi [-]
type
PCycleArray = ^TCycleArray;
TCycleArray = array[1..100] of Integer;
.
.
.
var
CycleArray:PCycleArray;

y la verdad, creo que es mas sencillo declararla así:

Código Delphi [-]
type
TCycleArray = array[1..100] of Integer;
.
.
.
var
CycleArray:TCycleArray;

La cosa es que NO sé cual es la diferencia entre una declaración y la otra, ¿alguien me podría decir en qué se diferencia y porqué sospecho que la primera es más profesional?.

Gracias.

Comentario sobre el primer código que has puesto:

- Cuando declaras una variable de tipo PCycleArray, es un puntero, o sea 4 bytes en memoria.
- cuando declaras una variable de tipo TCycleArray, estás creando la tabla completa, con todos los elementos, por tanto ocupas más memoria.

Muchas rutinas de la api se le pasan punteros, por tanto, por comodidad, se usa la primera declaración.

Un saludo

Hola Lepe.
Sé que sé poco de OOP ;) pero no me cuadra, si declaro PCycleArray tendrá que ocupar todo el espacio de la variable TCycleArray porque sino es así ¿donde meto los datos de la variable?.
La verdad es que no lo entiendo del todo bien, ¿puedes esplicarmelo un poco mejor por favor?.
Gracias.

No es que una forma sea mas profesional que la otra. El uso de punteros te permite hacer mas dinámico y eficiente el uso de memoria. De hecho, la solución con puntero en el caso que expusiste ocupa en realidad 4 bytes mas de memoria al reservar la memoria para la estructura (en este caso array)... pero mientras esto no se haga, ocupará solamente 4 bytes como bien lo apuntó ya Lepe.

Otra diferencia importante es que al inicializar un puntero, la memoria se reserva en el heap (monton), mientras que si es una variable estática local se consume el precioso espacio del stack (pila) y si es estática pues queda en el segmento de datos del ejecutable.

Veamos:

Código Delphi [-]
type
  PCycleArray = ^TCycleArray;
  TCycleArray = array[1..100] of Integer;

Procedure Prueba;
var
  CycleArrayD : PCycleArray; // esta variable ocupa 4 bytes en memoria
  CycleArrayE : TCycleArray; // esta variable ocupa 400 bytes de memoria

Begin
  New(CicleArrayD); // esto reserva los 400 bytes en el heap
  // a partir de aqui el uso es prácticamente el mismo.
  CicleArrayE[1] := 20;
  CicleArrayD^[1] := 20;
  .
  .
  .
  Dispose(CicleArrayD); // si esto no se hace la memoria se queda desperdiciada!
End;

Con uso tan simple, yo me decantaría por la variable estática, dado también su poco consumo de memoria. La principal ventaja de los punteros es que te permite manejar estructuras de datos mas complejas de manera dinámica y limitado prácticamente solo por los recursos de la máquina: pilas, colas, listas, árboles, etc.

Hasta luego.

;)

Tienes q leer sobre la alocacion dinamica y alocacion estatica y asi lo entedneras. Las variables estaticas se alocan automaticamente al comenzar el programa y terminar con el. Las dinamicas (q estan apuntadas por una variable estatica que es el puntero) se alocan dinamicamente segun la necesidad del programa y se desalocan tb dinamicamente al ordenarlo el programa y asi se libera memoria durante la ejecucion del programa sin terminarlo. En el caso de los records es recomendable usar la alocacion dinamica en Delphi/Pascal; en el caso de objects y classes es obligatorio..

Esto es cierto para las variables globales... para las variables locales de procedimientos/funciones, la memoria se reserva automáticamente en la pila al entrar al procedimiento/función y se liberan al salir de él.

Por cierto, Delfino, de donde has sacado la palabra alocar?... eso en mi pueblo es equivalente a desquiciar, y hasta donde se las variables siguen siendo cuerdas, a menos que el programador pierda el control... :D

Supongo que viene de una mala traducción del ingles allocate

verbo alocar

allocate verb

Hasta luego.

;)

Con razón mis colegas me miran raro cuando les digo que mis objetos se alocan. :rolleyes:

// Saludos

En frances
allocation dynamique
allocation statique

AllocMem en Delphi