Entwurfsmuster für das Caching von verschiedenen abgeleiteten Typen ohne RTTI mit

Question

Lassen Sie uns sagen, dass ich eine Familie von Klassen haben, die alle die gleiche Schnittstelle implementieren, vielleicht für die Planung:

class Foo : public IScheduler { 
public: 
    Foo (Descriptor d) : IScheduler (d) {} 
    /* methods */ 
}; 

class Bar : public IScheduler { 
public: 
    Bar (Descriptor d) : IScheduler (d) {} 
    /* methods */ 
}; 

Lassen Sie uns jetzt sagen, dass ich einen Scheduler-Klasse haben, die Sie kann fragen, ob eine IScheduler-abgeleitete Klasse für einen gegebenen Deskriptor gestartet werden soll. Wenn es bereits existiert, erhalten Sie einen Hinweis darauf. Wenn einer nicht existiert, erzeugt er einen neuen.

Foo & foo = scheduler->findOrCreate<Foo>(descriptor); 

dass Implementierung würde eine Karte, deren Schlüssel erforderlich waren (Beschreiber, RTTI) zugeordnet Basisklasse Zeiger:

Eine hypothetische Aufruf wäre so etwas wie sein. Dann müssten Sie dynamic_cast. Etwas in dieser Richtung, ich denke:

template<class ItemType> 
ItemType & Scheduler::findOrCreate(Descriptor d) 
{ 
    auto it = _map.find(SchedulerKey (d, typeid(ItemType))); 
    if (it == _map.end()) { 
     ItemType * newItem = new ItemType (d); 
     _map[SchedulerKey (d, typeid(ItemType))] = newItem; 
     return *newItem; 
    } 
    ItemType * existingItem = dynamic_cast<ItemType>(it->second); 
    assert(existingItem != nullptr); 
    return *existingItem; 
} 

fragen sich, ob jemand eine Möglichkeit hat, ein ähnliches Ergebnis ohne stützte sich auf RTTI wie dies zu erreichen. Vielleicht könnte jeder geplante Elementtyp eine eigene Karteninstanz haben? Ein Designmuster oder ...?

Answer 1

Die Adresse einer Funktion oder eines statischen Members der Klasse ist garantiert eindeutig (soweit < angezeigt wird), sodass Sie eine solche Adresse als Schlüssel verwenden können.

template <typename T> 
struct Id { static void Addressed(); }; 

template <typename ItemType> 
ItemType const& Scheduler::Get(Descriptor d) { 
    using Identifier = std::pair<Descriptor, void(*)()>; 

    Identifier const key = std::make_pair(d, &Id<ItemType>::Addressed); 

    IScheduler*& s = _map[key]; 

    if (s == nullptr) { s = new ItemType{d}; } 

    return static_cast<ItemType&>(*s); 
} 

Beachten Sie die Verwendung von operator[] ein Doppelnachschau zu vermeiden und die Funktionskörper vereinfachen.

Answer 2

Hier ist ein Weg.

eine rein virtuelle Methode zu IScheduler hinzufügen:

virtual const char *getId() const =0; 

Dann auf seine eigene .h oder CPP Datei jeder Unterklasse setzen, und definieren Sie die Funktion:

virtual const char *getId() const { return __FILE__; } 

Zusätzlich zur Verwendung von Vorlagen, wo Sie den genauen Typ zur Kompilierzeit haben, im gleichen Fil e definieren statische Methode, die Sie ohne Klasseninstanz (AKA static polymorphism) verwenden können:

static const char *staticId() { return __FILE__; } 

Dann verwenden Sie diese als Cache-Karte Schlüssel. __FILE__ ist im C++ - Standard, also ist dies auch portabel.

Wichtiger Hinweis: Verwenden Sie den richtigen Zeichenfolge vergleichen, anstatt nur Zeiger zu vergleichen. Vielleicht std::string statt char* zurückgeben, um Unfälle zu vermeiden. Auf der positiven Seite können Sie dann mit beliebigen String-Werten vergleichen, speichern Sie sie in Datei usw., Sie müssen nicht nur Werte verwenden, die von diesen Methoden zurückgegeben werden.

Wenn Sie Zeiger vergleichen möchten (wie für Effizienz), benötigen Sie ein bisschen mehr Code, den Sie pro Klasse genau ein Zeigerwert, um sicherzustellen, haben (variable Deklaration private static Mitglied in hinzufügen .h und Definition + Initialisierung mit FILE in entsprechenden .cpp, und geben Sie dann zurück, und verwenden Sie nur die von diesen Methoden zurückgegebenen Werte.

---

Hinweis über Klassenhierarchie, wenn Sie etwas haben, wie

• A erbt IScheduler muss getId()
• A2 erbt A, Compiler beschweren getId()

über das Vergessen nicht außer Kraft setzen Dann, wenn Sie sicherstellen wollen, dass Sie nicht leiden ntally vergessen getId() außer Kraft zu setzen, können Sie stattdessen

• abstrakt sollte AbaseIScheduler erbt, ohne zu definieren getId()
• letzte AAbase erbt und muss getId()
• final A2 erbt Abase, hinzufügen und getId() hinzufügen müssen, in Neben den Änderungen an A

(Hinweis: final keyword identifier with special meaning ist C 11 ++ Funktion, die für frühere Versionen es nur auszulassen ...)

Answer 3

static_cast die ItemType* zu void* und speichern, die in der Karte. Dann, in findOrCreate, erhalten Sie einfach die void* und static_cast es zurück zu ItemType*.

static_cast ing T * -> void * -> T * ist garantiert, dass Sie wieder den ursprünglichen Zeiger zu erhalten. Sie verwenden bereits typeid(ItemType) als Teil Ihres Schlüssels, sodass sichergestellt ist, dass die Suche nur dann erfolgreich ist, wenn derselbe Typ angefordert wird. Das sollte also sicher sein.

Wenn Sie auch die IScheduler* in der Scheduler Map benötigen, speichern Sie einfach beide Zeiger.

Answer 4

Wenn Scheduler ein Singleton ist, würde dies funktionieren.

template<typename T> 
T& Scheduler::findOrCreate(Descriptor d) { 
    static map<Descriptor, unique_ptr<T>> m; 
    auto& p = m[d]; 
    if (!p) p = make_unique<T>(d); 
    return *p; 
} 

Wenn Scheduler kein Singleton ist, könnte man eine zentrale Registrierung haben die gleiche Technik verwenden, aber einen Scheduler */Descriptor Paar zum unique_ptr zuordnen.

Answer 5

Wenn Sie alle Ihre verschiedenen Subtypen von IsScheduler kennen, dann ja absolut. In Boost.Fusion können Sie eine Karte erstellen, deren Schlüssel wirklich ein Typ ist. So für Ihr Beispiel, könnten wir so etwas wie tun:

typedef boost::fusion::map< 
    boost::fusion::pair<Foo, std::map<Descriptor, Foo*>>, 
    boost::fusion::pair<Bar, std::map<Descriptor, Bar*>>, 
    .... 
    > FullMap; 

FullMap map_; 

Und wir werden diese Karte verwenden thuslly:

template <class ItemType> 
ItemType& Scheduler::findOrCreate(Descriptor d) 
{ 
    // first, we get the map based on ItemType 
    std::map<Descriptor, ItemType*>& itemMap = boost::fusion::at_key<ItemType>(map_); 

    // then, we look it up in there as normal 
    ItemType*& item = itemMap[d]; 
    if (!item) item = new ItemType(d); 
    return item; 
} 

Wenn Sie versuchen, ein Element findOrCreate, die Sie nicht in Ihrem FullMap definiert haben, dann kann at_key nicht kompilieren. Wenn Sie also etwas wirklich Dynamisches brauchen, wo Sie neue Scheduler ad hoc hinzufügen können, wird dies nicht funktionieren. Aber wenn das keine Voraussetzung ist, funktioniert das großartig.