Access Violation nach Hinzufügen eines RichEdit

[Caps]

Hi,

folgendes merkwürdige passiert bei mir:
Ich habe eine Form und ein paar Buttons, mit denen ich einen Algorithmus anstoße, der mit dynamischen Arrays arbeitet.
Soweit alles gut - funktioniert.

Füge ich jedoch der Form ein RichEdit hinzu (einfach nur Hinzufügen der Komponente, keine Event-Handler oder sonst was) und führe das Programm aus, so erhalte ich regelmäßig eine AccessViolation (Schreibzugriff) bei der SetLength-Funktion, die mein dyn. Array vergrößern soll.

Ich vermute, dass SetLength den Speicherbereich beschreiben will, in dem die RichEdit-Komponente angesiedelt ist, aber das kann ich in der WatchList nicht genau ausmachen.

Bevor ich Code poste (weil ist viel) wollte ich fragen, ob jemandem so ein Problem schon begegnet ist, oder ob es weitere Ideen gibt.

Grundsätzlich verfahre ich mit dynamischen Arrays so:
- Deklaration
- Allokierung mit SetLength
- Wertezuweisung

Muss ich noch was beachten? Kümmert sich Delphi nicht um die Trennung der Speicherbereiche? Bzw. wie kann ich sicherstellen, dass ich nicht in den Speicher einer Komponente schreibe?

Schonmal danke für Ideen & viele Grüße
Caps

Edit: es tritt auch auf, wenn ich andere Komponenten hinzufüge, statt eines RichEdits...

[Uwe Raabe]

Zitat von Caps:

Kümmert sich Delphi nicht um die Trennung der Speicherbereiche?

Doch, das tut es!

Zeig doch mal den Code - wenigstens von der Deklaration des Arrays bis zum SetLength...

[himitsu]

Zitat von Uwe Raabe:

Doch, das tut es!

Innerhalb einer Anwendung nicht.

Und zwischen verschiedenen Anwendungen trennt Windows das ab. (seit der WinNT-Reihe)

[Uwe Raabe]

Zitat von himitsu:

Zitat von Uwe Raabe:

Doch, das tut es!

Innerhalb einer Anwendung nicht.

Natürlich trennt Delphi den Speicherbereich eines dynamischen Arrays von dem einer Objekt-Instanz. Insofern kann man eigentlich gefahrlos ein SetLength auf ein Array loslassen, ohne sich um den dabei involvierten Speicher zu kümmern. Das wäre ja vorsintflutlich, wenn man sich noch selbst um die Position seiner Variablen im Speicher kümmern müsste.

Die Tatsache, daß es in diesem Fall zu einer Access-Violation kommt ist mit hoher Wahrscheinlichkeit ein Fehler im Code - und nicht eine Unzulänglichkeit von Delphi.

[Luckie]

Es sieht so aus, als wenn er seinen Speicher nicht sauber verwaltet (hinter das Array schreibt) und bisher Glück gehabt hat, weil da nichts kam. Jetzt liegt da aber wohl das RichEdit im Speicher und dann überschreibt er sich den Speicher des RichEdits.

[Uwe Raabe]

Zitat von Luckie:

Es sieht so aus, als wenn er seinen Speicher nicht sauber verwaltet (hinter das Array schreibt) und bisher Glück gehabt hat, weil da nichts kam. Jetzt liegt da aber wohl das RichEdit im Speicher und dann überschreibt er sich den Speicher des RichEdits.

Das glaube ich auch - aber er zeigt uns ja nichts...

[Caps]

Hi,

naja, ich war gestern nicht am Rechner... aber jetzt zeig ich was.
Danke für die Antworten inzwischen!
(Leider bekomme ich nach der Access Violation nur ein CPU-Fenster angezeigt, da erkenne ich leider nicht, was schiefgegangen sein könnte)

Deklaration von TCell:

Delphi-Quellcode:

    TCell = class(TObject)
            public
             entries: Array of TCellEntry; // Zelleinträge
             position: TCellReference; // Metrische Position der Zelle
             constructor Create; overload;
             constructor Create(pX, pY, pZ: Integer); overload;
             procedure addToEntries(pMainIndex: Integer; pWayPoints: TIntArray); overload;
             procedure addToEntries(pMainIndex: Integer; pWayPoints: Array of Integer); overload;
             function transit(pMainIndex, pStepWidth: Integer): Boolean;
            end;

Implementierung von addToEntries(), der Methode von TCell innerhalb derer das SetLength schiefgeht:

Delphi-Quellcode:

procedure TCell.addToEntries(pMainIndex: Integer; pWayPoints: TIntArray);
var
   len: Integer;
begin
With self do begin
     len := Length(entries);
     inc(len);
     SetLength(self.entries, len); // <<<=== FEHLERPOSITION
     entries [len-1] := TCellEntry.Create;
     With entries [len-1] do begin
          mainIndex := pMainIndex;
          setWayPoints(pWayPoints);
                             end;
             end;
end;

Die Funktion, in der die Methode addToEntries()aufgerufen wird, und wobei dann der Fehler auftritt:

Delphi-Quellcode:

function TCell.transit(pMainIndex, pStepWidth: Integer): Boolean;
var
   baseList: Array of TCellEntry; // Liste aller Einträge mit Hauptindex = pMainIndex
   targetList: TCellReferenceArray; // Liste aller Zellreferenzen, die als Ziel in Frage kommen
   i, j, k: Integer;
   len: Word;
   targetCell: TCell;
   targetValid: Boolean;
   temp_wayPoints: TIntArray;
begin
result := false; // Bei Abbruch der Funktion an irgendeiner Stelle ist auf jeden Fall (result = false) gegeben
With self do begin
     if Length(entries) > 0 then begin // Falls Einträge in der aktuellen Zelle vorhanden sind...


        For i:=0 to Length(entries)-1 do begin // Basisliste anlegen...
            if entries [i].mainIndex = pMainIndex then begin
               len := Length(baseList);
               inc(len);
               SetLength(baseList, len);
               baseList [len-1] := entries [i];
                                                       end;
                                         end;

        SetLength(targetList, 0);
        targetList := calculatePotentialTargets(self.position, pStepWidth); // Liste potentieller Ziele berechnen...

        // Einträge in den validen Zielen anlegen...
        For i:=0 to Length(baseList)-1 do begin // Für alle Einträge der aktuellen Zelle...
            For j:=0 to Length(targetList)-1 do begin // Für alle Ziele... (von der aktuellen Zelle aus)
                targetCell := getCellByReference(targetList [j], mainCellArray);
                targetValid := true;

                For k:=0 to Length(targetCell.entries)-1 do begin // Für alle Einträge der Zielzelle (falls vorhanden) prüfe ob "wir" den geschrieben haben, d.h. ob wir schonmal da waren...
                    With targetCell.entries [k] do begin
                         if (mainIndex < pMainIndex) and
                            (isPrefix(wayPoints, baseList [i].wayPoints)) then begin
                            targetValid := false;
                            break;
                                                                               end;
                                                   end;
                                                            end;

                if targetValid then begin // Wenn das Ziel nicht invalidiert wurde...
                   temp_wayPoints := baseList [i].getWayPoints;
                   len := Length(temp_wayPoints);
                   inc(len);
                   SetLength(temp_wayPoints, len);
                   temp_wayPoints [len-1] := j;
                   targetCell.addToEntries(pMainIndex+1, temp_wayPoints); // <<<=== FEHLERPOSITION
                   result := true;
                                    end;
                                                end;
                                          end;

                                 end;
             end;
end;

Eine möglicherweise sehr wichtige Information ist diese:
In der Methode TCell.transit() tritt der Fehler bei Aufruf der Methode targetCell.addToEntries() auf (da wo FEHLERPOSITION steht).
Interessant ist, dass der Fehler nicht auftritt, wenn ich das SetLength aus targetCell.addToEntries() vor dem Aufruf von targetCell.addToEntries() quasi "manuell" selber ausführe, in dem ich vorher eine Zeile einfüge, die lautet:
SetLength(targetCell.entries, <Größe>)
In diesem Fall bekomme ich keine Access Violation bei der Veränderung dieses Arrays - passiert die Veränderung jedoch innerhalb der Methode, so erhalte ich eine Violation.
--> nix verstehen

Wenn Ihr noch mehr Code braucht - kein Problem, is ja nicht geheim. Is halt noch ein bisschen was.

Bin gespannt auf Rückfragen oder Ideen...

Viele Grüße
Caps

[Luckie]

Die Formatierung ist jetzt nicht dein Ernst oder?

Delphi-Quellcode:

SetLength(targetList, 0);
targetList := calculatePotentialTargets(self.position, pStepWidth);

Du setzt die Länge des Arrays auf null und weißt ihr dann ein anderes Array zu?

[Caps]

Zitat von Luckie:

Die Formatierung ist jetzt nicht dein Ernst oder?

Doch.

Zitat von Luckie:

Delphi-Quellcode:

SetLength(targetList, 0);
targetList := calculatePotentialTargets(self.position, pStepWidth);

Du setzt die Länge des Arrays auf null und weißt ihr dann ein anderes Array zu?

Ah, könnten dadurch bei jedem Schleifendurchlauf alte "Instanzen" des Arrays übrigbleiben? Ich sollte wahrscheinlich das Array targetList eher als var-Parameter verwenden, gel?

[Luckie]

Dein dynamisches Array ist null Elemente groß und du weiß ihm ein Array mit n Elementen zu? Kann das funktionieren?