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

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!

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;
    }
};

...

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

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?