Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : C - les types de base
(Article écrit par Batchman et extrait d'A-News (Amiga News) - juillet 1989)
|
|
Bon-soir, je-suis-très-heu-reux de vous re-trou-ver dans notre ru-brique Où-bogue-il-y-a, le maga-zine du C ex-trême. Je
vous ra-ppelle que Où-bug-il-y-a est la ru-bri-que la plus au Sud d'A-News. Comme vous-le-voyez, je suis en-an-tare-tique en
train d'a-pprendre le C à des-manchots et je vous assure que ça n'est-pas de-la-tar-te. Tout-de-suite, notre pre-mier
re-portage : vous connai-ssez tous Flo-rent Calpin, le maî-tre de la glisse. Spé-cia-liste de bare-foot à Ta-hi-ti, nous
le-re-trou-vons aujourd'-hui en train de sur-fer sur son Ami-ga dans sa bai-gnoire.
Argh ! Je viens juste de gli-sser sur une tou-che de mon clavier et je-vous assure que ça fait très-mal.
Tout-de-suite, sé-quen-ce compi-la-tion...
Nous avons vu le mois dernier quelle était l'organisation générale d'un programme
en C. Nous avons parlé de variables et de fonctions, caractérisées par leur type. Mais qu'est-ce qu'un type ? C'est l'attribut
que vous donnez lors de la déclaration d'une variable ou d'une fonction pour indiquer au compilateur les valeurs qu'elle
doit manipuler et comment elle doit être codée en mémoire. Par exemple, dans la déclaration : "int i;" le type est "int"
(c'est vraiment de l'initiation !).
Nous distinguerons les types de base, les types dérivés et les types énumérés. Les deux derniers feront l'objet du prochain
article. Cette fois-ci, nous nous contenterons des types de base (et c'est déjà pas mal !).
Quels sont-ils ?
- void.
- char.
- short.
- int.
- long.
- float.
- double.
Void : le type vide
Ce type correspond à une donnée vide, rien, le néant. Évidemment, on ne peut pas déclarer de variables de ce type ;
seulement des fonctions. Par conséquent, les fonctions de type "void" ne retournent rien, aucune valeur, et peuvent
être assimilées à des procédures. Donc, si vous utilisez une fonction qui ne retourne pas de résultat, déclarez-la
du type void : vous n'aurez pas de problème avec le compilateur.
Par exemple :
void Affiche() {
printf("Bonjour");
}
|
C'est le seul type qui soit réservé aux fonctions ; les autres types peuvent être affectés aux fonctions ou aux variables.
Char : le type caractère
Une variable de ce type permet de stocker un caractère, et est donc réservée sur 1 octet. Par exemple, elle peut contenir
"A".
Vous pouvez aussi utiliser ce type pour stocker des entiers compris entre -128 et +127. Mais attention, si vous utilisez
moins de mémoire, le traitement de ces variables est moins rapide. Ceci est spécifique à l'Amiga, ou tout au moins, aux
machines à microprocesseur 680x0. En effet, celui-ci travaille naturellement sur 16 bits. Il ne peut donc accéder qu'aux
octets pairs de la mémoire. Par conséquent, lorsque vous stockez consécutivement deux variables de type char (comme nous
le verrons dans les tableaux), le programme doit faire de la gymnastique pour accéder aux octets impairs. Ce qui le
ralentit bien sûr. Conclusion : le fait de stocker des entiers dans des caractères gagne de la place mais fait perdre du temps.
Les types entiers : int, short et long
Int est LE type entier par excellence. C'est celui que manipule le plus efficacement votre programme. C'est celui qu'il faut
utiliser si vous n'avez pas de contrainte particulière sur l'intervalle des valeurs. Par exemple, pour compter de 1 à 10 dans
une boucle.
Bizarrement, l'implémentation n'est pas la même sur les deux compilateurs ennemis : deux octets (par défaut) sur le Manx,
quatre octets pour le Lattice. Ce qui donne respectivement des valeurs pouvant aller de -32768 à +32767, et de -2147483648
à +2147483647. Un programme manipulant des entiers sur deux octets est un peu plus rapide qu'un programme calculant avec
des entiers sur quatre octets.
En fait, le type int est l'intermédiaire entre les deux types short et long, "short" représente des entiers courts (au
détriment de l'intervalle de valeurs qu'ils peuvent prendre) ; "long" code des entiers longs (au détriment de la vitesse car
le 68000 calcule plus vite sur 16 bits que sur 32). Pourquoi trois types alors qu'il n'y a que deux possibilités de codage ?
C'est pour respecter la norme du langage C : en effet, certaines machines plus gonflées que l'Amiga peuvent manipuler des
entiers sur 16, 32, 48, 64, 72 bits, voire plus.
Le type short consiste à coder sur deux octets ; le type long sur quatre octets. Et ceci, quel que soit le compilateur.
Vous en déduisez donc que, sur le Manx, le type int par défaut est équivalent au type short ; alors que sur le Lattice,
le type int représente le type long. La seule chose qui est garantie est qu'un short est plus court qu'un long. Enfin,
vous pourrez rencontrer les écritures "short int" et "long int" qui correspondent respectivement à short et long.
Les types réels : float et double
Ces types permettent de coder des nombres réels. Par conséquent, leur intervalle de valeurs est beaucoup plus grand que
celui des entiers : -10E+38 à +10E+38 dans le premier cas, et de -10E+308 à +10E+308 dans le second. Inconvénients :
on peut faire moins d'opérations que sur les réels, il faut utiliser des bibliothèques spéciales et surtout, les calculs
sont beaucoup moins rapides. C'est logique : en assembleur, additionner deux octets se fait avec une seule instruction.
Alors que la même opération en réels est réalisée par de véritables sous-programmes.
Float code les réels sur deux octets, de la façon suivante :
- 1 bit de signe.
- 8 bits pour coder l'exposant.
- 23 bits pour coder la mantisse.
Double les codes sur quatre octets :
- 1 bit de signe.
- 11 bits pour l'exposant.
- 52 bits pour la mantisse.
Il y a aussi une autre façon de coder les flottants : c'est le format FFP (Fast Floating Point : respectivement 1, 7 et 24 bits).
Mais c'est plus de la programmation que du langage C. Nous verrons donc comment mettre en oeuvre ces réels plus tard.
Le mot-clé unsigned
Il est nécessaire de parler ici d'unsigned. Ce mot-clé peut s'appliquer aux variables de type char, short, int ou long.
Il permet de faire des calculs en arithmétique non signée. L'intervalle des valeurs devient donc :
unsigned char : 0 à 255.
unsigned short : 0 à 65535.
unsigned int : 0 à 65535 ou 4294987295 (suivant le compilateur).
unsigned long : 0 à 4294987295.
Vous pouvez donc trouver, par exemple, la déclaration "unsigned long int nombre;" qui correspond à un entier long non signé
et qui est équivalente à "unsigned long nombre;".
Nous ne l'avons pas dit jusqu'ici mais il est bien évident, qu'en cas de débordement, on obtient le résultat modulo à la
portée du type. Comment ça, rien compris ? Voici un exemple simple : "x" est une variable de type unsigned char, "x"
vaut 100. Après l'opération x = x + 200, "x" vaudra 44 soit (100+200)-256.
Autre exemple : "x" est de type short et vaut 32767. Après x = x + 1, "x" vaut -32768. Attention à ce genre de pièges !
Voilà, c'est tout pour les types de base. Le mois prochain, nous parlerons des types dérivés et énumérés. En attendant,
méditez bien.
|
