TD6

Créer un projet dans lequel vous définissez intégrer le fichier “simple_sort.hpp” qui contient la fonction de comparaison suivante:

#pragma once
#include<algorithm>
 
template<typename  iterator>
void simple_sort(iterator start, iterator end) 
    requires(std::forward_iterator<iterator> && std::input_or_output_iterator<iterator>)
{
    for(;start != end; start ++)
    {
        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);
        }
    }
}

Déterminer quel type d'itérateur est requis pour effectuer les opérations ?

Ajouter une contrainte imposant que le type passé à la fonction correspond bien au type d'itérateur que vous avez identifié ?

template<typename  iterator>
void simple_sort(iterator start, iterator end) 
    requires(std::forward_iterator<iterator> && std::input_or_output_iterator<iterator>)
{
    std::cout << "Insertion Sort\n";
    for(;start != end; start ++)
    {
        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);
        }
    }
}

Nous supposons ajouter l'opérateur suivant qui liste l'ensemble des éléments d'un containeur:

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 << "}";
} 

Ajouter ce code à votre fichier 'simple_sort.hpp' et puis tester ensuite à la fois la précédente fonction et cette nouvelle fonction avec le code suivant :

#include<list>
#include"simple_sort.hpp"
 
int main() 
{
    std::list<int> v = {1, 7, 3, 4, 9, 2, 5};
    simple_sort(v.begin(), v.end());
    std::cout << v;
    return 0;
}

Dans la question précédente, nous avons définit une nouvelle surcharge de l'opérateur «. En fait, cette surcharge n'est pas optimale, puisqu'il suffit que je définisse un type quelconque non supporté et cela ne fonctionne plus :

#include<list>
#include"sort.hpp"
 
struct Toto {};
int main() 
{
    std::list<int> v = {1, 7, 3, 4, 9, 2, 5};
    simple_sort(v.begin(), v.end());
    std::cout << v;
    std::cout << Toto() << std::endl;
    return 0;
}

Expliquer pourquoi le compilateur génére une erreur ?

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) {...}

Partie 2