Vous êtes sur la page 1sur 34

Université Ibn Zohr - Faculté des Sciences

SMI3

Programmation I.
Language C, concepts de base

1
Commencer par l’exemple !

/* le classique programme « Hello World » */

#include <stdio.h>

main()
{
printf ("Hello World \n" ) ;

Cet exemple affiche à son exécution le message Hello Word

2
Commentaire:

•Le texte entre /* et /* correspond à des commentaires : il n'est pas interprété par la
machine ;
• La commande #include sert à inclure un fichier. En règle générale, si le nom est
entre <>, il s'agit d’un fichier du système. S’il est entre guillemets, il s’agit par contre
d’un fichier saisi par l'utilisateur;
• Le fichier stdio.h (standard input/output header) est nécessaire pour utiliser les
fonctions d’entrée/ sortie ;
• Le texte main() annonce le programme principal (point de départ de l’exécution du
programme). Le programme en lui même est composé de l’ensemble du texte qui suit,
et est entre accolades;
• Toute instruction C se termine par un point-virgule (;) ou une accolade fermante si
elle avait débuté par une accolade ouvrante;
• L'instruction printf sert à afficher des messages. Ces messages peuvent être des
nombres, des chaînes de caractères, ou un mélange des deux ;
• Dans une chaîne de caractères entre guillemets, un caractère précédé d'un backslash
(\) est un caractère spécial, Ici, le \n (newline) signifie que l'ordinateur devra aller à la
ligne après avoir écrit le texte entre guillemets.
3
‫ﻳﻤﯿﺰ‬
Une variable possède:
• Un nom ;
• Un type ;
• Une valeur.

Le nom d’une variable est fixe ; c’est ce qui caractérise la variable. De même, le type
d’une variable est fixe. Mais sa valeur peut être modifiée.

Dans le nom des variables, on distingue majuscules et minuscules ; donc toto et Toto
sont deux variables différentes. Un nom de variable commence toujours par une
lettre. Les autres caractères peuvent être des lettres, des chiffres ou le tiret de
soulignement : _. Des noms de variables trop courts manquent souvent de sens, et
rendre le programme peu compréhensible. Des noms de variables trop longs rendent
le programme illisible.

‫ﻏﯿﺮ ﻗﺎﺑﻞ ﻟﻠﻘﺮاءة‬

4
Pour être utilisée, une variable doit être déclarée. Pour déclarer une variable, il faut
donner son type, son nom, puis, éventuellement une valeur initiale.
On appelle type de base les types déjà définis dans le langage (on verra par la suite
que l’on peut aussi définir ses propres types). Les types de bases sont :

char : les caractères (un seul symbole) ;


int : les entiers ;
short : encore des entiers ;
long : toujours des entiers ;
float : les décimaux;
double: encore des décimaux ;
long double : et toujours des décimaux.

Les variables peuvent être déclarées de deux façons: de manière globale ou locale.
Dans le premier cas elles seront déclarées au début du fichier, dans le deuxième cas,
juste après l'accolade ouvrante suivant un en-tête de fonction.

5
Note : Les variables déclarées de manière globale sans initialisation spécifique de la
part du programmeur sont initialisées à zéro, tandis que les variables locales ont
une valeur indéterminée. Cependant, dans tous les cas, il est conseillé de spécifier à
quelle valeur une variable est initialisée.

Exemple:

#include<stdio.h>
/* Déclaration d’une variable globale appelée toto, de type entier. */
int toto;
main()
{
/* Déclaration d’une variable locale titi, décimale, initialisée à 1,5. */
float titi = 1.5;
printf("Hello World\n");
}
Note : On peut aussi déclarer les variables de façon multiple si elles ont le même
type. Par exemple la séquence d'instructions int a; int b; peut être remplacée par
l’instruction int a, b ;
6
Pour modifier la valeur d'une variable v, il faut utiliser une instruction d’affectation.
Ainsi, pour donner à la variable v la valeur 1, il faut taper v = 1;. Pour utiliser la
valeur d'une variable, il suffit d'utiliser le nom de la variable. Ainsi, la séquence
d’instruction suivante affecte la valeur 1 à v1 et à v2 :
v1 = 1; v1 = v2 ;

Note: Une affectation multiple est possible, l'instruction a = b= c = d recopie dans a,


b et c la valeur de d.

L'affichage de la valeur d’une variable se fait grâce à la fonction printf.


Exemple:

#include<stdio.h>
main( )
{
float approx_pi = 22./7. ;
printf("le nombre %f est une valeur approchée de π \n", approx_pi) ;
}

7
Le caractère % signifie que la valeur d’une variable, parmi celles qui suivent (à
l'intérieur des parenthèses, séparées par des virgules) doit être affichée à cet endroit.
La lettre ‘d’ qui suit le symbole % indique que c'est une variable de type entier.
On peut, dans une même instruction printf afficher la valeur de plusieurs variables.
Auquel cas les variables sont affichées dans l’ordre dans lequel elles sont citées.

Exemple:
#include<stdio.h>
main( )
{
int a, b, r;
b = 22;
a = 7;
r = b/a ;
printf("la division euclidienne %d / %d a pour résultat %d. \n" ,a, b, r);
}
Donne le résultat :
la division euclidienne 22/7 a pour résultat 3.

Note: En fait, printf n'affiche pas des variables, mais des expressions, dont les
variables ne sont qu'une forme particulière. 8
La fonction d'écriture printf
La fonction printf est une fonction d’impression formatée, ce qui signifie que les
données sont converties selon le format particulier choisi. Sa syntaxe est :
‫ﻣﻮاﺻﻔﺎت‬

printf("chaîne de contrôle ",expression-1,… ,expression-n);

La chaîne de contrôle contient le texte à afficher et les spécifications de format


correspondant à chaque expression de la liste. Les spécifications de format ont pour
but d'annoncer le format des données à visualiser. Elles sont introduites par le
caractère %, suivi d’un caractère désignant le format d’impression.

La fonction de saisie scanf


La fonction scanf permet de saisir des données au clavier et de les stocker aux adresses
spécifiées par les arguments de la fonction.(le signe & signifie l’adresse).

scanf (" chaîne de contrôle", &argument-1, …, &argument-n);

La chaîne de contrôle indique le format dans lequel les données lues sont converties.
Elle ne contient pas d'autres caractères (notamment pas de \n). Comme pour printf, les
conversions de format sont spécifiées par un caractère précédé du signe %.
9
En Algorithmique En C
Algorithme Affectation
#include<stdio.h>
Var main()
A, B : Entiers ; {
C : Réel ; int A, B ;
Début float C ;

Ecrire(" Entrer un entier") ; printf(" Entrer un entier \n") ;


Lire(A) ; scanf(" %d",&A) ;
B 2*A ; B = 2*A ;
Ecrire(" La valeur de A est :", A , " et la printf(‘" La valeur de A est : %d et la
valeur de B est :", B) ; valeur de B est : %d \n", A, B) ;

C (A+B)/2 ; C=(A+B)/2 ;
Ecrire(" La valeur de C est :", C) ; printf(" La valeur de C est : %f ", C) ;
Fin }
10
Exemple:

#include<stdio.h>
main( )
{
int i;
printf("entrez un entier sous forme hexadécimale i = " );
scanf("%x",&i);
printf("i = %d \n",i);
}

Si on entre au clavier la valeur 1a, le programme affiche i = 26.

11
Deux types d’instruction ont déjà été vues: l’instruction d'affichage
printf et l'instruction d’affectation =. La forme générale de cette dernière est
variable = expression. Une expression est assimilable, en règle générale, à une
formule mathématique. Voici quelques exemples d’expressions :

12
Note : Il existe des formes abrégées des affectations utilisant certains de ces
symboles. Ainsi, l’affectation:

x = x - 4;
Peut s’écrire plus simplement:
x- = 4;

Une forme encore plus simple existe lorsqu’une variable est incrémentée ou
décrémentée: plutôt que d’écrire

x+ = 1; /* raccourci de x=x+1*/

On peut écrire, au choix, x++ ou ++x

13
Note :

une affectation est aussi une expression, qui a pour valeur le résultat de
l’affectation. C’est là que se situe la différence entre x++ et ++x. Dans le
premier cas, l’incrémentation est faite après l’évaluation de x, alors qu’elle est
faite avant dans le deuxième cas. Ainsi, si x vaut 2, l’instruction a = 4+ x++
donne à a la valeur 6, et à x la valeur 3, tandis que l’instruction a = 4+ ++x, si
elle donne toujours à x la valeur 3, donne par contre à a la valeur 7.

14
Exemple 1:
Pour chacun des exercices ci-dessous ( de 1 à 4), trouvez la valeur des variables
qui figurent en commentaire.
Exercice 1 Exercice 2

#include<stdio.h> #include<stdio.h>
main() main()
{ {
int x = 10; int x = 3, z = 1;
int y, z; z = x / ++x; /* x = z = */
x *= y = z = 4; /* x = */ }
} Solution :

Exercice 3 Exercice 1
x = 40
#include<stdio.h>
main() Exercice 2
{ x=4 z= 1
int x, y, z;
x = 2; y = 1; z = 0; Exercice 3
x = x && y || z; /* x = */ x=1 15
}
La structure alternative en langage algorithmique

si (<expression logique>) alors


<bloc d'instructions 1>
sinon
<bloc d'instructions 2>
fsi

•Si l'<expression logique> a la valeur logique vrai, alors le <bloc


d'instructions 1> est exécuté
•Si l'<expression logique> a la valeur logique faux,
alors le <bloc d'instructions 2> est exécuté

16
La structure alternative en C

if ( <expression> )
<bloc d'instructions 1>
else
<bloc d'instructions 2>

• Si l'<expression> fournit une valeur différente de zéro, alors le <bloc


d'instructions 1> est exécuté
• Si l'<expression> fournit la valeur zéro, alors le <bloc d'instructions 2> est
exécuté

La partie <expression> peut désigner :


• une variable d'un type numérique,
• une expression fournissant un résultat numérique.

La partie <bloc d'instructions> peut désigner :


• un (vrai) bloc d'instructions compris entre accolades,
• une seule instruction terminée par un point-virgule.
17
Exemples d’instructions if:

if (a>b) max =a; else max = b;

if (x>y)
{
… /* liste d’instructions 1*/
}
else
{
… /* liste d’instructions 2 */
}

if (a) /* équivalent à if (a!=0) a est VRAI*/


{
… /* liste d’instructions */
} 18
En combinant plusieurs structures if - else en une expression nous obtenons une
structure qui est très courante pour prendre des décisions entre plusieurs alternatives:

if ( <expr1> )
<bloc1>
else if (<expr2>)
<bloc2>
else if (<expr3>)
<bloc3>

else if (<exprN>)
<blocN>
else <blocN+1>

Les expressions <expr1> ... <exprN> sont évaluées du haut vers le bas jusqu'à ce
que l'une d'elles soit différente de zéro. Le bloc d'instructions y lié est alors exécuté
et le traitement de la commande est terminé.

19
Exemple :

#include <stdio.h>
main()
{
int A,B;
printf("Entrez deux nombres entiers :");
scanf("%i %i", &A, &B);

if (A > B)
printf("%i est plus grand que %i \n", A, B);

else if (A < B)
printf("%i est plus petit que %i \n", A, B);

else
printf("%i est égal à %i \n", A, B);

return 0;
} 20
Dans le cas où plusieurs instructions différentes doivent être exécutées selon la valeur d'une
variable de type intégral, l'écriture de if successifs peut être relativement lourde.
Le langage de programmation C fournit donc la structure de contrôle switch, qui permet
de réaliser un branchement conditionnel. Sa syntaxe est la suivante
switch(nom_de_la_variable)
{
case valeur_1:
Instructions à exécuter dans le cas où la variable vaut valeur_1
break;
case valeur_2:
Instructions à exécuter dans le cas où la variable vaut valeur_2
break;
….
case valeur_N:
Instructions à exécuter dans le cas où la variable vaut valeur_N
break;
default:
Instructions à exécuter dans le cas où la variable vaut une valeur autre
que valeur_1, valeur_2 …. valeur_N
break;
21
}
valeur est évalué en premier. Son type doit être entier. Selon le résultat de
l'évaluation, l'exécution du programme se poursuit au cas de même valeur.

Si aucun des cas ne correspond et si default est présent, l'exécution se poursuit


après default. Si en revanche default n'est pas présent, on sort du switch.

Les instructions qui suivent le case approprié ou default sont exécutées.

Les instructions du cas suivant sont également exécutées (on ne sort donc pas du
switch). Pour forcer la sortie du switch, on doit utiliser le mot-clé break.

22
23
Exemple :
#include <stdio.h> switch(k)
main() {
{ case 0 :
int i,j,k; printf(" %d + %d = %d \n", i,j,i+j);
printf("entrez deux nombres entiers \n"); break;
scanf("%d %d",&i,&j); case 1 :
printf(" %d * %d = %d \n", i,j,i*j);
printf("entrez 0 pour avoir la somme \n"); break;
printf("entrez 1 pour avoir la multiplication \n"); case 2 :
printf("entrez 2 pour avoir la soustraction \n"); printf(" %d - %d = %d \n", i,j,i-j);
printf("ou 3 pour avoir la division \n"); break;
case 3 :
scanf("%d",&k); printf(" %d / %d = %d \n", i,j,i/j);
break;
default :
printf("il faut entrer 0 , 1, 2 ou 3\n");
printf("relancez l‘exécution\n");
}
}
24
Un centre de photocopie facture à : 0.50 Dh les dix premières
photocopies, 0.40 Dh les vingt suivantes et 0.25 Dh au-delà.
Écrire un programme qui demande à l’utilisateur le nombre de
photocopies effectuées et qui affiche le prix associé.

25
Il s'agit d’une instruction qui permet de répéter un certain nombre de fois une
instruction donnée Cette instruction a classiquement la forme suivante:

for ( init ;cond; evol)


inst
où:
 init est une instruction d’initialisation (par exemple, i = 0) ;
 cond est une condition (expression) de continuation, faisant souvent référence au
compteur: on répète inst tant que cette condition est vraie (par exemple i <= 10);
 evol est une instruction qui fait évoluer le compteur, susceptible de modifier la
valeur de cond;
 inst est une instruction.

Note: le test cond est effectué avant d’exécuter le corps de la boucle. Aussi, si celui
est faux avant la première itération, l’instruction inst n’est pas exécutée.

26
Par exemple, pour imprimer tous les entiers de 0 à 9, on écrit:
for (i=0;i<10;i++)
printf("\n i = %d", i);

Voici un autre exemple, permettant d'afficher la table de multiplication de 7 :

#include <stdio.h>
main()

{
int i;
for(i=1; i < 10; i++)
printf("%d x 7 = %d \n", i, i * 7);
return 0;
}
À la toute première itération de la boucle, l’initialisation est exécutée. Ce peut être
une instruction du genre i=0. Ensuite, à la fin de chaque itération, l’incrémentation
est exécutée. On utilise en général des instructions comme i++ ou i--.

27
Exemple :

#include<stdio.h>
/* Programme qui calcule la somme des entiers de 0 a 100 */
main()
{
int somme = 0 ; /* on initialise la somme à zéro */
int compteur ; /* la variable qui servira de compteur dans la boucle */

for(compteur = 0 ; compteur <= 100; compteur++)


somme += compteur ;

/* on rajoute à la somme des entiers de 0 à compteur-1 la valeur compteur */


/* ce qui donne la somme des entiers de 0 a compteur */

printf(" La somme des entiers de 0 à 100 vaut %d \n", somme);


}

28
On désigne par imbrication le fait d'utiliser une ou plusieurs boucles les unes dans
les autres. Cette opération est tout à fait possible et dans certains cas, très
intéressante, comme le montre l'exemple suivant :
#include<stdio.h>
main()

{
int i,j;
/* On calcule toutes les tables de 0 à 9 */
for(i=1; i < 10; i++){
for(j=1; j < 10; j++)
{
printf("%d x %d = %d\n", i, j, i * j);
}
}
return 0;
}

29
Avec ces boucles, le nombre de fois où sont répétées les instructions est indéfini.

Boucle While :
Il s’agit d’une autre forme de boucle dont la syntaxe est:
while(cond)
inst

La condition cond est vérifiée avant chaque itération. Si elle est évaluée à faux, on
sort de la boucle.

Boucle do … while :
Syntaxe :
do
inst
while (cond)

Par rapport à la boucle for ou à la boucle while, le test est effectué après chaque
itération. Donc s’il est faux au moment de rentrer pour la première fois dans le
corps de la boucle, celui-ci est quand même exécuté.
30
31
32
Examen 2016/2017

Exercice 1 (4 pts)
Écrire un programme qui vérifie si un entier positif donné noté n est un nombre
parfait.
Un nombre est dit parfait s’il est égal à la somme de ses diviseurs stricts.
Exemple : 6=1+2+3 ; 28 = 1 + 2 + 4 + 7 + 14

#include<stdio.h>
main (){
int i, n, compt=0 ;
printf("Donner un entier ");
scanf("%d", &n);

for (i=1; i <=n/2; i++) if (n%i==0) compt+=i;


if(compt==n) printf("%d est un nombre parfait ",n);
else printf("%d n'est pas un nombre parfait ",n);
}

33
Examen 2016/2017

Exercice 2 (4 pts)
Ecrire un programme qui permet de calculer et d’afficher le nombre
d’occurrences d’un chiffre (0 ≤ chiffre < 10) dans un nombre positif n.

Exemples : L’occurrence du chiffre 7 dans le nombre 778 est 2.


L’occurrence du chiffre 8 dans le nombre 20681 est 1.
L’occurrence du chiffre 5 dans le nombre 2771 est 0.
#include<stdio.h>
main (){ int nbr, n, chiffre, occu=0, rest ;

printf("Entrer un nombre positif :\n");


scanf("%d", &nbr);
do{ printf("Entrer un chiffre (0<= chiffre <10):\n");
scanf("%d", &chiffre);
} while(chiffre<0 || chiffre>=10) ;
n = nbr;
do{ rest = n%10; n = n/10;
if(rest==chiffre) occu++;
}while(n);
printf(" le nombre d'occurences de %d dans %d est de %d ",chiffre, nbr, occu); 34
}