[FAQ] fr.comp.lang.c - partie 1/4
Guillaume Rumeau <guillaume.rumeau@wanadoo.fr>
Archive-Name: fr/comp/lang/faq-c-1
Archive-Name: fr/comp/lang/faq-c-1
---------------------------------------------------------------------------
FAQ de fr.comp.lang.c
18 avril 2003
Partie 1/4 (sections 1 à 4)
---------------------------------------------------------------------------
Foire aux questions sur le langage C
Résumé :
Ce document regroupe les questions les plus fréquemment posées
(avec les réponses) du groupe de discussion francophone
<news:fr.comp.lang.c> sur le langage C.
Cette FAQ (voir la question 2.1)
est basée sur celle de <news:comp.lang.c>
maintenue par Steve Summit
(<http://www.eskimo.com/~scs/C-faq/top.html>).
Une version HTML de ce document est disponible à l'adresse suivante :
<http://www.isty-info.uvsq.fr/~rumeau/fclc/>.
Une version PDF de la FAQ est à nouveau disponible ici :
<http://www.isty-info.uvsq.fr/~rumeau/fclc/fclc.pdf>.
Enfin, il existe aussi une version poscript :
<http://www.isty-info.uvsq.fr/~rumeau/fclc/fclc.ps>.
Même si ce document n'est plus si récent que ça, il est
probable qu'il y traine encore quelques coquilles ou erreurs.
Aussi, si vous en trouvez, n'hésitez pas à les indiquer aux
mainteneurs (voir la question 2.5).
Derniers changements :
- Version 2.15, le 18/04/2003
Quelques modifications mineures et corrections de liens morts.
- Version 2.14, le 18/01/2003
Corrections dans le source XML
Une version PDF est à nouveau disponible
Modification de la question 14.3
- Version 2.13, le 11/11/2002
Correction du code de la question 14.12
Ajout de la question 14.8
Correction des questions 3.10 et 15.10.
- Version 2.12, le 27/08/2002
Correction de l'exemple dans la question 14.2.
- Version 2.11, le 03/07/2002
Précisions sur la question 13.9
Et quelques corrections typographiques.
- Version 2.10, le 09/04/2002
Compléments sur la question 3.6
Ajout de la question 5.8
Ajout de la question 11.10
Ajout de la question 9.10
De nombreuses autres corrections et modifications.
1. Copyright (Droits de reproduction)
1.1 Copyright de la FAQ de comp.lang.c
1.2 Qu'en est-il de ce document ?
2. Introduction
2.1 Qu'est-ce qu'une FAQ ?
2.2 Qui la maintient ?
2.3 Qui y contribue ?
2.4 Où puis-je la trouver ?
2.5 J'ai trouvé une erreur !
2.6 Et mes questions ?
2.7 Dois-je poster sur fr.comp.lang.c ?
2.8 Comment poster sur fr.comp.lang.c ?
2.9 Comment comprendre le langage utilisé sur fr.comp.lang.c ?
3. Le langage C
3.1 Qu'est-ce que le langage C ?
3.2 À quoi ça sert ?
3.3 D'où vient le C ?
3.4 Que peut-on faire en C ?
3.5 Portabilité, matériel, système ...
3.6 Et le C++ dans tout ça ?
3.7 ISO, ANSI, K&R, ..., qu'es aquo ?
3.8 De quoi ai-je besoin pour programmer en C ?
3.9 Quel(s) bouquin(s) ?
3.10 Où trouver...
4. Outils, environnement de développement et autres gadgets
4.1 Environnements de développement intégrés
4.2 Compilateurs
4.3 Débogueurs
4.4 Graphisme
4.5 Bibliothèques
4.6 Outils divers
4.7 Où trouver du code ?
5. Déclarations et initialisations
5.1 Quels types utiliser ?
5.2 Comment définir une structure qui pointe sur elle-même ?
5.3 Comment déclarer une variable globale ?
5.4 Quelle est la différence entre const et #define ?
5.5 Comment utiliser const avec des pointeurs ?
5.6 Comment bien initialiser ses variables ?
5.7 Comment déclarer un tableau de fonctions ?
5.8 Comment connaître le nombre d'éléments d'un tableau ?
5.9 Quelle est la différence entre char a[] et char * a?
5.10 Peut-on déclarer un type sans spécifier sa structure ?
6. Structures, unions, énumérations
6.1 Quelle est la différence entre struct et typedef struct ?
6.2 Une structure peut-elle contenir un pointeur sur elle-même ?
6.3 Comment implémenter des types cachés (abstraits) en C ?
6.4 Peut-on passer des structures en paramètre de fonctions ?
6.5 Comment comparer deux structures ?
6.6 Comment lire/écrire des structures dans des fichiers ?
6.7 Peut-on initialiser une union ?
6.8 Quelle est la différence entre une énumération et des #define ?
6.9 Comment récupérer le nombre d'éléments d'une énumération ?
6.10 Comment imprimer les valeurs symboliques d'une énumération ?
7. Tableaux et pointeurs
7.1 Quelle est la différence entre un tableau et un pointeur ?
7.2 Comment passer un tableau à plusieurs dimensions en paramètre d'une fonction ?
7.3 Comment allouer un tableau à plusieurs dimensions ?
7.4 Comment définir un type pointeur de fonction ?
7.5 Que vaut (et signifie) la macro NULL ?
7.6 Que signifie l'erreur « NULL-pointer assignment » ?
7.7 Comment imprimer un pointeur ?
7.8 Quelle est la différence entre void * et char * ?
8. Chaînes de caractères
8.1 Comment comparer deux chaînes ?
8.2 Comment recopier une chaîne dans une autre ?
8.3 Comment lire une chaîne au clavier ?
8.4 Comment obtenir la valeur numérique d'un char (et vice-versa) ?
8.5 Que vaut sizeof(char) ?
8.6 Pourquoi sizeof('a') ne vaut pas 1 ?
8.7 Pourquoi ne doit-on jamais utiliser gets() ?
8.8 Pourquoi ne doit-on presque jamais utiliser scanf() ?
9. Fonctions et prototypes
9.1 Pour commencer ...
9.2 Qu'est-ce qu'un prototype ?
9.3 Où déclarer les prototypes ?
9.4 Quels sont les prototypes valides de main() ?
9.5 Comment printf() peut recevoir différents types d'arguments ?
9.6 Comment écrire une fonction à un nombre variable de paramètres ?
9.7 Comment modifier la valeur des paramètres d'une fonction ?
9.8 Comment retourner plusieurs valeurs ?
9.9 Peut-on, en C, imbriquer des fonctions ?
9.10 Qu'est-ce qu'un en-tête ?
10. Expressions
10.1 Le type Booléen existe-t-il en C ?
10.2 Un pointeur NULL est-il assimilé à une valeur fausse ?
10.3 Que donne l'opérateur ! sur un nombre négatif ?
10.4 Que vaut l'expression a[i] = i++ ?
10.5 Pourtant, i++ vaut i ?
10.6 En est-il de même pour i++ * i++ ?
10.7 Peut-on utiliser les parenthèses pour forcer l'ordre d'évaluation d'une expression ?
10.8 Qu'en est-il des opérateurs logiques && et || ?
10.9 Comment sont évaluées les expressions comprenant plusieurs types de variables ?
10.10 Qu'est-ce qu'une lvalue ?
11. Nombres en virgule flottante
11.1 J'ai un problème quand j'imprime un nombre réel.
11.2 Pourquoi mes extractions de racines carrées sont erronées ?
11.3 J'ai des erreurs de compilation avec des fonctions mathématiques
11.4 Mes calculs flottants me donnent des résultats étranges et/ou différents selon les plateformes
11.5 Comment simuler == entre des flottants ?
11.6 Comment arrondir des flottants ?
11.7 Pourquoi le C ne dispose-t-il pas d'un opérateur d'exponentiation ?
11.8 Comment obtenir Pi ?
11.9 Qu'est-ce qu'un NaN ?
11.10 Faut-il préférer les double aux float ?
12. Allocation dynamique
12.1 Doit-on ou ne doit-on pas caster malloc() ?
12.2 Comment allouer proprement une variable ?
12.3 Pourquoi mettre à NULL les pointeurs après un free() ?
12.4 Pourquoi free() ne met pas les pointeurs à NULL ?
12.5 Quelle est la différence entre malloc() et calloc() ?
12.6 Que signifie le message « assignment of pointer from integer » quand j'utilise malloc() ?
12.7 Mon programme plante à cause de malloc(), cette fonction est-elle buggée ?
12.8 Que signifient les erreurs « segmentation fault » et « bus error » ?
12.9 Doit-on libérer explicitement la mémoire avant de quitter un programme ?
12.10 Du bon usage de realloc()
13. Le pré-processeurs
13.1 Quel est le rôle du préprocesseur ?
13.2 Qu'est-ce qu'un trigraphe ?
13.3 À quoi sert un backslash en fin de ligne ?
13.4 Quelles sont les formes possibles de commentaires ?
13.5 Comment utiliser #include ?
13.6 Comment éviter l'inclusion multiple d'un fichier ?
13.7 Comment définir une macro ?
13.8 Comment définir une macro avec des arguments ?
13.9 Comment faire une macro avec un nombre variable d'arguments ?
13.10 Que font les opérateurs # et ## ?
13.11 Une macro peut-elle invoquer d'autres macros ?
13.12 Comment redéfinir une macro ?
13.13 Que peut-on faire avec #if ?
13.14 Qu'est-ce qu'un #pragma ?
13.15 Qu'est-ce qu'un #assert ?
13.16 Comment définir proprement une macro qui comporte plusieurs statements ?
13.17 Comment éviter les effets de bord ?
13.18 Le préprocesseur est-il vraiment utile ?
13.19 Approfondir le sujet.
14. Fonctions de la bibliothèque
14.1 Comment convertir un nombre en une chaîne de caractères ?
14.2 Comment convertir une chaîne en un nombre ?
14.3 Comment découper une chaîne ?
14.4 Pourquoi ne jamais faire fflush(stdin) ?
14.5 Comment vider le buffer associé à stdin ?
14.6 Pourquoi mon printf() ne s'affiche pas ?
14.7 Comment obtenir l'heure courante et la date ?
14.8 Comment faire la différence entre deux dates ?
14.9 Comment construire un générateur de nombres aléatoires ?
14.10 Comment obtenir un nombre pseudo-aléatoire dans un intervalle ?
14.11 À chaque lancement de mon programme, les nombres pseudo-aléatoires sont toujours les mêmes ?
14.12 Comment savoir si un fichier existe ?
14.13 Comment connaître la taille d'un fichier ?
14.14 Comment lire un fichier binaire proprement ?
14.15 Comment marquer une pause dans un programme ?
14.16 Comment trier un tableau de chaînes ?
14.17 Pourquoi j'ai des erreurs sur les fonctions de la bibliothèque, alors que j'ai bien inclus les entêtes ?
15. Styles
15.1 Comment bien programmer en C ?
15.2 Comment indenter proprement du code ?
15.3 Quel est le meilleur style de programmation ?
15.4 Qu'est-ce que la notation hongroise ?
15.5 Pourquoi certains écrivent-ils if(0==x) et non if(x==0) ?
15.6 Pourquoi faut-il mettre les '{' et '}' autour des boucles ?
15.7 Pourquoi certains disent-ils de ne jamais utiliser les goto ?
15.8 Pourquoi commenter un #endif ?
15.9 Où trouver de la doc sur les différents styles ?
15.10 Comment bien structurer son programme ?
16. Autres
16.1 Comment rendre un programme plus rapide ?
16.2 Quelle est la différence entre byte et octet ?
16.3 Peut-on faire une gestion d'exceptions en C ?
16.4 Comment gérer le numéro de version de mon programme ?
16.5 Pourquoi ne pas mettre de `_' devant les identifiants ?
16.6 À quoi peut servir un cast en (void) ?
17. En guise de conclusion
1. Copyright (Droits de reproduction)
1.1 Copyright de la FAQ de comp.lang.c
« The comp.lang.c FAQ list is Copyright 1990-1999 by Steve Summit.
Content from the book C Programming FAQs: Frequently Asked
Questions is made available here by permission of the author
and the publisher as a service to the community.
It is intended to complement the use of the published text and is
protected by international copyright laws.
The content is made available here and may be accessed
freely for personal use but may not be republished without
permission. »
1.2 Qu'en est-il de ce document ?
- Steve Summit a rédigé la version anglo-saxonne sur
laquelle nous nous sommes basés. On en a traduit de longs passages,
réorganisé, annoté, repensé une partie et réécrit complétement
d'autres paragraphes, ce avec son consentemment.
- Les auteurs comme les contributeurs de cette FAQ ne
garantissent rien, ni que les conseils donnés ici fonctionnent, ni
que le code compile et fonctionne correctement, ni que votre
machine ne va pas s'autodétruire instantanément après lecture de ce
message. Autrement dit, vous êtes entièrement responsable de ce que
vous faites des informations données ici. En cas de pépin, vous ne
pouvez vous en prendre qu'à vous même.
- Les copies conformes et versions intégrales de ce document
sont autorisées sur tout support pour peu que cette notice soit
préservée. Une utilisation commerciale devra faire l'objet d'une
autorisation préalable, notamment de Steve Summit.
2. Introduction
2.1 Qu'est-ce qu'une FAQ ?
C'est une Foire Aux Questions (les anglos-saxons
disent Frequent Asked Questions ou questions
fréquemment posées). Elle regroupe les réponses aux questions
récurrentes sur <news:fr.comp.lang.c>.
2.2 Qui la maintient ?
Elle est rédigée à l'initiative de Guillaume Rumeau
(<mailto:guillaume.rumeau@wanadoo.fr>).
2.3 Qui y contribue ?
Les rédacteurs de la FAQ sont :
- Guillaume Rumeau (<mailto:guillaume.rumeau@wanadoo.fr>),
- Thomas Pornin (<mailto:Thomas.Pornin@ens.fr>),
- Pascal Cabaud (<mailto:pascal.cabaud@wanadoo.fr>),
mais elle ne saurait exister sans les contributions de :
« After »,
« EpSylOn »,
« ironfil »,
« MacLord »,
Edgar Bonnet,
Erwan David,
Thomas Deniau,
Emmanuel Delahaye,
Gabriel Dos Reis,
Laurent Dupuis,
Horst Kraemer,
Antoine Leca,
Vincent Lefèvre,
Fabien Le Lez,
Éric Lévénez,
Serge Paccalin,
Yves Roman,
Michel Simian,
et tous les autres...
Merci aussi à Thomas Baruchel pour ces nombreuses
corrections orthographiques et typographiques, et à Stéphane
Muller pour son script python qui permet d'avoir des
versions postscript et pdf de la FAQ.
et n'oublions pas bien sûr Steve Summit.
Remarque :
Si vous pensez qu'un nom a été injustement omis, n'hésitez pas à
nous le faire savoir, nous nous ferons un plaisir de l'ajouter.
2.4 Où puis-je la trouver ?
à la page de Guillaume Rumeau :
<http://www.isty-info.uvsq.fr/~rumeau/fclc/>
et deux fois par mois sur <news:fr.comp.lang.c>
et <news:fr.usenet.reponses>.
2.5 J'ai trouvé une erreur !
Ce document étant rédigé par des humains,
il peut contenir des erreurs. Vous êtes vivement invités à les
signaler soit en postant sur <news:fr.comp.lang.c>
soit en écrivant à l'un des (aux) rédacteurs.
(voir aussi 2.3)
2.6 Et mes questions ?
Il faut commencer par les reformuler le plus précisément possible
(par exemple les reformuler en questions moins ouvertes) ; décrire
les problèmes aide beacoup.
Quand on commence à avoir une idée, chercher les mots clefs
décrivant le problème à l'aide de moteurs de recherche, par
exemple <http://www.google.com/>.
Regardez aussi ce que sait faire <http://www.copernic.com/fr>.
Si vous n'avez toujours pas de reponse, analysez les différents
forums disponibles, et posez la question dans celui qui vous
semblera le plus adapté ; si il y a plusieurs questions qui
semblent pouvoir aller dans plusieurs forums, rédigez plusieurs
messages (il y aura plus de réponses, car les réponses seront
moins longues à écrire ...).
Si la question est très technique et n'obtient pas de réponse
valable, faites l'effort de la re-rédiger en anglais et/ou
demandez gentiment une traduction si vous n'êtes pas sûr de votre
anglais, il y a suffisament de francophones sur les groupes
internationaux pour qu'une bonne âme vous rende service.
Avant de poster (sur <news:fr.comp.lang.c>),
mieux vaut se demander si :
- la question porte-t-elle sur le C ISO ?
cf. 3.7.
- la réponse est-elle dans la doc' ? dans mon bouquin ?
Bonne lecture !
- la réponse est-elle dans la FAQ ?
Bonne lecture !
- la réponse a-t-elle déjà été donnée ?
Pour le savoir, il faut chercher sur <http://groups.google.com/>.
Comme il est dit et redit quotidiennement sur
<news:fr.comp.lang.c>,
le forum ne traite ni de graphisme, ni de Windows.
À ce sujet, rappelons que la FAQ de
<news:fr.comp.os.ms-windows.programmation>
est disponible ici :
<http://www.usenet-fr.news.eu.org/fr.usenet.reponses/comp/os/faq-winprog.html>.
(Merci à Emmanuel Delahaye pour l'URL de copernic et à
Antoine Leca de m'avoir prêté sa plume ;-)).
2.7 Dois-je poster sur fr.comp.lang.c ?
Ainsi que le stipule la charte du groupe, les seules questions
traitées sur <news:fr.comp.lang.c> portent sur
le C ISO. Pour ce qui a trait avec la programmation
Be, DOS, Mac,
Unix, Windows, il y a des forums
dédiés.
En particulier,
- <news:fr.comp.os.ms-windows.programmation>
pour la programmation sous Windows,
- <news:fr.comp.sys.mac.programmation>
pour la programmation sous MacOS, MacOS X.
Pour les autres systèmes, il n'y a pas de forum spécifique dans la
hierarchie <news:fr.*>.
Pour ce qui concerne les Unix,
<news:fr.comp.os.unix> et/ou
<news:fr.comp.os.bsd>
(ou encore <news:news:fr.comp.sys.next>)
devraient faire l'affaire.
Dans la hiérarchie internationale, on trouve :
- <news:comp.os.msdos.programmer> pour DOS,
- <news:comp.unix.programmer> pour Unix,
- <news:comp.sys.be.programmer> pour Be,
- <news:comp.os.os2.programmer> pour OS/2,
Enfin, en ce qui concerne la programmation graphique, il existe
désormais un forum dédié à ce sujet dans la hiérarchie fr :
<news:fr.comp.graphisme.programmation>
2.8 Comment poster sur fr.comp.lang.c ?
En n'envoyant pas de pièce jointe, en postant en texte ASCII.
Les accents (ISO-8859-1) sont acceptés.
Outre les pièces jointes, le HTML, le quoted
printable et tout ce qui n'est pas text/plain
est à proscrire (pas mal de serveurs de news
supprimeront ces contributions indésirables sans autre forme de
procès).
Plus la question est précise, meilleure sera la réponse. On peut
utiliser des balises dans le sujet, une liste est maintenue par
Alexandre Lenoir, disponible là :
<http://www.planete.net/~alenoir/fcsm.html>. Ne
donnez pas de noms propres dans les sujets !
Il est de bon ton de poster les morceaux de code
problématique. Veillez à poster du code qui compile (sauf s'il ne
s'agit que de quelques lignes). Si le programme est trop gros,
donnez une URL où on peut le lire.
Pour répondre, veillez à ne citer que le strict nécessaire et à
répondre après le message ou passage cité.
Je vous rappelle qu'il est très impoli, pour des raisons évidentes, de
demander une réponse par mail ; et en général vous n'aurez pas
satisfaction. Si vraiment vous y tenez, tentez votre
chance avec le service fourni ici : <http://francette.net/bdr.html>
(je n'ai pas testé).
2.9 Comment comprendre le langage utilisé sur fr.comp.lang.c ?
Ceci n'est pas une FAQ sur Usenet mais sur le langage C donc on va
faire court :
- OEQLC signifie « Où Est la Question sur Langage
C» autrement dit, votre question est hors-sujet (off
topic),
- OT ou HS signifie « Hors-Sujet »
autrement dit, c'est du bruit,
- RTFM signifie « Read The F*cking
Manual » autrement dit, c'est dans tout bouquin digne
de ce nom (voir 3.9 et 3.10).
Pour les âmes sensibles, on traduit parfois par « Read
The Fine Manual », ou en français par « Regarde
Ton Fichu Manuel ».
3. Le langage C
3.1 Qu'est-ce que le langage C ?
Donner une définition du C est assez difficile, je vous propose
celle-ci (avec laquelle je me suis le moins fait insulté
;-)) :
C'est un langage structuré, généralement compilé, de haut niveau.
Pour le « haut niveau », cela dépend un peu du point de vue en
fait. À la fin des années 70, les réfractaires disaient de lui que
c'était « encore un assembleur ». D'autres le trouvent donc de bas
niveau ...
On vous renvoie à l'introduction et aux avant-propos de K&R
(cf. 3.9).
Il dispose d'une bibliothèque standard (normes ANSI, ISO, IEEE,
AFNOR,...) permettant un minimum d'interactions avec la machine.
Il a été normalisé (cf. 3.7)
ce qui permet de recompiler un source (n'utilisant que la
bibliothèque standard) sur n'importe quelle machine disposant d'un
compilateur respectueux de la norme.
Cett dernière ne porte que sur le langage proprement dit et sur le
contenu de la bibliothèque standard. Cette dernière ne contient
que le strict minimum pour interagir avec la machine. Ainsi,
peut-on manipuler du texte et des fichiers, déterminer le temps de
calcul ou gérer la mémoire mais guère plus. Le reste est à la
charge du programmeur, ou des bibliothèques spécifiques du
système.
Au vu de ce qui précède, on peut donc donner cette autre
définition :
Le C est un langage de programmation dont la structure est proche
de la machine de Von Neumann.
Donc ce qui importe, ce n'est pas tant qu'on puisse recompiler
notre programme type sans modification sur toutes les
plateformes, c'est la « sémantique ». Le fait d'écrire en C
standard n'implique nullement que le programme soit portable en ce
sens qu'il a la même sémantique sur tous les compilateurs. Il est
important de noter que la définition de C définit une machine
abstraite « paramétrée » -- les paramètres variant d'un
compilateur à un autre.
Rappelons ici encore que le langage ne gère ni la souris, ni
l'écran, ni votre store électrique (pardon, nucléaire) dernier
cri. Tout cela est du ressort de votre OS.
Voir aussi 3.5.
Merci à Emmanuel Delahaye, Gabriel Dos Reis, Vincent
Lefèvre, Thomas Pornin et tous les autres pour
la rédaction de cet article.
3.2 À quoi ça sert ?
À créer ses propres logiciels, selon ses besoins, de manière
portable ie. indépendemment de la machine et du
système d'exploitation.
3.3 D'où vient le C ?
Il a été créé par Brian Kernighan et Dennis
Ritchie, sur les cendres du BCPL (Basic Combined
Programming Language de Martin Richard, le BCPL
étant une simplification du CPL, Cambridge Programming
Language) et du B (langage expérimental de Ken
Thompson), dans les années 70 lorsqu'ils écrivaient
Unix.
Voir aussi 3.7.
3.4 Que peut-on faire en C ?
On peut tout faire ou presque. On peut créer son propre système
d'exploitation (les Unix-like sont encore écrits en C
pour la majorité), son interface graphique, sa base de données,
son driver (pilote) pour la dernière machine à café
USB, etc.
Tout compilateur C est fourni avec une bibliothèque de fonctions,
en principe standard.
Voir aussi 3.5.
3.5 Portabilité, matériel, système ...
Si la norme du C permet une bonne portabilité, il faut noter que
l'on peut faire des choses parfaitement dépendantes de la
cible. Ainsi, les Unix sont-ils écrits en C. Mais
point n'est besoin d'utiliser des API [1] exotiques pour perdre en
portabilité, présupposer qu'un char fait 8 bits est
l'exemple le plus flagrant (cf. 16.2).
Un autre exemple classique est de croire que toutes les machines
supportent l'ASCII ...
3.6 Et le C++ dans tout ça ?
Le C++ est un langage à objets basé sur le C. Il y a des
différences suffisantes pour qu'il s'agisse d'un autre langage,
ayant son forum propre :
<news:fr.comp.lang.c++>.
Il existe un autre langage à objets basé sur le C. Il s'agit
d'Objective-C. Il est principalement utilisé dans Mac OS X
et dans GNUStep.
Son forum est <news:fr.comp.lang.objective-c>.
3.7 ISO, ANSI, K&R, ..., qu'es aquo ?
Les origines :
Le langage C est le fruit des efforts conjoints de Brian
Kernighan, Denis Ritchie et Ken Thompson.
Le dernier dirigeait le projet de réécriture de
Multics (un OS multi-utilisateurs, projet abandonné)
et il voulait créer un OS qui soit portable répondant à ses
attentes, permettant un accès simple aux périphériques. De fil en
aiguille, c'est devenu un système largement indépendant du
hardware. À l'époque les plateformes étaient toutes
si différentes qu'il était commun de donner ses sources et la
moindre recompilation d'une machine à une autre demandait souvent
un effort de portage.
Pour faire ce système, il en est venu à penser Unix
de sorte que les deux seuls éléments qui dépendent du
hardware se résument au strict minimum à savoir le
compilateur et le noyau. Il lui fallait un langage d'assez bas
niveau et simple. Se basant sur le BCPL, Thompson a donc
mis au point le langage B (pour Unics, 1969-1972)
puis Ritchie l'a amélioré pour en faire le langage C
(Unix, 1973).
Voir aussi 3.3 et surtout le papier de
Dennis Ritchie :
<http://cm.bell-labs.com/cm/cs/who/dmr/chist.html> pour plus
de détails.
La popularité du C tient alors autant à sa simplicité qu'à la
pénétration d'Unix (et donc l'apparition de
compilateurs C sur les machines ie. la nouvelle
portabilité des programmes). Des compilateurs sont alors assez
vite apparus sur d'autres plateformes qu'Unix,
contribuant ainsi à la diffusion (un peu anarchique) du langage.
En 1978, Brian W. Kernighan et Denis M. Ritchie
ont publié The C Programming Language
(ISBN:0131101633) (On trouve tous les numéros ISBN des différentes
éditions sur <http://cm.bell-labs.com/cm/cs/cbook/index.html>).
Dès lors, les compilateurs ont commencé à suivre les
recommandations et indications des auteurs. Cet ouvrage a fait
office de norme pendant longtemps, le langage qui y est décrit
s'appelle le C K&R, en référence aux 2 auteurs.
La normalisation :
Devant la popularité du C, l'American National Standard
Institut (<http://www.ansi.org>) charge en 1983 le
comité X3J11 de standardiser le langage C. On parle à ce moment-là
de C pré-ANSI. Après un processus long et complexe, le travail du
comité a finalement été approuvé :
le 14 décembre 1989, le standard ANSI X3.159-1989 (ou C89) est
né. Il est publié au printemps 1990.
Entre-temps, en 1988, durant la période de travail du comité, la
deuxième édition du K&R a été publiée (ISBN: 0131103709). Elle
a été complètement réécrite et on y a ajouté des exemples et des
exercices afin de clarifier l'implémentation de certaines
constructions complexes du langage.
Dans sa plus grande partie, le standard C ANSI de 1989 officialise
les pratiques existantes, en ajoutant quelques nouveautés
provenant du C++ comme les prototypes de fonctions et le support
de jeux de caractères internationaux (notamment les très
controversées séquences trigraphes). Le standard C ANSI décrit
aussi les routines pour le support des bibliothèques d'exécution
du C.
L'International organization for standardization
(<http://www.iso.ch>) a adopté en 1990 ce standard en tant
que standard international sous le nom de ISO/IEC 9899:1990 (ou
C90). Ce standard ISO remplace le précédent standard ANSI (C89)
même à l'intérieur des USA, car rappelons-le, ANSI est une
organisation nationale, et non internationale comme l'ISO. Aux
USA, on parle alors de ANSI/ISO 9899-1990 [1992], en France de
ISO/CEI 9899:1990.
Détails sur la normalisation :
Durant les années 1990, lorsqu'on parle de C89 (C ANSI) ou de C90
(C ISO), ce sont deux appellations différentes pour en fait une
seule et même norme. Il existe aussi une norme européenne et une
française (AFNOR) dont on entend beaucoup moins parler, qui sont
aussi semblables à la norme ISO. Noter que la norme française
(AFNOR) est parfaitement identique à l'ISO, l'AFNOR se contentant
de publier l'ISO (en anglais) en guise de norme française (le site
du groupe de normalisation du C à l'AFNOR :
<http://forum.afnor.fr/afnor/WORK/AFNOR/GPN2/Z65B/>, ne pas
se fier aux apparences, il s'agit du groupe sur le C, la page est
un peu vieille et le groupe --- réduit passé un temps à Antoine
Leca --- a été recueilli par le groupe chargé du C++).
Les standards ISO, en tant que tel, sont sujets à des révisions,
par la diffusion de « Technical Corrigenda »
[2] et de « Normative
Addenda » [3] . C'est ainsi qu'en
1995, le Normative Addendum 1 (NA1)
(<http://www.lysator.liu.se/c/na1.html>) parfois appelé
Amendment 1 (AM1) fut approuvé en 1995. Il ajouta
environ 50 pages de spécifications diverses concernant notamment
de nouvelles fonctions dans la bibliothèque standard pour
l'internationalisation, et les séquences digraphes pour le jeu de
caractères ISO 646, autorisant ainsi les terminaux ne possédant
pas certains caractères à utiliser une écriture alternative
(<% %> pour { et } ou
encore <: :> pour [ et
]).
Peu de temps après, toujours en 1995, le Technical
Corrigendum 1 (TCOR1) (<http://anubis.dkuug.dk/JTC1/SC22/WG14/www/docs/tc1.htm>)
fut approuvé et modifia le standard ISO en environ 40 points, la
plupart d'entre eux étant des corrections mineures ou des
clarifications. En 1996, on publia aussi le TCOR2
(<http://anubis.dkuug.dk/JTC1/SC22/WG14/www/docs/tc2.htm>)
qui apporta des changements encore plus mineurs que le
TCOR1. TCOR2 reformulait certains points abscons.
À partir de 1997, on désigne par C95 l'ensemble des documents
TCOR1, TCOR2 et AMD1 et de la norme C90. Le terme C95 est utilisé
dans le « rationale » de C99.
En fait ce n'est pas directement l'ISO qui travaille sur les
standards, elle ne fait que les approuver conjointement avec l'IEC
(<http://www.iec.ch>). C'est pour cette raison que les
standards ISO du C commencent par ISO/IEC... De plus, l'ISO charge
des comités techniques de travailler dans tels et tels
domaines. En l'occurrence, le JTC1 (<http://www.jtc1.org>)
est le comité spécialisé dans le domaine informatique. Le JTC1 à
son tour répartit le travail dans plusieurs sous-comités : celui
qui nous intéresse est le SC22, dont le but est la standardisation
des technologies de l'information. Or le SC22 lui-même est
subdivisé en Working Groups, le WG14 étant celui qui
est en relation avec le C.
Finalement, c'est le ISO/IEC JTC1/SC22/WG14 qui rédige la norme
ISO du C, le SC2 approuve alors le projet final (FDIS), puis le
transmet au JTC1 qui approuve la nouvelle norme ISO.
En réalité, le groupe de travail WG14 est composé d'organismes
nationaux --- tels ANSI (le plus actif), AFNOR, BSI, CSA, DS,
... --- représentants les pays prenant part à la normalisation (je
vous passe les détails de pays votants, observateurs, et
autres). Chacun de ces organismes travaille sur le langage. L'ANSI
dispose elle aussi d'un comité spécialisé dans le domaine
informatique : le X3 (<http://www.x3.org>), qui depuis 1996
s'appelle NCITS (prononcez insights en anglais)
(<http://www.ncits.org>) pour National comittee for
Information Technology Standards. Lui aussi dispose de
comités techniques qui travaillent chacun dans un domaine
particulier : le J11 (<http://www.ncits.org/tc_home/j11.htm>)
a en charge le langage C. C'est donc le X3J11 qui développe la
norme C ANSI aux USA, et qui travaille avec le WG14.
Il se trouve qu'en 1993, lors des réunions bi-annuelles entre le
WG14 (ISO) et le X3J11 (ANSI), tout le monde s'est accordé pour
dire,
- que la révision (prévue dans les textes ISO) de 1995 ne
se ferait pas, et
- que la révision de 2000 environ aboutirait à une
nouvelle version de la norme (le futur C9X).
L'idée a alors émergée de créer un nouveau standard du C qui
regrouperait le C90, le NA1, le TCOR1 et le TCOR2, apporterait
d'autres modifications afin de maintenir le C en phase avec les
techniques de programmation d'aujourd'hui, et qui minimiserait
les incompatibilités avec le C++, sans pour autant vouloir
transformer le C en C++. Ce projet de nouveau standard du C a pris
le nom de code C9X avec l'intention qu'il serait publié dans la
fin des années 1990
(<http://anubis.dkuug.dk/JTC1/SC22/WG14/www/charter.html>).
Vers la fin de la normalisation de C99, SC22/WG21 -- le groupe de
travail qui s'occupe de C++ -- a adressé une requête formelle (par
l'intermédiaire du bureau SC22) à SC22/WG14 pour documenter les
éventuelles incompatibilités introduites par C99 par rapport à C++
(SC22/WG21 l'avait fait par rapport à C90). SC22/WG14
a répondu qu'il n'avait ni le temps nécessaire ni la compétence
pour faire cela.
Cependant, un tel travail (inspiré partiellement de ce que C++ a
déjà fait) a été entrepris à titre personel par
David Tribble dont la contribution se trouve ici :
<http://www.david.tribble.com/text/cdiffs.htm>.
Tout au long du projet C9X, des « drafts »
(brouillons) du projet sont distribués afin que tout le monde
puisse donner son avis et, le cas échéant, revoir certaines
parties. Le dernier draft disponible est le document
n869 (<http://www.dkuug.dk/jtc1/sc22/wg14/www/docs/n869/>) datant de
janvier 1999. Ce document est celui le plus proche de la norme et
que l'on peut obtenir gratuitement: il définit C9X, le projet de
la norme.
Dernières nouvelles :
Très récemment, le 1er décembre 1999, la norme officielle a été
adoptée par l'ISO sous le nom de ISO/IEC 9899:1999, ou plus
simplement C99. Elle a aussi été publiée par l'ANSI, qui travaille
conjointement avec l'ISO, sous le nom de ANSI/ISO/IEC 9899-1999,
mais que l'on appelle C2k.
À l'heure actuelle, C99, qui est équivalent à C2k,
n'est pas encore totalement supportée par les compilateurs. Il faut
un certain temps pour implémenter toutes les nouvelles
fonctionnalités de C99. Tout ce dont on peut être sûr, c'est que
n'importe quel bon compilateur supporte au moins la norme C90.
Voici d'ailleurs au passage quelques unes des nouveautés de C99:
- tableau à longueur variable,
- support des nombres complexes grâce à complex.h,
- types long long int et unsigned long long
int d'au moins 64 bits,
- famille de fonctions vscanf(),
- les fameux commentaires à-la-C++ //,
- les familles de fonctions snprintf(),
- le type booléen,
- etc.
Théoriquement, ISO révise les normes tous les cinq (5) ans. Les
groupes de travail n'ont pas besoin d'attendre les cinq ans avant
de commencer à travailler sur les éventuelles
extensions. Cependant le travail de normalisation prend un certain
temps --- pensez par exemple que ANSI a débuté le travail de
normalisation de C89 en 1983 et n'a fini qu'en 1989. Il est
possible qu'un C04 soit publié en 2004, ce serait C99 augmenté de
quelques amendements. Le travail de normalisation est long et
pénible par moment.
Un grand merci à « After » pour le brouillon de cet article et à
Gabriel Dos Reis, Éric Lévénez et Antoine
Leca pour leurs relectures avisées.
3.8 De quoi ai-je besoin pour programmer en C ?
D'un éditeur de texte basique,
d'un compilateur (voir 4.2),
d'un bon bouquin (voir 3.9),
d'un débogueur et de beaucoup de patience.
En principe, compilateur, bibliothèque(s), (débogueurs)
et doc' sont fournis ensembles.
Pour apprendre le C, il vous faudra un bon compilateur,
de la doc' papier, un bon dictionnaire d'anglais et un stock
d'aspirine ;-)
3.9 Quel(s) bouquin(s) ?
Le livre que tout programmeur C se doit de connaître et d'avoir
sur son bureau est Kernighan B.W. & Ritchie
D.M. (1997), Le langage C Norme ANSI, 2ème édition,
Dunod, Paris.
On trouvera les exercices corrigés du précédent dans :
Tondo C.L. & Gimpel S.E. (2000),
Exercices corrigés sur le langage C, Dunod, Paris.
En complément, Braquelaire J.-P. (2000),
Méthodologie de la programmation en C, Bibliothèque
standard, API POSIX, 3ème édition, Dunod, Paris.
sera une excellente ressource.
Enfin, citons l'excellent
Kernighan B.W. & Pike R., (1999)
The Pratice of Programming, Addison-Wesley, Reading.
(<http://cm.bell-labs.com/cm/cs/tpop/index.html>).
Il arrive souvent au programmeur de devoir résoudre des problèmes
d'Algorithmique. Il peut se reporter à la bible en la matière :
Knuth D.E. (1997), The Art of Computer
Programming, third edition, Addison-Wesley, Reading.
(communément abrégé en TAoCP). Il y a aussi :
Sedgewick R. (1991), Algorithmes en
langage C, InterÉditions, Paris.
ou cet autre :
Loudon K. (2000), Maîtriser les Algorithmes en
C, O'Reilly, Paris.
Une bonne introduction à l'Analyse Numérique en C est :
Press W.H., Flannery B.P., Teukolsky
S.A., Vetterling W.T. (1992), Numerical Recipes in
C, The Art of Scientific Computing, second edition,
Cambridge University Press. (communément abrégé en NR, PFTW ou
Numerical Recipes selon). C'est disponible en ligne
(voir 4.5).
Il existe aussi :
Engeln-Müllges G. & Uhlig F.
(1996), Numerical Algorithms with C, Springer,
Berlin. (fourni avec les sources et djgpp, pour
plateformes Wintel, sur CD).
3.10 Où trouver...
de la doc' ? :
Là par exemple : <http://cm.bell-labs.com/cm/cs/who/dmr/>,
c'est la page de Denis Ritchie.
Il y a aussi celle de Brian Kernighan :
<http://cm.bell-labs.com/cm/cs/who/bwk/>.
On trouve des cours de C sur le web en français sur
les sites universitaires. Ainsi, on peut citer :
<ftp://ftp.ltam.lu/TUTORIEL/COURS-C/COURS-C.ZIP>,
<http://www.enseignement.polytechnique.fr/profs/informatique/Eric.Goubault/poly/cours.ps.gz>,
<http://www.loria.fr/~mermet/CoursC/coursC.ps>,
<http://www.enseignement.polytechnique.fr/profs/informatique/Jean-Jacques.Levy/poly/polyx-cori-levy.ps.gz>,
<http://www-inf.int-evry.fr/COURS/COURSC/>
On lira aussi très attentivement :
<ftp://ftp.laas.fr/pub/ii/matthieu/c-superflu/c-superflu.pdf>
qui contient tout ce qu'il faut savoir pour commencer à programmer
proprement en C. Il contient aussi une grosse bibliographie.
Un CD complet en ligne sur le C : <http://www.infop6.jussieu.fr/cederoms/Videoc2000/>
Les sources du bouquin de Braquelaire (dernière édition :
la 3ème, 2ème tirage...) :
<http://dept-info.labri.u-bordeaux.fr/~achille/MPC-3/2T/MPC-3-2t.tar.gz>
Les sources du bouquin de Loudon :
<http://www.editions-oreilly.fr/archives/algoc.zip>.
La bibliothèque standard : <http://www.dinkumware.com/htm_cl/index.html#Table-of-Contents>
Le IOCCC est un concours de hackers qui récompense
chaque année le pire programme C :
<http://www.ioccc.org/index.html>
Un freezzine en anglais :
<http://www.gmonline.demon.co.uk/cscene/>
Sur les sites universitaires on trouve toujours des cours en
ligne, du code, etc ...
Signalons aussi (même si c'est hors-sujet) le fichier
<ftp://ftp.laas.fr/pub/ii/matthieu/tpp/tpp.ps.gz>
qui explique comment utiliser make.
Je recommande aussi vivement l'utilisation d'outils tels que
CVS :
<http://www.cvshome.org/docs/>
<http://www.idealx.org/fr/doc/cvs/cvs.html>
<http://matrix.samizdat.net/serveurs/cvs/tut_cvs.html>
la norme ? :
Là : <http://wwwold.dkuug.dk/jtc1/sc22/open/n2794/n2794.txt>
On peut aussi l'acheter soit auprès de l'AFNOR (très cher) soit en
ligne aux USA (environ 20 $ US), ça se passe ici :
<http://www.cssinfo.com/ncitsgate.html> ou encore là
<http://webstore.ansi.org/ansidocstore/product.asp?sku=ANSI%2FISO%2FIEC+9899%2D1999>
(Merci à Antoine Leca).
la FAQ de comp.lang.c ? :
Là : <http://www.eskimo.com/~scs/C-faq/top.html>
les pages des manuels Unix en français ? :
On peut trouver les pages de manules en Français pour la plupart des Unix,
sous la forme de packages du système. Pour Linux, vous les trouverez ici :
<http://perso.club-internet.fr/ccb/>
ou encore là :
<http://www.delafond.org/traducmanfr/>
Le C et les CGI ? :
Tout ce qui concerne le C à propos des CGI est là :
<http://www.chez.com/nospam/cgi.html>
Il y a aussi une FAQ ici :
<http://www.htmlhelp.com/faq/cgifaq.html>
(informations bienvenues à <mailto:pascal.cabaud@wanadoo.fr>)
La Programmation Objet en C ? :
Oui, on peut programmer Orienté Objet en C. Voici un document qui
présente ces techniques :
<http://ldeniau.home.cern.ch/ldeniau/html/oopc/oopc.html>
4. Outils, environnement de développement et autres gadgets
Note :
Cette section a du mal à vivre sans l'aide des
lecteurs. Par soucis d'équité et pour limiter un peu le volume
d'informations, on s'en tient aux logiciels, programmes, codes,
etc. libres, gratuits ou du domaine public.
4.1 Environnements de développement intégrés
Apple :
Sur Mac OS, MPW combiné avec le terrible
MacsBug
vous donneront entière satisfaction.
Pour Mac OS X, Project Builder est l'IDE de choix
utilisant GNU CC.
<http://developer.apple.com/tools/projectbuilder/>
Unix :
Sur Unix-like, vi[m] et
[x]emacs, combinés avec make, GNU
CC et GNU DB forment un environnement de
développement intégré.
Wintel :
Borland fournit l'environnement
Turbo complet avec éditeur, débogueur,
etc. Mais c'est
passablement vieux : la version 2.0 distribuée sur les sites de
Borland date de 1988, il s'agit donc d'un compilateur
pré-ANSI (cf. 3.7). Si
l'on tient à utiliser du matériel Borland,
Turbo C++ 1.01 sera plus confortable et plus conforme
à la norme (en ayant récupéré l'archive BC20P2.ZIP
qui traîne un peu partout).
Mieux vaut se rabattre sur le couple
djgpp-RHIDE (tentez votre chance ici :
<http://www.rhide.com>), qui d'ailleurs existe sous Linux.
Il y a aussi Source Navigator disponible ici :
<http://sources.redhat.com/sourcenav/>.
On pourra aussi utiliser NTemacs
(cf.
<http://www.linux-france.org/article/appli/emacs/Gnus+Emacs/Windows/emacs.html>).
Signalons enfin l'existence d'un IDE assez complet, gratuit et
open-source : Dev-C++ ; il est basé sur
MinGW (mais peut aussi utiliser Cygwin)
pour la compilation et le debugger. On le retrouvera à l'adresse :
<http://www.bloodshed.net/devcpp.html>.
(voir aussi 4.2).
4.2 Compilateurs
Le choix dépend du système d'exploitation et du processeur cible.
Apple :
Pour les machines sous Mac OS, le compilateur
d'Apple est gratuit, il est là :
<ftp://ftp.apple.com/devworld/Tool_Chest/Core_Mac_OS_Tools/MPW_etc./>.
Pour les machines sous Mac OS X, le compilateur est GNU
CC
Unix :
Pour Unix-like, le GNU C Compiler (
alias GNU
CC ou gcc) est fourni avec toute
distribution *BSD ou GNU/Linux.
Wintel :
Pour machines Wintel, il existe un portage du célèbre
GNU C Compiler :
<http://www.delorie.com/djgpp/>.
Un autre portage existe pour Windows :
<http://sources.redhat.com/cygwin/>.
MinGW (Minimalist-GnuWin32), encore un portage
Win32 de
gcc.
Frustre mais puissant, optimise bien, adapté si
l'on connaît bien l'environnement de programmation UNIX :
<http://mingw.sourceforge.net/>
Borland a aussi mis en
téléchargement gratuit certains de ses compilateurs là :
<http://www.borland.com/bcppbuilder/freecompiler/>
ou là :
<http://www.borland.fr/download/compilateurs/>.
Il y a aussi lcc-win32, qui est un dérivé du
lcc originel de Chris Fraser et David
Hanson.
lcc-win32 vient avec un éditeur intégré, et
contient ce qu'il faut comme documentation et bibliothèques pour
ouvrir des fenêtres sous Windows. Il est plus léger
en termes de consommation mémoire et de CPU que GNU
CC; il produit un code décent (mais néanmoins pas optimal) :
<http://www.cs.virginia.edu/~lcc-win32/>
4.3 Débogueurs
Apple :
Allez là : <http://devworld.apple.com/tools/debuggers/>.
Pour Mac OS X, le déboggeur fourni avec le système
est GNU DB.
Unix :
GNU DB (alias gdb) est
fourni avec les distributions *BSD et
GNU/Linux.
Wintel :
À part celui de l'environnement Turbo
(cf. 4.1), regardez du côté de
<http://sources.redhat.com/insight/>.
4.4 Graphisme
Apple :
Pour Mac OS classique, il vous faut récupérer
QuickDraw, fournie par Apple :
<http://devworld.apple.com/macos/quickdraw.html>
Pour Mac OS X, l'environnement graphique s'appelle
Quartz et il utilise OpenGL :
<http://developer.apple.com/techpubs/macosx/CoreTechnologies/graphics/Quartz2D/quartz2d.html>
Unix :
Pour environnement Unix, il existe un environnement
graphique libre, reproduisant le système X11 (dit
aussi X-Window). Il est fourni avec toute
distribution *BSD ou GNU/Linux. Allez le
voir sur <http://www.xfree86.org/>.
Wintel :
Pour du graphisme sous DOS avec djgpp,
il y a Allegro qui se trouve là :
<http://www.talula.demon.co.uk/allegro>
4.5 Bibliothèques
Calcul scientifique :
Pour du calcul scientifique, ici : <http://www.netlib.org/>
(mis à jour très régulièrement).
Ajay Shah maintenait un index de codes libres et/ou du
domaine public implémentant diverses routines de calcul. On le
trouve par exemple là :
<ftp://ftp.math.psu.edu/pub/FAQ/numcomp-free-c>
mais ça date.
Numerical Recipes in C :
Là :
<http://www.ulib.org/webRoot/Books/Numerical_Recipes/bookcpdf.html>.
Les sources ont été incluses dans la distribution
Linux pour les plateformes à base de
PowerPC :
« LinuxPPC 1999 ». Les sources ont disparu des
miroirs et « LinuxPPC 2000 » ne l'intègre plus mais
les miroirs ont encore (en septembre 2000) le package
de binaires (pour PPC uniquement) et certains sont prêts à envoyer
les sources.
Générateurs de nombres pseudo-aléatoires :
(Les anglo-saxons disent Pseudo-Random Numbers
Generators et abrègent en PRNG)
Par exemple là :
<http://www.io.com/~ritter/NETLINKS.HTM#RandomnessLinks>,
<http://burtleburtle.net/bob/rand/isaacafa.html> ou
<http://random.mat.sbg.ac.at/>.
Voir aussi <http://www.netlib.org/> et cherchez enfin
r250, RANLIB et FSULTRA.
Calcul multi-précision :
On trouve le code des fonctions quad() de
BSD quelque part là :
<ftp://ftp.uu.net/systems/unix/bsd-sources/> dans
un répertoire src/lib/libc/quad/.
Il y a aussi la bibliothèque GNU MP (GNU Multiple
Precision ou GMP) que l'on trouve ici :
<http://www.swox.com/gmp/>.
Enfin, il y a le package
MIRACL (voir <http://indigo.ie/~mscott/>).
Les sources de la bibliothèque standard :
Le livre
Plauger P.J. (1994), La bibliothèque C
standard chez Masson, réimplémente la plupart des
fonctions. Attention, les sources ne sont pas libres. On peut
aussi consulter les sources des Unix-based libres
*BSD ou encore celles du projet GNU.
(informations bienvenues à
<mailto:pascal.cabaud@wanadoo.fr>).
4.6 Outils divers
Notez que la majorité des outils cités ici ont initialement été
écrits pour des plateformes Unix. Il existe assez
souvent des portages sur d'autres OS, que l'on cite
parfois. Il arrive fréquemment que je ne donne pas d'URL ; une
recherche par exemple avec le merveilleux <http://www.google.com/>
vous donnera des liens à ne plus savoir qu'en faire ...
Certains sont là :
<ftp://gatekeeper.dec.com/pub/usenet/comp.sources.unix/>
ou sur le mirroir :
<ftp://ftp.uu.net/usenet/comp.sources.unix/>.
Pour les outils
GNU, voir sur le site du projet : <http://www.gnu.org/>.
Indentation et mise en forme :
Cherchez cb, enscript,
indent, lgrind, vgrind.
Vérification de sources :
Cherchez lint et regardez
<http://www.elirion.com/lintpage.html>.
On trouve splint(anciennement LCLint) là :
<ftp://www.splint.org>.
Génération de références croisées :
Cherchez cflow, cxref,
calls, cscope, xscope, ou
ixfw. C'est pratique pour voir les graphes de
dépendances des fonctions.
Dégénération de code C :
Cherchez obfus, shroud, ou
opqcp. Ce gadget sert à rendre un source parfaitement
illisible.
Interprétation des déclarations :
Cherchez cdecl dans le volume 14, à
<http://www.uu.net/usenet/comp.sources.unix/>. Ça sert
essentiellement à comprendre des déclarations ou à en générer.
Génération de dépendances :
Cherchez makedepend ou tentez cc -M ou
cpp -M.
Gestion de projets :
Cherchez GNU make. Voir aussi 3.10.
Contrôle de versions :
Cherchez CVS, RCS et SCCS.
Voir aussi 3.10.
Traducteurs Fortran/C et Pascal/C :
Cherchez ftoc et f2c pour le Fortran.
On trouve f2c sur
<http://www.netlib.org/>. Il existe une version pour
MacOS :
<http://www.alumni.caltech.edu/~igormt/Mac_F2C.html>.
Pour le Pascal, ça se trouve là :
<ftp://csvax.cs.caltech.edu/pub/p2c-1.20.tar.Z>.
Cherchez aussi ptoc.
Calcul d'unités :
Cherchez ccount, Metre, lcount,
csize,
<http://www.qucis.queensu.ca/>.
Calcul du nombre de lignes d'un fichier source :
Utilisez les commandes wc ou grep -c ";".
Génération de prototypes :
Cherchez cproto (<http://www.vex.net/~cthuang/cproto/>)
et cextract.
Gestion correcte des appels à malloc :
Cherchez dbmalloc, MallocDebug,
JMalloc.c et JMalloc.h, zieutez la page
<http://www.cs.colorado.edu/homes/zorn/public_html/MallocDebug.html>
et regardez :
<ftp://ftp.crpht.lu/pub/sources/memdebug>. Ceci
fait, il vous reste à compiler et installer dmalloc
provenant de là :
<http://dmalloc.com/>.
Génération de documentation à partir de code commenté :
Il existe divers outils dont doc++ et
doxygen. Le dernier gère le format LaTeX2e, HTML et
nroff et se trouve ici :
<http://www.stack.nl/~dimitri/doxygen/>.
Voir aussi 4.7.
Préprocesseur sélectif :
Cherchez unifdef, rmifdef et
scpp. Ils suppriment les directives
#ifdef inutiles, rendant ainsi un code plus lisible.
Gestion des expressions régulières :
Le projet GNU propose rx.
Il y a aussi regexp sur
<ftp://ftp.cs.toronto.edu/pub/regexp.shar.Z>.
Profileur :
Le projet GNU développe gprof (
cf. 16.1).
Il existe aussi FunctionCheck :
<http://www710.univ-lyon1.fr/~yperret/fnccheck/profiler.html>
4.7 Où trouver du code ?
Là : <http://www.gnu.org> par exemple.
Les logiciels GNU, les Unix-like
*BSD et
GNU/Linux sont distribués (ils sont
libres) avec les sources. La pluparts d'entre eux
étant écrits en C, cela en fait une très grande collection de
code.
On trouvera du code (du domaine public) là :
<ftp://ftp.cdrom.com>.
Il y a aussi
<ftp://ftp.brokersys.com/pub/snippets> et sur le
web à <http://www.brokersys.com/snippets/> ou
<http://www.ping.de/sites/systemcodes/> ou encore par
ftp par exemple à
<ftp://ftp.funet.fi/pub/languages/C/Publib/>.
Les serveurs <ftp://ftp.uu.net/>,
<ftp://archive.umich.edu/>,
<ftp://oak.oakland.edu/>,
<ftp://sumex-aim.stanford.edu/>, et
<ftp://wuarchive.wustl.edu/>,
hébergent une grande quantité de logiciels, code et documentation
libres et/ou gratuits. le serveur princicpal du projet
GNU est <ftp://prep.ai.mit.edu/>.
Voir aussi 4.6 et 4.5.
(informations bienvenues à
<mailto:pascal.cabaud@wanadoo.fr>)
Traduit en HTML par faq2html.pl le Wed Nov 3 05:42:13 2010 pour le site Web Usenet-FR.
