shared_ptr - pass by value vs. pass by reference
Angenommen ich habe:
typedef boost::shared_ptr<Event> EventPtr;
In einem thread, erstelle ich eine Event
und senden es ab zu erhalten ausgelöst:
Event* event = new Event();
EventPtr eventPtr(event);
EventDispatcher::dispatch(eventPtr); //pseudocode
Den EventDispatcher
erhält eine EventPtr und fügt es zu einer Warteschlange, verarbeitet in einem anderen thread...aber was ist eine geeignete Methode, Unterschrift für die dispatch-Methode?
dispatch(EventPtr event); //will push_back(event)
oder
dispatch(const EventPtr& event); //will push_back(event);
Wenn man bedenkt, dass meine EventDispatcher hat eine Warteschlange:
typedef std::queue<EventPtr> EventQueue
EventQueue theQueue;
Dann später den anderen thread, erscheint ein Ereignis aus der Warteschlange und übergibt es aus, um etwas zu verarbeiten, Veranstaltung:
EventPtr event = theQueue.front();
EventProcessor::process(event); //pseudocode
theQueue.pop();
Wieder, was ist eine geeignete Methode, Unterschrift für die process
Methode? Ich Frage mich, ob ich einfach die nackten Event*
an die process-Methode?
Ich denke, ich Frage mich, soll ich nur als Wert übergeben, so wird die Referenz-Zählung ist korrekt? Ich bin eigentlich nur besorgt über die Tatsache, dass ein thread drängen in die queue und einem anderen thread knallen aus der Warteschlange und ich werde nicht Leck Zeiger irgendwo...
Dank!
Du musst angemeldet sein, um einen Kommentar abzugeben.
Entweder Vorschlag ist in Ordnung; die übergabe von const-Referenz wird wahrscheinlich effizienter sein, da es sich nicht ändern, der pointer, reference count. In jedem Fall
push_back
wird eine Kopie der Zeiger auf die Warteschlange, halten die Veranstaltung am Leben, während es in der Warteschlange.Übergabe der shared pointer (Wert oder Referenz) wird klar dokumentieren und durchzusetzen, das Eigentum an der Veranstaltung, und wird ermöglichen, dass der Prozessor zu halten, die es nach dem Aufruf
process()
wenn es nötig ist. Vorbei an einem raw-pointer stellt die Unsicherheit über das Eigentum; der Prozessor wird, benötigen Sie einen Vertrag, der besagt, dass es nicht die Eigenverantwortung der Veranstaltung, und darf nicht versuchen, darauf zugreifen, sobaldprocess()
beendet hat.In das große Bild, es spielt keine Rolle, zu viel, ob Sie pass-by-value oder by-reference. So oder so, der Referenzzähler wird erhöht, wenn Sie kopieren Sie die
shared_ptr
zu schieben Sie es in die Warteschlange.Vorbei die nackt-Zeiger ist auch okay, solange Sie vorsichtig sind Sie am Ende nicht mit zwei verschiedenen
shared_ptr
Instanzen mit unterschiedlichen Referenz, zählt man in der Anrufer und man in der aufgerufenen Funktion.Persönlich mag ich die pass-by-value-option, weil es fühlt sich mehr wie an einem realen Zeiger rund. Die eine
shared_ptr
als argument erinnert auch an die Programmierer, die die Funktion aufrufen, die er will, die Lebensdauer des Objekts, zu übersteigen, die Funktion Anruf und der Anrufer speichern möchten, und das argument in eineshared_ptr
sowieso in Fall gibt die Funktion vorzeitig, wenn eine Ausnahme geworfen wird, etc.Sowohl dispatch-Funktionen ordnungsgemäß funktionieren.
Im ersten Fall, wird eine Instanz der shared pointer wird auf den stack kopiert und dann erneut kopiert werden, wenn hinzufügen, um die Ereignis-queue. Dies bedeutet, das kopieren des Zeigers und die Erhöhung der Referenz-Zähler.
Im zweiten Fall wird nur eine Referenz auf eine bestehende Instanz wird an die Funktion übergeben werden und dann in die Warteschlange kopiert. Ich würde zu dieser Variante greifen.
Bei der übergabe der shared pointer zu verarbeiten (können), können Sie auch pass it by reference: