Autor Beitrag
delfiphan
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2684
Erhaltene Danke: 32



BeitragVerfasst: Mi 06.04.05 01:01 
Folgender Code wird von Delphi7 und auch Delphi 2005 falsch compiliert. Einige Stunden Debugging waren nötig bis ich das Problem auf dieses Codestückchen beschränken konnte! :x
Zugegeben, die Prozedur RuinString ist ein etwas komisches Konstrukt. Da war natürlich noch mehr drum herum - ich hab das ganze aufs Wesentliche runtergekürzt und die Prozeduren umbenannt.

Wie dem auch sei. Hier das Problem: Die Funktion RuinString zerstört den String A!
Das sollte aber nicht passieren, denn RuinString hat
1. keine Var-Parameter und
2. wird sowieso überhaupt nirgends auf Speicher geschrieben.

Der Code ist syntaktisch korrekt, es werden auch keine Compiler-Errors/Warnings/Hints angezeigt.
Workaround: String(vAnsiString) auf Zeile 14 zuerst in eine temporäre String-Variable speichern und auf die Kopie zugreifen.

Also ich werde das mal Borland melden, falls sich rausstellt, dass es sich hier nicht um meinen Fehler handelt.

Jemand ne Idee?

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
{$APPTYPE CONSOLE}

procedure DoNothingWithChar(var AChar: Char);
begin
end;

procedure RuinString(Args: Array of Const);
begin
 if length(Args) > 0 then
  with Args[0] do
   Case VType of
    vtAnsiString: 
     if Length(String(vAnsiString)) > 0 then
      DoNothingWithChar(String(vAnsiString)[1]);
   end;
end;

Var
 A, B: String;
begin
 A := 'Hello, World';
 B := A;
 Writeln(Length(A)); // Ausgabe: 12
 RuinString([A]);
 B := '';
 Writeln(Length(A)); // Ausgabe: 28 (?!)
 readln;
end.
uall@ogc
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 1826
Erhaltene Danke: 11

Win 2000 & VMware
Delphi 3 Prof, Delphi 7 Prof
BeitragVerfasst: Mi 06.04.05 01:58 
ok ich gebe es zu das es ein bischen komisch ist, ABER

1) es wird wohl was geschrieben! nähmlich bei

ausblenden Delphi-Quelltext
1:
B := '';					


2)
a)

hierbei tritt der fehler auf, aber vor dem schreiben in B ist noch alles ok:

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
Var
 A, B: String;
begin
 A := 'Hello, World';
 B := A;
 Writeln(length(A)); // Ausgabe: 12
 RuinString([A]);
 Writeln(length(A)); // Ausgabe: 12
 B := '';
 Writeln(length(A)); // Ausgabe: 28 (?!)
 readln;
end.


b)

hier funktioniert wieder alles:

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
Var
 A, B: String;
begin
 A := 'Hello, World';
 B := A+'a';                   //änderung
 Writeln(length(A)); // Ausgabe: 12
 RuinString([A]);
 Writeln(length(A)); // Ausgabe: 12
 B := '';
 Writeln(length(A)); // Ausgabe: 12
 readln;
end.


c) ebenfalls hier ist wieder alles korrekt:

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
procedure DoNothingWithChar(var AChar: Char);
begin
  if Achar = #0 then asm end;  //änderung
end;

procedure RuinString(Args: Array of Const);
begin
 if length(Args) > 0 then
  with Args[0] do
   Case VType of
    vtAnsiString:
     if Length(String(vAnsiString)) > 0 then
      DoNothingWithChar(String(vAnsiString)[1]);
   end;
end;

Var
 A, B: String;
begin
 A := 'Hello, World';
 B := A;
 Writeln(length(A)); // Ausgabe: 12
 RuinString([A]);
 Writeln(length(A)); // Ausgabe: 12
 B := '';
 Writeln(length(A)); // Ausgabe: 12
 readln;
end.



d.h. der fehler tritt nur auf wenn

B := A
macht und snschließend ohne auf B oder A zuzugreifen B wieder ändert

ich denke delphi optimiert das so das bei einem nichtzugriff B = A ist, und somit mit B := '' auf A zugegriffen wird
es ist ein fehler, aber normalerweise tritt dieser nicht auf da wohl kein programmierer etwas ändert ohne später drauf zuzugreifen und dann wieder die variable ändert

ja ich bin gemein zu dir, aber so eine situation sollte man einfach gar net erst zulassen ^^

_________________
wer andern eine grube gräbt hat ein grubengrabgerät
- oder einfach zu viel zeit
Muetze1
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 346



BeitragVerfasst: Mi 06.04.05 13:17 
Moin!

Bei der Zuweisung macht er erstmal eine Referenz auf den String A im String B. Somit scheint hier nicht gewährleistet zu werden, dass die Referenzen aufgelöst werden müssen, wenn ein String verändert wird - also B wird nicht ordentlich abgetrennt.

MfG
Muetze1
Motzi
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2931

XP Prof, Vista Business
D6, D2k5-D2k7 je Prof
BeitragVerfasst: Mi 06.04.05 16:56 
@delfiphan: das ist kein Compiler-Bug, sondern eine Nebenwirkung des internen String-Handlings... schau dir einfach mal mein String-Tutorial auf www.manuel-poeter.de an, da wird auf diese internals eingegangen.

Gruß, Motzi

_________________
gringo pussy cats - eef i see you i will pull your tail out by eets roots!
delfiphan Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2684
Erhaltene Danke: 32



BeitragVerfasst: Mi 06.04.05 18:25 
Was hab ich denn bitte falsch gemacht? Es geht mir nicht darum, was der Compiler intern macht, ob der String Reference-Counted ist, ob was optimiert ist. Ich kann mir schon vorstellen, wie der Fehler entsteht.
Was ich sage ist, dass ich syntaktisch nichts falsch gemacht habe. Fact ist doch: Zwischen Zeile 23 und 26 wird A nicht verändert (Intern ist mir egal was passiert, ich habs nirgends angegeben). Aber trotzdem hat's am schluss Speichermüll drin.
Da gibt es wohl kleine Rechtfertigung dafür.


Zuletzt bearbeitet von delfiphan am Mi 06.04.05 18:29, insgesamt 1-mal bearbeitet
wdbee
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 628
Erhaltene Danke: 1



BeitragVerfasst: Mi 06.04.05 18:29 
Hast du das mal mit und ohne Optimierung probiert? Macht das einen Unterschied?
delfiphan Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2684
Erhaltene Danke: 32



BeitragVerfasst: Mi 06.04.05 18:30 
Es ist mir auch egal, ob's an der Optimierung liegt. Ich sag nur: Hier läuft was schief mit dem Compiler!

user profile iconuall@ogc hat folgendes geschrieben:

es ist ein fehler, aber normalerweise tritt dieser nicht auf da wohl kein programmierer etwas ändert ohne später drauf zuzugreifen und dann wieder die variable ändert
ja ich bin gemein zu dir, aber so eine situation sollte man einfach gar net erst zulassen ^^

Wie gesagt hab ich das ganze gestrippt bis aufs Minimum. Die Funktion DoNothingWithChar macht im meinem Programm natürlich was. Und es wird auch nicht umsonst eine Kopie des Strings erzeugt. Was ich gepostet hab ist einfach das minimale Programm, welches den Fehler noch zum Vorschein bringt.
wdbee
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 628
Erhaltene Danke: 1



BeitragVerfasst: Mi 06.04.05 18:36 
Ich sage ja garnichts dagegen, habe selbst auch schon Compilerfehler unter D5 festellen müssen (Spezieller Fall einer for-Schleife, bei der die Reihenfolge eine Rolle spielt, die Delphi aber ungefragt rückwärts ausführt). Mich interessiert nur, ob die Optimierung da ihre Finger im Spiel hat, oder es ein grundsätzliches Problem ist.

Und hast du einen Kompiler, bei dem das nicht auftritt? (Version?)
delfiphan Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2684
Erhaltene Danke: 32



BeitragVerfasst: Mi 06.04.05 18:38 
Wie gesagt, unter Delphi7 und Delphi 2005 kommt der Fehler. Was anderes hab ich leider nicht. Ich denke den Bug gibt's schon seit es AnsiStrings gibt.

PS: An der Optimierung liegt's nicht.
Motzi
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2931

XP Prof, Vista Business
D6, D2k5-D2k7 je Prof
BeitragVerfasst: Mi 06.04.05 18:53 
Also nochmal: das ist kein Bug!!

Ich hab dein Prog mal ein bisschen erweitert:
ausblenden volle Höhe Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;
  
type
  PStringInfo = ^TStringInfo;
  TStringInfo = packed record
    iRefCount   : Integer;
    iLenCount   : Integer;
    pStringAddr : Pointer;
  end;

procedure ShowStringInfo(const s: String);
var
  p: PStringInfo;
begin
  if s = '' then
    WriteLn('  s = ''''')
  else
  begin
    p := Pointer(s);
    Dec(Integer(p), 8);

    WriteLn(Format('  String:        %s', [s]));
    WriteLn(Format('  p.RefCount:    %d', [p^.iRefCount]));
    WriteLn(Format('  p.LenCount:    %d', [p^.iLenCount]));
  end;
end;

procedure DoNothingWithChar(var AChar: Char);
begin
end;

procedure RuinString(Args: Array of Const);
begin
 if length(Args) > 0 then
  with Args[0] do
   Case VType of
    vtAnsiString:
     if Length(String(vAnsiString)) > 0 then
      DoNothingWithChar(String(vAnsiString)[1]);
   end;
end;

Var
 A, B: String;
begin
  A := 'Hello, World';
  WriteLn('A := ''Hello, World'';');
  WriteLn('Inhalt von A:');
  ShowStringInfo(A);
  WriteLn(Format('  Pointer(A):    0x%p', [Pointer(A)]));
  WriteLn(Format('  @A:            0x%p', [@A]));
  WriteLn;
  WriteLn;


  B := A;
  WriteLn('B := A');
  WriteLn('Inhalt von A:');
  ShowStringInfo(A);
  WriteLn(Format('  Pointer(A):    0x%p', [Pointer(A)]));
  WriteLn(Format('  @A:            0x%p', [@A]));
  WriteLn;
  WriteLn('Inhalt von B:');
  ShowStringInfo(B);
  WriteLn(Format('  Pointer(B):    0x%p', [Pointer(B)]));
  WriteLn(Format('  @B:            0x%p', [@B]));
  WriteLn;
  WriteLn;
  
  Writeln(Length(A)); // Ausgabe: 12
    
  RuinString([A]);
  WriteLn('RuinString([A]);');
  WriteLn('Inhalt von A:');
  ShowStringInfo(A);
  WriteLn(Format('  Pointer(A):    0x%p', [Pointer(A)]));
  WriteLn(Format('  @A:            0x%p', [@A]));
  WriteLn;
  WriteLn('Inhalt von B:');
  ShowStringInfo(B);
  WriteLn(Format('  Pointer(B):    0x%p', [Pointer(B)]));
  WriteLn(Format('  @B:            0x%p', [@B]));
  WriteLn;
  WriteLn;


  Writeln(Length(A));
  B := '';
  WriteLn('B := '''';');
  WriteLn('Inhalt von A:');
  ShowStringInfo(A);
  WriteLn(Format('  Pointer(A):    0x%p', [Pointer(A)]));
  WriteLn(Format('  @A:            0x%p', [@A]));
  WriteLn;
  WriteLn('Inhalt von B:');
  ShowStringInfo(B);
  WriteLn(Format('  Pointer(B):    0x%p', [Pointer(B)]));
  WriteLn(Format('  @B:            0x%p', [@B]));
  WriteLn;
  WriteLn;

  Writeln(Length(A)); // Ausgabe: 28 (?!)
  ReadLn;
end.


Wenn du das ausführst und dir die Ausgabe anschaust siehst du unter anderem:
ausblenden Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
B := A
Inhalt von A:
  String:        Hello, World
  p.RefCount:    2
  p.LenCount:    12
  Pointer(A):    0x00C80854
  @A:            0x0040B848

Inhalt von B:
  String:        Hello, World
  p.RefCount:    2
  p.LenCount:    12
  Pointer(B):    0x00C80854
  @B:            0x0040B84C

Hier sieht man, Pointer(A) und Pointer(B) sind identisch, das heißt sie zeigen auf denselben Speicherblock, in dem sich Referenzzähler, Längenzähler und Text befinden. Da 2 Strings auf diesen Bereich zeigen ist RefCount logischerweise 2.

ausblenden Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
RuinString([A]);
Inhalt von A:
  String:        Hello, World
  p.RefCount:    1
  p.LenCount:    12
  Pointer(A):    0x00C80854
  @A:            0x0040B848

Inhalt von B:
  String:        Hello, World
  p.RefCount:    1
  p.LenCount:    12
  Pointer(B):    0x00C80854
  @B:            0x0040B84C

Nach Aufruf von RuinString zeigen noch immer beide Strings auf denselben Speicherbereich, RefCount ist aber nur mehr 1. Wenn B jetzt durch die Zuweisung des Leerstrings freigegeben wird, steht nur mehr Müll im Speicher, A zeigt aber immer noch auf diesen Bereich.

Woran liegt das nun? Schaun wir uns mal RuinString an:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
procedure RuinString(Args: Array of Const);
begin
 if length(Args) > 0 then
  with Args[0] do
   Case VType of
    vtAnsiString:
     if Length(String(vAnsiString)) > 0 then
      DoNothingWithChar(String(vAnsiString)[1]); // <-- hier wird intern UniqueString aufgerufen
   end;
end;

An der markierten Stelle wird intern UniqueString aufgerufen, da direkt auf ein einzelnes Zeichen des Strings zugegriffen wird. UniqueString soll dafür sorgen, dass ein String eindeutig ist, also sein Referenzzähler 1 ist. Dazu wird ein neuer String erstellt, der Referenzzähler auf 1 gesetzt, und der Text kopiert. Der Kopf von UniqueString schaut so aus:
ausblenden Delphi-Quelltext
1:
procedure UniqueString(var str: AnsiString);					

übernimmt also einen Var-Parameter. Normalerweise erhält der per Var-Parameter übergebene String die Adresse des neu erzugten String. In diesem Fall müsste aber die Variable A direkt an UniqueString übergeben werden. Da dies aber nicht der Fall ist (durch den array of const Parameter), kann A die neue Adresse aber nicht erhalten. Der Referenzzähler der an UniqueString übergebenen Variable wird aber dennoch um 1 dekrementiert, daher zeigen A und B im Endeffekt immer noch auf denselben Speicherbereich, obwohl RefCount nur mehr 1 ist.

Das Problem kannst du ganz einfach lösen, indem du vor dem Aufruf von RuinString manuell UniqueString aufrufst: UniqueString(A);

Gruß, Motzi

_________________
gringo pussy cats - eef i see you i will pull your tail out by eets roots!
delfiphan Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2684
Erhaltene Danke: 32



BeitragVerfasst: Mi 06.04.05 19:33 
Man möge es nennen wie man es will. Nebenwirkung... Ok. Aber Frage: War ich fahrlässig? Das: DoNothingWithChar(String(vAnsiString)[1]); kreiert Speichermüll und S:=String(vAnsiString); DoNothingWithChar(S[1]); funktioniert. Kein Compiler Hint oder Warning. Ich weiss nicht. Das ist doch zu mindest sehr merkwürdig.
Ist es denn meine Aufgabe, solche Fälle genau zu durchdenken; mir zu überlegen, was intern alles passiert? Es ist doch Aufgabe des Compilers, das ganze so auszubügeln, dass ich unbekümmert Strings rumkopieren kann, als Parameter übergeben kann, usw.. Solange ich nicht direkt mit Pointern hantiere und im Speicher rumschreibe, sollte ich meiner Meinung nach keine Probleme wie Speichermüll kriegen.

PS:
user profile iconMotzi hat folgendes geschrieben:
Das Problem kannst du ganz einfach lösen, indem du vor dem Aufruf von RuinString manuell UniqueString aufrufst: UniqueString(A);

:arrow: UniqueString aufrufen ist 1. keine Lösung (ich kann doch nicht vorschreiben, dass der User vor der Benützung der Prozedur ein UniqueString ausführen muss. Das wär dann definitiv nicht die Meinung). 2. UniqueString ausführen ist schlicht und einfach nicht die Aufgabe des Users.
Motzi
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2931

XP Prof, Vista Business
D6, D2k5-D2k7 je Prof
BeitragVerfasst: Mi 06.04.05 19:57 
user profile icondelfiphan hat folgendes geschrieben:
Man möge es nennen wie man es will. Nebenwirkung... Ok. Aber Frage: War ich fahrlässig? Das: DoNothingWithChar(String(vAnsiString)[1]); kreiert Speichermüll und S:=String(vAnsiString); DoNothingWithChar(S[1]); funktioniert. Kein Compiler Hint oder Warning. Ich weiss nicht. Das ist doch zu mindest sehr merkwürdig.

Ist auch logisch, du weißt den String einer neuen Variable (s) zu - RefCount ist daraufhin 3. DoNothingWithChar(S[1]); ruft daraufhin UniqueString mit S als Parameter auf. S erhält die Adresse des neu erzeugten Strings mit RefCount 1, RefCount des alten Strings wird von 3 auf 2 erniedrigt. Damit passt also alles.

user profile icondelfiphan hat folgendes geschrieben:
Ist es denn meine Aufgabe, solche Fälle genau zu durchdenken; mir zu überlegen, was intern alles passiert? Es ist doch Aufgabe des Compilers, das ganze so auszubügeln, dass ich unbekümmert Strings rumkopieren kann, als Parameter übergeben kann, usw.. Solange ich nicht direkt mit Pointern hantiere und im Speicher rumschreibe, sollte ich meiner Meinung nach keine Probleme wie Speichermüll kriegen.

Naja, im allgemeinen treten derartige Fehler nur sehr sehr selten auf. Das String-Handling von Delphi ist eigentlich eh sehr gut konzipiert, sodass man nur sehr selten mit den Internals in Berührung kommt. Das ist halt leider einer der Fälle wo das passiert. Im Allgemeinen braucht man sich nicht wirklich drum zu kümmern, nur wenn eben mal solche seltsamen Fehler auftreten sollte man wissen woran das liegen kann und wo man suchen muss.

user profile icondelfiphan hat folgendes geschrieben:
PS: UniqueString aufrufen ist 1. keine Lösung (ich kann doch nicht vorschreiben, dass der User vor der Benützung der Prozedur ein UniqueString ausführen muss. Das wär dann definitiv nicht die Meinung). 2. UniqueString ausführen ist schlicht und einfach nicht die Aufgabe des Users.

Es gibt mehrere Lösungen - entweder eben selbst UniqueString aufzurufen (ok, magst du nicht), WideStrings zu verwenden (die sind immer unique, wird dir aber wahrscheinlich auch nicht gefallen), oder eben wie du es oben schon gemacht hast innerhalb von RuinString noch mit einer dritten String-Variable zu arbeiten.

_________________
gringo pussy cats - eef i see you i will pull your tail out by eets roots!
Sprint
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 849



BeitragVerfasst: Mi 06.04.05 21:21 
Für mich ist das kein Compiler-Fehler, sondern ein Syntax Fehler der nicht bemängelt wird.
Eigentlich müsste es const Args: array of const heißen. Und dann würden deine spätern Fehler (var) auch aufgedeckt.

_________________
Ciao, Sprint.
delfiphan Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2684
Erhaltene Danke: 32



BeitragVerfasst: Mi 06.04.05 22:36 
"Eigentlich müsste es heissen". Es muss überhaupt nichts. Wer schreibt mir denn das Const vor? Das ist doch kein Syntaxfehler, wenn dort das Const fehlt! Aber egal wie: In meinem ursprünglichen Code steht tatsächlich const args: array of const drin. Das ganze sieht dort recht anders aus. Es kommt aber auch dort kein Compiler Warning. Das ganze kompiliert und es kommt derselbe Effekt. Es ist vielleicht kein Bug, aber eine Inkonsistenz der Sprache. Es ist ein Mangel, das steht fest.
Sprint
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 849



BeitragVerfasst: Do 07.04.05 04:17 
user profile icondelfiphan hat folgendes geschrieben:
Wer schreibt mir denn das Const vor?

Die Delphi Hilfe und zahlreiche Beispiele in der Unit SysUtils.

_________________
Ciao, Sprint.
delfiphan Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2684
Erhaltene Danke: 32



BeitragVerfasst: Do 07.04.05 10:57 
user profile iconSprint hat folgendes geschrieben:
user profile icondelfiphan hat folgendes geschrieben:
Wer schreibt mir denn das Const vor?

Die Delphi Hilfe und zahlreiche Beispiele in der Unit SysUtils.

Sprint,

1. Beispiele sind keine Belege. Das Const ist lediglich eine Optimierungssache bzw. semantisch sinnvoll, deswegen steht es meistens da.
2. Der Fehler lässt sich, wie schon oben gesagt, auch mit Const erzeugen (jedoch sieht das ganze dann etwas anders aus)
3. Bitte keine solche Behauptungen ohne Belege: In der Delphihilfe ist es ohne Const beschrieben:
Delphi-Hilfe hat folgendes geschrieben:
Variant open array parameters
(...)
To define a routine with a variant open array parameter, specify array of const as the parameter's type. Thus
procedure DoSomething(A: array of const);declares a procedure called DoSomething that can operate on heterogeneous arrays.

Also, bitte sei in Zukunft ein bisschen vorsichtiger mit deinen Behauptungen.
MrSaint
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 1033
Erhaltene Danke: 1

WinXP Pro SP2
Delphi 6 Prof.
BeitragVerfasst: Fr 08.04.05 09:19 
Also sorry leute, ich bin der meinung hier haben beide Seiten irgendwo recht. Rein logisch ist es schon nachzuvollziehen, dass der "Fehler" auftritt. Die Sach eist halt die,dass Delphi uns normalerweise mit solchen Speicherdingen nicht belastet, wie das z.B. C++ oder so tut, im Normalfall tut das alles Delphi für uns. Jetzt tritt hier halt ein Fall auf, in dem Delphi das nicht mehr tut. Das kann man nun als Fehler betrachten oder nicht, ich denke wegen so etwas muss man nicht streiten... Also bleibt doch mal ganz cool :)



MrSaint

_________________
"people knew how to write small, efficient programs [...], a skill that has subsequently been lost"
Andrew S. Tanenbaum - Modern Operating Systems
delfiphan Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2684
Erhaltene Danke: 32



BeitragVerfasst: Fr 08.04.05 11:22 
So viel zum Thema: "Is it a bug or a feature". Ich bin weiterhin der Meinung, dass es ein Bug bzw. eine Inkonsistenz ist, die man melden sollte. Man kann immer sagen "Der Compiler macht das und das, deswegen kommt's so raus". Es ist aber ein Fehlverhalten; sollte nicht sein. Solange man nicht direkt im Speicher rumschreibt oder Überläufe produziert sollte eine Sprache eigentlich absturzfrei sein.
Bei .NET ist's noch ne Stufe krasser: Wenn man da mit Pointern arbeiten will, wird sofort gemotzt und man muss es irgendwie als unsafe markieren, damit man damit arbeiten darf. Kenne mich bei .NET aber nicht wirklich aus.

Die Veränderung des ursprünglichen Strings ist in der Funktion RuinString semantisch gesehn absolut tabu, und das muss auch vom Compiler korrekt umgesetzt werden. Das Reference-Counting bereitet mir auch bei den Interfaces Probleme. Im Normalfall ist alles super, aber sobald man etwas Unübliches macht muss man stets aufpassen. Leider haben solche Inkonsistenzen normalerweise nur einen indirekten Fehler zur Folge, was das Debugging erschwert. Das ganze ist einfach noch nicht 100.0% ausgereift.