Langage C:Variables scalaires
Un article de WikiTuto.
Sommaire |
Définitions
On appelle variable scalaire une variable ne contenant qu'une seule valeur, sur laquelle on pourra faire un calcul arithmétique. On possède trois types de base (char, int, float) que l'on peut modifier par 3 spécificateurs (short, long, unsigned).
char (caractère)
Une constante caractère est désignée entre apostrophes (simples quotes). 'a' correspond à un octet (alors que "a" à deux octets : 'a' et '\0', pour plus de détails voir le paragraphe chaînes de caractères). On peut définir certains caractères spéciaux, par le préfixe \ (antislash) :
- \n nouvelle ligne
- \t tabulation
- \b backspace
- \r retour chariot (même ligne)
- \f form feed (nouvelle page)
- \' apostrophe
- \\ antislash
- \" double quote
- \0 nul
- \nombre en octal sur 3 chiffres (ou moins si non suivi d'un chiffre).
- \xnombre : en Hexadécimal
Les char sont considérés dans les calculs comme des int (on considère leur code ASCII). Par défaut en C un char est signé donc peut varier de -128 à +127. Pour utiliser les caractères spéciaux du PC (non standard), il vaut mieux utiliser des unsigned char (de 0 à 255). Mais le comme C fait les calculs modulo 256, ça marche presque pareil.
int (entier)
Si l'on désire une taille précise, utiliser short int (16 bits) ou long int (32 bits). Sans précision, int donnera les programmes les plus rapides pour une machine donnée (int = short sur PC, mais long sur les stations 32 bits). Par défaut, les int sont signés, mais on peut préciser unsigned int.
Désormais certains compilateurs considèrent short comme 16 bits, int comme 32 bits et long comme 64 bits.
float (réel)
Un flottant est un nombre stocké en deux parties, une mantisse et un exposant. La taille de la mantisse définit le nombre de chiffres significatifs, alors que la taille de l'exposant définit le plus grand nombre acceptable par la machine. Les opérations sur les réels sont plus lents que sur les entiers. Pour une addition par exemple, il faut d'abord décaler la mantisse pour égaliser les exposants puis faire l'addition. Les réels sont toujours signés. On peut par contre utiliser le spécificateur long pour des réels avec une précision accrue. On peut également utiliser le nom double au lieu de long float. Certains compilateurs acceptent même des long double (quadruple précision).
Tailles et plages des variables
| type | taille (en bits) | plage de valeurs |
|---|---|---|
| char | 8 | -128 à +127 |
| unsigned char | 8 | 0 à 255 |
| short (short int) | 16 | -32768 à 32767 |
| unsigned short | 16 | 0 à 65535 |
| long (long int) | 32 | -2.147.483.648 à 2.147.483.647 |
| unsigned long | 32 | 0 à 4.294.967.295 |
| float | 32 | -3.4e38 à 3.4e38 (7 chiffres significatifs) |
| double (long float) | 64 | -1.7e308 à 1.7e308 (15 chiffres significatifs) |
| long double (non standard) | 80 ou 128 | ça dépend |
Conversions de type et cast
Dans les calculs, les char sont automatiquement transformés en int. Quand un opérateur possède des arguments de type différent, une transformation de type est effectuée automatiquement, suivant l'ordre :
char -> int -> long -> float -> double signed -> unsigned
Attention la transformation n'est effectuée que le plus tard possible, si nécessaire. 5/2+3.5 donnera donc 5.5. De plus les opérations arithmétiques sont toujours effectuées sur des long ou double, pour une précision maximale quels que soient les résultats intermédiaires (voir exemples au chapitre expressions arithmétiques).
On peut forcer une transformation en utilisant le cast, qui est un opérateur unaire. La syntaxe est : (type_résultat) valeur_à_transformer exemple : {float x;int a=5; x=(float)a;}
Un cast transformant un réel en entier prendra la partie entière. Cette transformation doit être explicite, elle est impossible implicitement. Pour obtenir l'entier le plus proche , utiliser (int)(réel_positif+0.5).
Il faut bien noter que le cast n'est une opération de transformation que pour les types scalaires, pour tous les autres types, le cast ne permet que de faire croire au compilateur que la variable est d'un autre type que ce qu'il attendait, pour qu'il n'émette pas de message d'erreur (à utiliser avec grande prudence).
Enumérations
On peut définir un nouveau type (d'entiers) sous la forme : [classe] enum nomdutype {liste_valeurs} [liste_variables]; ([] facultatifs)
- exemple :
enum jour {lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche};
On a créé un nouveau type. toute variable de type jour pourra valoir soit lundi, soit mardi, etc... On peut directement mettre la liste des variables à créer (entre le "}" et le ";"), ou indiquer :
enum nomdutype liste_variables;
- exemple :
enum jour aujourd_hui=mardi;)
En fait le type jour est un type int, avec lundi=0, mardi=1,... On peut donc faire toutes les opérations entières (aujourd_hui++ par exemple). Il n'y a aucun test de validité (dimanche+1 donne 7). Ceci permet de rendre les programmes plus clairs. On obtiendrait un résultat équivalent avec #define. Attention, printf affichera un entier, mais on peut faire:
char *nom[7]={"lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"," dimanche"};
puis printf("%s",nom[aujourd_hui]);
On peut aussi prévoir une codification non continue :
enum truc {a=4,b,c,d=2,e,f} : d=2,e=3,f=a=4,b=5,c=6
En utilisant typedef, on n'a pas besoin de répéter enum dans la déclaration de variables :
typedef enum {coeur,carreau,pique,trèfle}couleurs;
couleurs i,j,k;
Voir aussi
- Instructions
- Structures de contrôle
- Déclaration et stockage des variables
- Fonctions
- Variables scalaires
- Tableaux
- Structures et unions
Auteur :Patrick TRAU. Copyright : utilisation de ces documents libre pour tout usage personnel. Utilisation autorisée pour tout usage public non commercial, à condition de citer son auteur (Patrick TRAU, IPST, Université Louis Pasteur Strasbourg, email : Patrick.Trau (à) ipst-ulp.u-strasbg.fr ) et de me signaler tout usage intensif. Utilisation commerciale interdite sans accord écrit de ma part.
