Jetzt entwickle ich eine Klasse für die Erkennung eines Objekts in einem Foto, und diese Klasse besteht aus mehreren Komponenten (Klassen). Zum Beispielist dies ein Beispiel, in dem abstrakte Fabrikmuster verwendet werden?
class PhotoRecognizer
{
public:
int perform_recogniton()
{
pPreProcessing->do_preprocessing();
pFeatureExtractor->do_feature_extraction();
pClassifier->do_classification()
}
boost::shared_ptr<PreProcessing> pPreProcessing;
boost::shared_ptr<FeatureExtractor> pFeatureExtractor;
boost::shared_ptr<Classifier> pClassifier;
}
In diesem Beispiel, wenn wir diese Klasse verwenden Erkennung auszuführen, rufen wir andere Klassen PreProcessing, FeatureExtractor und Classifier. Wie Sie sich vorstellen können, gibt es viele verschiedene Methoden, um jede Klasse zu implementieren. Für die Klasse Classifier können wir beispielsweise SVMClassfier oder NeuralNetworkClassifer verwenden, die eine abgeleitete Klasse der Basisklasse Classifier ist.
class SVMClassifier: public Classifier
{
public:
void do_classification();
};
daher durch verschiedene Elemente innerhalb PhotoRecognizer Klasse verwenden, können wir verschiedene Arten von PhotoRecongnizer erstellen. Jetzt baue ich einen Benchmark, um zu wissen, wie man diese Elemente kombiniert, um ein optimales PhotoRecognizer zu schaffen. Eine Lösung, die ich denken kann, ist abstrakte Werk zu verwenden:
class MethodFactory
{
public:
MethodFactory(){};
boost::shared_ptr<PreProcessing> pPreProcessing;
boost::shared_ptr<FeatureExtractor> pFeatureExtractor;
boost::shared_ptr<Classifier> pClassifier;
};
class Method1:public MethodFactory
{
public:
Method1():MethodFactory()
{
pPreProcessing.reset(new GaussianFiltering);
pFeatureExtractor.reset(new FFTStatictis);
pClassifier.reset(new SVMClassifier);
}
};
class Method2:public MethodFactory
{
public:
Method1():MethodFactory()
{
pPreProcessing.reset(new MedianFiltering);
pFeatureExtractor.reset(new WaveletStatictis);
pClassifier.reset(new NearestNeighborClassifier);
}
};
class PhotoRecognizer
{
public:
PhotoRecognizer(MethodFactory *p):pFactory(p)
{
}
int perform_recogniton()
{
pFactory->pPreProcessing->do_preprocessing();
pFactory->pFeatureExtractor->do_feature_extraction();
pFactory->pClassifier->do_classification()
}
MethodFactory *pFactory;
}
Also, wenn ich Method1 verwenden Foto Erkennung durchzuführen, kann ich einfach folgendes tun:
Method1 med;
PhotoRecognizer recogMethod1(&med);
med.perform_recognition()
Weiter mehr, kann ich selbst machen die Klasse PhotoRecognizer kompaktere:
enum RecMethod
{
Method1, Method2
};
class PhotoRecognizer
{
public:
PhotoRecognizer(RecMethod)
{
switch(RecMethod)
{
case Method1:
pFactory.reset(new Method1());
break;
...
}
}
boost::shared_ptr<MethodFactory> pFactory;
};
So, hier ist meine Frage: ist die abstrakte Fabrik-Entwurfsmuster gut begründet in der oben beschriebenen Situation? Gibt es alternative Lösungen? Vielen Dank.
Dies ist nicht im Zusammenhang mit C++, also warum ist das Tag dort? – Ceros
@Ceros Die Demo-Codes sind in C++ – feelfree
Aber Ihre Frage ist über Code-Design nicht C++ – Ceros