|
Le C est un langage informatique évolué. Il possède des mots clés et une grammaire, comme tout langage. Il a
été inventé en 1972 par Dennis Ritchie pour les besoins de l'adoption du système UNIX aux ordinateurs DEC
PDP-11. Comme la plupart des langages informatiques, il est fondé sur des termes anglais.
Le langage C est naturellement très lié au système d'exploitation UNIX. Mais on le trouve également dans les
autres environnements tels que Windows ou Mac OS.
Il a donné naissance à d'autres langages, comme le C++, et a également inspiré les concepteurs des langages
PERL, PHP et JAVA. C'est un langage très important. L'apprentissage du C permet d'évoluer facilement vers les
autres langages.
La normalisation du C par l'organisme américain ANSI (American Nation Standards Institute) a débuté en 1983
pour aboutir à la norme ANSI C en 1988, ce qui rend ce langage universel. Un programme en C respectant la
syntaxe décrite dans la norme ANSI est portable sur tout ordinateur possedant un compilateur C.
Enfin, le C est devenu le langage de programmation de référence dans l'enseignement, détronant le langage
PASCAL, même si parfois ses aspects très techniques sont difficiles à enseigner.
L'écriture d'un programme consiste à déclarer toutes les variables nécessaires, puis à les utiliser par le biais des
instructions.
Voici comment se présente la structure d'un programme en C :
|
/* ---------- */
/* somme.c */
/* ---------- */
#include <stdio.h>
main ()
{
int a, a, somme ;
printf("Entrez deux entiers : ");
scanf("%d %d", &a, &b);
somme = a+b ;
printf("La somme de %d et de %d est %d\n",a,b,somme);
}
| |
Tout d'abord se trouvent les commentaires, comme en CSS, introduits par /* et terminés par */.
Vient ensuite l'inclusion d'un fichier. Il n'y a pas toujours un fichier inclus mais très souvent.
"main ()" et "{" sont les en-têtes du bloc.
Après, les variables sont déclarés ("int a, a, somme ;").
Et pour finir, suit le bloc d'instructions.
Le programme principal (main) appelle une fonction calcul() qui effectue la somme des deux entiers.
Les deux blocs sont écrits l'un après l'autre dans le même fichier. Au moment de l'exécution, la fonction calcul()
est appelée par le programme principal main(). Le bloc "calcul" est imbriqué dans le bloc "main".
Une variable est un espace mémoire que le programme réserve lors de son exécution. La réservation s'effectue
lors de la déclaration de la variable.
Les données utilisées dans le programme sont rangées dans les différentes variables. C'est pourquoi la
déclaration de toutes les variables doit être effectuée avant l'écriture des instructions qui les traitent.
Une variable est caractérisée par les éléments suivants :
Un nom. L'accès à l'espace mémoire réservé se fait grâce au nom qui lui est affecté. C'est le nom de la variable.
Un type. La taille de cet espace mémoire est fournie par le type de la variable. Il correspond à un
certain nombre d'octets.
Un caractère prendra un octet, alors qu'un entier occupera généralement quatre
octets.
Le type indiquera aussi la méthode utilisée pour coder et décoder les données en binaire. Un caractère ne sera
pas codé de la même manière qu'un entier.
Les caractères valides pour nommer une variable sont les suivants :
Les caractères accentués ne sont pas autorisés, pas plus que les signes de ponctuation. Voici quelques noms de
variables interdits :
an'02
valeur-actuelle
+value
année
Les variables contiennent des données modifiables par les instructions d'où leur nom.
Les variables de types simples concernent les données "uniques", comme un entier, un caractère ou un nombre
avec une virgule. Elles disposent d'opérateurs associés (addition, soustraction, etc) et de fonctions particulières
(toupper(), tolower() pour les caractères, par exemple).
Les types simples sont les suivants :
Les variables de types structurés correspondent à un ensemble de données, comme une suite de caractères
(chaîne de caractères) ou une suite de nombres (tableau d'entiers).
Chaque case élémentaire de cet ensemble peut contenir une donnée de type simple mais également une donnée
structurée. Cet "emboitement" de structures de données ressemble un peu aux poupées russes : l'ouverture d'une
poupée dévoile d'autres poupées à l'intérieur. Au bout d'un moment, on retombe toujours sur une ou plusieurs
données de types très simples.
Bien comprendre les données élémentaires permet d'assimiler les données structurées.
Les types structurés sont les suivants :
Le type tableau (int notes[10])
Le type cha$ine de caractères (char prenom[20])
Le type enregistrement (union)
Le type fichier (FILE)
Les variables déclarées à l'intérieur d'un bloc ou à l'intérieur des blocs seront dites respectivement "locales" ou
"globales". Voici les définitions de ces notions.
Les variables locales. Toute variable déclarée à l'intérieur d'un bloc est une variable "locale".
Elle n'existe que dans ce bloc. Elle est invisible pour les autres blocs. Seules les instructions du bloc où
se trouve la déclaration peuvent la manipuler.
Dans l'exemple précédant (somme.c), les variables a, b et somme sont locales au bloc main().
Les variables globales. Toute variable déclarée à l'extérieur d'un bloc est une variable "globale".
Elle existe pour tous les blocs. Elle est manipulable par toutes les instructions. Elle ne doit pas être
déclarée une autre fois dans le bloc.
Si une variable globale est à nouveau déclarée dans un bloc, cette nouvelle déclaration provoque la création
d'une nouvelle variable portant le même nom. Il n'y a aucune ambiguïté pour le compilateur ; les instructions du
bloc où se trouve la nouvelle déclaration utiliseront la variable locale.
Notions sur les constantes
Une constante est l'inverse d'une variable. C'est une valeur fixe qui ne change jamais durant l'exécution du
programme. Elle peut être entière, réelle, caratère, ou chaîne de caractères, comme les variables.
Les constantes font partie du langage C. Elles n'ont pas besoin d'être déclarées pour être reconnues par le
compilateur. Leur utilisation permet d'afficher une valeur aux variables, soit directement, soit au travers des
expressions (calculs).
Voici des exemples d'instructions où apparaissent des constantes :
Après ces instructions, les variables sont modifiées. Elles contiennent les valeurs suivantes :
La variable i contient la valeur entière -10
La variable surface_sphere contient la valeur réelle 12.56636 multipliée par le rayon au carré
La variable pseudo contient le texte (ou chaîne de caractères) Isothop
La variable initiale contient la lettre I
Je rappelle à nouveau, une constante n'a pas besoin d'être déclarée. Cependant, dans certains cas, il peut être
intéressant de lui donner un nom afin de rendre le programme plus lisible.L'exemple précédent du calcul de la
surface de la sphère gagnerait un peu en lisibilité s'il s'écrivait de la façon suivante :
|
surface_sphere = 4 * PI * rayon * rayon
| |
Pour que PI représente la valeur 3.14159, il suffit d'en faire la déclaration en début de programme.
Il existe de moyens de déclarer une constante :
Personnellement je préfère utiliser #define.
Le code suivant donne la syntaxe des deux méthodes :
|
/* declaration_contante.c */
#include <stdio.h>
#define PI 3.14159
main ()
{
const int COEFF=4 ;
float surface, rayon ;
printf("Rayon de la sphère : ") ;
scanf("%f",&rayon)
surface = COEFF * PI * rayon * rayon ;
printf("La surface est : \n",surface) ;
}
| |
L'exécution du programme donne :
|
Rayon de la sphère : 2.5
La surface est : 78.539749
| |
La méthode la plus utilisée dans le langage C est celle du #define.
Une autre utilisation de la déclaration des constantes est le "paramétrage" du programme. Cela consiste à écrire
le programme de manière à pouvoir modifer facilement une valeur constante qui pourrait quand même évoluer
un jour.
Les directives de compilation
Comme je viens de le dire plus haut, les directives de compilation sont des instructions données au compilateur.
Le compilateur va modifier le code C selon les directives de compilation, avant de le traduire en binaire.
Leur syntaxe est très différente des instructions habituelles du C, car ce ne sont pas des instructions de
programmation, mais des instructions de modification du programme source.
Les différentes directives de compilation sont les suivantes :
#define
#inclde
#undef
#if
#ifdef
#ifndef
#elif
#else
#line
#error
#pragma
La compréhension de la plupart d'entre elles nécessite d'avoir assimilé les mécanismes évolués, comme les tests
et les boucles.
La directive #define
La directive #define sert principalement à déclarer des constantes. Elle est utilisée plus haut pour déclarer la
constante PI. Toutes les occurences du mot PI ont été remplacées dans le code par la valeur 3.14159. Il s'agit
donc bien d'une réécriture du code.
A l'inverse, la syntaxe de la variable COEFF, devenue non modifiable par l'application du qualificateur const,
reste inchangée dans ce code. C'est une variable du langage C et non une instruction de réécriture donnée au
compilateur.
La directive #include
Comme toutes les directives, #include modifie le programme source avant la traduction en binaire. Elle indique
d'inclure un code à l'endroit précis où elle se trouve. C'est une sorte de copier-coller effectué par le compilateur.
Les fichiers "include" sont généralement des fichiers de déclaration de variables, de constantes ou de fonctions.
Puisque le fichier à inclure contient avant tout des déclarations, la directive se place naturellement en tête du
programme. L'extension du fichier à inclure est par convention .h pour "header".
Il existe deux syntaxes de cette directive :
#include <fichier>. Le fichier dont le nom apparaît entre ces signes < > est recherché dans un
répertoire système. Dans l'environnement UNIX, tous les fichiers "include" sont situés dans le
répertoire /usr/include.
#include "fichier". Le fichier dont le nom apparaît entre les guillemets est recherché à partir du
répertoire dans lequel est lancé la compilation. Si le nom de fichier est précisé en syntaxe absolue avec
une hiérarchie, le fichier est recherché dans le répertoire indiqué.
La procédure d'affichage printf()
La procédure printf() affiche les données à l'écran. Elle admet comme argument un format d'affichage, suivi
éventuellement d'une liste de variables. Le format est un texte (chaîne de caractères) contenant des parties fixes
et des parties variables. Ce code affiche une partie fixe :
La forme utilisant un format fixe affiche un texte simple à l'écran. Ce texte est encadré par des guillemets dans la
syntaxe de printf().
Voici un code avec une partie variable :
|
prinft("Le résultat de %d+%d=%d",i,j,k) ;
| |
Cette forme permet d'afficher un texte dont certaines sont variables. Lors de l'affichage à l'écran, ces valeurs
apparaissent à l'emplacement précis où se trouvent les codages commençant par le caractère %. Le format %d
affiche un entier. Chaque format %d doit correspondre à une variable de la liste. Le premier codage affiche la
valeur de i, le second celle de j et la dernière celle de k.
|
/!\ Le premier codage affiche la valeur du premier élément de la liste et ainsi de suite.
| |
Voici un programme qui va vous expliquer tout ça :
|
/* fomat_d'affichage */
#include <stdio.h>
/* déclaration du bloc main */
main()
{
/* déclaration des variables */
int i,j,k ;
i = 10 ;
j = 20 ;
k = 30 ;
/* format d'affichage correct */
printf("Premier affichage : %d %d %d\n",i,j,k") ;
/* pas assez de codage dans le format */
printf("Deuxième affichage : %d %d\n",i,j,k") ;
/* trop de codage dans le format */
printf("Troisième affichage : %d %d %d %d\n",i,j,k") ;
}
/* ----- EOF ----- */
| |
L'exécution du programme donne :
|
Premier affichage : 10 20 30
Deuxième affichage : 10 20
Troisième affichage : 10 20 30 1075117868
| |
Comme vous avez pu le constater, un caractère entré ne s'est pas affiché. Il s'agit du \n. C'est un saut de ligne.
L'affichage du saut de ligne à l'écran utilise un codage particulier.
|
printf ("Bonjour") ;
printf ("Hello") ;
printf ("Bonjour\n") ;
printf ("Hello") ;
| |
Le premier code affichera :
Tandis que le second :
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
Informations
Cet article a été écrit par Isothop.
Email:isothop@darkalpha.com
Website:www.Dakalpha.com
|