Créer des shared_ptr de référence

Je suis en nouvelle C++ et c'coutures comme une question de noob, mais je n'étais pas en mesure de le résoudre avec d'autres ressources sur internet.

Je suis en train de créer un shared_ptr à partir d'une référence. J'ai suivantes Book classe:

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

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

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

Et c'est mon Author classe:

#include <memory>
class Book;

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

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

J'ai fatigué de mettre en œuvre la Book::setAuthor méthode comme suit:

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

Mais si j'essaie de compiler ce que j'obtiens:

Invalid conversion de const Auteur* Auteur*

Invalid conversion de sizeof à const Auteur

Pouvez-vous me dire quel est le problème avec mon code? J'ai aussi essayé la même chose avec le weak mais cela ne fonctionne pas non plus.

Je pense que vous devriez utiliser std::vector<Book> et std::vector<Author>. Pas de pointeur, pas de std::shared_ptr, pas de std::weak_ptr. Gérer la relation entre les livres et les auteurs dans un relationnel de la base de données; c'est ce qu'ils sont pour. Traiter le std::vector<Book> et std::vector<Author> objets que temporairement besoin de résultats de requêtes de base de données.
Vous avez raison et je veux aussi cela, mais je voudrais utiliser un ORM bibliothèque et là, j'ai utiliser vectors de shared_ptr pour représenter plusieurs les relations. Ou est-il un autre moyen pour le faire?
Eh bien, pourquoi utiliser une bibliothèque si il vous oblige à utiliser un défaut de conception? L'ORM n'est pas un but en soi.
Ok merci je vais y réfléchir. Mais ai-je le droit que je dois utiliser std::vector<Book*> ensuite parce que les classes (en-têtes), dépendants les uns des autres et que je dois utiliser avant la déclaration d'une classe (ici Book)?
Oui, si Book contient un std::vector<Author> et un Author contient un std::vector<Book>, alors vous auriez une récursion infinie, de sorte qu'il n'est pas possible. Je pense que d'une question importante n'a pas été posée: Quelles sont les opérations que vous effectuez sur cette structure de données? Si, par exemple, l'objectif est d'afficher une liste de livres avec une liste d'auteurs pour chaque élément, puis il n'est pas nécessaire pour Author pour contenir un std::vector<Book>.

OriginalL'auteur Cilenco | 2017-02-08

c++shared-ptr

11

Que votre erreur vient du fait que le std::shared_ptr<Author> constructeur en cours d'utilisation s'attend à ce Author*, mais l'expression &t_author résultats à un objet de type const Author*

Une autre mauvaise chose:
```
void Book::setAuthor(const Author& t_author)
{
   m_author = std::shared_ptr<Author>(&t_author);
}
```
Imaginer appel book.setAuthor(Author("Herb Sutter"));, vous aurez une balançant pointeur parce que t_author cessera d'exister après que la fonction se termine.

Vous avez besoin de copier ou de déplacer l'objet dans votre std::shared_ptr instance. Utilisation std::make_shared<T> pour créer votre std::shared_ptr<T> les objets chaque fois que possible.
```
void Book::setAuthor(const Author& t_author)
{
   m_author = std::make_shared<Author>(t_author);
}
```
Mieux encore:
```
void Book::setAuthor(Author t_author)
{
   m_author = std::make_shared<Author>(std::move(t_author));
}
```
Merci pour la réponse qui m'a beaucoup aidé. Pouvez vous s'il vous plaît jeter un oeil sur mon commentaire en dessous de la question? Que pensez-vous serait le meilleur modèle de conception pour le un à de nombreuses approche? Ou ne devrais-je pas utiliser un ORM bibliothèque?
Je utiliser un ORM bibliothèque?" est très large et l'opinion à la question! 🙂 Je pense que la seule réponse que nous pouvons vous donner est de choisir le bon outil pour votre logiciel ou de votre employeur), les exigences, ne jamais utiliser un outil de sorte que vous pouvez utiliser un outil, et de garder à l'esprit que chaque solution a des avantages et des passifs. Qui sait, même C++ lui-même peut être un mauvais choix pour ce problème spécifique, mais on peut dire sans comprendre le problème.
N'est pas le dernier cas, la copie de Author objet est transmis?

OriginalL'auteur WhiZTiM
4

Si vous voulez faire une copie d'utilisation std::make_shared:
```
void Book::setAuthor(const Author& t_author)
{
   m_author = std::make_shared<Author>(t_author);
}
```
mais c'est un mauvais design, si vous prévoyez de conserver la propriété de passé objets que vous devriez passer std::shared_ptr à votre fonction au lieu de const référence:
```
void Book::setAuthor( std::shared_ptr<Author> t_author)
{
   m_author = std::move( t_author );
}
```
Donc, avec mon design, je ne voudrais pas être le propriétaire, en plus de la référence? Pouvez-vous expliquer cela plus en détail? Vous avez également peut-être des idées pour un bon modèle de conception avec le pmo (orm) de la bibliothèque (voir les commentaires relatifs à la question)
Dans votre conception, vous passer de l'objet par référence const, de sorte que vous pouvez appeler const méthodes de ou en faire une copie. Dans votre classe, vous utilisez std::shared_ptr qui suggère le partage de la propriété. Quelque chose de mal ici, vous pouvez soit ne pas utiliser std::shared_ptr ou passer des objets que possédait déjà par std::shared_ptr pour votre classe afin d'être en mesure de partager.
Et il n'y a pas une telle chose comme propriétaire de la référence. Si vous passez objet par référence à vous d'assumer cette fonction vous passer il ne peut pas prendre ou à partager la propriété.

OriginalL'auteur Slava
2

C'est probablement un comportement indéfini. shared_ptr indique propriété de l'objet auquel il renvoie. Dans à peu près tous les scénarios possibles, t_author se réfère à un Author qui est possédé par quelque chose d'autre. Il y aura presque certainement être en deux endroits qui tentent de détruire l'instance.

Si vous doit créer un shared_ptr à une instance existante, vous pouvez regarder dans l'aide de enable_shared_from_this, mais cela ne fonctionne que si t_author a été créé avec std::make_shared. Et si c'est le cas, vous pouvez très bien changer votre fonction d'accepter la shared_ptr directement. Alternativement, vous pouvez créer un shared_ptr avec une coutume deleter, qui ne fait rien. Mais à ce moment, il n'y a rien à gagner de l'utilisation de shared_ptr, à l'exception peut-être de compatibilité avec certains d'interface.

OriginalL'auteur François Andrieux

Vous devez vous connecter pour publier un commentaire.