EAccesViolation mit Borland C++ builder 6

Pik-9 · 29. März 2009

Hallo erstmal,

ich schreibe gerade ein Programm in C++ mit dem Borland C++ Builder 6.
Dabei bin ich auf ein Problem gestoßen, dass ich so nicht verstehe! Und zwar habe ich in etwa folgenden Code:

Code:

class A_Class
{
private:
  bool My_Bool;
public:
  void Set_My_Bool (bool ABC)
  {
    My_Bool=ABC;
  }
};

class B_Class
{
private:
  A_Class *My_A_Class;
public:
  void Set_A_Bool (bool DEF)
  {
    //Der Konstruktor wurde schon aufgerufen. Daran liegt es also nicht!
    My_A_Class->Set_My_Bool(DEF);
  }
};

//----------------------------------------------------------------------------------------------

int main ()
{
  B_Class *My_B_Class;
  //Der Konstruktor von B_Class wird aufgerufen. Dies schreibe ich aber nicht.

  bool GHI;
  My_B_Class->Set_A_Bool(GHI);
}

Der Compiler erkennt das problemlos an, der Linker auch, nur während der Laufzeit tritt eine Exception auf!
Ich habe das mal mit dem Debugger überprüft, alle Klassen sind korrekt initialisiert und die Variablen sind auch ok. Aber aus i-einem Grund kann die Funktion A_Class::Set_My_Bool(bool) nicht auf My_Bool zugreifen, denn da tritt die Exception auf.

Ich bin kein besonders versierter Programmierer, also bitte nicht böse sein, wenn das ein ganz doofer Fehler ist, es wäre aber trotzdem nett, wenn ihr mir helfen könntet!

sheel · 29. März 2009

Ist das der Originalcode oder ein kleines Testbeispiel?
Wo zeigen denn deine ganzen Pointer hin und wo ist irgendein Konstruktor?

Matthias Reitinger · 29. März 2009

Hallo Pik-9,

sollen die Kommentare bedeuten, dass du an diesen Stellen Quellcode weggelassen hast? Wenn ja, dann poste doch bitte den vollständigen Quellcode. Wenn nicht, dann hast du die Zeiger nirgends initialisiert (A_Class *B_Class::My_A_Class und B_Class *My_B_Class in main).

Grüße, Matthias

Pik-9 · 29. März 2009

Ja, das war nur ein kleines Testbeispiel.
Ich werde mal den richtigen Code posten:

Die Headerdatei:

Code:

#ifndef Unit2H
#define Unit2H
#include <vcl.h>
#include <string>
#include <CheckLst.hpp>
#include <ExtCtrls.hpp>

//#include "Unit2.cpp"
//---------------------------------------------------------------------------
#endif

class TGleichung
{
private:
  double a, b, c;
  TColor Farbe;
  bool Aktiv;
public:
  TGleichung (char*);
  TGleichung (double, double, double, TColor);
  TGleichung (TGleichung&);

  void Set_activity (bool);
  bool Get_activity ();

  double Get_Y (double);
  double Get_a ();
  double Get_b ();
  double Get_c ();
  TColor Get_Color ();

  AnsiString Get_Name ();
  char* Get_FileText ();

  ~TGleichung ();
};

class TSammlung
{
private:
  TGleichung* Funktion[500];
  int Funk_size;
  TCanvas* Tafel;
public:
  TSammlung (TCanvas*);
  TSammlung (TCanvas*, char*);

  void Neue_Funktion (double, double, double, TColor);
  void Del_Funktion (int);
  void Change_Funktion (int, double, double, double, TColor);
  void active_Funktion (int, bool);

  int Gueltige_Funktionen ();

  void Fill_table (TStringGrid*, double, double, double);
  void Fill_list (TCheckListBox*);
  void Fill_Captions (TLabeledEdit*, TLabeledEdit*, TLabeledEdit*, TPanel*, int);
  void Zeichnen (int, int, double, double, double, double, double, double, TColor, TColor);

  void Schreibe_Datei (char*);
  ~TSammlung ();
};

und die cpp-Datei:

Code:

#pragma hdrstop

#include "Unit2.h"
#include <vcl.h>
#include <math.h>
#include <iostream>
#include <fstream>

//---------------------------------------------------------------------------

#pragma package(smart_init)

TGleichung::TGleichung (char* Text)
{
  AnsiString H = AnsiString(Text);
  AnsiString Ha, Hb, Hc, Hf;

  for (int i=1; i<=H.Length(); ++i)
  {
    int A = 0;

    if (H[i]==';')
      ++A;
    else
    {
      switch (A)
      {
        case 0: Ha=(Ha+H[i]);
          break;
        case 1: Hb=(Hb+H[i]);
          break;
        case 2: Hc=(Hc+H[i]);
          break;
        case 3: Hf=(Hf+H[i]);
          break;
      }
    }
  }

  try
  {
    a=Ha.ToDouble();
    b=Hb.ToDouble();
    c=Hc.ToDouble();
    Farbe=Hf.ToInt();
    Aktiv=true;
  }
  catch (...)
  {
    a=0;
    b=0;
    c=0;
    Farbe=clBlack;
  }
}

TGleichung::TGleichung (double Va, double Vb, double Vc, TColor L_Farbe)
{
  a=Va;
  b=Vb;
  c=Vc;
  Farbe=L_Farbe;
  Aktiv=true;
}

TGleichung::TGleichung (TGleichung& G)
  : a(G.a), b(G.b), c(G.c), Farbe(G.Farbe), Aktiv(G.Aktiv)
{
}

void TGleichung::Set_activity (bool A)
{
  Aktiv=A;
}

bool TGleichung::Get_activity ()
{
  return Aktiv;
}

double TGleichung::Get_Y (double X)
{
  return (a*(X+b)+c);
}

double TGleichung::Get_a ()
{
  return a;
}

double TGleichung::Get_b ()
{
  return b;
}

double TGleichung::Get_c ()
{
  return c;
}

TColor TGleichung::Get_Color ()
{
  return Farbe;
}

AnsiString TGleichung::Get_Name ()
{
  AnsiString H = AnsiString(a)+" * (X+"+AnsiString(b)+") + "+AnsiString(c);
  return H;
}

char* TGleichung::Get_FileText ()
{
  AnsiString H = AnsiString(a)+";"+AnsiString(b)+";"+AnsiString(c)+";"+AnsiString(Farbe);
  return H.c_str();
}

TGleichung::~TGleichung ()
{
}

TSammlung::TSammlung (TCanvas* Board)
{
  Tafel=Board;
  Funk_size=0;
}

TSammlung::TSammlung (TCanvas* Board, char* Pfad)
{
  Tafel=Board;
  std::fstream Datei;
  Datei.open(Pfad, std::ios::in);
  Funk_size=0;
  while (Datei.eof()==false)
  {
    char S [256];
    char *HS = &S[0];
    Datei.getline(S, 256);
    ++Funk_size;
    Funktion[Funk_size]=&TGleichung::TGleichung(HS);
  }
  Datei.close();
}

void TSammlung::Neue_Funktion (double a, double b, double c, TColor Farbe)
{
  Funktion[Funk_size]=&TGleichung::TGleichung(a, b, c, Farbe);
  ++Funk_size;
}

void TSammlung::Del_Funktion (int Index)
{
  if (Index==Funk_size)
  {
    Funktion[Index]->~TGleichung();
    --Funk_size;
  }

  if ((Index<(Funk_size-1)) && (Index>=0))
  {
    for (int i=Index; i<(Funk_size-1); ++i)
    {
      Funktion[i]->~TGleichung();
      Funktion[i]=&TGleichung::TGleichung(*Funktion[(Index+1)]);
    }

    Funktion[Funk_size]->~TGleichung();
    --Funk_size;
  }
}

void TSammlung::Change_Funktion (int Index, double Neu_a, double Neu_b, double Neu_c, TColor Neu_Farbe)
{
  if ((Index<Funk_size) && (Index>=0))
  {
    Funktion[Index]->~TGleichung();
    Funktion[Index]=&TGleichung::TGleichung(Neu_a, Neu_b, Neu_c, Neu_Farbe);
  }
}

void TSammlung::active_Funktion (int Index, bool Aktivitaet)
{
  if ((Index<Funk_size) && (Index>=0))
  {
    Funktion[Index]->Set_activity(Aktivitaet);
  }
}

int TSammlung::Gueltige_Funktionen ()
{
  int h = 0;
  for (int i=0; i<Funk_size; ++i)
  {
    if (Funktion[i]->Get_activity()==true)
    {
      ++h;
    }
  }

  return h;
}

void TSammlung::Fill_table (TStringGrid* Tisch, double Min_X, double Max_X, double X_Ab)
{
  int AF = floor((Max_X-Min_X)/X_Ab);
  Tisch->RowCount=(AF+1);
  Tisch->ColCount=(Gueltige_Funktionen()+1);
  Tisch->Cells[0][0]="X | Y";

  int GF[500];
  int HH = 0;
  for (int i=0; i<Funk_size; ++i)
  {
    if (Funktion[i]->Get_activity()==true)
    {
      GF[HH]=i;
      ++HH;
    }
  }

  for (int i=0; i<AF; ++i)
  {
    double HX = ((i+Min_X)*X_Ab);
    Tisch->Cells[(i+1)][0]="X="+AnsiString(HX);

    for (int a=0; a<Gueltige_Funktionen(); ++a)
    {
      double E = Funktion[GF[a]]->Get_Y(HX);
      Tisch->Cells[i][(a+1)]=AnsiString(E);
      Tisch->Cells[0][(a+1)]="Y"+AnsiString(GF[a])+"=";
    }
  }
}

void TSammlung::Fill_list (TCheckListBox* Liste)
{
  Liste->Clear();
  for (int i=0; i<Funk_size; ++i)
  {
    Liste->Items->Add(Funktion[i]->Get_Name());
    Liste->Checked[i]=Funktion[i]->Get_activity();
  }
}

void TSammlung::Zeichnen (int C_Breite, int C_Hoehe, double min_X, double min_Y, double max_X, double max_Y, double Ab_X, double Ab_Y, TColor VG, TColor HG)
{
  TKSystem *H = &TKSystem::TKSystem(Tafel, VG, HG, C_Breite, C_Hoehe, max_X, min_X, min_Y, max_Y, Ab_X, Ab_Y);
  H->Zeichnen();
  for (int i=0; i<Funk_size; ++i)
  {
    if (Funktion[i]->Get_activity()==true)
    {
      double HX = min_X;
      while (HX<=max_X)
      {
        double HHX = (HX+Ab_X);
        H->Linie_Zeichnen(HX, Funktion[i]->Get_Y(HX), HHX, Funktion[i]->Get_Y(HHX), Funktion[i]->Get_Color());
        HX=HHX;
      }
    }
  }

  H->~TKSystem();
}

void TSammlung::Fill_Captions (TLabeledEdit* a_Label, TLabeledEdit* b_Label, TLabeledEdit* c_Label, TPanel* Color_Panel, int Nummer)
{
  if (Nummer<Funk_size)
  {
    a_Label->Text=AnsiString(Funktion[Nummer]->Get_a());
    b_Label->Text=AnsiString(Funktion[Nummer]->Get_b());
    c_Label->Text=AnsiString(Funktion[Nummer]->Get_c());
    Color_Panel->Color=Funktion[Nummer]->Get_Color();
  }
}

void TSammlung::Schreibe_Datei (char* Pfad)
{
  std::fstream Datei;
  Datei.open(Pfad, std::ios::out);
  for (int i=0; i<Funk_size; ++i)
  {
    Datei << Funktion[i]->Get_FileText() << std::endl;
  }
  Datei.close();
}

TSammlung::~TSammlung ()
{
  for (int i=0; i<Funk_size; ++i)
  {
    Funktion[i]->~TGleichung();
  }
}

EAccesViolation mit Borland C++ builder 6

Pik-9

Grünschnabel

sheel

I love Asm

Matthias Reitinger

ɐɯıǝɹ

Pik-9

Grünschnabel

Neue Beiträge