Klassenliste?!

Hallo,

ich habe folgendes Problem, wozu ich leider keinen Lösungsansatz habe:
Ich habe eine endliche Anzahl an Klassen (A, B, C, D, E,...), die alle von BaseClass erben. Nun beziehe ich zur Laufzeit des Programms Daten in Form von strings, nach denen Instanzen dieser Klassen erstellt werden. Das heißt, mir wird beispielsweise per string "A" übergeben. Nun möchte ich eine Instanz der Klasse A erstellen, die dann weiterhin benutzt wird.

Ich denke, das eigentliche Erstellen der Klasse kann mit templates umgesetzt werden. Aber wie komme ich von dem string "A" auf die Klasse A, damit ich die entsprechende Klasse meiner template Klasse übergeben kann?

Grüße Neulinger

brotbernd

Abstrakte Fabrik
http://www.drdobbs.com/184403786

XSpille

brotbernd schrieb:

Abstrakte Fabrik
http://www.drdobbs.com/184403786

Weswegen Abstract Factory und keine normale Factory?

Gruß,
XSpille

brotbernd

Was genau ist eine normale Fabrik? Zu den GoF Mustern zählt "Abstrakte Fabrik" und "Fabrikmethode". "Normale Fabrik" kenn ich nicht.

Aber stimmt schon, die Implementierung in dem Link zeigt nicht wirklich eine abstrakte Fabrik, bzw. es gibt dort nur eine konkrete Fabrik. Trotzdem ist das für mich eine Form des Patterns Abstract Factory.

Aus dem konkreten Link werde ich nicht wirklich schlau. Durch die Codezeilen am Ende, können/ müssen doch Codezeilen von weiter oben entfernt werden?!

Ich habe aber mal nach abstrakten Klassen gegoogelt und bin auch auf ein paar Ergebnisse gestoßen:
http://en.csharp-online.net/Abstract_Factory_design_pattern:_Example

Das ist zwar eine andere Sprache, das Entwicklungskonzept dahinter bleibt aber gleich?! Wenn ich das ganze richtig verstehe (was ich momentan nicht so ganz glaube), habe ich hier das gleiche Problem wie vorher: Ich komme auf keine Programmzeile, die folgendes ersetzt/ durchführt:

A* inst = new A();

pumuckl

brotbernd schrieb:

Trotzdem ist das für mich eine Form des Patterns Abstract Factory.

Weder noch. Das abstract factory pattern zielt drauf ab, die factory je nach Bedarf gegen andere austauschen zu können. Die verschiedenen Factories liefern jewiels Produkte einer gleichen Oberklasse, jedoch mit (leicht) unterschiedlichem Verhalten.

Beim factory method pattern im GoF-Sinn bestimmt der dynamische Typ des Erzeugers, welches Produkt geliefert wird. Das ist hier nicht der Fall.

Es gibt allerdings weitere Interpretationen, was eine "factory method" ist und was nicht - das hier ist eine davon.

Neulinger schrieb:

[...] habe ich hier das gleiche Problem wie vorher: Ich komme auf keine Programmzeile, die folgendes ersetzt/ durchführt:
A* inst = new A();

Naja, man kann es zumindest ein bisschen umgehen:

struct base {
	virtual ~base() {}
};

struct A : base {
};

struct B : base {
};

template<typename T>
base* createObject() {
	return new T();
}

int main() {
	typedef base*(*create_func)();
	std::map<std::string,create_func> Factory;
	Factory["A"] = createObject<A>;
	Factory["B"] = createObject<B>;

	std::string ClassName = "B";
	base* Object = Factory[ClassName]();
}

brotbernd

Neulinger schrieb:

Aus dem konkreten Link werde ich nicht wirklich schlau. Durch die Codezeilen am Ende, können/ müssen doch Codezeilen von weiter oben entfernt werden?!

Im Prinzip zeigt die Seite eine generische Implementierung von einer Fabrik (abstrakt oder nicht, Methode oder wie auch immer man es nun nennen mag ) wie

class Base
{

};
typedef Base* (*Creator)();

class Factory
{
    typedef std::map<std::string, Creator> Map;
    typedef Map::const_iterator Iter;
    Map creators_;
public:

    static Factory& Instance()
    {
        static Factory inst;
        return inst;
    }

    bool Register(const std::string& key, Creator f)
    {
        creators_[key] = f;
        return true;
    }

    Base* Create(const std::string& key) const
    {
        Iter i = creators_.find(key);
        if (i == creators_.end()) 
            throw std::runtime_error("unknown type");
        return i->second();
    }

};

class A : public Base{};
namespace
{
    Base* CreateA() { return new A; }
    bool adummy = Factory::Instance().Register("A", CreateA);
}

class B : public Base{};
namespace
{
    Base* CreateB() { return new B; }
    bool bdummy = Factory::Instance().Register("B", CreateB);
}

int main() 
{
    Base * a = Factory::Instance().Create("A");
    Base * b = Factory::Instance().Create("B");

    return 0;
}

So langsam wirds heller! Vielen Dank!

Manchmal denke ich, ich habs voll verstanden und plötzlich verliere ich dann wieder den Faden. Aber ich glaube mittlerweile habe ich ein Bild von dem Problem und den Lösungsansätzen.

XSpille

brotbernd schrieb:

Was genau ist eine normale Fabrik? Zu den GoF Mustern zählt "Abstrakte Fabrik" und "Fabrikmethode". "Normale Fabrik" kenn ich nicht.

Aber stimmt schon, die Implementierung in dem Link zeigt nicht wirklich eine abstrakte Fabrik, bzw. es gibt dort nur eine konkrete Fabrik. Trotzdem ist das für mich eine Form des Patterns Abstract Factory.

Das "Abstract" ist meiner Meinung nach fehl am Platz...
Da dir ja das Konzept der "Abstrakten Fabrik" bekannt ist, kannst du ja mal kucken,
was rauskommt, wenn du den abstrakten Teil weglässt...

Ich kenne auch keine "konkrete Fabrik"
http://en.wikipedia.org/wiki/Design_pattern_(computer_science)

brotbernd

XSpille schrieb:

Ich kenne auch keine "konkrete Fabrik"

Beim Abstract Factory Muster gibt es verschiedene konkrete Fabriken, die die Schnittstelle der abstrakten Fabrik implementieren und ihre jeweiligen konkreten Produkte ausliefern (siehe pumuckl).
Aber es stimmt schon, dass die verlinkte, generische Fabrik mit dem GoF Muster "Abstrakte Fabrik" nicht viel zu tun hat. Aber auch nicht mit dem GoF Muster "Fabrikmethode". Von mir aus nennen wir es normale Fabrik

314159265358979

Ich würde es eine Object-Factory nennen.