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 - pointeurs de fonction appliqués aux automates
(Article écrit par Squonk et extrait d'Amiga News - décembre 1990)
|
|
En lisant cet article sur les pointeurs de fonction, j'ai eu envie de vous présenter un petit
programme qui me paraît bien illustrer le propos de Roméo Rapido. Voici donc un programme utilisant
le concept de pointeurs de fonctions appliqué aux automates.
Programmation orientée par les données
Pour être précis, il faut très exactement parler "d'automates d'états finis". Je ne parlerai pas de
"programmation orientée objet", car on a un peu trop tendance à mon goût à coller ce terme
à n'importe quel bout de programme où les données sont à peu près encapsulées (accessibles
uniquement aux fonctions qui les utilisent). Je préfère parler de "programmation orientée par
les données". Ce mode de programmation, contrairement au précédent, est très facile à implémenter
en langage C tout à fait commun et utilise donc les pointeurs de fonction.
Dans la programmation orientée par les données, le comportement du programme est étroitement
lié aux données qui lui sont fournies (par exemple un fichier, une saisie), à tel point que
le déroulement du programme ne peut être prévu sans elles.
Le principal avantage de ce style de programmation est de fournir une méthode d'analyse pour
les problèmes généralement complexes représentables par des graphes d'états/transitions.
Parmi ces problèmes, je vois :
- Les analyseurs syntaxiques.
- Les séquenceurs pour les pilotes de robots, automatismes...
Bien sûr, on peut résoudre ces problèmes par des méthodes d'analyse moins systématiques avec
des "for", "while", "break", "continue", "goto" dans tous les sens, mais on arrive très rapidement
à des programmes "spaghetti" où il est bien difficile de distinguer le début de la fin !
Et je ne parle pas des difficultés d'ajout d'un nouveau cas pas forcément prévu au départ
(nouveau "token" ou vérin supplémentaire...).
La méthode des automates, quant à elle, permet de faire correspondre directement
chaque état à une routine unique bien isolée, les liaisons entre états pilotant le
passage d'une fonction à une autre. Il devient alors trivial de modifier le comportement
d'un état particulier ou d'en rajouter un nouveau.
La pratique
Bon, finie la théorie, passons à la pratique ! Je vous propose ce mois-ci un petit programme
capable d'interpréter caractère par caractère un nombre flottant entré au clavier et de le
transformer en type "float" pour le C. Bien sûr, il utilise la méthode des automates décrite ci-dessus.
La fonction main() est la partie la plus intéressante : elle est constituée d'une boucle
"while" contenant un appel à une fonction par l'intermédiaire d'un pointeur de fonction. Ce pointeur
est tout d'abord initialisé pour pointeur sur la première fonction à exécuter. Puis, pour chaque boucle,
la valeur retournée par la fonction ainsi appelée est réaffectée à ce même pointeur.
Ainsi, lors de la prochaine boucle, la valeur retournée sera utilisée pour appeler la
prochaine fonction à exécuter. Ce même pointeur est également testé par le "while",
une valeur nulle retournée par l'un des appels terminant la boucle. Je pense que vous commencez
à comprendre où je veux en venir : il s'agit da mécanisme de passage d'un état au suivant.
Il faut remarquer que les appels ne sont pas emboîtés, mais consécutifs.
Les autres fonctions du programme correspondent donc aux états successifs de décodage du nombre.
Encore une subtilité : la déclaration du pointeur de fonction. Il faudrait normalement déclarer
un "pointeur sur une fonction qui retourne un pointeur sur une fonction qui retourne un pointeur
sur une fonction qui...". Cette définition n'étant pas compréhensible par le compilateur, on
est obligé de scinder la déclaration en deux, la première un type "pointeur sur quelque chose"
("char" ou "void", au choix), la deuxième un pointeur sur une fonction retournant ce type.
Remarquez les macros préprocesseur STATE et RETURN qui évitent une redéfinition des types
systématique ("casting").
Enfin, si vous désirez écrire un gros analyseur syntaxique, je vous conseille de toute
façon de regarder d'abord un programme comme Lex (ou Flex), qui n'est rien d'autre qu'un générateur
automatique d'automates (disponible sur Fish 407).
Je vous conseille d'exécuter ce programme en pas à pas car cela sous permettra de bien suivre
le déroulement du bidule. Et même si l'intérêt de ce bout de code est limité (sauf si vous désirez
récrire scanf !), je suis sûr que cela donnera de bonnes idées à certains !
Listing
|
