Beruflich Dokumente
Kultur Dokumente
SMI3
Programmation I.
Language C, concepts de base
1
Commencer par l’exemple !
#include <stdio.h>
main()
{
printf ("Hello World \n" ) ;
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 :
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 ;
#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 :
ﻣﻮاﺻﻔﺎت
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 ;
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);
}
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*/
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
16
La structure alternative en C
if ( <expression> )
<bloc d'instructions 1>
else
<bloc d'instructions 2>
if (x>y)
{
… /* liste d’instructions 1*/
}
else
{
… /* liste d’instructions 2 */
}
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.
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:
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);
#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 */
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);
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.