C++, Qt, OpenGL, CUDA

Outils d'utilisateurs

Outils du Site

Vous êtes ici: C++, Qt, OpenGL, CUDA » Les catégories d'algorithmes standards
rechercher

Différences

Cette page vous donne les différences entre la révision choisie et la version actuelle de la page.

Lien vers cette vue

rechercher [2016/01/14 18:56]
gbdivers 		rechercher [2017/01/16 19:27] (Version actuelle)
gbdivers
Ligne 1: Ligne 1:
  
-^ Chapitre précédent ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ Chapitre suivant ^+^ [[comparer|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[iterateurs|Chapitre suivant]] ^
  
  
Ligne 17: Ligne 17:
 ===== Les algorithmes non modifiants ===== ===== Les algorithmes non modifiants =====
  
-Les algorithmes non modifiants (//non-modifying sequence operations//). Ce sont des algorithmes qui ne modifient pas les collections sur les quelles ils sont utilisés. Vous allez trouvé dans cette catégorie par exemple l'algorithme d'égalité ''std::equal'' que vous avez déjà vu, ainsi que les algorithmes de recherche (en premier lieu ''std::find''), les algorithmes de comptage (''std::count'') et l'algorithme ''std::for_each'' (qui permet d'appeler une fonction sur chaque élément d'une collection).+Les algorithmes non modifiants (//non-modifying sequence operations//). Ce sont des algorithmes qui ne modifient pas les collections sur les quelles ils sont utilisés. Vous allez trouver dans cette catégorie par exemple l'algorithme d'égalité ''std::equal'' que vous avez déjà vu, ainsi que les algorithmes de recherche (en premier lieu ''std::find''), les algorithmes de comptage (''std::count'') et l'algorithme ''std::for_each'' (qui permet d'appeler une fonction sur chaque élément d'une collection).
  
-Un algorithme non modifiants va donc prendre une collection sans la modifier et retourner un résultat. La valeur retournée peut être utiliser directement ou enregistrée dans une variable, comme n'importe quelle valeur. Le type de la valeur retournée dépend de l’algorithme et du type de collection, le plus simple est d'utiliser l’inférence de type pour créer une variable (consulter la documentation pour connaitre le type exact).+Un algorithme non modifiants va donc prendre une collection sans la modifier et retourner un résultat. La valeur retournée peut être utilisée directement ou enregistrée dans une variable, comme n'importe quelle valeur. Le type de la valeur retournée dépend de l’algorithme et du type de collection, le plus simple est d'utiliser l’inférence de type pour créer une variable (consulter la documentation pour connaitre le type exact).
  
 <note>Les exemples de code suivants utilisent une chaîne, pour simplifier l’écriture du code et l'affichage du résultat. N'oubliez pas qu'une chaîne est une collection de caractères.</note> <note>Les exemples de code suivants utilisent une chaîne, pour simplifier l’écriture du code et l'affichage du résultat. N'oubliez pas qu'une chaîne est une collection de caractères.</note>
Ligne 54: Ligne 54:
  
  
-==== std::all_of, std::any_of et std::none_of ====+==== std::count et std::count_if ====
  
-Les algorithmes [[http://en.cppreference.com/w/cpp/algorithm/count|std::count et std::count_if]] permettent le nombre d’éléments d'une collection correspondant respectivement a une valeur et un prédicat. Ces algorithmes retournent une valeur entière signée.+Les algorithmes [[http://en.cppreference.com/w/cpp/algorithm/count|std::count et std::count_if]] retournent le nombre d’éléments d'une collection correspondant respectivement à une valeur et un prédicat. Ces algorithmes retournent une valeur entière signée.
  
 <code cpp main.cpp> <code cpp main.cpp>
Ligne 81: Ligne 81:
 ==== std::equal ==== ==== std::equal ====
  
-Et bien sur, vous avez déjà vu l'algorithme [[http://en.cppreference.com/w/cpp/algorithm/equal|std::equal]].+Et bien sûr, vous avez déjà vu l'algorithme [[http://en.cppreference.com/w/cpp/algorithm/equal|std::equal]].
  
 <code cpp main.cpp> <code cpp main.cpp>
Ligne 143: Ligne 143:
     std::string s4       { "........................................" };     std::string s4       { "........................................" };
          
-    std::copy(begin(s1), end(s1), begin(s2));+    std::copy(cbegin(s1), cend(s1), begin(s2));
     std::cout << s2 << std::endl;     std::cout << s2 << std::endl;
          
-    std::copy_if(begin(s1), end(s1), begin(s3), isalpha);+    std::copy_if(cbegin(s1), cend(s1), begin(s3), isalpha);
     std::cout << s3 << std::endl;     std::cout << s3 << std::endl;
          
-    std::copy_n(begin(s1), 10, begin(s4));+    std::copy_n(cbegin(s1), 10, begin(s4));
     std::cout << s4 << std::endl;     std::cout << s4 << std::endl;
 } }
Ligne 261: Ligne 261:
 #include <functional> #include <functional>
 #include <algorithm> #include <algorithm>
 +#include <vector>
    
 int main() { int main() {
Ligne 266: Ligne 267:
     const std::vector<int> v2 { -1, 2, -1, 2 };     const std::vector<int> v2 { -1, 2, -1, 2 };
     std::transform(begin(v1), end(v1), begin(v2), begin(v1), std::multiplies<int>());     std::transform(begin(v1), end(v1), begin(v2), begin(v1), std::multiplies<int>());
-    for (auto i: v1) std::cout << i << ' '; std::cout << std::endl;+    for (auto i: v1) std::cout << i << ' '; 
 +    std::cout << std::endl;
 } }
 </code> </code>
Ligne 588: Ligne 590:
  
 Les algorithmes sur les ensembles (//set operations//) permettent de manipuler une collection comme un ensemble d’éléments (donc sans élément en double). Les algorithmes sur les ensembles (//set operations//) permettent de manipuler une collection comme un ensemble d’éléments (donc sans élément en double).
 +
 +
  
  
Ligne 598: Ligne 602:
  
 Les **algorithmes minimum/maximum** permettent de recherche des éléments minimum ou maximum et réaliser des permutations. Les **algorithmes minimum/maximum** permettent de recherche des éléments minimum ou maximum et réaliser des permutations.
 +
 +
  
  
Ligne 604: Ligne 610:
 Les **algorithmes numériques** (//numeric operations//) permettent de travailler sur des collections de nombres. Les **algorithmes numériques** (//numeric operations//) permettent de travailler sur des collections de nombres.
  
-^ Chapitre précédent ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ Chapitre suivant ^+ 
 +<code cpp main.cpp> 
 +#include <iostream> 
 +#include <algorithm> 
 +#include <vector> 
 +#include <numeric> 
 + 
 +int main() { 
 +    std::vector<int> v1(5); 
 +    std::iota(begin(v1), end(v1), 0); 
 +    for(const auto i: v1) { std::cout << i << ' '; } std::cout << std::endl; 
 +     
 +    std::cout << std::accumulate(begin(v1), end(v1), 0) << std::endl; 
 +     
 +    const std::vector<int> v2 = { 2, 3, 4, 0, 1 }; 
 +    std::cout << std::inner_product(begin(v1), end(v1), begin(v2), 0) << std::endl; 
 +    // = 0 * 2 + 1 * 3 + 2 * 4 + 3 * 0 + 4 * 1 
 +     
 +    std::vector<int> v3(v2.size()); 
 +    std::adjacent_difference(begin(v1), end(v1), begin(v3)); 
 +    for(const auto i: v3) { std::cout << i << ' '; } std::cout << std::endl;    
 +     
 +    std::vector<int> v4 { v2 }; 
 +    std::adjacent_difference(begin(v4), end(v4), begin(v4)); 
 +    for(const auto i: v4) { std::cout << i << ' '; } std::cout << std::endl;    
 +} 
 +</code> 
 + 
 +affiche : 
 + 
 +<code> 
 +0 1 2 3 4  
 +10 
 +15 
 +0 1 1 1 1  
 +2 1 1 -4 1  
 +</code> 
 + 
 + 
 +^ [[comparer|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[iterateurs|Chapitre suivant]] ^ 
rechercher.1452794169.txt.gz · Dernière modification: 2016/01/14 18:56 par gbdivers

Outils de la Page

Sauf mention contraire, le contenu de ce wiki est placé sous la licence suivante : CC Attribution-Noncommercial-Share Alike 3.0 Unported
CC Attribution-Noncommercial-Share Alike 3.0 Unported Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki