#ifndef _OBSERVABLE_H
#define _OBSERVABLE_H
#include <iostream>
#include <list>
#include "Observer.h" //Meine eigene Observer-Klasse

class Observable {
  private:
    list<Observer*> observers;

  public:
    void notify()
    {
      list<Observer*>::iterator iter = observers.begin();
      while(iter != observers.end())
      {
        // Diese Schleife wird beim Aufruf von notify() ununterbrochen durchlaufen,
        // wenn "list<Observer*> observers;" wie oben deklariert ist.
        // Deklariere ich das aber hier:
        //list<Observer*> observers;
        // Dann läuft es. Allerdings habe ich dann immer eine leere Liste,
        // was natürlich keinen Sinn macht.

        std::cout << "Test" << endl;
        iter++;
      }
    }
};
#endif

Warum wird die Liste unendlich oft durchlaufen, wenn ich sie oben unter private deklariere? Ich habe ja nichtmal Methoden, mit dem ich ein Element eingefügt habe.
Ich hoffe, ihr habt einen Tipp für mich.
Dankeschön!
Andy

list<Observer*>::iterator iter = observers.begin();

nicht ein

list<Observer*>::iterator iter = observers->begin();

stehen??Schließlich hast du ja zeiger auf deine Observer Klasse?Fals ich falsch liege berichtig mich bitte.

Falls ich falsch liege berichtig mich bitte.

Das ist schon richtig so, schließlich ist observers selbst kein Zeiger, folgedessen nur ein observers.begin().

Der Fehler muss woanders liegen, hier sind noch alles gut aus.

Firefighter schrieb:

Falls ich falsch liege berichtig mich bitte.

Das ist schon richtig so, schließlich ist observers selbst kein Zeiger, folgedessen nur ein observers.begin().

Der Fehler muss woanders liegen, hier sind noch alles gut aus.

Ahh stimmt...natürlich, da hatte ich nicht aufgepasst. Danke

Aus welchem Namespace kommt die Liste denn? Wo kommt der Namespace her? Hast Du std im Header in den globalen Namespace importiert? Nicht gut!

Ach das habe ich vergessen, dazu zu schreiben:

using namespace std;

habe ich noch vor meiner Klasse stehen...

Die Liste kommt aus std. Ist es gar nicht gut, im Header den Namespace zu importieren?

Ich habe es nochmal probiert, ohne std zu importieren, aber daran liegt es leider auch nicht.

Tachyon schrieb:

Aus welchem Namespace kommt die Liste denn? Wo kommt der Namespace her? Hast Du std im Header in den globalen Namespace importiert? Nicht gut!

Ach das habe ich vergessen, dazu zu schreiben:

using namespace std;

habe ich noch vor meiner Klasse stehen...

Das ist schlecht. Man sollte niemals nicht in einem Header irgendwelche namespaces in den globalen Scope importieren.

sunnyandy schrieb:

Tachyon schrieb:

Aus welchem Namespace kommt die Liste denn? Wo kommt der Namespace her? Hast Du std im Header in den globalen Namespace importiert? Nicht gut!

Ach das habe ich vergessen, dazu zu schreiben:

using namespace std;

habe ich noch vor meiner Klasse stehen...

Das ist schlecht. Man sollte niemals nicht in einem Header irgendwelche namespaces in den globalen Scope importieren.

OK danke für deinen Tipp, leider hat es auch nicht funktioniert.
Ich habe die "observers" eben mal als Pointer deklariert und im Konstruktor ein Objekt erzeugt, nur leider hat das auch nichs gebracht.

Das ist schlecht. Man sollte niemals nicht in einem Header irgendwelche namespaces in den globalen Scope importieren.

Korrekt und zwar weil:
Du hebelst den Nutzen vom Namespace damit aus. Überall wo du den Header inkludierst, wird automatisch der entsprechende Namespace in den globalen Scope übertragen, was zu ungewollten Namenskonflikten führen kann, wovon der namespace ja eigentlich schützen sollte.

Das kann auch sehr ärgerlich für Leute sein, welche deine Bibliotheken nutzen wollen.

Man sollte sowieso so oft wie möglich auf using namespace verzichten. bei langen namespace Namen kann man auch sowas benutzen:

namespace xml = dsi::bliblablub::nochwas::xml;

so erreicht man das lange Ding direkt über den Namespace xml

Zu deinem Problem, zeig mal etwas mehr Code. So viel kann ja nicht passieren in der while-Schleife.

Grüssli

Die Liste muss doch initialisiert worden sein, oder? Ansonsten kann die Test-Ausgabe doch nicht tausendmal auf meinem Monitor ausgegeben werden, richtig?

Zu deinem Problem, zeig mal etwas mehr Code. So viel kann ja nicht passieren in der while-Schleife.

Grüssli

Wenn die Liste leer ist, passiert gar nichts, weil er gar nicht in die Schleife rein gehen sollte.

Tachyon schrieb:

Zu deinem Problem, zeig mal etwas mehr Code. So viel kann ja nicht passieren in der while-Schleife.
Grüssli

Aufgrund des Fehlers habe ich mittlerweile alles auskommentiert. In der while-Schleife passiert nicht mehr.
Irgendwie scheint er die Liste nicht richtig zu erzeugen...

Schmeiss mal das #include "Observer.h" raus und ersetzte es durch struct Observer{}; .

PS: Natürlich nur zum Testen.

Wenn die Liste leer ist, passiert gar nichts, weil er gar nicht in die Schleife rein gehen sollte.

a) Die Liste ist nicht leer. Sonst würde die Endlosschleife nicht starten!
b) Eine Endlosschleife kann dann nur dadurch passieren, dass in der While-Schleife ein Problem ist.
c) Dass die Liste Elemente aufweist, obwohl sie leer sein sollte, ist natürlich noch ein weiteres Problem, auf welches ich aber erst als zweites geschaut hätte

Grüssli

ich benutze den GNU g++

Ich glaube eher, dass er nicht die Liste benutzt, von der er denkt, dass er sie benutzt.

Zeige mal den Code für die int* Liste.

#ifndef _OBSERVABLE_H
#define _OBSERVABLE_H

#include <iostream>
#include <list>

class Observable {

 private:
  std::list<int*> *observers;

 protected:
  Observable()
    {
      observers = new std::list<int*>;
    }

 public:

  void notify(void *obj) {

    std::list<int*>::iterator iter = observers->begin();
    int i = 0;
    while (iter != observers->end()) {      
      std::cout << "OOO_ESTI " << i++ << std::endl;
      iter++;
    }
  }   

};
#endif

Wie legst Du denn Observable-Objekte an, wenn der Ctor protected ist?
Falls Du von dem Ding erbst:
Probier Observable.notify() lieber erstmal direkt in der main aus, ohne über die erbende Klasse zu gehen.

Genau, ich geh momentan über die erbende Klasse. Ich habe die header-Datei in einem einfachen Testprogramm eingebunden und dort hat es eben funktioniert (aus der main aufgerufen, wie du es sagst).

Wenn ich hier die Anzahl der Elemente ausgeben will, kommt das Programm zum Stillstand (das ist merkwürdig, oder?):

while (iter != observers->end()) {      
      std::cout << "OOO_ESTI " << observers->size() << std::endl;
      iter++;
    }

Der Konstruktor der Klasse, die von Observable erbt, sieht so aus:

MapModel::MapModel(): Observable(){

}

Das habe ich doch richtig gemacht, oder?

void MapModel::loadMapFile(char *filename)
{
  ...
  notify(NULL);
}

Wie kann ich denn in C++ explizit eine Methode der Oberklasse aufrufen?
Sowas wie "inherited notify" in Delphi z.B. (Geht das überhaupt aufgrund der Mehrfachvererbung?)

So:

struct Base
{
   void function(){}
};

struct Derived : Base
{
   void function(){}
};

Derived derivedObject;
derivedObject.Base::function();