[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&amp;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 &amp;&amp; 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>)


Valid XHTML 1.0! [Retour au sommaire] Valid CSS!

Traduit en HTML par faq2html.pl le Wed Nov 3 05:42:13 2010 pour le site Web Usenet-FR.