Início / coding / Perguntas / 77879143
Accepted
Baruch
Asked: 2024-01-25 18:22:52 +0800 CST

Aviso estranho com função de conversão SFINAE

  • 772

Este é o meu código de exemplo:

#include <type_traits>

template <bool B>
struct S {
    // #1
    // template <bool C = B, class = std::enable_if_t<!C>>
    // operator S<true>() const { return {}; }

    // #2
    // operator S<true>() const { return {}; }
};

int main() {
    S<true> b1;
    S<false> b2;
}

Ao compilar com g++ ( https://godbolt.org/z/P46qE8EGG ), não recebo nenhum aviso se habilito a opção 1, a opção 2 ou ambas. Eu esperaria um aviso de que é uma função de autoconversão quando eu habilitar o número 2, mas talvez o g++ não tenha esse aviso.

O verdadeiro problema é ao compilar com o clang. Recebo os seguintes avisos apenas se ativar o número 1:

erro: a função de conversão que converte 'S' para si mesmo nunca será usada [-Werror,-Wclass-conversion]

A ativação do nº 2 não aciona esse aviso e a desativação da instanciação de um deles b1ou b2não o impede. O que está acontecendo? Isso é um erro no clang?

EDIT: estou me referindo especificamente ao motivo pelo qual o número 1 produz o aviso. A outra informação pretendia mostrar minhas tentativas de tentar restringir o problema a um exemplo funcional menor

c++

1 respostas

  1. Best Answer

    Eu esperaria um aviso de que é uma função de autoconversão quando eu habilitar o número 2, mas talvez o g++ não tenha esse aviso.

    Correto, pode-se esperar avisos do compilador (melhores práticas não padrão), mas não há garantia de que um determinado compilador os forneça.

    A ativação do nº 2 não aciona esse aviso e a desativação da instanciação de b1 ou b2 não o impede. O que está acontecendo? Isso é um erro no clang?

    Clang está correto em não avisar #2, pois pode ser invocado, mostrado mais facilmente em um exemplo com definições excluídas:

    template <bool B>
struct S {  
    // #2
    operator S<true>() const = delete;
};

int main() {
    S<false> const b1;
    S<true> b2 = b1;  // error: call to a deleted function
}

    Por que? Como o construtor de cópia implícito copia

    S<true>  -> S<true>
S<false> -> S<false>

    enquanto, no entanto, S<false>into S<true>não é uma operação de cópia no mesmo sentido.

    O construtor do modelo também está presente quando a classe "copiar de" é S<false>, então Clang pode parecer, à primeira vista, alertar incorretamente que esta função nunca será usada:

    #include <type_traits>

template <bool B>
struct S {
    // #1 - warning: -Wclass-conversion
    template <bool C = B, class = std::enable_if_t<!C>>
    operator S<true>() const = delete;
};

int main() {
    S<false> const b1;
    S<true> b2 = b1;  // error: deleted function
}

    No entanto, Clang provavelmente não é inteligente o suficiente para analisar o SFINAE, e podemos ver que a construção SFINAE é uma pista falsa para quando ou não o aviso é emitido, pois obtemos o mesmo diagnóstico no seguinte caso:

    template <bool B>
struct S {
    // #1 - warning: -Wclass-conversion
    template <typename Dummy = void>
    operator S<true>() const = delete;
};

int main() {
    S<false> const b1;
    S<true> b2 = b1;  // error: deleted function
}

    Percebemos que o Clang emite avisos para quando instanciamos S<true>, caso em que é realmente verdade: a função nunca será invocada.

    template <bool B>
struct S {
    // #1
    template <typename Dummy = void>
    operator S<true>() const = delete;
};

S<false> sf{}; // correct: no warning emitted for #1
S<true>  st{}; // correct: warning emitted for #1

    Neste ponto, podemos nos perguntar por que ele não emite um aviso para #1. Pode ser que uma função de modelo ( #1) esteja um degrau abaixo na resolução de sobrecarga, ou que a análise da função não-modelo não dependente ( #2) aconteça apenas uma vez, independente de incluir as instanciações das especializações de modelo de classe.

    Se tivermos certeza de que a função nunca será convertida para si mesma em nenhuma instanciação, os avisos, como esperado, desaparecerão:

    template <bool B>
struct S {
    // #1
    template <typename Dummy = void>
    operator S<!B>() const = delete;
};

S<false> sf{}; // no warning emitted for #1
S<true>  st{}; // no warning emitted for #1

    Eu não ficaria surpreso se Clang rejeitasse um relatório de bug para este problema, já que o aviso é preciso para a especialização que ele sinaliza, a menos que algum esforço heróico seja feito para entender quando e quando uma determinada função de modelo não é SFINAE:d ou não.

    • 4

relate perguntas