PChar: Zeichen rechts abschneiden?

[Pseudemys Nelsoni]

Moin Marabu,

das ist mir (noch?) ein bisschen zu hoch, aber nochmal einfach gestellt :

Könnte ein Zugriff auf ein Zeichen VOR dem String je einen Fehler verursachen oder kann ich da immer problemlos drauf zugreifen? Es geht mir nur darum das di Funkktion natürlich keine AVs erzeugt

[bigg]

Motzi hat dazu ein Tut geschrieben:
http://www.manuel-poeter.de/index.php?site=tutorials


gruss bigg

[Dax]

Ja, kann. Bzw. wird irgendwann garantiert.

[marabu]

Zitat von Pseudemys Nelsoni:

Könnte ein Zugriff auf ein Zeichen VOR dem String je einen Fehler verursachen oder kann ich da immer problemlos drauf zugreifen?

Auf das Zeichen direkt vor deinem String oder auf irgendein Zeichen davor? Aus technischer Sicht mag die Frage interessieren (direkt davor liegen wahrscheinlich implementierungsbedingte Verwaltungsinformationen für diesen sehr "speziellen" Datentyp von Object Pascal), im Hinblick auf die Code-Qualität ist sie irrelevant. Dein Code darf beim Arbeiten mit Zeigern weder unbeabsichtigt (Fehlerfall), noch bewusst (Erfolg durch Nebenwirkung) auf "solche" Speicherbereiche zugreifen.

marabu

[Pseudemys Nelsoni]

@bigg: Guck ich mir an, danke
@Dax: Danke für die Info.

@marabu: auf irgendeinzeichen davor Ich denke ja das wir nichtmehr im string sind wenn wir unter dem ersten zeichen sind oder?

So sah meine Funktion aus, die alle Zeichen links gelöscht hat:

Delphi-Quellcode:

function StripCharsLeft(const S: string; CharSet: TCharSet): string;
var
  PResIdx: PChar;
  PSIdx: PChar;
  Idx: Integer;
  SLen: Integer;
begin
  SetLength(Result, Length(S));
  if S <> '' then
  begin
    PResIdx := @Result[1];
    PSIdx := @S[1];
    Idx := 0;
    SLen := Length(S);
    while (PSIdx^ <> #0) and (PSIdx^ in CharSet) do
    begin
      Inc(PSIdx);
      Inc(Idx);
    end;
    if PSIdx^ <> #0 then
    begin
      CopyMemory(@Result[1], PSIdx, SLen-Idx);
      SetLength(Result, SLen-Idx);
    end;
  end;
end;

Die wollte ich nun nochmal (selbst) so schreiben, das rechts gelöscht wird statt links, aber da wir ja am Anfang des Strings kein #0 Zeichen haben, bin ich daran bis jetzt gescheitert :\

Zitat:

Dein Code darf beim Arbeiten mit Zeigern weder unbeabsichtigt (Fehlerfall), noch bewusst (Erfolg durch Nebenwirkung) auf "solche" Speicherbereiche zugreifen.

Jo, ich dachte nur man darfs, wegen:

Zitat von marabu:

Klar doch

Oder war das Ironie?

Danke auch Dir

[marabu]

Den scheinbaren Widerspruch in den beiden von mir zitierten Aussagen möchte ich dann doch noch erklären:

Mit "klar doch" wollte ich zum Ausdruck bringen, dass dich der Compiler bei der Programmerstellung nicht daran hindert Zugriffe außerhalb deines strings zu machen. Das ist gewissermaßen die "innere" Sicht. Ich habe ja auch geschrieben, wo du da eventuell landest. Zur Verdeutlichung ein Stück Code aus vergangenen Zeiten:

Delphi-Quellcode:

function AllocString(size: cardinal): PChar;
var
  pCard: ^Cardinal;
begin
  pCard := AllocMem(size + 2 * SizeOf(Cardinal));
  pCard^ := size;
  Inc(pCard);
  pCard^ := 0; // length 
  Inc(pCard);
  Result := Pointer(pCard);
end;

In meinem späteren Beitrag habe ich die "äußere" Sichtweise eingenommen. Die Funktionen zum Umgang mit sz-strings und big strings basieren auf Konventionen - nach dem terminierenden #0 ist der string zu Ende und vor dem string liegender Speicher ist tabu. Man hält sich daran oder man weiß ganz genau was man da tut. Klar, dass systemnahes Programmieren mitunter auch zu implementationsabhängigem Code führen kann. Du solltest sowas aber weitgehend vermeiden.

Viel Spaß noch beim Arbeiten mit Zeigern.

marabu

PS: hast du der Schildkröte ein i geklaut oder ist das ein falscher Verdacht von mir?

[Olli]

Zitat von marabu:

Als ich mich noch mit solchen Fragen beschäftigt habe, da gab es eine global bzw. local descriptor table, in der Prozessor und MMU informiert wurden, welche Zugriffe auf welchen Speicher erlaubt sind. Ein Zugriff auf die falschen Adressen sollte vom OS erkannt und gemeldet werden.

LDT und GDT gibt es immernoch, und ja, die werden je nach Threadkontext anders geladen. So ist beispielsweise der TEB (Thread Environment Block) immer an einer anderen Stelle pro Thread, man kann ihn aber ermitteln, indem man fs:0 ausliest. Voila, ein Deskriptor ganz nach altem PM-Stil
Im PM sagt man zu cs, ds, es, fs usw. ja nicht umsonst "Segment-Deskriptoren", obwohl es doch keine Segmente mehr gibt

Zitat von Pseudemys Nelsoni:

Könnte ein Zugriff auf ein Zeichen VOR dem String je einen Fehler verursachen oder kann ich da immer problemlos drauf zugreifen? Es geht mir nur darum das di Funkktion natürlich keine AVs erzeugt

Egal wo, ja. Das Problem ist folgendes:

• Jeder Prozeß hat insgesamt 2 GB, die ihm gehören (die anderen 2 bis 4 sind "Kernelspeicher", kann aber auch verstellt werden, zB auf Servern)
• Wie kann ein Prozeß 2 GB haben wenn dein PC nur 1 GB hat?
• Es ist kein echter sondern virtueller Speicher (Linearer Speicher). Auf den echten kannst du aus dem Usermode nicht (ohne weiteres) zugreifen.
• Dieser Speicher wird in Tabellen vom OS verwaltet, welches dann dafür sorgt, daß lineare zu physikalischen Seiten gemappt werden können.
• Zugriff wird vom OS immer überprüft und wenn du woanders zugreifst als du alloziert hast, gibt's normalerweise eine Exception (auch die kann man bekanntlich abfangen)

Fazit: Laß es sein. Wenn du sowas mit Exceptions machen willst, schau dir an wie zB Stacks implementiert werden. Ansonsten ist Speicher den man nicht alloziert hat tabu. Und mit "man" meine ich hier einen beliebigen Teil deines Programmes (oder von außen einen Teil der als dein Programm agiert).
Hinweis: manche Stacks sind so implementiert, daß sie wachsen wenn eine Exception ausgelöst wurde. In diesem Fall wird die Exception vor dem Programm versteckt und intern genutzt um den Stack dynamisch zu vergrößern. Ich persönlich benutze das gerade für ein speichersparendes Modell von Molekülen.