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/09/17 12:07]
gbdivers 		aide_memoire_syntaxe [2019/01/03 20:58] (Version actuelle)
nico [Fichier header]
Ligne 1: Ligne 1:
  
 ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ ^ [[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 318: Ligne 320:
 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 337: 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 356: 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 ==== 
  
  
Ligne 363: Ligne 394:
 ===== Directives de compilation ===== ===== Directives de compilation =====
  
-3.1.  Les directives d'inclusion+==== 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 372: 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 393: Ligne 431:
     std::cout << "Salut tout le monde !" << std::endl;     std::cout << "Salut tout le monde !" << std::endl;
 }  } 
 +</code>
  
 ===== Les fonctions ===== ===== Les fonctions =====
  
-4.1.  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 414: 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 430: 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 455: 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>;
-int (f*) (int a);+
  
 +==== Les pointeurs de fonctions ====
 +
 +<code cpp>
 +int (f*) (int a);
 +</code>
  
 ===== Les classes et structures ===== ===== Les classes et structures =====
  
-5.1.  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 485: 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 494: 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 506: 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 529: 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 543: 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 550: 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 562: 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 571: 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 578: 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 585: 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 595: 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 601: 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
-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 619: 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
 +</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 =====
  
 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 675: 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 707: 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 734: 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 785: 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 819: 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()
 +</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.1410948446.txt.gz · Dernière modification: 2014/09/17 12:07 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