C26415 SMART_PTR_NOT_NEEDEDC26415 SMART_PTR_NOT_NEEDED

« Le paramètre de pointeur intelligent est utilisé uniquement en pointeur de l’accès aux contenus."Smart pointer parameter is used only to access contained pointer. Utilisez T * ou T & à la place. »Use T* or T& instead."

Instructions de base C++: R.30 : prennent des pointeurs intelligents comme paramètres uniquement à la sémantique de la 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 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 en réalité jamais appelle tout code qui peut entraîner la désallocation (jamais affecte 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 entraîne é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 que vous basculez ensuite vers le cas 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 plus axée sur le 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 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 publics 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ée ni par défaut.public destructor which is neither deleted nor defaulted. Cela inclut des destructeurs qui sont définies explicitement vide.This includes destructors which are explicitly defined empty.
    • Interprétation des opérations qui peut affecter la durée de vie des objets contenus est assez large 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;
    • méthodes non constante.non-constant methods. ## ExempleExample gestion de la durée de vie lourdescumbersome 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 lourdes - 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);
    // ...
}