Problem mit Pointer //Lösung gefunden



  • Hi,

    ich habe hier eine struct die einen Pointer speichert.
    Diese sieht so aus

    struct function_object
    {
    	funktion fct;
    	ploting_range range;
    	MyQTreeWidgetItem *parentItem;
    };
    

    Eine Referenz dieser struct übergebe ich in eine Funktion und weiße dort dem Pointer "parentItem" einen Wert zu.

    function_object &f // wird als Funktionsargument übergeben
    //Hier hat der pointer noch den Wert Null
    
    // main_item wird erstellt
    MyQTreeWidgetItem *main_item = new MyQTreeWidgetItem();
    
    f.parentItem = main_item; // zuweißung
    

    Die Instanz von der struct wird während des gesamten Zeitraums in einem std::vector gespeichert.

    Das Problem ist, wenn ich jetzt wieder auf das parentItem zugreifen will, um es zu vergleichen, ist es undefiniert. Quasi geht es verloren.

    Was mache ich falsch, bzw. wo habe ich den falschen Ansatz?



  • Definiere "zugreifen will", "um zu vergleichen", "ist undefiniert ".

    Kurz: Code!



  • Zugriff über einen Funktor der nach dem Element im Vektor sucht

    Funktor:

    struct find_item {
    
        MyQTreeWidgetItem* parent;
        find_item(MyQTreeWidgetItem* i) :parent(i){}
    
    	bool operator==(const function_object &f) {
    		if (parent == f.parentItem) {
    			return true;
    		}
    		return false;
    	}
    
    	bool operator()(const function_object &f) {
    		if (parent == f.parentItem) {
    			return true;
    		}
    		return false;
    	}
    };
    

    Zugriff:

    auto it = std::find_if(fcts.begin(), fcts.end(), function_object::find_item(item));
    
    std::vector<punkt<double>>g = schnittpunkte(temp, it->fct);
    


  • Wenn du ein Objekt mit new erzeugst, muss sich jemand auch wieder um das Zerstören kümmern. Derjenige ist der Besitzer des Objekts. Entsprechend sind dann Pointerzuweisungen als Besitztransfer zu verstehen. Von Besitzverhältnissen sehe ich in deinem Code aber nichts, da stammen also vermutlich auch deine Probleme her. Mach aus parentItem ein std::unique_ptr<MyQTreeWidgetItem>. Unsachgemäße Benutzung der Strukturen resultieren dann mehr oder weniger automatisch in einem Compilerfehler.



  • std::unique_ptr<> kann ich nicht verwenden da die Objekte in einem QTreeWidget dargestellt werden sollen, somit bin ich gewzungen std::shared_ptr<> zu verwenden.

    Somit sieht das Ganze jetzt so aus

    Funktor:

    struct find_item {
    
    		std::shared_ptr<MyQTreeWidgetItem>parent;
    		find_item(std::shared_ptr<MyQTreeWidgetItem>i ) :parent(i){}
    
    		bool operator()(const function_object f) {
    			if (parent == f.parentItem) {
    				return true;
    			}
    			return false;
    		}
    	};
    

    Und aufruf des Funktors

    auto it = std::find_if(fcts.begin(), fcts.end(), function_object::find_item(std::shared_ptr<MyQTreeWidgetItem>(new MyQTreeWidgetItem(*item))));
    

    Jetzt gibt es allerdings das Problem das "it" immer fcts.end() zeigt, folglich findet der Funktor das Element im Vektor nichtmehr. Es ist aber noch vorhanden!
    Wie löse ich das, bzw wie schreib ich das sinnvoll?



  • Lösung gefunden!

    Es war einfach mein Fehler indem ich versucht habe die QTreeWidgetItem-Klasse zu überladen. Das hat alles sehr instabil gemacht. Jetzt mit der normalen QTreeWidgetItem-Klasse klappt alles auch ohne smart-pointer!

    Trotzdem Danke für die Hilfe!


Log in to reply