Vérifié contenu

C (langage de programmation)

Sujets connexes: Programmation informatique

Contexte des écoles Wikipédia

SOS Enfants a fait cette sélection Wikipedia aux côtés d'autres écoles des ressources . Avant de vous décider à propos de parrainer un enfant, pourquoi ne pas en apprendre davantage sur différents organismes de parrainage premier ?

C
Couverture de livre pour
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):

auto
pause
cas
carboniser
const
continuer
défaut
faire
double
autre
énumération
externe
flotteur
pour
aller à
si
int
longue
enregistrer
retour
court
signé
taille de
statique
struct
interrupteur
typedef
union
unsigned
vide
volatil
tandis que

C99 ajoute cinq autres mots-clés:

_Bool
_Complex
_Imaginary
en ligne
restreindre

C11 ajoute sept autres mots-clés:

_Alignas
_Alignof
_Atomic
_Generic
_Non-Retour
_Static_assert
_Thread_local

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.

Récupéré à partir de " http://en.wikipedia.org/w/index.php?title=C_(programming_language)&oldid=556129868 "