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/01 20:11]
nico [Les directives d'inclusion] 		aide_memoire_syntaxe [2019/01/03 20:58] (Version actuelle)
nico [Fichier header]
Ligne 322: Ligne 322:
 extern int& r2; // ok, initialisation ailleurs extern int& r2; // ok, initialisation ailleurs
 </code> </code>
 +
 Intialisation avec une litérrale : Intialisation avec une litérrale :
 +
 <code cpp> <code cpp>
 int& r3 = 123; // erreur int& r3 = 123; // erreur
 const int& r3 = 123; // Ok, lvalue const int& r3 = 123; // Ok, lvalue
 </code> </code>
 +
 2.9.  Les tableaux 2.9.  Les tableaux
 Les tableaux à une dimension Les tableaux à une dimension
 +
 <code cpp> <code cpp>
 int a1[10]; int a1[10];
Ligne 335: Ligne 339:
 int a3[8] = { 1, 2, 3, 4 }; // ajout de 4 éléments 0 à la fin int a3[8] = { 1, 2, 3, 4 }; // ajout de 4 éléments 0 à la fin
 </code> </code>
 +
 Pointeur sur tableau Pointeur sur tableau
 +
 <code cpp> <code cpp>
 int v[] = { 1, 2, 3, 4 }; int v[] = { 1, 2, 3, 4 };
Ligne 346: Ligne 352:
 int d = &v[2] - &v[0]; // d = 2 int d = &v[2] - &v[0]; // d = 2
 </code> </code>
 +
 Parcourir un tableau Parcourir un tableau
 +
 <code cpp> <code cpp>
 int v[] = { 1, 2, 3, 4 }; int v[] = { 1, 2, 3, 4 };
Ligne 352: Ligne 360:
 for (int* p = &v[0]; p != &v[4]; ++p) { int x = *p; } for (int* p = &v[0]; p != &v[4]; ++p) { int x = *p; }
 </code> </code>
 +
 Les tableaux à N dimensions Les tableaux à N dimensions
 +
 <code cpp> <code cpp>
 int a2[15][20]; int a2[15][20];
 </code> </code>
 +
 Tableaux dynamiques Tableaux dynamiques
 +
 <code cpp> <code cpp>
 int* pi; int* pi;
Ligne 364: Ligne 376:
 delete[] table; delete[] table;
 </code> </code>
 +
 2.10.  Les espaces de nom 2.10.  Les espaces de nom
 +
 <code cpp> <code cpp>
 namespace std {} namespace std {}
Ligne 397: Ligne 411:
 ==== Fichier header ==== ==== Fichier header ====
  
 +<code cpp>
 // dans mon_fichier.h // dans mon_fichier.h
 #ifndef MONFICHIER_H #ifndef MONFICHIER_H
Ligne 416: Ligne 431:
     std::cout << "Salut tout le monde !" << std::endl;     std::cout << "Salut tout le monde !" << std::endl;
 }  } 
 +</code>
  
 ===== Les fonctions ===== ===== Les fonctions =====
Ligne 422: 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 438: 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 454: Ligne 474:
  
 void* f(); // retourne un pointeur void* f(); // retourne un pointeur
 +</code>
 ==== Passage de paramètres ==== ==== Passage de paramètres ====
  
 +<code cpp>
 int i = 0; int i = 0;
 void f1(int& i) { ++i; } // passage par référence void f1(int& i) { ++i; } // passage par référence
Ligne 481: Ligne 502:
     }     }
 } }
 +</code>
  
 ==== Fonction static ==== ==== Fonction static ====
 +
 +<code cpp>
  
 static void foo() {} static void foo() {}
 +
 +</code>
  
 ==== Fonction variadique ==== ==== Fonction variadique ====
  
 +<code cpp>
 void f(... args) { void f(... args) {
 } }
 +</code>
  
 ==== Les pointeurs de fonctions ==== ==== Les pointeurs de fonctions ====
  
 +<code cpp>
 int (f*) (int a); int (f*) (int a);
 +</code>
  
 ===== Les classes et structures ===== ===== Les classes et structures =====
 +
  
 ==== Syntaxe de bases ==== ==== Syntaxe de bases ====
  
 +<code cpp>
 struct A { int x, y; }; // définition de la structure struct A { int x, y; }; // définition de la structure
 A a; // déclaration de la variable a de type A A a; // déclaration de la variable a de type A
Ligne 518: Ligne 549:
 f(); // erreur f(); // erreur
 g(a); // erreur g(a); // erreur
 +</code>
  
 Forme canonique de Coplien Forme canonique de Coplien
  
 +<code cpp>
 struct A { struct A {
     A() {} // constructeur par défaut     A() {} // constructeur par défaut
Ligne 529: Ligne 562:
     A& operator= (A&& a); // affectation par déplacement [C++11]     A& operator= (A&& a); // affectation par déplacement [C++11]
 }; };
 +</code>
  
 Constructeurs Constructeurs
  
 +<code cpp>
 struct A { struct A {
     A(); // constructeur par défaut     A(); // constructeur par défaut
Ligne 543: Ligne 578:
 A a2(a); // constructeur par copie A a2(a); // constructeur par copie
 A a3 = a; // opérateur de copie A a3 = a; // opérateur de copie
 +</code>
  
 Initialisation Initialisation
  
 +<code cpp>
 struct A { int x; }; struct A { int x; };
 A a1; // initialisation avec les valeurs par défaut A a1; // initialisation avec les valeurs par défaut
Ligne 568: Ligne 605:
  
 // Tableau d'initialisation // Tableau d'initialisation
 +
 struct A { int x, y, z; }; struct A { int x, y, z; };
 A a = { 1, 2, 3 }; A a = { 1, 2, 3 };
 +</code>
  
 Accès aux variables et fonctions membres Accès aux variables et fonctions membres
  
 +<code cpp>
 A a; A a;
 a.x; a.x;
Ligne 584: Ligne 624:
 a.*pi; a.*pi;
 pa->*pi; pa->*pi;
 +</code>
  
 Conversion Conversion
  
 +<code cpp>
 struct A { struct A {
     A(B const& b); // conversion implicite de B vers A     A(B const& b); // conversion implicite de B vers A
Ligne 593: Ligne 635:
     explicit operator B() const; // conversion implicite de A vers B [C++11]     explicit operator B() const; // conversion implicite de A vers B [C++11]
 }; };
 +</code>
 ==== Les variables membres ==== ==== Les variables membres ====
  
 +<code cpp>
 a.x; // accès  a.x; // accès 
 +</code>
  
 ==== Fonctions membres ==== ==== Fonctions membres ====
  
 +<code cpp>
 a.x; // accès  a.x; // accès 
 +</code>
 ==== Opérateurs ==== ==== Opérateurs ====
  
 +<code cpp>
 Foncteurs (objets fonctions) Foncteurs (objets fonctions)
 struct A { struct A {
Ligne 610: Ligne 656:
     void operator() (B const& b, C const& c); // foncteur à deux argments     void operator() (B const& b, C const& c); // foncteur à deux argments
 }; };
 +</code>
  
 Déréfencement Déréfencement
  
 +<code cpp>
 class PtrA { // classe pointeur sur A class PtrA { // classe pointeur sur A
     A* p;     A* p;
Ligne 621: Ligne 669:
     // operator. interdit !     // operator. interdit !
 }; };
 +</code>
  
 Incrémentation et décrémentation Incrémentation et décrémentation
  
 +<code cpp>
 struct A { struct A {
     A& operator++ (); // préfixe : ++a     A& operator++ (); // préfixe : ++a
Ligne 630: Ligne 680:
     A operator-- (int); // postfixe : a--     A operator-- (int); // postfixe : a--
 }; };
 +</code>
  
 ==== Héritage ==== ==== Héritage ====
Ligne 635: Ligne 686:
 Héritage simple Héritage simple
  
 +<code cpp>
 struct A {}; struct A {};
 struct B1 : A {}; // héritage privé struct B1 : A {}; // héritage privé
Ligne 640: Ligne 692:
 struct B : protected A {}; // héritage protected struct B : protected A {}; // héritage protected
 struct B : private A {}; // héritage privé struct B : private A {}; // héritage privé
 +</code>
  
 Héritage multiple Héritage multiple
  
 +<code cpp>
 struct A {}; struct A {};
 struct B {}; struct B {};
 struct C : public A, public B {}; // hérite de A et B struct C : public A, public B {}; // hérite de A et B
 +</code>
  
 Constructeur Constructeur
  
 +<code cpp>
 struct A {}; struct A {};
 struct B1 : public A  struct B1 : public A 
Ligne 654: Ligne 710:
     B() : A() {}     B() : A() {}
 }; };
 +</code>
  
 Fonctions virtuelles Fonctions virtuelles
  
 +<code cpp>
 struct A { struct A {
     virtual ~A(); // obligatoire si au moins une fonction virtuelle     virtual ~A(); // obligatoire si au moins une fonction virtuelle
Ligne 662: Ligne 720:
     virtual f(); // fonction virtuelle     virtual f(); // fonction virtuelle
 }; };
 +</code>
  
 Classe abstraite Classe abstraite
  
 +<code cpp>
 struct A { // ne possède que des fonctions virtuelles pures struct A { // ne possède que des fonctions virtuelles pures
     virtual f() = 0; // fonction virtuelle pure     virtual f() = 0; // fonction virtuelle pure
 }; };
 +</code>
  
 ===== Les structures de contrôle ===== ===== Les structures de contrôle =====
  
 +<code cpp>
 break, continue, return break, continue, return
 +</code>
 ==== if ==== ==== if ====
  
 +<code cpp>
 if (condition) statement if (condition) statement
 if (condition) { statement } if (condition) { statement }
 if (condition) statement else statement if (condition) statement else statement
 +</code>
 ==== switch ==== ==== switch ====
  
 +<code cpp>
 swicth (key) { swicth (key) {
     case ITEM1 : (…) break;     case ITEM1 : (…) break;
Ligne 686: Ligne 750:
     default : (…)     default : (…)
 } }
 +</code>
  
 ==== while et do ==== ==== while et do ====
  
 +<code cpp>
 while (condition) statement while (condition) statement
 do f() while (condition) do f() while (condition)
 do { … } while (condition) do { … } while (condition)
 +</code>
 ==== for ==== ==== for ====
  
 +<code cpp>
 int v[] = { 1, 2, 3, 4 }; int v[] = { 1, 2, 3, 4 };
 for (;;) {} // forever for (;;) {} // forever
 for (int i = 0; i < 4; ++i) { int x = v[i]; } for (int i = 0; i < 4; ++i) { int x = v[i]; }
 for (int* p = &v[0]; p != &v[4]; ++p) { int x = *p; } for (int* p = &v[0]; p != &v[4]; ++p) { int x = *p; }
 +</code>
  
 ==== try et catch ==== ==== try et catch ====
  
 +<code cpp>
 try {} handler_list try {} handler_list
 +</code>
  
 ==== goto ==== ==== goto ====
  
 +<code cpp>
 goto identifier; goto identifier;
 identifier : statement identifier : statement
 +</code>
  
 ===== La surcharge des opérateurs ===== ===== La surcharge des opérateurs =====
  
 +<code cpp>
 void* operator new(size_t); void* operator new(size_t);
 void operator delete(void*); void operator delete(void*);
 void* operator new[](size_t); void* operator new[](size_t);
 void operator delete[](void*); void operator delete[](void*);
 +</code>
  
 ===== Les templates ===== ===== Les templates =====
  
 +<code cpp>
 Les fonctions template Les fonctions template
 template<class T> f() {} template<class T> f() {}
 Les classes template Les classes template
 template<class T> class A {}; template<class T> class A {};
 +</code>
  
 ===== Les exceptions ===== ===== Les exceptions =====
  
 +<code cpp>
 try { … } try { … }
 catch (bad_alloc) { … } catch (bad_alloc) { … }
 +</code>
  
 ===== La bibliothèque standard ===== ===== La bibliothèque standard =====
Ligne 732: Ligne 810:
 Utiliser une classe de la STL directement : Utiliser une classe de la STL directement :
  
 +<code cpp>
 std::vector<int> v; std::vector<int> v;
 +</code>
  
 Utiliser une classe de l'espace de nom std : Utiliser une classe de l'espace de nom std :
  
 +<code cpp>
 using std::vector; using std::vector;
 vector<int> v; vector<int> v;
 +</code>
  
 Utiliser toutes les classes de l'espace de nom std : Utiliser toutes les classes de l'espace de nom std :
  
 +<code cpp>
 using namespace std; using namespace std;
 vector<int> v; vector<int> v;
 +</code>
  
 Quelques fichiers de la bibliothèque standard Quelques fichiers de la bibliothèque standard
  
 +<code cpp>
 <iostream> <iostream>
 <cctype> => fonction isalpha(), etc. <cctype> => fonction isalpha(), etc.
 +</code>
  
 ==== Les conteneurs ==== ==== Les conteneurs ====
Ligne 755: Ligne 841:
 == vector == == vector ==
  
 +<code cpp>
 vector<int> v1; // vecteur de 0 élément vector<int> v1; // vecteur de 0 élément
 vector<int> v2(100); // vecteur de 100 éléments initialisés avec 0 vector<int> v2(100); // vecteur de 100 éléments initialisés avec 0
Ligne 761: Ligne 848:
 int& i = v[0]; int& i = v[0];
 int* p = &v[0]; // pointeur vers le premier élément int* p = &v[0]; // pointeur vers le premier élément
 +</code>
  
 == list == == list ==
Ligne 776: Ligne 864:
 == map == == map ==
  
 +<code cpp>
 map<string, double> table; map<string, double> table;
 table["pi"] = 3.14159265358979; table["pi"] = 3.14159265358979;
 +</code>
  
 == multimap == == multimap ==
Ligne 793: Ligne 883:
 === C++11 === === C++11 ===
  
 +<code cpp>
 unordered_set<T> unordered_set<T>
 unordered_multiset<T>  unordered_multiset<T> 
Ligne 799: Ligne 890:
 forward_list<T> forward_list<T>
 array<T, N> array<T, N>
 +</code>
  
 === Créer son propre conteneur === === Créer son propre conteneur ===
Ligne 806: Ligne 898:
 === Les algorithmes non modifiant === === Les algorithmes non modifiant ===
  
 +<code cpp>
 10.2.1.1.  foreach 10.2.1.1.  foreach
  
Ligne 829: 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 880: 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 915: 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 922: 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.1546369874.txt.gz · Dernière modification: 2019/01/01 20:11 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