C++, Qt, OpenGL, CUDA

Outils d'utilisateurs

Outils du Site

Vous êtes ici: C++, Qt, OpenGL, CUDA » Aide mémoire sur la syntaxe du C++
aide_memoire_syntaxe

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

aide_memoire_syntaxe [2019/01/03 20:44]
nico [for] 		aide_memoire_syntaxe [2019/01/03 20:58] (Version actuelle)
nico [Fichier header]
Ligne 411: Ligne 411:
 ==== Fichier header ==== ==== Fichier header ====
  
 +<code cpp>
 // dans mon_fichier.h // dans mon_fichier.h
 #ifndef MONFICHIER_H #ifndef MONFICHIER_H
Ligne 430: Ligne 431:
     std::cout << "Salut tout le monde !" << std::endl;     std::cout << "Salut tout le monde !" << std::endl;
 }  } 
 +</code>
  
 ===== Les fonctions ===== ===== Les fonctions =====
Ligne 436: Ligne 437:
 ==== Précisions sémantiques ==== ==== Précisions sémantiques ====
  
 +<code cpp>
 void f(int i) {} // i est un paramètre void f(int i) {} // i est un paramètre
 f(j); // j est un argument f(j); // j est un argument
Ligne 452: Ligne 454:
     // la fonction const et non const n'ont pas les mêmes signatures     // la fonction const et non const n'ont pas les mêmes signatures
 // static ? Inline ? // static ? Inline ?
 +</code>
 +
 4.2.  Déclaration d'une fonction 4.2.  Déclaration d'une fonction
 +
 +<code cpp>
 void f(); // sans paramètre de retour void f(); // sans paramètre de retour
  
Ligne 468: Ligne 474:
  
 void* f(); // retourne un pointeur void* f(); // retourne un pointeur
 +</code>
 ==== Passage de paramètres ==== ==== Passage de paramètres ====
  
Ligne 892: Ligne 898:
 === Les algorithmes non modifiant === === Les algorithmes non modifiant ===
  
 +<code cpp>
 10.2.1.1.  foreach 10.2.1.1.  foreach
  
Ligne 915: Ligne 922:
  
 10.2.1.12.  search_n 10.2.1.12.  search_n
 +</code>
  
-10.2.2.  Les algorithmes modifiants+===Les algorithmes modifiants=== 
 + 
 +<code cpp>
 10.2.2.1.  transform 10.2.2.1.  transform
  
Ligne 966: Ligne 976:
  
 10.2.2.25.  random_shuffle 10.2.2.25.  random_shuffle
 +</code>
  
 == C++11 == == C++11 ==
 +<code cpp>
 bool all_of(Iter first, Iter last, Pred pred)  bool all_of(Iter first, Iter last, Pred pred) 
 bool any_of(Iter first, Iter last, Pred pred)  bool any_of(Iter first, Iter last, Pred pred) 
 bool none_of(Iter first, Iter last, Pred pred)  bool none_of(Iter first, Iter last, Pred pred) 
 +
 Iter find_if_not(Iter first, Iter last, Pred pred)  Iter find_if_not(Iter first, Iter last, Pred pred) 
 +
 OutIter copy_if(InIter first, InIter last, OutIter result, Pred pred) OutIter copy_if(InIter first, InIter last, OutIter result, Pred pred)
 OutIter copy_n(InIter first, Size n, OutIter result)  OutIter copy_n(InIter first, Size n, OutIter result) 
 +
 uninitialized_copy_n(InIter first, Size n, OutIter result) uninitialized_copy_n(InIter first, Size n, OutIter result)
 +
 OutIter move(InIter first, InIter last, OutIter result) OutIter move(InIter first, InIter last, OutIter result)
-OutIter move_backward(InIter first, InIter last, result) s +OutIter move_backward(InIter first, InIter last, result)  
-is_partitioned(InIter first, InIter last, Pred pred) + 
 +sis_partitioned(InIter first, InIter last, Pred pred)  
 pair<OutIter1, OutIter2> partition_copy(InIter first, InIter last, OutIter1 out_true, OutIter2 out_false, Pred pred) pair<OutIter1, OutIter2> partition_copy(InIter first, InIter last, OutIter1 out_true, OutIter2 out_false, Pred pred)
 +
 Iter partition_point(Iter first, Iter last, Pred pred)  Iter partition_point(Iter first, Iter last, Pred pred) 
 +
 RAIter partial_sort_copy(InIter first, InIter last, RAIter result_first, RAIter result_last)  RAIter partial_sort_copy(InIter first, InIter last, RAIter result_first, RAIter result_last) 
 RAIter partial_sort_copy(InIter first, InIter last, RAIter result_first, RAIter result_last, Compare comp) RAIter partial_sort_copy(InIter first, InIter last, RAIter result_first, RAIter result_last, Compare comp)
 +
 bool is_sorted(Iter first, Iter last) bool is_sorted(Iter first, Iter last)
 bool is_sorted(Iter first, Iter last, Compare comp)  bool is_sorted(Iter first, Iter last, Compare comp) 
 +
 Iter is_sorted_until(Iter first, Iter last) Iter is_sorted_until(Iter first, Iter last)
 Iter is_sorted_until(Iter first, Iter last, Compare comp)  Iter is_sorted_until(Iter first, Iter last, Compare comp) 
 +
 bool is_heap(Iter first, Iter last) Vrai si [first, last)  bool is_heap(Iter first, Iter last) Vrai si [first, last) 
 bool is_heap(Iter first, Iter last, Compare comp) bool is_heap(Iter first, Iter last, Compare comp)
 +
 Iter is_heap_until(Iter first, Iter last)  Iter is_heap_until(Iter first, Iter last) 
 Iter is_heap_until(Iter first, Iter last, Compare comp)  Iter is_heap_until(Iter first, Iter last, Compare comp) 
 +
 T min(initializer_list<T> t) T min(initializer_list<T> t)
 T min(initializer_list<T> t, Compare comp) T min(initializer_list<T> t, Compare comp)
 T max(initializer_list<T> t) T max(initializer_list<T> t)
 T max(initializer_list<T> t, Compare comp) T max(initializer_list<T> t, Compare comp)
 +
 pair<const T&, const T&> minmax(const T& a, const T& b) pair<const T&, const T&> minmax(const T& a, const T& b)
 pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp)  pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp) 
Ligne 1001: Ligne 1026:
 pair<Iter, Iter> minmax_element(Iter first, Iter last) pair<Iter, Iter> minmax_element(Iter first, Iter last)
 pair<Iter, Iter> minmax_element(Iter first, Iter last, Compare comp) pair<Iter, Iter> minmax_element(Iter first, Iter last, Compare comp)
 +
 void iota(Iter first, Iter last, T value) void iota(Iter first, Iter last, T value)
 +</code>
 10.3.  Iterateurs et allocateurs 10.3.  Iterateurs et allocateurs
  
Ligne 1008: Ligne 1035:
 === Opérations sur les caractères === === Opérations sur les caractères ===
  
 +<code cpp>
 Char c = ' '; Char c = ' ';
 bool t = isspace(c); // test si est une espace bool t = isspace(c); // test si est une espace
 bool t = isdigit(c); // test si est un chiffre bool t = isdigit(c); // test si est un chiffre
 bool t = isalpha(c); // test si est une lettre bool t = isalpha(c); // test si est une lettre
 +</code>
  
 === Manipuler les chaînes de caractères === === Manipuler les chaînes de caractères ===
  
 +<code cpp>
 bool t = isalnum(c); // test si est un chiffre ou une lettre bool t = isalnum(c); // test si est un chiffre ou une lettre
 string s; string s;
 s = "une chaine de caractères"; s = "une chaine de caractères";
 string s2 = "une autre chaine"; string s2 = "une autre chaine";
-10.4.3.  manipuler les chaînes style C+</code> 
 + 
 +=== manipuler les chaînes style C === 
 + 
 +<code cpp>
 strlen() strlen()
 strcpy() strcpy()
 strcmp() strcmp()
 +</code>
 ==== Les flux ==== ==== Les flux ====
  
 === Flux de sortie === === Flux de sortie ===
  
 +<code cpp>
 cout << "un message" << endl; cout << "un message" << endl;
 cerr << "une erreur" << endl; cerr << "une erreur" << endl;
 clog << "une information" << endl; clog << "une information" << endl;
 +</code>
  
 === Flux d'entrée === === Flux d'entrée ===
  
 +<code cpp>
 cin >> i; // lecture cin >> i; // lecture
 char c; char c;
 cin.get(c); cin.get(c);
 +</code>
  
 === Flux sur les chaines de caractères === === Flux sur les chaines de caractères ===
  
 +<code cpp>
 #include <sstream> #include <sstream>
 istream* input; istream* input;
 input = new istringstream(argv[1]) ; input = new istringstream(argv[1]) ;
 +</code>
  
 === Flux sur les fichiers === === Flux sur les fichiers ===
  
 +<code cpp>
 ifstream ifstream
 +</code>
  
 ===== Les fonctions numériques ==== ===== Les fonctions numériques ====
  
 +<code cpp>
 fsqrt() fsqrt()
 +</code>
  
 ===== A trier ===== ===== A trier =====
  
 +<code cpp>
 typeid(int); // évaluation à la compilation typeid(int); // évaluation à la compilation
 typeid(a); // évaluation à l'éxécution typeid(a); // évaluation à l'éxécution
 extern extern
 namespace namespace
 +</code>
aide_memoire_syntaxe.1546544693.txt.gz · Dernière modification: 2019/01/03 20:44 par nico

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