C (langage)

il existe depuis longtemps (plus de 30 ans, voir plus bas), ce qui fait que de nombreux compilateurs C existent sur des architectures très variées ;
il est très facile à porter d'une machine à une autre (les compilateurs sont souvent écrits en C : il y a juste à changer les routines de génération de code et à le faire se compiler lui-même pour avoir une nouvelle machine cible) ;
il est relativement facile à comprendre à première vue, étant plus pauvre en concepts que le C++ par exemple ;
sa conception minimaliste lui permet de revendiquer de bonnes performances d'exécution dans la grande majorité des cas.

Ses principaux inconvénients sont :

qu'il permet facilement au programmeur non rigoureux de produire du code inextricable et souvent non portable ;
qu'il donne une grande permissivité au programmeur quant à l'accés à la zone mémoire, les manipulations de pointeurs peuvent alors notamment introduire des bugs.

[modifier] Histoire

Kenneth Thompson (à gauche) et Dennis Ritchie (à droite)

Le langage C est apparu au cours de l'année 1972 dans les Laboratoires Bell. Il était développé en même temps qu'UNIX par Dennis Ritchie et Ken Thompson. Ken Thompson avait développé un prédécesseur de C, le langage B. Dennis Ritchie a fait évoluer le langage B dans une nouvelle version suffisamment différente pour qu'elle soit appelée C. Par la suite, Brian Kernighan aida à populariser le langage. Il procéda aussi à quelques modifications de dernière minute. En 1978, il fut notamment le principal auteur du livre The C Programming Language décrivant le langage enfin fixé ; Ritchie s'était occupé des appendices et des exemples avec UNIX. On parle encore de C K&R, K&R C en anglais (pour Kernighan and Ritchie C) lorsqu'on se réfère au langage tel qu'il existait à cette époque.

[modifier] Normalisations

En 1983, l'Institut national américain de normalisation (ANSI) a formé un comité de normalisation du langage qui a abouti en 1989 à l'approbation de la norme dite ANSI C ou C89 (formellement ANSI X3.159-1989). En 1990, cette norme a également été adoptée par l'Organisation internationale de normalisation (C ISO, formellement ISO/CEI 9899:1990). ANSI C est une évolution du C K&R qui reste extrêmement compatible. Elle reprend quelques idées de C++.

En 1999, une nouvelle évolution du langage est normalisée par l'ISO : C99 (formellement ISO/CEI 9899:1999). Parmi les ajouts, on notera les tableaux dynamiques, ainsi que des fonctionnalités (types complexes, mot-clef « restrict », directives agissant sur la simplification des instructions arithmétiques) souhaitables pour les calculs numériques intensifs, domaine habituel de FORTRAN ; certaines de ces fonctionnalités étaient déjà présentes dans certains compilateurs comme GCC.

[modifier] Présentation

Le langage C peut être qualifié de bas niveau ou peu typé dans le sens où le langage manipule les mêmes sortes d'objets que la plupart des ordinateurs : des mots machine (pouvant contenir une donnée interprétée comme un nombre, un caractère ou une adresse). Le langage ne propose aucune opération qui traite directement des objets de plus haut niveau (fichier, chaîne de caractères, liste…) et il faut donc faire appel à des fonctions de la bibliothèque standard pour manipuler ce type d'objet.

Le langage C a été utilisé pour rendre le système d'exploitation UNIX plus portable. Il a conservé de cela une très grande efficacité pour tout ce qui concerne le développement système. Ainsi la majorité des grands systèmes d'exploitation entre les années 1975 et 1993 ont été développés en C.

De même, le langage ne propose pas en standard la gestion de la programmation orientée objet, ni de mécanisme d'exception, ou de traitement multitâche. Il existe des fonctions standards pour gérer les entrées-sorties et les chaînes de caractères, mais contrairement à d'autres langages, aucun opérateur spécifique pour améliorer l'ergonomie. Ceci rend aisé le remplacement des fonctions standards par des fonctions spécifiquement conçues pour un programme donné. En autorisant la surcharge des opérateurs, C++ permet de mélanger la souplesse de C à l'ergonomie des opérateurs spécifiques.

Ces caractéristiques en font néanmoins un langage à privilégier quand on cherche à maîtriser les ressources utilisées, le code assembleur généré par les compilateurs étant relativement prévisible et parfois même optimal sur les machines d'architecture RISC à grand nombre de registres.

Ce langage est donc extrêmement utilisé dans des domaines comme : la programmation embarquée sur microcontrôleurs, les calculs intensifs, l'écriture de systèmes d'exploitation et tous les modules où la rapidité de traitement est importante. Il est en effet une bonne alternative aux langages assembleurs dans ces domaines avec les avantages d'une syntaxe plus lisible et de la portabilité du code.

En contrepartie, la mise au point de programmes en C, surtout s'ils utilisent des structures de données complexes, est plus difficile qu'avec des langages de plus haut niveau. En effet, dans un souci de performance le langage C impose à l'utilisateur de programmer certains traitements (libération de la mémoire, vérification de la validité des index sur les tableaux…) qui sont pris en charge automatiquement par les langages de haut niveau.

Le C étant un langage simple, son compilateur l'est également. Cela se ressent au niveau du temps de développement d'un compilateur C pour un nouveau microprocesseur, qui selon Kernighan et Ritchie estiment qu'il peut être développé en deux mois. C'est pour cela qu'il est souvent choisi comme premier langage sur une nouvelle architecture. Le compilateur GNU GCC est d'ailleurs écrit en C : seule la partie de génération de code est à modifier quand on porte le compilateur sur une autre machine, par compilation croisée.

Beaucoup de limitations du langage C ont été levées dans le langage C++ qui est, à l'origine, C enrichi de la notion d'objet.

Beaucoup d'autres langages de programmation ont adopté une syntaxe (notation) ressemblant à celle du langage C, notamment C++, Java, JavaScript, PHP ou C#.

[modifier] Hello world

Voici l'exemple de programme Hello world donné en 1978 dans The C Programming Language de Brian W. Kernighan et Dennis M. Ritchie :

#include <stdio.h>

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

Le même programme, conformément à la norme ISO :

#include <stdio.h>

int main(void) {
  printf("hello, world\n");
  return 0;
}

#include <stdio.h> inclut le fichier d'en-tête stdio.h, contenant les déclarations des fonctions d'entrée-sortie de la bibliothèque standard du C.
main est le nom de la fonction principale (la première appelée) du programme.
Le mot clé void entre les parenthèses signifie que la fonction main ne prend aucun paramètre. Cependant, il n'est pas obligatoire de le spécifier.
Les accolades { et } entourent les instructions constituant le corps de la fonction main.
printf est la fonction d'écriture formatée dans la sortie standard (la console par défaut).
Les caractères " délimitent une chaîne de caractères. Dans ce cas, cela sera la chaîne à afficher.
Le \n désigne le caractère de nouvelle ligne.
Un point-virgule ; termine toute instruction.
La norme ISO exige qu'un code retour soit explicitement renvoyé, ce qui est fait avec le mot clé return qui retournera la valeur 0 (ce qui par convention signifie « aucune erreur »).

Il est à noter que créer un programme affichant "Hello World" est depuis devenu une référence pour chaque première présentation d'un nouveau langage.

[modifier] Des sources à l'exécutable

La génération d'un exécutable, à partir des fichiers sources se fait en plusieurs étapes, qui sont souvent automatisées à l'aide d'outils comme :

make
SCons (écrit en Python)
ou bien encore des outils spécifiques à l'environnement de développement intégré (EDI) utilisé.

Les étapes menant des sources au fichier exécutable sont au nombre de quatre :

[modifier] Préprocesseur

Durant cette étape, le préprocesseur effectue plusieurs opérations sur les fichiers sources, dont les instructions (les directives du préprocesseur) sont au sein même de ces fichiers. Le préprocesseur produit alors des fichiers intermédiaires pour chaque fichier source (qui ont généralement l'extension ".c"), qui seront utilisés dans l'étape suivante.

Le préprocesseur effectue des remplacements de textes, des inclusions de fichiers (généralement les fichiers d'en-têtes contenant diverses déclarations) avec la possibilité d'effectuer certaines opérations uniquement si certaines conditions sont remplies. C'est également durant cette étape que les commentaires sont supprimés.

[modifier] Compilation

La phase de compilation consiste généralement en la génération du code assembleur (encore lisible par un être humain, mais dépendant du processeur). Pour chaque fichier source, on obtient un fichier en langage d'assemblage.

Cette étape est divisée en trois sous-étapes, qui sont :

l'analyse lexicale, qui est la reconnaissance des mots clés du langage
l'analyse syntaxique, qui analyse la structure du programme et sa conformité avec la norme
l'écriture d'un code isomorphe à celui de l'assembleur (et parfois du code assembleur lui-même quand cela est demandé en option du compilateur)

Par abus de langage, on appelle compilation toute la phase de génération d'un fichier exécutable à partir des fichiers sources. Mais c'est seulement une des étapes menant à la création d'un exécutable.

[modifier] Assemblage

Cette étape consiste à la génération à partir du code assembleur, d'un fichier objet pour chaque fichier assembleur. Ce fichier objet (d'extension ".o") est en langage machine. C'est un format binaire, dépendant du processeur. Cette phase est parfois regroupée avec la précédente, dans ce cas le compilateur génère directement un fichier objet binaire.

[modifier] Édition de liens

L'édition de liens est la dernière étape et a pour but de réunir tous les éléments d'un programme. Les différents fichiers objets sont alors réunis, ainsi que les bibliothèques statiques, pour ne produire qu'un fichier exécutable.

[modifier] Éléments du langage

[modifier] Instructions du pré-compilateur

#include, #define, #pragma (C89), #if, #ifdef, #ifndef, #elif (C89), #else, #endif, #undef, #line, #error.

[modifier] Mots clés

auto, break, case, const (C89), continue, default, do, else, enum (C89), extern, for, goto, if, inline (C99), register, restrict (C99), return, sizeof, static, struct, switch, typedef, union, void (C89), volatile (C89), while, signed (C89), unsigned, char, short, int, long, float, double, _Bool (C99), _Complex (C99), _Imaginary (C99)

[modifier] Types

Le langage C comprend de nombreux types de nombre entier, occupant plus ou moins de bits. La taille des types n'est que partiellement standardisée, le standard fixant uniquement une taille et une magnitude minimale. Les magnitudes minimales sont compatibles avec d'autres représentations binaires que le complément à deux, bien qu'il soit presque toujours utilisé. Cette souplesse permet au langage d'être efficacement adapté à des processeurs très variés. En revanche, elle complique la portabilité des programmes écrits en C.

Chaque type entier a une forme « signée » pouvant représenter des nombres négatifs et positifs, et une forme « non signée » ne pouvant représenter que des nombres naturels. Notons que le type char, généralement utilisé pour représenter un caractère, est un type entier comme les autres.

Types entiers ≥ 8 bits, magnitudes minimales de -127 à +127 et de 0 à 255 : char, unsigned char, signed char (C89).
Types entiers ≥ 16 bits, magnitudes minimales de -32767 à +32767 et de 0 à 65535 : short (identique à signed short), unsigned short.
Types entiers (mot machine) ≥ 16 bits, magnitudes minimales de -32767 à +32767 et de 0 à 65535 : int (identique à signed int), unsigned int.
Types entiers ≥ 32 bits, magnitudes minimales de -2147483647 à +2147483647 et de 0 à 4294967295 : long (identique à signed long), unsigned long.
Types entiers ≥ 64 bits (C99), magnitudes minimales de -9223372036854775807 à +9223372036854775807 et de 0 à 18446744073709551615 : long long (identique à signed long long), unsigned long long.
Types énumérés : enum.

Il existe trois types de nombres à virgule flottante, de précision, donc de longueur en bits, variable :

float, double, long double (C89).

Types élaborés :

struct, union, * pour les pointeurs, [ ... ] pour les tableaux, ( ... ) pour les fonctions.

[modifier] Commentaire

Dans les versions de C antérieures à C99, les commentaires devaient commencer par une barre oblique et un astérisque (« /* ») et se terminer par un astérisque et une barre oblique. Tout ce qui est compris entre ces symbole est du commentaire, saut de ligne compris :

/* Ceci est un commentaire
sur deux lignes*/

La norme C99 a ajouté la possibilité de faire des commentaires sur une seule ligne, de la même manière qu’en C++ :

//Commentaire comme en C++, valable jusqu'au saut de ligne

[modifier] Structures de contrôle

La syntaxe des différentes structures de contrôle existantes en C est largement reprise dans plusieurs autres langages, comme le C++ bien sûr, mais également Java, C#, PHP ou encore JavaScript.

Les trois grands types de structures sont présents :

les tests avec :
- if ... else if ... else
- switch ... case ... default:
les boucles avec :
- while
- for
- do ... while
les sauts :
- break
- continue
- return
- goto

[modifier] La bibliothèque standard

Voir l’article Bibliothèque standard du C.

La bibliothèque standard est assez pauvre en comparaison de celle fournie par d'autres langages. Voici une liste de quelques fichiers contenant les déclarations des types et fonctions de la bibliothèque standard :

assert.h : pour un diagnostic de conception lors de l'exécution (assert)
ctype.h : tests et manipulation des caractères (isalnum, tolower)
errno.h : gestion minimales des erreurs (déclaration de la variable errno)
math.h : fonctions mathématiques de base (sqrt, cos) ; nombreux ajouts en C99
signal.h : gestion des signaux (signal et raise)
stddef.h : définitions générales (déclaration de la constante NULL)
stdio.h : pour les entrées/sorties de base (printf, scanf)
stdlib.h : fonctions générales (malloc, rand)
string.h : manipulation des chaînes de caractères (strcmp, strlen)
time.h : manipulation du temps (time, ctime)

La bibliothèque standard n'offre aucun support du réseau, des entrées/sorties évoluées (port série ou parallèle) ou encore de la gestion avancée des erreurs (comme avec des exceptions structurées).

[modifier] Optimiseurs

Des essais de comparaison entre le C et l'assembleur effectués depuis 1990 sur des machines RISC montrent, de façon tout à fait contre-intuitive, un net avantage au C lorsque toutes les options d'optimisation du compilateur sont activées. Les optimiseurs construisent en effet un graphe chromatique qui leur permet d'allouer sans se tromper les usages de registres de façon quasi-optimale, là où un programmeur serait vite perdu. Ils regroupent de plus directement les instructions en réarrangeant les chargements et sauvegardes de registres pour bénéficier de l'effet pipeline. La même opération effectuée sur un programme source serait envisageable, mais le rendrait quasi impossible ensuite à maintenir.

En revanche, les optimiseurs ont moins de latitude concernant la réorganisation d'instructions CISC, plus complexes, et dans ce cas précis les résultats sont moins tranchés.

[modifier] Critiques

Le C étant dépouillé volontairement de toute fonctionnalité non rudimentaire, même les opérations les plus simples (opérations sur chaînes de caractères, ordres d'entrée-sortie) se font par des fonctions qui ne peuvent se livrer à aucune vérification syntaxique approfondie au moment de la compilation (hormis une vérification élémentaire du type des arguments). Un programme nommé lint tentait de remédier à ce défaut du langage; quelques fonctionnalités de lint furent par la suite intégrées au compilateur lui-même, et splint fut créé pour remplacer lint.
Chaque programmeur C a au moins une fois écrit par mégarde = au lieu de == dans un if()… avec des résultats hautement inattendus, vu qu'une affectation est exécutée au lieu d'un test ! Toutefois, cette erreur classique est signalée par un message d'avertissement par de nombreux compilateurs. Il est généralement recommandé de compiler C en activant les messages d'avertissement.
Le débordement de tampon peut passer inaperçu et avoir des conséquences dramatiques.
Les erreurs d'allocation mémoire comme un oubli d'allocation, une double désallocation, ou un accès à une zone non allouée sont très difficiles à éviter. Il faut noter qu'un ramasse-miettes conservateur pour le C existe (le collecteur Böhm-Weiser), sous la forme d'une bibliothèque, mais son utilisation peut être parfois délicate.

[modifier] Exemples

Voici quelques exemples présentant très succinctement quelques propriétés du C. Pour plus d'information, voir le WikiLivre Programmation C.

[modifier] Chaînes de caractères

Voici une implémentation possible de la fonction strlen de la bibliothèque standard qui retourne la longueur d'une chaîne de caractères sans la modifier. Le principe est de parcourir les caractères jusqu'à ce qu'on tombe sur un caractère nul, marquant conventionnellement la fin d'une chaîne en C.

#include <stddef.h>

/* Retourne : la longueur de la chaîne str. */
size_t strlen(const char *str)
{
    const char *start = str; /* start = adresse du début de la chaîne */
  
    /* La boucle while suivante utilise une notation classique
       mais très brève permise par C, qui n'a pas peu contribué
       à donner à C une réputation de langage peu lisible. Le caractère
       pointé par str est comparé avec zéro, et s'il est différent,
       alors le pointeur str est incrémenté. Cette boucle n'a pas de
       corps, car toutes les opérations sont effectuées dans le test.
       On considère qu'il faut maîtriser ce genre de notation pour
       maîtriser C^[1]. */
    while (*str++);

    return str - start; /* La longueur est la différence entre
                           la fin et le début de la chaîne. */
}

[modifier] Allocation mémoire

La structure int_list représente un élément d'une liste chaînée, contenant des données de type int. Les deux fonctions qui suivent (insert_next et remove_next) servent à ajouter et supprimer un élément de la liste.

/* La gestion de la mémoire n'est pas intégrée au langage
   mais assurée par des fonctions de la bibliothèque standard. */
#include <stdlib.h>

struct int_list {
    struct int_list *next; /* pointeur sur l'élément suivant */
    int value;             /* valeur de l'élément */
};

/* 
 * Ajouter un élément à la suite d'un autre.
 * node : élément après lequel ajouter le nouveau
 * value : valeur de l'élément à ajouter
 * Retourne : adresse de l'élément ajouté, ou NULL en cas d'erreur.
 */
struct int_list *insert_next(struct int_list *node, int value) {
    /* Allocation de la mémoire pour un nouvel élément. */
    struct int_list *const new_next = malloc(sizeof(struct int_list));

    if (new_next) {
        /* L'allocation a réussi, alors on insère
           new_next entre node et node->next */
        new_next->next = node->next;
        node->next = new_next;
        new_next->value = value;
    }

    return new_next;
}

/*
 * Supprimer l'élément suivant un autre.
 * node : élément dont le suivant est supprimé
 */
void remove_next(struct int_list *node) {
    /* node_next_next = adresse de l'élément suivant le suivant. */
    struct int_list *node_next_next = node->next->next;
    /* Libération de la mémoire occupée par l'élément suivant node. */
    free(node->next);
    /* Le suivant de node est l'ex-suivant du suivant. */
    node->next = node_next_next;
}

Dans cet exemple, les deux fonctions essentielles sont malloc et free. La première sert à allouer de la mémoire, le paramètre qu'elle reçoit est le nombre de bytes que l'on désire allouer et elle retourne l'adresse du premier byte qui a été alloué, sinon elle retourne NULL. free sert à libérer la mémoire qui a été allouée par malloc.

[modifier] Articles connexes

[modifier] Références

↑ Brian W. Kernighan, Dennis M. Ritchie, The C Programming Language, Second Edition, Prentice Hall, ISBN 0-13-110362-8, p. 106

[modifier] Ressources Internet

Voir aussi sur Wikilivres :
la programmation en C.

(fr) Introduction au langage C, qui est plus qu'une simple introduction
(fr) Cours de C
(fr) Rubrique C de developpez.com : site francophone d'entraide entre développeurs.
(fr) CPPFrance : site de passionnés qui mettent en commun leurs connaissances
(en) The Development of the C Language par Dennis Ritchie
(en) La FAQ du groupe de discussion comp.lang.c, très technique et très pointu
(fr) Cours pour débuter en C Des cours simples conçus pour débutants

[modifier] Bibliographie

B.W.Kernighan D.M.Ritchie, Le langage C, ISBN 2-225-82070-8
A.Braquelaire, Méthodologie de la programmation en C, ISBN 2-100-49018-4

[modifier] Quelques programmes célèbres écrits en C

UNIX
La suite de compilateurs GNU Compiler Collection (GCC)
Le noyau Linux
Le noyau de Microsoft Windows
GNOME

[modifier] Compilateurs C

GCC (multiples plateformes)
LCC (multiples plateformes)
LCC Win32 (Windows)
TenDRA
Ten15, un fork de TenDRA

Récupérée de « http://fr.wikipedia.org../../../c/_/%28/C_%28langage%29.html »

Catégories : Langage de programmation • Langage impératif • Norme ISO