PROGRAMMER EN LANGAGE C
Plan du cours (cliquer sur un lien pour aller
directement sur la partie qui vous intéresse)
I-GENERALITES SUR LA PROGRAMMATION
ALGORITHMIQUE
II-GENERALITES SUR LE
LANGAGE C
III-STRUCTURE D’UN
PROGRAMME EN C
IV-LES VARIABLES ET LES CONSTANTES
V-LES INSTRUCTIONS D’ENTREE/SORTIE
VII-LES STRUCTURES DE CONTROLE
VIII-LES TABLEAUX EN LANGAGE C
IX-LES FONCTIONS EN
LANGAGE C
I:GENERALITES SUR LA PROGRAMMATION
ALGORITHMIQUE
1-Les langages de programmation
Les programmeurs
utilisent des langages de programmation pour écrire leurs programmes.
Un langage de programmation est un
ensemble normalisé des règles d’écriture du programme informatique.
Il existe plusieurs
types de langages de programmation qui ont évolué avec le temps et l’avancée
des ordinateurs :
1.1- Langage machine
Le langage
machine est le langage spécifique de
l’ordinateur, dans lequel les instructions sont exprimées en code binaire. Le
processeur exécute les instructions du programme sous forme de chiffres 0 et 1
(bit). C’est le langage binaire.
Par exemple, lorsque
l’ordinateur veut effectuer la somme 3+5. Un codeur binaire transforme le 3 décimal en 0011 binaire et 5
décimal en 0101 binaire pour un mémoire de 4 bits, l’opération à effectuer
devient par la suite :
Un décodeur
binaire transforme le résultat binaire
(1000) en décimal (8).
L’ordinateur ne connait que le
langage binaire !!!
Comme le langage machine utilisé par
les ordinateurs ainsi que tous les circuits numériques n’est pas du tout
compréhensible par les humains, les informaticiens ont inventé de nouveaux
langages compréhensibles par les humains et faciles à utiliser qui seraient
ensuite traduits en langage binaire par des logiciels spécialisés : ce
sont les langages de haut niveau ou langages
évolués.
1.2- Langage de haut niveau
Un langage
de haut niveau est un langage
indépendant du type d’ordinateur dans lequel les instructions sont exprimées de
façon proche du langage humain. Plus le niveau d’un langage est haut, plus il
se rapproche du langage humain donc facile à utiliser, et plus il s’éloigne du
langage machine. Les langages de bas niveau sont plus proches du langage
machine et plus complexes au niveau de la programmation.
On peut distinguer deux grands types de
langages évolués : les langages interprétés et les langages compilés.
·
Langages interprétés : Le code source est interprété par un
logiciel appelé interpréteur.
Celui-ci va utiliser le code source et les données d’entrée pour calculer les
données de sortie. L’interpréteur va exécuter les instructions ligne par ligne,
en décidant à chaque étape de ce qu’il va faire par la suite.
Exemples : java, python, JavaScript, php, ruby, etc.
Avantages : le code source d’un langage interprété peut
marcher directement avec tout ordinateur. Ils sont plus flexibles, le code est
plus leger, plus simple à écrire.
Inconvénients : ils sont moins rapides car ils exécutent les
instructions ligne après ligne. Ce qui pose problème pour créer des logiciels
rapides, des jeux vidéo et des systèmes d’exploitation.
·
Langages compilés : Le code source est d’abord compilé, par un
logiciel appelé compilateur,
c.-à-d. traduit en code binaire, très facile à lire par l’ordinateur.
C’est alors directement le Système d’exploitation qui va utiliser le code
binaire et les données d’entrée pour calculer les données de sortie.
Exemple :
C, C++, Pascal, etc.
Un compilateur
est donc un programme informatique qui
traduit en langage machine un programme établi en langage évolué. Le passage du
langage évolué en langage machine est transparent pour l’utilisateur, seule la
machine contrôle toutes les opérations.
Avantage : Le langage compilé est plus rapide car
directement exécuté sur l’ordinateur. Globalement les langages compilés sont
plus performants.
Inconvénient : Il faut un compilateur pour chaque
machine. De plus, avec un langage compilé il faut (en général) tout recompiler
à chaque modification, ce qui pose d’énormes soucis (peut durer plusieurs
heures). Les langages compilés sont plus complexes : plus dure à
apprendre, plus de lignes de codes. Ils dépendent de votre plateforme.
1.3- Langage d’assemblage
Un
langage d’assemblage ou assembleur en programmation informatique, est un
langage de bas niveau, plus proche du langage machine, qui peut être
directement interprété par le microprocesseur de l’ordinateur tout en restant
lisible par un humain.
Les combinaisons de bits du langage
machine sont représentés par des symboles dits « mnémoniques »
c.-à-d. faciles à retenir. L’assembleur convertit ces mnémoniques en langage
machine, ainsi que les valeurs (écrites en décimal) en binaire et les libellés
d’emplacement en adresse, en vue de créer par exemple un fichier objet ou un
fichier exécutable.
Avantage :
-Le langage le plus facile à convertir est l’assembleur car
il possède quasiment les mêmes instructions que le langage machine, donc il est
plus rapide par rapport aux langages de haut niveau.
-Il offre la possibilité de traduire le code dans les deux
sens (langage d’assemblage↔ langage machine) sans perte d’informations.
Inconvénient : L’assembleur diffère d’une machine à une
autre, bien que les instructions soient au bout de compte très semblables. Ce
sont des informaticiens chevronnés qui programment en assembleur.
2- Installer un IDE
Pour écrire
un programme informatique, il faut :
-un éditeur de texte qui permet d’écrire le code source.
-un compilateur qui permet de traduire le code source en
binaire.
-un debugger qui permet de rectifier les erreurs commises
par le programmeur.
Il existe des
solutions « trois-en-un » qui offrent des plateformes complètes
contenant ces trois outils appelé IDE (Integrated Development
Environment) ..
Parmi les IDE les plus connus, on peut citer : Code :: Blocks,
qui fonctionne sur Windows, Mac et Linux ; Visual C++ ou Visual
Studio Express qui fonctionnent
uniquement sur Windows, Xcode qui fonctionne sur Mac/OS uniquement.
Pour les applications mobiles : Xcode
pour les Système d’exploitation iOS, Android Studio ou Eclipse pour Android,
Visual studio pour Windows Phone
Les IDE permettent de développer
d’autres logiciels, certains IDE contiennent aussi des simulateurs permettant
de tester l’exécution des logiciels.
Mais on utilise généralement en C
comme outil de programmation, un programme « trois-en-un » qui
combine éditeur de texte, compilateur et débogueur : c’est un IDE.
Dans ce cours nous allons utiliser Code ::Blocks. C’est un IDE libre et gratuit et téléchargeable à partir du lien http://www.codeblocks.org/downloads/binaries
Téléchargez le logiciel en
prenant le programme qui contient mingw dans le
nom (ex. :
codeblocks‐20.03mingw-setup.exe
). Certaines versions ne contiennent pas ce fichier, ce qui cause
beaucoup de désagréments. L'installation est très simple et rapide. Laissez
toutes les options par défaut et lancez le programme. A la fin de
l’installation, la fenêtre de code ::blocks
s’ouvre :
On distingue 4 grandes
sections dans la fenêtre, numérotées sur l'image :
1.la barre d'outils : elle
comprend de nombreux boutons,
2. la liste des fichiers du
projet : c'est à gauche que s'affiche la liste de tous les fichiers source de
votre programme;
3. la zone principale :
c'est là que vous pourrez écrire votre code en langage C ;
4.la zone de notification :
aussi appelée la « zone de la mort », c'est ici que vous verrez les erreurs de
compilation s'afficher si votre code comporte des erreurs.
II:
GENERALITES SUR LE LANGAGE C
1-Historique
Le langage C est un langage de programmation
évolué très populaire. Il est créé dans les années 1970 par Dennis
Ritchie. C’est un langage
incontournable qui a beaucoup inspiré beaucoup d’autres langages.
2-Compilateur
Le langage C est
un langage compilé c-à-d qu’il a besoin pour fonctionner d’un programme appelé compilateur qui va traduire le code source en langage
machine (langage binaire). Le compilateur C utilisé sous UNIX s’appelle cc, cependant on utilisera de préférence le
compilateur gcc du projet GNU, système d’exploitation sous licence libre (open source).
3-Versions du langage C
Il n’existe pas à proprement parler des versions du langage C, mais les
versions améliorées ont été baptisées le langage C++ et C#. Le C++ et le C# de
Microsoft ne sont rien d’autre que le langage C avec des ajouts permettant de
programmer de manières différentes.
III:STRUCTURE D’UN PROGRAMME EN C
1-Structure de base
Un programme en C comprend les
parties suivantes :
|
[Directives du
préprocesseur] [Déclaration des variables
externes] int main ( )
//fonction principale { [Déclaration des
variables internes à cette fonction] [Instructions] return 0 ; } |
1.1- Les directives du préprocesseur
Les
premières lignes d’un code en langage C, reconnaissables par le symbole # au
début de la ligne, sont des lignes spéciales qu’on appelle directives du
préprocesseur. Elles sont lues par un
programme appelé préprocesseur,
un programme qui se lance au début de la compilation. Son rôle est d’exécuter
les instructions spéciales qu’on lui a fournies dans les directives de
préprocesseur.
Ces lignes
comprennent des fichiers sources tous prêts à être utilisés, disponibles
sous forme précompilé dans l’IDE appelés bibliothèques (librairies en anglais). Ces fichiers contiennent des
codes prêts qui permettent entre autres de gérer les opérations d’entrée/sortie
(stdio.h), d’exécuter les opérations de conversion, l’allocation des mémoires, le
contrôle des processus, le tri, la recherche (stdlib.h), d’effectuer des calculs (math.h), de
manipuler des chaines de caractère (string.h), créer des interfaces à base de texte (conio.h), etc.
Afin de
pouvoir les utiliser, il faut les inclure dans les
programmes c-à-d les insérer au projet pour la compilation. Pour le faire, on
utilise include, précédé d’un # et suivi du
nom du fichier à inclure, de la
forme suivante :
#include <nomFichier.h> // nomFichier désigne le nom du
fichier à inclure.
1.2-Déclaration des variables externes
Il s’agit
ici des variables accessibles à toutes les fonctions du programme ou variables globales. Ces variables doivent être placées en dehors de toute fonction pour
pouvoir être utilisées par toutes les fonctions.
Remarque : A
l’intérieur de chaque fonction, on déclare seulement les variables utiles pour
cette fonction ou variables locales.
1.3-La fonction principale
Un programme en langage C
est essentiellement constitué des fonctions. Il contient toujours une
fonction principale, la fonction main ().
|
int main ( ) { //Déclaration des
variables internes à la fonction principale //Instructions return 0 : } |
·
Les instructions
A l’intérieur des accolades de la fonction, se trouvent les instructions. Les instructions sont des ordres qu’on donne à l’ordinateur pour faire
un travail précis. Un programme informatique n’est qu’une suite d’instructions.
Toute instruction se termine obligatoirement par un point-virgule.
·
Les commentaires
Les commentaires sont
des annotations faites par le développeur pour expliquer le fonctionnement
d'une instruction ou même d'un groupe d'instructions. Les commentaires ne
gênent pas l'exécution d'un programme. Il existe deux types de commentaires :
les commentaires de fin de ligne, et les commentaires multilignes.
-Commentaires de fin de ligne
Ils servent à commenter une instruction. Un tel commentaire
commence par deux slashs, suivis du commentaire :
// Texte du commentaire
-Commentaires multilignes
Ce type de commentaire permet d'écrire beaucoup plus de
texte, tout en permettant les retours à la ligne. Un commentaire multiligne
commence par /* et se termine par */ :
Il sera aussi possible d'inclure des
commentaires sur plusieurs lignes avec le code
/* commentaire
sur plusieurs lignes */
Remarque :
Un projet complet est généralement constitué
de plusieurs autres fonctions créées par le programmeur pour exécuter des
tâches précises et répétitives. Un vrai projet peut contenir des centaines de
fonctions.
2-Comment créer un nouveau projet
Pour créer un nouveau projet :
·
Dans l’application Code ::Block,
Cliquer sur Nouveau projet,
·
Choisir le mode Console Application, puis
cliquer sur Next,
·
Choisir C,
·
Saisir le nom du projet, puis sur next
·
Cliquer sur Finish
3-Un premier programme en c
3.1-Le code de base
Le langage C contient toujours
un « code minimal » qui sert de code de base pour la plupart des
programmes.
|
1 #include< stdio.h> 2 #include< stdlib.h> 3 4 int main ( ) 5 { 6 //insérer
les instructions ici 7 return 0; 8 } |
Dans ce code minimal généré
par l’IDE, nous avons :
- Une seule fonction, la
fonction principale main ().
-Deux directives du préprocesseur qui sont stdio.h et stdlib.h :
·
stdio.h contient du code tout prêt à être utilisé
dans les opérations d’entrée/sortie
telle que l’affichage du texte à l’écran.
·
stdlib.h déclare des fonctions qui effectuent la
conversion des nombres, la gestion de la mémoire et d’autres tâches.
Ces fichiers existent déjà, tous prêts à
l’emploi. Notons qu’on peut
inclure autant de fonctions en-tête que le programme l’exige (ici deux
seulement sont nécessaires).
-Les lignes à l’intérieur
d’une fonction sont des instructions.
-return 0
indique qu’on arrive à la fin de la fonction main () et demande de renvoyer la valeur 0. return 0 n’est pas
obligatoire, on peut souvent l’omettre selon les compilateurs.
-La ligne 4 peut aussi s’écrire : int main
(int argc, char*argv[ ])
Remarques :
·
Il est
conseillé de terminer chaque fichier par une ligne vide. On l’obtient en tapant
sur la touche Entrée après la
dernière accolade.
·
Pour tester
ce programme, il faut cliquer sur l’icône Build & Run. Il compile le projet et l’exécute.
3.2-Les caractères spéciaux
·
\n : retour à la ligne
·
\v : tabulation verticale
·
\t : tabulation horizontale
·
\b :
retour arrière
·
\f ; saut
de page
·
\r : return (retour au début de la ligne,
sans saut de ligne)
·
\a : signal d’alerte (signal acoustique)
NB : Il faut éviter les
accents dans le code.
IV :
LES VARIABLES ET LES CONSTANTES
1-Les
variables
1.1-Définitions
Une variable est un espace de stockage permettant
d'enregistrer tout type de donnée, que ce soit une chaîne de caractères, une
valeur numérique ou bien des structures un peu plus particulières.
Une
variable est constituée de deux éléments :
·
Une valeur :
c’est le nombre qu’elle stocke.
·
Un nom :
ce qui permet de la reconnaitre.
Les identificateurs sont des noms qui permettent de désigner un
objet manipulé dans le programme : variables et fonctions principalement.
Le
nom d’une variable doit respecter certaines conditions en langage C :
-Il ne peut y avoir que des lettres
minuscules, lettres majuscules et des chiffres.
-Il doit commencer par une lettre.
-Les espaces sont interdits. A la
place, on peut utiliser un caractère « underscore » :
ou barre de 8.
-On ne doit pas utiliser les
accents.
Exemples : nom_visiteur ; nomVisiteur, nomDuVisieur
On rappelle que le
langage C est sensible à la casse, c-à-d que les majuscules et les
minuscules doivent être respectées. Ainsi fonction,
Fonction ou foncTion sont trois noms différents
en C.
1.2-Types de variables
Le langage C est un langage typé c-à-d que toute variable, constante ou
fonction est d’un type précis. Le type d’un objet définit la façon dont il est
représenté en mémoire.
Les
principaux types de base existant en langage C sont :
-Les types entiers (bâtis autour du mot-clé int) permettent de représenter les nombres
entiers ; Le type
int
peut être précédé d’un attribut de précision (short ou long) et/ou d’un
attribut de représentation (unsigned).
-Les types réels (mot-clé float
ou double) permettent de représenter les nombres réels (parfois appelés
« flottant » en informatique) tels que les nombres avec virgule.
-Le type octet (mot-clé char) permet de représenter les variables occupant un seul octet, en
particulier les caractères ; il s’agit en réalité d’un type entier car
chaque caractère est converti en chiffre par le code ASCII. Quand une variable
char est utilisée
pour stocker un caractère, elle peut prendre toutes les valeurs du code ASCII,
soit 256 valeurs. La façon la plus simple de lui donner une valeur consiste à
le placer entre apostrophes ‘ ‘, ou si c’est possible, à donner son code ASCII
hexadécimal.
Par exemple, lorsque l’on tape la lettre A, la table ASCII effectue la conversion de
A en 65 en décimal.
|
Nom du type |
Minimum |
Maximum |
|
Char |
-127 |
127 |
|
Int |
-32767 |
32767 |
|
Float |
-1x1037 |
1x1037 |
|
Double |
-1x1037 |
1x1037 |
·
Char (8bits)
et int (32
bits) permettent de stocker des nombres entiers :1 ; 2 ;
3 ; …
(short
est un entier court (16 bits) long est un entier long (64 bits)
·
float et double
permettent de stocker des nombres décimaux (appelés aussi flottants) : 12,4 ; 235,45….
Ces types sont dits « signés »
car ils sont positifs et négatifs. Il existe aussi des types dits « unsigned » (non signés) qui ne peuvent
stocker que des entiers positifs. Pour les utiliser, il suffit d’écrire le mot unsigned devant
le type :
|
unsigned char |
0 à 255 |
|
unsigned int |
0 à 65535 |
|
unsigned long |
0 à
4294967295 |
En résumé, on fera surtout la distinction entre nombres entiers et
flottants :
·
Pour un
nombre entier, on utilisera le plus souvent int.
·
Pour un nombre
flottant, on utilisera généralement double.
1.3-Déclarer une variable
Déclarer
une variable, c’est réserver de l’espace dans la mémoire de l’ordinateur. Il
suffit dans l’ordre :
-d’indiquer le type de la variable
que l’on veut créer
-d’insérer un espace
-d’indiquer le nom qu’on veut donner
à la variable
-de ne pas oublier le point-virgule.
Syntaxe :
typenom_de_la_variable ;
Exemple :
intnombreVisiteurs ; //la
variable appelée nombreVisiteur
est un entier
·
On peut
déclarer plusieurs variables d’un même type
int a,b,c ;
·
Les
déclarations des variables se font au début des fonctions.
Exemple:
|
#include< stdio.h> #include< stdlib.h> int main ()
//
Equivalent de int main() { int nombreVisiteurs ;
//on déclare la variable ……………………………………………. //insérer les instructions ici return 0; } |
1.4-Affecter une valeur à une
variable
·
Pour donner
une valeur à une variable
Syntaxe :
type nomDe LaVariable = valeurDeLaVariable
Exemple :
·
On
peut procéder en deux temps
int nombreVisiteurs ;
nombreVisiteurs =10; //on vient d’affecter
la valeur 10 à la variable.
·
Mais c’est
toujours mieux d’initialiser chaque variable dès qu’on la déclare c.-à-d. lui
attribuer une valeur au moment de sa définition.
Int nombreVisiteurs=10 ;
1.5-La portée des variables
Les variables ont une
portée dans le programme c-à-d qu’elles ne peuvent pas être accessibles
n’importe où dans un programme. Elles n’ont pas toutes la même durée de vie. On
distingue deux catégories de variables
1.5.1-Les variables globales.
On
appelle variable globale une variable déclarée en dehors de toute fonction. Les
variables globales sont systématiquement permanentes. Elles sont accessibles
dans toutes les fonctions du programme.
Exemple :
|
Int nombre=3 Int triple(void) { Return nombre*3 ; } Int main(void) { Nombre=triple () ; printf (« %d », nombre) ; return 0 ; } |
Dans ce code, la variable nombre a
une portée au niveau du fichier et peut par conséquent être bien utilisée dans
la fonction triple () que dans la fonction main ()
1.5.2- Les variables locales
On
appelle variable locale toute variable déclarée à l’intérieur d’une fonction
(ou d’un bloc d’instructions) du programme. Par défaut les variables locales
sont temporaires, elles n’existent que pendant que la fonction est exécutée. A
la sortie de cette fonction, elles sont perdues. De même, une variable locale
d’une fonction n’est accessible qu’à l’intérieur de cette fonction, on ne peut
pas accéder à cette variable depuis une autre fonction.
Exemple :
|
int main(void) { { int nombre=10 ; printf (« %d\n », nombre) ; } printf (« %d\n », nombre) ; return 0 ; } |
Dans ce code, la variable nombre est déclarée dans un sous-bloc.
Sa portée est donc limitée à ce dernier et elle ne peut pas être utilisée en
dehors.
Remarques :
1-Les variables locales à une
fonction ont une durée de vie limitée à une seule exécution de cette fonction.
Leurs valeurs ne sont pas conservées d’un appel au suivant. Toutefois il est
possible de créer une variable locale de classe statique en faisant précéder sa
déclaration du mot-clé static.
Syntaxe :
static type
nom- de -variable ;
Elle reste locale à la
fonction dans laquelle elle est déclarée, mais sa valeur est conservée d’un
appel au suivant. Elle est également initialisée à zéro à la compilation et ne
peut donc entrer en conflit avec les autres variables du programme.
2-Les variables locales n’ont en
particulier aucun lien avec des variables globales de même nom, surtout si
elles ont des portées différentes.
Exemple :
|
int nombre=10 ; int main(void) { int nombre=20 ; printf (« %d\nombre) ; return 0 ; }. |
2-Les constantes
2.1-Définitions
Une constante est un
objet dont la valeur ne change pas au cours de l’exécution d’un programme.
Il existe en C des constantes
littérales et des constantes symboliques. Dans le cadre de ce cours nous allons
nous intéresser aux constantes symboliques définies par le programmeur.
2.2-Délarer une constante
·
Constante déclarée avec le modificateur const
Ces
constantes sont des variables dont la valeur n’est pas modifiable, sauf au
niveau de leurs déclarations. Pour les déclarer, il suffit d’utiliser le mot const, juste devant le type quand on déclare la constante. Par convention, les noms
des constantes sont écrits en majuscules.
Syntaxe :
const type
nomDeLaConstante=valeurDeLaConstante
Exemple :
const int NOMBRE=5 ;
·
Constante préprocesseur
#define est une directive de
préprocesseur qui permet de définir une constante préprocesseur. Elle
est différente des simples constantes car elle permet de remplacer une variable
directement par sa valeur dans un code, tout comme la fonction Rechercher/Remplacer de Microsoft Word.
Exemple :
#define MAX 100
Voudrait dire que
chaque fois que le préprocesseur rencontre le mot MAX, il le remplace par le
nombre 100. Notez qu’il n’y a pas de point-virgule ici.
·
Constante énumérée
L’énumération est une suite de constantes renfermées dans une seule.
enum DIRECTION
{NORD, SUD, EST, OUEST} ;
enum définit les identificateurs NORD, SUD, EST, OUEST
comme étant des constantes de type int et leur donne par défaut respectivement les
valeurs 0,1,2,3. On peut donner des
valeurs particulières à ces constantes, par exemple :
enum DIRECTION
{NORD=10, SUD=20, EST=30, OUEST=40}
Si on donne une seule valeur, le
reste sera obtenu par incrémentation de 1, si on ne donne aucune valeur, par
défaut la première valeur sera zéro.
V:
LES INSTRUCTIONS D’ENTREE/ SORTIE
1-Les
instructions de sortie
1.1-Instruction de sortie formatée : printf
·
Afficher du texte
On utilise printf pour afficher du texte. C’est une fonction
qui est incluse dans les bibliothèques citées au début du programme, surtout
dans stdio.h. Ce fichier en-tête contient des informations nécessaires au
compilateur pour vérifier la bonne utilisation des fonctions d’entrée/sorties
comme printf.
Syntaxe :
printf (« texte
à afficher ») ;
Exemple :
printf (« Bienvenue sur ma page ») ;
|
Le code minimal devient : #include< stdio.h> #include< stdlib.h> int main () { printf
(« Bienvenue sur ma page ») ; return 0; } |
·
Afficher le contenu d’une variable
On utilise printf de la même manière, sauf qu’on ajoute un
symbole spécial à l’endroit où on veut afficher la variable. Les spécifications
de format ont pour but d’annoncer le format des données à visualiser. Elles
sont introduites par symbole % suivi d’un caractère désignant le format
d’impression. Le symbole spécial indique le format ou le type de variable qu’on
veut afficher. Après avoir
indiqué un endroit précis où on voudrait afficher le contenu de la variable, il
faut ensuite préciser cette variable.
Syntaxe :
printf («
format », nomDeLaVariable) ;
Exemple :
Int nombreVisiteurs=5 ;
printf (« On
a obtenu %d visiteurs », nombreVisiteurs) ; //
On lira : On a obtenu 5 visiteurs.
Le %d sera remplacé par la variable
indiquée après la virgule, à savoir nombreVisiteurs.
·
Lorsqu’il y
a plusieurs valeurs, il suffit d’indiquer d’abord les symboles spéciaux là où
on veut, ensuite les variables correspondantes dans le même ordre,
séparées par des virgules.
Exemple :
intnombreVisiteurs=5 ;
intnombrePeriodes=2 ;
printf (« on a obtenu %d visiteurs repartis sur %d périodes », nombreVisiteurs, nombrePeriodes) ;
// on lira : on a obtenu 5 visiteurs repartis sur 2 périodes
Il existe plusieurs
symboles :
|
Format |
Type attendu |
|
Format |
Type attendu |
|
%d |
Int |
|
%u |
Unsigned int |
|
%ld |
Long |
|
%hd |
short |
|
%f |
Float |
|
%hu |
Unsigned short |
|
%f |
Double |
|
%lu |
Unsigned long |
|
% lf |
LongDouble |
|
%c |
char |
|
%s |
String |
|
|
|
·
Afficher un caractère
On utilise toujours la fonction printf, mais cette fois avec le symbole %c (c comme caractère)
Exemple :
|
int main () { char lettre=’A’ ; printf («%c\n »,lettre) ;
//Affiche A return 0 ;
} |
Donc, malgré que le
type char stocke les
nombres, on peut l’utiliser pour stocker une lettre, tout simplement parce
qu’il y a une table que l’ordinateur utilise pour convertir les lettres en
nombres et inversement, la table ASCII évoquée plus haut. Il faut bien
évidemment utiliser les apostrophes pour obtenir la valeur ASCII d’une lettre.
|
int main () { char
lettre=’A’ ; printf (« %d\n », lettre) ;
//Affiche 65 return 0 ; } |
1.2-Instructions de sortie non formatées : put () et putchar ()
·
puts effectue l’écriture d’une chaine de
caractères sur l’écran.
Exemple :
puts ("Bonjour Monsieur") ;
·
putchar effectue l’écriture d’un caractère
sur l’écran.
Exemple :
char lettre='A'
;
putchar (lettre); //affiche A
2-Les instructions d’entrées
2.1-Instruction d’entrée
formatée : scanf
Pour demander à l’utilisateur
d’entrer quelque chose dans la console, on va utiliser la fonction scanf.
Mais il faut d’abord mettre le format pour indiquer ce que l’utilisateur doit
entrer (un int, un float,..)
Il faut ensuite indiquer le nom de la variable qui va recevoir ce que
l’utilisateur va saisir.
Syntaxe :
scanf
(« format »,&variable-qui-contiendra_notre-valeur) ;
Exemple:
int age=0;
scanf
(« %d », &age);
Lorsque le programme
arrive à un scanf, il se met en pause et attend que
l’utilisateur entre quelque chose, ici un nombre. Ce nombre sera stocké dans la
variable age.
NB : On doit mettre le %d entre guillemets et ajouter le symbole & devant le nom de la variable qui va
recevoir la valeur.
Attention : Pour récupérer un float dans le cas d’un scanf, c’est le format « %f » qu’il faut utiliser, mais pour le type double, c’est plutôt le format « %lf »,
contrairement au printf, pour lequel
on utilise %f dans les deux cas.
Exemple :
doublepoids=0 ;
scanf (« %lf »,
&poids) ;
Exercice d’application 1 :
Ecrire en C un programme qui demande
l’âge et l’affiche.
|
#include< stdio.h> #include< stdlib.h> int main ()
// Equivalent de int main() { int age=0 ; printf (« Quel age
avez-vous ? ») ; scanf (« %d », &age) ; // on
demande d’entrer l’âge printf (« Vous avez donc %d ans !\n\n », age); return 0; } |
Remarque :
·
Si vous
entrez un nombre décimal, seule la partie entière sera conservée.
·
Si
vous tapez des lettres, le programme affichera 0, la valeur initialisée. On
peut aussi demander à l’utilisateur d’entrer une lettre en utilisant %c dans un scanf.
Exercice d’application 2 : Ecrire en C un programme qui demande un
caractère et l’affiche.
|
int main () { char lettre=’0’ ; scanf (« %c »,&lettre) ; printf (« %c\n », lettre) ; //Affiche
la lettre B si on tape B return 0 ; } |
2.2-Instructions d’entrées non formatées : get
() et getchar ()
·
gets effectue la lecture d’une chaine de
caractères à partir du clavier.
Exemple :
|
char nom [100] ; printf ("Quel est votre nom svp?") ; gets (&nom) ; printf ("votre nom est : %s », &nom) |
;
·
getchar effectue la lecture d’un caractère à partir
du clavier.
Exemple :
|
char x ; printf ("Entrer un caractere")
; x = getchar () ; printf ("Voici le caractere entre") ; putchar (x) ; |
VI:
LES OPERATEURS
1- Les
opérateurs de calcul
Dans les exemples, la valeur
initiale de x sera toujours égale à 11.
|
Signe
|
Nom |
Signification |
Exemple |
Résultat |
|
+ |
Plus |
Addition |
X+3 |
14 |
|
- |
Moins |
Soustraction |
x-3 |
8 |
|
* |
Multiplication |
multiplié par |
x*2
|
22 |
|
/ |
Division |
divisé par |
x.0/2.0 |
5.5 |
|
% |
Modulo |
reste de la division par |
x%5 |
1 |
|
= |
affectation |
a la valeur |
x=5 |
5 |
·
Pour la division, il faut d’abord transformer les
nombres entiers en décimaux. Ainsi, au lieu de poser 5/2, il faut plutôt poser
5.0/2.0 pour avoir 2.5.
·
Le modulo est une opération mathématique qui permet
d’obtenir le reste d’une division. Ainsi, 5%2 donne 1 car 1 est le reste de la
division de 5 par 2.
2- Les opérateurs de
comparaison
|
Signe
|
Nom |
Exemple |
Résultat |
|
== |
Egal |
X==11 |
True |
|
< |
Inferieur |
X<11 |
False |
|
<= |
Inférieur ou égal |
x<=11
|
True |
|
> |
Supérieur |
x>11 |
False |
|
>= |
Supérieur ou égal |
x>=11 |
True |
|
!= |
Différent
|
x!=11
|
False |
Important. On confond
souvent le = et le == (deux signes =). Le = est un opérateur d'attribution de
valeur tandis que le == est un opérateur de comparaison. Cette confusion est
une source classique d'erreur de programmation.
3- Les opérateurs associatifs
On appelle
ainsi les opérateurs qui réalisent un calcul dans lequel une variable
intervient des deux côtés du signe = (ce sont donc en quelque sorte également
des opérateurs d'attribution).
Dans les
exemples suivants x vaut toujours 11 et y aura comme valeur 5.
|
Signe |
Description |
Exemple |
Signification |
Résultat |
|
+= |
Plus égal |
x += y |
x = x + y |
16 |
|
-= |
Moins égal |
x -= y |
x = x – y |
6 |
|
*= |
Multiplié égal |
x *= y |
x = x * y |
55 |
|
/= |
Divisé égal |
x /= y |
x = x / y |
2.2 |
4 -Les opérateurs logiques
Aussi
appelés opérateurs booléens, ces opérateurs servent à vérifier deux ou
plusieurs conditions.
|
Signe |
Nom |
Exemple |
Signification |
|
&& |
Et |
(condition1)
&& (condition2) |
condition1 et condition2 |
|
|| |
Ou |
(condition1)
|| (condition2) |
condition1 ou condition2 |
|
! |
Non |
|
|
5- Les opérateurs
d'incrémentation
Ces
opérateurs vont augmenter ou diminuer la valeur de la variable d'une unité. Ce
qui sera fort utile, par exemple, pour mettre en place des boucles.
Dans les exemples x vaut 3.
|
Signe |
Description |
Exemple
|
Signification |
Résultat |
|
x++ |
Incrémentation |
y = x++ (x++ est le même que x=x+1) |
3 puis plus 1
|
4 |
|
x- - |
Décrémentation |
y=
x- - (x-- est le même que x=x-1) |
3 puis moins 1
|
2 |
6- La priorité des opérateurs
Les
opérateurs s'effectuent dans l'ordre suivant de priorité (du degré de priorité
le plus faible ou degré de priorité le plus élevé).
Dans le cas d'opérateurs de
priorité égale, de gauche à droite.
|
Opération |
Opérateur |
|
, |
virgule ou séparateur de liste |
|
=, +=, -=, *=, /=, %=
|
Affectation (la plus faible priorité) |
|
? :
|
opérateur conditionnel |
|
|| |
OU logique |
|
&& |
ET logique |
|
==, != |
Égalité |
|
<,<=,>=,> |
Relationnel |
|
+, -
|
addition soustraction |
|
* ,/ ,% |
multiplier diviser modulo |
|
! , ++, --
|
Unaire (opérateur qui fait utilise un seul opérande) |
|
( )
|
Parenthèses (la plus forte priorité) |
VII: LES STRUCTURES DE CONTROLE
1-Structures
conditionnelles
Une
condition permet d'exécuter ou non une série d'instructions. Elle peut être
écrite sous différentes formes : on parle de structures conditionnelles.
1.1 La structure de base « if
...else »
·
Dans sa formulation la plus simple, l'expression if se présente
comme suit :
Syntaxe : forme réduite
if (condition vraie) {
//une ou plusieurs
instructions à exécuter si la condition est vraie
}
·
Si on souhaite exécuter un code suite à la
vérification d’une condition et exécuter un autre code si elle n’est pas
vérifiée, il existe la structure …else.
Syntaxe : forme complète
if (condition vraie) {
Instructions1 ;
}
else {
Instructions2 ;
}
·
Si la condition est vérifiée (true), le bloc
d'instructions 1 s'exécute. Si elle ne l'est pas (false), le
bloc d'instructions 2 s'exécute.
Exemple:
|
#include< stdio.h> #include< stdlib.h> int main () { int age=20; if (age<= 18) { printf ('Vous êtes mineur ') ; } else{ printf ('Vous êtes senior ') ; } return0 ; } |
1.2-La structure « else if »
Elle teste
plusieurs conditions à la fois et exécute leurs codes correspondants. La
structure else if
peut être utilisée plusieurs fois à la suite. Il suffit seulement d’avoir écrit
une condition avec la structure if juste avant.
Syntaxe :
if (condition vraie) {
instructions1;
}
else if {
instructions2;
} else if
{
Instructions3;
}
else {
Instructions4 ;
}
Exemple :
|
#include< stdio.h> #include< stdlib.h> int main () { int température=20 ; if (temperature
<=0) { print (“l’eau est solide”); } else if (0 <temperature && temperature<= 100) { printf (« l‘eau est liquide »); } else if (temperature> 100) { printf (« l‘eau est
vapeur »); } else { printf (« Vous n’avez pas entré une temperature »)
; } return 0 ; } //Affiche :l’eau
est liquide |
Les booléens :
Les
conditions font intervenir les booléens en informatique. Un booléen admet juste deux
valeurs : vrai(true) ou faux
(false) , admis ou refusé, etc.
Exemple1 :
|
if (1) { printf («c’est vrai ») ; } else { printf («c’est faux ») ; } //affiche c’est vrai |
Exemple2 :
|
if (0) { printf («c’est vrai ») ; } else { printf («c’est faux ») ; } //affiche c’est faux |
Si on met 0, le
test affiche faux, si on met 1
ou un autre nombre, le test affiche vrai.
Lorsqu’on
fait une condition avec un if, le programme renvoie la valeur 1 si la condition est vraie, et 0 si la condition est fausse.
On peut
donc dire que les booléens sont le cœur des conditions
if (age>=18)
si age=12 ans, le test est vrai et l’ordinateur remplace (age<=18) par 1.
si age =30 ans, le test est faux et l’ordinateur remplace (age<=18) par 0.
Exemple3 :
|
int age=20 ; int Majeur=0 ; Majeur= age>=18 ; printf (« Majeur
vaut : %d\n »,Majeur) ; |
La
condition age>=18 a renvoyé le nombre 1 car
elle est vraie, du coup la variable Majeur vaut 1,
Si on fait age==10 par exemple, majeur vaudra 0 ; la variable
Majeur est un booléen.
Exemple 4 :
|
int Majeur=1 ; if (Majeur) { printf (« Tu es majeur ! ») ; } else { prinf (« Tu es mineur ») ; } |
Remarques :
i) En langage C, on gère
les booléens avec int.
ii) Le test if
(majeur==1) marche aussi bien.
2-Structures itératives (boucles)
2.1-L’incrémentation
Elle permet
d’ajouter une unité à un nombre au moyen d’une syntaxe courte. A l’inverse, la
décrémentation permet de soustraire l’unité
Exemple :
int number=0 ;
number++;
printf (number; //affiche 1
number--;
printf (number); //affiche 0
NB: number++ signifie
number=number+1 et number—signifie number=number-1
2.2- L'expression for
L'expression
for permet d'exécuter un bloc d'instructions un certain nombre de fois en
fonction de la réalisation d'un certain critère.
Syntaxe :
for (valeur initiale ; condition ; progression)
{
// instructions;
}
Exemple :
|
int i; for (i=0; i<5; i++) { printf (“Ligne n° %d\n:”, i); } |
2.3-While
L'instruction while permet d'exécuter une instruction (ou un
groupe d'instructions) un certain nombre de fois.
Syntaxe :
while (condition vraie) {
//continuer
à faire quelque chose
}
Aussi longtemps que la
condition est vérifiée, le langage C continue à exécuter les instructions entre
les accolades. Une fois que la condition n'est plus vérifiée, la boucle est
interrompue et on continue le programme.
Attention ! Avec ce système de boucle, le
risque existe (si la condition est toujours vérifiée), de faire boucler
indéfiniment l'instruction.
Exemple 1 :
|
Int nombreEntre=0 ; while (nombreEntre ! =47) { printf (« Tapez le nombre 47 ») ; scanf (« %d », &nombreEntre) ; } |
Exemple 2:
|
int i=1; while (i<5) {
printf (“Salut les gars ! \n”) ; i++ ; } printf (‘Fin de la boucle) |
Exemple 3:
|
int i=1; while (i<5) { printf (“La variable i vaut
%d \n”, i); i++; } printf (‘Fin de la boucle) ; |
2.4- Do………..While
Ce type de boucle est similaire à while, la seule chose qui change est la position de la condition.
Au lieu d’être au début de la boucle, la condition est à la
fin.
Exemple :
|
int i=1; do {
printf (“La variable i vaut
%d \n”, i); i++ ; } while (i<5) ; |
Notez le point-virgule après while. C’est une particularité de la boucle do…while.
VIII : LES TABLEAUX EN LANGAGE C
1-Définir un tableau
Un tableau est constitué d’une suite
de variables pouvant contenir plusieurs nombres du même type (long, int, char,
double…).
Syntaxe :
type nomDuTableau [tailleDuTableau]
Exemple :
int tab [5] ; où 5 est le nombre
de cases du tableau
2-Ajout des éléments d’un tableau
Pour
remplir les différents éléments du tableau, on pourra affecter à chaque case de
ce tableau une valeur.
Exemple :
int tab [5] ;
tab
[0] =36 ;
tab
[1] =50 ;
tab
[2] =80 ;
tab [3] =100 ;
tab [4] =150 ;
Les indices du tableau sont : 0, 1, 2, 3, 4 ;
Les valeurs sont : 36, 50, 80, 100,1 50 ;
Attention !!: Un tableau commence toujours par
l’indice 0.
3-Récupérer une valeur
Pour récupérer une valeur, il suffit
d’indiquer la case de cette valeur entre crochets de la manière suivante :
int tab [5]
printf (« %d », tab [0]) ;
// Affiche 36
4-Parcourir un tableau
On
peut se servir d’une boucle for pour passer en revue les valeurs d’un tableau.
Exemple:
|
for (i=0;
i<5; i++) { printf (“%d”, tab[i]) ; } |
5-Initialiser un tableau
Pour initialiser un tableau, on écrit :
tab [5] = {valeur1, valeur2, valeur3,
valeur4, valeur5}
Exemple :
int tab [5] = {0,0,0,0,0}, i=0 ;
On pouvait tout
simplement écrire :
int tab[5] = {0} ; // toutes les cases du tableau seront initialisées à 0.
Cependant, on peut définir les
valeurs des premières cases, les autres cases seront mises automatiquement à 0
par défaut.
Exemple :
int tab [5] = {26,33} ;
// Les valeurs insérées seront 26, 33, 0, 0,0
IX-FONCTIONS
1- Définition
Une fonction est un bloc de code dont le but est d’effectuer une tâche précise
et que l'on pourra, si besoin est, utiliser à plusieurs reprises.
L’avantage majeur des fonctions est qu’elles peuvent être réutilisées plusieurs
fois dans un code assez long. Il suffit à chaque fois d’appeler la fonction,
une fois créée, tout simplement en mentionnant son nom pour pouvoir l’utiliser
autant de fois qu’on le veut.
En langage C, il existe deux types de fonctions :
· Les fonctions qui renvoient
une valeur : on leur met des types de caractères que l’on
connait (char, int, double, ...).
· Les fonctions qui ne
renvoient pas de valeur : on leur met un type spécial void
(qui
signifie « vide »).
2-
Création d’une fonction
Pour créer une fonction, la syntaxe est la suivante :
Syntaxe :
type
nom_Fonction (type paramètre) {
Déclaration
des variables locales
Le code que la fonction va devoir exécuter
}
· type désigne le type de la
fonction c-à-d le type de la valeur qu’elle retourne. En effet ,comme les
variables, les fonctions ont un type ; ce type dépend du résultat que la
fonction retourne : si la fonction retourne un nombre décimal, le type est
double, si elle retourne un entier, le type est int
ou long par exemple ou enfin si elle ne retourne aucune valeur, le type est void.
· Nom_Fonction
est un nom qu’on donne à la fonction que l’on veut créer.
Le nom de la fonction suit les mêmes règles que celles qui régissent les noms
des variables.
A titre de rappel, Le langage C est sensible à la casse f est différent de F.
Ainsi
fonction () ne sera pas égal à Fonction ().
· S’ensuit un couple de
parenthèses contenant ce qu’on appelle les paramètres. Elles servent à fournir
des informations à la fonction lors de son exécution.
· Entre les accolades, on
écrit le code à exécuter. Lorsqu’une accolade est ouverte, elle doit
impérativement, sous peine de message d'erreur, être refermée.
Exemple :
int triple (int nombre)
{
int resultat=0 ; //
on déclare et initialise la variable resultat
resultat = 3*nombre ; //on multiplie le
nombre fourni par 3
return resultat ; //on retourne la
variable resultat qui vaut le triple de
nombre
}
Ce code est équivalent à celui-ci
int triple (int nombre)
{
return 3*nombre ;
} //on définit la fonction
3-
L'appel d'une fonction
Le fait de définir une fonction n'entraîne pas l'exécution des commandes qui la
composent. Ce n'est que lors de l'appel de la fonction que le code de programme
est exécuté.
Exemple 1:
· On définit la fonction
triple :
#include< stdio.h>
#include< stdlib.h>
|
int triple (int
nombre) |
//Définition de la fonction |
return3*nombre ;
}
· On appelle cette fonction dans un
programme principal :
int main ()
{
int nombreEntre=0;
printf (Entrez un nombre…. ») ;
scanf (« %d », &nombreEntre)
;
triple (nombreEntre) ; //on appelle la
fonction
return 0 ;
}
On peut récupérer la valeur que la fonction renvoie dans une variable pour
l’afficher ou l’utiliser plus tard.
Exemple :
#include< stdio.h>
#include< stdlib.h>
int triple (int nombre)
{
return 3*nombre;
} i
nt main (int argc, char*argv[])
{
int nombreEntre=0,nombreTriple=0;
printf (Entrez un nombre…. ») ;
scanf (« %d », &nombreEntre)
;
NombreTriple = triple (nombreEntre) ; //on appelle la fonction
printf (« Le triple de ce nombre est %d\n », nombreTriple)
;
return 0 ;
}
La fonction triple renvoie une valeur qu’on récupère dans la variable nombreTriple avec la ligne suivante et on
l’affiche.
Remarque: On n’est pas obligé de stocker le résultat
d’une fonction dans une variable.
Exemple 2 : fonction qui ne retourne pas
de valeur :
void punition (int nombreDeLignes)
{
int i ;
for (i=0 ; i<nombreDeLignes ; i++)
{
printf (« je ne dois pas recopier mon voisin \n ») ;
}
172
L’appel de cette fonction dans un programme principal :
int main (int argc, char*argv [])
{
punition (10);
return 0;
}
· On peut passer plusieurs paramètres à une
fonction, on sépare les paramètres par des virgules.
Syntaxe :
type nomFonction (type1 param1, type2
param2, type3 param3) {
Code des instructions ...
}
Exemple :
|
int addition (int a, int b)
|
// on définit la fonction addition avec deux paramètres |
return a+b
;
}
Remarque
Toutes les fonctions n’ont pas besoin de paramètres (en revanche la paire de
parenthèses est obligatoire)
Exemple :
void bonjour ()
{
printf (« Bonjour ») ;
}
4-Utiliser
les prototypes des fonctions
Les prototypes des fonctions sont des lignes qui annoncent une fonction. Ces
lignes sont généralement placées avant la fonction principale main (). Les
prototypes ont la formed’une déclaration de fonction,
à la seule différence qu’ils se terminent par un point-virgule.
Soit une fonction appelée surfaceRectangle qui
calcule l’aire d’un rectangle, le prototype de cette fonction est :
double surfaceRectangle (double largeur, double
longueur) ;
Rôle : Les prototypes permettent à l’ordinateur de s’organiser, il sait
qu’il existe une fonction appelée surfaceRectangle
qui prend tels ou tels paramètres en entrée et renvoie une sortie dutype indiqué. Quand le protocole d’une fonction est placé
en haut des fichiers, l’ordinateur
connait le mode d’emploi de cette fonction dès le début de lecture du fichier.
La fonction elle-même peut être placée n’importe où dans le code.
Lorsque par contre on ne place pas le prototype d’une fonction en haut du code source ,après les #include et les variables globales, cette
fonction doit obligatoirement se placeravant la
fonction main() pour que l’ordinateur puisse la prendre en considération. Les
fichiers
qui contiennent les prototypes des fonctions sont appelés fichiers headers, on
les reconnait avec l’extension .h
Exemple:
#include< stdio.h>
#include< stdlib.h>
int triple (int nombre) ;
//prototype pour annoncer la fonction
int main ()
{
|
int nombreEntre=0; |
//initialisation de la variable nombreEntre |
|
printf (Entrez un nombre…. »)
; |
|
|
triple (nombreEntre)
; |
//on appelle la fonction triple |
return 0 ;
}
// Notre fonction triple peut être maintenantmise
n’importe où dans le code source
int triple (int nombre) //
début de la fonction triple
{
return 3*nombre ;
}
NB : Il faut noter la présence d’un point-virgule à la fin du prototype. C’est
ce qui permet à l’ordinateur de différencier un prototype du véritable début
d’une fonction. On reprend l’expression de la définition de la fonction et on
ajoute un point-virgule à la fin.
Remarques :
|
i) |
La fonction main () n’a pas de prototype, c’est la seule en effet
qui n’en nécessite |
|
ii) |
variables. Ainsi, cette ligne
peut aussi être écrite sans noms de variables :
Exemple : double aireRectangle (double, double) ;
5-La
portée des variables
Les variables et les fonctions ont une portée dans le programme c.-à-d.
qu’elles ne peuvent pas être accessibles n’importe où dans un programme. Elles
n’ont pas toutes la mêmedurée de vie. On distingue
deux catégories de variables
5.1-Les
variables globales.
On appelle variable globale une variable déclarée en dehors de toute fonction.
Les variables globales sont systématiquement permanentes. Elles sont
accessibles dans toutes les fonctions du programme.
Exemple :
Int nombre=3
Int triple(void)
{
Return nombre*3 ;
}
Int main(void)
{
Nombre=triple () ;
printf (« %d », nombre) ; return 0 ;
}
Dans ce code, la variable nombre a une portée au niveau du fichier et peut par conséquentêtre bien utilisée dans la fonction triple () que
dans la fonction main ().
5.2-
Les variables locales
On appelle variable locale toute variable déclarée à l’intérieur d’une fonction
(ou d’un bloc d’instructions) du programme. Par défaut les variables locales
sont temporaires, elles n’existent que pendant que la fonction est exécutée. A la
sortie de cette fonction, elles sont perdues. De même, une variable locale
d’une fonction n’est accessible qu’à l’intérieur de cette fonction, on ne peut
pas accéder à cette variable depuis une autre fonction.
Exemple :
int main(void)
{
{ i
nt nombre=10 ;
printf (« %d\n », nombre) ;
}
printf (« %d\n », nombre) ;
return 0 ;
}
Dans ce code, la variable nombre est déclarée dans un sous-bloc. Sa
portée est donc limitée à ce dernier et elle ne peut pas être utilisée en
dehors.
Remarques :
1-Les variables locales à une fonction ont une durée de vie limitée à une seule
exécution de cette fonction. Leurs valeurs ne sont pas conservées d’un appel au
suivant. Toutefois il est possible de créer une variable locale de classe
statique en faisant précéder sa déclaration du mot-clé static.
Syntaxe :
static type nom- de -variable ;
Elle reste locale à la fonction dans laquelle elle est déclarée, mais sa
valeur est conservée d’un appel au suivant. Elle est également initialisée à
zéro à la compilation et nepeut donc entrer en
conflit avec les autres variables du programme.
2-Les variables locales n’ont en particulier aucun lien avec des variables
globales de même nom, surtout si elles ont des portées différentes.
Exemple :
int nombre=10 ;
int main(void)
{ i
nt nombre=20 ;
printf(« %d\nombre) ;
return 0 ;
}
EXERCICES
CONTROLE DE
CONNAISSANCES
1-Définir : compilateur, préprocesseur
2-Pourquoi dit-on que le langage C est
un langage :
a-compilé
b-typé
c-sensible à
la casse
3-Citer 02 compilateurs utilisés par le langage C.
4-Quels sont les trois types de base du langage C ?
5-Le type char peut être assimilé à un entier en C. vrai ou
faux ?
6-Quelle est la différence entre une variable locale et une
variable globale ?
7-Est-ce qu’on peut parler de la notion de procédure en langage
C ?
EXERCICE
I :
1.#include<stdio.h>
2. int
main void () {
3. int
n ;
4. printf (« Entrer un
nombre ») ;
5. scanf
(« %d », &n) ;
6. return 0 ;
7.}
En
vous servant de vos connaissances sur la programmation en langage C, répondre
aux questions suivantes :
1) Identifier dans le programme
a)Le nom d’une bibliothèque
b) Le nom d’une fonction de lecture
c)Une instruction qui fait une
déclaration de variable
d) La fonction principale du
programme
2. Réécrire ce programme en
respectant la règle d’indentation
3. Expliquer le rôle joué par les
caractères % et & contenus dans la ligne 5
(Probatoire 2020)
EXERCICE II :
1.#include< stdio.h>
2.#include< stdlib.h>
3.
4. int Notes [10] ;
5. int main (){
6. int i=0 ;
7. int S=0 ;
8. for(i=0 ;i<9 ;i++){
9. S=S+Notes [i];
10.}
11.printf
(« %d »,S/9) ;
12.
return 0;
13.}
Questions :
1. Identifier dans ce code 02 instructions d’entrée et 02
instructions de sortie.
2. Identifier dans ce code 01variable locale 01 variable globale.
3. Identifier dans ce code01 structure
4. Que font les lignes n°6 et n°7 ?
5.
EXERCICE
III : Transcrire l’algorithme
ci-dessous en langage C.
1. Algorithme SimpleOuDouble
2. Constante C=0 ;
3. Variable V : entier ;
4. Début
5. Ecrire ("Donnez-moi un
entier : ") ;
6. Lire (V) ;
7. SI V< C ALORS
8. V ←V*2 ;
9. Ecrire ("Voici son 10.double :’’, V) ;
11. SINON
12. Ecrire ("Voici la valeur 13.inchangée :’’, V) ;
14. FinSI
15. Fin
EXERCICE IV : Transcrire l’algorithme ci-dessous en
langage C.
1. Algorithme CalculPgcd
2. Variable A,
B : entiers ;
3. Début
4. Ecrire ("A = "), Lire(A) ;
5. Ecrire ("B =
"), Lire(B) ;
6. Tant que NOT (A*B
=0) Faire
7. Si A > B alors
8. A ← A-B ;
9’Sinon
10.B ← B-A ;
11. FinSi
12. Fin Tant que
13. Si A=0 alors
14. Ecrire (« pgcd= », B) ;
15. Sinon
16. Ecrire (« pgcd= », A) ;
17. FinSi
18. Fin
EXERCICE V: Transcrire en langage C:
1. Nb : Tableau [5] d’entiers ;
2. Var i : entier ;
3. Début
4. Pour i de 1 à 5 Faire
5. Nb [i] ← i*i ;
6. FinPour
7. Pour i de1 à 5 Faire
8. Ecrire Nb [i] ;
9. FinPour
10. Fin
CORRIGES
1-Compilateur : C’est un programme qui traduit le code source d’un programme en binaire.
Préprocesseur : C’est un programme qui se lance au
début de la compilation. Son rôle est d’exécuter les instructions spéciales
qu’on lui a fournies dans les directives de préprocesseur.
2-a) Le
langage C a besoin d’un compilateur pour fonctionner.
b) Toute variable, constante ou fonction en
langage C est d’un type bien précis.
c) Il faut bien différencier les majuscules
des minuscules.
3- Le
compilateur cc sous Unix et le compilateur gcc du
projet GNU.
4- Type entier (int, long, unsigned char)
Type flottant (double, float)
Type caractère:
char;
NB:
char est en réalité un type entier car la table ASCII convertit les caractères
en entiers.
5-VRAI
6-La portée d’une variable locale se limite à la fonction dans
laquelle elle est définie alors la portée d’une variable globale s’étend sur
toutes les fonctions du code ;
7-Non. Toutes les fonctions retournent quelque chose, si une
fonction ne retourne rien, on met le mot clé void
EXERCICE I :
1- a) <stdio.h>
b) scanf
c)int n
d)int main void ()
{
int n ;
printf (« Entrer un nombre ») ;
scanf (« %d », &n) ;
return 0 ;
}
2-
#include<stdio.h>
int main void (){..
}
3- % spécifie
le format de la donnée à afficher (int, long, float, etc.)
&
s’ajoute devant le nom de la variable qui va recevoir une valeur.
EXERCICE II : Transcription d’un algorithme en
langage C
|
Algorithme |
Programme en langage C |
|
1. Algorithme Calcul 2. Variable : X, A, B, i : entier ; 3. début 4. écrire (« Entrer X et
A ») ; 5. Lire (X, A) ;
7. pour i
allant de 1 à X pas=1 faire
9. finpour 10. écrire
(« résultat = », B) ; 11. fin |
#include <stdlib.h> #include<stdio.h> int main (int argc,char*argv[ ]){ int B=1; int i, X, A ; printf (‘Entrez X et A’) ; scanf (‘%d,%d ‘,
&X, &A) ; for (i=1 ;i<X ;i++){ B=B*A ;
} printf (« résultat =%d», B ) ; return 0 ; } |
