Access Violation und kein Ende in Sicht

[SirThornberry]

es muss so aussehen:

Delphi-Quellcode:

//declaration
public 
  variable: KlassenTyp;
[...]
variable := KlassenTyp.ConstructorAufruf(eventuelleParameter);

Oben bei der Declaration haben Funktionsaufrufe und Constructoraufrufe nichts zu suchen. Diese musst du unten im Teil wo der Quelltext plaziert wird plazieren.

[grenzgaenger]

hab dir mal zwei fehler im constructor und destructor korrigiert:

Delphi-Quellcode:

UNIT mBruch;

INTERFACE

USES Math;

TYPE
  TBruch = CLASS
  strict private
    zZaehler: integer;
    zNenner:  integer;

  protected

  public
    CONSTRUCTOR init;
    PROCEDURE setzeZaehler(pZaehler: integer);
    PROCEDURE setzeNenner(pNenner: integer);
    FUNCTION gibZaehler: integer;
    FUNCTION gibNenner: integer;
    FUNCTION gibDezimalzahl: extended;
    FUNCTION ggt(zZaehler, zNenner: integer): integer;
    PROCEDURE ErweitereUm(pFaktor: integer);
    PROCEDURE KuerzeUm(pFaktor: integer);
    PROCEDURE KuerzeVoll;
    //procedure KehreUm ;
    DESTRUCTOR gibFrei;
  published

  END;

IMPLEMENTATION

{Bruch}

CONSTRUCTOR TBruch.init;
BEGIN
  inherited create; //nicht vergessen
  zZaehler := 0;
  zNenner  := 1;
END;

PROCEDURE TBruch.setzeZaehler(pZaehler: integer);
BEGIN
  IF zNenner <> 0 THEN
  BEGIN
    zZaehler := pZaehler;
  END;
END;

PROCEDURE TBruch.setzeNenner(pNenner: integer);
BEGIN
  IF zZaehler <> 0 THEN
  BEGIN
    zNenner := pNenner;
  END;
END;

FUNCTION TBruch.gibZaehler;
BEGIN
  Result := zZaehler;
END;

FUNCTION TBruch.gibNenner;
BEGIN
  Result := zNenner;
END;

FUNCTION TBruch.GibDezimalzahl;
BEGIN
  Result := zZaehler / zNenner;
END;

PROCEDURE TBruch.ErweitereUm(pFaktor: integer);
BEGIN
  IF pFaktor <> 0 THEN
  BEGIN
    zZaehler := zZaehler * pFaktor;
    zNenner  := zNenner * pFaktor;
  END;
END;

PROCEDURE TBruch.KuerzeUm(pFaktor: integer);
BEGIN
  IF (zZaehler mod pFaktor = 0) and (zNenner mod pFaktor = 0) THEN
    zZaehler := zZaehler div pFaktor;
  zNenner := zNenner div pFaktor;
END;

FUNCTION TBruch.ggt(zZaehler, zNenner: integer): integer;
BEGIN
  IF zZaehler = zNenner THEN
    Result := zZaehler
  ELSE
    Result := ggt(min(zNenner, zZaehler), abs(zZaehler - zNenner));
END;

PROCEDURE TBruch.KuerzeVoll;
BEGIN
  self.KuerzeUm(ggT(zZaehler, zNenner));
END;

DESTRUCTOR TBruch.gibFrei;
BEGIN
  free;  //nicht vergessen
END;


END.

du solltest nicht vergessen die gerbten methoden für die initalisierung und freigabe aufzurufen, sonst wirst noch experte mit dem debugger ;-) . rekursionen habt ihr ja schon integriert.

ausserdem, sollten klassen resp. typen mit "T" beginnen, damit man weiss was man anfasst.

[HackZu]

Zitat:

Zitat von grenzgaenger

hab dir mal zwei fehler im constructor und destructor korrigiert:
[...]

du solltest nicht vergessen die gerbten methoden für die initalisierung und freigabe aufzurufen, sonst wirst noch experte mit dem debugger ;-) . rekursionen habt ihr ja schon integriert.

ausserdem, sollten klassen resp. typen mit "T" beginnen, damit man weiss was man anfasst.

Danke sehr, das Problem ist, dass wir strikt die Vorgaben umsetzen müssen, die die Lehrerin uns gibt. Werde es mal als Verbesserungsvorschlag einbringen. :)

[SirThornberry]

bitte erstelle für eine neue Frage ein neues Thema damit es hier nicht ein reisen Durcheinander wird wenn sich jemand zur ursprünglichen Frage äußert dann wieder jemand zur nächsten etc. Zudem passt dann der Titel zum Beitrag und man findet das Thema auch besser über die Suche :-)

[HackZu]

Zitat:

Zitat von SirThornberry

bitte erstelle für eine neue Frage ein neues Thema damit es hier nicht ein reisen Durcheinander wird wenn sich jemand zur ursprünglichen Frage äußert dann wieder jemand zur nächsten etc. Zudem passt dann der Titel zum Beitrag und man findet das Thema auch besser über die Suche :-)

Okay, kein Problem, kannst du den Beitrag dann löschen, nachdem ich das neue Thema erstellt habe?

[grenzgaenger]

das hat nix mit benennung zu tun, sondern, da du über die deklaration

Delphi-Quellcode:

type xy = class (...)

von einer bestehenden klasse ableitest. das heisst, damit diese ordungsgemäss funktionieren sollte auch immer die geerbte methode ausgeführt werden. i.a.r. mit inherited. da du jedoch andere bezeichnungen verwendetst für den constructor/desctructor geht das über das schlüsselwort nicht mehr...

[SirThornberry]

Das hier funktioniert zwar ist aber nicht ganz richtig:

Delphi-Quellcode:

DESTRUCTOR TBruch.gibFrei; 
BEGIN 
  free;  //nicht vergessen 
END;

besser so:

Delphi-Quellcode:

DESTRUCTOR TBruch.gibFrei; 
BEGIN 
  inherited Destroy();
END;

[mkinzler]

Und verwende besser den Standart-Destruktor Destroy

[Blup]

Der Destructor "Destroy" ist virtuell.
Objekte werden über den Aufruf von "Free" freigegeben.
"Free" ruft intern den Destructor "Destroy" auf.
Deshalb sollten Klassen die einen eigenen Destructor benötigen, immer "Destroy" mit override überschreiben.

Hab noch einen Fehler gefunden:

Delphi-Quellcode:

procedure TTestBruchrechner.BAdditionClick(Sender: TObject); 
begin 
  self.setzeEingabe; 
  hatBruchrechner.Addition(hatBruch1, hatBruch2); 
  LZaehlerErgebnis.Caption:=IntToStr(hatErgebnisbruch.gibZaehler); 
  LNennerErgebnis.Caption:=IntToStr(hatErgebnisbruch.gibNenner); 
end;

richtiger z.B. so:

Delphi-Quellcode:

procedure TTestBruchrechner.BAdditionClick(Sender: TObject); 
begin 
  setzeEingabe; 
  {der alte hatErgebnisbruch wird freigegeben}
  hatErgebnisbruch.Free;
  {eine neue Instanz von Bruch wird erzeugt und hatErgebnisbruch zugewiesen}
  hatErgebnisbruch := hatBruchrechner.Addition(hatBruch1, hatBruch2); 
  LZaehlerErgebnis.Caption:=IntToStr(hatErgebnisbruch.gibZaehler); 
  LNennerErgebnis.Caption:=IntToStr(hatErgebnisbruch.gibNenner); 
end;

[HackZu]

Danke, habe es mal geändert, funktioniert einwandfrei.