C (langage de programmation)

C

The C Programming Language (aka "K & R"), le livre fondamental sur C
Paradigm (s)	Imp??ratif ( proc??durale), structur??
Paru dans	1972
Con??u par	Dennis Ritchie
Promoteur	Dennis Ritchie & Les Bell Labs (cr??ateurs); ANSI X3J11 ( ANSI C); ISO / IEC JTC1 / SC22 / GT14 (ISO C)
Version stable	C11 (D??cembre 2011)
Typing discipline	Statique, faible, manifeste, nominal
Les grandes impl??mentations	Clang, GCC, Intel C, MSVC, Pelles C, Watcom C
Dialectes	Cyclone, Unified Parallel C, Split-C, Cilk, C *
Influenc?? par	B ( BCPL, CPL), Algol 68, Assembl??e, PL / I, FORTRAN
Influenc??	De nombreux: AMPL, AWK, CSH, C ++ , C--, C #, Objective-C, BitC, D, Go, Java , JavaScript Limbo, LPC, Perl , PHP, Pike, Traitement, Seed7
OS	Croix-plate-forme (multi-plateforme)
Habituel les extensions de fichier	.c .h
C Programmation ?? Wikibooks

En informatique, C ( / s Je /, Comme dans la lettre C) est un usage g??n??ral langage de programmation initialement d??velopp?? par Dennis Ritchie entre 1969 et 1973, ?? AT & T Bell Labs. Comme la plupart langues imp??rieuses Tradition ALGOL, C dispose d'installations pour et permet la programmation structur??e port??e variable lexicale et r??cursion, tandis qu'un syst??me de type statique emp??che de nombreuses op??rations non d??sir??es. Sa conception offre constructions qui correspondent efficacement aux typique instructions machine, et l'utilisation durable qu'il a donc trouv?? dans les applications qui avaient ??t?? pr??c??demment cod??es dans langage d'assemblage, notamment logiciel de syst??me comme Unix ordinateur syst??me d'exploitation.

C est une des langues les plus largement utilis??s de programmation de tous les temps et les compilateurs C sont disponibles pour la majorit?? des disponibles architectures informatiques et syst??mes d'exploitation.

Beaucoup de langues ult??rieures ont emprunt?? directement ou indirectement de C, y compris C #, D, Go, Java , JavaScript Limbo, LPC, Perl , PHP, Python , et Unix de C shell. L'influence la plus r??pandue sur ces langues (hors Python) a ??t?? syntaxique, et ils ont tendance ?? combiner l'expression reconnaissable et d??claration syntaxe de C avec des syst??mes de type sous-jacents, des mod??les de donn??es s??mantiques et qui peuvent ??tre radicalement diff??rente. C ++ commenc?? comme un pr??processeur de C et est actuellement pr??s d'un sur-ensemble de C.

Avant il y avait une norme officielle C, de nombreux utilisateurs et d??veloppeurs se appuyaient sur une sp??cification informelle contenues dans un livre de Dennis Ritchie et Brian Kernighan; cette version est g??n??ralement d??nomm??e "K & R" C. En 1989, le American National Standards Institute a publi?? une norme C (g??n??ralement appel??e " ANSI C "ou" C89 "). L'ann??e suivante, la m??me sp??cification a ??t?? approuv?? par le Organisation internationale de normalisation comme norme internationale (g??n??ralement appel?? "C90"). ISO lib??r?? plus tard une extension de la support de l'internationalisation de la norme en 1995, et une norme r??vis??e (connu sous le nom " C99 ") en 1999. La version actuelle de la norme (maintenant connu sous le nom" C11 ") a ??t?? approuv?? en D??cembre 2011.

Conception

C est un Imp??ratif ( proc??durale) langue. Il a ??t?? con??u pour ??tre compil?? en utilisant une relativement simple compilateur, de fournir de bas niveau acc??s ?? la m??moire, de fournir des ??l??ments de langage qui correspondent efficacement aux instructions de la machine, et d'exiger un minimum run-time support. C est donc utile pour de nombreuses applications qui avait autrefois ??t?? cod??es dans langage d'assemblage, comme dans la programmation du syst??me.

Malgr?? ses capacit??s de bas niveau, la langue a ??t?? con??u pour encourager programmation multiplate-forme. A conforme aux normes et programme portably ??crite de C peut ??tre compil?? pour une tr??s grande vari??t?? de plates-formes informatiques et syst??mes d'exploitation avec quelques modifications ?? son code source. La langue est devenue disponible sur une tr??s large gamme de plates-formes, ?? partir embarqu?? microcontr??leurs ?? superordinateurs.

Caract??ristiques

Comme la plupart des langages imp??ratifs dans le Tradition ALGOL, C dispose d'installations pour et permet la programmation structur??e port??e variable lexicale et r??cursion, tandis qu'un statique syst??me de type emp??che de nombreuses op??rations non d??sir??es. En C, tout le code ex??cutable est contenu dans sous-programmes, qui sont appel??s ??fonctions?? (mais pas dans le sens strict du programmation fonctionnelle). Fonction param??tres sont toujours pass??s par valeur. Passez par r??f??rence est simul?? dans C en passant explicitement valeurs de pointeur. Texte source du programme C est format libre, en utilisant le virgule comme un d??claration terminateur et accolades pour regrouper les blocs d'instructions.

Le langage C pr??sente ??galement les caract??ristiques suivantes:

• Il ya un petit nombre fixe de mots-cl??s, y compris un ensemble complet de flux de primitives de contr??le: for , if/else , while , switch , et do/while . Il existe une espace de noms et noms d??finis par l'utilisateur ne sont pas distingu??s des mots-cl??s par tout type de Sigil.
• Il existe un grand nombre d'op??rateurs arithm??tiques et logiques, tels que + , += , ++ , & , ~ , etc.
• Plus d'un affectation peut ??tre effectu??e en une seule d??claration.
• valeurs de retour de fonction peuvent ??tre ignor??s lorsqu'ils ne sont pas n??cessaires.
• La frappe est statique, mais mal appliqu??e: toutes les donn??es a un type, mais les conversions implicites peut ??tre effectu??e; par exemple, les caract??res peuvent ??tre utilis??s comme des entiers.
• D??claration syntaxe imite contexte d'utilisation. C n'a pas de mot-cl?? ??d??finir??; ?? la place, une mention commen??ant par le nom d'un type est pris comme une d??claration. Il n'y a pas "fonction" mot-cl??; ?? la place, une fonction est indiqu??e par les parenth??ses d'une liste d'arguments.
• D??finis par l'utilisateur ( typedef types) et compos??s sont possibles.
  • Types de donn??es agr??g??es (h??t??rog??nes struct ) permettent ??l??ments de donn??es connexes soient accessibles et affect??s comme une unit??.
  • indexation Array est une notion secondaire, d??fini en termes de pointeur arithm??tique. Contrairement structs, les tableaux ne sont pas des objets de premi??re classe; ils ne peuvent pas ??tre c??d??s ou compar??s en utilisant op??rateurs int??gr??s simples. Il n'y a pas mot-cl?? "du tableau", en cours d'utilisation ou la d??finition; ?? la place, les crochets indiquent les tableaux, par exemple syntaxiquement month[11] .
  • Les types ??num??r??s sont possibles avec l' enum mot-cl??. Ils ne sont pas ??tiquet??s, et sont librement interconvertibles avec des nombres entiers.
  • Les cha??nes ne sont pas un type de donn??es s??par??e, mais sont classiquement mis en oeuvre en tant que tableaux ?? z??ro terminal de caract??res.
• L'acc??s de bas niveau pour m??moire d'ordinateur est possible en convertissant les adresses de la machine ?? typ?? pointeurs.
• Proc??dures (sous-routines pas les valeurs de retour) sont un cas particulier de la fonction, avec un type de retour non typ??e void .
• Les fonctions ne peuvent ??tre d??finis dans la port??e lexicale d'autres fonctions.
• Fonction et donn??es pointeurs permettent ad hoc run-time polymorphisme.
• Un effectue de pr??processeur d??finition de macro, code source inclusion de fichier, et compilation conditionnelle.
• Il ya une forme de base de Modularit??: les fichiers peuvent ??tre compil??s s??par??ment et reli??s entre eux, avec contr??le sur les fonctions et les donn??es objets sont visibles ?? d'autres fichiers via static et extern attributs.
• Fonctionnalit??s complexes telles que E / S, manipulation de cha??ne, et math??matiques fonctions sont toujours d??l??gu??es ?? routines biblioth??que.

C ne comprend pas certaines fonctionnalit??s trouv?? dans les nouvelles langues les plus modernes, de haut niveau, y compris l'orientation objet et la collecte des ordures.

Histoire

Les premiers d??veloppements

Ken Thompson et Dennis Ritchie, les d??veloppeurs du langage de programmation C.

Le d??veloppement initial de C se est produite ?? AT & T Bell Labs entre 1969 et 1973; selon Ritchie, la p??riode la plus cr??ative se est produite en 1972. Il a ??t?? nomm?? ??C?? parce que ses caract??ristiques ont ??t?? obtenues ?? partir d'une langue t??t appel?? " B ", qui, selon Ken Thompson ??tait une version all??g??e de la Langage de programmation BCPL.

L'origine de C est ??troitement li??e au d??veloppement de l' Unix syst??me d'exploitation, ?? l'origine mis en ??uvre en langage d'assemblage sur un PDP-7 par Ritchie et Thompson, incorporant plusieurs id??es de ses coll??gues. Finalement, ils ont d??cid?? de porter le syst??me d'exploitation ?? un PDP-11. L'incapacit?? de B pour profiter de certaines fonctionnalit??s du PDP-11, notamment octet d'adressage, a conduit au d??veloppement d'une premi??re version de C.

La version originale PDP-11 du syst??me Unix a ??t?? d??velopp?? en langage d'assemblage. En 1973, avec l'ajout de struct types, le langage C ??tait devenu assez puissant que la plupart des Unix noyau a ??t?? r????crit en C Ce ??tait l'un des premiers noyaux du syst??me d'exploitation mis en ??uvre dans une langue autre que l'assemblage. (Cas ant??rieures comprennent le Syst??me Multics (??crit en PL / I), et MCP ( Master Control Program) pour la Burroughs B5000 r??dig?? en ALGOL en 1961.) Circa 1977, d'autres changements ?? la langue ont ??t?? faites par Ritchie et Stephen C. Johnson pour faciliter la portabilit?? du syst??me d'exploitation Unix. Johnson Portable C Compiler a servi de base pour plusieurs impl??mentations de C sur de nouvelles plateformes.

K & R C

En 1978, Brian Kernighan et Dennis Ritchie a publi?? la premi??re ??dition du The C Programming Language. Ce livre, connu pour les programmeurs C comme "K & R", a servi pendant de nombreuses ann??es comme informelle indication de la langue. La version de C qu'il d??crit est commun??ment appel?? K & R C. La deuxi??me ??dition de l'ouvrage couvre le tard Norme ANSI C.

K & R introduit plusieurs fonctionnalit??s de langage:

• biblioth??que standard I / O
• long int type de donn??es
• unsigned int type de donn??es
• op??rateurs d'affectation compos?? de la forme = op (comme =- ) ont ??t?? modifi??s pour la forme op = de lever l'ambigu??t?? s??mantique cr???? par des concepts comme les i=-10 , qui avait ??t?? interpr??t?? comme i =- 10 (diminution i par 10 ) au lieu du ??ventuellement destin?? i = -10 (soit i -10)

M??me apr??s la publication de la norme C 1989, pendant de nombreuses ann??es K & R C a ??t?? toujours consid??r?? comme le ??plus petit d??nominateur commun" ?? laquelle les programmeurs C se sont limit??s quand une portabilit?? maximale a ??t?? souhait??, puisque de nombreux compilateurs plus anciens ??taient encore en usage, et parce que soigneusement ??crit K & R code C peut ??tre l??gal standard C ainsi.

Dans les premi??res versions de C, seules les fonctions qui ont renvoy?? un non int valeur n??cessaire pour ??tre d??clar?? se il est utilis?? avant la d??finition de la fonction; une fonction utilis??e sans d??claration pr??c??dente a suppos?? renvoyer un type int , si sa valeur a ??t?? utilis??e.

Par exemple:

 ?? long une_fonction ();
 / * Int * / other_function ();
 
 / * Int * / calling_function ()
 {
     ?? long test1;
     inscrire / int * * / test2;
 
     test1 = une_fonction ();
     if (test1> 0)
           test2 = 0;
     autre
           test2 = other_function ();
     retourner test2;
 }

Les int sp??cificateurs de type qui sont comment??s sur pouvaient ??tre omis dans K & R C, mais sont tenus dans les normes ult??rieures.

Depuis K & R d??clarations de fonctions ne comprennent pas toutes les informations sur les arguments de fonction, param??tre de fonction contr??les de type ne ont pas ??t?? effectu??es, bien que certains compilateurs seraient d??livrer un message d'avertissement si une fonction locale a ??t?? appel??e avec le mauvais nombre d'arguments, ou si plusieurs appels ?? une fonction externe utilis?? diff??rents num??ros ou types d'arguments. Outils distincts tels que Unix de utilitaire de peluches ont ??t?? d??velopp??s que (entre autres choses) pourrait v??rifier la coh??rence de l'utilisation de la fonction sur plusieurs fichiers sources.

Dans les ann??es suivant la publication de K & R C, plusieurs caract??ristiques non officielles ont ??t?? ajout??s ?? la langue, soutenu par les compilateurs d'AT & T et d'autres vendeurs. Notamment:

• void fonctions (c.-fonctions avec aucune valeur de retour)
• fonctions de retour struct ou union types (plut??t que des pointeurs)
• affectation pour struct types de donn??es
• types ??num??r??s

Le grand nombre d'extensions et de l'absence d'accord sur un biblioth??que standard, avec la popularit?? de la langue et le fait que m??me la compilateurs Unix pr??cis??ment mis en ??uvre la sp??cification K & R, a conduit ?? la n??cessit?? de la normalisation.

C ANSI et ISO C

?? la fin des ann??es 1970 et 1980, les versions de C ont ??t?? mises en ??uvre pour une grande vari??t?? de ordinateurs centraux, mini-ordinateurs, et micro-ordinateurs, y compris la IBM PC, que sa popularit?? a commenc?? ?? augmenter de mani??re significative.

En 1983, le American National Standards Institute (ANSI) a form?? un comit??, X3J11, d'??tablir une sp??cification standard de C. X3J11 bas??e la norme C sur l'application Unix; cependant, la partie non portable de la biblioth??que Unix C a ??t?? transf??r?? au IEEE groupe de travail 1003 pour devenir la base de la 1988 Standard POSIX. En 1989, la norme a ??t?? ratifi??e C ANSI X3.159-1989 "langage de programmation C". Cette version de la langue est souvent appel??e ANSI C, standard C, ou parfois C89.

En 1990, la norme ANSI C (avec des modifications de mise en forme) a ??t?? adopt?? par le Organisation internationale de normalisation (ISO) ISO / IEC 9899: 1990, qui est parfois appel?? C90. Par cons??quent, les termes "C89" et "C90" se r??f??rent au m??me langage de programmation.

ANSI, comme d'autres organismes nationaux de normalisation, ne d??veloppe plus la norme C ind??pendamment, mais se en remet ?? la norme internationale C, maintenu par le groupe de travail ISO / IEC JTC1 / SC22 / GT14. L'adoption nationale d'une mise ?? jour de la norme internationale se produit g??n??ralement dans l'ann??e de publication de l'ISO.

L'un des objectifs du processus de normalisation de C ??tait de produire un sur-ensemble de K & R C, int??grant de nombreuses fonctionnalit??s non officiels introduits ult??rieurement. Le comit?? des normes comprenait ??galement plusieurs fonctionnalit??s suppl??mentaires telles que prototypes de fonction (emprunt?? ?? C ++), void pointeurs, le soutien pour l'international jeux de caract??res et locales et les am??liorations de pr??processeur. Bien que le syntaxe de d??clarations de param??tres a ??t?? augment?? pour inclure le style utilis?? en C ++, le K & R interface continu?? ?? ??tre autoris??e, pour la compatibilit?? avec le code source existant.

C89 est pris en charge par les compilateurs actuels C, et la plupart du code C ??crit aujourd'hui est sur cette base. Tout programme ??crit que dans la norme C et sans hypoth??ses d??pendantes du mat??riel sera de fonctionner correctement sur ne importe quel plate-forme de mise en oeuvre avec un C conforme, dans ses limites de ressources. Sans cette pr??caution, les programmes peuvent compiler seulement sur une certaine plate-forme ou ?? un compilateur particulier, en raison, par exemple, ?? l'utilisation de biblioth??ques non standard, telles que Biblioth??ques GUI, ou ?? une d??pendance ?? l'??gard des attributs sp??cifiques plateforme compiler- ou comme la taille exacte de types de donn??es et octets boutisme.

Dans les cas o?? le code doit ??tre compilable soit par des compilateurs standards conformes ou base-C K & R, le __STDC__ macro peut ??tre utilis?? pour diviser le code en sections standard et K & R pour emp??cher l'utilisation sur un compilateur des fonctionnalit??s disponibles uniquement en base-C K & R Norme C.

C99

Apr??s le processus de normalisation ANSI / ISO, la sp??cification du langage C est rest?? relativement stable depuis plusieurs ann??es. En 1995 normative Amendement 1 ?? la norme C 1990 (ISO / IEC 9899 / AMD1: 1995, connu officieusement comme C95) a ??t?? publi??, pour corriger certains d??tails et ajouter le support plus ??tendu pour les jeux de caract??res internationaux. Le standard C a ??t?? r??vis?? ?? la fin des ann??es 1990, conduisant ?? la publication de la norme ISO / IEC 9899: 1999 en 1999, ce qui est commun??ment appel?? " C99 ". Il a depuis ??t?? modifi??e ?? trois reprises par Rectificatifs techniques.

C99 introduit plusieurs nouvelles fonctionnalit??s, y compris fonctions inline, plusieurs nouveaux types de donn??es (y compris les long long int et un complex de type pour repr??senter des nombres complexes ), tableaux de longueur variable, un meilleur support IEEE 754 virgule flottante, pour soutenir macros variadic (macros de variables arit??), et le soutien ?? une commentaires en ligne commen??ant par // , comme dans BCPL ou C ++. Beaucoup d'entre eux avaient d??j?? ??t?? mises en ??uvre comme des extensions dans plusieurs compilateurs C.

C99 est en grande partie compatible avec C90, mais est plus stricte ?? certains ??gards; en particulier, une d??claration qui n'a pas de sp??cificateur de type ne est plus a int implicitement suppos??. Une macro standard __STDC_VERSION__ est d??fini avec la valeur 199901L pour indiquer que le soutien C99 est disponible. GCC, Solaris Studio et d'autres compilateurs C prennent d??sormais en charge un grand nombre ou la totalit?? des nouvelles fonctionnalit??s de C99.

C11

En 2007, les travaux ont commenc?? sur une autre r??vision de la norme C, officieusement appel?? "C1X" jusqu'?? sa publication officielle sur 2011-12-08. Le comit?? des normes C a adopt?? des directives pour limiter l'adoption de nouvelles fonctionnalit??s qui ne avaient pas ??t?? test??s par les impl??mentations existantes.

La norme C11 ajoute de nombreuses nouvelles fonctionnalit??s ?? C et la biblioth??que, y compris les macros g??n??riques de type, structures anonymes, une meilleure prise en charge Unicode, les op??rations atomiques, multi-threading et fonctions par ses limites. Il rend ??galement certaines parties de la biblioth??que de C99 existant optionnel, et am??liore la compatibilit?? avec C ++.

Embedded C

Historiquement, la programmation C embarqu?? n??cessite une extension non standard ?? la langue de C afin de soutenir caract??ristiques exotiques tels que arithm??tique en virgule fixe, plusieurs banques de m??moire distincts, et les op??rations de base d'E / S.

En 2008, le Comit?? des normes C a publi?? un rapport technique ??tendant le langage C pour r??soudre ces probl??mes en fournissant une norme commune pour toutes les impl??mentations ?? respecter. Il comprend un certain nombre de fonctionnalit??s non disponibles dans normale C, comme arithm??tique en virgule fixe, espaces d'adressage nomm??s et base mat??rielle adressage E / S.

Syntaxe

C a un grammaire formelle sp??cifi?? par la norme C. Contrairement aux langages tels que FORTRAN 77, code source C est de forme libre qui permet l'utilisation arbitraire des espaces pour formater code, plut??t que des restrictions fond??es texte en ligne en colonnes ou. Les commentaires peuvent appara??tre soit entre le s??parateurs /* et */ , ou (depuis C99) ?? la suite // jusqu'?? la fin de la ligne. Commentaires d??limit?? par /* et */ ne pas nid, et ces s??quences de caract??res ne sont pas interpr??t??s comme des s??parateurs de commentaires se ils apparaissent ?? l'int??rieur cha??nes ou de caract??res litt??raux.

Fichiers source C contiennent des d??clarations et des d??finitions de fonctions. Les d??finitions de fonctions, ?? son tour, contiennent des d??clarations et d??clarations. D??clarations soit d??finir de nouveaux types utilisant des mots cl??s tels que struct , union et enum ou attribuer des types de stockage et peut-??tre de r??serve pour les nouvelles variables, g??n??ralement par ??crit le type suivi par le nom de la variable. Mots-cl??s tels que char et int pr??cisez les types internes. Sections de code sont plac??es entre accolades ( { et } , parfois appel??s ??accolades??) pour limiter la port??e des d??clarations et d'agir comme une seule d??claration pour les structures de contr??le.

Comme un langage imp??ratif, C utilise des instructions pour sp??cifier actions. La d??claration la plus commune est une d??claration d'expression, consistant en une expression ?? ??valuer, suivie par un point-virgule; comme un effet secondaire de l'??valuation, les fonctions peuvent ??tre appel??s et les variables peuvent ??tre nouvelles valeurs attribu??es. Pour modifier l'ex??cution s??quentielle normale des ??tats, C fournit plusieurs d??clarations de flux de contr??le identifi??es par des mots cl??s r??serv??s. Programmation structur??e est soutenu par if (- else ) l'ex??cution conditionnelle et en do - while , while , et for l'ex??cution it??rative (en boucle). Le for d??claration a initialisation s??par??e, les tests et les expressions de r??initialisation, tout ou partie de ce qui peut ??tre omis. break et continue peut ??tre utilis?? pour quitter le instruction de boucle englobante la plus profonde ou sauter ?? sa r??initialisation. Il existe ??galement un non-structur??e goto d??claration qui branches directement au d??sign??e ??tiqueter dans la fonction. switch s??lectionne un case doit ??tre ex??cut?? sur la base de la valeur d'une expression enti??re.

Les expressions peuvent utiliser une vari??t?? d'op??rateurs int??gr??s et peuvent contenir des appels de fonction. L'ordre dans lequel les arguments des fonctions et des op??randes ?? la plupart des op??rateurs sont ??valu??s ne est pas sp??cifi??. Les ??valuations peuvent m??me ??tre entrelac??s. Cependant, tous les effets secondaires (y compris le stockage de variables) se produira avant la prochaine " point de s??quence "; points de s??quence inclut la fin de chaque instruction d'expression, et l'entr??e et retour de chaque appel de fonction points de s??quence se produisent ??galement lors de l'??valuation des expressions contenant certains op??rateurs (. && , || , ?: et le op??rateur virgule). Cela permet un degr?? ??lev?? de l'optimisation de code objet par le compilateur, mais n??cessite programmeurs C de prendre plus de soin pour obtenir des r??sultats fiables que est n??cessaire pour d'autres langages de programmation.

Kernighan et Ritchie-dire dans l'introduction de The C Programming Language: "C, comme ne importe quelle autre langue, a ses imperfections Certains op??rateurs ont la mauvaise priorit??; certaines parties de la syntaxe pourrait ??tre mieux.". La norme C n'a pas tent?? de corriger un grand nombre de ces imperfections, en raison de l'impact de ces changements sur les logiciels d??j?? existants.

Jeu de caract??res

L'ensemble de base C de caract??res source comprend les caract??res suivants:

• Lettres: a - z , A - Z , _
• Chiffres: 0 - 9
• Ponctuation: ~ ! @ # % ^ & * ( ) - + = : ; " ' < > , . ? | / \ { } [ ] ~! @ #% ^ & * () - + =:; " ' < > , . ? | / \ { } [ ]
• Les caract??res blancs: espace, tabulation horizontale, onglet vertical, saut, nouvelle ligne

Saut de ligne indiquant la fin d'une ligne de texte; il ne doit pas correspondre ?? un caract??re unique r??elle, bien que pour la commodit?? C traite comme une.

Caract??res multi-octets cod?? suppl??mentaires peuvent ??tre utilis??s, mais ne sont pas portable. La derni??re norme C ( C11) permet multinational Les caract??res Unicode ?? ??tre int??gr??s dans les portably C texte source en utilisant un \u DDDD encodage (o?? DDDD d??signe un code de caract??re Unicode), bien que cette fonctionnalit?? ne est pas encore largement appliqu??.

L'ensemble de base C de caract??res d'ex??cution contient les m??mes caract??res, avec des repr??sentations pour alerte, backspace, et retour chariot. Soutien Run-time pour les jeux de caract??res ??tendus a augment?? avec chaque r??vision de la norme C.

Mots-cl??s

C89 dispose de 32 mots-cl??s (mots r??serv??s ayant une signification particuli??re):

C99 ajoute cinq autres mots-cl??s:

C11 ajoute sept autres mots-cl??s:

La plupart des mots-cl??s ajout??s r??cemment commencent par un tiret suivi d'une lettre majuscule, parce identificateurs de cette forme ont d??j?? ??t?? r??serv??s par la norme C pour une utilisation uniquement par les impl??mentations. Depuis code source de programme existant ne aurait pas d?? utiliser ces identifiants, il ne serait pas affect??e lorsque les impl??mentations C a commenc?? ?? soutenir ces extensions du langage de programmation. Certaines t??tes standard ne d??finissent synonymes plus pratiques pour les identificateurs soulign??s. La langue utilis??e pour inclure un mot-cl?? r??serv?? appel?? entry , mais cela n'a jamais ??t?? mis en ??uvre et a ??t?? enlev?? comme un mot r??serv??.

Op??rateurs

C prend en charge un ensemble riche de op??rateurs, qui sont des symboles utilis??s dans un expression pour sp??cifier les manipulations ?? effectuer tout en ??valuant cette expression. C a pour les op??rateurs:

• arithm??tique : + , - , * , / , %
• affectation: =
• affectation augment??e: += , -= , *= , /= , %= , &= , |= , ^= , <<= , >>=
• bit logique: ~ , & , | , ^
• les changements au niveau du bit: << , >>
• la logique bool??enne: ! , && , ||
• l'??valuation conditionnelle: ? :
• test de l'??galit??: == , !=
• appel de fonctions: ( )
• augmenter ou diminuer: ++ , --
• la s??lection des membres: . , ->
• taille de l'objet: taille de
• relations d'ordre: < , <= , > , >=
• r??f??rence et d??r??f??rencer: & , * , [ ]
• s??quen??age: ,
• sous-expression groupement: ( )
• Type de conversion: ( typename )

C utilise le = op??rateur, r??serv??e en math??matiques pour exprimer l'??galit??, pour indiquer l'affectation, apr??s le pr??c??dent de Fortran et PL / I, mais ?? la diff??rence ALGOL et ses d??riv??s. La similitude entre l'op??rateur de C pour l'affectation et que pour l'??galit?? ( == ) a ??t?? critiqu??e comme il est facile de remplacer accidentellement un pour l'autre. Dans de nombreux cas, chacun d'eux peut ??tre utilis?? dans le contexte de l'autre sans erreur de compilation (bien que certains compilateurs produisent avertissements). Par exemple, l'expression conditionnelle dans if(a=b+1) est vrai si a ne est pas nul, apr??s l'affectation. En outre, de C la priorit?? des op??rateurs est non-intuitive, comme == liaison plus ??troitement que & et | dans des expressions comme x & 1 == 0 , qui auraient besoin d'??tre ??crite (x & 1) == 0 ??tre correctement ??valu??s.

"Bonjour, monde?? par exemple

Le " bonjour, monde "par exemple, qui a paru dans la premi??re ??dition du K & R, est devenu le mod??le pour un programme d'introduction dans la plupart des manuels de programmation, ind??pendamment du langage de programmation. Les gravures de programme "Bonjour, monde" ?? la sortie standard, qui est habituellement un affichage du terminal ou de l'??cran.

La version originale ??tait:

 main ()
 {
     printf ("bonjour, world \ n");
 }

A conforme ?? la norme "bonjour, monde" programme est:

 #include 
 
 int main (void)
 {
     printf ("bonjour, world \ n");
 }

La premi??re ligne du programme contient un directive pr??traitement, indiqu?? par #include . Cela provoque le compilateur pour remplacer cette ligne avec l'ensemble du texte de la stdio.h t??te standard, qui contient des d??clarations pour les fonctions d'entr??e et de sortie standard telles que printf . Les crochets entourant stdio.h indiquent que stdio.h se trouve en utilisant une strat??gie de recherche qui pr??f??re t??tes standard vers d'autres t??tes ayant le m??me nom. (Les guillemets doubles sont utilis??es pour inclure des fichiers d'en-t??te locaux ou sp??cifiques au projet.)

La ligne suivante indique qu'une fonction nomm??e main est d??finie. Le main fonction sert un but particulier dans les programmes C; l'environnement d'ex??cution appelle la main fonction de commencer l'ex??cution du programme. Le sp??cificateur de type int indique que la valeur qui est retourn?? ?? l'invocateur (dans ce cas l'environnement d'ex??cution) ?? la suite de l'??valuation de la main fonction, est un entier. Le mot-cl?? void comme une liste de param??tre indique que cette fonction ne prend aucun argument.

L'accolade d'ouverture indique le d??but de la d??finition de la main fonction.

La ligne suivante appelle (d??tourne l'ex??cution ??) une fonction nomm??e printf , qui est aliment?? ?? partir d'un syst??me biblioth??que. Dans cet appel, le printf fonction est adopt?? (fourni avec) un seul argument, l'adresse du premier caract??re de la cha??ne litt??rale "hello, world\n" . La cha??ne litt??rale est une sans nom tableau avec des ??l??ments de type char , mis en place automatiquement par le compilateur avec un caract??re final 0-valeur pour marquer la fin du tableau ( printf besoin de savoir cela). La \n est une s??quence d'??chappement qui se traduit par un C caract??re de nouvelle ligne, qui sur la production signifie la fin de la ligne actuelle. La valeur de retour de la printf fonction est de type int , mais il est ??limin?? en silence, car il ne est pas utilis??. (Un programme plus prudent pourrait tester la valeur de retour pour d??terminer si oui ou non l' printf fonction a r??ussi.) Le point-virgule ; met fin ?? la d??claration.

L'accolade fermante indique la fin du code de la main fonction. Conform??ment ?? la sp??cification C99 et plus r??cent, main implicitement retourner un ??tat 0 en atteignant le} qui termine la fonction. Ceci est interpr??t?? par le syst??me d'ex??cution comme un code de sortie indiquant une ex??cution r??ussie.

Les types de donn??es

C a un statique typage faible Type syst??me qui partage certaines similitudes avec celui des autres ALGOL descendants tels que Pascal. Il ya des types int??gr??s pour entiers de diff??rentes tailles, tous deux sign??s et non sign??s, nombres ?? virgule flottante, les caract??res et les types ??num??r??s ( enum ). C99 a ajout?? une de type bool??en. Il ya aussi des types d??riv??s, y compris tableaux, pointeurs, (dossiers struct ), et non balis?? syndicats ( union ).

C est souvent utilis??e dans la programmation des syst??mes de bas niveau o?? se ??chappe du syst??me de type peut ??tre n??cessaire. Le compilateur tente d'assurer l'exactitude de type de la plupart des expressions, mais le programmeur peut remplacer les contr??les de diverses mani??res, soit en utilisant un tapez jet?? pour convertir explicitement une valeur d'un type ?? l'autre, ou en utilisant des pointeurs ou des syndicats de r??interpr??ter les bits sous-jacentes d'un objet de donn??es d'une autre mani??re.

Certains trouvent la syntaxe de d??claration de C intuitif, en particulier pour des pointeurs de fonction. (L'id??e de Ritchie devait d??clarer identificateurs dans des contextes ressemblant ?? leur utilisation: " D??claration refl??te l'utilisation ".)

Conversions arithm??tiques usuelles de C permettent de code efficace ?? g??n??rer, mais peuvent parfois produire des r??sultats inattendus. Par exemple, une comparaison de nombres entiers non sign??s et sign??s de largeur ??gale n??cessite une conversion de la valeur sign??e de non sign??e. Cela peut g??n??rer des r??sultats inattendus si la valeur est n??gative sign??.

Pointeurs

C prend en charge l'utilisation de pointeurs, un type de r??f??rence qui enregistre l'adresse ou l'emplacement d'un objet ou une fonction en m??moire. Les pointeurs peuvent ??tre d??r??f??renc??s pour acc??der aux donn??es stock??es ?? l'adresse soulign??, ou d'invoquer un pointu pour fonctionner. Les pointeurs peuvent ??tre manipul??es en utilisant cession ou pointeur arithm??tique. La repr??sentation moment de l'ex??cution d'une valeur de pointeur est g??n??ralement une adresse m??moire brute (peut-??tre augment??e par un champ de d??calage-dans-mot), mais depuis un type de pointeur comprend le type de la chose a soulign??, expressions y compris des pointeurs peuvent ??tre de type v??rifi?? au moment de la compilation. Pointeur arithm??tique est automatiquement mis ?? l'??chelle par la taille de la pointe de-type de donn??es. Pointeurs sont utilis??s ?? de nombreuses fins diff??rentes en C. Les cha??nes de texte sont couramment manipul??es en utilisant des pointeurs dans des tableaux de caract??res. Allocation dynamique de m??moire est effectu??e en utilisant des pointeurs. De nombreux types de donn??es, tels que arbres, sont couramment mises en ??uvre allou??s dynamiquement struct objets li??s ensemble en utilisant des pointeurs. Pointeurs de fonctions sont utiles pour les fonctions passant comme arguments pour fonctions d'ordre sup??rieur (tel que qsort ou bsearch) ou rappels ?? ??tre invoqu??s par les gestionnaires d'??v??nements.

Un valeur de pointeur nul indique explicitement ?? aucun emplacement valide. D??r??f??rencement une valeur de pointeur NULL est undefined, ce qui entra??ne souvent une segmentation fault. Valeurs de pointeur NULL sont utiles pour indiquer des cas particuliers tels que pas de pointeur "suivant" dans le noeud final d'un liste li??e, ou comme une indication d'erreur ?? partir des fonctions de pointeurs de retour. Dans des contextes appropri??s dans le code source, comme pour affecter ?? une variable pointeur, une constante de pointeur NULL peut ??tre ??crite comme 0 , avec ou sans conversion explicite ?? un type de pointeur, ou comme NULL macro d??finie par plusieurs t??tes standard. Dans des contextes conditionnels, valeurs de pointeur NULL renvoient false, tandis que toutes les autres valeurs de pointeur ??valuer ?? true.

Pointeurs void ( void * ) indiquent aux objets de type non pr??cis??, et peuvent donc ??tre utilis??s comme pointeurs de donn??es ??g??n??riques??. Comme la taille et le type de l'arithm??tique de pointeur soulign?? ?? objet ne est pas connu, pointeurs void ne peuvent pas ??tre d??r??f??renc??s, et ne est en leur a permis, m??me si elles peuvent ??tre facilement (et dans de nombreux contextes implicitement sont) converti depuis et vers tout autre pointeur d'objet taper.

Utilisation n??gligente de pointeurs est potentiellement dangereux. Parce qu'ils sont g??n??ralement pas coch??e, une variable de pointeur peut ??tre faite pour pointer vers ne importe quel endroit arbitraire, ce qui peut provoquer des effets ind??sirables. Bien pointeurs correctement utilis??s pointent dans des endroits s??rs, ils peuvent ??tre faites pour pointer vers des endroits dangereux en utilisant invalide arithm??tique de pointeur; les objets qu'ils pointent vers peuvent ??tre d??sallou??es et r??utilis??s ( pointeurs fant??mes); ils peuvent ??tre utilis??s sans avoir ??t?? initialis?? ( pointeurs sauvages); ou ils peuvent ??tre directement attribu??s une valeur dangereuse en utilisant un pl??tre, syndicat, ou par un autre pointeur corrompu. En g??n??ral, C est permissive en permettant la manipulation et de conversion entre des types de pointeurs, bien compilateurs fournissent g??n??ralement des options pour les diff??rents niveaux de contr??le. Certains autres langages de programmation abordent ces probl??mes en utilisant plus restrictive types de r??f??rence.

Tableaux

types de tableau en C sont traditionnellement d'un fixe, la taille statique sp??cifi??e au moment de la compilation. (La r??cente norme C99 plus permet aussi une forme de tableaux de longueur variable). Cependant, il est ??galement possible d'allouer un bloc de m??moire (de taille arbitraire) au moment de l'ex??cution, ?? l'aide de la biblioth??que standard malloc la fonction, et le traiter comme un tableau. L'unification de C des tableaux et pointeurs moyens d??clar?? tableaux et ces tableaux simul??s allou??s dynamiquement sont pratiquement interchangeables.

Comme les tableaux sont toujours accessibles (en vigueur) par l'interm??diaire des pointeurs, les acc??s de tableau ne sont g??n??ralement pas v??rifi??es par rapport ?? la taille du tableau sous-jacent, bien que certains peuvent fournir des compilateurs v??rification des limites en option. Tableau d??limite violations sont donc possibles et assez commune dans le code avec d??sinvolture, et peuvent conduire ?? diverses r??percussions, y compris la m??moire acc??de ill??gale, la corruption des donn??es, d??passements de m??moire tampon, et les exceptions d'ex??cution. Si la v??rification des limites est souhait??, il doit ??tre fait manuellement.

C n'a pas une disposition sp??ciale pour la d??claration de tableaux multidimensionnels, mais se appuie plut??t sur la r??cursivit?? dans le syst??me de type de d??clarer des tableaux de tableaux, qui accomplit effectivement la m??me chose. Les valeurs de l'indice de la "tableau multidimensionnel" r??sultant peuvent ??tre consid??r??s comme de plus en plus rang??e importante commande.

Les tableaux multidimensionnels sont couramment utilis??s dans les algorithmes num??riques (principalement appliqu??e alg??bre lin??aire ) pour stocker des matrices. La structure de la matrice C est bien adapt?? ?? cette t??che particuli??re. Cependant, puisque les tableaux sont pass??s simplement comme des pointeurs, les limites du tableau doivent ??tre connus des valeurs fixes ou encore explicitement transmises ?? des sous-programme qui leur impose, et les tableaux de taille dynamique de tableaux ne peuvent pas ??tre accessible en utilisant le double indexation.(Une solution pour cela est d'allouer le tableau avec un "vecteur ligne" supplémentaire de pointeurs vers les colonnes.)

C99 introduit "tableaux de longueur variable» qui traitent de certains, mais pas tous, des problèmes avec les réseaux ordinaires de C.

Array-pointeur interchangeabilité

L' indice de notation x [i] (où X désigne un pointeur) est un sucre syntaxique pour * (X + i) . Profitant de la connaissance de la compilation du type de pointeur, l'adresse qui x + i pointe vers est pas l'adresse de base (pointé par X ) incrémenté par je octets, mais plutôt est défini comme étant l'adresse de base incrémenté par je multiplié par la taille d'un élément que X les points à.

En outre, dans la plupart des contextes d'expression (une exception notable est que des opérandes taille de ), le nom d'un tableau est automatiquement converti en un pointeur vers premier élément de la matrice; donc pour un tableau déclaré avec le nom UNE , A [i] désigne la i + 1 ^e élément du tableau. Cela implique également que jamais un tableau est copié dans son ensemble lorsqu'il a été nommé un argument à une fonction, mais seulement l'adresse de son premier élément est passé. Par conséquent, bien que les appels de fonction en C utilisation passent par valeur sémantique, les tableaux sont en effet passés par référence.

La taille d'un élément peut être déterminée en appliquant l'opérateur taille de de tout élément de dépointé X , comme dans n = sizeof * x , ou n = sizeof x [0] , et le nombre d'éléments dans un tableau déclaré UNE peut être déterminée comme sizeof A / sizeof A [0] . Ce dernier ne va aux noms de tableau: variables déclarées avec indices ( int A [20] ). En raison de la sémantique de C, il est impossible de déterminer la taille complète de tableaux par des pointeurs vers des tableaux ou ceux créés par l'allocation dynamique ( malloc ); code tel que sizeof arr / sizeof arr [0] (où arr = A désigne un pointeur) ne fonctionnera pas car le compilateur suppose la taille du pointeur est elle-même demandée. Depuis nom du tableau des arguments pour taille de sont pas convertis en pointeurs, ils ne présentent pas une telle ambiguïté. Cependant, les tableaux créés par allocation dynamique sont initialisés à des pointeurs plutôt que de véritables variables de tableau, de sorte qu'ils souffrent des mêmes taille de problèmes que les pointeurs de tableaux.

Ainsi, en dépit de cette apparente équivalence entre les variables de tableau et de pointeur, il ya encore une distinction à faire entre eux. Même si le nom d'un tableau est, dans la plupart des contextes d'expression, converti en un pointeur (à son premier élément), ce pointeur ne se occupe pas tout stockage; le nom du tableau est pas une lvalue, et son adresse est une constante , contrairement à une variable pointeur. Par conséquent, ce que un tableau "Points" ne peut pas être changé, et il est impossible d'attribuer une nouvelle adresse à un nom de tableau. contenu du tableau peut être copié, cependant, en utilisant la memcpy fonction, ou en accédant aux éléments individuels.

Gestion de la m??moire

Une des fonctions les plus importantes d'un langage de programmation est de fournir des installations de gestion de la mémoire et les objets qui sont stockés dans la mémoire. C fournit trois façons distinctes d'allouer de la mémoire pour les objets:

• Allocation de mémoire statique: l'espace de l'objet est fourni dans le binaire au moment de la compilation; ces objets ont une mesure (ou durée de vie) dans la mesure où le binaire qui les contient est chargé en mémoire.
• Attribution automatique de la mémoire: objets temporaires peuvent être stockés sur lapile, et cet espace est automatiquement libéré et réutilisable après le bloc dans lequel elles sont déclarées est sorti.
• Allocation dynamique de mémoire: des blocs de mémoire de taille arbitraire peuvent être demandés au moment de l'exécution en utilisant les fonctions de la bibliothèque tels que malloc d'une région de la mémoire appelé le tas; ces blocs persister jusqu'à la suite libérés pour réutilisation en appelant la fonction de bibliothèque realloc ou gratuit

Ces trois approches sont appropriés dans des situations différentes et ont différents compromis. Par exemple, l'allocation de mémoire statique a peu de frais généraux d'allocation, l'allocation automatique peut impliquer un peu plus les frais généraux, et l'allocation dynamique de la mémoire peut potentiellement avoir beaucoup de frais généraux pour les deux allocation et la libération. Le caractère persistant d'objets statiques est utile pour maintenir des informations d'état à travers des appels de fonction, affectation automatique est facile à utiliser, mais l'espace de pile est généralement beaucoup plus limitée et transitoire que soit la mémoire statique ou espace de tas, et l'allocation dynamique de la mémoire permet répartition pratique des objets dont la taille est connue seulement au moment de l'exécution. La plupart des programmes C font un usage intensif de tous les trois.

Où allocation possible, automatique ou statique est généralement plus simple parce que le stockage est géré par le compilateur, libérant le programmeur de la corvée potentiellement sujette aux erreurs d'allocation et la libération de stockage manuellement. Cependant, de nombreuses structures de données peuvent changer de taille à l'exécution, et depuis allocations statiques (et des allocations automatiques avant C99) doivent avoir une taille fixe au moment de la compilation, il ya beaucoup de situations dans lesquelles l'allocation dynamique est nécessaire. Avant la norme C99, tableaux taille variable étaient un exemple courant de cela. (Voir l'article sur malloc un exemple de tableaux alloués dynamiquement.) Contrairement à l'allocation automatique, qui peut échouer lors de l'exécution avec des conséquences incontrôlées, les fonctions d'allocation dynamique de retour une indication (sous la forme d'une valeur de pointeur nul) lorsque le stockage nécessaire ne peut pas allouer. (Allocation statique qui est trop grand est habituellement détectée par le linker ou chargeur, avant que le programme peut même commencer l'exécution.)

Sauf indication contraire, les objets statiques contiennent zéro ou nulles valeurs de pointeur sur le démarrage du programme. Objets attribués automatiquement et dynamiquement sont initialisées que si une valeur initiale est explicitement spécifié; sinon, ils ont d'abord des valeurs indéterminées (typiquement, quelle que soit motif de bits arrive à être présents dans le stockage, ce qui pourrait ne pas représenter encore une valeur valide pour ce type). Si le programme tente d'accéder à une valeur non initialisée, les résultats sont indéfinis. Beaucoup de compilateurs modernes tentent de détecter et avertir de ce problème, mais les deux faux positifs et des faux négatifs peuvent survenir.

Un autre problème est que l'allocation de mémoire de tas doit être synchronisé avec son utilisation réelle dans tout programme afin qu'il soit réutilisé autant que possible. Par exemple, si le seul pointeur vers une allocation de mémoire de tas est hors de portée ou a sa valeur écrasé avant gratuit () est appelé, alors que la mémoire ne peut pas être récupéré pour être réutilisé plus tard et est essentiellement perdu au programme, un phénomène connu sous le nom d'une fuite de mémoire. Inversement, il est possible pour la mémoire à être libéré mais continue d'être référencée, ce qui conduit à des résultats imprévisibles. Généralement, les symptômes apparaissent dans une partie du programme éloigné de l'erreur réelle, ce qui rend difficile à traquer le problème. (Ces questions sont améliorés dans les langues à la collecte des ordures automatique.)

Biblioth??ques

Le langage de programmation C utilise les bibliothèques comme principale méthode d'extension. En C, une bibliothèque est un ensemble de fonctions contenues dans un seul fichier "archive". Chaque bibliothèque a généralement un fichier d'en-tête, qui contient les prototypes des fonctions contenues dans la bibliothèque qui peuvent être utilisés par un programme, et les déclarations de types de données et de symboles spéciaux utilisés macro avec ces fonctions. Pour un programme à utiliser une bibliothèque, il doit inclure le fichier d'en-tête de la bibliothèque, et la bibliothèque doit être liée avec le programme, ce qui dans de nombreux cas nécessite drapeaux du compilateur (par exemple, -lm , raccourci pour "bibliothèque mathématique").

La bibliothèque la plus courante C est la bibliothèque standard C, qui est spécifié par les ISO et les normes ANSI C et est livré avec chaque mise en ??uvre de C. (Implémentations qui ciblent les environnements limités, tels que les systèmes embarqués peuvent fournir seulement un sous-ensemble de la bibliothèque standard.) Cette librairie supporte entrée de flux et de la production, l'allocation de mémoire, les mathématiques, les chaînes de caractères, et les valeurs de temps. Plusieurs têtes de standards distincts (par exemple, stdio.h ) précisent les interfaces pour ces et d'autres installations de la bibliothèque standard.

Un autre ensemble commun de fonctions de la bibliothèque C sont ceux utilisés par les applications ciblées pour Unix et Unix-like systèmes, en particulier les fonctions qui fournissent une interface pour le noyau. Ces fonctions sont détaillées dans diverses normes telles que POSIX et de la Single UNIX Specification.

Etant donné que de nombreux programmes ont été écrits en langage C, il existe une grande variété d'autres bibliothèques disponibles. Les bibliothèques sont souvent écrites en C parce que les compilateurs C génèrent efficace code objet; programmeurs créent alors des interfaces à la bibliothèque afin que les routines peuvent être utilisés à partir de langages de haut niveau comme Java , Perl et Python .

Outils linguistiques

Des outils ont été créés pour aider les programmeurs C éviter certains des problèmes inhérents à la langue, tels que les états avec un comportement indéfini ou des déclarations qui ne sont pas une bonne pratique, car ils sont susceptibles d'entraîner un comportement involontaire ou erreurs d'exécution.

Code source de contrôle et l'audit automatisé sont bénéfiques dans toute langue, et C de nombreux tels outils existent, comme Lint. Une pratique courante consiste à utiliser Lint pour détecter le code discutable quand un programme est d'abord écrit. Une fois un programme passe Lint, il est ensuite compilé en utilisant le compilateur C. Aussi, de nombreux compilateurs peuvent éventuellement avertir constructions syntaxiquement valides qui sont susceptibles d'être en fait des erreurs. MISRA C est un ensemble exclusif de directives pour éviter un tel code douteuse, développé pour les systèmes embarqués.

Il existe également des compilateurs, les bibliothèques et les mécanismes au niveau du système d'exploitation pour effectuer des actions qui ne sont pas un élément standard de C, tels que des bornes de tableaux de contrôle,la détection de dépassement de tampon,la sérialisation etla collecte des ordures automatique.

Des outils tels quePurify ouValgrind et la liaison avec les bibliothèques contenant des versions spéciales desfonctions d'allocation de mémoire peut aider à découvrir des erreurs d'exécution dans l'utilisation de la mémoire.

Utilisations

C est souvent utilisé pour " la programmation du système ", y compris la mise en ??uvre des systèmes d'exploitation et applications de systèmes embarqués, en raison d'une combinaison de caractéristiques souhaitables telles que la portabilité du code et de l'efficacité, la capacité d'accéder aux adresses matérielles spécifiques, la capacité de calembour types pour correspondre à l'accès aux données imposée de l'extérieur exigences, et une faible demande d'exécution sur les ressources système. C peut également être utilisé pour la programmation de site Web en utilisant CGI comme une «porte d'entrée» pour des informations entre l'application Web, le serveur et le navigateur. Quelques raisons pour choisir C sur les langages interprétés sont sa vitesse, la stabilité et la disponibilité quasi-universelle.

Une des conséquences de grande disponibilité et l'efficacité de C est que les compilateurs, les bibliothèques, et les interprètes ded'autreslangages de programmation sont souvent mises en ??uvre en C. Les implémentations primaires dePython(CPython),Perl5 etPHP sont tous écrits en C.

Grâce à sa fine couche d'abstraction et de bas frais généraux, C permet des implémentations efficaces d'algorithmes et de structures de données, ce qui est utile pour les programmes qui effectuent un grand nombre de calculs. Par exemple, le GNU bibliothèque multi-précision, laGNU Scientific Library,Mathematica etMATLAB sont complètement ou partiellement écrit en C.

C est parfois utilisé comme un langage intermédiaire par les implémentations d'autres langues. Cette approche peut être utilisée pour la portabilité ou de commodité; à l'aide de C comme un langage intermédiaire, il est nécessaire de développer des générateurs de codes spécifiques à la machine. C dispose de quelques fonctionnalités, comme la ligne-numéro directives de préprocesseur et des virgules superflues en option à la fin des listes de initialiseur, qui soutiennent la compilation du code généré. Toutefois, certaines des lacunes de C ont favorisé le développement d'autres langages basés-C spécifiquement conçus pour une utilisation en tant que langues intermédiaires, tels que C--.

C a également été largement utilisé pour mettre en ??uvre desapplications de l'utilisateur final, mais beaucoup de ce développement a évolué à nouveaux langages.

Langues associées

C a directement ou indirectement influencé de nombreuses langues ultérieures telles que C #, D, Go, Java , JavaScript Limbo, LPC, Perl , PHP, Python , et Unix de C Shell. L'influence la plus répandue a été syntaxique: toutes les langues mentionnées combinent la déclaration et (plus ou moins reconnue) expression syntaxe de C avec les systèmes de type, les modèles de données et / ou des structures de programmes de grande envergure qui diffèrent de celles de C, parfois radicalement .

Plusieurs interprètes C ou quasi-C existent, y comprisCh etCINT, qui peut également être utilisé pour les scripts.

Lorsque les langages orientés objet est devenu populaire, C ++ et Objective-C étaient deux extensions différentes de C qui a fourni les capacités orientées objet. Les deux langues ont été initialement mis en ??uvre comme compilateurs source-source; code source a été traduit en C, puis compilé avec un compilateur C.

Le C ++ langage de programmation a été conçue par Bjarne Stroustrup comme une approche à fournir une fonctionnalité orientée objet avec la syntaxe de C-like. C ++ ajoute une plus grande force de frappe, la portée, et d'autres outils utiles dans la programmation orientée objet et permet la programmation générique via des modèles. Près d'un sur-ensemble de C, C ++ prend désormais en charge la plupart des C, à quelques exceptions près (voir Compatibilité de C et C ++).

Objective-C était à l'origine une couche très «mince» au-dessus de C, et reste un sur-ensemble de C stricte qui permet la programmation orientée objet en utilisant un paradigme statique dynamique hybride / dactylographie. Objective-C tire sa syntaxe à la fois C et Smalltalk: syntaxe qui implique prétraitement, des expressions, des déclarations de fonctions, et appels de fonction est héritée de C, tandis que la syntaxe des fonctionnalités orientées objet a été prise à l'origine de Smalltalk.

En plus deC ++et Objective-C, Ch,Cilk etUnified Parallel C sont près de supersets de C.