C26417 NO_LVALUE_REF_SHARED_PTRC26417 NO_LVALUE_REF_SHARED_PTR

« Paramètre de pointeur partagé est passé par référence et pas réinitialisé ou réassigné."Shared pointer parameter is passed by reference and not reset or reassigned. Utilisez T * ou T & à la place. »Use T* or T& instead."

C++ Core Guidelines: R.35 : prendre un shared_ptr& paramètre pour exprimer qu’une fonction peut réinstaller le pointeur partagéC++ Core Guidelines: R.35: Take a shared_ptr& parameter to express that a function might reseat the shared pointer

Passage de pointeurs partagés par référence peut être utile dans les scénarios où code appelant met à jour la cible de l’objet pointeur intelligent et son appelant s’attend à voir ces mises à jour.Passing shared pointers by reference may be useful in scenarios where callee code updates target of the smart pointer object and its caller expects to see such update. À l’aide d’une référence uniquement à réduire les coûts de passer un pointeur partagé est douteux.Using a reference solely to reduce costs of passing a shared pointer is questionable. Si le code appelant accède uniquement aux objet cible et jamais gère sa durée de vie, il est préférable de passer le pointeur brut ou référence, plutôt que d’exposer les détails de gestion de ressources.If callee code only accesses target object and never manages its lifetime, it is safer to pass raw pointer or reference, rather than to expose resource management details.

NotesRemarks

  • Cette vérification reconnaît std::shared_pointer et les types définis par l’utilisateur qui sont susceptibles de se comportent comme des pointeurs partagés.This check recognizes std::shared_pointer and user-defined types which are likely to behave like shared pointers. Les caractéristiques suivantes sont attendus pour défini par l’utilisateur de pointeurs partagés :The following traits are expected for user-defined shared pointers:
  • surchargé déréférencer ou d’accès au membre opérateurs (publiques et non supprimé) ;overloaded dereference or member access operators (public and non-deleted);
  • constructeur de copie ou opérateur d’assignation de copie (publique et non supprimé) ;copy constructor or copy assignment operator (public and non-deleted);
  • destructeur public qui n’est ni supprimé ni une valeur par défaut.public destructor which is neither deleted nor defaulted. Les destructeurs vides sont toujours comptabilisées comme défini par l’utilisateur.Empty destructors are still counted as user-defined.
  • L’action de réinitialisation ou la réaffectation est interprétée de façon plus générique :The action of resetting or reassigning is interpreted in a more generic way:
  • un appel à une fonction non constante sur un pointeur partagé peut réinitialiser potentiellement le pointeur ;any call to a non-constant function on a shared pointer can potentially reset the pointer;
  • tout appel à une fonction qui accepte une référence à un pointeur partagé non constante peut réinitialiser ou réaffecter ce pointeur.any call to a function which accepts a reference to a non-constant shared pointer can potentially reset or reassign that pointer.

ExempleExample

complication de l’interface inutilesunnecessary interface complication

bool unregister(std::shared_ptr<event> &e) // C26417, also C26415 SMART_PTR_NOT_NEEDED
{
    return e && events_.erase(e->id());
}

void renew(std::shared_ptr<event> &e)
{
    if (unregister(e))
        e = std::make_shared<event>(e->id());
    // ...
}

ExempleExample

complication interface inutiles - simplifiéeunnecessary interface complication - simplified

bool unregister(const event *e)
{
    return e && events_.erase(e->id());
}

void renew(std::shared_ptr<event> &e)
{
    if (unregister(e.get()))
        e = std::make_shared<event>(e->id());
    // ...
}