NatCompare

[himitsu]

Hab mir noch nicht alles durchgelesen, aber

Zitat:

Achtung : Die aufrufende Funktion muss sicherstellen, dass S1 und S2 nicht leer sind

warum machst du dann sowas wie p1:=@s1[1]; ?

p1:=PChar(s1); = fertig und keine Probleme mehr, wenn man nun auch noch auf #0 prüft oder bei den Berechnungen für n1/n2 etwas aufpaßt.

Zitat:

n1:=PChar(s1)+(Length(s1)-1)-p1;

(ich hoff mal die -1 stimmt)

[Furtbichler]

-gelöscht-

[Amateurprofi]

Zitat von himitsu:

warum machst du dann sowas wie p1:=@s1[1]; ?

p1:=PChar(s1);

Weiß ich eigentlich auch nicht so richtig, aber vermutlich aus dem gleichen Grund, aus dem du hier http://www.delphipraxis.net/1183123-post17.html nach
if Pointer(s1) = Pointer(s2) then Exit(True);
schreibst:
if Pointer(s1) = nil then l1 := 0 else l1 := (PInteger(s1) - SizeOf(Integer))^;
if Pointer(s2) = nil then l2 := 0 else l2 := (PInteger(s2) - SizeOf(Integer))^;
besser wäre
if (Pointer(s1)=nil) or (Pointer(s2)=nil) then Exit(false);
l1 := (PInteger(s1) - SizeOf(Integer))^;
l2 := (PInteger(s2) - SizeOf(Integer))^;
Warum?!
Weil du eingangs bereits geprüft hast, dass nicht beide identisch sind, was einschließt, dass nicht beide nil sind.
Wenn du dann feststellst, dass einer der beiden nil ist …..

Zur Ausgangsfrage :
Einfach nicht richtig überlegt.
Danke für den Hinweis (das ist nicht ironisch gemeint).

[Medium]

Zwischenfrage: Ist "nil" identisch mit dem Zahlenwert "0"? Weil rein aus Pointer-Sicht kann ein Null-Pointer ja überall unterhalb der Base-Address liegen, und muss daher nicht zwangsweise "0" sein um "nil" zu sein. Wie sicher ist "nil == nil"?

[himitsu]

Rein wertmäßig ist Beides absolut identisch:
Pointer(0) = nil
0 = NativeUInt(nil)

Aber Falsch. Nil liegt zwar unterhalb der Base-Adress, aber es kann nicht alles sein, was darunter liegt.
Erstmal gibt es mehrere Base-Adresse jenachdem was man als Base anzieht, hat jede DLL/EXE eine BASE (Startadresse) im Speicher und dann hat jeder bei Windows reservierter Speicherblock nochmal seine eigene BASE.

NIL ist aber immer "0".
Ja, früher haben ein paar Idioten Unwissende einfach Integer(P) <= 0 verwendet, um "ungültige" Zeiger zu erkennen, aber nicht für NIL-Zeiger,
aber das geht natürlich nur bis zu einer Speichernutzung von unter 2 GB "gut".



Klar kann man hier und da noch ein bissl was optimieren, vorallem wenn man einfach mal blind ignoriert, daß es Idioten gibt, welche fahrlässig an der Speicherverwaltung rumspielen. (aber die gehören eh gevierteilt und erschossen und gehängt und dann noch gesteinigt)

Delphi-Quellcode:

if Pointer(s1) = Pointer(s2) then Exit(True);
if Pointer(s1) = nil then Exit(False);
l1 := (PNativeUInt(s1) - 1)^;  // oder falls es keine Pointer-Arithmetik für diesen Pointer-Typ existieren
l2 := (PNativeUInt(s2) - 1)^;  // l2 := (PByte(s2) - SizeOf(NativeUInt))^;  // oder l2 := PAnsiChar(Pointer(s2)) - SizeOf...

// oder (aber hier legt Delpgi eventuell noch eine temporäre Vaiable für's Result auf den Stack, da nach Zuweisung
//   an das Result die Prozedur nicht sofort verlassen wird und je nach Optimierung könnte EAX belegt sein)
Result := Pointer(s1) = Pointer(s2);
if Result or (s1 = '') then Exit; // if Result or (Pointer(s1) = nil) then Exit;
l1 := (PNativeUInt(s1) - 1)^;
l2 := (PNativeUInt(s2) - 1)^;

[Amateurprofi]

Zitat von himitsu:

Delphi-Quellcode:

if Pointer(s1) = Pointer(s2) then Exit(True);
if Pointer(s1) = nil then Exit(False);
l1 := (PNativeUInt(s1) - 1)^;  // oder falls es keine Pointer-Arithmetik für diesen Pointer-Typ existieren
l2 := (PNativeUInt(s2) - 1)^;  // l2 := (PByte(s2) - SizeOf(NativeUInt))^;  // oder l2 := PAnsiChar(Pointer(s2)) - SizeOf...

// oder (aber hier legt Delpgi eventuell noch eine temporäre Vaiable für's Result auf den Stack, da nach Zuweisung
//   an das Result die Prozedur nicht sofort verlassen wird und je nach Optimierung könnte EAX belegt sein)
Result := Pointer(s1) = Pointer(s2);
if Result or (s1 = '') then Exit; // if Result or (Pointer(s1) = nil) then Exit;
l1 := (PNativeUInt(s1) - 1)^;
l2 := (PNativeUInt(s2) - 1)^;

Und was passiert, wenn s2 nil ist ?
Ich denke, nur s1 auf nil zu prüfen, reicht nicht. Oder übersehe ich da etwas?

[himitsu]

Stimmt, das passiert, wenn an wieder zu weit falschrum denkt.
Joar, s2 könnsollte man och noch prüfen.

Wenn s1=nil UND s2=nil wurde vorher abgefangen, also kann es danach nur noch unterschiedlich sein (und nicht gleich, wo man es weglassen hätte können)


Nja, was aber "theoretisch" niemals passieren kann, ist eine "Länge" von <= 0, denn bei sowas hat Borland es so definiert, daß der String dann intern NIL ist ... ist er nicht NIL ('' ), dann ist immer mindestens ein Zeichen darin. (außer jemand hat an der Speicherverwaltung rumgepfuscht)