Langage C

Télécharger au format pdf ou txt
Télécharger au format pdf ou txt
Vous êtes sur la page 1sur 116

Introduction au langage C

Z. D. SANOU HT L1 BOBO 22 23 1
PLAN (30H)
Chap 1. Introduction
Chap 2. Les variables et les types de données
Chap 3. Entrées sorties conversationnelles
Chap 4. Les opérateurs du langage C
Chap 5. Les structures de contrôles
Chap 6. Tableaux

Z. D. SANOU HT L1 BOBO 22 23 2
Chapitre 1. Introduction

Z. D. SANOU HT L1 BOBO 22 23 3
Langage de programmation

Z. D. SANOU HT L1 BOBO 22 23 4
Un langage de programmation est un code de
communication entre un humain et une machine.
A l'aide de ces langages on peut écrire des
programmes.

Plusieurs langage : Java, C#, PHP, C++, Python, C,



Z. D. SANOU HT L1 BOBO 22 23 5
Le langage C a été crée par Dennis Ritchie au
début des années 70 afin d'éviter autant que
possible l'utilisation de l'assembleur dans
l'écriture du système UNIX.

Z. D. SANOU HT L1 BOBO 22 23 6
Le langage C est un langage évolué et structuré. Il
possède assez peu d'instructions et fait par contre
appel à des bibliothèques, fournies en plus ou
moins grand nombre avec le compilateur.

Z. D. SANOU HT L1 BOBO 22 23 7
Avantage du C
Universel
Prés de la machine
Rapide
Indépendant de la machine
Portable
extensible
Z. D. SANOU HT L1 BOBO 22 23 8
C'est quoi un programme

Z. D. SANOU HT L1 BOBO 22 23 9
Z. D. SANOU HT L1 BOBO 22 23 10
Structure générale d'un
programme C

Z. D. SANOU HT L1 BOBO 22 23 11
La transformation d'un texte écrit en langage C en
un programme exécutable par l'ordinateur se fait
en deux étapes : la compilation et l'édition de
liens.

Z. D. SANOU HT L1 BOBO 22 23 12
La compilation est la traduction des fonctions
écrites en C en des procédures équivalentes écrites
dans un langage dont la machine peut exécuter les
instructions.

Le compilateur lit toujours un fichier, appelé fichier


source, et produit un fichier, dit fichier objet.
Z. D. SANOU HT L1 BOBO 22 23 13
L'édition de liens est l'opération par laquelle plusieurs
fichiers objets sont mis ensemble pour se compléter
mutuellement.
Le résultat est un unique fichier exécutable.
Chaque fichier source entrant dans la composition d'un
programme exécutable est fait d'une succession d'un
nombre quelconque d'éléments indépendants, qui sont :
Z. D. SANOU HT L1 BOBO 22 23 14
• des directives pour le préprocesseur (lignes
commençant par #),
• des constructions de types (struct, union, enum,
typedef),
• des déclarations de variables et de fonctions externes,
• des définitions de variables et
• des définitions de fonctions.

Z. D. SANOU HT L1 BOBO 22 23 15
La règle généralement suivie par l'éditeur de liens
est la suivante : parmi les fonctions données il doit
en exister une dont le nom est main. C'est par elle
que l'exécution commencera.

Elle est unique et obligatoire dans tous les


programmes C.
Z. D. SANOU HT L1 BOBO 22 23 16
Z. D. SANOU HT L1 BOBO 22 23 17
• Une instruction est délimitée à la fin par un point-
virgule et s’écrit donc : instruction ;
• un bloc d’instructions
{
instruction1 ;
instruction2 ;
instruction3 ;
}
Z. D. SANOU HT L1 BOBO 22 23 18
• Les commentaires commencent par /* et se terminent
par */ ou // Ceci est un commentaire de la mode C++.

• Le langage C distingue les minuscules, des majuscules.

• Les mots réservés du langage C doivent être écrits en


minuscules.

Z. D. SANOU HT L1 BOBO 22 23 19
Les directives destinées au préprocesseur comportent,
dans l'ordre :
• un signe # (qui, en syntaxe originale, doit occuper la
première position de la ligne) ;
• un mot-clé parmi include, define, if, ifdef, ifndef, else
et endif qui identifie la directive.

Z. D. SANOU HT L1 BOBO 22 23 20
Sous la forme :
#include <nom-de-fichier>
Ex : #include <stdio.h>
#define nom corps
Ex :
#define NBLIGNES 15
#define NBCOLONNES (2 * NBLIGNES)
Z. D. SANOU HT L1 BOBO 22 23 21
Quelques bibliothèques standards du c

Z. D. SANOU HT L1 BOBO 22 23 22
Exemple de programme C
#include <stdio.h>
int main() {
printf("Bonjour\n");
return 0;
}

Z. D. SANOU HT L1 BOBO 22 23 23
L'environnement de
développement : Code Blocks

Z. D. SANOU HT L1 BOBO 22 23 24
Chapitre 2. Les variables et les
types de données

Z. D. SANOU HT L1 BOBO 22 23 25
Qu'est ce qu'une variable ?
La programmation est basée sur deux concepts
nécessaires : les variables et les instructions.
Dans un programme, une variable est
caractérisée par :

Z. D. SANOU HT L1 BOBO 22 23 26
Le nom d'une variable
Les noms de variable en C sont composés d'une suite
de lettres et de chiffres dont le premier ne peut être
un chiffre.
Les symboles utilisables sont donc :
0, 1, 2, …, 9
A, B, …, Z
A, b, …, z
'_'
Les majuscules et minuscules sont différenciées.

Z. D. SANOU HT L1 BOBO 22 23 27
Les types de variable
Le C est un langage typé. Les types de base en C concernent
les entiers,
les caractères
les nombres réels.
En C, à un type donné, correspond toujours un nombre
limité de valeurs différentes.

Z. D. SANOU HT L1 BOBO 22 23 28
Les types entiers
Le mot-clé int correspond à la représentation de
nombres entiers. Les différents types d'entier sont :
• short int (qu’on peut abréger en short),
• int,
• long int (qu’on peut abréger en long).

Z. D. SANOU HT L1 BOBO 22 23 29
Les types caractères : char
Ce type permet de représenter un caractère comme
une lettre, un chiffre, …

Lorsqu’ils correspondent à des caractères imprimables,


on les met entre apostrophes (ou quotes).

Z. D. SANOU HT L1 BOBO 22 23 30
Les types numériques (Entier) en C
Type de données Signification Plage de valeurs
acceptées
char caractère -128 à 127
unsigned char Caractère non signé 0 à 255
short Entier court -32768 à 32767
unsigned short Entier court non signé 0 à 65535
int Entier -32768 à 32767
unsigned int Entier non signé 0 à 65535
long Entier long -2Md à 2Md
unsigned long Entier long non signé 0 à 4Md
Z. D. SANOU HT L1 BOBO 22 23 31
Les types réels
Le type float permet de représenter des nombres réels.
La notation décimale doit comporter obligatoirement
un point.

Z. D. SANOU HT L1 BOBO 22 23 32
Les types numériques (rationnels) en C
Type de données Signification Plage de valeurs acceptées
float Flottant (réel) -3,4*10-38 à 3,4*1038
double Flottant double -1,7*10-308 à 1,7*10308
long double Flottant double long -3,4*10-4932 à 3,4*104932

La précision est de
• 6 chiffres après la virgule pour le float
• 15 chiffres après la virgule pour le long
• 17 chiffres après la virgule pour le long double
Z. D. SANOU HT L1 BOBO 22 23 33
Les déclarations de variable
Syntaxe :
Type NomVariable [= valeur];
Exemple
char x;
int y;
float moy;
long i, j, k;
Z. D. SANOU HT L1 BOBO 22 23 34
Accès au contenu d'une variable par le nom de la
variable

Z. D. SANOU HT L1 BOBO 22 23 35
Initialisation
Le C permet l'initialisation des variables dans la
zone de déclaration

Z. D. SANOU HT L1 BOBO 22 23 36
Z. D. SANOU HT L1 BOBO 22 23 37
Les constantes
• const type nom_variable = valeur;
Exemple : const int coef = 2;
• #define identificateur valeur
Exemple : #define coef 2

Z. D. SANOU HT L1 BOBO 22 23 38
Chapitre 3. Entrées sorties
conversationnelles

Z. D. SANOU HT L1 BOBO 22 23 39
Z. D. SANOU HT L1 BOBO 22 23 40
3.1 L'affichage
La fonction printf est une fonction d’affichage des
données et des messages sur écran. C'est une fonction
de la bibliothèque stdio.h.
Sa syntaxe générale est :
printf(format,[liste_d'expression]);

Z. D. SANOU HT L1 BOBO 22 23 41
Affichage des messages simples
Syntaxe : printf("message");
Exemple :

Z. D. SANOU HT L1 BOBO 22 23 42
Affichage des messages contenant des variables
Syntaxe : printf("%format1% format2…" Exp1, Exp2,…);
Exemple :

Z. D. SANOU HT L1 BOBO 22 23 43
Les spécificateurs de format :
Format Type Impression comme
%d int Entier
%f float Réel
%c char, int Caractères
%s char* Chaîne de caractères

Z. D. SANOU HT L1 BOBO 22 23 44
En plus du code de conversion, on peut modifier :
• Le gabarit d'affichage
Exemple :
%3d : entier avec 3 caractères minimum
• La précision
Exemple :
%.2f : réel avec 2 chiffres après la virgule.

Z. D. SANOU HT L1 BOBO 22 23 45
3.2 La saisie de données
La fonction scanf appartenant à la bibliothèque stdio.h,
permet la saisie clavier de n'importe quel type de
données.

Syntaxe :

scanf("%format", &variable);

Z. D. SANOU HT L1 BOBO 22 23 46
• La chaine de format détermine comment les données
reçues doivent être interprétées.
%d pour entier, %f pour réel, %c pour caractère,...
• Adresse de la variable dans laquelle la valeur sera
stockée. Elle est indiquée par le nom de la variable
précédée du signe &.

Z. D. SANOU HT L1 BOBO 22 23 47
Z. D. SANOU HT L1 BOBO 22 23 48
Exemples:
char alpha;
int i;
float r;
scanf("%c",&alpha); /* saisie d'un caractère */
scanf("%d",&i); /* saisie d'un entier */
scanf("%f",&r); /* saisie d'un réel */
Z. D. SANOU HT L1 BOBO 22 23 49
Exercices (TP) :
1. Ecrire un programme C qui permet de saisir deux
entiers A, V, un réel B et un caractère C puis affiche
leur contenu.
2. Un programme permettant de calculer le prix d'un
produit TTC sachant que le taux de TVA est de 18%.
3. Programme permettant de calculer et afficher la
moyenne semestrielle (2 chiffres après virgule) d'un
étudiant sachant que celui-ci a obtenu 4 notes au
cours du semestre.
Z. D. SANOU HT L1 BOBO 22 23 50
4.Ecrire un programme C qui échange deux entiers saisis.
Afficher les entiers avant et après l'échange.
5.Un programme qui affiche le code ASCII des lettres et des
chiffres saisis sous la forme suivante :
Caractère A code = 65
Caractère B code = 66
….
Caractère 1 code = 49
….
Caractère 9 code = 57

Z. D. SANOU HT L1 BOBO 22 23 51
Chapitre 4. Les opérateurs du
langage C

Z. D. SANOU HT L1 BOBO 22 23 52
Z. D. SANOU HT L1 BOBO 22 23 53
Le langage C est certainement l’un des langages les plus
fournis en opérateurs. En plus des opérateurs classiques
(arithmétiques, relationnels, logiques), il dispose d’un
important éventail d’opérateurs originaux d’affectation
et d’incrémentation.

Z. D. SANOU HT L1 BOBO 22 23 54
4.1. Les opérateurs arithmétiques
+ - * / %
Addition Soustraction Multiplication Division Modulo
Exemples :
Programme C déclarant 2 variables entières et affichant
leur somme et leur produit.

Z. D. SANOU HT L1 BOBO 22 23 55
Les opérateurs arithmétiques ne sont définis que
lorsque leurs deux opérandes sont de même type. Mais
on peut écrire des "expressions mixtes" dans lesquelles
interviennent des opérandes de types différents.
Pour que cela soit possible, le compilateur va mettre en
place des instructions de conversion de type.

Z. D. SANOU HT L1 BOBO 22 23 56
Une conversion telle que int -> float se nomme une « conversion
d’ajustement de type ».
Une telle conversion ne peut se faire que suivant une hiérarchie
qui permet de ne pas dénaturer la valeur initiale, à savoir :
int -> long -> float -> double -> long double
On peut bien sûr convertir directement un int en double ; en
revanche, on ne pourra pas convertir un double en float ou en
int.

Z. D. SANOU HT L1 BOBO 22 23 57
Les opérateurs numériques n'étant pas définis pour les
types char et Short, le langage C prévoit tout simplement
que toute valeur de l’un de ces deux types apparaissant
dans une expression est d’abord convertie en int, et cela
sans considérer les types des éventuels autres opérandes.
On parle alors, dans ce cas, de "promotions numériques".

Z. D. SANOU HT L1 BOBO 22 23 58
4.2. L'assignation (affectation)
En C, l’affectation se fait par le signe = et effectue une
conversion de type implicite.
En pratique, nous effectuons souvent des affectations
de type Somme = Somme + i;
En C, nous utiliserons la formulation plus compacte :
Somme += i;
L'opérateur += est un opérateur d'affectation

Z. D. SANOU HT L1 BOBO 22 23 59
La syntaxe générale est de la forme : Exp1 op= Exp2
Les opérateurs d'affectation composée sont donc :
Opérateur composé Expression abrégée Equivalence
+= C+=3 C=C+3
-= C-=3 C=C-3
*= C*=3 C=C*3
/= C/=3 C=C/3
%= C%=3 C=C%3

Z. D. SANOU HT L1 BOBO 22 23 60
4.3. Les opérateurs d’incrémentation et de décrémentation
Les affectations les plus fréquentes sont du type
X = X + 1 et X = X -1.
En C , il y a deux opérateurs qui peuvent faire la même chose :
++ et --
++ est un opérateur de
• Pré-incrémentation si ++Var
• Post-incrémentation si Var++
Z. D. SANOU HT L1 BOBO 22 23 61
Exemple :

Z. D. SANOU HT L1 BOBO 22 23 62
Exemples :

Z. D. SANOU HT L1 BOBO 22 23 63
- - est un opérateur de
• Pré-décrémentation si - -Var
• Post-décrémentation si Var- -
Ex1 : Ex3 :
int i=0, j=0; int i=2, j=0;
j = ++i; j = --i;
Ex2 : Ex4 :
int i=0, j=0; int i=2, j=0;
j = i++; j = i--;

Z. D. SANOU HT L1 BOBO 22 23 64
4.4. Les opérateurs de comparaisons
> >= < <= == !=
supérieur supérieur inférieur inférieur égal différent
ou égal ou égal

En C, le résultat de la comparaison est, non pas une


valeur booléenne (vrai ou faux), mais un entier valant 0
ou 1.

Z. D. SANOU HT L1 BOBO 22 23 65
4.5. Les opérateurs logiques booléens

&& et logique

|| ou logique

! négation logique

Syntaxe :

expression1 op expression2
Z. D. SANOU HT L1 BOBO 22 23 66
4.6. L'opérateur conditionnel : (?)
C'est un opérateur ternaire. Ses opérandes sont des
expressions.
Syntaxe : expr1 ? expr2 : expr3
Si la valeur de l'expression expr1 est vraie, seule l'expression
expr2 est évaluée sinon c'est l'expression expr3 qui est évaluée.

Exemple : max = a > b ? a : b;


Si a > b alors max = a Sinon max =b

Z. D. SANOU HT L1 BOBO 22 23 67
4.7. Les conversions explicites (opérateur de "cast")
En C, le programmeur peut, s’il le souhaite, forcer la conversion
d’une expression quelconque dans un type de son choix selon
la syntaxe (type) expression_a_caster

Ex : double d; int i = 20, j = 7;


d=i/j;
d=(double)(i/j);
d=(double)(i)/j;

Z. D. SANOU HT L1 BOBO 22 23 68
Exercice
Décomposer les suites d'instructions et donner la valeur de i, j, n après
exécution :
int i, j, n;
i=0; n=++i;
printf ("A : i = %d ", i , " n= %d",n);
i=10; n=++i;
printf ("B : i = %d", i , " n= %d",n);
i=20; j=5; n=i++*++j;
printf ("C : i = %d", i , " j= %d", j , " n= %d",n);
i=15; n= i +=3;
printf ("D : i = %d", i , " n= %d",n);
i=3; j=5; n=i *= --j;
printf ("E : i = %d", i , " j= %d" , j , " n= %d",n);

Z. D. SANOU HT L1 BOBO 22 23 69
Chapitre 5. Instructions du
langage C

Z. D. SANOU HT L1 BOBO 22 23 70
I. Structures conditionnelles

Z. D. SANOU HT L1 BOBO 22 23 71
On appelle structure conditionnelle les instructions qui
permettent de tester si une condition est vraie ou
fausse.

Z. D. SANOU HT L1 BOBO 22 23 72
Rappel : les expressions

Z. D. SANOU HT L1 BOBO 22 23 73
La structure if
Si la condition de la structure If est vraie, on peut
exécuter une instruction unique ou un ensemble
d'instructions entre {}
Présence obligatoire des parenthèses de l'expression de test.
Syntaxe :
If(condition) instruction_à_exécuter;

Z. D. SANOU HT L1 BOBO 22 23 74
Exemple :
Saisir le rayon et le mettre à 0 si négatif.
Scanf("%f", &rayon);
If(rayon <0.0)
rayon =0;
Surf = 3.14 * rayon * rayon;

Z. D. SANOU HT L1 BOBO 22 23 75
La structure if : Bloc
Permet d'exécuter plus d'une instruction lorsque la
condition est vraie.
Syntaxe :
If(condition) {
instruction1;
.
.
instruction_n;
}
Z. D. SANOU HT L1 BOBO 22 23 76
La structure if…else

Z. D. SANOU HT L1 BOBO 22 23 77
Z. D. SANOU HT L1 BOBO 22 23 78
????????

Z. D. SANOU HT L1 BOBO 22 23 79
La structure : switch

Z. D. SANOU HT L1 BOBO 22 23 80
Syntaxe :

Z. D. SANOU HT L1 BOBO 22 23 81
Pourquoi le break ?
L'instruction break est indispensable pour sortir du
switch. Si on l'oublie, une fois le branchement exécuté,
toutes les instructions qui suivent sont exécutées.

Z. D. SANOU HT L1 BOBO 22 23 82
Exemple :

Z. D. SANOU HT L1 BOBO 22 23 83
??????
#include <stdio.h> switch(code){
main(){ case 1 : printf("1000F");break;
int i, code; case 2 : printf("2000F");break;
printf("Taper le code operation "); case 3 : printf("3000F");break;
scanf("%d", &i); default : printf("Code incorrecte");
switch(i){ }
case 1 : break;
case 2 : printf("Achat unites\n"); break; case 5 : printf("Paiement\n"); break;
case 3 : printf("Transfert argent\n"); break; case 6 : printf("Forfait\n"); break;
case 4 : printf("Retrait argent\n"); default : printf("Choix incorrect\n");
printf("Taper le code du montant\n"); break;
scanf("%d", &code); }
}
Z. D. SANOU HT L1 BOBO 22 23 84
Structures répétitives

Principe : exécuter plusieurs fois une instruction

Z. D. SANOU HT L1 BOBO 22 23 85
En C, il existe 3 types de structures répétitives :

Z. D. SANOU HT L1 BOBO 22 23 86
La structure FOR
La structure POUR en algo est utilisée pour faciliter la
programmation de boucle de comptage.
La structure FOR en C est plus générale et beaucoup plus
puissante.
Syntaxe :

Z. D. SANOU HT L1 BOBO 22 23 87
Exemple : afficher 10 fois "Bonjour"

Z. D. SANOU HT L1 BOBO 22 23 88
La structure while
Syntaxe :

Les instructions dans le bloc while sont exécutées tant


que la condition est vraie sinon l'exécution se poursuit à
l'instruction suivant le bloc.

Z. D. SANOU HT L1 BOBO 22 23 89
Exemple 1

Z. D. SANOU HT L1 BOBO 22 23 90
Exemple 2 : validité d'une note

Z. D. SANOU HT L1 BOBO 22 23 91
La structure do… while()
Syntaxe :

Z. D. SANOU HT L1 BOBO 22 23 92
Exemple

Z. D. SANOU HT L1 BOBO 22 23 93
Instructions de branchement

Z. D. SANOU HT L1 22 23 94
Dans le cas où une boucle commande l’exécution d’un bloc
d’instructions, il peut être intéressant de vouloir sortir de
cette boucle alors que la condition de passage est encore
valide. Ce type d’opération est appelé une rupture de
séquence.

Z. D. SANOU HT L1 22 23 95
Z. D. SANOU HT L1 22 23 96
break
Il permet de sortir d’un bloc d’instruction associé à une
instruction répétitive ou alternative contrôlée par les
instructions if, for, while ou do while.

continue
L’instruction continue, insérée dans une boucle, permet de
sauter les instructions restantes du traitement en cours, sans
sortir de la boucle
Z. D. SANOU HT L1 22 23 97
return
L’instruction return provoque la terminaison de l’exécution de
la fonction dans laquelle elle se trouve et le retour à la fonction
appelante.
Les formes possibles du return sont donc :
• return ;
• return expression ;

Z. D. SANOU HT L1 22 23 98
TP
1.Ecrire un programme calculatrice permettant la saisie
de deux entiers et une opération booléenne (+, - , / , x )
et affichant le résultat.

Z. D. SANOU HT L1 BOBO 22 23 99
2. Programme permettant de saisir et de valider :
• Le sexe d'une personne ('f', 'F', 'm' ou 'M')
• L'âge d'une personne (entre 1 et 134)
Ensuite on affiche un message du genre :
C'est un (enfant(1 à 11ans), adolescent(12 à 17),
adulte(18ans et plus) de sexe(masculin, féminin)).
On répète le même traitement tant que l'usager décide de
continuer.
Z. D. SANOU HT L1 BOBO 22 23 100
3. Ecrire un programme mettant en œuvre le jeu suivant :
Le premier utilisateur saisi un entier que le second doit
deviner. Pour cela, il a le droit à autant de tentatives qu’il
souhaite. A chaque échec, le programme lui indique si l’entier
cherché est plus grand ou plus petit que sa proposition.
Un score indiquant le nombre de coups joués est mis à jour
et affiché lorsque l’entier est trouvé.

Z. D. SANOU HT L1 BOBO 22 23 101


4. Le nombre 720 a 30 diviseurs (1, 2, 3, 4, 5, 6, 8, 9,
…,360, 720). Un autre nombre supérieur à 720 mais
inférieur à 1000, en a encore plus.
Ecrire un programme qui permet de découvrir ce
nombre et d'afficher ses diviseurs.

Z. D. SANOU HT L1 BOBO 22 23 102


Chapitre 6. Tableaux

Z. D. SANOU HT L1 BOBO 22 23 103


Tableaux à une dimension

Z. D. SANOU HT L1 BOBO 22 23 104


Rappel

Z. D. SANOU HT L1 BOBO 22 23 105


Z. D. SANOU HT L1 BOBO 22 23 106
Déclaration
Syntaxe :

Exemple : déclarer un tableau tab de 8 entiers


int tab[8];
Chaque composante du tableau est référencée par un
indice.
Les indices de tableau commencent à 0 en C.
Z. D. SANOU HT L1 BOBO 22 23 107
Initialisation
Lors de la déclaration d'un tableau, on peut initialiser les
composantes du tableau, en indiquant la liste des valeurs
respectives entre accolades.
int tab[10] = {9,8,7,6,5,4,3,2,1,0};
• Si la liste ne contient pas assez de valeurs pour toutes les
composantes, les composantes restantes sont initialisées par 0.
• Si la dimension n'est pas indiquée explicitement lors de
l'initialisation, l'ordinateur réserve alors le nombre d'octets
nécessaires.
Z. D. SANOU HT L1 BOBO 22 23 108
Accès à un contenu du tableau
Syntaxe :

Z. D. SANOU HT L1 BOBO 22 23 109


L'accès successif à tous les éléments du tableau est obtenu
par une itération.
#include <stdio.h>
main(){
float T[10];
int i;
for(i=0; i<10; i++)
scanf("%f", &T[i]);
for(i=0; i<10; i++)
printf("%f", T[i]);
}

Z. D. SANOU HT L1 BOBO 22 23 110


Exercices
1.Ecrire un programme qui lit la dimension N d'un tableau T du type int
(dimension maxi 50), remplit le tableau par des valeurs saisies. Trouver la
moyenne de ces nombres.
2.Ecrire un programme qui lit la dimension N d'un tableau T du type float
(dimension maxi 50), remplit le tableau par des valeurs saisies. Trouver la
valeur maximale de ces nombres.
3.Ecrire un programme qui permet de remplir un tableau par N entiers (N
donné par l'utilisateur). Saisir un nouveau nombre et chercher si ce nombre
appartient au tableau ou pas.

Z. D. SANOU HT L1 BOBO 22 23 111


4.Ecrire un programme permettant d'insérer un élément à une
position donnée. La dimension du tableau étant supposée
suffisante.
5.Ecrire un programme qui permet de supprimer un élément
d'un tableau si cet élément existe.
6.Ecrire un programme qui permet de remplir un tableau
d'entiers et de le trier par ordre croissant.

Z. D. SANOU HT L1 BOBO 22 23 112


Tableaux à deux dimensions

Z. D. SANOU HT L1 BOBO 22 23 113


Z. D. SANOU HT L1 BOBO 22 23 114
Déclaration

L'accès successif à tous les éléments du tableau est


obtenu par deux itérations

Z. D. SANOU HT L1 BOBO 22 23 115


Z. D. SANOU HT L1 BOBO 22 23 116

Vous aimerez peut-être aussi