Main ( ) c?est la fonction en tête du programme
Appellation des bibliothèques
Exemple : nom.h
<math .h> : appellation de la bibliothèque informatique
Déclaration des variables
Exemple : main ( )
{ instruction de déclaration ou instruction d?exécution
}
Une variable est un nom qui sert à repérer un emplacement mémoire dont on peut faire évoluer la valeur au cours du déroulement du programme.
La notion de type de variable de déclaration
3 principaux types de variable en langage C sont :
int : nombre entiers
float : nombres réels décimaux
Char : déclarer un caractère (lettres, chiffres, signes......)
Exemple : les entiers s?écrivent comme en maths sous forme de décimal, avec ou sans signe.
On peut écrire les constantes flottantes indifféremment suivant deux notions : décimale qui doit comporter un . à la place de la virgule.
L ?exponentielle utilise e ou E pour introduire un exposant entier.
Exemple : 48e13 42.5 E4
S./2 : une variable de type foat égal à 2,5
S/2 : fournit une valeur de type int = à 2
Int n,pi
Float val, x1, x2i
Char réponse ;
Les instructions d?affectation
Int n p ;
N = 10
P = 2* n-3 ;
Exemple : b = a+3
A=b ;
B=a ;
La première instruction place dans a la valeur de b tandis que dans la seconde place b dans la valeur de a.
Exemple : a = a+1 ;
Cette instruction signifie calculer l?expression a+1 et de ranger le résultat dans a.
Exemple : a+5 = 3
Cette instruction à cause d?une instruction d?affectation n?a aucun sens car on ne peut pas attribuer une variable à une expression mis seulement à une variable.
Les expressions " mixtes "
En C, on peut mélanger différents types de variables dans une même expression. On parle alors d?expression mixte.
Exemple : int n,p ;
Float x ;
N+x ?
N*p+x
La règle des priorités des opérations est la suivante :
L?opérateur inair (l?opposé) a la priorité la plus élevée. En suite, à un même niveau, les opérations *, / et %. Enfin, sur un dernier niveau, apparaissent les opérations + et...
D?après les règles, de priorité des opérateurs, le compilateur effectue le produit n *p qui conduit à un résultat de type entier. Ce résultat est alors converti au type float pour pouvoir lui ajouter X et le résultat final sera de type float.
Exemple :
Int n ;
Float x ;
N=+5.3 ;
Les instructions d?affichage de lecture
Exemple d?affichage avec l?instruction printf
Affichage de la valeur d?une variable
Int n = 20 ;
L?instruction suivante printf (" %d,n) demande d" afficher la valeur n. Cette instruction affiche la valeur de la variable mentionnée en tenant compte des indications précisées dans le format. %d correspond à l" affichage d" une variable de type entier.
PRINTF (" total : %d ", n) ;
L?exécution de cette instruction va provoquer l?affichage de total = 20.
Affichage de plusieurs variables
Int n = 10 ; p = 25
Printf (" nombre : %d_valeur : %d ",n, p) ;
Son exécution provoque l?affichage de nombre = 10 et valeur = 25.
Affichage d?une valeur d?une expression
Int n= 10 , p= 25 ;
L ?exécution de l?instruction printf (" la somme de %d est %d, n, p, n+p) ;
On pourrait la remplacer par :
Q = n+p
Printf (" la somme de %d et de %d est %d, n , p, q) ;
Exemple : printf (" Bonjour ") ; sur l?écran, je vais avoir Bonjour
Quelques autres codes de format
Pour le type de %c ou %f
Pour le type de float, on peut faire appel à l?un des deux codes %e M%f affiche la valeur correspondante avec une notation exponentielle.
%f = affiche une notation décimale
Exemple : float X = 1.23456e4
Printf (" X notation exponentielle : %e, X notation décimale : %f ", x) ;
Sur l?écran, X notation exponentielle : 1.234560e +0,4, X notation décimale : 123456e4 = 0e + 0,4
Char : caractère (variable, +, 5, S)
Char ?S? ;
Char ?+? ;
Char ?s?,?+? ;
%c : code format d?un caractère
Exemple :
Int n = 15 ;
Char C : ?S? ;
Printf (" nombre : %d caractère : %c ", n, c) ;
On obtient le nombre 15 et le caractère S. On peut trouver une chaîne de caractères.
Char " variable " ;
Printf (" %s ", " variable ") ;
En C, on trouve un certain nombre de code qui ne correspond pas à un caractère usuel comme par exemple :
\n : saut à la ligne
printf (" \n%,n)i
?\b? : retour arrière
?\a? : cloche
?\t? : tabulation
Initialisation des variables
Il est possible d?attribuer une valeur à une variable lors de sa déclaration.
Int n = 5 ;
Float X : 5.25 ;
Char c = ?e? ;
Cette valeur sera placée dès la compilation dans la variable correspondante.
Exemple :
Int ni ;
Float X
Char c
N = 5 ;
X = 5.25 ;
C =?E? ;
Ici, n, x et c recevront leur première valeur lors de l?exécution des trois premières instructions d?affectation.
Exemple :
Int n = 5, p, q = 10, v ;
On a initialisé la valeur n = 5 et
q = 10 alors que p et v ne sont pas initialisés.
Gabarit, précision et changement de ligne
Par défaut, les entiers sont affichés avec les nombres de caractère nécessaire et les float (flottants) sont affichés avec 6 chiffres après le print (aussi bien e, p). Un nombre placé après % dans le code format précise un gabarit d?affichage c?est-à-dire un nombre de caractères minimal. Si le nombre ne peut s?afficher convenablement avec ce printf. Printf utilisera le nombre de caractère nécessaire pour le faire précéder d?un nombre suffisant d?espace.
Exemple :
Printf (" %3d ",n) ;
N = 20 ; 20
N = 3 ; 3
N = 2358 ; 2368
Printf(" %10f ", X) ;
X = 1.2345 ; 1.234500
X = 1.2345E5 ; 123450000000
La précision de l?affichage
Il est possible de préciser le nombre de chiffres après le point décimal. On fait figurer ce nombre avant le code format et après le gabarit si ce dernier est présent.
Exemple :
Printf (" %10.3f, x) ;
X = 1.2345 ; 1.234
X = 1.2345 e 3 ; 1234.500
Printf (" %12.4e ", x) ;
X = 1.2345 1.2345e+00
Remarque
Il est possible de mentionner une précision sans gabarit " %.5f "
Changement de ligne
L ?instruction printf affiche les informations à la suite de celles qui ont déjà été affichées par un précédent printf. Il n? y a pas de passage à la ligne.
Exemple :
Int n = 5 ;
Char c =?5? ;
Printf (" nombre =%, "n) ;
Printf(" caractère :%c, C ")
L?ordinateur affiche le nombre 15 et le caractère S.
Printf (" nombre /%d caractère :%c ", n, c) ;
Avec une autre instruction :
Printf (" nombre /%d caractère :%c ", n, c) ;
L?ordinateur affiche nombre : 15
Caractère : S
On obtient le même résultat avec l?instruction suivante :
Printf(" nombre : %d\n ", n) ;
Printf(" caractère : %c, C) ;
Premier programme complet
Tout programme C doit être construit de la façon suivante :
#include <stdio.h>
main ()
{instruction déclaration
instruction exécutable
}
Exemple de programme complet
#include <stdio.h>
main()
{
float valeur =12.85
float carre, cube ;
int ent ;
carre = valeur *valeur ;
cube = carré *carré
printf(" la valeur %f a pour carré %f et pour cube %f\n, valeur, carre, cube) ;
ent = cube
printf(" la partie entière de son cube est : %d ", ent) ;
Les commentaires
En plus des instructions en langage C destinées au compilateur, on peut introduire ce qu?on appelle des commentaires, i.e. des explications de son choix qui ne seront pas prises en compte par le compilateur. Ces commentaires doivent être placés entre les symboles : /* et */.
Exemple :
/*premier programme complet en langage C*/
#include <stdio.h>
main()
{
/*les déclarations*/ PAS D?ESPACE ENTRE INCLUDE ET " < "
float valeur=12.25 ;
float carre ;/*pour le carre de la valeur*/
float cube ;/*pour le cube de la valeur*/
int ent ;/*pour la partie entière du cube de la valeur*/
/***les instructions exécutables***/
carre=valeur*valeur ;
cube=carre*valeur ;
printf(" la valeur%f et pour cube %f\n ", valeur, carre, cube) ;
ent=cube ;
printf(" la partie entière de son cube est :%d ",ent) ;
}
Lecture des valeurs numériques avec scanf
L?instruction de lecture va permettre de fournir des informations à un programme au moment de son exécution.
Cette instruction va " chercher " une valeur, qu?on frappe au clavier, et après l?avoir convenablement codée, la range dans une variable.
Lecture d?un nombre entier
La lecture au clavier d?un nombre entier que l?on range dans une variable n (type int) s?écrit en langage C de la manière suivante :
Scanf(" %d,&n)
Le symbole " & " indique l?adresse de n.
Lorsque le programme va exécuter cette instruction, il attendra que vous frappiez une information au clavier.
Lecture d?un nombre réel (flottant)
%e ou %f
Exemple : scan (" %e,&x) ; (avec x la variable flottante)
Scan (" %f ",&x) ;
Exemple :
#include <stdio.h>
main()
{
/*les déclarations*/
float valeur;
float carre, cube ;
int ent ;
printf(" donnez un nombre réel : ") ;
scanf (" %f ",&valeur) ;
carre=valeur*valeur ;
cube=carre*valeur ;
printf(" la valeur%f et pour cube %f\n ", valeur, carre, cube) ;
ent=cube ;
printf(" la partie entière de son cube est :%d ",ent) ;
}
Exemple de fonction sans résultat
Void optimist (int n)
{
int i ;
for (i=0 ;i<n ; i++)
printf (" bonjour ")
}
L?en-tête de la fonction montre qu?elle comporte un paramètre entier (n) ; cette fois, l?en-tête est précédée du mot void qui indique que la fonction ne fournit pas de résultat. Aucune instruction ne figure dans la définition de la fonction.
Exemple
Include <stdio .h>
Main ()
{
void optimist (int) ;
int N =2, p =1 ;
optimist (N) ;
optimist (P) ;
optimist (N+P) ;
void optimist (int n) ;
{
int i ;
for (i = 0 ; i<n ;i = i+1)
printf (" bonjou r ") ;
}
}
Exécution de ce programme :
Donnez un nombre réel : 12.85 (tapé au clavier)
La valeur 12.850000 a pour carré 165.122513 et pour cube 2121.824463
La partie entière de son cube est : 2121
La lecture de deux valeurs numériques entières
Exemple :
Int n,p ;
Scanf(" %d%d ",&n,&p) ;
Exercice
Ecrire un programme qui récupère le nom de l?article, sa catégorie, son prix unitaire et la quantité, par un dialogue du genre :
Article : S
Catégorie : B
Quantité : 50
Prix unitaire : 2.50
Et afficher le résultat suivant :
50 articles S, de catégorie B, à 2.50 pièce coûtent : 125.000 francs
#include <stdio>
main()
{
clrscr() ;
int q ;
float p ;
Char A,C ;
/*déclaration des variables*/
Printf(" veuillez entrer le nom de l"article : ") ;
Scanf(" %c ",&A) ;
Printf(" entrer sa catégorie : ") ;
Scanf(" %c ", &c) ;
Printf(" enter son prix ") ;
Scanf(" %f,&p ") ;
Printf(" entrer sa quantité ") ;
Scanf(" %d,&q ") ;
Getch() ;
}
Exemple pour introduire l?instruction if :
Choix entre deux instructions :
#include <stdio.h>
main()
{
int n,p ;
Printf(" donnez deux nombres entiers : ") ;
Scanf("%d%d ",&n,&p ") ;
If (n<p) printf (" croissant\n ")
Else
Printf (" decroissant\n ") ;
}
Exemple :
#include <stdio.h>
main()
{
int n,p,max ;
Printf(" donnez deux nombres entiers : ") ;
Scanf("%d%d ",&n,&p ") ;
If (n<p)
{
max=p
printf (" croissant\n ")
}
Else
{
max=n
Printf (" decroissant\n ") ;
}
Printf(" le plus grand des deux nombres est : %d\n " ,max) ;
}
Exemple :
If(n<p) (bloc 1)
Else (bloc 2)
Donnez deux nombres entiers : 12 45
Croissant
Le plus grand des deux nombres est 45.
Un cas particulier if : l?exécution conditionnelle
Il n?est pas nécessaire qu?une instruction if comporte une partie introduite par else.
Exemple :
If(n<p)printf(" croissant\n ") ;
Printf(" fin du programme ") ;
La syntaxe de l?instruction if
D?une manière générale, l?instruction if se présente sous l?une des deux formes suivantes :
If (condition) If(condition)
Instruction_1 Instruction_1
Else
Instruction_2
Instruction_1 et Instruction_2
Instruction simple,
Instruction structurée,
Bloc
Exemple : {if(n<p)printf(" croissant\n ") ;
Max=b
}
else
Printf(" décroissant\n ") ;
L?instruction vide
If(n<p) {....}
Else {.....}
Les conditions simples et les opérateurs de comparaisons
Les différents opérateurs de comparaison du C sont :
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
N !=p vrai si la valeur de n est différente de celle de p
C1=?e? vrai si le caractère C1 et le caractère e.
Les conditions composées et les opérateurs logiques
|
|
|
|
|
|
|
|
|
|
|
|
(a<b)&&(c<d)
prend la valeur vraie si les deux conditions a<b et c<d sont toutes les deux vraies, la valeur fausse dans le cas contraire.
Exemple : (a<b)II(c<d)
Prend la valeur vraie si l?une au moins des deux conditions a<b et c<d est vraie.
!(a<b)®
a<b n?est pas vraie (fausse).
Exercice 1
Donner un programme qui demande à l?utilisateur de lui fournir une lettre minuscule se situant entre les lettres d et m (les lettres inclues) et qui précise si la réponse est correcte ou non.
#include <stdio.h>
main()
{char?a? ;
printf(" rentrer une lettre minuscule entre d et m (inclues) ") ;
Scanf(" %c ",&a) ;
If((a>=?d?) && (a<=?m?) )
Printf(" correct\n ") ;
Else
Printf(" incorrect ") ;
}
Exercice 2
Ecrivez un programme qui lit trois nombres entiers et qui précise s?ils sont ou non rangés par ordre croisant strict.
#include <stdio.h>
main()
{int ent,a,b ;
printf(" entrer trois nombres entiers ") ;
Scanf(" %d%d%d,&ent,&a,&b ) ;
If((a<b) && (b<ent) )
Printf(" croissant\n ") ;
Else
Printf(" decroissant") ;
}
Exercice 3
Donnez un programme qui résoud une équation du 1er degré (de la forme ax+b=0). Il lit les deux coefficients et fournit soit la racine s?il existe, soit un message précisant que l?équation est impossible (a=0 et b=non nul) ou indéterminée (a=0 et b=0)
#include <stdio.h>
main()
{float a,b,racine ;
printf(" entrer les deux coefficients : ") ;
Scanf(" %e%e,&a,&b ) ;
If(a !=0)
{racine=-b/a
Printf(" solution :%e\n ", racine) ;
Else
If(B==0)
Printf(" solution indéterminée") ;
Else
Printf(" pas de solution ") ;
}
y= ax+b
0=ax+b
-b/ a= x
Les structures de répétition
Ces structures de répétition consiste à exécuter à plusieurs reprises une instruction ou un bloc d?instruction.
L?instruction do..........while
#include <stdio.h>
main()
{
int n ;
do
printf("donner un nombre entier :") ;
Scanf(" %d,&n) ;
Printf(" voici son carre :%d\n ",n*n) ;
}
while (n !=0) ;
Printf(" fin du programme") ;
}
ctrl + c= arrêt du programme
On demande ici de répéter le bloc d?instruction en examinant à chaque fois (après exécution du bloc d?instruction) si la condition mentionnée (n !=0) est vraie, si tel est le cas, le bloc est de nouveau répété. Dans le cas contraire, la répétition s?arrête et l?on passe à l?instruction suivante.
La syntaxe de l?instruction do.....while
Do instruction
While (condition) ;
Exercice
Ecrivez un programme qui demande à l?utilisateur de lui fournir un nombre entier positif et inférieur à 100 et ceci jusqu?à ce que la réponse soit satisfaisante. Dans le cas contraire se présentera de la façon suivante :
< Donnez un entier positif inférieur à 100 : 452
< Donnez un entier positif inférieur à 100 : 0
< Donnez un entier positif inférieur à 100 : 28
< Merci pour le nombre 28
#include <stdio.h>
main()
{
int n ;
do
{
printf("donner un nombre entier positif :") ;
Scanf(" %d,&n) ;
}
while ((n<=0)||(n>=100);
Printf(" merci pour le nombre %d ",n) ;
}
n>0 et n<100 = n<=0 ou n>=100
L?instruction while
L?instruction do.....while permet de réaliser les structures de répétition conditionnelle dans laquelle la décision de poursuivre la répétition est effectuée à la fin de l?exécution des instructions concernant en langage c, il existe une autre instruction while, analogue à la précédente dans laquelle la décision de poursuivre la répétition est effectuée avant l?exécution des instructions concernées.
La syntaxe de l?instruction while
While (condition)
Instruction
Lien entre do.......while et while
Do instruction while (condition) ;
Est équivalent à :
Instruction
While (condition) instruction
De même :
While (condition) instruction
Est équivalent à :
Do if (condition) instruction
While (condition)
Exercice
Ecrivez le programme du 1er exemple de l?instruction do....while en utilisant l?instruction while.
#include <stdio.h>
main()
{
int n ;
{
printf("donner un nombre entier :") ;
Scanf(" %d,&n) ;
Printf(" voici son carre :%d\n ",n*n) ;
}
while (n !=0) ;
{
printf("donner un nombre entier :") ;
Scanf(" %d,&n) ;
Printf(" voici son carre :%d\n ",n*n) ;
Printf(" fin du programme") ;
}
Autre exemple
#include <stdio.h>
main()
{
int n ;
n=1 ;/*valeur arbitraire non nulle pour forcer le premier tour de la boucle*/
while(n !=0)
{instruction
}
printf(" fin du programme ") ;
}
La notion de compteur de boucle
Il est possible de compter les tours de boucles à l?aide d?une variable entière qu?on initialise et qu?on augmente de un valeur à chaque tour.
On peut utiliser ce compteur de deux façons différentes :
- soit simplement pour en exploiter la valeur, aussi bien dans les instructions à l?intérieur de la boucle que dans les instructions à l?intérieur de la boucle que dans les instructions après la fin de la boucle, on parle alors d?exploitation passive.
- soit pour limiter effectivement le nombre
de tours de boucle en introduisant une condition de poursuite faisant intervenir
le compteur ; on parle alors d?exploitation active.
Exemple
#include <stdio.h>
main()
{
int n ;/*pour le nombre fourni par l?utilisateur*/
int i ;/*pour le nombre de valeurs à traiter*/
i=0 ;
do
{
i=i+1 ;/*+1 sur le compteur*/
Printf(" donner le %dème nombre entier : ") ;
Scanf(" %d,&n) ;
Printf(" voici son carre :%d\n ",n*n) ;
while (n !=0) ;
printf("vous avez fourni %dvaleurs (y compris le 0 de fin)\n ",i) ;
}
< Donnez le 1er nombre entier : 5
Voici son carré : 25
< Donnez le 2ème nombre entier : 12
Voici son carré : 144
< Donnez le 3ème nombre entier : 0
Voici son carré : 0
Vous avez fourni 3 valeurs (y compris le 0 de fin)
Remarque
L?instruction est : i=i+1, et peut également s?écrire i++ ;
Exercice
Ecrivez un programme qui lit une suite de caractères (limitée par une validation donc un caractère de fin de ligne) et qui affiche le nombre de caractères lus (fin de ligne non comprise)
#include <stdio.h>
main()
{
int i ;
char C ;
{
printf(" entrer une suite de caractères:\n ") ;
scanf(" %c ",&c) ;
}
while (C !=?\n?)
printf(" le nombre de caractères est %d ,i ") ;
}
Correction
#include <stdio.h>
main()
{
int n car ;/*nombre de caractères*/
char C ;/*pour lire un caractère*/
printf(" donnez une ligne quelconque : \n") ;
ncar=0 ;
do
{
ncar= ncar+1 ; /*le compteur*/
scanf(" %c ",&c) ; /*lecteur d?un caractère*/
while (C !=?\n?) ; /*jusqu?à fin*/
printf(" la ligne comporte %d caractère ",ncar) ;
}
}
Exercice
Ecrivez un programme déterminant le nombre de lettres e (minuscules) contenues dans un texte fourni en donnée (cette ligne est supposée ne pas dépasser 128 caractères) puis affiche le nombre e que contient le texte réaliser un programme qui utilise l?instruction do....while.
#include <stdio.h>
main()
{
int i ;
char C ;
{
printf(" entrer une suite de caractères: \n ") ;
scanf(" %c ",&c) ;
if(c ==?e?),i=i+1 ;
while (C !=?\n?)
printf(" le nombre de caractères est %d, i ") ;
}
}
Comment imposer un nombre de tours : exploitation active ?
Nos précédents exemples utilisaient un concours de répétition de façon passive. Il est facile d?exploiter un compteur pour imposer un nombre de répétitions et donc de réaliser uns structure de boucles inconditionnelles.
Exemple
#include <stdio.h>
main()
{
int n; /*nombre fourni par l?utilisateur*/
int i ; /*compteur du nombre des valeurs précaires*/
i=0 ;
do
{
printf(" donner un nombre entier: \n ") ;
scanf(" %d ",&n) ;
printf(" %d "\n,n*n) ;
i=i+1
while(i<4) ; /*nouvelle condition d?arrêt*/
}
L?instruction for
Lorsque l?on exploite un compteur, on peut imposer le nombre de tours et une instruction while. Iles possible de simplifier les choses en faisant appel à l?instruction for.
I=0 ;
While (i<4)
For(i=0 ; i=i+1)
{
instruction à répéter
}
Syntaxe de l?instruction for
For (avant, condition, fin de tour)
Instruction
Avant est une instruction qui sera exécuté avant le premier tour de boucle.
La condition est la condition de poursuite de la boucle examiné avant chaque tour de boucle.
La fin de tour est une instruction qui sera exécuté à la fin de chaque tour de boucle.
I=0 ;
While(condition)
{
instruction
fin de tour
}
Exercice 1
Ecrivez un programme qui affiche d?entrées consécutifs à partir d?une valeur donnée p, les valeurs notées ici n et p étant lues en données.
Valeur initiale et nombre de valeurs : 48 4
48
49
50
51
}
#include <stdio.h>
main()
{
int n,p,i;
printf(" donner un nombre entier: \n ") ;
scanf(" %d %d",&n,&p) ;
for(i=n,i<n+P , i=i+1)
{
printf(" vous avez fourni %d valeurs\n ",i) ;
}
}
Exercice 2
Compter le pourcentage de lettres " e " d?une ligne. Il faut utiliser à la fois un compteur systématique pour connaître le total de lettres et un compteur sélectif pour le nombre de e. Utilisez l?instruction do.......while.
#include <conio.h>
#include <stdio.h>
main()
{
int i ,s;
float p ;
char c ;
s=0 ;
i=0 ;
clrscr() ;
do
{
printf(" donner le total de lettres: \n ") ;
scanf(" %c",&c) ;
s=s+1 ;
if(c==?e?)
i++ ;
}
while (c !=?\n?)
{
p=(100*i)/s ;
printf(" il y a %f pour cent due dans le texte "\n ",p) ;
if(i=0)
printf(" il n" y a pas de e ") ;
getch() ;
}
}
Exercice 3
Ecrivez un programme qui lit 20 notes entières et qui indique le pourcentage de notes supérieur à 10.
#include <stdio.h>
main()
{
int i ,s;
float p ;
int N ;
s=0 ;
i=0 ;
printf(" entrer les notes entières: \n ") ;
for(i=n,i<20, i=i+1)
{
scanf(" %d",&n) ;
if(n>10)
s=s+1 ;
}
if(s==0)
printf(" aucune note>10\n ") ;
else
{
p=100*s/20
printf(" le pourcentage de notes supérieures à 10 est %f ",p) ;
}
}
Pour un tableau à une dimension (ou à un indice)
On repère chaque élément du tableau par un indice. IL s?agit alors d?une liste de valeurs de même type, désignée par un nom unique.
Exemple :
Supposons que l?on peut écrire un programme qui vise 5 valeurs avant d?en afficher les différents carrés et cubes.
Le dialogue
Donner cinq nombres entiers : 11, 9, 14, 15, 32
Nombres Carré Cube
11 121 1331
9 81 729
14 196 2744
25 625 15625
32 1024 32768
Pour un tableau à deux dimensions
Chaque valeur du tableau est repérée par deux indices. Elle est constituée de lignes et de colonnes.
Solution : le tableau
Ø Attribuer un seul nom à l?ensemble des cinq valeurs par exemple Nombres
ØRepérer chaque valeur par ce nom entre crochet [ ] une valeur entière comprise entre 0 et 4 qu?on appelle indice.
Ex : Nombres [i]
En langage C, le 1er élément commence par 0.
Plus généralement, si i est
une valeur numérique de type int dont la valeur est comprise entre
0 et 4 , on parle de nombre [i].
| Nombres [0] | Nombres [1] | Nombres [2] | Nombres [3] | Nombres [4] |
® Comment utiliser un tableau à une dimension ?
Comme pour une variable, le compilateur doit être en mesure de réserver l?emplacement d?un tableau et doit connaître le type de différents éléments du tableau. Ces informations sont données par une instruction de déclaration.
Exemple : int nombres [5] ; /*5 éléments : la taille du tableau*/
Int Nombres [5] , tab [7] ;
L?affectation de valeurs à un tableau
Int X [4].
Les instructions :
X [0] =12 ;
X [1] = 5 ;
X [2] = 8 ;
X [3] = 20 ;
| 12 | 5 | 8 | 20 |
Exemple :
Char voy [4] ;
Les instructions :
Voy [0] = ?e? ;
Voy [1] = ?-? ;
Voy [2] = ?c? ;
Voy [3] =?d? ;
| E | - | C | d |
Exemple :
Int X [4] ;
X[0] =1 ;
X[1] =1 ;
X[2]=1 ;
X[3]=1 ;
Les instructions peuvent être remplacées par une répétition utilisant un compteur i dont la valeur progresse de 0 à 3.
Int X [4] ;
Int i ;
For(i=0, i<4 ; i++)
X[i] = 1 ;
De même, si t1 et t2 sont deux tableaux de même type et de même taille.
Int t1 [1000], t2 [1000] ;
For(i=0, i<1000, i++) t1 [i]=t2 [i] ;
Lecture d?élément d?un tableau
Int X [4].
Scanf(" %d ",&X [0]) ;
&X 50] signifie l?adresse de 1er élément c?est-à-dire &X[0] ; (de type int) du tableau X. On peut utiliser une répétition appropriée pour lire des valeurs pour chacun des éléments de X.
For (i=0, i<4, i++) ;
Scanf(" %d ",&X[i]) ; /*lire l?élément d?indice*/
Ecriture d?éléments d?un tableau
Il suffit d?appliquer à un élément
de tableau (variable indice) ce que l?on sait faire avec une variable simple
de type identique.
Exemple :
For (i=0, i<4, i++) ;
Printf(" %d ", &x[i]) ; /* écrire l?élément d?indice */
Exercice
Ecrire un programme qui lit 5 valeurs avant d?en afficher les différents carrés puis les différents cubes.
#include <stdio.h>
main ()
{
int tab [5] ;
int i ;
printf(" entrer les 5 valeurs\n ") ;
for(i=0, i<5, i++) ;
scanf(" %d,&tab[i]) ;
printf(" nombres\t carre\n ") ;
for(i=0, i<5,i++) ;
printf(" %d\t\t%d\n ", tab[i],tab[i]*[i]) ;
printf(" nombres\t cube ") ;
for(i=0, i<5, i++) ;
printf(" %d\t\t%d\n ", tab[i]*tab[i]*tab[i]) ;
}
Initialisation du tableau à une dimension
Int tab [5] = {10, 20, 5, 0, 3} ;
Char X [3] = {?0?, ?e?, ?c?} ;
Int tab [<] = {3, 4} ;
Modification de la dimension d?un tableau
Float tab [10] ;
Float tab [25] ;
L?idée serait alors d?utiliser une variable déclarée ainsi :
Int nel = 10 ;
Float tab [nel] ; /* nel n?est pas une constante*/
#define nel 10
main ()
{
float tab [nel] ;
}
L?instruction #define demande au compilateur de remplacer avant d?entamer la traduction du programme. Le symbole nel par 10 apparaît.
Le
tableau à 2 dimensions
|
|
|
|
|
|
|
|
|
|
|
|
Tab [2] [2] ; /* 4 éléments =2*2*/
Tab [0] [0] = 12 ;
Tab [0] [1] = 14 ;
Tab [1] [0] = 8 ;
Tab [1] [1] = 10 ;
Tab [i] [j] ;
I = lignes
J = colonnes
Tab [3] [4] ; /*12 éléments*/
Exemple :
Int i, j ;
For (i=0, i<2, i++)
Tab [i] [j] =1 ; /* tous les éléments = 1*/
Lecture d?un tableau à deux dimensions
Int tab [3] [4] ;
Scanf (" %d ",&tab [1] [2]) ;
For(i =0 ; i<3, ; i++)
For (j=0 ; j<4 ; i++)
Scanf (" %d ",&tab [i] [j]) ;
Initialisation d?un tableau à deux dimensions
Int tab [3] [4] = {{1, 2, 3, 4} ;
{6, 7, 10, 11} ;
{0,3,4,2}};
Int tab [3] [4] = {1, 2, 3 ,4, 6, 7, 10, 11, 0,3, 4 , 2} ;
Exemple :
Int tab [3] [4] [5] ;
OE
For (i=0 ; i<4 ; i++] /* résultat : 1 2 3 4 */
5 6 7 8
{
printf (" \n ") ;
for (j=0 ; j<2 ;j++)
Scanf (" %d ", x[i], [j]) ;
}

For (j=0 ; j<2 ; j++) ;
For (i=0 ; i<4 ; i++) ;
Scanf (" %d ", x[i] [j]) ;
Résultat : 15263748
Ž
For (i=0 ; i<2 ; i++)
For (j=0 ; j<4 ;j++)
Scanf (" %d ", x [i] [j]) ;
Résultat
: 12345678
Exercice 1
Soit la déclaration int tab [3] [4] ;
Ecrire un programme qui lit 12 valeurs pour le tableau tab en les demandant lignes par lignes et qui réecrit colonnes par colonnes comme dans : donnez les valeurs de la ligne 0 : 3452. Puis, donnez les valeurs de la ligne 1 : 0 2 3 9. Voici la colonne n° 0 : 3 9 0, la colonne N°1 : 4 8 2 , la colonne N°2 : 5 1 2 3, la colonne N°3 : 2 3 9.
#include <stdio.h>
main()
{
Int tab [3] [4] ;
Int i, j ;
For (i =0 ; i<3 ; i++) ;
{
printf(" donner les valeurs de la ligne %d\n, i) ;
For (j=0 ; j<4 ; j++)
Scanf (" %d ", &tab [i] [j]) ;
}
For (j=0 ; i<4 ; j++)
{
printf (" voici la colonne %d\n ", j) ;
For (i=0 ; i<3 ; i++) ;
Scanf (" %d ", &tab [i] [j]) ;
}
}
Quelques règles
Les paramètres formels (muets) : ce sont des paramètres qui figurent dans l?en-tête d?une fonction s?appellent des paramètres muets (formels). Le rôle de ces paramètres est de permettre au sein du corps de la fonction d?écrire ce qu?elle doit faire.
Les paramètres effectifs ce sont des paramètres fournis lors de l?appel de la fonction s?appellent des paramètres effectifs.
L?instruction return peut mentionner un nom de variable ou n?importe quelle expression.
Float cube (float x)
{
return (x*x*x) ;
}
Le rôle de l?instruction return est double : d?une part, il précise la valeur fournie en résultat. D?autre part, il met fin à l?exécution des instructions de la fonction.
Exemple de fonction déterminant le maximum de deux valeurs
{
Float max (float a, float b)
Int m ;
If (a>b)
M =a ;
Else
M = b ;
Return m ;
}
Exemple :
Float max (float a, float b)
{
if (a >b)
Return a ;
else
Return b ;
}
Le cas des fonctions sans paramètres
Si une fonction ne possède aucun paramètre, son en-tête et sa déclaration doivent comporter le mot void à la place de la liste des paramètres.
Exemple :
Int f1 (void)
Void int (void)
Dans ce cas, la fonction ne reçoit aucun paramètre et ne fournissant aucun résultat.
Exercice
Ecrire une fonction sans paramètre, ni valeur de retour appelée fonction qui place la valeur 1 de 10 éléments d?un tableau d?entiers appelés tab déclaré d?une fonction globale.
#include <stdio.h>
int tab [10] ;
void main (void)
{
Void fonct (void) ; /*déclaration de la fonction, prototype*/
Fonct () ; /* pas de paramètres et faire appel à la fonction */
Void fonct (void) ; /* on définit l?instruction et met l?en-tête */
{
int i ;
for (i =0 ; i< 10 ; i++)
tab [i] = 1 ;
}