Aviso C26415

O parâmetro de ponteiro inteligente é usado apenas para acessar o ponteiro contido. Use T* ou T& em vez disso.

Diretrizes principais do C++: R.30: Use ponteiros inteligentes como parâmetros apenas para expressar explicitamente a semântica do tempo de vida

Usar um tipo de ponteiro inteligente para passar dados para uma função indica que a função de destino precisa gerenciar o tempo de vida do objeto contido. No entanto, suponhamos que a função use apenas o ponteiro inteligente para acessar o objeto contido e nunca realmente chame qualquer código que possa levar à sua desalocação (ou seja, nunca afete sua vida útil). Então, geralmente não há necessidade de complicar a interface com ponteiros inteligentes. É preferível um ponteiro simples ou uma referência ao objeto contido.

Observações

Esta verificação abrange a maioria dos cenários que também causam C26410, C26415, C26417 e C26418. É melhor remover o SMART_PTR_NOT_NEEDED primeiro e, em seguida, alternar para casos extremos para ponteiros partilhados ou exclusivos. Para uma limpeza mais focada, este aviso pode ser desativado.

Além dos modelos padrão std::unqiue_pointer e std::shared_pointer, essa verificação reconhece tipos definidos pelo usuário que provavelmente se destinam a ser ponteiros inteligentes. Espera-se que esses tipos definam as seguintes operações:

• Desreferenciação sobrecarregada ou operadores de acesso de membro que são públicos e não marcados como excluídos.
• Destrutor público que não é eliminado nem definido como padrão, incluindo destrutores que são explicitamente definidos como vazios.

A interpretação das operações que podem afetar a vida útil dos objetos contidos é ampla e inclui:

• Qualquer função que aceite um ponteiro ou parâmetro de referência para um ponteiro inteligente não constante
• Copiar ou mover construtores ou operadores de atribuição
• Funções não constantes

Exemplos

Gestão complicada do ciclo de vida.

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();
}

Gestão do ciclo de vida complicada - reformulada.

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);
    // ...
}