Hallo Zusammen,

ich habe eine Procedur, die erwartet einen Int-Wert als Parameter:

ProcedurB(intValue : Integer) An diese Methode möchte ich allerdings einen double übergeben. Überschreiben oder mit globalen Variablen möchte ich nicht arbeiten.
Nun war die Idee einen Int-Pointer zu erstellen und diesen auf den Double-Wert zeigen zu lassen. An ProcedurB wird der Pointer-Wert des Integer-Pointers übergeben, das ganze sieht wie folgt aus:

markieren

Delphi-Quellcode:

procedure ProcedureA(Gewicht : double);
var
  pGewicht : PInteger;
begin
  pGewicht := nil,
  New(pGewicht);
  pGewicht := @Gewicht;

  ProcedurB(pGewicht^);
end;

Erhoffte 'Rückkonvertierung' in ProcedurB geht leider nicht bzw. ich habe dabei nichts gewonnen:

markieren

Delphi-Quellcode:

procedure ProcedurB(intWert : Integer)
var
pGewicht : PInteger;
Gewicht : double;
begin
  pGewicht := @intWert;
  Gewicht := pGewicht^;
end

Hierbei hat man nichts gewonnen, d.h. natürlich kommt nur der Int-Wert heraus, da ich in ProcedurA einen Int-Pointer verwendet habe. Wie kann das Problem gelöst werden? (Geht das überhaupt: Einen Double Wert als "Integer-Pointer-Wert" übergeben und zurück)

zusammenfalten · markieren

Delphi-Quellcode:

procedure ProcedureA(Gewicht : double);
var
  A_pGewicht : PInteger;
begin
  A_pGewicht := nil,
  New(A_pGewicht);
  A_pGewicht := @Gewicht;

  ProcedurB(A_pGewicht^);
end;

procedure ProcedurB(B_intWert : Integer);
var
  B_pGewicht : PInteger;
  B_Gewicht : double;
begin
  B_pGewicht := @B_intWert;
  B_Gewicht := B_pGewicht^;
end;

zusammenfalten · markieren

Delphi-Quellcode:

procedure ProcedureA(Gewicht : double);

var
  A_pGewicht : PInteger;
  B_pGewicht : PInteger;
  B_Gewicht : double;

//A_pGewicht := nil; nicht verwendet, da eh gleich überschrieben
New(A_pGewicht);
A_pGewicht := @Gewicht; // Zeiger auf Gewicht
// der Zeiger auf den mit New reservierten Speicher wird überschrieben = Speicherleck

//ProcedurB(A_pGewicht^);
B_intWert := A_pGewicht^; // Byte 1 bis 4 von Gewicht

B_pGewicht := @B_intWert; // Zeiger auf B_intWert
B_Gewicht := B_pGewicht^; // Wert von B_intWert = Byte 1 bis 4 von Gewicht

Wenn Gewicht rein zufällig ein Integer gewesen wäre, dann hätte es vielleicht klappen können.

Versuch es mal mit PDouble, statt PInteger.



oder belaß es einfach bei einem konvertierten Pointer:

zusammenfalten · markieren

Delphi-Quellcode:

procedure ProcedureA(Gewicht : double);
begin
  ProcedurB(Integer(@Gewicht));
end;

procedure ProcedurB(intWert : Integer);
var
  Gewicht : double;
begin
  Gewicht := PDouble(intWert)^;
end;

Durch casten kannst du natürlich den den Speicher eines Double als Integer interpretieren lassen. Allerdings macht das keinen Sinn da der Wert als Double interpretiert etwas ganz anderes ergibt.

@himitsu: Aus deiner Antwort werde ich nicht ganz schlau, was ist davon nun richtig und was falsch? Ich bin diese Beispiele durchgegangen und habe dies in meinem Programm umgesetzt, leider ohne Erfolg.

Zitat von himitsu:

zusammenfalten · markieren

Delphi-Quellcode:

procedure ProcedureA(Gewicht : double);

var
  A_pGewicht : PInteger;
  B_pGewicht : PInteger;
  B_Gewicht : double;

//A_pGewicht := nil; nicht verwendet, da eh gleich überschrieben
New(A_pGewicht);
A_pGewicht := @Gewicht; // Zeiger auf Gewicht
// der Zeiger auf den mit New reservierten Speicher wird überschrieben = Speicherleck

//ProcedurB(A_pGewicht^);
B_intWert := A_pGewicht^; // Byte 1 bis 4 von Gewicht

B_pGewicht := @B_intWert; // Zeiger auf B_intWert
B_Gewicht := B_pGewicht^; // Wert von B_intWert = Byte 1 bis 4 von Gewicht

Dies ist (entschuldigung) etwas chaotisch. Ich erwarte natürlich keine 100% passende Lösung (will ja selbst noch zu Lösung beitragen ) jedoch verstehe ich es nicht.

Zitat von himitsu:

oder belaß es einfach bei einem konvertierten Pointer:

zusammenfalten · markieren

Delphi-Quellcode:

procedure ProcedureA(Gewicht : double);
begin
  ProcedurB(Integer(@pGewicht));
end;

procedure ProcedurB(intWert : Integer);
var
  B_Gewicht : double;
begin
  B_Gewicht := PDouble(intWert)^;
end;

Geht leider nicht.

Der erste Codeblock zeigt das, was in deinem Beispielcode sozusagen intern abliefäuft.

Der Letzte zeigt den "einfachen" Weg.

Ein Pointer ist aktuell (in Win32) genauso groß, wie ein Integer ... also braucht man einfach nur zwischen Pointer und Integer hin- und hercasten.

[edit]

Zitat:

Geht leider nicht.

Was geht nicht?
(ist nicht böse gemeint, aber das sind "Fehlerbeschreibungen", welche überhaupt nicht weiterhelfen)

Wenn du das angeblich unbekannte "pGewicht" meinst ... da hätte man eventuell auch selber draufkommen können, daß ich mich da verkopiert (verschrieben) hab und "Gewicht" gemeint war.

Hab den Code da oben nochmal korrigiert.

Jup, diesen Fehler habe ich bereits korrigiert. Liefere gleich mehr Infos was gemeinst ist, habe gerade noch 'schnell' etwas probiert...

EDIT: Was ich gemeint habe ist das Ergebnis. Wenn ich z.B. 123,456 übergebe, hat das
Gewicht in ProcedurB anschliessend den Wert 4,205...e-291 , also mit sovielen Nachkommstellen, das dies zwangsläufig eine Exception wird. Fehlt mir da noch eine Wertkonvertierung? (Ist länger her bei mir )

Du hast den Code von himitsu nicht richtig zitiert. Bei dir heist es an einer Stelle pGewicht, im Orginal steht überall Gewicht.
Der Code von himitsu funktioniert, also machst du etwas anders/falsch.
Wenn du uns jetzt deinen Code zeigst ...

@Blup: Da stand wirklich pGewicht.

Theoretisch ist alles nun korrekt bei mir, aber genanntes Problem der 'Rückkonvertierung' (Zahl mit vielen Nachkommstellen) bleibt bestehen. Mein jetziger Stand:

zusammenfalten · markieren

Delphi-Quellcode:

procedure ProcedureA(Gewicht : double)
begin
ProcedureB(Integer(@Gewicht))
end;


procedure ProcedureB(intWert: integer)
var
  Gewicht: double
begin
  Gewicht := PDouble(intWert)^;
end;

Inzwischen habe ich das auch selbst (wieder) verstanden (ich komme aus der C++ Welt, dann C#, jetzt Delphi), in der Theorie bzw. vom Verständnis her macht das sinn und sollte funktionieren. Bei der Rückkonvertierung wird der IntWert wieder in einen Double-Zeiger konvertiert und anschliessend der Wert ausgelesen. Habe ich vielleicht noch etwas vergessen? Initialisierungen? New-Operator?