Quelle est la syntaxe de l'expression "requires" d'un modèle variadique avec contraintes ?

Question

Si j'ai un modèle variadique du type ;

template<typename T>
concept Fooable = requires (T t) { t.bar() -> bool; };

struct Foo {
  int big_foo;

  template<std::Integral T, Fooable ... U>
  explicit Foo(T&& i, U&& ... f) noexcept
    : big_foo {std::forward<T>(i)}
  {
    Something::something(std::forward<U>(f)...);
    ...
  }

};

la définition du modèle et de ses contraintes fonctionne comme prévu.

Mais si j'exige plus de contraintes sur Foo et que j'utilise le format d'expression "exige", comme par exemple ;

  template<typename T, typename ... U>
    requires std::Integral<T>
          && Fooable<U> && BillyBobable<U> // WHAT GOES HERE? ELLIPSIS... BUT WHERE?
  explicit Foo(T&& i, U&& ... f) noexcept
    : big_foo {std::forward<T>(i)}
  {
    SOMETHING::something(std::forward<U>(f)...);
    ...
  }

Ensuite : Quelle est la syntaxe à utiliser pour l'expression "variadique" ? U pour l'étendre dans l'expression ?

Answer 1

Vous pouvez utiliser ici la syntaxe habituelle de l'expression de pliage du C++17 :

template<typename T, typename ... U>
  requires std::Integral<T>
        && ((Fooable_concept<U> && BillyBobable_concept<U>) && ...)
explicit Foo(T&& i, U&& ... f) noexcept

Vous pouvez également revenir à votre syntaxe antérieure en introduisant un nouveau concept qui fusionne les deux :

template <typename T>
concept FooAndBillyBob = Fooable_concept<T> && BillyBobable_concept<T>;

template <std::Integral T, FooAndBillyBob ... U>
explicit Foo(T&& i, U&& ... f) noexcept

---

Note : Ne donnez pas de nom à vos concepts *_concept