Pointerinhalt verändern

[marabu]

@Jasmine:

Delphi-Quellcode:

uses
  Windows;
  
const
  CBUFSIZE = 1024;

var 
  buffer, src: PByte; 
  copyBuffer, tgt: PByte; 

begin
  buffer := Pchar(AllocMem(CBUFSIZE)); 
  copybuffer := Pchar(AllocMem(CBUFSIZE)); 
  FileRead(FH, buffer^, 50); 

  src := buffer;
  tgt := copyBuffer
  for i := 1 to 50 do begin
    tgt^ := src^ + vari[i];
    Inc(src); // Zeiger um eine Stelle weiterrücken
    Inc(tgt);
  end;
end;

Grüße vom marabu

[SirThornberry]

von welchem Typ ist dein "vari"? wenn es ebenso ein PChar ist könntest du mit move arbeiten, dies sollte so ziemlich das schnellste sein

Delphi-Quellcode:

move(vari^, copybuffer^, 50);

wenn du dich für die andere Variante mit der Schleife entscheidest solltest du daran denken das der Schleifendurchlauf bei 0 beginnen sollte weil PChar 0 bassierend ist und nicht wie String 1 basierend.
Bei PChar würdest du also mit

Delphi-Quellcode:

copybuffer[1] := 'a';

das zweite zeischen schreiben

[barf00s]

tuts da nich auch einfach nen

Delphi-Quellcode:

Move(pointer(ziel)^, pointer(quelle)^, groesseinbytesofquelle);

[Olli]

Zitat:

Zitat von Delphi-Freak

Bedeutet das, dass wenn man zwei Typen

Delphi-Quellcode:

type
  MyType: Array of Byte;
  PMyType: ^MyType;

hat, dass es dann automatisch die »Funktion« PMyType gibt, um einen Pointer zu erzeugen? :gruebel:

Nein, es bedeutet, daß man verschiedene Typen ineinander "konvertieren" kann. Das nennt sich dann "Typecast". Diese Methode gibt es in verschiedenen Sprachen und sie ist an verschiedenen Stellen unabdingbar - insofern deine benutzte Sprache eine halbwegs rigide Typüberprüfung während der Kompilation vornimmt.

Beispiel:

Delphi-Quellcode:

var
  Int32: Integer; // vorzeichenbehaftet 32bit
  UInt32: DWORD; // vorzeichenlos 32bit
  Bla: PChar; // Pointer auf nullterminierte Zeichenkette
begin
  Int32 := -1;
  UInt32 := DWORD(Int32); // vorzeichenbehaftet nach vorzeichenlos konvertieren
  // Hier ist (UInt32 == $FFFFFFFF)
  Bla := 'Ottokar das Früchtchen';
  UInt32 := DWORD(Bla); // Pointer nach "unsigned integer"
  UInt32 := UInt32 + 4;
  Bla := PChar(UInt32);
  // Hier zeigt Bla auf 'kar das Früchtchen'! Wir sind nämlich 4 Bytes vorgerückt
end;

String(PCharVariable) und PChar(StringVariable) gehören ebenfalls in diese Kategorie, haben aber noch eine tiefere Bedeutung ("compiler magic")!

[Jasmine]

Hallo ihr Lieben,

vielen Dank für die vielen Tips.

Ich habe verstanden, dass man einen PChar Pointer nicht mit Byte oder PByte
verrechnen kann, wie ich es versuchte, da mein vari :
array[1..100] of byte
ist.

Im Prinzip will ich von einem File in einen buffer schreiben, diesen mit Werten meines
Arrays vari verrechnen und den geänderten Buffer wieder in ein File schreiben.

Die Idee von maribu war schon nicht schlecht, allerdings gibt es in dem Beispielcode
auch einen Konflikt zwischen der Deklaration von PByte und dann der Speicherreservierung
Pchar(AllocMem(CBUFSIZE)). Wenn ich hier auch mit PByte reserviere, startet mein Programm,
jedoch stürzt es an der Stelle ab und gibt ein Exeption mit Pointer invalid operation oder
so aus.

Werde mal die Idee von brechi :

Delphi-Quellcode:

type tbla: array[0..0] of byte; 
     pbla: ^tbla; 
     bla: pbla; 
begin 
  bla := copybuffer; 
  for i := 0 to 50-1 do 
    bla[i]^ := bla[i]^+var[i]; 
end;

ausprobieren.

Würde mich über weitere Hilfe sehr freuen und Danke für eure Geduld.

Jasmine :cat:

[marabu]

Hallo Jasmine,

Zitat:

Zitat von Jasmine

Die Idee von maribu war schon nicht schlecht, allerdings gibt es in dem Beispielcode auch einen Konflikt zwischen der Deklaration von PByte und dann der Speicherreservierung
Pchar(AllocMem(CBUFSIZE)).

Weg mit dem unnützen type cast - und vergess nicht später deinen dynamisch angeforderten Speicher wieder frei zu geben.

marabu

[Jasmine]

Also ist schon seltsam mit PChar und PByte.

Einen Pointer mit PByte deklariert kann ich nicht mit :

copybuffer[i]^:=copybuffer[i]^+vari[i]; oder

copybuffer^[i]:=copybuffer^[i]+vari[i]; oder

copybuffer[i]:=copybuffer[i]+vari[i]; setzen. (vari:array[1..100] of integer)

Wenn ich allerdings einen PChar Pointer nehme klappt es,
allerdings kann ich dann kein Integer / Byte Wert in vari[i] nehmen.

Also habe ich den Wert erst mit integer(copybuffer[i]) in eine Zwischenvaliable a als
Integer deklariert gelesen, dann meinen vari[i] dazuaddiert, und wieder über
copybuffer[i]:=var(a) in den Speicher zurückgeschrieben und es funktioniert.

Ist vielleicht nicht sehr elegant, aber läuft.

Mich würde jetzt brennend interessieren, warum ich dasselbe nicht mit einem PByte deklarierten
Pointer machen kann. Vielleicht weil PByte nicht gleich Integer ist ? Ich werde mal einen Pointer mit PInteger versuchen.

Danke trotzdem, habt mir sehr geholfen.

Jasmine :hello:

[SirThornberry]

wenn du eine Datei verändern willst kannst du auch gleich TFileStream nehmen und dann mit YourFileStreamInstanz.Write den buffer direkt in die Datei schreiben, das müsste dir ne Menge arbeit spaaren und sollte auch von der performance her recht flott sein.

[brechi]

wenn du nen integer nimmst musst du auch nen pinteger nehmen anstatt nen pbyte...
oder du musst halt den integer mit byte(vari[i]) abschneiden

[Delphi-Freak]

Zitat:

Zitat von Olli

Zitat:

Zitat von Delphi-Freak

Bedeutet das, dass wenn man zwei Typen

Delphi-Quellcode:

type
  MyType: Array of Byte;
  PMyType: ^MyType;

hat, dass es dann automatisch die »Funktion« PMyType gibt, um einen Pointer zu erzeugen? :gruebel:

Nein, es bedeutet, daß man verschiedene Typen ineinander "konvertieren" kann. Das nennt sich dann "Typecast". Diese Methode gibt es in verschiedenen Sprachen und sie ist an verschiedenen Stellen unabdingbar - insofern deine benutzte Sprache eine halbwegs rigide Typüberprüfung während der Kompilation vornimmt.

Beispiel:

Delphi-Quellcode:

var
  Int32: Integer; // vorzeichenbehaftet 32bit
  UInt32: DWORD; // vorzeichenlos 32bit
  Bla: PChar; // Pointer auf nullterminierte Zeichenkette
begin
  Int32 := -1;
  UInt32 := DWORD(Int32); // vorzeichenbehaftet nach vorzeichenlos konvertieren
  // Hier ist (UInt32 == $FFFFFFFF)
  Bla := 'Ottokar das Früchtchen';
  UInt32 := DWORD(Bla); // Pointer nach "unsigned integer"
  UInt32 := UInt32 + 4;
  Bla := PChar(UInt32);
  // Hier zeigt Bla auf 'kar das Früchtchen'! Wir sind nämlich 4 Bytes vorgerückt
end;

String(PCharVariable) und PChar(StringVariable) gehören ebenfalls in diese Kategorie, haben aber noch eine tiefere Bedeutung ("compiler magic")!

Aha, das erklärt einiges, Danke :thumb:

LG, Delphi-Freak