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
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.
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.
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.
VARIABLES
ET 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 :
type nom_de_la_variable ;
Exemple :
int nombreVisiteurs ; //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.
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 :
int nombreVisiteurs=5 ;
int nombrePeriodes=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 :
double poids=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) ; |
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é) |
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.
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
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 ») ;
}
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 du type
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 placer avant 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 maintenant mise 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 pas, parce que l’ordinateur la connait. |
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ême
duré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 ; } |
