Access Violation durch Length(Array)?

[Jumpy]

Den Fehler gefunden. Eine Callback-Funktion gibt immer den Handle des Calls weiter an eine Funktion, die den Callback Verarbeitet. Aus dem Handle wird der Handle der Line bestimmt, auf der der Call läuft und aus dem Linehandle wird der Index der Line im Array priv_Lines bestimmt.

Aber nun: Bei einer bestimmten Callback-Nahricht wird nicht der Handle des Calls, sondern der einer Line zurückgegeben. Die Funktion, die aus dem Call-Handle einen Line-Handle sucht wird daher natürlich nicht fündig und liefert 0 zurück.

Die Funktion, die aus dem LineHandle nun den Index sucht findet damit natürlich auch nix und liefert -1 zurück.

Dann wird auf priv_Lines[-1].CallCount zugegriffen (weil bisher der Test Index>=0 fehlt) und da knallt es. Keine Ahnung warum es da innerhalb der CallCount knallt und nicht in der Funktion in der die Zeile priv_Lines[-1].CallCount steht und wo doch ein Idndex out of Bounds oder so gemeldet werden müsste?

[himitsu]

Zitat:

Zitat von Jumpy (Beitrag 1193535)

Keine Ahnung warum es da innerhalb der CallCount knallt und nicht in der Funktion in der die Zeile

Das kommt eben immer drauf an, wie und auf was man zugreift.

Bei einem Array kann man locker vor den Ersten oder hinter den letzten eintrag zugreifen.
es kommt nur drauf an, was für einen Typ die Felder haben (Integer ist unproblematischer als z.B. String) und ob an der Stelle zufällig etwas anderes im Speicher liegt, so daß keine Zugriffsverletzung auftritt.

Bezüglich der Arrays kann man das ganz leicht prüfen lassen, indem man z.B. die Bereichsprüfung in den Projektoptionen aktiviert.

[Bjoerk]

Statt des Arrays würde ich eine TList verwenden.

[Jumpy]

Wenn ich schon Generics könnte würd ich das machen, aber ohne ist mir die ganze is/as-Casterei zu lästig (müsste bei meiner momentanen Coderenovierung zuviel anpacken).

[Bjoerk]

Zitat:

Zitat von Jumpy (Beitrag 1193607)

[..] aber ohne ist mir die ganze is/as-Casterei zu lästig (müsste bei meiner momentanen Coderenovierung zuviel anpacken).

Du meinst TObjectList? Bei einer TList ist das so nicht erforderlich. Ich hab' mal auf die Schnelle was zusammen gezimmert. Ich will Dir das nicht aufzuschwatzen, aber das sollte doch in deine App mit vergleichsweise wenig Aufwand einzubauen sein? Der Vorteil wäre eine saubere Speicherverwaltung und die leichte Handhabbarkeit. Satt des Array's halt eine Instanz der Klasse verwenden.

Delphi-Quellcode:

unit uCallItems;

interface

uses
  Classes, TTAPICallunits;

type
  TCallItem = class
  private
    FCall: TTApiCall;
    FHandle: Cardinal;
  public
    property Call: TTApiCall read FCall;
    property Handle: Cardinal read FHandle;
    constructor Create(const AHandle: Cardinal);
    destructor Destroy; override;
  end;

  TCallItems = class(TList)
  private
    function GetItem(Index: integer): TCallItem;
    procedure AddItem(const AItem: TCallItem);
    procedure DelItem(Index: integer);
  public
    procedure AddCall(const AHandle: Cardinal);
    procedure DelCall(const AHandle: Cardinal);
    function IndexOfHandle(const AHandle: Cardinal): integer;
    destructor Destroy; override;
    property CallItems[Index: integer]: TCallItem read GetItem; default;
  end;

implementation

constructor TCallItem.Create(const AHandle: Cardinal);
begin
  inherited Create;
  FHandle := AHandle;
  FCall := TTApiCall.Create(FHandle);
end;

destructor TCallItem.Destroy;
begin
  FCall.Free;
  inherited Destroy;
end;

destructor TCallItems.Destroy;
begin
  while Count > 0 do
    DelItem(Count - 1);
  inherited Destroy;
end;

function TCallItems.GetItem(Index: integer): TCallItem;
var
  PItem: ^TCallItem;
begin
  PItem := Items[Index];
  Result := PItem^;
end;

procedure TCallItems.AddItem(const AItem: TCallItem);
var
  PItem: ^TCallItem;
begin
  New(PItem);
  PItem^ := AItem;
  Add(PItem);
end;

procedure TCallItems.DelItem(Index: integer);
var
  PItem: ^TCallItem;
begin
  PItem := Items[Index];
  PItem^.Free;
  Dispose(PItem);
  Delete(Index);
end;

function TCallItems.IndexOfHandle(const AHandle: Cardinal): integer;
var
  PItem: ^TCallItem;
  I: integer;
begin
  Result := -1;
  for I := 0 to Count - 1 do
  begin
    PItem := Items[I];
    if PItem^.Handle = AHandle then
      Result := I;
  end;
end;

procedure TCallItems.DelCall(const AHandle: Cardinal);
var
  Index: Integer;
begin
  Index := IndexOfHandle(AHandle);
  if Index > -1 then
    DelItem(Index);
end;

procedure TCallItems.AddCall(const AHandle: Cardinal);
var
  Item: TCallItem;
begin
  If IndexOfHandle(AHandle) = -1 then
  begin
    Item := TCallItem.Create(AHandle);
    AddItem(Item);
  end;
end;

end.

[Jumpy]

Danke für die Mühe, das sieht tatsächlich so aus, als könnte ich das für meine Zwecke mit nur wenig Anpassung brauchen. Der Trick, auf den ich so nicht gekommen wäre, scheint zu sein, eine eigene Liste als Nachfahre von TList zu bauen und darin die casterei zu verstecken bzw. in deiner Version Pointerrei?
Ich hab normal kein Problem eigene Klassen zu erstellen, mit Vererbung oder Benutzung von anderen Klassenbeziehung. Aber irgendwie nehm ich immer die VCL als gegeben hin und komm nie drauf, das man da ja auch was Ableiten könnte oder das man mal eigene Komponenten machen könnte. Das höchste was ich da mal gemacht hab ist ein TMyFrame von dem dann andere Frames geerbt haben, so dass ich mir eine dynamische GUI bauen konnte.
Ich muss da mal die entsprechende Blockade im Kopf aufbohren und kreativer denken :coder:

[Bjoerk]

Fein. :)

Noch schöner wär’s hier, wenn man aus AddCall / DelCall functions vom Typ boolean macht, dann kann man von außen ausführen:

Delphi-Quellcode:

if not FCallItems.AddCall(AHandle) then
  ShowMessage('Call konnte nicht hinzugefügt werden.');

Gruß
Thomas

[DeddyH]

Könnte man dann nicht von TObjectList statt TList ableiten? Das wäre doch noch bequemer.

[Bjoerk]

Und für noch Bequemere :)

http://www.delphi-treff.de/tutorials...ist/sonstiges/

Oft ist TItem aber vom Typ Record, da kommt man mit einer TObjectList nicht besonders weit...