Differences

This shows you the differences between two versions of the page.

--- in204:tds:sujets:td6:part2 [2019/11/03 11:26]
bmonsuez [Question n°3]
+++ in204:tds:sujets:td6:part2 [2022/11/18 10:49] (current)
@@ Line 1: / Line 1: @@
-====== Partie II – Vérifier que les exceptions sont bien capturées.======
+====== Partie II – Spécialisation par contraintes ======
 [[in204:tds:sujets:td6|TD6]]
+===== Question n°1 =====
-L'objet des questions suivantes est de pouvoir vérifier au moment de la compilation que les exceptions sont bien capturées ou bien que seules les exceptions indiquées sont supposées être déclencheés (cf. [[in204:cpp:syntax:exceptions:contract|les annotations relatives aux exceptions]]).
+Nous considérons toujours notre code affichant le contenu d'un conteneur tel que défini dans la [[in204:tds:sujets:td6:part1|première partie]].
-===== Question n°1 =====
+<code cpp>
+template<typename  containerT, typename charT, typename traits = std::char_traits<charT>>
+std::basic_ostream<charT, traits>& operator << (std::basic_ostream<charT, traits>& aStream, const containerT& aContainer)
+{
+    aStream << "{";
+    auto end = aContainer.end();
+    for(auto it = aContainer.begin(); it != end;)
+    {
+        aStream << *it ++;
+        if(it != end)
+            aStream << ", ";
+    }
+    aStream << "}";
+}
+</code>
-L’exception ''division_by_zero'' peut être levée par la fonction ''divide''. Ajouter cette information à la fonction ''divide''.
+==== Question n°1.1 =====
+Déterminer ce qui va caractériser un conteneur pouvant être pris comme argument par la fonction précédente ?
 <hidden Correction>
-Nous considérons que l'exception ''division_by_zero'' n'est plus capturée par la fonction ''divide'' et est propagée aux fonctions appelantes.
+En fait, il est attendu que le conteneur fournisse deux méthodes :
-Dans ce cas nous devons indiquer que la fonction ''divide'' peut générer une exception. Nous avons plusieurs possibilités pour le faire.
+  * `begin()`: retournant un itérateur marquant le début de la séquence,
+  * `end()`: retournant un itérateur marquant le fin de la séquence.
-  * Indiquer que la fonction ''divide'' genére une exception de type ''division_by_zero''.\\ <code cpp>
+L'itérateur qui est retourné doit supporter :
-double divide(double, double) throw(division_by_zero);
+  * l'accès en lecture des données stockées dans le conteneur,
-</code>
+  * le parcours en avant.
-  * Indiquer que la fonction ''divide'' genére une exception sans spécifier laquelle. Dans ce cas, les syntaxes suivantes sont équivalentes\\ <code cpp>
+Il n'a pas besoin de supporter le multipasse.
-double divide(double, double) noexcept(false);
-double divide(double, double) throw(...);
-</code>
+</hidden>
-Ceci nous donne en conséquence les codes suivants pour la méthode ''divide'' :
-<code cpp>
+==== Question n°1.2 =====
-double divide(double theNumerator, double theDivisor) throw(division_by_zero)
-{
-    if(theDivisor == 0)
-        throw division_by_zero();
-    return theNumerator / theDivisor;
-}
-</code>
+Implanter un concept qui permet de formaliser les exigences que vous venez de formuler ?
-Jusqu'à la version C++14, nombreux étaient les compilateur qui considérait que :
+<hidden Correction>
 <code cpp>
-double divide(double, double) throw(division_by_zero);
+template<typename T>
-</code>
+concept Browsable = requires (const T& a)
-était equivalent à :
+{
-<code cpp>
+    { a.begin() } -> std::forward_iterator;
-double divide(double, double) noexcept(false);
+    { a.end() } -> std::forward_iterator;
+};
 </code>
-En fait les compilateur ne vérifiaient pas la nature des exceptions qui étaient capturées. De ce fait, depuis C++17, cette fonctionnalité a été déclarée comme "abandonnées" et désormais il est demandé de déclarer une fonction qui ne lève pas d'exception par : ''noexcept'' ou par ''noexcept(true)'' et une foncion qui lève une exception par soit ''noexcept(false)'' ou ''throw(...')''.
 </hidden>
+==== Question n°1.3 =====
-===== Question n°2 =====
+Ajouter les contraintes à l'opérateur %%<<%% qui a été défini pour un conteineur.
-Compilez votre programme, que constatez-vous ?
 <hidden Correction>
-Nous avons un message relativement à une exception non capturée.
+<code cpp>
+template<typename containerT, typename charT, typename traits = std::char_traits<charT>>
+requires Browsable<containerT>
+std::basic_ostream<charT, traits>& operator << (std::basic_ostream<charT, traits>& aStream, const containerT& aContainer)
+{
+    aStream << "{";
+    auto end = aContainer.end();
+    for(auto it = aContainer.begin(); it != end;)
+    {
+        aStream << *it ++;
+        if(it != end)
+            aStream << ", ";
+    }
+    aStream << "}";
+    return aStream;
+}
+</code>
+</hidden>
-En effet, la fonction ''divide'' génère une exception ''division_by_zero'' et cette exception n'est jamais capturée. Ce qui pose un problème à la compilation.
+==== Question n°1.4 =====
+Introduisez une implantation de l'opérateur `<<` qui pour tout type affiche 'NONE'.
+<hidden Correction>
+<code cpp>
+template<typename T, typename charT, typename traits = std::char_traits<charT>>
+std::basic_ostream<charT, traits>& operator << (std::basic_ostream<charT, traits>& aStream, const T& aContainer)
+{
+    std::cout << "NONE";
+    return aStream;
+}
+</code>
 </hidden>
-===== Question n°3 =====
-Ajoutez les informations complémentaires à votre programme pour pouvoir compiler le programme ?
-<hidden Correction>
+===== Question n°2 ====
-Pour la méthode ''test_divide'', nous devons
-  - modifier la fonction pour qu'elle capture l'excpetion générée par ''divide'',
+Nous avons deux fonctions pour effectuer un tri, l'algorithme simple de tri que nous avons implanté et l'algorithme ``std::sort`` fourni par la STL.
-  - indiquer qu'elle ne génère pas d'exceptions. En conséquence, nous devons lui ajouter un des marquages suivants :
-<code cpp>
-void test_divide() noexcept;
-void test_divide() noexcept(true);
-void test_divide() throw(); // Attention, n'est plus supporté depuis la version C++17.
-</code>
-Ce qui donne pour cette fonction le code suivant :
+Cependant notre algorithme fonctionne pour des itérateurs qui ne supportent pas l'accès indexé tandis que l'algorithme ``std::sort`` est un quicksort et nécessite un accès indexé mais qui est plus rapide.
+Modifier le code de ``std::simple_sort`` pour appeller ``std::sort`` si jamais les itérateurs sont des itérateurs supportant l'accès direct (``std::random_access_iterator``).
+<hidden Correction>
 <code cpp>
-void test_divide() noexcept
+template<typename  iterator>
+void simple_sort(iterator start, iterator end)
+    requires(std::forward_iterator<iterator> && ! std::random_access_iterator<iterator> && std::input_or_output_iterator<iterator>)
 {
-  double i, j;
+    std::cout << "Insertion Sort\n";
-  for(;;) {
+    for(;start != end; start ++)
-    std::cout << "Le numerateur (0 pour arreter): ";
-    std::cin >> i;
-    if(i == 0)
-      break;
-    std::cout << " Le denominateur : ";
-    std::cin >> j;
-    try
     {
-        std::cout << "Resultat: " << divide(i,j) << std::endl;
+        auto it = start; it++;
+        for(;it != end; it ++)
+        {
+            // Compare si les deux elements sont dans le bon ordre.
+            if (*start > *it)
+                std::swap(*start, *it);
+        }
     }
-    catch(division_by_zero anException)
+}
-    {
+template<typename iterator>
-        std::cout << "Erreur: " << anException.what() << std::endl;
+void simple_sort(iterator start, iterator end)
-    }
+    requires(std::random_access_iterator<iterator> && std::input_or_output_iterator<iterator>)
-  }
+{
+    std::cout << "Quicksort\n";
+    return std::sort(start, end);
 }
 </code>
-Nous pouvons désormais marquer la fonction ''main'' comme étant une fonction ne génèrant aucune exception.
+Et nous exécutons le code suivant :
 <code cpp>
-void main() noexcept
 {
-///
+    std::list<int> l = {1, 7, 3, 4, 9, 2, 5};
-}
+    std::vector<int> v(l.begin(), l.end());
+    simple_sort(l.begin(), l.end());
+    std::cout << l << std::endl;
+    simple_sort(v.begin(), v.end());
+    std::cout << v << std::endl;
+</code>
+qui génèrera la sortie suivante:
+<code>
+Insertion Sort
+{1, 2, 3, 4, 5, 7, 9}
+Quicksort
+{1, 2, 3, 4, 5, 7, 9}
 </code>
-et nous obtiendrons une compilation garantissant que toutes les exceptions sont bien capturées.
 </hidden>

Cours

User Tools

Site Tools

Differences

Page Tools