Langage C++/Types
Les Types[modifier | modifier le wikicode]
En C++ il existe plusieurs types organisés dans des catégories. Ces types ont différentes longueurs et différentes interprétations possibles dépendant de la plage de valeurs sur laquelle on veut travailler : signés ou non, à virgule flottante ou non.
|
Selon l'architecture de votre ordinateur les tailles des types peuvent varier ! Ce cours se base sur une architecture PC. D'autres machines ont potentiellement des types de longueurs différentes de celles exprimées ici. |
Types Intrinsèques :[modifier | modifier le wikicode]
Il existe plusieurs catégories de types en C++ dont certaines sont incompatibles avec le langage C. Pour représenter les nombres non-signés on utilise le mot clé "unsigned". Pour représenter les nombres signés on utilise le mot clé "signed". Cela permet à l'ordinateur de savoir comment il doit interpréter les valeurs. Pour des raisons de simplification du codage, les types représentent par défaut des nombres signés, ce qui rend l’utilisation du mot clé "signed" facultative.
Catégories de types[modifier | modifier le wikicode]
Le Type Vide[modifier | modifier le wikicode]
Cette catégorie, compatible avec le langage C, représente l'absence de type.
Le type vide est surtout utilisé pour l'écriture de méthodes (les méthodes ne renvoyant aucune valeur ont un type de retour vide), mais il arrive que l’on s'en serve pour accéder à une adresse mémoire sans essayer d’avoir une interprétation de la valeur se trouvant à cette adresse.
| Type de Base | Taille du type en octets | Nombres de valeurs possibles | Plage de valeurs possibles |
|---|---|---|---|
| void | (inaccessible) | (inaccessible) | (inaccessible) |
Le Type Char, un type lettré ![modifier | modifier le wikicode]
Le type char est un type un peu particulier : il se comporte comme un entier mais il est destiné à mémoriser des caractères (ou parfois des morceaux de caractères). Dans certains système d'exploitation il existe une table de 256 dessins représentant graphiquement, entre autres, les 26 lettres minuscules et majuscules (52 au total) ainsi que les 10 chiffres (0 à 9). Le reste des 256 codes permet de représenter d'autres caractères tels que le caractère null, l'espace, la tabulation, la ponctuation ou des caractères propres à des langues spéciales, parfois même des smileys. Le dessin de ces caractères ainsi que leur codage numérique sont définis par une norme de codage de caractères. Par exemple, la norme ASCII est une norme relativement ancienne, alors que la norme Unicode est plus universelle. L'ordinateur lui ne manipulera que les valeurs numérique de ce type, par contre les logiciels qui affichent la valeur de ce type à l'écran le font sous forme graphique, c'est-à-dire en affichant le dessin du caractère correspondant à la valeur affectée.
Commun aux processeurs 32 et 64 bit :
| Mode | Type de Base | Taille du type en octets | Nombres de valeurs possibles | Plage de valeurs possible dans le mode |
|---|---|---|---|---|
| non-signé | unsigned char | 1 | 256 | [0 ; 255] |
| signé | (signed) char | 1 | 256 | [ -128 ; +127 ] |
| caractère (non-signé) | (signed|unsigned) char | 1 | 256 | Caractères de la table ASCII |
Les Entiers[modifier | modifier le wikicode]
Cette catégorie, compatible avec le langage C, regroupe les types représentant les nombres entiers. À partir du type short, tous les types entiers se réfèrent au type int. Là encore pour simplifier le codage, l'écriture du mot clé "int" est facultative excepté pour le type int signé lui-même.
Commun aux processeurs 32 et 64 bit :
| Mode | Type de Base | Taille du type en octets | Nombres de valeurs possibles | Plage de valeurs possible dans le mode |
|---|---|---|---|---|
| non-signé | unsigned char | 1 | 256 | [ 0 ; 255 ] |
| signé | (signed) char | 1 | 256 | [ -128 ; +127 ] |
| non-signé | unsigned short (int) | 2 | 65 536 | [ 0 ; 65 535 ] |
| signé | (signed) short (int) | 2 | 65 536 | [ −32 768 ; 32 767 ] |
| non-signé | unsigned (int) | 4 | 4 294 967 296 | [0; 4 294 967 295 ] |
| signé | (signed) int | 4 | 4 294 967 296 | [ −2 147 483 648 ; 2 147 483 647 ] |
Spécifiques aux processeurs 32 bits :
| Mode | Type de Base | Taille du type en octets | Nombres de valeurs possibles | Plage de valeurs possible dans le mode |
|---|---|---|---|---|
| non-signé | unsigned long (int) | 4 | 4 294 967 296 | [0; 4 294 967 295 ] |
| signé | signed long (int) | 4 | 4 294 967 296 | [ −2 147 489 648 ; 2 147 489 647 ] |
| non-signé | unsigned long long (int) | 8 | 18 446 744 073 509 552 000 | [0; 18 446 744 073 509 552 000 ] |
| signé | (signed) long long (int) | 8 | 18 446 744 073 509 552 000 | [ −9 223 372 036 854 776 000 ; 9 223 372 036 854 776 000 ] |
Spécifiques aux processeurs 64 bits :
| Mode | Type de Base | Taille du type en octets | Nombres de valeurs possibles | Plage de valeurs possible dans le mode |
|---|---|---|---|---|
| non-signé | unsigned long (int) | 8 | 18 446 744 073 509 552 000 | [ 0 ; 18 446 744 073 509 552 000 ] |
| signé | (signed) long (int) | 8 | 18 446 744 073 509 552 000 | [ −9 223 372 036 854 776 000 ; 9 223 372 036 854 776 000 ] |
En effet, selon que l’on soit en présence d’un processeur 32 ou 64 bits, certains types ont des tailles et des plages de valeurs variables. C’est pour cette raison que normalement on doit utiliser les types dit "Entiers Fixes" dont nous parlerons plus loin.
Une règle détermine la validité des tailles des types entiers :
[signed|unsigned], char <= short <= int <= long [<= long long]
Les Flottants[modifier | modifier le wikicode]
Cette catégorie, compatible avec le langage C, regroupe les types représentant les nombres à virgule flottante.
Commun aux processeurs 32 et 64 bit :
| Type de Base | Taille du type en octets | Taille de l'exposant | Taille de la mantisse | Nombres de valeurs possibles | Plage de valeurs possible |
|---|---|---|---|---|---|
| float | 4 | 8 bits | 23 bits | 4 294 967 296 | (indisponible actuellement) |
| double | 8 | 11 bits | 52 bits | 18 446 744 073 509 552 000 | (indisponible actuellement) |
| long double | 12 | 15 bits | 64 bits | 79 008 162 513 705 380 000 000 000 000 | (indisponible actuellement) |
Le Type Logique[modifier | modifier le wikicode]
Ce type est un apport par rapport au langage C, il n'est donc pas compatible avec celui ci.
Le type bool est un type un peu particulier. Il est codé sur 4 octets et représente les données logiques vrai et faux par 2 mots clés respectivement "true" et "false". Ce type gère sa valeur de manière assez singulière :
true vaut 1, false vaut 0, mais d’une manière générale tout ce qui n’est pas false (égal à 0) vaut true (différent de 0). En effet comme ce type est codé sur 4 octets il possède la même plage de valeurs qu'un signed int et nous pouvons lui affecter n’importe quelle valeur de cette plage.
Commun aux processeurs 32 et 64 bit :
| Type de Base | Taille du type en octets | Nombres de valeurs possibles | Plage de valeurs possible | Valeur = 0 | Valeur = [ −2 147 489 648 ; -1 ] U [ +1 ; 2 147 489 647 ] |
|---|---|---|---|---|---|
| bool | 4 | 4 294 967 296 | [ −2 147 489 648 ; 2 147 489 647 ] | false | true |
Les Méthodes[modifier | modifier le wikicode]
Nous parlerons en détail de ce type dans le chapitre Méthodes.
Les Pointeurs, Tableaux et Références[modifier | modifier le wikicode]
Le type pointeur n'est qu'un raccourci vers la mémoire. Le type pointeur est en fait une adresse mémoire soit un entier non signé de la taille du bus d'adresse dans le contexte logiciel. Sa taille est donc variable suivant le matériel et le système d'exploitation utilisé.
Sa valeur représente l'adresse mémoire vers laquelle il pointe. Son type est le type dans lequel on lui demande de traduire la valeur existant à l'adresse où il pointe.
Il peut s'agir dans des cas peu fréquents de pointeurs sur méthodes mais nous verrons cela dans le chapitre Pointeur, Tableaux et Références.
Les Énumerations[modifier | modifier le wikicode]
Nous parlerons en détail de ce type dans le chapitre Énumérations.
Les Structures[modifier | modifier le wikicode]
Nous parlerons en détail de ce type dans le chapitre Structures, unions et champs de bits.
Les Champs de Bits[modifier | modifier le wikicode]
Nous parlerons en détail de ce type dans le chapitre Structures, unions et champs de bits.
Les Classes[modifier | modifier le wikicode]
Les classes sont le summum de l'architecture logicielle. Elles permettent la programmation-objet et la construction d'applications au code robuste réutilisable et relativement facile à debugger. Nous en reparlerons plus loin.
Structures vs Classes[modifier | modifier le wikicode]
- La visibilité d’une classe est par défaut privée, celle d’une structure, publique.
- L’héritage d’une classe est par défaut privé, celle d’une structure, publique.
- Template de classe, impossible en structure.
Types Étendus[modifier | modifier le wikicode]
Les types étendus sont des types définis par les utilisateurs et sont le plus souvent des agglomérations de types intrinsèques et/ou types étendus. Ainsi il est possible de créer des types étendus agglomérant n’importe quel type intrinsèque en n’importe quelle quantité (dans les limites de la mémoire disponible) et dans n’importe quel ordre.
Le langage nous permet de définir de nouveaux types étendus grâce au mot clé "typedef".
La syntaxe de cette instruction est :
typedef NomDuTypeEtendu NomDuTypeDeBase;
Nous verrons des exemples concrets de cette syntaxe dans les chapitres suivants.
