|
Qui sont :
 int
: entier (16 ou 32 bits, suivant les machines),
 float
: réel,
 double
: réel double précision,
 char
: caractère (en général
8 bits).
La fonction sizeof()
permet de connaître le nombre d'octets occupés par un objet
(voir détermination de la taille des
types élémentaires).
Les entiers
représentation et
opérations exactes
 int:
entier sur 32 bits sur VOTRE machine [-2 147 483 6M, 2 147 483 647] à
déterminer par l'appel de In fonction sizeof(type)
 short:
entier court, sur 16 bits sur VOTRE machine [-32 768, 32 767]
 long:
entier long, sur 32 bits sur VOTRE machine
 unsigned
: entier non signé (i.e. nombres positifs)
  unsigned
int, unsigned short, unsigned long
  unsigned
short: 16 bits sur VOTRE machine [0, 65 536]
Exemples
de constantes entières |
24
| -24
| +25
| -0
|
|
0xooff
| constants
hexadécimale
|
|
016
| constante
octale
|
|
54L
| constante
de type long
|
Le type int peut être modifié
par l'un des qualificateurs suivants
 short
: entier court (souvent 16 bits),
 unsigned
: non signé, peut également qualifier un objet de type
char,
 long:
entier long (souvent 32 bits)
Raccourcis
d'écriture : |
Le mot clé int est facultatif
lors de son emploi avec les qualificateurs non ambigus: |
|
short int v1; est
équivalent à short
v1; |
Les constantes entières peuvent s'écrire en notation

décimale,

hexadécimale (précédées de 0x ou de 0X (zéro-X))

ou octale (précédées de 0, une constante commençant
par un zéro et ne contenant que les chiffres : 0, 1, 2, 3, 4,
5, 6 et 7 est une constante octale.).
Une constante entière peut être suffixée par les
caractères l ou L et u on U pour
spécifier une constante de type long et unsigned.
Exemples |
12 |
- 43 |
85 |
|
Oxabfb |
Ox25D3a |
Ox3aUL |
|
0321 |
07215 |
01526L |
Pour écrire un programme portable, on ne fait aucune supposition
sur la taille en octets d'un objet de type int :
 On
déclare une variable de type int chaque fois que la précision
d'un entier court est suffisante, sans chercher à optimiser la
mémoire occupée par cette variable,
 On
utilise le type short à chaque fois que l'on souhaite optimiser
l'espace mémoire (s'il n'y a pas de risque de débordement),
 On
utilise le type long lorsque le codage de la variable nécessite
plus de 2 octets.
Retour
Les réels
 float:
réel sur 32 bits sur VOTRE machine
 double:
réel sur 64 bits sur VOTRE machine
 long
double: réel sur 64 bits sur VOTRE machine
Exemples de constantes réelles : 0. -4.34 +4E5
Les opérations ne sont jamais précises et le test (x
== 0.) risque de toujours être faux, il doit être remplacé
par le test
( (-eps < X) && (x < eps) )
où eps contient la marge d'erreur accordée.
Les constantes réelles s'écrivent avec un point décimal
et éventuellement en notation exponentielle :
 |
532.652 |
-286.34 |
12.73 |
|
52e+4 |
42.63E-12 |
-28.l5e4 |
Par défaut, une constante réelle est de type double,
elle peut être suffixée par la lettre f ou F
pour être forcée en type float, ou par la lettre 1
ou L pour être forcée en type long double.
À cause des erreurs d'arrondi, il faut remplacer les tests d'égalité
entre des réels par des tests d'appartenance de l'un de ces réels
à un intervalle encadrant l'autre réel.
Retour
Les caractères
char,
unsigned char: caractère codé sur 8 bits.
Exemples de constantes caractères: 'a' 'c' '$' '\n' '\t' '\172'
Les chaînes
de caractères
Le type chaîne de caractères n'existe pas, il faut créer
des tableaux de caractères. Mais il est possible de manipuler des
constantes chaînes de caractères. Par exemple de constantes
chaînes de caractères:

strcpy(chaine,"bonjour") ;
 char
main[] = "message" ;
Retour
Les booléens
Le type booléen
n'existe pas, on utilise généralement un entier court
(éventuellement non signé) |
(unsigned
short) |
ou
même un caractère (non signé) |
(unsigned
char) |
ou même un caractère (non signé)
Les tableaux de caractères sont présentés slide
54.
Retour
Détermination
de la taille des types élémentaires
#include <stdio.h>
void main(void)
{
printf("taille d'un
entier court (short) : %d octets\n", sizeof(short)) ;
printf("taille d'un
entier (int): %d octets\n", sizeof(int)) ;
printf("taille d'un
entier long (long) : %d octets\n", sizeof(long)) ;
printf("taille d'un
réel (float) : %d octets\n", sizeof(float)) ;
printf("taille d'un
double réel (double) : %d octets\n", sizeof(double)) ;
printf("taille d'un
double réel long (long double): %d octets\n",

sizeof(long double)) ;
}
Résultat d'exécution:
taille d'un entier court
(short): 2 octets
taille d'un entier (int):
4 octets
taille d'un entier long
(long): 4 octets
taille d'un réel
(float): 8 octets
taille d'un double réel
(double): 8 octets
taille d'un double réel
long (long double): 8 octets
Retour
Langage
C Partie I: Déclaration des variables
|