faq-c-1

précédant | suivant | sommaire
---------------------------------------------------------------------------
FAQ de fr.comp.lang.c

31 janvier 2001
Partie 1/3 (section 1 à 4)

Foire Aux Questions du forum fr.comp.lang.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 PostScript de cette FAQ est disponible à l'adresse
     suivante :
     http://www.isty-info.uvsq.fr/~rumeau/FAQ-FCLC.ps
     Une version PDF est également disponible :
     http://www.isty-info.uvsq.fr/~rumeau/FAQ-FCLC.pdf
     Les sources LATEX 2e sont récupérables ici :
     http://www.isty-info.uvsq.fr/~rumeau/faq_sources.tar.gz
---------------------------------------------------------------------------

Table des matières

1. Copyright
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 Et le C++ dans tout ça ?
3.6 ISO, ANSI, K&R, ..., qu'es aquo ?
3.7 De quoi ai-je besoin pour programmer en C ?
3.8 Quel(s) bouquin(s) ?
3.9 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 Bibliothèques
4.5 Outils divers
4.6 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 Quelle est la différence entre char a[] et char * a ?
5.9 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 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 ?

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 extraction 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 plate-formes.
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 ?

12. Allocation dynamique
12.1 Pourquoi ne 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 ?

13. Le pré-processeur
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 construire un générateur de nombres aléatoires ?
14.9 Comment obtenir un nombre pseudo-aléatoire dans un intervalle ?
14.10 À chaque lancement de mon programme, les nombres pseudo-aléatoires
        sont toujours les mêmes ?
14.11 Comment savoir si un fichier existe ?
14.12 Comment connaître la taille d'un fichier ?
14.13 Comment lire un fichier binaire proprement ?
14.14 Comment marquer une pause dans un programme ?
14.15 Comment trier un tableau de chaînes ?
14.16 Pourquoi j'ai des erreurs sur les fonctions de la bibliothèque,
        alors que j'ai bien inclus les en-tê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 if(0==x) et non if(x==0) ?
15.6 Pourquoi faut-il mettre les '{ }' autour des boucles ?
15.7 Pourquoi certains disent de ne jamais utiliser les goto ?
15.8 Pourquoi commenter un #endif ?
15.9 Où trouver de la doc sur les différents styles ?

16. Autres
16.1 Comment rendre un programme plus rapide ?
16.2 De la différence entre byte et octet
16.3 Peut-on faire une gestion d'exception 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 ?

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. En
     outre, seule la version courante de ce document fait foi.
   * 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
(guillaume.rumeau@wanadoo.fr).

2.3 Qui y contribue ?

Les rédacteurs de la FAQ sont :

   * Guillaume Rumeau (guillaume.rumeau@wanadoo.fr),
   * Thomas Pornin (Thomas.Pornin@ens.fr),
   * Pascal Cabaud (pascal.cabaud@wanadoo.fr),

mais elle ne saurait exister sans les contributions de :

« -hs- », « After », « ironfil », « MacLord », Edgar Bonnet, Erwan David,
Thomas Deniau, 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...

et n'oublions pas bien sûr Steve Summit.

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://www.deja.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 à -hs- 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,

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ématiques. 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écéssaire 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 plates-formes, 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 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 à «-hs-», 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 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++.

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, il a pensé un système largement
indépendant du hardware. À l'époque les plates-formes é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 et Kernighan l'ont 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 plates-formes 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)1. 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 finallement été approuvé : le 14 décembre
1989, le standard ANSI X3.159-1989 (ou C89) est né. Il est publié au
printemps 1990.

Entretemps, 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 commence 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 est 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,

1. [(i)] que la révision (prévue dans les textes ISO) de 1995 ne se ferait
pas, et
2. 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 ou là :
http://home.flash.net/~dtribble/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 (septembre 2000), C99, qui est équivalent à C2k, n'est
pas encore totalement supporté 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 corriges 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 3.10).

Il existe aussi :
Engeln-Müllges G. & Uhlig F. (1996), Numerical Algorithms with C, Springer,
Berlin.
(fourni avec les sources et djgpp, pour plate-formes 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://videoc.lip6.fr/

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.dinkum.com/htm_cl/

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 et
ftp://ftp.laas.fr/pub/ii/matthieu/cvs.ps.gz comment utiliser CVS.

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 ?

Là : ftp://ftp.lip6.fr/pub/linux/french/docs/,
dans l'archive man-fr-x.x où x.x est le numéro de version (actuellement 0.8,
bientôt 0.9).

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 à pascal.cabaud@wanadoo.fr)

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 MacOS, MPW combiné avec le terrible MacsBug vous donneront entière
satisfaction.

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.tu-chemnitz.de/ sho/rho/rhide-1.4/rhide.html). 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).

(voir aussi 4.2).

4.2 Compilateurs

Le choix dépend du système d'exploitation et du processeur cible.

Apple

Pour machines sous MacOS, le compilateur d'Apple est gratuit, il est là :
ftp://ftp.apple.com/devworld/Tool_Chest/Core_Mac_OS_Tools/MPW_etc./. On sera
en mesure de vous dire quoi installer sur MacOS X beta sur
news:fr.comp.sys.mac.programmation.

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://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/.

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 Bibliothèques

Graphisme

Apple

Pour MacOS (classique), il vous faut récupérer QuickDraw, fournie par Apple
:
http://devworld.apple.com/macos/quickdraw.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

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.

Voir aussi :

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 plates-formes à
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 Multi-Precision et 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, Masson, Paris.
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 à pascal.cabaud@wanadoo.fr).

4.5 Outils divers

Notez que la majorité des outils cités ici ont initialement été écrits pour
des plates-formes Unix. Il existe assez souvent des portages sur d'autres
OSes, 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://cplus.about.com/compute/cplus/msublint.htm. On trouve LCLint là :
ftp://larch.lcs.mit.edu/pub/Larch/lclint/.

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 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
LATEX 2e, HTML et nroff et se trouve ici :
http://www.stack.nl/~dimitri/doxygen/.

Voir aussi 4.6.

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).

4.6 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 prinicpal du projet GNU est ftp://prep.ai.mit.edu/.

Voir aussi 4.5 et 4.4.
(informations bienvenues a pascal.cabaud@wanadoo.fr)

====================================================
From - Sat Mar 10 00:13:37 2001
Path: nnrp3.proxad.net!feeder2.proxad.net!proxad.net!fr.usenet-edu.net!usenet-edu.net!freenix!fr-chartes!maintfaq
From: Guillaume Rumeau <guillaume.rumeau@wanadoo.fr>
Newsgroups: fr.comp.lang.c,fr.usenet.reponses
Subject: [FAQ] fr.comp.lang.c - partie 1/3
Supersedes: <fr.comp.lang.faq-c-1-981002595.861472@ns2.freenix.org>
Followup-To: fr.comp.lang.c
Date: Fri, 16 Feb 2001 04:43:16 GMT
Organization: FCLC
Approved: fr-reponses@frmug.org
Expires: Mon, 5 Mar 2001 04:43:16 GMT
Message-ID: <fr.comp.lang.faq-c-1-982298596.169801@ns2.freenix.org>
Mime-Version: 1.0
Content-Type: text/plain; charset=iso-8859-15
Content-Transfer-Encoding: 8bit
Summary: Faq de fr.comp.lang.c
X-No-Productlink: yes
Lines: 1105
Xref: feeder2.proxad.net fr.comp.lang.c:21765 fr.usenet.reponses:9487

Archive-Name: fr/comp/lang/faq-c-1

précédant | suivant | sommaire