KlasseB in KlasseA -> KlasseA gibt B zurück



  • Hey 🙂

    Ich stehe grade vor einem kleinerem Problem. Und zwar
    habe ich Strategy Klassen die nur eine Funktion beeinhalten. z.B.:

    class _comTest : public _IStrategy
    {
    	public:
    		void method(shared_ptr<vector<string>> tokens)
    		{
    			m_CData->AppendConsoleTXT("bla bla bla Mr. Freeman\r\n");
    		};
    };
    

    Das Problem ist jetzt, das die Funktion method(), auf Daten zurückgreifen muss.
    Also eigentlich so aussieht:

    class _comTest : public _IStrategy
    {
    	public:
    		_comTest(shared_ptr<_CData> CData)
    		{
    			m_CData = CData;
    		}
    		void method(shared_ptr<vector<string>> tokens)
    		{
    			m_CData->AppendConsoleTXT("bla bla bla Mr. Freeman\r\n");
    		};
    	private:
    		shared_ptr<_CData>		m_CData;
    		_SerialCom*				m_Serial;
    };
    

    Jetzt ist es nur so das, jede dieser _com Klassen exakt den gleichen Konstruktor haben wird, das Einzige das anders wird ist method().
    Dann kommt jetzt noch das _comTest in der Klasse _Console aufgerufen wird.

    _Console :: _Console(shared_ptr<_CData> CData)
    {
    	m_CData	= CData;
    	m_commands.clear();
    	m_commands.push_back(_Command("test", shared_ptr<_IStrategy>(new _comTest(m_CData))));
    }
    

    es funktioniert natürlich, aber ich würde es gerne vermeiden jedes mal CData in den Konstruktor zu schreiben, und jedes mal die entsprechende Variablen zu haben.

    jemand eine Idee?
    Gruß, Chris



  • Ich hab grade eine Lösung gefunden.

    und zwar ändere ich die Strategy Klasse um:

    class _IStrategy
    {
    	public:
    		virtual			~_IStrategy(){}
    		virtual void	method(shared_ptr<std::vector<std::string>> tokens) = 0;
    
    		static shared_ptr<_CData>	m_CData;
    };
    

    und setze nach dem erstellen von _CData:

    _IStrategy::m_CData = m_pCData;
    

    so kennen alle Klassen die _IStrategy erben auch den Pointer zu CData.

    Danke 🙂
    Das Aufschreiben von Problemen führ bei mir oft zur Lösung.


  • Mod

    static shared_ptr in abstrakten Basisklassen als Lösung? Klingt erstmal wild. Was soll das werden? So eine Art Strategy Pattern? Das implementiert man anders und zwar weitaus einfacher und sauberer.

    Falls ich falsch vermutet haben sollte, beschreib mal, was du erreichen möchtest. Nicht, wie du dir die technische Umsetzung vorstellst.



  • Warum stellst du überall einen Underscore voran? Strenggenommen sind solche Bezeichner reserved for the implementation und dürfen nicht benutzt werden.



  • Das Strategy Pattern ist auch einfacher implementiert.
    Es geht bei mir aber um die Implementierung eines solchen Patterns in eine Konsole.

    Also:
    _Console hat einen Vektor aus Befehlen mit strategy Klassen (z.B._comTest).
    Jeder Befehl soll natürlich eine eigene Strategy haben, da kein Befehl die gleiche Aktion ausführt.
    Die StrategyKlasse _comTest und alle anderen Strategys benötigen Zugriff auf Daten um diese individuell zu bearbeiten. Das realisiere ich jetzt über den static pointer.
    Da alle StrategyKlassen eh IStrategy erben, und so auch den Pointer, den es ohnehin nur einmal gibt, bekommen.

    DocShoe schrieb:

    Warum stellst du überall einen Underscore voran? Strenggenommen sind solche Bezeichner reserved for the implementation und dürfen nicht benutzt werden.

    Programiergruppen interner Codingstyle - Ich habe Ihn nicht gemacht.


Log in to reply