C26415 SMART_PTR_NOT_NEEDEDC26415 SMART_PTR_NOT_NEEDED

« Paramètre de pointeur intelligent est utilisé uniquement pour le pointeur d’accès contenues."Smart pointer parameter is used only to access contained pointer. Utilisez T * ou T & à la place. »Use T* or T& instead."

C++ Core Guidelines: R.30 : prennent des pointeurs intelligents comme paramètres uniquement à la sémantique de durée de vie explicitement expressC++ Core Guidelines: R.30: Take smart pointers as parameters only to explicitly express lifetime semantics

À l’aide d’un type pointeur intelligent pour passer des données à une fonction indique que la fonction cible doit gérer la durée de vie de l’objet de relation contenant-contenu.Using a smart pointer type to pass data to a function indicates that the target function needs to manage the lifetime of the contained object. Toutefois, si la fonction utilise uniquement le pointeur intelligent pour accéder à l’objet de relation contenant-contenu et qu’elle appelle en fait jamais tout code qui peut-être entraîner sa désallocation (jamais affectent sa durée de vie), il n’est généralement aucun nécessaire de compliquer l’interface avec des pointeurs intelligents.However, if the function only uses the smart pointer to access the contained object and never actually calls any code which may lead to its deallocation (never affect its lifetime), there is usually no need to complicate the interface with smart pointers. Un pointeur brut ou une référence à l’objet de relation contenant-contenu doit être préféré.A plain pointer or reference to the contained object should be preferred.

NotesRemarks

  • Cette vérification est couvre la majorité des scénarios qui provoque également C26410, C26415, C26417 et C26418.This check is a covers majority of scenarios that also causes C26410, C26415, C26417, and C26418. Il est préférable de nettoyage SMART_PTR_NOT_NEEDED tout d’abord et ensuite basculer vers la périphérie pour les pointeurs partagés ou uniques.It is better to cleanup SMART_PTR_NOT_NEEDED first and then switch to edge cases for shared or unique pointers. Pour vous êtes davantage intéressé nettoyage cela avertissement peut être désactivé.For more focused cleanup this warning can be disabled.
    • Outre les std::unqiue_pointer standard et les modèles de std::shared_pointer, cette vérification reconnaît les types définis par l’utilisateur qui sont probablement destinés à être des pointeurs intelligents.In addition to the standard std::unqiue_pointer and std::shared_pointer templates, this check recognizes user defined types which are likely intended to be smart pointers. Ces types sont attendus pour définir les opérations suivantes :Such types are expected to define the following operations:
    • surchargé déréférencer ou opérateurs d’accès au membre, qui sont publiques et non marquée comme étant supprimé ;overloaded dereference or member access operators, that are public and not marked as deleted;
    • destructeur public qui n’est ni supprimé ni une valeur par défaut.public destructor which is neither deleted nor defaulted. Cela inclut des destructeurs qui sont explicitement définies vide.This includes destructors which are explicitly defined empty.
    • Interprétation des opérations qui peut affecter la durée de vie des objets de relation contenant-contenus est très vaste et inclut :Interpretation of the operations that can affect lifetime of contained objects is quite broad and includes:
    • n’importe quelle fonction qui accepte un paramètre pointeur ou référence à un pointeur intelligent non constante ;any function which accepts pointer or reference parameter to a non-constant smart pointer;
    • copier ou déplacer des constructeurs ou opérateurs d’assignation ;copy or move constructors or assignment operators;
    • fonctions non constante.non-constant functions. ## ExempleExample gestion de la durée de vie fastidieusecumbersome lifetime management
bool set_initial_message(
            const std::unique_ptr<message> &m) // C26415, also C26410 NO_REF_TO_CONST_UNIQUE_PTR
{
    if (!m || initial_message_)
        return false;

    initial_message_.reset(m.get());
    return true;
}

void pass_message(const message_info &info)
{
    auto m = std::make_unique<message>(info);
    const auto release = set_initial_message(m);
    // ...
    if (release)
        m.release();
}

ExempleExample

gestion de la durée de vie fastidieuse - retravailléecumbersome lifetime management - reworked

void set_initial_message(std::shared_ptr<message> m) noexcept
{
    if (m && !initial_message_)
        initial_message_ = std::move(m);
}

void pass_message(const message_info &info)
{
    auto m = std::make_shared<message>(info);
    set_initial_message(m);
    // ...
}