Início / user-1021959

Bernard's questions

Martin Hope
Bernard
Asked: 2024-11-11 22:28:07 +0800 CST
  • 10

Em C++20, subsunção de conceito se refere a um conceito sendo um superconjunto de outro conceito. Por exemplo, no exemplo a seguir, Fooablesubsumes BetterFooable:

template <typename T>
concept Fooable = requires(T& t) {
    t.foo();
};

template <typename T>
concept BetterFooable = Fooable<T> && requires(T& t, int x) {
    t.foo(x);
};

O compilador é capaz de ver que BetterFooableé definido como Fooable e outra coisa e, portanto, qualquer tipo que satisfaça BetterFooabletambém deve necessariamente satisfazer Fooable.

Isso nos permite especializar parcialmente as classes de modelo:

template <Fooable T1>
struct MyStruct1 {};
template <BetterFooable T1>
struct MyStruct1<T1> {};

Entretanto, uma especialização de uma classe com um pacote de parâmetros de modelo parece não ser aceitável nem no GCC nem no Clang, mas aceitável no MSVC ( link godbolt ):

template <Fooable... Ts>
struct MyStruct2 {};

template <BetterFooable... Ts>
struct MyStruct2<Ts...> {};

O erro produzido pelo GCC está abaixo, e o erro produzido pelo Clang é muito semelhante:

<source>:15:8: error: partial specialization 'struct MyStruct2<Ts ...>' does not specialize any template arguments and is not more constrained than the primary template; to define the primary template, remove the template argument list
   15 | struct MyStruct2<Ts...> {};
      |        ^~~~~~~~~~~~~~~~
<source>:12:8: note: primary template here
   12 | struct MyStruct2 {};
      |        ^~~~~~~~~

O GCC e o Clang estão corretos em rejeitar esse código? E há alguma maneira alternativa de expressar a subsunção de conceitos em pacotes de parâmetros de modelo?

c++
Martin Hope
Bernard
Asked: 2024-11-09 23:34:41 +0800 CST
  • 7

Tenho vários std::varianttipos possivelmente repetidos e gostaria de incrementar o índice ativo da variante.

Aqui está um exemplo que demonstra o que eu gostaria de fazer:

template <typename... Ts>
bool update_variant(std::variant<Ts>& v, std::tuple<work_generator<Ts>>& gen) {
    return visit_with_index([&]<size_t Index /* the active index */>(auto& e) {
        if (e.done()) {
            // we are done with e
            constexpr size_t next_index = Index + 1;
            if constexpr (next_index == sizeof...(Ts)) {
                // no more other work to do
                return false;
            } else {
                // still have other work to do so we move on to the next variant alternative
                v.emplace(
                        std::in_place_index_t<next_index>{},
                        std::get<next_index>(gen).create_worker()
                    );
                return true;
            }
        } else {
            // do some work on e, so e gets closer to the done state
            e.do_some_work();
            return true;
        }
    }, v);
}

Para implementar isso, parece que preciso de algo semelhante ao visit_with_indexacima, que me forneça o índice atual como um valor de tempo de compilação.

Além de escrever minha própria versão do visit_with_indexacima, que efetivamente é escrever minha própria versão de std::visit, há alguma maneira mais simples de conseguir o que quero sem realizar mais de uma pesquisa por índice?

c++