Pass und speichern Schnittstelle Implementierung

Question

Nehmen wir an, wir haben Schnittstelle selector_interface_t und Implementierung dieser Schnittstelle pin_selector_t.

class selector_interface_t 
{ 
    public: 
     virtual void select(uint8_t address) = 0; 
     virtual void deselect() = 0; 
}; 

class pin_selector_t : public selector_interface_t 
{ 
    private: 
     uint8_t mask; 

    public: 
     pin_selector_t(uint8_t mask); 
     void select(uint8_t address); 
     void deselect(); 
}; 

Und jetzt wollen wir Objekt Hexe passieren implementiert diese Schnittstelle zur Klasse myclass_t und Speicher für die zukünftige Verwendung durch andere myclass_t Methoden (zB. strobe).

class myclass_t 
{ 
    private: 
     selector_interface_t * selector; 

    public: 
     myclass_t(selector_interface_t & selector); 
     void strobe(uint8_t pin); 
}; 

myclass_t::myclass_t(selector_interface_t & selector) // : selector(selector) 
{ 
    // ... 
} 

void myclass_t::strobe(uint8_t pin) 
{ 
    this->selector->select(pin); 
    this->selector->deselect(); 
} 

Der einzige Weg ist die Umsetzung durch den Zeiger übergeben oder durch Bezugnahme eingeschlossen. Ich bevorzuge zweite Lösung und gehe durch Referenz. Aber ich kann nicht einfach diese Referenz in myclass_t Objekt wegen der Lebensdauer des Objekts mit Schnittstellenimplementierung speichern. Es wäre besser, eine Kopie zu machen. Aber ich kann nicht selector_interface_t Feld Mitglied haben. Ich kann nur einen Verweis oder Zeiger auf diesen Typ haben. Auf der anderen Seite möchte ich Malloc vermeiden. Was kann ich damit machen?

Answer 1

Wenn Sie den selector_interface_t-Typ erstellen, können Sie ihn in einem shared_ptr speichern und die Klasse myclass_t ein schwaches_ptr oder shared_ptr an der Schnittstelle halten.

Wenn Sie nicht derjenige sind, der selector_interface_t erstellt, dann nehme ich an, dass Sie andere Mittel haben, das Objekt am Leben zu halten, es in eine Klasse zu verpacken, die die Lebensdauer und den Objektumbruch in shared_ptr verwaltet.

Answer 2

Wenn Sie nicht garantieren können, dass die Implementierung die richtige Lebensdauer hat, müssen Sie sie verwalten, dh sie dynamisch zuweisen. (Mit new, nicht malloc.)

ich dringend der Verwendung würde vorschlagen, entweder shared_ptr<selector_interface_t> oder unique_ptr<selector_interface_t> - je nachdem, ob Sie sich nur wünschen Implementierung von Objekten zwischen Kunden zu teilen. Sie erhalten dann mit sehr geringem Aufwand den richtigen Code.