Programmation système – Types primitifs^[1]

Comme vous le savez déjà, toute donnée traitée par un programme C++ ne possède pas seulement une valeur, mais aussi un type.

Le type d'une donnée permet entre autres de déterminer sa taille, soit l'espace en mémoire vive que cette donnée occupera durant son existence. De plus, le type permet de connaître le schéma ou le format selon laquelle la donnée sera représentée. Par exemple, un entier encodé sur 32 bits et un nombre à virgule flottante encodé sur 32 bits seront tout deux constitués de 32 bits contigüs en mémoire mais les divers bits de chacun auront un sens différent pour le programme, sens qui sera dicté par la nature du type.

En C++ les types de données sont :

• Ceux qu'on dit prédéfinis, les types de données primitifs, qui sont incorporés dans le langage C++ lui-même et connus a priori du compilateur, et
• Ceux qui sont définis par les programmeuses et les programmeurs, comme par exemple les types énumérés (enum), les enregistrements (struct), les union (union) et les classes (class)

Ce document portera sur les types de données primitifs. Nous ferons toutefois une petite incartade pour les types énumérés (plus bas) et pour les enregistrements (plus bas).

Bornes et caractéristiques des types primitifs

Dans ce document, nous référerons souvent aux bornes et aux caractéristiques intrinsèques des types primitifs. Sachez que C et C++ offrent des en-têtes standards décrivant ces types de manière accessible efficacement par les programmes :

• L'en-tête <climits>, version C++ de l'en-tête <limits.h> du langage C, décrit par des macros les bornes minimale et maximale des types primitifs du langage; et
• L'en-tête <limits> définit sous une forme plus utile en C++ les bornes des types primitifs, mais aussi plusieurs données pertinentes à leur sujet (le type supporte-t-il une représentation pour l'infini? Le type supporte-t-il une représentation pour l'infinitésimal (un epsilon)? Le type est-il signé? etc.).

#include <iostream>
#include <limits>
int main ()
{
   using namespace std;
   cout << "Min (short): "   << numeric_limits<short>::min()
        << ", max (short): " << numeric_limits<short>::max() << endl;
}

Valeurs booléennes – le type bool

if (0)
   cout << "Ceci ne s'affichera pas" << endl;
if (-34)
   cout << "Ceci s'affichera" << endl;

Bien que cette approche fonctionne encore et soit encore fort utilisée, il existe maintenant un type de donnée primitif servant spécifiquement à représenter des valeurs booléennes : le type bool. Une variable ou une constante de ce type peut prendre soit la valeur true, soit la valeur false, et rien d'autre^[3] au sens où tenter d'affecter une autre valeur (p. ex. : 28) à un bool résultera en un avertissement de la part du compilateur (un Performance Warning indiquant que le code en question sera inefficace dû à l'obligation qu'aura le compilateur d'y insérer des opérations de conversion de types supplémentaires).

bool est_pair(int n)
{
   bool reponse; // pas initialisée encore
   if (n % 2 == 0)
      reponse = true;
   else
      reponse = false;
   return reponse;
}

Il importe donc d'initialiser chaque variable de type bool lors de sa déclaration, ou du moins de ne pas présumer que cette variable sera true ou false tant et aussi longtemps qu'on ne lui aura pas explicitement affecté de valeur. De toute manière, utiliser en lecture une variable non initialisée est une pratique à éviter, tous langages confondus.

Les types entiers

Pour représenter les nombres entiers, C++ offre les types primitifs suivants :

• bool;
• char;
• wchar_t;
• short int (ou simplement short);
• int;
• long int (ou simplement long); et
• depuis C++ 11, le type long long.

À chacun de ces types (outre bool et wchar_t) peuvent être ajouté les qualificatifs signed (pour indiquer un entier signé) ou unsigned (pour indiquer un entier non signé). Les deux sont mutuellement exclusifs : un entier est soit signé, soit non signé, mais pas les deux.

Un nombre signé peut prendre des valeurs positives ou négatives; un nombre non signé ne peut prendre que des valeurs positives. La valeur zéro est considérée positive pour fins de subdivision des nombres en signé/ non signé (voir cet article pour plus de détails à ce sujet).

// s_i est un signed int
signed s_i;
// u_i est un unsigned int
unsigned u_i;

Les mots clés signed et unsigned, si utilisés seuls, sont équivalents à signed int et unsigned int, respectivement.

Par défaut, tous les types entiers sont signés si ni signed, ni unsigned n'est indiqué explicitement. Seul le type char est différent, étant signé ou non selon l'implantation choisie par et pour le compilateur sur une plateforme donnée.

Le type char

Pour le type char, qui est en fait un entier représenté sur un byte, il existe aussi trois variantes, soit char, signed char et unsigned char. Tel qu'indiqué ci-dessus et contrairement aux autres types entiers, les noms char et signed char ne sont pas systématiquement synonymes^[4].

Puisqu'une donnée de type char occupe un byte en mémoire, on peut l'utiliser pour mémoriser un petit entier ou un caractère.

Afficher un char

#include <iostream>
int main()
{
   using namespace std;
   char c = 'A';
   cout << c << endl; // affiche A
   int i = c; // même valeur mais perçue comme un int
   cout << i << endl; // affiche 65
   // l'entier 50 correspond au code affichable du caractère '2'
   c = 50;
   cout << c << endl; // affiche 2
}

Lorsqu'on affiche un caractère, on voit sa représentation selon un code entreposé dans une table (traditionnellement mais pas exclusivement la table ASCII). Cette table fait une association entre chaque caractère et un nombre entier. Il existe plusieurs correspondances entre valeur entière et symbole affichable, incluant (sans s'y limiter) les correspondances ASCII et ANSI, bien connues en Amérique du Nord.

Par exemple, lorsque le caractère 'A' est entreposé dans une variable de type char, on retrouve réellement en mémoire le nombre 65 ou, exprimé sous forme binaire, 01000001. Le symbole correspondant à la valeur 65 selon le standard ASCII est le 'A' majuscule.

Le type wchar_t

En pratique, dans le monde de l'informatique contemporaine et à l'ère Internet, on ne peut plus penser un programme pour la seule clientèle nord-américaine. L'internationalisation du code est un dossier important, riche et complexe.

#include <iostream>
int main()
{
   using namespace std;
   // préfixe L pour indiquer
   // un caractère étendu
   wchar_t c = L'A';
   // idem pour les séquences
   wchar_t *s = L"allo";
   wcout << c << L' ' << s << endl;
}

Habituellement, un wchar_t occupe un espace de 2 bytes. Il peut être signé ou non selon l'implémentation, mais on ne peut le qualifier explicitement signed ou unsigned. Sa raison d'être est véritablement d'entreposer et de représenter un caractère étendu; bien qu'il soit un type entier, il n'est pas recommandable de l'utiliser pour des fins arithmétiques. Voir cet article pour plus de détails.

Espace occupé et signe d'un nombre

L'espace en mémoire qu'occupe une donnée du type char (ou de tout type entier) est le même que ce type soit signé ou non. En fait, ce qui varie alors est l'intervalle des combinaisons possibles. Un entier signé sur un byte et un entier non signé sur un byte ont tous deux la même taille, après tout :

sizeof(char)==1
sizeof(char)==sizeof(unsigned char)
sizeof(char)==sizeof(signed char)

La borne supérieure de la déclinaison unsigned d'un type entier est plus élevée que la borne supérieure de la déclinaison signed du même type, alors que la borne inférieure de la déclinaison signed d'un type entier est plus basse que la borne inférieure de la déclinaison unsigned du même type.

Caractères standards et caractères étendus

Il n'y a habituellement pas de différence entre une donnée de type signed char et une donnée de type unsigned char tant que celle-ci sert à mémoriser un caractère standard (au sens des états-uniens, excluant donc – entre autres – les caractères accentués de la langue française). Ces caractères ont une valeur se situant entre 0 et 127 inclusivement quand la représentation sous-jacente est ASCII ou ANSI.

#include <iostream>
int main()
{
   using namespace std;
   unsigned char a= 227;
   signed char   b= 227;
   char          c= 227;
   cout << "a: "   << static_cast<int>(a) // affichera 227
        << ", b: " << static_cast<int>(b) // affichera -29
        << ", c: " << static_cast<int>(c) // affichera 227 ou -29 selon la plateforme
        << endl;
}

Notez la présence de conversions explicites de types ISO : le static_cast<int>(a), par exemple, qui a pour but d'indiquer au compilateur de traiter a comme un int plutôt que comme un unsigned char, ce qui force l'affichage de la valeur entière dans la variable plutôt que celui du symbole correspondant dans une table.

Les types short, int et long

S'il est possible d'encoder des entiers sur des variables de type char, il est plus commun de le faire sur l'un de trois types entiers que sont les types short, int et long.

Les règles du langage C++ exigent du type short qu'il occupe au moins aurant d'espace que le type char, sans toutefois dépasser la taille du type int. Elles exigent aussi du type int qu'il occupe au moins autant d'espace que le type short, sans toutefois dépasser la taille du type long. Ainsi :

• Dans la plupart des implantations du langage – mais pas toutes – un short occupera deux bytes (16 bits) en mémoire
• Selon les compilateurs, un int sera représentées sur deux ou quatre bytes (donc sur 16 ou 32 bits), quoiqu'il existe des cas où on retrouve des int encodés sur 64 bits
• Un long occupera habituellement un espace de quatre bytes (32 bits), bien qu'on trouve sur certaines plateformes des long encodés sur 64 ou même 128 bits

#include <iostream>
int main()
{
   using namespace std;
   unsigned short u_s = 32767;
   signed   short s_s = 32767;
   cout << u_s++ << ",";
   cout << u_s << ";";
   cout << s_s++ << ",";
   cout << s_s << ";" << endl;
}

Types à virgule flottante

Les types dits à virgule flottante servent à représenter des approximations à divers niveaux de précision de nombres réels.

Les nombres à virgule flottante ne sont pas représentés de la même façon que les entiers, ce qui comporte son lot d'avantages et de désavantages. Leur représentation interne se compose de trois parties: le signe, l'exposant et la mantisse.

Le langage C++ offre trois types différents pour représenter les nombres à virgule flottante, soit float, double et long double.

Le type float

Une donnée de type float occupe au moins quatre bytes – ce nombre peut varier, mais l'encodage sur 4 bytes semble être la norme – et sa taille ne peut dépasser celle du type double.

• La mantisse d'un float occupe 24 des 32 bits de sa représentation.
• L'exposant est stocké sur 7 bits et le signe sur le bit restant.

En tenant compte de ces affirmations, on peut mémoriser dans un float des nombres allant de 3,4*10^-38 à 3,4*10³⁸ inclusivement.

Les types double et long double

Le type double doit avoir une taille au moins égale à celle du type float et au plus égale à celle du type long double.

L'implantation du type double occupe généralement huit bytes (typiquement 64 bits) en mémoire, avec une mantisse de 53 bits et un exposant de 10 bits. Un double peut donc représenter des nombres allant de 1,7*10^-308 à 1,7*10³⁰⁸ inclusivement.

Le type long double doit avoir une taille au moins égale à celle du type double.

L'implantation du type long double occupe généralement 10 ou 12 bytes en mémoire – la plus répandue est celle à 10 bytes, typiquement 80 bits, soit une mantisse de 64 bits munie d'un exposant de 15 bits, pour des valeurs allant de 1,2*10^-4932 à 1,2*10⁴⁹³² inclusivement – mais certaines implantations commerciales offrent des types double et long double de même taille.

Nombres à virgule flottante et précision

Il est extrêmement important de se souvenir que les nombres à virgules flottantes sont des approximations, pas des valeurs exactes comme le sont les entiers, et que leur précision n'est garantie que pour un nombre de décimales significatives, soit :

• 6 décimales significatives pour un nombre à virgule flottante encodé sur 32 bits (le float typique);
• 15 décimales significatives pour un nombre à virgule flottante encodé sur 64 bits (le double typique); et
• 18 décimales significatives pour un nombre à virgule flottante encodé sur 80 bits (le long double typique).

Lorsqu'on dépasse cette précision avec une opération arithmétique (ce qui arrive bien sûr fréquemment, puisque les réels peuvent exiger une précision infinie), une part d'approximation sera effectuée par le processeur, ce qui provoquera inévitablement une perte de précision, et peut mener à des erreurs. Les erreurs, quant à elle, peuvent se multiplier à long terme et passer de petite à considérable, ce qui implique qu'une saine manipulation de nombres à virgule flottante est à la fois chose délicate et essentielle dans la majorité des applications de nature scientifique.

Cas particulier : le type void

Le type void décrit un ensemble vide de valeurs. Il est impossible de déclarer une variable ou une constante de type void, bien que des pointeurs de type void (des pointeurs abstraits soient assez fréquents).

Ce type permet surtout de déclarer des procédures (fonctions ne retournant aucune valeur), et permet certaines manoeuvres de programmation un peu particulières, auxquelles vous serez convié(e)s éventuellement.

Taille des types primitifs

const short NOTE_MAX = 100;
int n = 3;
cout << sizeof(NOTE_MAX)       << ","
     << sizeof(IndiceEtudiant) << ","
     << sizeof(double);

Pour tout compilateur C++ conforme à la norme ISO, les relations suivantes seront respectées :

• sizeof(char)==1, donc un char occupe un espace d'un byte;
• sizeof(char)<=sizeof(short);
• sizeof(short)<=sizeof(int). Notez que sizeof(int) tend à être égal à la taille d'un mot mémoire, mais ce n'est pas garanti par le standard. Règle générale, int sera le type sur lequel les opérations seront les plus rapides sur un ordinateur donné;
• sizeof(int)<=sizeof(long). Notez que tout cela signifie qu'il peut arriver, sur certains ordinateurs et avec certains compilateurs, que les tailles des types char, short, int et long soient toutes égales, même si ce n'est pas habituel;
• sizeof(float)<=sizeof(double); et
• sizeof(double)<=sizeof(long double).

Souvenez-vous que sizeof(void) est illégal. Notez aussi que, hormis le cas particulier du Empty Base Class Optimization, tout type C++ occupe au moins un byte de mémoire.

Pour connaître la taille des pointeurs ou pour en savoir plus au sujet de l'opérateur sizeof, référez-vous à cet article.

Nous verrons maintenant comment s'évalue la taille d'un type maison.

Définir ses propres types de données

// auparavant: typedef unsigned long Quantite;
using Quantite = unsigned long;
// équivaut à unsigned long Cargo;
Quantite Cargo;

Il est possible pour une programmeuse ou un programmeur de définir des types de données à partir des types de données primitifs du langage. Le cas le plus simple est celui d'un nom servant d'alias pour un type primitif, à l'aide du mot clé typedef ou, dans du code plus contemporain, avec le mot clé using.

L'exemple proposé à droite définit un type Quantite équivalent à unsigned long, et déclare une variable Cargo du type Quantite.

Les types énumérés

Un type énuméré est un type entier défini par l'utilisateur et déclaré à l'aide du mot réservé enum.

On peut, à l'aide des types énumérés, énoncer un à un les éléments d'un tout. Cette énonciation affecte à chaque élément une valeur entière. Le résultat est un ensemble de constantes dont l'utilisation permet d'écrire des programmes beaucoup plus clairs sans qu'on ait à connaître leurs valeurs spécifiques – ce qui n'empêche pas de connaître ces valeurs si on en ressent le besoin.

À titre d'exemple, supposons qu'on désire déclarer des variables pouvant représenter les couleurs primaires rouge, bleu et vert et ce, sans vraiment se préoccuper des valeurs spécifiques à l'un ou à l'autre. Dans un tel cas, les deux options ci-dessous sont possibles.

const int rouge = 0,
          bleu = 1,
          vert = 2;
// primaire est un alias pour int
using Primaire = int;
// en C ou en C++ 03 : typedef int Primaire;
// déclaration d'une variable de ce type
Primaire couleur = vert;

enum Primaire
{
   rouge
,  bleu
,  vert
}; // définition du type
// déclaration d'une variable de ce type
Primaire couleur = vert;

Une fois ces déclarations faites, dans un cas comme dans l'autre, il existera un type Primaire pouvant contenir les valeurs rouge, bleu et vert. Toutefois, la version à gauche, avec constantes entières et définition d'un alias ne permet pas d'empêcher l'affectation de la valeur -37 à un primaire puisque primaire n'est alors qu'un autre mot pour dire int. Dans la version à droite, le type Primaire est un type à part entière.

En fait, dans la version de notre exemple utilisant une énumération, les constantes rouge, bleu et vert de type Primaire correspondent à des entiers aux valeurs allant de 0 à 2, dans l'ordre.

enum Primaire
{
   rouge
,  bleu = 3
,  vert
};
Primaire couleur = vert;

Bien qu'on emploie généralement des constantes énumérées lorsque la valeur de l'une ou de l'autre importe peu, il peut arriver qu'il devienne pertinent de contourner le bon usage et qu'on veuille connaître la valeur d'une telle constante. Il se trouve que par défaut, en C++, la première constante énumérée dans la séquence – ici: rouge – vaudra toujours 0, la suivante vaudra 1 et ainsi de suite.

Il est possible de briser la séquence en identifiant directement l'une d'entre elles comme ayant une valeur spécifique. Par exemple, si on définissait plutôt le type Primaire comme proposé à droite, alors les valeurs précises que prendraient rouge, bleu et vertdeviendraient respectivement 0, 3 et 4.

Un type énuméré est représenté par un int. Clairement, pour le type primaire comme pour tout type énuméré, sizeof(Primaire)==sizeof(int). Les opérations arithmétiques usuelles sur un int s'appliquent aussi à un enum, ce qui implique que l'ordre des valeurs des divers symboles de l'énumération devrait être tel que les opérateurs relationnels <, <=, >, >=, == et != aient un effet respectant l'intuition des programmeurs.

Les langages C et C++ ont des notations distinctes pour décrire un type énuméré.

typedef enum
{
   Dimanche,
   Lundi, Mardi, Mercredi,
   Jeudi, Vendredi,
   Samedi,
}
Jour;
bool est_fin_de_semaine(Jour j)
   { return j == Samedi || j == Dimanche; }

enum Jour
{
   Dimanche,
   Lundi, Mardi, Mercredi,
   Jeudi, Vendredi,
   Samedi,
};
bool est_fin_de_semaine(Jour j)
   { return j == Samedi || j == Dimanche; }

Entrées/ sorties avec une constante énumérée

#include <iostream>
int main()
{
   using namespace std;
   enum Primaire
   {
      rouge, bleu, vert
   };
   Primaire prim = vert;
   cout << prim << endl; // affichera 2
}

Pour mieux faire, il importe de définir des opérateurs de projection sur un flux ou d'extraction d'un flux pour le type énuméré visé :

#include <iostream>
#include <string> // correspondance nom/ valeur
enum Primaire
{
   inconnu = -1, rouge, bleu, vert
};
std::istream& operator>>(std::istream &is, Primaire &p)
{
   if (!is) return is;
   using std::string;
   string s;
   if (!(is >> s)) return is;
   // Ceci pourrait être nettement optimisé et raffiné.
   // Je vous laisse le travail en exercice
   if (s == "rouge")
      p = rouge;
   else if (s == "bleu")
      p = bleu;
   else if (s == "vert")
      p = vert;
   else
      p = inconnu;
   return is;
}
std::ostream& operator<<(std::ostream &os, const Primaire p)
{
   // sujet à optimisation par savoir discret
   switch (p)
   {
   case rouge:
      os << "rouge";
      break;
   case bleu:
      os << "bleu";
      break;
   case vert:
      os << "vert";
      break;
   default:
      os << "inconnu";
   }
   return os;
}
int main()
{
   using namespace std;
   Primaire p = vert;
   cout << vert << endl; // affichera "vert"
}

Il existe des techniques plus efficaces pour en arriver au même résultat, incluant celle décrite dans Technique-Optimisation-savoir-discret.html

Enregistrements

Il est fréquemment utile de regrouper des variables de différents types de données dans un ensemble cohérent – dans un même type. On nommera ce genre de regroupement enregistrement, qu'on définira comme un contenant organisé de données de types distincts regroupées selon leur appartenance logique. Un enregistrement correspond en C et en C++ au mot clé struct. Notez qu'en C++, un struct est plus polyvalent qu'en C, bien que cela ne nous concerne pas ici.

Par exemple, supposons qu'on veuille représenter un(e) étudiant(e) par son âge, représenté par un entier non signé sur 16 bits, et par sa note globale, un nombre à virgule flottante de simple précision.

Il est possible de représenter cet(te) étudiant(e) par une paire de variables (les deux variables à gauche), mais il est aussi possible de le faire par un enregistrement (la variable e de type Etudiant, à droite) :

unsigned short age;
float note;

struct Etudiant
{
   unsigned short age;
   float note;
};
Etudiant e;

struct Etudiant
{
   using age_t = unsigned short;
   using note_t = float;
   age_t age;
   note_t note;
};
Etudiant e;

Les langages C et C++ ont des notations distinctes pour décrire un enregistrement..

typedef struct
{
   short y, y;
}
Point;
bool est_origine(const Point &p)
   { return p.y == 0 && p.y == 0; }

struct Point
{
   short x, y;
};
bool est_origine(const Point &p)
   { return p.y == 0 && p.y == 0; }

Membres d'un struct

#include <iostream>
struct Point
{
   short x,y;
};
int main()
{
   using namespace std;
   Point p;
   if (cin >> p.x >> p.y)
      cout << "Le point est à la position { "
           << p.x << ' ' << p.y << " }" << endl;
}

Entrées/ sorties avec une constante énumérée

On peut faire encore mieux et définir des opérateurs d'insertion sur un flux et d'extraction d'un flux sur un enregistrement. L'exemple suivant montre comment on pourrait définir ces opérateurs sur le type Point. Notez que la validation des balises ',' et '}' dans l'opérateur d'extraction d'un flux pourrait être améliorée.

#include <iostream>
struct Point
{
   short x, y;
};
//
// support du format "{ X , Y }" et du format "X Y"
//
std::istream& operator>>(std::istream &is, Point &p)
{
   if (!is) return is;
   char c;
   short x, y;
   if (is >> c && c == '{')  // format "{ X , Y }"
   {
      if (is >> x >> c >> y) // c consomme la virgule (perfectible)
         if(is >> c && c == '}')               // consommer '}'
         {
            p.x = x;
            p.y = y;
         }
   }
   else
   {
      is.unget();           // remettre le flux dans son état initial
      if (is >> x >> y)     // format "X Y"
      {
         p.x = x;
         p.y = y;
      }
   }
   return is;
}
std::ostream& operator<<(std::ostream &os, const Point &p)
   { return os << '{' << p.y << ',' << p.y << '}'; // format "{X,Y}" }
int main()
{
   using namespace std;
   Point p;
   if (cin >> p)
      cout << "Le point est à la position " << p << endl;
}

Taille d'un struct

La taille en mémoire d'une structure correspond à au moins la somme des tailles de ses attributs, ce qui devrait vous sembler raisonnable. Le calcul exact permettant d'évaluer la taille d'un enregistrement dépendra de plusieurs facteurs :

• Les compilateurs inséreront habituellement un peu de tamponnage entre les attributs pour que le début de chacun soit aligné sur la taille d'un mot mémoire, du fait que l'accès en mémoire à une donnée ainsi alignée est plus rapide que ne l'est l'accès à une donnée qui ne l'est pas. Voir Alignement.html pour plus de détails
• Sur demande, les compilateurs pourront générer un enregistrement compact et sans tamponnage. Ceci sera préférable pour les ordinateurs ou les systèmes informatiques pour lesquels la consommation en espace mémoire compte plus que la rapidité de l'accès aux données
• Il n'est donc pas sécuritaire de présumer de la taille exacte d'un enregistrement à partir de la taille de ses attributs. Au mieux, la somme des tailles des attributs d'un enregistrement constitue sa taille minimale

De l'avantage de nommer les choses rapidement

Imaginons un programme devant gérer des noeuds d'une liste chaînée. Un noeud sera un enregistrement représenté par le type Noeud. Chaque Noeud contiendra une valeur (un int, disons) et un pointeur sur le Noeud suivant (qui sera nul à la fin de la liste).

// alias pour un type pas encore déclaré!
typedef Noeud *ptrNoeud_t;
typedef struct
{
   int val;
   ptrNoeud_t succ; // pointeur sur un Noeud
} Noeud; // le type Noeud existe maintenant

struct Noeud
{
   int val;
   Noeud *succ; // pointeur sur un Noeud
};

Initialisation automatique

Il est toujours possible, en C++, d'initialiser une variable lors de sa déclaration. On le fait déjà spontanément avec les constantes, puisqu'il est interdit d'affecter une valeur à une constante après sa déclaration.

La syntaxe est d'ailleurs la même pour une variable que pour une constante. Toutes les déclarations ci-après sont valides en C++.

enum Jour
{
   Dimanche,
   Lundi, Mardi, Mercredi,
   Jeudi, Vendredi,
   Samedi
};
int main()
{
   const double PI = 3.14159;
   const Jour JOUR_DE_PAYE = Jeudi;
   short s  = 12;
   int   i1 = -24,
         i2 = 35001;
   float f  = 0.47f;
   jour  j  = Samedi;
   // ...
}

Règle générale, dans les langages orientés objets comme C++, il est préférable de définir les variables et les constantes près de leur premier point d'utilisation, idéalement à un moment où il est possible de les initialiser.

Initialisation automatique d'un struct

struct Point
{
   float x, y;
};
// constante de type Point
const Point ORIGINE = { 0.0f, 0.0f };
int main()
{
   // variable de type Point
   Point pos = { 25.4, -2.0 };
   // ...
}

C++ et les constructeurs

struct Point
{
   float X, Y;
   // constructeur par défaut
   Point()
      : x{}, y{}
   {
   }
   //
   // constructeur paramétrique
   // (remarquez la syntaxe)
   //
   Point(float x, float y)
      : x{x}, y{y}
   {
   }
};
int main()
{
   // construction par défaut
   Point p0;
   // construction paramétrique
   Point p1{3.5f, -2.0f};
}

Un constructeur a pour rôle d'initialiser les attributs d'un objet. Le constructeur est un sous-programme sans type qui porte le même nom que celui du type qu'il sert à initialiser. S'il ne prend pas de paramètres, alors on dit qu'il s'agit d'un constructeur par défaut. S'il prend des paramètres, on dit de lui qu'il est un constructeur paramétrique. Il est aussi possible (et souvent nécessaire) d'offrir ce qu'on nomme un constructeur par copie, mais nous éviterons ce sujet ici.

En ayant recours au constructeur, l'initialisation d'un enregistrement devient un sous-programme dans lequel il est possible d'effectuer du traitement complexe (une répétitive, la lecture dans un fichier, de l'allocaiton dynamique de mémoire, etc.).

Notez que les types primitifs ont aussi en C++ un constructeur par défaut, mais qui n'est applicable que si on l'invoque explicitement (p. ex. : int i = int();). L'initialisation par défaut d'un type primitif lui appose l'équivalent de la valeur zéro pour le type en question. Ce détail est peu connu et sert surtout pour faciliter la programmation générique. Depuis C++ 11, on écrira simplement int i{}; qui est plus simple et plus homogène.

Enregistrements imbriqués

Tout comme il est possible de créer un enregistrement à partir d'un assemblage de types primitifs, il est aussi possible de créer un enregistrement à partir d'autres enregistrements.

Le fonctionnement est le même, pour la définition du type comme pour la déclaration des variables, des constantes, et l'initialisation.

#include <iostream>
struct Point
{
   float x, y;
};
struct Carre
{
   Point position;
   int longueur;
};
std::istream& operator>>(std::istream &is, Carre &c)
{
   if (!is) return is;
   Point pos;
   int lg;
   if (is >> pos >> lg)
   {
      c.position = pos;
      c.longueur = lg;
   }
   return is;
}
std::ostream& operator<<(std::ostream &os, const Carre &c)
   { return os << c.position << ' ' << c.longueur; }
int main()
{
   using namespace std;
   Carre c =
   {
      { -1.0, 1.0 }, // position du carré (de type Point)
      10             // longueur d'un côté (de type int)
   };
   // exemple d'accès aux membres de c et aux membres de
   // son membre Position. Affichera "{-1, 1}, 10"
   cout << "{" << c.position.x << ", "
        << c.position.y << "}, "
        << c.longueur << endl;
   // ...
}

#include <iostream>
struct Point
{
   float x, y;
   // par défaut, X==0.0f et Y==0.0f
   Point()
      : x{}, y{}
   {
   }
   Point(float x, float y)
      : x{x}, y{y}
   {
   }
};
struct Carre
{
   Point position;
   int longueur;
   // par défaut: position par défaut et longueur 1
   Carre()
      : Carre{1}
   {
   }
   // position par défaut, longueur choisie par l'appelant
   Carre(int longeur)
      : position{}, longueur{longueur}
   {
   }
   // position et longueur choisies par l'appelant
   Carre(float x, float y, int longueur)
      : position{x,y}, longueur{longueur}
   {
   }
   // position et longueur choisies par l'appelant
   Carre(const Point &p, int longueur)
      : Position{p}, longueur{longueur}
   {
   }
};
//
// opérateurs agissant sur les flux inchangés
// (voir plus haut)
//
int main()
{
   Carre c0; // à l'origine, 1x1
   Carre c1{3}; // à l'origine, 3x3
   Carre c2{1.5f, 1.5f, 3}; // pos {1,.5,1.5}, 3x3
   Carre c3{Point{-1.0f, -1.0f}, 2}; // pos {-1,-1}, 2x2
   // ...
}

Utiliser des pointeurs

En C et en C++, toute donnée a une adresse accessible à l'aide de l'opérateur &. Ainsi, si val est une variable, alors &val exprime l'adresse de val.

Si une donnée a un type, alors son adresse a aussi un type, et ce type est pointeur sur le type de cette donnée. Un pointeur est une adresse typée. L'accès à la donnée pointée par un pointeur est un accès indirect, ou une indirection.

Si val est une variable int, alors &val est de type pointeur sur un int, ou int *. Si VAL est une constante int, alors le type de &VAL est pointeur sur un int constant, ou const int *.

On peut obtenir le contenu pointé par un pointeur en le déréférençant à l'aide de l'opérateur *. Si p est un pointeur, alors *p signifie ce qui se trouve là où pointe p. Si p est un int *, alors *p est un int (pour être plus précis, il s'agit du int qui se trouve à l'adresse indiquée par p). Si p est un const int *, alors *p est un const int.

int main()
{
   char c = 'A';
   int *p = &c; // illégal
   // devient légal, mais dangereux
   int *q = reinterpret_cast<int *>(&c);
   *q = 3; // considère *q comme un int... or c'est un
           // char! On vient d'écrire sur c, mais aussi
           // sur les sizeof(int)-sizeof(char) bytes
           // qui suivent... Qui sait ce que nous venons
           // d'endommager?
}

C'est une bonne chose, puisque certaines manoeuvres (en particulier celles devant parfois être réalisées près du matériel) en dépendent, mais cela implique de la part du programmeur discipline, rigueur, prudence et (surtout) indique qu'il faut éviter le plus possible les conversions explicites de types et rendre celles que nous réalisons les plus visibles possibles dans un programme.

Par convention, l'adresse 0 est inaccessible à tout programme et un pointeur vers 0 (ou pointeur nul) est considéré comme non initialisé. Il est donc sage d'initialiser systématiquement vos pointeurs à 0 si vous ne comptez pas les utiliser immédiatement après qu'ils aient été déclarés.

Pointeurs et enregistrements

#include <iostream>
struct Point
{
   int x, y;
};
int main()
{
   using namespace std;
   Point pt = { 1, 5 };
   Point *p = &pt; // p pointe sur pt
   cout << pt.x << ',' << pt.y << endl
        << (*p).x << ',' << (*p).y << endl
        << p->x << ',' << p->y << endl;
}

Selon les circonstances, on préférera l'une ou l'autre de ces notations. Il importe d'être habile avec chacune d'entre elles.

Pointeurs abstraits

Il peut arriver qu'un programme souhaite représenter une adresse a usens abstrait. Dans ce cas, le type à utiliser est void *. Il est illégal de déclarer une variable de type void mais il est très légal de manipuler un pointeur void *.

Toutefois, on le comprendra, il est illégal de le déréférencer puisqu'on obtiendrait alors une donnée de type void, chose interdite par le langage. Un void * doit être converti explicitement en un autre type de pointeur avant qu'on puisse opérer sur son contenu. La conversion implicite de tout pointeur en void* est toutefois légale (aux qualifications const et volatile près).

Pointeurs de pointeurs

Il peut arriver qu'un programme doive manipuler l'adresse d'une adresse. Pas de problème: si p est un pointeur, disons un int *, alors &p est son adresse, donc un int ** (ou pointeur sur un pointeur de int). Certaines techniques impliquent la manipulation de créatures étranges comme des void **.

Tout compilateur C ou C++ doit supporter un minimum de six niveaux d'indirections. Cela dit, la plupart des programmes ne dépassent que très rarement la double indirection.

Arithmétique de pointeurs

Il est possible de réaliser de l'arithmétique sur des pointeurs. En fait, la majorité des programmes y ont recours sans s'en apercevoir de par leur usage de tableaux.

Si p est un int *, alors p+1 représente conceptuellement l'adresse du prochain int en mémoire après celui pointé par p si on considère la mémoire comme n'étant faite que d'une immense séquence de int contigüs (comme un immense tableau de int). De même, p+n représente l'adresse p à laquelle on a ajouté n*sizeof(int) bytes.

int main()
{
   // *p est de type char
   char *p = nullptr;
   // le compilateur transforme 3 en '\3'
   // (les deux instructions suivantes
   // sont essentiellement équivalentes)
   *(p+1000) = 3;
   *(p+1000) = '\3';
   // accès direct!
   *(reinterpret_cast<char *>(1000)) = '\3';
   // q pointe à l'adresse 1000
   char *q = reinterpret_cast<char *>(1000);
   *q = '\3';
}

Bien qu'il ne faille pas agir ainsi sans savoir ce que l'on fait, il arrive fréquemment en programmation système qu'on doive accéder à une adresse précise (celle d'un élément matériel, par exemple, ou dans un cas à haute performance où notre programme doit gérer manuellement un espace mémoire selon des politiques qui lui sont propres).

int main()
{
   int tab[10];
   // accès par indice
   for (int i = 0; i < 10; ++i)
      tab[i] = i + 1;
   // arithmétique de pointeurs et indirection
   for (int i = 0; i < 10; ++i)
      *(tab+i) = i + 1;
   // itérer avec un pointeur
   for (int i = 1, *p = tab; i < 10; ++p, ++i)
      *p = i;
   // plus subtil
   {
      int i = 0, *p = tab;
      while (p != tab + 10) *p++ = ++i;
   }
}

Distinguer le programme et la mémoire

La mémoire d'un ordinateur est une zone brute, qui ne connaît pas les types de données. Le programme exprime des types, le compilateur génère du code très primitif en correspondance avec les types et les opérations décrites par le programme, mais en bout de ligne un pointeur n'est qu'une adresse en mémoire.

Cela signifie que si un programme choisit de mentir au compilateur et de faire pointer un pointeur d'une nature donnée (disons un Point *) sur une donnée d'un autre type dans le programme (disons un short *), il ne sera plus possible de savoir que la donnée au bout du pointeur n'est pas du bon type une fois l'affectation réalisée. Toutes les zones mémoire sont équivalentes.

Les pointeurs sont, clairement, un outil de grande personne. un pointeur n'est pas un jouet.

Les littéraux

const float PI = 3.14159;

Supposons qu'on écrive ce qui suit. Alors, le compilateur nous générera (avec raison) un avertissement signalant une forme de perte de précision. Pourtant, la valeur 3.14159 devrait pouvoir amplement être représentée par une constante de type float, n'est-ce pas? Que se passe-t-il exactement ici?

Le type des littéraux

Tout littéral a un type, avant même d'être affecté à une variable ou à une constante. En effet, quand un programme comprend l'expression float f="allo";, le compilateur doit être en mesure de détecter l'incongruité de l'expression et de souligner le problème de manière claire, or le problème est un conflit de types et doit être détecté et souligné comme tel.

Ainsi, en C++ :

• Un littéral entier, comme par exemple 3 ou -87, est de type int
• Pour imposer au compilateur de considérer un littéral entier comme étant de type long, il faut lui apposer le suffixe L (le suffixe l est aussi valide mais il est difficile à différencier du littéral entier 1 alors il est préférable de s'en tenir à la version majuscule). Ainsi, 3L et -87L sont des long
• Un littéral à virgule flottante, comme par exemple -3.14159 et 0.0, est de type double
• Un littéral à virgule flottante suffixé par L , comme par exemple -3.14159L et 0.0L, est de type long double
• Pour imposer au compilateur de considérer un littéral à virgule flottante comme étant de type float, il faut lui apposer le suffixe f ou le suffixe F. Par conséquent, -3.14159f et 0.0f sont des float
• Il est illégal d'appliquer le suffixe U à un littéral float ou double
• Pour imposer au compilateur de considérer un littéral entier comme étant non signé, il faut lui apposer le suffixe U ou le suffixe u. Le suffixe U et le suffixe L peuvent être combinés dans un ordre comme dans l'autre. Ainsi, 3UL est un littéral unsigned long et 1000U est de type unsigned int. Le littéral -3U est légal mais générera un avertissement à la compilation du fait que la tentative de déposer une valeur négative dans un type non signé sera transformée en un gros nombre positif
• Un littéral de type char sera présenté entre apostrophes. Certains caractères spéciaux seront représentés à l'aide d'une combinaison de caractères nommée séquence d'échappement et seront précédés d'une contre-estafilade (d'un backslash). Ainsi, pour une liste indicative mais non exhaustive :
  • le littéral 'A' est la valeur entière correspondant au caractère A;
  • le littéral 'a' est la valeur entière correspondant au caractère a;
  • le littéral '1' est la valeur entière correspondant au caractère 1 (indice du symbole affichable 1 dans une table – valeur 49 dans la table ASCII – ce qui n'est très probablement pas la même chose que la valeur 1);
  • le littéral '$' est la valeur entière correspondant au caractère $;
  • le littéral '\n' est la valeur entière correspondant à un saut de ligne (New Line);
  • le littéral '\t' est la valeur entière correspondant à une tabulation;
  • le littéral '\a' est la valeur entière correspondant à une sonnerie (Alarm);
  • le littéral '\b' est la valeur entière correspondant à un retour en arrière (Backslash);
  • le littéral '\0' est la valeur zéro encodée sur un byte (ce qui est différent du caractère affichable '0');
  • le littéral '\65' est la valeur soixante-cinq encodée sur un byte (ce qui correspond au caractère affichable 'A' dans la table ASCII) et exprimée en notation décimale;
  • le littéral '\0101' est la valeur soixante-cinq encodée sur un byte (ce qui correspond au caractère affichable 'A' dans la table ASCII) et exprimée en notation octale;
  • le littéral '\0x41' est la valeur soixante-cinq encodée sur un byte (ce qui correspond au caractère affichable 'A' dans la table ASCII) et exprimée en notation hexadécimale;
• Le littéral "allo" est de type const char * et représente la séquence ASCIIZ de caractères 'a','l','l','o','\0' (la valeur '\0', donc 0 encodée sur un char représente un délimiteur de fin de chaîne ASCIIZ)
• Un littéral de la forme L'A' est de type wchar_t. Les règles sont les mêmes que pour les littéraux de type char, au préfixe L près
• un littéral de la forme L"allo" est de type const wchar_t *. Les règles sont les mêmes que pour les littéraux de type const char *, au préfixe L près

#include <iostream>
int main()
{
   using namespace std;
   cout << sizeof(0.0) << ',' << sizeof(-3.14159) << ','
        << sizeof(0.0f) << ',' << sizeof(-3.14159f)
        << endl
        << sizeof(0) << ',' << sizeof(127L) << ','
        << sizeof(32767) << ',' << sizeof(65535L)
        << endl
        << sizeof(-32768) << ',' << sizeof(1000000) << ','
        << sizeof(-1000000)<< ',' << sizeof(65536)
        << endl
        << 0x000a << ',' << 0x0100 << ',' << 10 << ',' << -1U
        << endl;
}

Les opérateurs bit à bit

Ce qui suit se veut un petit outil de référence pour la manipulation des bits de par les opérateurs mis à votre disposition par les langages C et C++ (mais aussi dans bien d'autres langages comme Java, C#, JavaScript, etc. Il y a parfois des nuances d'un langage à l'autre – par exemple, règle générale, Java ne supporte pas les entiers non signés – alors renseignez-vous!).

Opérateur ET bit à bit (&)

L'opération c = a & b dépose dans c une valeur pour laquelle chaque bit aura la valeur 1 seulement s'il était à 1 à la fois pour a et pour b, et aura la valeur 0 dans tous les autres cas.

short a= 0x0101, // a == 257_10 ou 401_8 ou 0000000100000001_2
      b= 0x0100, // b == 256_10 ou 400_8 ou 0000000100000000_2
      c;
c= a & b; // c == 0x0100, ou 256_10 ou 400_8 ou 0000000100000000_2

Opérateur OU bit à bit (|)

L'opération c = a | b met dans c une valeur pour laquelle chaque bit aura la valeur 1 s'il était à 1 soit pour a, soit pour b, et aura la valeur 0 dans tous les autres cas.

short a= 0x0101, // a == 257_10 ou 401_8 ou 0000000100000001_2
      b= 0x0100, // b == 256_10 ou 400_8 ou 0000000100000000_2
      c;
c= a | b; // c == 0x0101, ou 257_10 ou 401_8 ou 0000000100000001_2

Opérateur OU EXCLUSIF bit à bit (^)

L'opération c = a ^ b dépose dans c une valeur pour laquelle chaque bit aura la valeur 1 s'il était différent pour a et pour b, et aura la valeur 0 dans tous les autres cas.

short a= 0x0101, // a == 257_10 ou 401_8 ou 0000000100000001_2
      b= 0x0110, // b == 272_10 ou 420_8 ou 0000000100010000_2
      c;
c= a ^ b; // c == 0x0011, ou 17_10 ou 21_8 ou 0000000000010001_2

Glissement vers la gauche (<<)

L'opération c = a << b affecte à c la valeur de a mais avec chaque bit glissé de b positions vers la gauche.

Le vide créé à droite est rempli par des bits de valeur 0. Les bits poussés hors limite à gauche disparaissent.

#include <iostream>
int main()
{
   using namespace std;
   signed short s=      -1; // (signed short)      -1_10 == 0xffff
   unsigned short u= 32767; // (unsigned short) 32767_10 == 0xffff
   cout << hex;
   for (int i= 1; i < 16; i++)
      cout << static_cast<unsigned short> (s << i)<< ' ';
   cout << endl;
   for (int i= 1; i < 16; i++)
      cout << static_cast<unsigned short> (u << i)<< ' ';
   cout << dec << endl;
}

Le résultat imprimé en sera :

fffe fffc fff8 fff0 ffe0 ffc0 ff80 ff00 fe00 fc00 f800 f000 e000 c000 8000
fffe fffc fff8 fff0 ffe0 ffc0 ff80 ff00 fe00 fc00 f800 f000 e000 c000 8000

Glissement vers la droite (>>)

L'opération c = a >> b affecte à c la valeur de a mais avec chaque bit glissé de b positions vers la droite. Le vide créé à gauche est rempli par la valeur du signe de a. Les bits à droite disparaissent.

#include <iostream>
int main()
{
   using namespace std;
   signed short s=      -1; // (signed short)      -1_10 == 0xffff
   unsigned short u= 32767; // (unsigned short) 32767_10 == 0xffff
   cout << hex;
   for (int i= 1; i < 16; i++)
      cout << static_cast<unsigned short> (s >> i)<< ' ';
   cout << endl;
   for (int i= 1; i < 16; i++)
      cout << static_cast<unsigned short> (u >> i)<< ' ';
   cout << dec<< endl;
}

Le résultat imprimé en sera :

ffff ffff ffff ffff ffff ffff ffff ffff ffff ffff ffff ffff ffff ffff ffff
3fff 1fff fff 7ff 3ff 1ff ff 7f 3f 1f f 7 3 1 0

Conversions de types

En C++, comme dans bien d'autres langages, les opérations de base (certains disent opérations internes) sont réalisées sur des opérandes de même type. Le corollaire de cette affirmation est que si les types de données des opérandes sont différents pour une opération de base, au moins l'un d'entre eux devra être converti.

Il existe deux grandes catégories de conversions de types: les conversions implicites et les conversions explicites.

Conversions implicites de types

On nomme conversion implicite de types une conversion faite automatiquement par le compilateur.

Le compilateur suit une série de règles que l'on appelle, selon les écoles de pensé, promotion entière (Integral Promotion) et conversion arithmétique habituelle (Usual Arithmetic Conversion).

Promotion entière

La promotion entière veut que lorsqu'une opération est évaluée, les opérandes de types char et short (donc char – qui est équivalent à signed char ou à unsigned char selon l'implantation – short et unsigned short) soient toujours converties en valeurs des types int ou unsigned int, selon le cas. Le choix fait entre int ou unsigned int dépendra des valeurs des opérandes.

char car1 = 'Z', car2 = 'Y';

Par exemple, les variables dans l'extrait de code à droite seront converties en int avant que ne s'effectue la comparaison if (car1 == car2).

Les conversions arithmétiques habituelles s'effectuent spontanément lors d'une opération binaire, en excluant les affectations et les opérations logiques && et ||.

Un ensemble de règles s'appliquent pour les autres cas. Dotons-nous de quelques symboles, pour simplifier l'énonciation de ces règles.

long double

unsigned long

double

long

float

unsigned int

int

Les règles de conversions arithmétiques habituelles vont comme suit, et la priorité va en décroissant (la première règle applicable rencontrée à partir du début de la liste sera celle qui s'appliquera) :

• Si un opérande est de type LD, alors l'autre opérande sera converti en LD.
• Si aucun des opérandes n'est du type LD et si un opérande est de type D, alors l'autre sera opérande converti en Det le résultat sera de type D.
• Si aucun des opérandes n'est du type LD ou du type D et si un opérande est de type F, alors l'autre opérande sera converti en F et le résultat sera de type F.
• Si aucun des opérandes n'est du type LD, du type D ou du type F et si un opérande est de type UL, alors l'autre opérande sera converti en UL et le résultat sera de type UL.
• Si aucun des opérandes n'est du type LD, du type D , du type F ou du type UL et si un opérande est de type L, alors l'autre opérande sera converti en L et le résultat sera de type L.
  • Si l'autre opérande est du type UI, il sera converti en L si le type L peut représenter les valeurs de UI. Sinon, les deux opérandes seront convertis en UL.
• Si aucun des opérandes n'est du type LD, du type D, du type F, du type UL ou du type L et si un opérande est de type UI, alors l'autre opérande sera converti en UI et le résultat sera de type UI.
• Dans tous les autres cas, les deux opérandes sont du type I et le résultat de l'opération sera aussi du type I.

Règle générale, le type le plus faible est toujours converti vers le type le plus fort, sauf dans le cas des affectations. Le concept cherche, évidemment, à éviter les débordements de capacité dans le résultat des opérations.

int x = 1;
cout << sizeof(x + 3.1415f) << endl;

short a = 5;
long  b = 250000;
double c = 100.5;
cout << sizeof(a * b + c) << endl;

Les conversions implicites dans les affectations

Les conversions habituelles n'auront pas lieu dans le cas des affectations. Si les types des opérandes d'une affectation ne sont pas les mêmes, le type de données de la valeur de l'opérande se trouvant à la droite de l'affectation sera converti vers le type de données de l'opérande à sa gauche.

Ce type de conversion peut causer un grave problème: une perte de données...

int x = 123;
double y;
y = x  // la valeur de x est d'abord convertie en une
       // valeur de type double, puis est affectée à y
cout << y;

On obtient ici le nombre 123 à l'écran, soit un nombre à virgule flottante sans point décimal, ni chiffre après le point, puisque ces derniers ne sont pas significatifs.

int x;
double y = 123.111;
x = y;
cout << x;

Le résultat, dans ce cas, sera 123, pas 123.111. La compilation risque d'ailleurs de générer un avertissement, signifiant une perte de précision due à l'affectation d'un nombre à virgule flottante à une variable entière, donc par définition incapable de contenir une partie fractionnaire.

Il est important de noter qu'une conversion par voie d'affectation n'affecte en rien la valeur de l'opérande de droite. En fait le contenu de la zone mémoire où est entreposée la variable n'est pas modifiée par l'opération de conversion implicite; la modification porte sur une copie de la valeur de la variable.

int x;
double y = 123.111;
x = y; // ne change rien à la valeur de y
cout << x << ' ' << y;

long l = 25687973;
float f;
f = l;
cout << f;

double d = 1.153467;
float f;
f = d;
cout << setprecision(10) << "d était: " << d
     << setprecision(10) << ", f est: " << f << endl;

long  l = 25687973;
short s;
s = l;
cout << s << endl;

int a = 5;
a *= 6.7;

float f = 40.0f;
f *= 1/10;

float f = 40.0f;
f = f * 1/10;

Conversions explicites de types

On nomme conversion explicite de type, transtypage ou typecast (que l'on abrège souvent par cast), une conversion forcée par une opération du programme lui-même.

La conversion explicite de types du langage C (supportée aussi par C++, mais il est nettement préférable d'utiliser des conversions explicites de types ISO qui n'ont que des avantages sur leur ancêtre) est provoquée à l'aide d'un opérateur combinant le nom du type de destination et des parenthèses. On la retrouve sous deux formes.

(type)expression

type(expression)

Conversions explicites de types et pertes de données

cout << int (1.0234); // ou (équivalent)
cout << (int) 1.0234;

Quiconque demande la conversion explicite d'une donnée d'un type à un autre devient responsable de ce geste et des conséquences qui en découlent. Si on ne fait pas attention aux types impliqués, il est possible d'encourir une perte de données. Par exemple, dans l'extrait de code proposé à droite, chacun des énoncés affichera 1.

La prudence est donc de mise. Chaque conversion explicite de types devrait être justifiée par écrit, documentée et facile à retrouver puis à éliminer en temps et lieu.

int a = 3,
    b = 5;
float resultat;
resultat = a/b;   // donnerait 0.0f... voir remarque 0?
resultat = float (a/b); // donnerait 0.0f... voir remarque 1?
resultat = float (a)/b; // donnerait 0.6f... voir remarque 2?
resultat = (float) a/b; // donnerait 0.6f... voir remarque 2?

Remarque 0 : la division de a par b se fait d'abord. Les deux opérandes étant des entiers, une division entière sera réalisée, et la division entière de 3 par 5 donne 0 reste 3. La valeur 0 est ensuite affectée à resultat, qui est de type float et prend ainsi la valeur 0.0f.

Remarque 1 : la division de a par b se fait encore une fois avant toute chose. Les deux opérandes étant des entiers, une division entière sera réalisée, et la division entière de 3 par 5 donne 0 reste 3. La valeur 0 est ensuite convertie explicitement en float pour devenir 0.0f, puis affectée à resultat, qui est aussi de type float.

Remarque 2 : la priorité de l'opérateur de conversion explicite de type est supérieure à celle de la division.

La variable a est donc d'abord convertie en float et devient 3.0f, puis la division entre ce float et la variable entière b demande la conversion implicite de cette dernière à un float (5.0f).

La division résultante se fera entre les float de valeur 3.0f et 5.0f, ce qui donnera 0.6f qui sera ensuite affecté à resultat, un float.

#include <iomanip>
#include <iostream>
int main()
{
   using namespace std;
   char  c =  65;
   short s = -10;
   float f = 2.0;
   int   a = 2,
         b = 3;
   cout << s << endl
        << (unsigned short) s     << endl
        << c               << endl
        << (short) c       << endl
        << (unsigned short) c     << endl
        << (unsigned short) f / b << endl
        << unsigned short (f / b) << endl
        << float (a / b)   << endl
        << (float) a / b   << endl;
}

Réponses aux exercices

Les résultats qui suivent ont été obtenus avec Visual Studio 2003, pour du code 32 bits. Vos résultats peuvent différer.

32767,32768;32767,-32768

8,8,4,4
4,4,4,4
4,4,4,4
10,256,10,4294967295

4

8

2.5688e+07

D était: 1.153467, F est: 1.153467059

-2139

33

-10
65526
A
65
65
0
0
0
0.666667

^[1] Remerciements spéciaux à messieurs Patrice Pelland et à Jean-François Théorêt pour leur contribution à la première version de ce document.

^[2] Soit jusqu'à C++ 98.

^[3] Ce n'est pas, à strictement parler, tout à fait vrai, du fait qu'une variable bool non initialisée peut contenir n'importe quelle valeur entière encodable sur sizeof(bool) bytes.

^[4]Dans les cas où un programmeur doit manipuler un byte explicitement signé ou explicitement non signé, alors il est important de spécifier explicitement signed char ou unsigned char sinon le code deviendra non portable.