PROGRAMMER EN LANGAGE C

Plan du cours (Cliquez sur un lien pour aller directement à la partie qui vous intéresse)

I- LANGAGE DE PROGRAMMATION ET IDE

II- GENERALITES SUR LE LANGAGE C

III- LES INSTRUCTIONS D’ENTREE/ SORTIE

IV-LES OPERATEURS

V-LES STRUCTURES DE CONTROLE

VI- LES TABLEAUX ET ENREGISTREMENTS EN LANGAGE C

VI-FONCTIONS EN LANGAGE C

VIII-EXERCICES

I- LANGAGES DE PROGRAMMATION ET IDE

Les langages de programmation

Les programmeurs utilisent des langages de programmationpour é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:

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:      

0011

+          0101

1000           

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.

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.

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 probleme pour créer des logiciels rapides, des jeux vidéos et des systèmes d’exploitation.

 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 performents.

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.

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.

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): Code :: Blocks, Visual studio, windev,Xcode etc.

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.

 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.

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:

Fig:59:

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 decompilation s'afficher si votre code comporte des erreurs.

II- GENERALITES SUR LE LANGAGE C

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.

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).

Structure de base d’un programme en C

Un programme en C comprend les parties suivantes:

[Directives du préprocesseur]

 [Déclaration des variables externes]

[Prototypes des Fonctions secondaires]

                 int main ( )

{

[Déclaration des variables internes à cette fonction]

[Instructions]

return 0;

}

           

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 comprennentdes 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),

-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),

- 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.

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 autres fonctions.

Remarque: A l’intérieur de chaque fonction, on déclare seulement les variables utiles pour cette fonction ou variables locales.

Prototypes des fonctions secondaires

Les prototypes sont des lignes de programme qui servent à annoncer une fonction. Lorsqu’on les écrit en haut du code source, avant la fonction main (), la fonction correspondante peut être écrite n’importe où dans le code c.-à-d. avant ou après la fonction main ()car l’ordinateur sait déjà qu’il existe une fonction qui va suivre. C’est le mode d’emploi de la fonction pour l’ordinateur.

La fonction principale

 Un programme en langage C est essentiellement constitué des fonctions. Il contient toujours une fonction principale, la fonction main ().Il faut aller dans le menu File/New/Project, puis choisir Console Application et sélectionner le langage C.

int main()

{

//Déclaration des variables internes à la fonction principale

//Instructions

return 0:

}

-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.

Comment créer un nouveau projet

· Entrer dans le programme Code::Block,

· Cliquer sur Nouveau projet,

· Choisir le mode Console Application, puis cliquer sur Next,

· Choisir C, Puis Saisir le nom du projet, puis sur next

· Cliquer sur Finish

 Fig.60

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 intmain()

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.hcontient du code tout prêt à être utilisé dans les opérations  d’entrée/sortie telle que l’affichage du texte à l’écran.

· stdlib.hdé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 4peut aussi s’écrire:

Int main(int argc, char*argv[ ])

Remarques:

6-Les caractères spéciaux

· \n: retour à la ligne

· \v: tabulation verticale

NB: Il faut éviter les accents dans le code.

Les variables et les constantes

Les variables

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:

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.

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

   (short est un entier court (16 bits) long est un entier long (64 bits)

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.

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

int a,b,c;

Exemple:

#include< stdio.h>

#include< stdlib.h>

intmain() // Equivalent de int main()

 {

int nombreVisiteurs;                               //on déclare la variable

 …………………………………………//insérer les instructions ici

return 0;

}

Affecter 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.

IntnombreVisiteurs=10;

Les constantes

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 symboliquesdéfinies par le programmeur.

Déclarer une constante

            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 variable. Par convention, les noms des constantes sont écrits en majuscules.

Syntaxe:

            .    const type nomDeLaConstante=valeurDeLaConstante

Exemple:

             const int NOMBRE=5;

III- LES INSTRUCTIONS D’ENTREE/ SORTIE

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’endroitoù 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 leformat 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.

Exemples:

          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:

intmain ()

{

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.

intmain()

{

char lettre=’A’;

printf("  %d\n"", lettre);//Affiche 65

return 0;            

}

Instructions de sortie non formatées: put () et putchar ()

· put 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

Les instructions d’entrées

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);

           

Exerciced’application 1:

Ecrire en C un programme qui demande l’âge et l’affiche.

#include< stdio.h>

#include< stdlib.h>

intmain()   // 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’application2:

Ecrire en C un programme qui demande un caractère et l’affiche.

intmain()

{

char lettre=’0’;

scanf ("%c",&lettre);

printf("  %c\n", lettre);//Affiche la lettre B si on tape B

return 0;              

}

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) ;

· getchareffectue la lecture d’un caractère à partir du clavier.

Exemple:

charx ;

printf ("Entrer un caractere") ;

x = getchar () ;

printf("Voici le caractere entre");  

putchar(x) ;

III-LES OPERATEURS

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

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.

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

                                                          

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

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

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é)

IV-LES STRUCTURES DE CONTROLE

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.

La structure de base « if ...else»

Syntaxe: forme réduite

if (condition vraie) {

//une ou plusieurs instructions à exécuter si la condition est vraie

}

Exemple:

If (age>=18){

Printf("vous êtes majeur");

}

Syntaxe: forme complète

if (condition vraie) {

Instructions1 ;

}

else {

Instructions2 ;

}

Exemple:

#include< stdio.h>

#include< stdlib.h>

int main()      

{

int age=20;

            if (age<= 18) {

                        printf('Vous êtes mineur!') ;

}

else{

                        printf ('Vous êtes majeur!') ;

}

return0 ;

}

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 ()

{

inttempérature=20;

if (temperature <=0){

            printf(“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 entre une temperature") ;

}

return 0;

}

//Affiche:l’eau est liquide

NB:

Tester l’opposé d’une condition avec !

Ajouter une contrainte ET avec&&

Ajouter une contrainte OU avec ||  (alt Gr +6)

Utiliser== dans les expressions logiques

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:

IntMajeur=1;

if (Majeur)

{

Printf("  Tu es majeur!");

}

else

{

Prinft (" Tu es mineur");//Affiche: Tu es majeur

}

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

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:

Inti;

for(i=0; i<5;i++)

{

printf (“Ligne n° %d\n:”, i); 

}

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.

Exemple1 :

IntnombreEntre=0;

While(nombreEntre! =47)

{

printf("Tapez le nombre 47");

scanf("%d", &nombreEntre);

}

Exemple2:

int i=1;

while (i<5){

printf (“Salut les gars ! \n”);

i++ ;

}

printf(" Fin de la boucle") ;

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.

V- LES TABLEAUX ET ENREGISTREMENTS EN LANGAGE C

TABLEAUX

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:

            inttab [5]; où 5 est le nombre de cases du tableau

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

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]) ;

}

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.

ENREGISTREMENTS

Déclarer un enregistrement en C

Un enregistrement, appelé structure en langage C, est une variable complexe qui permet de désigner sous un seul nom un ensemble de valeurs pouvant être de types différents.

Syntaxe:

struct <Nom_Structure>{

            <Type_Champ1><Nom_Champ1>;

<Type_Champ2><Nom_Champ2>;

               ………………………………..

            };

Exemple:

Stuct Etudiant

{

char niveau;

int age;

foat moyenne;

 };

           

Contrairement aux tableaux qui obligent à utiliser le même type, les structures peuvent comporter plusieurs variables à la fois.

Tableau dans une structure

Les structures peuvent contenir des tableaux.

Exemple:

struct Personne{

                        char nom[100];

                        char prénom[100];

                        char adresse[1000];

int age;

int garçon;              // Booléen qui prend 1 pour garçon et 0 pour fille

};

Création dune variable Utilisateur de type Personne

Syntaxe:

            Struct nom_type nom_variable

Exemple:     Struct Personne Utilisateur

Initialisation d’une structure

Elle ressemble à celle d’un tableau.

Exemple: Soit la structure Coordonnée définit par:

Struct Coordonnées

{

int x;

int y;

};

Soit la variable point définie par:Coordonnées point

On peut initialiser les coordonnées à zero par:

Struct Coordonnées point = {0,0}

Ce qui signifie:

Point.x=0;

Point.y=0;

Accéder à un champ d’enregistrement en C

            Pour accéder à chaque composante de la structure, on sépare la variable et la composante par un point.

Syntaxe:

variable. nom de la composante

Exemple:

                        Utilisateur.nom

                        Utilisateur.prénom

Application

Ecrire en langage C un programme qui saisit les âges de deux apprenants et calcule la différence d’âge.

#include <stdio.h>

#include <stdlib.h>

typedef struct appr appr;

int main()

{

struct appr{

        char nom;

        char prenom;

int age;

};

struct appr appr1,appr2;

printf ("entrer le nom de l'apprenant 1");

    scanf("%s",&appr1.nom);

    printf ("entrer le prénom de l'apprenant 1 ");

    scanf("%s",&appr1.prenom);

    printf ("entrer l'age de l'apprenant 1");

    scanf("%d",&appr1.age);

    printf ("entrer le nom de l'apprenant 2");

    scanf("%s",&appr2.nom);

    printf ("entrer le prenom de l'apprenant 2");

    scanf("%s",&appr2.prenom);

    printf ("entrer l'age de l'apprenant 2");

scanf("%d",&appr2.age);

    if (appr1.age>appr2.age){

        printf("la difference d'age %d est", appr1.age - appr2.age);

    }

    else

          {

        printf("la difference d'age %d est", appr1.age - appr2.age);

}

return 0;

}

VI- LES FONCTIONS


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

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

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 ») ;
}

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 forme
d’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…. ») ;
scanf (« %d », &nombreEntre) ;

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.
Dans la ligne du prototype, l’ordinateur a juste besoin de connaitre les types de

ii)

variables. Ainsi, cette ligne peut aussi être écrite sans noms de variables :
Exemple : double aireRectangle (double, double) ;

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

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 ().

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 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)
{ 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? pourquoi?

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?pourquoi?

EXERCICEI:

1. #include< stdio.h>

2. #include< stdlib.h>

3.

4. int main(){

5.int tab[6];                                                               

6.int i=0;

7. for (i=0;i<6;i++){

8. T[i]=i*i;

9.}

10. for(i=0;i<6;i++){

11. printf («d%», T[i]);

12. }

13. return 0;

14. }

Questions:

1) Identifier dans le programme ci-dessus,

            a) Le nom d’une bibliothèque

b) La déclaration d’une variable.

c) La déclaration d’un tableau.

2. Réécrire ce programme en respectant la règle d’indentation

3. Expliquer le rôle joué par les caractères % contenu dans la ligne 11.

EXERCICE II: On donne le code suivant:

1.#include< stdio.h>

2.#include< stdlib.h>

3.

5.Struct Personne

6.    {

7.       Char nom[10];

8.               Int age;  

9.   };

10.int main()

11.{

12.  Personne Utilisateur;

13.

14. Printf («Quel est le nom?»);

15. Scanf(«%s», &Utilisateur.nom);

16. Printf («Quel est l’age?»);

17. Scanf(«%d», &Utilisateur.age);

18. Printf («Vous vous appelles %s et vous avez %d age», Utilisateur.nom, Utilisateur.age);

19. return 0;

28.}

Questions:

1) Définir: structure en langage C

2) Identifier dans le programme

a)une structure

b) Le nombre de sous-variables de cette structure.

c)Une variable de type Personne

3. Expliquer le rôle joué par les caractères & contenu dans la ligne 15.

EXERCICEIII: Transcrire en langage C:

1. Algorithme InitialiseTableau

2. tab: Tableau [0…7]  de réels;

3. var i entier;

4. Début

5. Pour i de 0 à 7 Faire

6. tab[i]   ←      0;

7. FinPour

8. Pour i de 0 à 7 Faire

9. Afficher tab[i];

10. FinPour

11. Fin

EXERCICE IV: Transcrire en langage C:

1. Algorithme AfficheTableau

2. tab: Tableau [0…5]  de réels

3. var i:entier;

4. Début

5. Pour i de 1 à 5 Faire

6. T[i]   ←      i*i;

7. FinPour

8. Pour i de 1 à 5 Faire

9. Afficher tab[i];

10. FinPour

11. Fin

EXERCICE V: Transcrire en langage C:

1. Algorithme CalculNotes

2. Notes: Tableau[1…9]  de réels;

3. Var i:entier;

4. Var s:entier;

5. Début

6. Pour i de 1 à 9 Faire

7. Ecrire «Entrer la note numéro», i+1;

8. Lire Notes(i)

9. FinPour

10. S    ←        0;

11. Pour i de 0 à 9 Faire

12. S       ← S +Notes[i];

13. FinPour

14. Ecrire(«Moyenne:», S/9);

15. Fin

Avez-vous un exercice à proposer au Forum?Cliquez-ici

CORRIGES

Merci de votre visite
Laissez un commentaire