3. operator() const, mit einem iterator

operator() const, mit einem iterator

  • E
     

    void Model::addLoop(Loop& l) //Hier verlangst du eine Referenz durch denn Operator &
{
    loopList_.push_back(l); //Die Referenz wird nun in die Liste eingefügt 
}

    Ich denke mal du hast (&l) geschrieben weil du denkst dass das eine Refernz daraus macht?

    Deine Referenz ist am ende nur eine Kopie der Klasse, diese Kopie wird am ende der eigentlichen Klasse zurück gegeben.

    Der einzige Weg die Klasse selbst zu nutzen ist:

    void Model::addLoop(const Loop& l){
    loopList_.push_back(l); 
}

    Aber dann kann die Klasse auch nicht verändert werden.

    0
  • K

    ok, soweit kann ich dir folgen.
    Aber brauch ich dann das:

    std::list<Loop> loopList_;

    oder

    std::list<Loop&> loopList_;

    (Ich weiss, das sind wirklich beschaemend dumme Fragen.)
    Danke

    0

  • Ich wollte aber in loopList_ keine objects sondern nur references haben

    Weshalb? Kopieroptimierung?

    Es wäre unintuitiv (=falsch?) wenn man Referenzen an eine Funktion übergibt und diese nach ihrer Beendigung immernoch Seiteneffekte auf das Objekt hat.

    Speichere die Objekte (bzw Kopien) besser in dem Vektor in der Klasse, wie exploit126 vorgeschlagen hat.

    EDIT:
    - Wenn es wirklich verweise auf die alten Objekte sein sollen (/müssen!), dann Zeiger als Funktionsparameter nehmen.
    - Wenn du NICHT garantieren kannst, dass die Objekte deine Klasse komplett überleben, dann brauchst du shared ownership (shared_ptr)

    Aber! Wenn beides letzteres der Fall ist, dann kannst du bestimmt was an deiner Programmstruktur verbessern.

    0
  • K

    Nein, Kopieroptimierung ist mit erstmal egal.

    Aber ich will, dass "setM" in Zeile 20 von model.cpp auf dem
    uebergebenen Loop-object arbeitet, und nicht auf einer Kopie.

    geht das?

    0

  • ich denke, dass in diesem Fall der shared_ptr ist was du willst, aber dann verpasst du deinen Loops die Eigenschaften von globalen Variablen. Jeder der ein Besitz von ihnen hat kann sie verändern.
    EDIT: Das ist schwer zu debuggen und führt normalerweise eher zu Kopfschmerzen.

    EDIT 2: Die Frage ist, wo du deine loops speichern willst.
    Momentan fügst du Zeiger auf lokale Objekte hinzu, die zerstört werden bevor du was mit ihnen machst.

    Deshalb läufst du in dein Problem.

    0
  • K

    Ich will eigentlich nur eine Liste der "Loop"s, die es im "Model" afk gibt.
    Also Loop l1, und Loop l2 in einer Liste &l1, &l2.

    Ueber diese Liste will ich dann mit einem iterator in Model::operator()
    iterieren. Dabei muss ich aber jede Loop mit "setM" veraendern. Ich kann also
    nicht mit kopierten objects in loopList_ arbeiten.

    Kann man die Erklaerung verstehen?

    Oder anders:
    eine Loop ist eine Gleichung deren x-Wert mit "setM" gesetzt wird, und deren y-Wert mit "getDP" ausgelesen wird.
    Und der operator() wird dann vom solver in Eigen immer wieder mit veraenderten x-Werten aufgerufen, bis die y-Werte alle Loops 0 werden.

    0

  • Ok gut, dann schlage ich sowas vor:

    class Model {
 //... gekürzt auf meine Änderungen
public:
    void addLoop(Loop const& l);
private:
    std::vector <Loop> loopList_; // es sei denn du hast einen guten Grund für die Liste (z.B. vieles entfernen und hinzufügen in der Mitte des Containers)
};

// ...

int Model::operator()(const VectorXd &x, VectorXd &fvec) /*EDIT: nicht const*/ {
    // ...
    // mit C++11
    for (auto& it : loopList_) {
        it.setM(x[i]);
    }
    // mit C++98
    for (std::vector <Loop>::iterator it = loopList_.begin(); it != loopList_.end(); ++it) {
        it->setM(x[i]);
    }
    //...
}

void Model::addLoop(Loop const& l) {
    loopList_.push_back(l);
}

    nun kannst du Loops in das Model hinzufügen und mehrmals den Funktionsoperator aufrufen und jedes Mal werden die Loops, die in deinem Model gespeichert sind, geändert.

    EDIT: habe deinen integer i vergessen. Deshalb habe ich oben nochmal die Namen korrigiert.

    0
  • K

    wow, da lieferst du mir ja die ganze Loesung.
    Super!
    Lass mich das ausprobieren.

    0
  • K

    Jetzt bekomme ich (mit der c++11 variante) beim compilieren:
    passing 'const Loop' as 'this' Argument of 'void Loop::setM(float)' discards qualifier [-fpermissive]

    0

  • Ja ich sehe gerade, dein Funktionsoperator ist const.

    Dann kann er natürlich keine Member der Klasse verändern.
    Ich hatte das dummerweise mitkopiert.

    0
  • K

    sieht gut aus!
    Ich glaube damit ist dieses Problem geloest.
    Was aber leider unweigerlich eine anderen Fehler offenlegt... 😞
    Da muss ich jetzt ran.
    vielen Dank jedenfalls fuer deine Ausdauer!
    kwurpi

    0
Anmelden zum Antworten