• #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 »).

Des sources à l'exécutable

• make
• SCons (écrit en Python)

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

Préprocesseur

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.

Compilation

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

• l'analyse lexicale, qui est la reconnaissance des mots clés du C
• l'analyse syntaxique, qui analyse la structure du programme et sa conformité avec la norme
• l'écriture d'un code isomorphe a 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 appele compilation toute la phase de génération d'un fichier exécutable à partir des fichiers sources. Mais c'est bien une des étapes menant à la création d'un exécutable.

Assemblage

Édition de liens

Éléments du langage

Instructions du pré-compilateur

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

Mots clés

Types

• Types entiers >= 8 bits : char (identique à signed char), unsigned char
• Types entiers >= 16 bits : short (identique à unsigned short)
• Types entiers (mot machine) >= 16 bits pour les processeurs 16 bits, sinon vaut 32 bits : int, (identique à unsigned int)
• Types entiers >= 32 bits : long (identique à unsigned long)
• Types entiers >= 64 bits (C-99) : long long (identique à unsigned long long)
• Types à virgule flottante : float, double, long double (C89)
• Types énumérés : enum
• Types élaborés : struct, union

Signé/non signé

Lorsqu'une variable est signée, elle peut représenter une valeur négative. La plage des valeurs disponibles est alors divisée par deux par rapport à une non signée, avec le 0 (en base décimale) comme centre de cette plage.

Voici un exemple avec le type char :

• signé : -128 à 127
• non signé : 0 à 255

La notion de variable signée n'a de sens que pour les types entiers. Les types flottants réservent tous un bit pour le signe. Le reste des bits est utilisé pour la partie entière et la mantisse.

Commentaire

Initialement, les commentaires devaient commencer par un slash et une étoile ("/*") et se terminer par une étoile et un slash. 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ée la possibilité de faire des commentaires sur une seule ligne, de la même manière que le C++ : //Commentaire comme en C++, valable jusqu'au saut de ligne

Structures de contrôle

La syntaxe des différentes structures de contrôles 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ésentes :

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

La bibliothèque standard

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)
• 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 la gestions des erreurs (comme avec des exceptions).

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.

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.

Exemples

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

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. 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(char *str) { char *start = str; /* start = adresse du début de la chaîne */ while (*str != '\0') /* Tant qu'on n'est pas en fin de chaîne */ ++str; /* pointer le caractère suivant. */ return str - start; /* La longueur est la différence entre */ /* la fin et le début de la chaîne. */ }

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.

#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 * val : 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 val) { struct int_list *const new_next = malloc(sizeof(struct int_list)); /* Allocation de la mémoire pour un nouvel élément. */ if (new_next) { /* Si l'allocation a réussi, alors */ new_next->next = node->next; /* insérer new_next entre node et node->next */ new_next->value = val; node->next = new_next; } 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) { struct int_list *node_next_next = node->next->next; /* node_next_next = adresse de l'élément suivant le suivant. */ free(node->next); /* Libération de la mémoire occupée par l'élément suivant node. */ node->next = node_next_next; /* Le suivant de node est l'ex-suivant du suivant. */ }

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 d'octets que l'on désire allouer et elle retourne l'adresse du premier octet qui a été alloué, sinon elle retourne NULL. free sert à libérer la mémoire qui a été allouée par malloc.

Articles connexes

• Alignement de données

Références

Ressources Internet

• Cours de C
• Rubrique C de developpez.com : site francophone d'entraide entre développeurs.
• CPPFrance : site de passionnés qui mettent en commun leurs connaissances
• Site du Zéro : cours pour débutants
• The Development of the C Language par Dennis Ritchie
• La FAQ du groupe de discussion comp.lang.c, très technique et très pointu

Bibliographie

• B.W.Kernighan D.M.Ritchie, Le langage C, ISBN 2-225-82070-8

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

Compilateurs C

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

Langage de programmation | Langage impératif | Norme ISO

C (programmeertaal) | Lenguache de programazión C | سي | Llinguaxe de programación C | C | C (мова праграмавання) | C (език за програмиране) | C programski jezik | Llenguatge C | C (programovací jazyk) | C (programmeringssprog) | C (Programmiersprache) | C (γλώσσα προγραμματισμού) | C programming language | C (programlingvo) | Lenguaje de programación C | C (programmeerimiskeel) | C programazio lengoaia | C (ohjelmointikieli) | C (Teanga ríomhchlárúcháin) | Linguaxe de programación C | C (שפת תכנות) | C (programski jezik) | C programozási nyelv | C (linguage de programmation) | Bahasa pemrograman C | Forritunarmálið C | C (linguaggio) | C言語 | C 프로그래밍 언어 | C (zimanê bernamekirinê) | C (codex programmandi) | C (kalba) | C (programmēšanas valoda) | Bahasa pengaturcaraan C | C (programmeertaal) | Programmeringsspråket C | C (programmeringsspråk) | C (język programowania) | Linguagem de programação C | Limbajul C | Си (язык программирования) | C (jezik) | C programming language | C (programovací jazyk) | Programski jezik C | Gjuha programuese C | Програмски језик C | C (programspråk) | சி நிரலாக்கல் மொழி | ภาษาซี | C programlama dili | C (мова програмування) | C (ngôn ngữ lập trình) | C语言