Les mots clefs

switch(maVariableATester){
case 2: //Si la variable à tester vaut 2
//Le code a effectuer
case 3: //Si la variable à tester vaut 3
//Le code a effectuer
}

for( int i = 0; i < 21; i++ ) {  // On itere de 0 à 20
     if( i == 10 )  // Si i vaut 10
       continue;      //On passe à l'itération suivante en sautant ce qui suit
    cout << i << " " << std::flush;
   }

try{
    const int i = f(); /// des appels...
    if (i==42) throw std::runtime_error("Désolé, 42"); //Lancement d'une exception
}
catch(std::exception const& e){ //On rattrape les erreurs (par référence!)
    std::cerr << "Erreur: " << e.what() << std::endl;
}

inline int addition(int a, int b)
{
    return a+b;
}

int main(int argc, char* argv[])

maClasse* ptr = new maClasse; //crée de l'espace mémoire de type sizeof(maClasse) et appelle le constructeur de maClasse pour remplir cette espace mémoire.

class A{
public:
   int a;
   mutable int b;
};
 
int main()
{
   const A monObjet;
   monObjet.a = 2; //Interdit car monObjet est constant, on ne peut modifier ses attributs normaux
   monObjet.b = 2; //Autorisé car l'attribut b est modifiable.
}

namespace monEspace{
//Les fonctions, classes, structures, variables de
//cet espace de nommage
}

class complex{
    double re, im;
public:
    complex& operator+=(complex a); // doit pouvoir accéder à la représentation
    // ...
};
 
complex operator+(complex a, complex b)
{
    complex r = a;
    return r += b; // accède à la représentation via +=
}

signed int a; //Déclaration d'un entier pouvant être positif ou négatif

class Truc{
          public:
          double Valeur;
          Truc(){valeur = 0;}
/*soit:*/ Truc(int i){valeur = i;}          // Autoriser le typage implicite int --> Truc
/*soit:*/ explicit Truc(int i){valeur = i;} // Interdire le typage implicite int --> Truc
}

volatile int a; //Déclaration d'un entier pouvant être modifié par un facteur externe au programme

try{
//Instructions susceptibles de lever une exception
}catch(/*...*/)
{
//Gestion de l'exception
}

//On crée une portion de code qui peut potentiellement lever une exception
try{
    //Une erreur s'est produite, on lance une exception
    throw std::exception(); //Lancement d'une exception
}
catch(std::exception& e){
    //Gestion de l'exception
    std::cerr << e.what() << std::endl;
    throw; //On relance la même exception pour la retraiter plus loin.
}

void maFonction(double a) throw(std::exception);
//Prototype d'une fonction susceptible de lever une exception

#include <iostream>
 
// Création d'un type.
union MonUnion
{
    int entier;
    double reel;
};
 
// Utilisation de l'union.
void f(void)
{
    MonUnion u;
    u.entier = 1300;
    u.reel = 12.5;
    std::cout << "u.reel vaut " << u.reel << std::endl;
    std::cout << "u.entier vaut " << u.entier << std::endl; // ATTENTION : ceci ne va pas afficher 1300!
}

const int a=12; //Déclaration d'un entier constant
int* b = const_cast<int*>(&a);  //Cast de a

int a = 12; //Déclaration d'un entier
char b = static_cast<char>(a);  //Cast de a en caractère

int a=123456; //Déclaration d'un entier
cha* b = reinterpret_cast<char*>(&a);  //On convertit a en pointeur sur un caractère.
//On obtient ainsi une séquence d'octets que l'on peut par exemple utiliser pour les fonctions 
// d'entrée-sortie binaire. Cette séquence d'octets correspond à l'entier tel qu'il est stocké
//en mémoire.

int surfaceRectangle(int a, int b) //Fonction qui calcule la surface d'un rectangle
{
   return a*b;  //On termine la fonction en renvoyant le produit a*b
}

wchar_t monCaractere = 'a'; //Un caractère long

void f(int a); //Fonction prenant un entier et ne renvoyant rien
int g(void);  //Fonction ne prenant aucun argument et renvoyant un int.
int g();      //Cette écriture est identique à la ligne précédente

int a=12; //Déclaration d'un entier

extern int a;

class B{
  friend class A;  //A déclarée comme amie de B
  friend void f(); //f() déclarée comme amie de B
 
//Attributs et fonctions membres de la classe
};

class A{
  static int compteur;   //Variable static commune à toutes les instances de A
  static f();            //Fonction membre statique
};

struct maStructure
{
   int a;      //Un attribut publique de maStructure
   void f();   //Une fonction membre publique de maStructure
};

//On crée l'alias Matrice pour les tableaux dynamiques 2D
typedef std::vector<std::vector <int> > Matrice;

template <typename T>
class A{ //Déclaration d'une classe template

    void f(T a){ //Fonction membre prenant en argument un objet de type non-défini
        if(typeid(a) == typeid(int)){ //Si a est un entier
            //Code particulier dans ce cas
        }
        //Reste de la fonction
    }
    //Reste de la classe
};

template <typename T>  //On définit T comme un type indéterminé
class A{  //Déclaration d'une classe template
 
    //Reste de la classe
 
};

#include <iostream>
 
std::cout << "Hello world" << std::endl; //On est ici obligé d'utiliser std:: pour spécifier quel cout utiliser
 
using namespace std;  //Permet d'utiliser l'entier des fonctions se trouvant dans
//l'espace de nommage std, sans les précéder du std::
 
cout << "Hello World" << endl; //On peut ici utiliser cout sans std::

using std::cout;
 
cout <<"Hello World" << std::endl;

if(/*Un test A*/)
{
    //Code exécuté si le test A est vrai
}
else if(/*Un test B*/)
{
    //Code exécuté si le test A est faux et que le test B est vrai
}
else
{
    //Code exécuté si les tests A et B sont faux
}