LG

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
Les concepts servent à forcer des classes à respecter certaines contraintes ou à définir des interfaces.

[[https://omnigoat.github.io/2020/01/19/cpp20-concepts/|https://omnigoat.github.io/2020/01/19/cpp20-concepts/]] {{ :lang:cpp:concept:omni_blogs_2020-02-05_21_56_31_.html |Archive du 19/01/2020 le 05/02/2020}}

====Définitions des concepts====

  * Contrainte sur un type :

<code cpp>
template <typename T>
concept integral = std::is_integral_v<T>;
</code>

  * Contrainte sur les fonctions :

<code cpp>
template <typename T>
// Le type est cv. Donc, il faut utiliser deux paramètres, l'un pour const, l'autre sans.
concept Shape = requires(const T t, T u, float f)
{
  // Le type de retour est facultatif mais conseillé.
  { t.area() } -> std::same_as<float>;
  { u.mod(f) } -> std::same_as<float>;
  // On impose une variable.
  // Elle peut être static / constexpr ou non.
  // Il faut la déclarer comme une référence.
  { t.varr } -> std::same_as<const float&>;
};
</code>

====Application des concepts====
  * Vérification qu'une structure respecte un concept
<code cpp>
struct Rectangle
{
    consteval float area() const {return 1.;}
    consteval float mod(float f) {return f;}
    static constexpr float varr = 2.f;
};
static_assert(Shape<Rectangle>);
</code>

  * Forcer un template à respecter un concept

<code cpp>
template <class T>
requires Shape<T>
class AllFormes
{

};
</code>

  * Cast d'un type vers un concept

<code cpp>
int main()
{
  Rectangle a;
  Shape auto &b = a;
  b.mod();
}
</code>

  * Déclaration d'une fonction dont un des paramètres doit respecter un concept

<code cpp>
void foo(const Concept auto&)
{}
</code>

Et cela va générer un symbole pour chaque type.

====Restriction====

===Fonction template===

Il n'est pas possible de définir un concept avec un template non défini dans le concept.

Exemple:

<code cpp>
struct Goat {
    template<class T>
    void eat(T);
};
</code>

Il n'est pas possible de laisser ''eat'' template. Il faudra définir explicitement chaque surcharge.

[[https://quuxplusone.github.io/blog/2020/08/10/concepts-cant-do-quantifiers/|Concepts can’t do quantifiers]] {{ :lang:cpp:concept:concepts_can_t_do_quantifiers_arthur_o_dwyer_stuff_mostly_about_c_2021-11-13_09_03_00_.html |Archive du 10/08/2020 le 13/11/2021}}

====Migration C++17 vers C++20====

  * Code C++17

<code cpp>
#include <tuple>

template <typename T>
concept bool IShape = requires (T x, T z, int y)
{
   { T() } ;
   { x = z } -> T&;
   { T(x) }  ;
   { x.countSides() } -> int;
   { x.sideLength(y) } -> int;
};

struct Rectangle
{
   Rectangle() {};
   Rectangle(const Rectangle& other) {};
   Rectangle& operator=(Rectangle& other) {return *this; };

   const char * getName() { return "Rectangle"; }
   int countSides() {return 4;}
   int sideLength(int side) { return (side % 2 == 0) ? 10 : 5; }
};

struct Square
{
   Square() {};
   Square(const Square& other) {};
   Square& operator=(Square& other) {return *this; };  

   const char * getName() { return "Square"; }
   int countSides() {return 4;}
   int sideLength(int side) { return 10; }
};

void print(IShape& shape)
{
   for (int side = 0 ; side < shape.countSides() ; ++side )
   {
      //std::cout << shape.getName() << " side=" << shape.sideLength(side) << "\n";
   }
};

int main()
{
   Square square;
   Rectangle rect;
   auto shapes = std::make_tuple(square, rect);
   std::apply([](auto&... shape) { ((print(shape)), ...); }, shapes) ;

   return 0;
};
</code>

  * Code C++20

<code cpp>
#include <concepts>
#include <tuple>

template <typename T>
concept IShape = requires (T x, T z, int y)
{
   { T() } ;
   { x = z } -> std::same_as<T&>;
   { T(x) }  ;
   { x.countSides() } -> std::same_as<int>;
   { x.sideLength(y) } -> std::same_as<int>;
};

struct Rectangle
{
   Rectangle() {};
   Rectangle(const Rectangle& other) {};
   Rectangle& operator=(Rectangle& other) {return *this; };

   const char * getName() { return "Rectangle"; }
   int countSides() {return 4;}
   int sideLength(int side) { return (side % 2 == 0) ? 10 : 5; }
};

struct Square
{
   Square() {};
   Square(const Square& other) {};
   Square& operator=(Square& other) {return *this; };  

   const char * getName() { return "Square"; }
   int countSides() {return 4;}
   int sideLength(int side) { return 10; }
};

void print(IShape auto& shape)
{
   for (int side = 0 ; side < shape.countSides() ; ++side )
   {
      //std::cout << shape.getName() << " side=" << shape.sideLength(side) << "\n";
   }
};

int main()
{
   Square square;
   Rectangle rect;
   auto shapes = std::make_tuple(square, rect);
   std::apply([](auto&... shape) { ((print(shape)), ...); }, shapes) ;

   return 0;
};
</code>