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 [2014/06/01 00:42]
gbdivers créée 		aide_memoire_syntaxe [2019/01/03 20:58] (Version actuelle)
nico [Fichier header]
Ligne 1: Ligne 1:
  
-^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[comment_realiser_les_exercices_de_ce_cours|Chapitre suivant]] ^+^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ 
 + 
 +__ utilité d'un tel aide mémoire de nos jours ? (internet, autocomplétion...)
  
 ====== Aide mémoire sur la syntaxe du C++ ====== ====== Aide mémoire sur la syntaxe du C++ ======
Ligne 6: Ligne 8:
 Ce document est destiné à retrouver facilement une syntaxe en C++ et à copier-coller le code d'exemple. Il est organisé selon le plan de l'ouvrage « Le langage C++ » de Bjarne Stroustrup . Les syntaxes spécifiques au C++11 sont indiquées à l'aide du tag [C++11]. Ce document ne donne pas d'explication sur les fonctionnalités présentées, pour cela, veuillez-vous référérer à un cours de C++. Ce document est destiné à retrouver facilement une syntaxe en C++ et à copier-coller le code d'exemple. Il est organisé selon le plan de l'ouvrage « Le langage C++ » de Bjarne Stroustrup . Les syntaxes spécifiques au C++11 sont indiquées à l'aide du tag [C++11]. Ce document ne donne pas d'explication sur les fonctionnalités présentées, pour cela, veuillez-vous référérer à un cours de C++.
  
-1.  Hello world+===== Hello world =====
  
 <code cpp> <code cpp>
Ligne 17: Ligne 19:
 </code> </code>
  
-2.  Les base du langage C+++===== Les base du langage C++ =====
  
-2.1.  Les types+==== Les types ====
  
   * Entier : int   * Entier : int
Ligne 28: Ligne 30:
   * Modificateur de signe : [signed], unsigned   * Modificateur de signe : [signed], unsigned
  
-2.2.  Les littérales+==== Les littérales ====
  
 Entiers Entiers
Ligne 74: Ligne 76:
 </code> </code>
  
-2.3.  Les variables+==== Les variables ====
  
 Variantes : Variantes :
Ligne 110: Ligne 112:
  
 Les types littérales Les types littérales
 +
 +<code cpp>
 char tab = '\t'; // tabulation char tab = '\t'; // tabulation
 char endl = '\n'; // fin de ligne char endl = '\n'; // fin de ligne
 const char* s = "une chaine de caractères"; const char* s = "une chaine de caractères";
 // les user string litterale [C++11] // les user string litterale [C++11]
 +</code>
 +
 Remarques Remarques
 +
 +<code cpp>
 char* s1 = "une chaine"; // const char* (compatiblité avec C) char* s1 = "une chaine"; // const char* (compatiblité avec C)
 s1[0] = 'U'; // erreur s1[0] = 'U'; // erreur
Ligne 120: Ligne 128:
 char s2[] = "une chaine"; // copie de la chaine dans le tableau char s2[] = "une chaine"; // copie de la chaine dans le tableau
 s2[0] = 'U'; // ok s2[0] = 'U'; // ok
 +</code>
  
 chaîne longue chaîne longue
 +
 +<code cpp>
 char* s = "abcdef" char* s = "abcdef"
           "ghijkl"; // s vaut "abcdzfghijkl"           "ghijkl"; // s vaut "abcdzfghijkl"
 +</code>
 +          
 Types réelles Types réelles
 +
 +<code cpp>
 float float
 double d = 123.456e-789; double d = 123.456e-789;
 long double long double
 1.23456789f ou 1.23456789F // littérale float 1.23456789f ou 1.23456789F // littérale float
 +</code>
 +
 Déclaration dans une condition Déclaration dans une condition
 +
 +<code cpp>
 for (int i=0; i<10; ++i) { } for (int i=0; i<10; ++i) { }
 if (double d = foo()) { /* si d n'est pas nul */ }  if (double d = foo()) { /* si d n'est pas nul */ } 
 +</code>
 +
 Opérateur sizeof : Opérateur sizeof :
 +
 +<code cpp>
 sizeof A; sizeof A;
 sizeof(A); sizeof(A);
Ligne 141: Ligne 164:
 sizeof(float) ≤ sizeof(double) ≤ sizeof(long double)  sizeof(float) ≤ sizeof(double) ≤ sizeof(long double) 
 sizeof(N) ≡ sizeof(signed N) ≡ sizeof(unsigned N)  sizeof(N) ≡ sizeof(signed N) ≡ sizeof(unsigned N) 
 +</code>
 +
 Obtenir des informations sur un type (http://www.cplusplus.com/reference/std/limits/numeric_limits/) Obtenir des informations sur un type (http://www.cplusplus.com/reference/std/limits/numeric_limits/)
 +
 +<code cpp>
 #include <limits> #include <limits>
 int m1 = numéric_limits<int>::min(); int m1 = numéric_limits<int>::min();
Ligne 147: Ligne 174:
 bool b1 = numéric_limits<int>::in_signed(); bool b1 = numéric_limits<int>::in_signed();
 bool b2 = numéric_limits<int>::in_integer(); bool b2 = numéric_limits<int>::in_integer();
 +</code>
 +
 Cast Cast
 +
 +<code cpp>
 static_cast<A>(a); // vérification à la compilation static_cast<A>(a); // vérification à la compilation
-dynamic_cast<A>(a); // vérification à l'éxecution +dynamic_cast<A>(a); // vérification à l’exécution 
-Non+
 reinterpret_cast<A>(a); // pas de vérification reinterpret_cast<A>(a); // pas de vérification
 const_cast<A>(a); // conversion de const const_cast<A>(a); // conversion de const
 +
 A a = b; // cast ou conversion implicite A a = b; // cast ou conversion implicite
 A a(b); // cast ou conversion implicite A a(b); // cast ou conversion implicite
 A a = (A) b; // cast explicite A a = (A) b; // cast explicite
 +</code>
 +
 Modificateur de déclaration Modificateur de déclaration
 +
 +<code cpp>
 const char tab = '\t'; // doit être initialisé lors de la déclaration const char tab = '\t'; // doit être initialisé lors de la déclaration
 static int i; static int i;
 mutable double d; // uniquement dans classe ? mutable double d; // uniquement dans classe ?
 extern float f; extern float f;
-2.4.  Constantes+</code> 
 + 
 +==== Constantes ==== 
 + 
 +<code cpp>
 const int i = 10; const int i = 10;
-const int[] v = { 1, 2, 3, 4 }; +const int[] v = { 1, 2, 3, 4 }; 
 +</code> 
 Pointeurs et références constantes Pointeurs et références constantes
 +
 +<code cpp>
 const int* p1 = &i; // pointeur vers constante const int* p1 = &i; // pointeur vers constante
 int* const p2 = &i; // pointeur constant int* const p2 = &i; // pointeur constant
 const int* const p3 = &i; // pointeur constant vers une constante const int* const p3 = &i; // pointeur constant vers une constante
 int const& r1 = i; // référence vers consante int const& r1 = i; // référence vers consante
-2.5.  Les énumération+</code> 
 + 
 +==== Les énumération ==== 
 + 
 +<code cpp>
 enum { ITEM1, ITEM2, ITEM3 }; // ITEM1 = 0, ITEM2 = 1; ITEM3 = 2 enum { ITEM1, ITEM2, ITEM3 }; // ITEM1 = 0, ITEM2 = 1; ITEM3 = 2
 enum E1 { ITEM1, ITEM2, ITEM3 }; // ITEM1 = 0, ITEM2 = 1; ITEM3 = 2 enum E1 { ITEM1, ITEM2, ITEM3 }; // ITEM1 = 0, ITEM2 = 1; ITEM3 = 2
Ligne 179: Ligne 227:
 // strong enum [C++11] // strong enum [C++11]
 // constexpr avec flag // constexpr avec flag
-2.6.  La définition de type Typedef+</code> 
 + 
 +==== La définition de type Typedef ==== 
 + 
 +<code cpp>
 typedef unsigned char uchar; typedef unsigned char uchar;
-2.7.  Les pointeurs+</code> 
 + 
 +==== Les pointeurs ==== 
 Déclaration Déclaration
 +
 +<code cpp>
 void* p1 = 0; void* p1 = 0;
 void* p2 = NULL; void* p2 = NULL;
 void* p3 = nullptr; [C++11] void* p3 = nullptr; [C++11]
 +</code>
 +
 Allocation et initialisation Allocation et initialisation
 +
 +<code cpp>
 float* p2 = new float; float* p2 = new float;
 float* p3 = new float(123.456f);  float* p3 = new float(123.456f); 
 new (&a) int; // placement new (&a) int; // placement
 new (&a) A(123); // placement et initialisation new (&a) A(123); // placement et initialisation
 +</code>
 +
 Destruction Destruction
 +
 +<code cpp>
 delete p3; delete p3;
 +</code>
 +
 Récupérer l'adresse d'une variable Récupérer l'adresse d'une variable
 +
 +<code cpp>
 int* pi = &i; int* pi = &i;
 +</code>
 +
 Manipuler les pointeurs Manipuler les pointeurs
 +
 +<code cpp>
 int x = *pi; int x = *pi;
 ++pi; ++pi;
Ligne 201: Ligne 274:
 pi + 3; pi + 3;
 pi – 3; pi – 3;
 +</code>
 +
 Cast Cast
 +
 +<code cpp>
 int* pi; int* pi;
 float* pf = pi; // erreur, conversion implicite interdit float* pf = pi; // erreur, conversion implicite interdit
 float* pf = static_cast<float>(pi); // conversion explicite, mais non sur float* pf = static_cast<float>(pi); // conversion explicite, mais non sur
 +</code>
 +
 Les pointeurs sur void Les pointeurs sur void
 +
 +<code cpp>
 int* pi; int* pi;
 void* pv = pi; // ok, conversion implicite void* pv = pi; // ok, conversion implicite
Ligne 211: Ligne 292:
 ++pv; // erreur ++pv; // erreur
 int* pi2 = static_cast<int*>(pv); // ok, conversion vers le type d'origine int* pi2 = static_cast<int*>(pv); // ok, conversion vers le type d'origine
 +</code>
 +
 Surcharge des opérateurs new et delete Surcharge des opérateurs new et delete
 +
 +<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>
 +
 Exception lancée par new Exception lancée par new
 +
 +<code cpp>
 try { for (;;) new char[1000]; } // provoque une erreur dès que la mémoire sature try { for (;;) new char[1000]; } // provoque une erreur dès que la mémoire sature
 catch (bad_alloc) { cout << "erreur bad alloc" << endl; } catch (bad_alloc) { cout << "erreur bad alloc" << endl; }
Ligne 223: Ligne 312:
 set_new_handler(foo); set_new_handler(foo);
 for (;;) new char[1000]; // provoque une erreur dès que la mémoire sature => foo() for (;;) new char[1000]; // provoque une erreur dès que la mémoire sature => foo()
 +</code>
  
-2.8.  Les références+==== Les références ====  
 + 
 +<code cpp>
 int i = 1; int i = 1;
 int& r1 = i; // r est un alias de i int& r1 = i; // r est un alias de i
 ++r1; // i vaut 2 maintenant ++r1; // i vaut 2 maintenant
-extern int& r2; // ok, initialisation ailleure+extern int& r2; // ok, initialisation ailleurs 
 +</code> 
 Intialisation avec une litérrale : Intialisation avec une litérrale :
 +
 +<code cpp>
 int& r3 = 123; // erreur int& r3 = 123; // erreur
 const int& r3 = 123; // Ok, lvalue const int& r3 = 123; // Ok, lvalue
 +</code>
 +
 2.9.  Les tableaux 2.9.  Les tableaux
 Les tableaux à une dimension Les tableaux à une dimension
 +
 +<code cpp>
 int a1[10]; int a1[10];
 int a2[] = { 1, 2, 3, 4 }; // tableau de 4 éléments int a2[] = { 1, 2, 3, 4 }; // tableau de 4 éléments
 int a3[4] = { 1, 2, 3, 4 }; int a3[4] = { 1, 2, 3, 4 };
 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>
 +
 Pointeur sur tableau Pointeur sur tableau
 +
 +<code cpp>
 int v[] = { 1, 2, 3, 4 }; int v[] = { 1, 2, 3, 4 };
 int* p1 = v;  int* p1 = v; 
Ligne 247: Ligne 351:
 int* p4 = p1 + 2; // p4 pointe sur 3 int* p4 = p1 + 2; // p4 pointe sur 3
 int d = &v[2] - &v[0]; // d = 2 int d = &v[2] - &v[0]; // d = 2
 +</code>
 +
 Parcourir un tableau Parcourir un tableau
 +
 +<code cpp>
 int v[] = { 1, 2, 3, 4 }; int v[] = { 1, 2, 3, 4 };
 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>
 +
 Les tableaux à N dimensions Les tableaux à N dimensions
 +
 +<code cpp>
 int a2[15][20]; int a2[15][20];
 +</code>
 +
 Tableaux dynamiques Tableaux dynamiques
 +
 +<code cpp>
 int* pi; int* pi;
 int i = pi[i]; // cast  int i = pi[i]; // cast 
- 
 int* table = new[10] int; int* table = new[10] int;
 table[i]; table[i];
 delete[] table; delete[] table;
 +</code>
 +
 2.10.  Les espaces de nom 2.10.  Les espaces de nom
 +
 +<code cpp>
 namespace std {} namespace std {}
 using namespace std; using namespace std;
Ligne 266: Ligne 385:
  
 ::nom; // espace de nom global ::nom; // espace de nom global
-2.11.  Ordre de priorité des opérateurs+</code> 
 + 
 +==== Ordre de priorité des opérateurs ==== 
  
  
 Priorité : de haut en bas, et de gauche à droite pour les opérateurs unaires et de droite à gauche pour les binaires. Priorité : de haut en bas, et de gauche à droite pour les opérateurs unaires et de droite à gauche pour les binaires.
-3.  Directives de compilation + 
-3.1.  Les directives d'inclusion+===== Directives de compilation ===== 
 + 
 +==== Les directives d'inclusion ==== 
 +<code cpp>
 #include "file/nomfichier.h" #include "file/nomfichier.h"
 #include <vector> // classe de la STL #include <vector> // classe de la STL
 +</code>
 +
 3.2.  Les commentaires 3.2.  Les commentaires
 +
 +<code cpp>
 // commentaire sur une seule ligne // commentaire sur une seule ligne
 /* commentaire /* commentaire
Ligne 280: Ligne 408:
 plusieurs plusieurs
 lignes */ lignes */
-3.3.  Fichier header+</code> 
 +==== Fichier header ====
  
 +<code cpp>
 // dans mon_fichier.h // dans mon_fichier.h
 #ifndef MONFICHIER_H #ifndef MONFICHIER_H
Ligne 301: Ligne 431:
     std::cout << "Salut tout le monde !" << std::endl;     std::cout << "Salut tout le monde !" << std::endl;
 }  } 
-4.  Les fonctions +</code> 
-4.1.  Précisions sémantiques+ 
 +===== Les fonctions ===== 
 + 
 +==== 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 319: 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 335: Ligne 474:
  
 void* f(); // retourne un pointeur void* f(); // retourne un pointeur
-4.3.  Passage de paramètres+</code> 
 +==== 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 360: Ligne 502:
     }     }
 } }
-4.6.  Fonction static+</code> 
 + 
 +==== Fonction static ==== 
 + 
 +<code cpp> 
 static void foo() {} static void foo() {}
-4.7.  Fonction variadique+ 
 +</code> 
 + 
 +==== Fonction variadique ==== 
 + 
 +<code cpp>
 void f(... args) { void f(... args) {
 } }
-4.8.  Les pointeurs de fonctions+</code> 
 + 
 +==== Les pointeurs de fonctions ==== 
 + 
 +<code cpp>
 int (f*) (int a); int (f*) (int a);
-5.  Les classes et structures +</code> 
-5.1.  Syntaxe de bases+ 
 +===== Les classes et structures ===== 
 + 
 + 
 +==== 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 387: 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 396: 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 408: 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 431: 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 445: 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 452: 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]
 }; };
-5.2.  Les variables membres+</code> 
 +==== Les variables membres ==== 
 + 
 +<code cpp>
 a.x; // accès  a.x; // accès 
-5.3.  Fonctions membres+</code>
  
 +==== Fonctions membres ====
 +
 +<code cpp>
 a.x; // accès  a.x; // accès 
-5.4.  Opérateurs+</code> 
 +==== Opérateurs ==== 
 + 
 +<code cpp>
 Foncteurs (objets fonctions) Foncteurs (objets fonctions)
 struct A { struct A {
Ligne 464: 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 473: 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 480: Ligne 680:
     A operator-- (int); // postfixe : a--     A operator-- (int); // postfixe : a--
 }; };
-5.5.  Héritage+</code> 
 + 
 +==== Héritage ==== 
 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 487: 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 497: Ligne 710:
     B() : A() {}     B() : A() {}
 }; };
-Fonctions vituelles+</code> 
 + 
 +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 503: 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
 }; };
-6.  Les structures de contrôle+</code> 
 + 
 +===== Les structures de contrôle ===== 
 + 
 +<code cpp>
 break, continue, return break, continue, return
-6.1.  if+</code> 
 +==== 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
-6.2.  switch+</code> 
 +==== switch ==== 
 + 
 +<code cpp>
 swicth (key) { swicth (key) {
     case ITEM1 : (…) break;     case ITEM1 : (…) break;
Ligne 519: Ligne 750:
     default : (…)     default : (…)
 } }
-6.3.  while et do+</code> 
 + 
 +==== 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)
-6.4.  for+</code> 
 +==== 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; }
-6.5.  try et catch+</code> 
 + 
 +==== try et catch ==== 
 + 
 +<code cpp>
 try {} handler_list try {} handler_list
-6.6.  goto+</code> 
 + 
 +==== goto ==== 
 + 
 +<code cpp>
 goto identifier; goto identifier;
 identifier : statement identifier : statement
-7.  La surcharge des opérateurs+</code> 
 + 
 +===== 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*);
-8.  Les templates+</code> 
 + 
 +===== 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 {};
-9.  Les exceptions+</code> 
 + 
 +===== Les exceptions ===== 
 + 
 +<code cpp>
 try { … } try { … }
 catch (bad_alloc) { … } catch (bad_alloc) { … }
-10.  La bibliothèque standard+</code> 
 + 
 +===== La bibliothèque standard ===== 
 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.
-10.1.  Les conteneurs +</code> 
-10.1.1.  Les séquences + 
-10.1.1.1.  vector+==== Les conteneurs ==== 
 + 
 +=== Les séquences === 
 + 
 +== 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 567: 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
-10.1.1.2.  list+</code>
  
-10.1.1.3.  deque+== list ==
  
-10.1.1.4.  stack+== deque ==
  
-10.1.1.5.  queue+== stack ==
  
-10.1.1.6.  priority_queue+== queue ==
  
-10.1.2.  Les conteneurs associatifs +== priority_queue == 
-10.1.2.1.  map+ 
 +=== Les conteneurs associatifs === 
 + 
 +== map == 
 + 
 +<code cpp>
 map<string, double> table; map<string, double> table;
 table["pi"] = 3.14159265358979; table["pi"] = 3.14159265358979;
-10.1.2.2.  multimap+</code>
  
-10.1.2.3.  set+== multimap ==
  
-10.1.2.4.  multiset+== set ==
  
-10.1.3.  Les autres conteneurs +== multiset ==
-10.1.3.1.  bitset+
  
-10.1.3.2.  valarray+=== Les autres conteneurs ===
  
-10.1.4.  C++11+== bitset == 
 + 
 +== valarray == 
 + 
 +=== C++11 === 
 + 
 +<code cpp>
 unordered_set<T> unordered_set<T>
 unordered_multiset<T>  unordered_multiset<T> 
Ligne 599: Ligne 890:
 forward_list<T> forward_list<T>
 array<T, N> array<T, N>
-10.1.5.  Créer son propre conteneur+</code>
  
-10.2.  Les algorithmes +=== Créer son propre conteneur === 
-10.2.1.  Les algorithmes non modifiant+ 
 +==== Les algorithmes ==== 
 + 
 +=== Les algorithmes non modifiant === 
 + 
 +<code cpp>
 10.2.1.1.  foreach 10.2.1.1.  foreach
  
Ligne 626: 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 677: Ligne 976:
  
 10.2.2.25.  random_shuffle 10.2.2.25.  random_shuffle
 +</code>
  
-10.2.2.26.  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 711: 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
  
-10.4.  Les chaînes de caractères +==== Les chaînes de caractères ==== 
-10.4.1.  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
-10.4.2.  Manipuler les chaînes de caractères+</code> 
 + 
 +=== 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()
-10.5.  Les flux +</code> 
-10.5.1.  Flux de sortie+==== Les flux ==== 
 + 
 +=== 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;
-10.5.2.  Flux d'entrée+</code> 
 + 
 +=== Flux d'entrée === 
 + 
 +<code cpp>
 cin >> i; // lecture cin >> i; // lecture
 char c; char c;
 cin.get(c); cin.get(c);
-10.5.3.  Flux sur les chaines de caractères+</code> 
 + 
 +=== 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]) ;
-10.5.4.  Flux sur les fichiers+</code> 
 + 
 +=== Flux sur les fichiers === 
 + 
 +<code cpp>
 ifstream ifstream
-10.6.  Les fonctions numériques+</code> 
 + 
 +===== Les fonctions numériques ==== 
 + 
 +<code cpp>
 fsqrt() fsqrt()
-11.  A trier+</code> 
 + 
 +===== 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>
-12.  Index+
aide_memoire_syntaxe.1401576169.txt.gz · Dernière modification: 2014/06/01 00:42 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