shared_ptr & amp; conversions weak_ptr

Je suis en train de jongler avec des objets à l'aide std::shared_ptr et std::weak_ptr. Le scénario est quelque chose comme ceci:

J'ai objets de la classe channel qui est dérivée d'une classe abstraite abstract::channel (avec des fonctions virtuelles pures). J'ai un conteneur channelContainer (std::vector) contenant des pointeurs partagés (std::shared_ptr) à channel Objets.

Maintenant, j'ai un deque (std::deque) contenant des pointeurs faibles (std::weak_ptr) pour chaque objet dans le channelContainer. Permet de nommer cette deque freeChannelQueue.

Donc permet de dire:

std::vector<std::shared_ptr<abstract::channel> > channelContainer;
std::deque<std::weak_ptr<abstract::channel > > freeChannelQueue;

//Assuming that both the containers are filled appropriately How do I go about implementeing the below functions?

abstract::channel& get_free_channel() {
  //This should return a free channel object from 'freeChannelQueue' and pop the queue.
}

bool release_channel(abstract::channel& ch) {
 //This should convert 'ch' to a std::weak_ptr (or std::shared_ptr) and push it to   'freeChannelQueue'
}

Je suis particulièrement intéressé par le 'Comment faire pour convertir une référence à un objet à une faible pointeur?'

source d'informationauteur user2559933

  1. 5

    Vous ne pouvez pas

    convertir une référence à un objet à une faible pointeur

    Vous pouvez faire un faible pointeur un pointeur partagé, juste à l'aide de cession =
    par exemple,

    std::shared_ptr<abstract::channel> get_free_channel();

    puis

    bool release_channel(std::shared_ptr<abstract::channel> ch)
{
    std::weak_ptr<abstract::channel> weak_ch = ch;
    //...
}

    Surveiller pour la durée de vie - la shared_ptr aller de l'avant de la faiblesse des pointeurs qui pointent vers eux?

  2. 1

    Est-ce votre conception? Comme c'est, il y a quelques graves canal vie les problèmes. Par exemple, si les appels de code get_free_channel() ensuite votre déclaration renvoie une référence à un objet, mais ils n'ont aucun moyen de garantir sa durée de vie englobe leur utilisation. Que pourrait a pas d'importance en fonction de ce que le code du client est que vous êtes à l'appel de la fonction, mais vous voudrez probablement pour retourner un shared_ptrcomme dans:

    std::shared_ptr<abstract::channel> get_free_channel()
{
    //return free channel from 'freeChannelQueue' and pop the queue

    //take a scoped lock on the free queue if necessary

    while (!freeChannelQueue.empty())
    {
         auto p_channel = freeChannelQueue.back();
         freeChannelQueue.pop_back();
         std::shared_ptr<abstract::channel> p = p_channel.lock();
         if (p) return p;
    }

    //freeChannelQueue empty... throw or return nullptr etc..
}

    Sujet de la "libération"...

    bool release_channel(abstract::channel& ch) {
 //This should convert 'ch' to a std::weak_ptr (or std::shared_ptr) and push it to   'freeChannelQueue'
}

    Comme il est, cela n'est possible que si vous recherchez le channelContainer pour trouver l'objet de vos weak ou shared_ptr à partir de là. Encore une fois, vous devrez probablement changer le prototype de sorte qu'il reçoit un shared_ptr ou weak_ptr directement, les verrous de la gratuit de la file d'attente pousse ensuite le pointeur intelligent....

    Dans l'ensemble, il est difficile de vous donner des conseils utiles sans la compréhension de la façon dont votre canal vie va être géré, et comment les différents threads peut tenter d'utiliser les objets et les files d'attente. J'espère que le ci-dessus permet de un peu, même si seulement de se poser plus de question précise.

  3. 0

    Je comprends votre question comme ça: vous avez un conteneur pour l'ensemble de votre chaîne d'objets et que vous avez un deuxième récipient pour maintenir l'ordre dans lequel les canaux peuvent être utilisés par votre application. Vous souhaitez une interface à retour d'une référence à la prochaine canal libre pour votre client, et lorsque le client est terminée, elle libère le canal vers le conteneur.

    Pour obtenir une référence à un canal, vous pouvez utiliser verrouillage pour créer un shared_ptr de votre weak et puis de déréférencement qui (il suffit de ne pas supprimer l'objet sous-jacent!). Cependant, je ne vois pas une façon raisonnable d'aller dans l'autre sens, vous devez rechercher votre canal conteneur de l'objet correspondant et créer un faible pointeur de la mise en correspondance shared_ptr de nouveau.

    Je voudrais envisager de ne pas utiliser weak et de références à tous, il suffit de coller shared_ptr. Puisque vous utilisez un deque pour maintenir les canaux qui sont disponibles, vous pourriez juste trouver des shared_ptr est là. Si vous êtes heureux que votre client sera toujours de libérer les canaux lorsque vous avez terminé, vous peut-être ne pas avoir besoin d'un conteneur pour tous les objets, que l'deque pour les chaînes gratuites - dépend de votre conception globale.

    Comme d'autres l'ont dit, vous devez tenir compte de la durée de vie de votre chaîne objets et comment ils sont utilisés par le client.