Pfeiloperator

xkris

Hallo Zusammen,

ich bin hier langsam am verzweifeln. Habe folgendes Problem:

Im Initialisierungsteil einer Klasse erzeuge ich einen Pointer *file auf ein Objekt einer selbstdefinierten Klasse "Data".
Im Konstruktor erzeuge ich ein Objekt dieser Klasse und weise anschliessend dem zuvor definiertem Pointer die Adresse dieses Objektes zu.

class SPR
{
    private:
        Goniometer G;
        Data *file ;
        KUSB3100 *sensor;

  public:
  SPR(string comment, string date,char *filename)
  {
      bool s_flag=true; //error-flag für Sensor-Objekt

      G.init();
      Data P(comment,date,filename);
      file=&P;
      KUSB3100 S(&s_flag);
      S.init(0);
      sensor=&S;  
  }
  ...

Wenn ich jetzt mittel Pfeiloperator auf eine der Methoden der Klasse Data zugreien möchte, schmiert das Programm ab.

file->write(line,0,k);

Compilieren kann ich es problemlos. Das schaut für mich so aus, als würde ich versuchen , auf nicht definierte Speicherbereiche zuzugreifen aber ich weiss nicht wo mein Fehler liegt.

Vielleicht weiß ja von euch jemand Rat

Ich sag mal vielen Dank im Voraus

Grüße

Kristian

MAG

Du erzeugst im Konstruktor eine lokale Variable, welche nach dem Verlassen der Methode nicht mehr existiert! Daher ist der Zeiger file ungültig und dementsprechend kommt es zum Absturz.

Richtigerweise würdest du es folgender Maßen machen:

SPR(string comment, string date,char *filename)
  {
      bool s_flag=true; //error-flag für Sensor-Objekt

      G.init();

      //: falsch!
      //Data P(comment,date,filename);
      //file=&P;

      //: richtig
      file = new Data(comment,date,filename);

      // ...
  }

Gleiches gilt wahrscheinlich auch für den Zeiger sensor!

*D*Evil

Hmm ... p ist außerhalb des Konstruktors nicht mehr vorhanden ... somit zeigt file ins nichts! Das selbe gilt für S!

class SPR
{
private:
    Goniometer m_gonio;
    Data  m_file;
    KUSB3100 m_sensor;

public:
    SPR(const std::string& comment, const std::string& date, const char *filename) : m_file(comment, data, filename), m_sensor(0)
    {
        m_gonio.init();
        m_sensor.init();
    }
};

oder

class SPR
{
private:
    Goniometer m_gonio;
    Data* m_file ;
    KUSB3100* m_sensor;

public:
    SPR(const std::string& comment, const std::string& date, const char* filename)
    {
        bool s_flag=true; //error-flag für Sensor-Objekt
        m_gonio.init();
        m_file = new Data(comment, date, filename);
        m_sensor = new KUSB3100(&s_flag);
        m_sensor->init(0);
    }
    SPR()
    {
        delete m_file;
        delete m_sensor;
    }
};

...

xkris

Hey, das ging ja fix.
Danke für die schnelle Hilfe.
Was wäre eigentlich wenn ich P als static definiere? Dann müsste es ja an seinem speicherplatz verbleiben und somit müsste der Zeiger "file" noch darauf zeigen, auch nach verlassen der Methode.

LordJaxom

Ja, das stimmt. Und darüberhinaus hättest Du die Möglichkeit verspielt jemals mehr als ein SPR-Objekt parallel agieren zu lassen, da ja alle auf dieselbe static Variable zugreifen

Warum machst Du m_file nicht einfach zum Mitglied ohne Zeiger, wie in (D)Evils erstem Beispiel.

xkris

LordJaxom schrieb:

Ja, das stimmt. Und darüberhinaus hättest Du die Möglichkeit verspielt jemals mehr als ein SPR-Objekt parallel agieren zu lassen, da ja alle auf dieselbe static Variable zugreifen

Warum machst Du m_file nicht einfach zum Mitglied ohne Zeiger, wie in (D)Evils erstem Beispiel.

"...da ja alle auf dieselbe static Variable zugreifen" alle was?

Ausserdem , wenn das nicht ginge, würde das nicht auch bedeuten, dass man nach

static int ...

auch keine weitere integer Variable mehr deklarieren könnte?

So wie ich die Definition von static verstehe, bedeutet das doch nur, dass diese Speicherstelle für immer und ewig (so lange das Programm läuft) für diese Variable zur Verfügung steht. Wenn ich jetzt eine neue Variable Deklariere, sei es ein int, double oder ein Objekt einer Klasse, warum sollte die nicht einen eigenen Speicherbereich zugewiesen bekommen?