Chapitre 2   Les structures de base

• Types de base et constantes
• Opérateurs et expressions
• Structuration d'un programme C++
• Fonctions
• Variables
• Pointeurs
• La bibliothèque d'entrées-sorties
• Les namespaces

2.1   Types de base et constantes

• bool : booléen¹, peut valoir true ou false,
• char : caractère (en général 8 bits), qui peuvent aussi être déclarés explicitement signés (signed char) ou non signés (unsigned char),
• int : entier (16 ou 32 bits, suivant les machines), qui possède les variantes short [int] et long [int], tous trois pouvant également être declarés non signés (unsigned),
• float : réel (1 mot machine),
• double : réel en double précision (2 mots machines), et sa variante long double (3 ou 4 mots machine),
• void qui spécifie un ensemble vide de valeurs.

  'a'  'G'  '3'  '*' '['

  \n  \t  \r  \135  \'  \x0FF

  12  -43  85  18642  54L 255u 38ul
  0xabfb  0x25D3a  0x3a
  0321  07215  01526

  532.652  -286.34  12.73
  52e+4  42.63E-12  -28.15e4

  "Home sweet home"
  "Français, je vous ai compris."

2.2   Opérateurs et expressions

2.2.1   Opérateurs arithmétiques

+

addition

-

soustraction

*

multiplication

/

division (entière ou réelle)

%

modulo (sur les entiers)

2.2.2   Opérateurs relationnels

> >= <= <

comparaisons

== !=

égalité et inégalité

!

négation (opérateur unaire)

&&

et relationnel

||

ou relationnel

2.2.3   L'affectation

=

affectation

  a = b = c+2;

2.2.4   Opérateurs d'incrémentation et de décrémentation

++

incrémentation

--

décrémentation

  a = 5; b = 6;
  c = ++a - b;

  a = 5; b = 6;
  c = a++ - b;

  t[++a] = a;

2.2.5   Opérateurs logiques

&

and. Exemple : a & 0x000F extrait les 4 bits de poids faible de a.

|

or. Ainsi, b = b | 0x100 force à 1 le 9ème bit de b.

^

xor.

<<

shift à gauche. a = b << 2 met dans a la valeur de b où tous les bits ont été décalés de 2 positions vers la gauche.

>>

shift à droite.

~

complément à 1 (opérateur unaire).

2.2.6   Modifier la valeur d'une variable

+=

a += b équivaut à a = a + b; --- À noter : a++  a += 1  a = a + 1

-=

idem, de même que *=, /=, %=, <<=, >>=, &=, |= et ^=.

2.2.7   Expressions conditionnelles

   z = (a > b) ? a : b;

2.2.8   Conversions de types

L'ancien système

La norme officielle

1. L'opérateur static_cast<T> (expr) : cet opérateur est utilisé pour effectuer des conversions qui sont résolues à la compilation. Il peut être utilisé pour convertir un pointeur (ou une référence) sur une classe de base vers un pointeur (ou une référence) sur une classe dérivée. L'opérateur n'effectue aucune vérification au cours de l'exécution (comme son nom l'indique) et doit donc être utilisé pour des conversions non-ambiguës. Mal utilisé, il renvoie un résultat indéfini. Il doit surtout être utilisé pour effectuer des conversions arithmétiques. Il est assez proche de la conversion de l'ancien système, mais permet de supprimer des trous de sécurité qui existaient.
2. L'opérateur const_cast<T> (expr) : cet opérateur permet de supprimer la constance d'un objet. Ce n'est pas très naturel, mais utile dans certaines situations ; il doit être ainsi utilisé avec parcimonie. Un exemple d'utilisation se trouve ci-dessous :

   void f(Article &i)
   {
   }
   
   void g(const Article &j)
   {
     f(j);  // Erreur : j est constant et f n'attend pas un const
     f(const_cast<Article&> (j));  // Ok
   }
     

   De même, il peut être utilisé à l'intérieur d'une méthode de classe constante : en l'appliquant sur le pointeur this, on peut modifier par la suite l'objet courant (!)
3. L'opérateur dynamic_cast<T> (expr) : c'est certainement l'un des nouveaux opérateurs les plus intéressants. Il peut uniquement être utilisé sur des pointeurs ou des références pour naviguer dans une hiérarchie de classes. Il peut être utilisé pour convertir un objet d'une classe dérivée vers un objet d'une classe de base ou inversement. Dans le premier cas, c'est une classique conversion statique qui est effectuée tandis que dans le second cas c'est une conversion dynamique qui est réalisée, en se basant sur le système RTTI. Dans ce cas, si la conversion est possible, l'opérateur de conversion renvoie un pointeur valide, ou un pointeur nul sinon. Cette fonctionnalité est très puissante comme le montre l'exemple suivant :

   #define MAXELTS 1000
   
   int main()
   {
     Article* lesArticle[MAXELTS];
   
     // Initialisation du tableau avec des articles hétérogènes
     // Deux cas différenciés : Alcools ou autres articles
   
     for (int i = 0; i < MAXELTS; i++) {
         BoissonAlcoolisee* ba;
   
         ba = dynamic_cast<BoissonAlcoolisee*> (lesArticle[i]);
   
         // Si l'article est un alcool, affichage du nom et du 
         // degré d'alcool. Affiche du nom uniquement sinon.
   
         if (ba != NULL)
           cout << ba->nom() << " (" << ba->degre() << ")" << endl;
         else
           cout << lesArticle[i]->nom() << endl;
     }
   }
     

4. L'opérateur reinterpret_cast<T> (expr) : cet opérateur peut être utilisé pour convertir des objets dont les types ne sont pas en relation. Le résultat de la conversion est dépendante de l'implantation, et n'est ainsi pas portable. Il peut être utilisé dans certains contextes particuliers de conversion entre types de pointeurs de fonctions.

2.2.9   Récapitulatif

2.3   Structuration d'un programme C++

typeRetour nomDeLaFonction(spécification des paramètres formels)

{
   suite de déclarations de variables locales et d'instructions
}

  int moyenne(int a, int b)
  {
    int c = (a+b)/2;
    return c;
  }

2.3.1   Instructions et blocs

   if (n > 0) {
      int cumul = 0;
      for (int i=0 ; i < n ; i++) ....
      ....
      }

  /* Exemple d'une instruction vide involontaire */
   for ( ... ) ;   // Ici le point-virgule indique une instruction vide
                   // à exécuter à chaque itération ; ce n'était pas
                   // forcément le souhait du programmeur

2.3.2   Structures conditionnelles

2.3.3   Structures itératives

   for ( ; ; )

  for ( ; ; ) if ((c = getchar()) == '&') break;

  while ((c = getchar()) != '&') ; // le point-virgule ici est
                                   // l'instruction vide !
     

2.4   Fonctions

    void swap(int& a, int& b)
    {
        int tmp = a; a = b; b = tmp;
    }
    ...
    int x, y;
    ...
    swap(x, y);

   void print(const Matrice& m)
   {
       // le compilateur interdit toute tentative
       // de modification de la variable m dans
       // le corps de la procédure print
   }

   inline int max(int x, int y) { return (x > y ? x : y); }

void ecranInit(Ecran ecran, int lig = 24, int col = 80, char fond = ' ');

void ecranInit(Ecran ecran, int lig, int col, char fond)
{
  ...
}

int main()
{
  Ecran ec;

  ecranInit(ec);              // Éq. à : ecranInit(ec, 24, 80, ' ');
  ecranInit(ec, 26);          // Éq. à : ecranInit(ec, 26, 80, ' ');
  ecranInit(ec, 26, 92);      // Éq. à : ecranInit(ec, 26, 92, ' ');
  ecranInit(ec, 26, 92, '+');
}

1. Une fonction peut définir des valeurs par défaut pour tous ses paramètres ou seulement pour une partie. Les paramètres acceptant des valeurs par défaut doivent se trouver après les paramètres sans valeur par défaut dans la liste des paramètres acceptés par une fonction.
2. Les valeurs par défaut de chaque paramètre ne peuvent être mentionnées qu'une seule fois. Ainsi, par convention, ces valeurs sont généralement mentionnées dans la déclaration de la fonction et pas dans sa définition (donc dans le header et pas dans le fichier de suffixe .cpp ou .C).
3. L'ordre de déclaration des paramètres est important : dans l'exemple ci-dessus il est en effet impossible de donner une valeur à col sans en donner une auparavant à lig. D'une façon générale, il faut donc positionner parmi les paramètres ayant des valeurs par défaut en premier ceux qui ont le plus de chances d'être modifiés.

2.5   Variables

automatiques

: c'est l'option par défaut pour toute variable interne d'une fonction. L'allocation se fait dans la pile d'exécution.

externes

ou globles : ce sont les variables définies à l'extérieur de toute fonction, et qui sont donc globales. Si on fait référence dans une fonction à une variable définie dans un autre module, on précisera qu'elle est externe par le mot-clé extern.

NB : Nous déconseillons fortement l'utilisation de variables externes.

statiques

: une variable globale statique (mot-clé static) est une variable dont le nom n'est pas exporté à l'édition de liens, et qui reste donc invisible hors du module où elle est définie.

Une variable interne à une fonction qui est déclarée statique est une variable rémanente : sa portée de visibilité est réduite à la fonction, mais elle n'est initialisée que la première fois où la fonction qui la déclare est appelée ; ensuite, sa valeur persiste d'un appel de la fonction à l'autre.

Le mot-clé static permet également de définir les variables et méthodes de classe (cf. § 3.8).

registres

: on peut demander qu'une variable de type entier, caractère ou pointeur soit implantée dans un registre, ce qui est souvent utile quand on veut aller vite. Les indices dans les tableaux et les pointeurs en mémoire sont souvent de bons candidats pour être déclarés comme registres.

Attention : seule une variable automatique peut être de type registre. De plus, le mot-clé register, à employer dans ce cas, ne donne qu'une indication au compilateur ; on ne garantit pas que la variable sera bien en registre, le compilateur n'ayant à sa disposition qu'un nombre limité de registres. Sauf cas très particuliers, comme en programmation système ou en micro-optimisation de code dans des boucles particulières, nous vous déconseillons de recourir à l'emploi de ce mot-clé.

const

: la variable désigne en fait une constante ; aucune modification n'est autorisée dans le programme.

volatile

: un objet déclaré volatile peut être modifié par un événement extérieur à ce qui est contrôlé par le compilateur (exemple : variable mise à jour par l'horloge système). Cette indication donnée au compilateur lui signale que toute optimisation sur l'emploi de cette variable serait hasardeuse.

2.6   Pointeurs

  int* px;

  int x;

     px = &x;

     x = *px;

  void swap(int* px, int* py)
  {
     int temp;    // variable temporaire

     temp = *px;
     *px = *py;
     *py = temp;
  }

  int a,b;

  swap(&a,&b);

  int* px;
  *px = 3;

2.6.1   Les tableaux

     int a[10];

     int* pa, a[10];

     pa = &a[0];

     pa = a;

     pa = a;

     a = pa;

     void funct(int tab[])

     void funct(int* tab)

     int tab[200][200];
     long int moyenne=0;
     int* p = tab;

     for (int i=0  ; i < 200 ; i++)
          for (int j=0 ; j < 200 ; j++ , p++)
              moyenne += *p;
     moyenne /= 40000;

     int tab[200][200];
     long int moyenne=0;
     int* p = tab;
     int* stop = p + 200 * 200;
     for ( ; p < stop ; ) // on ne fait plus p++ ici
              moyenne += *p++; // on accède à la valeur pointée
                               // par p, puis on l'incrémente
     moyenne /= 40000;

2.6.2   Allocation dynamique de mémoire

  int* pi = new int;

  int* tab = new int[20];

  delete pi;
  delete [] tab;

// Allocation d'une variable et d'un tableau en C++

int main()
{
  int* pi = new int;
  int* tab = new int[10];

  if ((pi != NULL) && (tab != NULL)) {
    ...
    delete pi;
    delete [] tab;
  }
}

2.6.3   Arithmétique sur les pointeurs

2.6.4   Compléments sur les pointeurs

• C++ propose deux manières de représenter les chaînes de caractères : celle héritée de C et le type string de la bibliothèque standard C++. Nous vous conseillons bien entendu d'utiliser ce dernier (cf. § 4.5.3).
  
  Mais comme vous risquez d'être parfois confrontés à des chaînes de caractères ``à l'ancienne'' (c'est-à-dire à la mode C), sachez que ce sont des tableaux de caractères terminés par le caractère nul (de code 0, et noté comme l'entier 0 ou le caractère \0).
• On peut bien sûr utiliser des tableaux de pointeurs, des pointeurs de pointeurs, des pointeurs de pointeurs de pointeurs, etc. Bref, vous voyez ce que je veux dire...
  
  
• On peut même manipuler des tableaux de fonctions, des pointeurs de fonctions, ce qui permet d'appeler plusieurs fonctions différentes en se servant du même pointeur.

2.7   La bibliothèque d'entrées-sorties

   #include <iostream>

• cin désigne le flot d'entrée standard (typiquement, votre clavier),
• cout désigne le flot de sortie standard (typiquement, la fenêtre d'exécution sur votre écran),
• cerr désigne le flot standard des messages d'erreur.

   #include <iostream>
   #include <string>

   // ...

   cout << "Bonjour, comment vous appelez-vous ? ";
   string nom;
   cin >> nom;
   if (nom.string_empty()) {
      cerr << "erreur : nom vide" << endl;
   }
   else {
      cout << nom << ", donnez-moi maintenant votre âge : ";
      int age;
      cin >> age;
      if (age > 35) {
          cout << "Ouah, vous n'êtes plus tout jeune !" << endl;
      }
      else {
          cout << "Blanc bec !" << endl;
      }
   }

2.8   Les namespaces

namespace MonNameSpace
{
  // Toutes les déclarations sont regroupées
  // dans ce bloc

  int f();

  // D'autres déclarations...

  // Fin du namespace
};

// Si on souhaite définir un alias sur le nom d'un
// namespace

namespace mon = MonNameSpace;

mon::f();   // Appelle MonNameSpace::f()

// Si la fonction f est la seule à être présente,
// on peut déclarer

using MonNameSpace::f;

f();   // Appelle MonNameSpace::f()

// Si on souhaite bénéficier de toutes les déclarations
// d'un namespace sans avoir à les préfixer du nom
// du namespace

using namespace MonNameSpace;

  using namespace std;

1

La présence d'un type booléen explicite est assez récente ; auparavant, les entiers étaient interprétés comme des booléens suivant leur valeur nulle ou non-nulle et par compatibilité, un certain nombre de compilateurs C++ continuent à accepter des valeurs entières à la place de valeurs booléennes.

2

zéro-X.

3

zéro.

4

Identification des types au cours de l'exécution.