Início / coding / Perguntas / 79496469
Accepted
Muhammad
Asked: 2025-03-10 03:24:17 +0800 CST

ordem de passagem de parâmetros para modelos em conceitos

  • 772

usando o seguinte código

template <typename T>
concept SomeConcept = requires(T t) {
    { t++ } -> std::convertible_to<T>;
};

O conceito SomeConceptgarante que o tipo Ttenha sobrecarregado o operator++(int)e o tipo de resultado seja conversível para T. E std::convertible_to recebe 2 parâmetros, o primeiro é From, e o segundo é To.

Então minha pergunta é: qual parâmetro recebe o resultado da expressão e por quê? E com essa resposta, por que ele Té passado como o outro parâmetro e não o contrário?

Por favor, forneça uma referência adequada para respaldar a resposta, de preferência do rascunho padrão, se possível.

desde já, obrigado

c++

2 respostas

  1. Best Answer

    De cppreference :

    Em uma restrição de tipo , um conceito recebe um argumento de modelo a menos do que sua lista de parâmetros exige, porque o tipo deduzido contextualmente é usado implicitamente como o primeiro argumento do conceito .

    template<class T, class U>
concept Derived = std::is_base_of<U, T>::value;
 
template<Derived<Base> T>
void f(T); // T is constrained by Derived<T, Base>

    Então, mesmo que std::convertible_toaceite dois parâmetros de modelo, o tipo deduzido será usado como o primeiro, que é o Fromparâmetro no seu caso.

    • 3

  2. Vou tentar explicar isso.

    Na expressão { t++ } -> std::convertible_to<T>, o tipo de resultado de t++se torna o Fromparâmetro de std::convertible_to, enquanto Té o Toparâmetro.

    Isso ocorre porque std::convertible_to<From, To>verifica se Frompode ser convertido para To. No nosso caso, queremos verificar se o resultado da operação de incremento pós-fixado (que normalmente é um objeto temporário contendo o valor original) pode ser convertido de volta para o tipo T.

    O conceito padrão std::convertible_to é definido como:

    template<typename From, typename To>
concept convertible_to = 
    is_convertible_v<From, To> &&
    requires { static_cast<To>(declval<From>()); };

    Então, quando escrevemos { t++ } -> std::convertible_to<T>, estamos efetivamente dizendo "o resultado de t++deve ser conversível para T", que é exatamente o que queremos verificar para um operador de incremento pós-fixado bem-comportado.

    Me avise se tiver alguma dúvida sobre minha resposta. Espero ter conseguido ajudar você.

    • 0

relate perguntas