Open-Closed-Prinzip: Auch hier anzuwenden?



  • Hallo Forum,

    lang ist's her 😃

    Zusammengefasst sagt ja das Open-Closed-Prinzip aus, dass eine Klasse offen für Erweiterungen und geschlossen für Modifikationen sein soll.

    Nun habe ich ja hier folgendes Klassengewusel:

    #include <string>
    
    class Base
    {
    	public:
    		virtual ~Base() = 0;
    
    		virtual std::string doIt() = 0;
    };
    
    class Foo : public Base
    {
    	public:
    		std::string doIt()
    		{
    			return "Foo";
    		}
    };
    
    class Bar : public Base
    {
    	public:
    		std::string doIt()
    		{
    			return "Bar";
    		}
    };
    
    class OpenClosedContainer
    {
    	private:
    		Foo *foo;
    		Bar *bar;
    		/* ... */
    
    		std::string result;
    
    	public:
    		OpenClosedContainer() : result("") {}
    
    		void doAll()
    		{
    			if(foo)
    			{
    				result += foo->doIt();
    			}
    
    			if(bar)
    			{
    				result += bar->doIt();
    			}
    		}
    };
    

    Die Klasse OpenClosedContainer ist ja so in der Form weniger schön.
    Neue Ableitung von Base bedeutet stures Copy-Paste in OpenClosedContainer.

    Um das zu unterbinden, hätte ich jetzt hier eine map herangezogen und die verschiedenen Instanzen darin gespeichert. (Es darf nur eine Instanz jeder Klasse verwendet werden).

    Von außen hätte ich dann Zugriff auf eine setter-Methode die mittels Key und Instanz einen Wert in die Map aufnimmt.

    Was haltet ihr davon? Auf jeden Fall oder übertrieben?



  • Mit Foo Bar und Baz kann man kein Software-Design machen.
    Dazu muss man wissen worum es eigentlich geht.

    EDIT: Eigentlich sind Foo/Bar/Baz nicht das Problem, sondern dass wir nicht wissen was OpenClosedContainer eigentlich soll.



  • Oh ... das Codebeispiel sollte nur etwas Unterstützung liefern.
    Das habe ich jetzt in C++ nur mal schnell zusammen gefrickelt um es anschaulicher darzustellen.

    Der Container ist quasi eine Verwaltungsklasse, dass die Abarbeitung aller Instanzen von Base übernimmt.

    Im konkreten Fall sind Foo/Bar/Baz Module die für sich bestimmte Dinge tun und am Ende einen generiertes Javascript zurückgeben. Der Container sammelt die Javascripte um sie dann am Ende der Seite auszugeben. (kurz gesprochen)

    davon kann es theoretisch unbekannt viele Objekte geben.



  • Ich kann bisher noch keinen guten Grund erkennen hier mehr als std::vector<unique_ptr<Base>> zu verwenden.

    Stellt sich also immer noch die Frage: wofür ist OpenClosedContainer gut?
    Also welcher Code soll darin "closed" sein?


Log in to reply