Início / coding / Perguntas / 79422181
Accepted
Fedor
Asked: 2025-02-08 05:17:43 +0800 CST

Contando o número de valores presentes em uma matriz de opcionais com std::ranges

  • 772

Meu colega porta um programa C++ com intervalos no macOS e observa um erro de compilação inesperado.

Após a simplificação máxima, o programa de exemplo fica assim:

#include <optional>
#include <algorithm>

int main() {
    std::optional<int> ops[4];
    //...
    return (int)std::ranges::count_if( ops, &std::optional<int>::has_value );
};

O GCC e o MSVC funcionam bem com o programa, mas o Clang exibe um longo erro:

 error: no matching function for call to object of type 'const __count_if::__fn'
    7 |     return (int)std::ranges::count_if( ops, &std::optional<int>::has_value );
      |                 ^~~~~~~~~~~~~~~~~~~~~
/opt/compiler-explorer/clang-19.1.0/bin/../include/c++/v1/__algorithm/ranges_count_if.h:62:3: note: candidate template ignored: constraints not satisfied [with _Range = std::optional<int> (&)[4], _Proj = identity, _Predicate = bool (std::__optional_storage_base<int>::*)() const noexcept]
   62 |   operator()(_Range&& __r, _Predicate __pred, _Proj __proj = {}) const {
      |   ^
/opt/compiler-explorer/clang-19.1.0/bin/../include/c++/v1/__algorithm/ranges_count_if.h:60:13: note: because 'indirect_unary_predicate<_Bool (std::__optional_storage_base<int>::*)() const noexcept, projected<iterator_t<optional<int> (&)[4]>, identity> >' evaluated to false
   60 |             indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Predicate>
      |             ^
/opt/compiler-explorer/clang-19.1.0/bin/../include/c++/v1/__iterator/concepts.h:191:60: note: because 'predicate<_Bool (std::__optional_storage_base<int>::*&)() const noexcept, iter_value_t<__type> &>' evaluated to false
  191 |     indirectly_readable<_It> && copy_constructible<_Fp> && predicate<_Fp&, iter_value_t<_It>&> &&
      |                                                            ^
/opt/compiler-explorer/clang-19.1.0/bin/../include/c++/v1/__concepts/predicate.h:28:21: note: because 'regular_invocable<_Bool (std::__optional_storage_base<int>::*&)() const noexcept, std::optional<int> &>' evaluated to false
   28 | concept predicate = regular_invocable<_Fn, _Args...> && __boolean_testable<invoke_result_t<_Fn, _Args...>>;
      |                     ^
/opt/compiler-explorer/clang-19.1.0/bin/../include/c++/v1/__concepts/invocable.h:34:29: note: because 'invocable<_Bool (std::__optional_storage_base<int>::*&)() const noexcept, std::optional<int> &>' evaluated to false
   34 | concept regular_invocable = invocable<_Fn, _Args...>;
      |                             ^
/opt/compiler-explorer/clang-19.1.0/bin/../include/c++/v1/__concepts/invocable.h:28:3: note: because 'std::invoke(std::forward<_Fn>(__fn), std::forward<_Args>(__args)...)' would be invalid: no matching function for call to 'invoke'
   28 |   std::invoke(std::forward<_Fn>(__fn), std::forward<_Args>(__args)...); // not required to be equality preserving
      |   ^
/opt/compiler-explorer/clang-19.1.0/bin/../include/c++/v1/__algorithm/ranges_count_if.h:54:3: note: candidate function template not viable: requires at least 3 arguments, but 2 were provided
   54 |   operator()(_Iter __first, _Sent __last, _Predicate __pred, _Proj __proj = {}) const {
      |   ^          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Demonstração online: https://gcc.godbolt.org/z/no55zPzGz

Não entendi o que há de errado com o programa?

c++

1 respostas

  1. Best Answer

    O que você está fazendo é tecnicamente UB e pode falhar — não há garantia de que usar ponteiros para funções de membro de classes de biblioteca padrão como essa realmente funcione. Para libc++, não funciona.

    Concretamente, a questão recebe uma hierarquia como:

    struct B { bool has_value() const; }
struct D : B { };

    O tipo de &B::has_valueé obviamente um bool (B::*)() const. Mas o tipo de &D::has_value... também é a mesma coisa. Pessoalmente, acho que é um defeito de linguagem e deveria lhe dar um bool (D::*)() constjá que foi isso que você pediu — mas isso provavelmente não pode ser mudado agora, e essas são as regras.

    Agora, para libstdc++ e MSVCSTL, &std::optional<int>::has_valuedá a você um bool (std::optional<int>::*)() constporque eles aparentemente implementam essa função membro diretamente. Mas para libc++, eles aparentemente implementam seu optionalum pouco, mas diferentemente... então o ponto membro que você obtém de volta é, na verdade, um bool (std::__optional_storage_base<int>::*)() const. Bem, também noexcept, mas isso não importa.

    Agora você pode pensar que isso não importa — afinal, você pode invocar funções de membro de classe base sem problemas, certo? Você pode. A menos que seja uma base privada. O que, neste caso, é.

    Em forma reduzida, libstdc++ e MSVCSTL se parecem com isto:

    template <class T> struct optional { bool has_value() const; };

    Enquanto libc++ se parece com isto:

    template <class T> struct optional_base { bool has_value() const; };
template <class T> struct optional : private optional_base<T> {
  using optional_base<T>::has_value;
};

    O resultado é que, embora o.has_value()funcione para todas as implementações, tentar usar &optional<int>::has_valuefor libc++ não é invocável porque você obtém um ponteiro para uma função de classe base privada.

    Aliás, uma das razões pelas quais seria ótimo se ponteiros para membros fossem invocáveis ​​é a qualidade das mensagens de erro.

    Considerar:

    template <class F, class T>
concept invocable = requires (F f, T t) {
    #if DIRECT
    (t.*f)();
    #else
    std::invoke(f, t);
    #endif
};

static_assert(invocable<decltype(&std::optional<int>::has_value), std::optional<int>>);

    No clang, esse conceito falha de qualquer forma, já que está verificando a mesma coisa de qualquer forma. Mas a qualidade do erro é bem diferente. Com std::invoke:

    <source>:7:5: note: because 'std::invoke(f, t)' would be invalid: no matching function for call to 'invoke'
    7 |     std::invoke(f, t);
      |     ^

    Com (t.*f)():

    <source>:7:7: note: because '(t .* f)()' would be invalid: cannot cast 'std::optional<int>' to its private base class 'std::__optional_storage_base<int>'
    7 |     (t.*f)();
      |       ^

    A disparidade do gcc é similar (embora você tenha que fazer fconcepts-diagnostics-depth=2). Com a invocação direta, você obtém um diagnóstico sobre a classe base estar inacessível. Com invokevocê obtém... nada.

    O que você prefere ver?

    • 13

relate perguntas