Início / coding / Perguntas / 79369634
Accepted
Johan
Asked: 2025-01-20 03:36:42 +0800 CST

O que significa To[1] no conceito é_conversível_sem_estreitamento?

  • 772

O seguinte conceito do C++20 - The Complete Guide (adaptado de http://wg21.link/p0870 ), proíbe conversões de estreitamento. Por exemplo, floatpara int, como em 1.9f→ 1.

template <typename From, typename To>
concept ConvertibleWithoutNarrowing = requires (From&& from) {
  { std::type_identity_t<To[]>{std::forward<From>(from)}} -> std::same_as<To[1]>;
};

O livro usa isso para uma coleção C que não deve ter conversões de restrição ao adicionar dados:

template<typename C, typename T>
requires ConvertsWithoutNarrowing<T, typename C::value_type>
void add(C& collection, const T& val) {…}

// Usage:
std::vector<int> vec_i;
add(vec_i, 1); // OK
add(vec_i, 1.3); // Does not compile.

Entendi a ideia geral por trás do conceito, mas o que o [1]na última parte, std::same_as<To[1]>;, faz?

c++

1 respostas

  1. Best Answer

    TL;DR [1]especifica explicitamente que o tamanho do que arrayestá sendo usado para comparação tem que ser, bem, 1. E usar um array economiza muito trabalho.

    Explicação adicional:

    1. Mas por que usar um arrayem primeiro lugar?

    Restrições C++ no estreitamento do tipo de array

    Ao criar uma matriz, C++ requer que o tipo de elementos usados ​​para inicializar a matriz não envolva nenhuma conversão de estreitamento

    Então se você tentar compilar

    int arr[1] = {1.3};

    Você obterá um erro do tipo narrowing conversion from double to int. A inicialização falha porque você não pode atribuir diretamente um double a um array int sem truncar ou converter explicitamente o valor.

        int x = 10.5; // WARNING: Implicit conversion from 'double' to 'int' changes value from 10.5 to 10
    int y[1] = {10.5}; // ERROR: Type 'double' cannot be narrowed to 'int' in initializer list

    2. Sobre aquele "requisito curto e complicado"

    O conceito fornecido

    { std::type_identity_t<To[]>{std::forward<From>(from)}} -> std::same_as<To[1]>;

    Garante que um valor de tipo Frompode ser convertido para tipo Tosem perder informações (ou seja, nenhuma conversão de estreitamento é permitida). O truque está em alavancar as regras mais rígidas em torno da inicialização de array e conversões de estreitamento para evitar a necessidade de escrever verificações explicitamente para esses casos (por exemplo, integral para ponto flutuante, ponto flutuante para integral).

    Sem ela, seria necessário muito mais envolvimento para atingir um resultado semelhante: esse conceito explodiria em:

    template <typename From, typename To>
concept ConvertibleWithoutNarrowing = requires(From&& from) {
        { static_cast<To>(std::forward<From>(from)) } -> std::convertible_to<To>;
    } &&
    []() constexpr {
        if constexpr (std::is_integral_v<From> && std::is_integral_v<To>) {
            return sizeof(From) <= sizeof(To);
        } else if constexpr (std::is_floating_point_v<From> && std::is_integral_v<To>) {
            return false;
        } else {
            return true;
        }
    }();

    E isso cobre apenas o caso de tipos aritméticos! Para uma implementação equivalente genuína sem depender de restrições de inicialização de array, você precisaria adicionar cada caso de estreitamento possível novamente, manualmente.

    3. Outra maneira de pensar sobre conceitos: eles fazem perguntas sobre tipos

    Uma maneira simples de entender o que o uso ConvertibleWithoutNarrowingfaz é pensar nisso como "fazer" a seguinte pergunta:

    To array[1] = {From}; // Is <- that valid C++?

    A resposta é "sim" se Frompuder ser convertido para To sem estreitamento .

    Para efeito de comparação, uma possível implementação de um conceito que verifica a conversão que permite o estreitamento:

    template <typename From, typename To>
concept ConvertibleWithNarrowing = requires (From&& from) {
    { static_cast<To>(std::forward<From>(from)) } -> std::same_as<To>;
};

    Você pode pensar nesse conceito como "perguntar":

    To x = From; // Is <- that valid C++?

    Agora considere essas "questões" para o caso em que From = doublee To = int:

    1. A verificação ConvertibleWithoutNarrowing falha porque o tipo doublenão pode ser restringido intna lista do inicializador; mas
    2. Verificando se há ConvertibleWithNarrowing passes , pois é permitido restringir doublepara int fora da inicialização de uma lista - ele apenas trunca para um inteiro.
    • 18

relate perguntas