Erstellen von shared_ptr Referenz

Ich bin relativ neu in C++ und diese Nähte wie eine noob Frage, aber ich war nicht in der Lage, es zu lösen, mit anderen Quellen im internet.

Ich versuche zu schaffen, ein shared_ptr von einem Verweis. Ich habe folgende Book Klasse:

#include <memory>
#include "Author.hpp"

class Book
{
   public:
      void setAuthor(const Author& t_author);

   private:
      std::shared_ptr<Author> m_author;
}

Und das ist mein Author Klasse:

#include <memory>
class Book;

class Author
{
   public:
      void addBook(const Book& t_book);

   private:
      std::vector<std::weak_ptr<Book>> m_books;
}

Ich müde zur Umsetzung der Book::setAuthor Methode etwa so:

void Book::setAuthor(const Author& t_author)
{
   m_author = std::shared_ptr<Author>(&t_author);
}

Aber wenn ich versuche zu kompilieren, das ich bekommen:

Invalide Konvertierung von const Autor* Autor*

Invalide Konvertierung von sizeof const Autor

Können Sie mir bitte sagen, was falsch ist mit meinem code? Ich habe auch versucht, das gleiche mit dem weak_ptr-aber das funktioniert auch nicht.

Ich glaube, Sie sollten std::vector<Book> und std::vector<Author>. Keine Zeiger, keine std::shared_ptr keine std::weak_ptr. Verwalten der Beziehung zwischen Büchern und Autoren in der relationale Datenbank; was Sie sind für. Behandlung der std::vector<Book> und std::vector<Author> Objekte als vorübergehend benötigt Ergebnisse von Datenbank-Abfragen.
Du hast Recht und ich will auch, aber ich würde gerne eine ORM-Bibliothek und dort habe ich vectors von shared_ptr zur Darstellung des viele Beziehungen. Oder gibt es einen anderen Weg, dies zu tun?
Nun, warum nutzen Sie die Bibliothek, wenn es zwingt Sie verwenden eine fehlerhafte Konstruktion? ORM ist nicht ein Ziel in sich selbst.
Okay danke ich werde darüber nachdenken. Aber bin ich richtig, dass ich std::vector<Book*> dann, weil die Klassen (Header) sind voneinander abhängig und ich habe mit vorwärts-Deklaration für eine Klasse (hier Book)?
Ja, wenn Book enthält eine std::vector<Author> und eine Author enthält eine std::vector<Book>, dann hätten Sie eine unendliche Rekursion, es ist also nicht möglich. Ich denke, eine wichtige Frage wurde nicht gefragt so weit: Was Operationen, die Sie auf dieser Datenstruktur? Wenn, z.B., das Ziel ist zum anzeigen einer Liste der Bücher, mit einer Liste von Autoren für jedes Element, dann ist es nicht notwendig, für Author enthalten std::vector<Book>.

InformationsquelleAutor Cilenco | 2017-02-08

  1. 11

    Obwohl, Ihr Fehler ergibt sich aus der Tatsache, dass die std::shared_ptr<Author> Konstruktor im Einsatz erwartet Author*, aber der Ausdruck &t_author Ergebnisse auf ein Objekt vom Typ const Author*

    Andere falsche Sache:

    void Book::setAuthor(const Author& t_author)
{
   m_author = std::shared_ptr<Author>(&t_author);
}

    Vorstellen Berufung book.setAuthor(Author("Herb Sutter")); haben Sie eine baumelnden Zeiger weil t_author aufhören wird zu existieren, nachdem diese Funktion abgeschlossen ist.

    Müssen Sie kopieren oder verschieben Sie das Objekt in Ihre std::shared_ptr Instanz. Verwenden std::make_shared<T> zu erstellen Sie Ihre std::shared_ptr<T> Objekte, Wann immer möglich. 

    void Book::setAuthor(const Author& t_author)
{
   m_author = std::make_shared<Author>(t_author);
}

    Besser noch:

    void Book::setAuthor(Author t_author)
{
   m_author = std::make_shared<Author>(std::move(t_author));
}
    Danke für die Antwort, hat mir sehr geholfen. Können Sie bitte schauen Sie auf meinen Kommentar unter der Frage? Was denkst du wäre die beste design-Muster für die eins-zu-viele-Ansatz? Oder sollte ich nicht so ein ORM-Bibliothek?
    Ich benutze ein ORM-Bibliothek?" ist ein sehr breites und Meinung-basiert Frage! 🙂 Ich denke, die einzige Antwort, die wir dir geben kann ist, wählen Sie das richtige Werkzeug für Ihre software (oder Ihr Arbeitgeber) Anforderungen, verwenden Sie niemals ein Werkzeug, nur so können Sie ein tool verwenden, und beachten Sie, dass jede Lösung hat Vorteile und Verbindlichkeiten. Wer weiß, auch C++ selbst kann eine schlechte Wahl für dieses spezielle problem, aber wir können nicht sagen, ohne das problem zu verstehen.
    Nicht der letztere Fall bewirken, dass das kopieren von Author - Objekt übergeben wird?

    InformationsquelleAutor WhiZTiM

  2. 4

    Wenn Sie möchten, machen Sie eine Kopie und verwenden std::make_shared:

    void Book::setAuthor(const Author& t_author)
{
   m_author = std::make_shared<Author>(t_author);
}

    aber dies ist eine falsche Konstruktion, wenn Sie erwarten, um Eigentum an übergebenen Objekte, die Sie passieren sollte std::shared_ptr auf Ihre Funktion anstelle von const-Referenz:

    void Book::setAuthor( std::shared_ptr<Author> t_author)
{
   m_author = std::move( t_author );
}
    Also mit meinem design, ich wäre nicht der Besitzer nicht mehr von der Referenz? Kannst du bitte Ausführlicher erklären? Tun haben Sie vielleicht auch Ideen für ein gutes design-pattern mit dem odb (orm) - Bibliothek (siehe Kommentare unter der Frage)
    In Ihrem Entwurf, den Sie passieren Objekt const-Referenz, so können Sie call-const-Methoden der it oder eine Kopie machen. In Ihrer Klasse, die Sie verwenden std::shared_ptr was darauf hindeutet gemeinsamen Besitz. Etwas falsch hier sollte man entweder nicht verwenden std::shared_ptr oder Objekte übergeben, die bereits im Besitz von std::shared_ptr für die Klasse teilen zu können.
    Und es gibt keine solche Sache als Besitzer der Referenz. Wenn Sie pass-Objekt durch die Referenz, die Sie davon ausgehen, dass die Funktion übergeben Sie es sich nicht nehmen-oder Aktienbesitz.

    InformationsquelleAutor Slava

  3. 2

    Dies ist wahrscheinlich nicht definiertes Verhalten. shared_ptr zeigt Eigentum von das Objekt verweist. In fast jedem denkbaren Szenario t_author bezieht sich auf eine vorhandene Author ist im Besitz von etwas anderem. Es wird fast sicherlich zwei Standorten, die versuchen, zu zerstören der Instanz.

    Wenn Sie muss erstellen Sie eine shared_ptr zu einer vorhandenen Instanz können Sie sich in enable_shared_from_this, aber das funktioniert nur, wenn t_author wurde mit std::make_shared. Und wenn dies der Fall ist, könnte man auch ändern Ihre Funktion übernehmen Sie die shared_ptr direkt. Alternativ können Sie erstellen eine shared_ptr mit einer custom deleter, die nichts tut. Aber an diesem Punkt, es gibt nichts zu gewinnen aus der Nutzung shared_ptr, außer vielleicht die Kompatibilität mit einigen interface.

    InformationsquelleAutor François Andrieux

Schreibe einen Kommentar