uso de punteros

[[Lepe]]

Por supuesto que no tiene utilidad ni sentido... es un caso didáctico. Pongamos por ejemplo el caso que indica roman, pero con algo más cercano a nosotros, la propiedad Tag que tienen todos los controles, imaginamos un Checkbox, que al marcarlo, queremos poner un texto en un Edit, podríamos hacer algo así:

En el Oncreate:

Código Delphi [-]
  checkbox1.tag := integer(Edit1);

Al hacer clic en el checkbox:

Código Delphi [-]
TEdit(checkbox1.tag).Text:= 'Opcion activa';

para un checkbox es complicarse la vida, pero extrapolemos las cosas.... 30 checkbox asociados cada uno con un Edit. podemos tener un solo evento Onclick del checkbox, pero común a los 30 checkboxs de esta forma:

Código Delphi [-]
TEdit(    TCheckbox(Sender).tag     ).Text:= 'Opcion activa';

Sender : será el checkbox donde se haga clic
TCheckbox(Sender) : es necesario un moldeo de tipos, para que el compilador trate a ese Tobject como un Tcheckbox
TCheckbox(Sender).tag : Accedemos a su propiedad Tag, aquí se está usando lo ya comentado por roman, usar un tipo de datos integer para almacenar un puntero.
TEdit(TCheckbox(Sender).tag) : moldeo necesario para que ese .Tag lo trate como un TEdit en lugar de un tipo de dato entero.
Por último accedemos a su propiedad Text y lo modificamos.

Si, ya, complejo ¿acaso es mejor algo así?:

Onclic del checkbox1:

Código Delphi [-]
edit1.text:= 'Opcion activa';

Onclic del checkbox2:

Código Delphi [-]
edit2.text:= 'Opcion activa';

Onclic del checkbox3:

Código Delphi [-]
edit3.text:= 'Opcion activa';

... no sigo, ya lo entiendes de sobra .

Saludos.

[[Lepe]]

Ya veo que roman y seoane se han adelantado, abstrayéndome un poco del problema, te diré que los punteros te serán esenciales cuando necesites más potencia en los controles "simplones" que trae delphi, ya que con el simple Tag se pueden hacer virguerías, no solo asociar un TEdit, sino cualquier objeto o clase que exista o tú mismo crees... casi nada esa frasecita .

Saludos

[roman]

Lamento diferir. Usar la propiedad Tag como apuntador a una estructura, puede ser sin duda muy útil y es, de hecho, un muy buen ejemplo del uso de apuntadores en Delphi. No obstante, no me parece que sea una técnica a usar como una metodología corriente. Si requieres Edits que referencien a otro objeto entonces defines un derivado de TEdit al que agregas la propiedad pertinente. Es decir, ese uso de apuntadores puede sacarnos de apuros pero yo no lo tomaría como una práctica de programación. La VCL hace uso de algo muy similar en muchos de sus controles y ciertamente es algo muy potente; pero lo hace así porque no le queda de otra, pues es necesario para comunicarse con la API de Windows.

// Saludos

[roman]

Otro ejemplo, que seguramente Lepe tiene muy en mente, del uso de apuntadores en Delphi, es el VirtualTreeView. Yo lo pondría como la excepción que hace a la regla. Su autor es un magnífico programador con orígenes en C y, según creo recordar, el VirtualTreeView fue de lo primero que hizo en Delphi, así que no es de extrañar tanto uso de apuntadores. Claro está que no se le puede reprochar nada con tan magnífico componente, pero, lo dicho, es una honrosa excepción.

Tampoco digo que esté prohibido usar apuntadores en Delphi ni mucho menos, pero si una diferencia hay con C, es precisamente la poca necesidad de usarlos, por el tipo de datos que maneja Delphi y porque Delphi es un lenguaje a un nivel un poco más alto que C (alto aquí no tiene nada que ver con mejor).

// Saludos

[[AzidRain]]

Yo creo que nos complicamos mucho con los apuntadores famosos. Estos vienen diría yo de la prehistoria de Delphi (Pascal) en donde en mas de una ocasión habia que usarlos. A todos nos tocó seguramente lo de las infames listas ligadas o doblemente ligadas que es el ejemplo clásico de como usarlos.

En la actualidad con Delphi pienso que no es necesario utilizarlos directamente dado que han quedado "encapsulados" por así decirlo en la forma de variables de objeto que por lo que no son otra cosa que apuntadores disfrazados de variables simples. De hecho al hacer un simple

Código Delphi [-]
  MyVentana := TForm.Create(nil);

En realidad estamos asignando memoria suficiente para que quepa una estructura TForm y almacenamos la direccion de esa memoria en un puntero que llamaremos MyVentana (aunque para nuestro código MyVentana no es un puntero sino un "objeto").

La abstracción de la implementacion de OOP en Delphi se encaraga de tapar los problemas comunes de usar "^" y todo lo que ya conocemos.

La solución simple es no usar punteros directamente, crear objetos simples que contengan lo que queramos y utilizarlos como lo hariamos con cualquier otro objeto y dejar que Delphi haga el trabajo por nosotros.

Y como dice Roman, me parece que meterse con punteros sin tener mucha experiencia es meterse en camisa de once varas. Sobre todo porque difícilmente requerirás usarlo. Ahora que estoy haciendo otras cosas en Java noté que ahi no existen los punteros como tales aunque en realidad se manejan como objetos.

[[Lepe]]

Coincido con AzidRain, pero me atrevería a decir que es necesario saber los conceptos de punteros y demás teoría, para aplicarlos correctamente. Si veo algo definido como Integer, jamás se me ocurriría el truco de asignarle un objeto y después usar un moldeo de tipos.

Hay que saber:
- Qué es un puntero.
- Como funciona.
- Cuanto ocupa un puntero.
- Cuanto ocupa un Integer.

Normalmente todo eso se aprende de forma teórica, pero no se llega hasta el punto que hemos llegado en este hilo ¿no os parece?

Saludos

[roman]

Empezado por Lepe

¿no os parece?

De acuerdo contigo. Aunque usualmente no se requieran apuntadores en un programa Delphi, es un concepto que no debe ni puede desdeñarse.

// Saludos

[oswaldo77_77]

Holas de nuevo

Introduje un tema, en el foro de APIs, pero mas me parece que pertenece a este grupo (y ya lo dije)

El problema basicamente, es que tengo una estructura de registro llamada .... definida en una unidad TAPI.pas, con ella consigo hacer todo, excepto la finalidad, obtener un numero, esta es la estructura:

 
  LPLineCallInfo = ^TLineCallInfo;                   
  TLineCallInfo = record
    dwTotalSize,
    dwNeededSize,
    dwUsedSize: Longint;
    hLine: THLine;
    dwLineDeviceID,
    dwAddressID,
    dwBearerMode,
    dwRate,
    dwMediaMode,
    dwAppSpecific,
    dwCallID,
    dwRelatedCallID,
    dwCallParamFlags,
    dwCallStates,
    dwMonitorDigitModes,
    dwMonitorMediaModes: Longint;
    DialParams: TLineDialParams;
    dwOrigin,
    dwReason,
    dwCompletionID,
    dwNumOwners,
    dwNumMonitors,
    dwCountryCode,
    dwTrunk,
    dwCallerIDFlags,
    dwCallerIDSize,
    dwCallerIDOffset,
    dwCallerIDNameSize,
    dwCallerIDNameOffset,
    dwCalledIDFlags,
    dwCalledIDSize,
    dwCalledIDOffset,
    dwCalledIDNameSize,
    dwCalledIDNameOffset,
    dwConnectedIDFlags,
    dwConnectedIDSize,
    dwConnectedIDOffset,
    dwConnectedIDNameSize,
    dwConnectedIDNameOffset,
    dwRedirectionIDFlags,
    dwRedirectionIDSize,
    dwRedirectionIDOffset,
    dwRedirectionIDNameSize,
    dwRedirectionIDNameOffset,
    dwRedirectingIDFlags,
    dwRedirectingIDSize,
    dwRedirectingIDOffset,
    dwRedirectingIDNameSize,
    dwRedirectingIDNameOffset,
    dwAppNameSize,
    dwAppNameOffset,
    dwDisplayableAddressSize,
    dwDisplayableAddressOffset,
    dwCalledPartySize,
    dwCalledPartyOffset,
    dwCommentSize,
    dwCommentOffset,
    dwDisplaySize,
    dwDisplayOffset,
    dwUserUserInfoSize,
    dwUserUserInfoOffset,
    dwHighLevelCompSize,
    dwHighLevelCompOffset,
    dwLowLevelCompSize,
    dwLowLevelCompOffset,
    dwChargingInfoSize,
    dwChargingInfoOffset,
    dwTerminalModesSize,
    dwTerminalModesOffset,
    dwDevSpecificSize,
    dwDevSpecificOffset: Longint;
    dwCallTreatment,                                { TAPI v2.0 }
    dwCallDataSize,                                 { TAPI v2.0 }
    dwCallDataOffset,                               { TAPI v2.0 }
    dwSendingFlowspecSize,                          { TAPI v2.0 }
    dwSendingFlowspecOffset,                        { TAPI v2.0 }
    dwReceivingFlowspecSize,                        { TAPI v2.0 }
    dwReceivingFlowspecOffset: Longint;             { TAPI v2.0 }
  end;

La logro usar asi:

 
              var
              wLPCALLINFO:  TLineCallInfo;
              r:            Integer;

              r:=LineGetCallInfo(hCall, wLPCALLINFO);

Y como me devuelve el offset y el size en:

 
              wNum:=wLPCALLINFO.dwCallerIDSize;
              wNum:=wLPCALLINFO.dwCallerIDOffset;

trato de acceder a el valor del numero telefonico, que se supone debería de obtenerlo en una formula mas o menos asi:

              www:=copy(StrPas(PChar(@wlpCallInfo)+wLPCALLINFO.dwCalledIDOffset),1,wLPCALLINFO.dwCalledIDSize);

Como veis el problema es acceder ese valor, no se como hacerlo. Este problema es basicamente manejo de punteros.

Aver si alguien me echa una mano. gracias.

Osw