ejkzek
Chapitre :1 Programmations en langage c
(Connaissances à avoir)
1-
Introduction :
« c » est un langage évolué et structuré, assez proche du langage machine destiné à des applications de contrôle de processus(gestion d’entrées/sorties, applications temps réel…).
Le langage c possède assez peu d’instructions, il fait par contre appel à des bibliothèques, fournies en plus ou moins Grant nombre avec le compilateur.
2-
Les bibliothèques 1* définition :Seront des blocs contenant des commandes bien définie, c'est-à-dire pour utiliser une commande il faut le définir (sont but ?), c’est le but des bibliothèques.
2* exemples :
Math.h : bibliothèque de fonctions mathématiques Stdio.h : bibliothèque des commandes d’entrées/sorties
déclaré dans le programme :
#include< nom du bibliothèque >
3* remarque :
Dans la langage c il existe des bibliothèques bien définies, on peut ajouter des autres bibliothèques sur mesure.
3-
Déclaration des variables/constants : 1* variables :Pour utiliser une variable ou constante dans notre programme il faut le déclaré au début du programme
Voici quelque type de variables :
types déclaration taille
Entier int 2 octets
Réel float 4 octets
caractère char 1 octet
double 4 octets
short 2 octets
On les déclare :
(Type variable) (Nom variable)
Par exemple : int x (int : type et x : nom donné arbitrairement)
2* constante :
If se peut dans des cas de déclaré une valeur fixe afin de l’utiliser dans le programme, par exemples :
Pi=3.14 (ou lieu de l’écrire { l’infinité de chiffre).
On les définies :
#define (nom de la constante) = ( la valeur choisie)
4-
Structure d’un programme c :1 ère bloc : définir les bibliothèques
2 éme bloc : déclaration des variables et constants 3 éme bloc :
Aves : « « { « « désigne le début et « « } « « désigne fin.
Toujours les programmes s’écrit de cette
manière quelque soit la difficulté présente.
5-
Les opérateurs :1* les opérateurs arithmétiques :
‘+’ : la somme ‘-‘ : la différence ‘*’ : Multiplication ‘/’ : Division
2* les opérateurs logique :
‘&’ : et
‘||’ : ou
‘!’ : Non
3* priorité des opérateurs :
() ! ,++,--*,/,% +,->,>=,<,<= && || Avec :
‘++’ : un conteur (opérateurs d’incrémentations)
‘- -‘ : un décanteur (opérateurs de décrémentations)
Par exemple : Pour i=3 ; i++ -> 3+1=4 -> 3+1+1=5 -> …… -> i-- -> 3-1=2 -> 3-1-1=1 -> ……. -> Exemple de priorité : x * ! y – 2 % t > h || a && b Devient : (((x * (! Y)) – (2 % t) > h) ||( a && b))
Chapitre :2 Programmations en langage c
(Niveau 2)
1-
Les fonctions d’entrée : 1* la fonction ‘scanf’ :Appartiens au bibliothèque (stdio.h), permet la saisie de n’importe quel type de variale.
Les variable à saisir sont formaté, le nom de la variable est précédé du symbole & désignant l’adresse de la variable dans la mémoire de l’ordinateur.
Plus de détaille :
Supposant que le registre de notre ordinateur est comme cà : Il contient beaucoup de case mémoire ayant pour chacune une adresse mémoire, la valeur de notre variable donné par l’utilisateur sera enregistré dans l’une des case (selon taille).
Mais le problème quand connait pas cette adresse donc il faut jouté le symbole d’adressage ‘&’ affin de s’avoir l’adresse de notre variable et pour l’utiliser dans des autres opérations.
110 112 ……….. 400 3 Adresse de la case ---valeur à pour adresse 400 500 502 ………. 800 Syntaxe : int -> %d float -> %f char -> %c chaine de caractère -> %s Scanf("format",&nom du variable) Exemple : Scanf("%d",&a) ;
Scanf : opération d’insertion
%d : déclaration d’une variable de type entier a : nom variable
Scanf("%3d",&a) ;
%3d : longueur maximale de a est 3 chiffres c'est-à-dire a<999
Scanf("%.3d",&a) ;
%.3d : trois nombre après la vergule 2* la fonction getch :
Appartient { la bibliothèque (conio.h), permet la saisie clavier d’un caractère sans l’affiché sur l’écran.
La saisie s’arête dés le caractère à été tapé. Getch() ;
Exemple :
X=getch() ; -> x prend une valeur que l’utilisateur tape sans le voir sur l’écran.
3* la fonction getchar :
Permet la saisie d’un caractère (char), elle appartient au bibliothèque (stdio.h).
Exemple :
Les deux écritures sont équivalentes 1* Char x ; X=getch() ; 2* Char x ; Scanf(" %c",&x) ;
2-
Les fonctions de sorties : 1* printf :Elle permet d’affiché un message, résultat… Syntaxe :
Printf ("format(s)", nom variable(s)) ;
Exemple :
Printf ("bonjour") ; -> affiche le message : bonjour Printf (" %d multiple %d donne %d", x, y, x*y) ;
2* la fonction putchar :
Elle permet d’affiché un caractère et de retourné { la ligne
automatiquement (sans utilisé « \n » qui permet le retour à la ligne) Exemple :
Printf ("bonjour\n") ;
C’est deux écriture sont corrects : 1* char x ; Putchar(x) ; 2* Char x ; Printf (" %c ", x) ; 3* la fonction puts :
Permet d’affiché un texte de retourné { la ligne automatiquement C’est deux écriture sont équivalentes :
Puts (" bonjour") ;
2*
Printf (" bonjour\n ") ;
Application :
On va appliquer se qu’on { étudier affin de réalisé un programme qui :
- Ecrire un message de bonjour
- Inséré 2 variables et affiché leur
somme, différence et produit. #include<stdio.h> #include<conio.h> Void main ()
/*fonction prédéfinie par logiciel c(voir après chapitre des fonction*/
{ int a,b,c ; puts(" Bonjour") ;
printf("donner trois entiers affin de faire leur somme, différences et produit\n ") ;
scanf (" %d%d%d",&a,&b,&c ) ;
printf ("la somme est %d, la produit est %d", a+b+c,a*b*c) ;
getch() ;
/*on l’utilise getch() pour voir le résultat car le programme après exécution des instruction il attendre
l’appuis d’une touche pour sortir(ou contraire il sort directement dans un temps très cour qui ne nous permet pas de voir le résultat)*/
}
S’appelle un commentaire, l’ordinateur ne le compile pas mais
elle est visible lors de l’écriture du programme
Il faut écrire :
/* (Explication) */
On va voir dans notre écran après exécution :
Bonjour
donner trois entiers affins de faire leur somme, différences et produit
la somme est x, la produit est y"
Chapitre :3
Les instructions conditionnelles
Les instructions itératives
1-
Les instructions itératives :
1* instruction if :
C’est l’instruction la plus simple, elle exécute le(s) instruction(s) si sa valeur est vraie.
Syntaxe :
Bloc d’(es) instruction(s) Exemple :
if(x>0)
printf("x est positive\n ") ;
else /*c’est le contraire de la condition x>0*/ printf("x est négative\n ") ;
Très important :
On cas de plusieurs instruction à faire il faut utiliser les accolades sinon le compilateur lit seulement la première instruction alors si on utilise else il va envoyer un message d’erreur.
Plus simplement :
Exemple :
(faux)
Instruction qui n’appartientpas { if
if(x>0)
printf("x est positive\n ") ;
L’emplacement de else est faux !
printf("ou x est nul") ; else printf("x est négative\n ") ; printf("ou x est nul") ;
(Correct)
Instruction qui appartient àif
{
printf("x est positive\n ") ;
L’emplacement de else est juste !
printf("ou x est nul") ;
}
else {
printf("x est négative\n ") ; printf("ou x est nul") ; }
Exemples : if(x>0)
printf("x est positive\n ") ; 2* instruction if-else :
Dans les cas où on est obligé à testé tout les cas possible (cas de non satisfaction de la condition), on utilise if-else.
Syntaxe :
if (condition)
Bloc des instructions else
Bloc des instructions Exemple :
printf("x est positive\n ") ;
else /*c’est le contraire de la condition x>0*/ printf("x est négative\n ") ;
Très important :
On cas de plusieurs instruction à faire il faut utiliser les accolades sinon le compilateur lit seulement la première instruction alors si on utilise else il va envoyer un message d’erreur.
Plus simplement :
Exemple :
(faux)
if(x>0)
printf("x est positive\n ") ; printf("ou x est nul") ; else printf("x est négative\n ") ; printf("ou x est nul") ;
(Correct)
if(x>0)
{
printf("x est positive\n ") ; printf("ou x est nul") ;
}
{
printf("x est négative\n ") ; printf("ou x est nul") ; } 3* switch : (selon) On à un choix multiple. Syntaxe : Switch(expression) {
Case ‘(valeur 1)’ : bloc 1
Break ; /*permet la sortie de la bloc*/ .
. .
Case ‘(valeur n)’ : bloc n Break ;
Default : bloc n+1 /*autrement dans les reste des cas*/ }
Exemple : Switch(opp) {
Case’+’ : printf("addition") ;break ; Case’-’ : printf("soustraction") ;break ;
. . .
Default :printf("opp ou symbole différent de + et -") ; /* le ; est liée à printf pas au default (regardé la syntaxe de selon)*/
}
1- les instructions itératives :
1* la boucle while : (tant que)
Elle éxécute un bloc des instruction tant que
la condition est
vraie.
Syntaxe :
While(condition)
Bloc d’instruction(s)
2* la boucle do-while : (répéter jusqu’{)
Elle éxécute un bloc des instruction tant que
la condition est
vraie.
Elle est utilisé lorsque l’éxécution du corp de la boucle
s’éffectuer au moins une fois.
Syntaxe :
do
{
Traitement
3* boucle for : (pour)
Syntaxe :
for(expression 1 ; expression 2 ; expression2 ; expression 3 ;)
bloc d’instruction(s)
avec :
Expression 1 : initialisation.
Expression 2 : condition
Expression 3 : pas à réalisé (modification)
Exemple :
for(i=0 ;i<2 ;i++)
Initialisation condition conteur (voir chapitre précédent)
printf("Bonjour\n") ;
Exécution donne :
i=0 -> bonjour
i=1 -> bonjour
Bonjour
bonjour
Si on à plusieurs instructions il faut utiliser les accolades (voir l’explication d’if).
Chapitre :4 Les fonctions en
Langage c
1- Introduction :
On venant de trouvé une solution à un grand problème en tombe dans la grande taille des instructions qui dans la majorité des cas ; soit faux car on ne peut pas vérifier facilement les erreurs quant fait.
Pour cette raison on utilise le découpage du grand problème en sous problèmes moins volumineux et complexes puis on les relient au grand probléme.
Donc on utilise des fonctions qui pour chacune d’elles fait une partie du travail demandé puis on les relie à la fonction principale prés définie (main).
Syntaxe :
Type_résultat non_fonction(liste type des paramétres) {
Déclaration des variables local Suite d’instruction(s)
}
Exemple :
int max (int a,int b) {
if(a>b) c=a ; else c=b ; return(c) ; }
Comande qui permet le retour du resultat finale Utilisé avec les fonctions qui renvois le résultat (contrairement à la fonction définie
Void).
Toutes fonction doit être déclaré sauf la fonction main.
Exemple :
#include<stdio.h> #include<conio.h> int max(int a,int b) ; void main()
{
int x,y,z ;
printf(" donner deux entier\n") ; scanf("%d%d ",&x,&y) ;
z=max(x,y) ;
printf("le max est %d\n",z) ; }
int max (int a,int b) { int c ; if(a>b) c=a ; else c=b ; return(c) ; }
Ou on peut écrire plus simplement : (sans la déclaration) #include<stdio.h>
int max (int a,int b) { int c ; if(a>b) c=a ; else c=b ; return(c) ; } void main() { int x,y,z ;
printf(" donner deux entier\n") ; scanf("%d%d ",&x,&y) ;
z=max(x,y) ;
printf("le max est %d\n",z) ; }
2- Type de déclaration :
1* déclaration local :
Avant la déclaration des variables, la fonction est déclaré localement dans la fonction qui l’appelle, elle disponible uniquement pour cette dernière. Exemple :
Void rectangle(int lg,int ht) {
Void ligne(int lg) ; int i ;
for(i=0 ;i<ht ;i++) ligne(ht) ;
}
Void ligne(int lg) {
int i ;
for(i=0 ;i<lg ;i++) printf("*") ;
}
Ou on peut faire aussi : (sans déclaration) Void ligne(int lg)
{ int i ;
for(i=0 ;i<lg ;i++) printf("*") ;
printf("\n") ; }
Void rectangle(int lg,int ht) {
int i ;
for(i=0 ;i<ht ;i++) ligne(ht) ;
}
L’ordre des fonctions est très intéressants ! Fessons une exécution à la main :
(Si vous voulez, prenez un papier est écrire l’algorithme en c on suivant les étapes de l’exécution)
Rectangle c’est la procédure qui fait travail (géronte), pour la procédure ligne elle est locale.
Void rectangle(int lg,int ht) {
Void ligne(int lg) ; int i ;
for(i=0 ;i<ht ;i++) ligne(ht) ; } Void ligne(int lg) { int j ;
/*modifier i par j pour ne pas faire la confusion*/ for(j=0 ;j<lg ;j++) printf("*") ; printf("\n") ; }
L
’
e
n
t
r
é
e
à
la fonction déclarée localement se
fait { l’aide de la fonction appelante.
2* déclaration globale :
Après les blocs des inclusions (bibliothèque les fonctions sont déclaré globalement au début. C’est fonctions sont utilisable pour tout les fonctions du programme.
Exemple :
#include<stdio.h>
Void rectangle(int lg,int ht) ; /*déclaration*/
Suposans que l’utilisateur donne comme valeur : lg=4 et ht =3
i=0<3=ht -> ligne (ht) =ligne(3) (on se déplace vers la fonction ligne)
Pour j=0<lg=4 -> *
Pour j=1<4 -> * (on aura ** car on n’{ pas utilisé \n dans printf(*)
for est exécuté seulement pour la première instruction)
Ainsi de suite j=3<4 -> ****
Enfin j=4 n’est pas inférieur 4 on sort de la boucle for et on fait un saute de ligne.
On aurra ; ****
| curseur i=1<3=ht (même travail)
enfin ;
**** (i=0) **** (i=1) **** (i=2)
Void ligne(int lg) ; Void main() { int l,h ; printf("donner la longeur") ; scanf("%d",&l) ; printf("donner la hauteur") ; scanf("%d",&h); rectangle(l,h) ;
/*appelle de la fonction rectangle dans la fonction principale main*/ }
Void rectangle(int lg,int ht) {
Void ligne(int lg) ; int i ;
for(i=0 ;i<ht ;i++) ligne(ht) ;
}
Void ligne(int lg) {
int i ;
for(i=0 ;i<lg ;i++) printf("*") ;
printf("\n") ; }
Ou on peut faire aussi : #include<stdio.h> Void ligne(int lg)
/* on appelle ligne avant rectangle et rectangle avant main ou sait faux */ {
int i ;
for(i=0 ;i<lg ;i++) printf("*") ;
printf("\n") ; }
Void rectangle(int lg,int ht) {
Void ligne(int lg) ; int i ;
for(i=0 ;i<ht ;i++) ligne(ht) ; } Void main() { int l,h ; printf("donner la longeur") ; scanf("%d",&l) ; printf("donner la hauteur") ; scanf("%d",&h); rectangle(l,h) ; }
Chapitre :5
Tableau multidimensionnels
1- Introduction :
Se sont les tableau clasique qui ont des lignes et des colonnes.
Le nom du tableau représente l’adresse du premier élément du tableau. Schéma :
Tableau :
1 2 3 4 5 6
7 8 9 10 11 12
13 14 15 16 17 18
Dans la mémoire notre tableau s’écrit comme une seule ligne : Supposant que notre tableau s’appelle ‘Tab’
L’adresse du premier élément Du tableau(1).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
2- Initialisation :
Lors de la déclaration d’un tableau on peut initialisé ses élément on indiquant la liste des valeur entre deux accolade.
Exemples :
int tab[3][5] /* 3 lignes et 5 colonnes*/ L’espace ocuppé on mémoire sera :
3*5*4(octets)=60 octets (car : 1 entier=4 octets). =60 Ø
short tab[3][5]={{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15}}
3- Accés :
Pour un tableau de l lignes et c colonnes :
T[0][0] : permet l’accée au premier élément du tableau T. T[l-1][c-1] : permet l’accée au dernier élément.
4- Affectation :
On peut affecter une valeur qu’ont choisit en remplaçant une autre qui existe déjà dans notre tableau.
T[0][1]=2
Les indices du tableau
0 1 2 3 0 1 10= T[0][1] 3 4 1 5 6 7 8 Ligne=2 Colonne=4 T[0][1]=2 : le tableau devient 0 1 2 3 0 1 10 2 3 4 1 5 6 7 8
Remplisage du tableu à 1 dimension : (une ligne seulement)
Printf("donner la dimension du tableau") ; Scanf("%d",&n) ;
for(i=0 ;i<n ;i++) scanf("%d",&tab[i]) ;
Remplisage du tableu ligne_colonnes :
Printf("donner nombre de lignes du tableau") ; Scanf("%d",&l) ;
Printf("donner la nombre de colonnes du tableau") ; Scanf("%d",&c) ;
for(i=0 ;i<l ;i++) for(j=0 ;j<c ;j++)
1-
Recherche dans un tableau :
C’est cherché un élément donné dans un tableau.il faut donc faire un parcourt du tableau on vérifiant l’existence de cet élément recherché.
Il existe de type de recherche : 1* recherche séquentiel :
If suffit de lire le tableau de début à la fin.si le tableau n’est pas ordonnée alors l’arrive à la fin du tableau sans trouvé la valeur signifie le non existence de l’élément, pour un tableau ordonné ; le premier élément testé qui est supérieur à la valeur recherché permet l’arrêt de la fonction de recherche.
int rech_seq(int tab[],int n,int val) {
int i ;
Chapitre :6
Trie interne
Tri des tableaux
1-
Introduction :
Dans la majorité des cas la recherche d’un élément donné dans un tableau est difficile et très lente en particulier pour des tableaux très grands.
Pour ce l{ on utilise la trie { fin de minimisé la recherche (il suffi d’arrivé { une valeur plus grande que la valeur recherche pour s’arrêté).
Méthodes de trie :
2-
tri par sélection :
parcourir tout le tableau affin de recherché la plus petit valeur qui sera ensuite permuté avec la première valeur du tableau.
Cette opération sera répéter jusqu’{ se que le tableau sera totalement trié. void tri_select(int tab[],int n)
{
int i,j,Min,Aux ; for(i=0 ;i<n-1 ;i++) {
Min=i ;
if(Tab[j]<Tab[Min]) { Min=j ; Aux=Tab[i] ; Tab[i]=Tab[min] ; Tab[min]=Aux ; } } }
3
-
trie par
insertion :
Affin de classé le i éme élément du tableau, on regarde successiveme nt on marche arrière a partir de i-1 .on décale les éléments visité vers la droite pour pouvoir mètre l’élément d’indice i { sa juste place.void tri_inst(int tab[],int n) {
int i,j,elem ; for(i=1 ;i<n ;i++) {
Elem=Tab[i] ; j=i ;
while(j>0&&Tab[j-1]>Elem)
Soit le tableau suivant à trié : n=4 i=0 1=Min 2 3
2 1 4 3
(permutation) i=0 -> min=0,
j=i+1=1 et Tab[j]=1<Tab[Min]=2 donc (on réalise la permutation) :min=j=1, aux=2, tab[i]=tab[2]=1 et
tab[min]=tab[1]=2
i=0 1=Min 2=j 3
1 2 4 3
j=j+1(j++)=2 et Tab[j]=4>Tab[Min]=2 donc on à rien à modifier
j=3<n=4 et Tab[j]=3>Tab[Min]=2 donc on à rien à modifier
j=4(>=)4=n -> sort de la boucle. i=1<n-1=3 -> min=i=1,
j=i+1=2 et Tab[j]=4>Tab[Min]=2 donc rien à modifier
j=j+1(j++)=3 et Tab[j]=3>Tab[Min]=2 donc on à rien à modifier
j=4>=4=n -> sort de la boucle. i=2<n-1=3 -> min=i=2,
j=i+1=3 et Tab[j]=3<Tab[Min]=4 min=j=3, aux=4, tab[i]= tab[min]= tab[3]=3
tab[min]=4
i=0 1 2 3
1 2 3 4
j=j+1(j++)=4(>=) 4 sort de la boucle. I=3(>=n-1=3) -> fin du programme.
{ Tab[j]=Tab[j-1] ; j-- ; } } Tab[j]=Elem ; }
4-
trie à bules :
cette méthode est sophistiqué et utiliser dans les cas des grands
tableaux (vous pouvez demander par émail ou contacte sur notre site pour avoir cette méthode et la trie insertion plus détaillé avec des exemples).
Chapitre :7
Chaine des caractères
1-
introduction :
C’est une succession de n caractères (0≤n≤255).
On langage c, une chaine de caractères est déclaré comme un tableau de caractères avec un dernier caractère de contrôle « \0 » : son code ASC2 est égal à zéro, il indique la fin de la chaine de caractères.
‘B’ ‘O’ ‘N’ ‘J’ ‘O’ ‘U’ ‘R’ ‘\0’
BONJOUR
2-
Les chaines de caractères :
Tableau : @ 1ére élément(caractère) du tableau. 1* déclaration d’une chaine :
Types(char) nom_tableau[longeur+1] /* +1 car on à la caractére \0*/ 2* initialisation d’une chaine :
Char mot[4]={‘b’,’o’,’n’,’\0’} ; /*3+1*/ 2éme méthode : Char mot[4] ; mot[0]=’b’ ; mot[1]=’o’ ; mot[2]=’n’ ; mot[3]=’\0’ ; 3éme méthode : Char mot[]= "bon" ;
3-
Chaine de caractères constante :
Sont indiqué entre " ". exemple : Char mot[]= "bon" ; La chaine vide est "".
L’accée { une caractére se fait comme les tableaux.
4-
Ecriture d’une chaine de caractères :
Printf("format(s) (%s)",nom_chaine(s)) ; Exemples :
Char matiere[]="informatique" ;
Printf("%s",matiere) ; /* donne : informatique*/ Printf("%.4s",matiere) ; /* donne : info*/
Il est faux décrire matière avec les e avec accent car les noms de tout les types(entier, réel…) ne sont pas tenus en compte en c).
Exemple :
int bébé ; /*faux*/
5-
Lecture d’une chaine de caractères :
Scanf("format(s)",nom_chaine) ;
/*attention nom_chaine n’est suivi d’un & (adressage), c’est valable seulement pour les chaine de caractères ou des autre cas à étudier par la suite des chapitres*/
On peut aussi utilisé la fonction prés difinie « gets » permet de lire une ligne se terminant par un retour à la ligne et la copie { l’adresse indiqué par le nom de la chaine.
Syntaxe :
Gets(nom_chaine) ;
6-
Les fonctions de manipulation d’une chaine de
caractères :
Beaucoup de chaine sont fournie on langage c obtenue à partir de la bibliothèque : string.h
1* strlen : retourne le nombre du caractères d’une chaine sans calcule de\0. Strlen(nom_chaine) ;
2*strcpy : permet de copier une chaine de caractére dans une variable de type chaine de caractére.
Strcpy(nom_ch1,nom_ch2) ; Exemple :
Strcpy(ch1, "info") ;
3* strcat : permet la concaténation de deux chaines de caractères. Strcat(ch1,ch2) ;
Exemple :
Strcpy(ch1,"bon") ; Strcpy(ch2,"jour") ;
Strcat(ch1,ch2) ; donne : bonjour
4* strcmp : compare deux chaines de caractères et renvoie l’indice 0 si elles sont identique.
Strcmp(ch1,ch2) ;
7-
Les tableaux de chaine de caractères :
C’est un tableau { deux dimensions de type char telle que chaque ligne admet une chaine de caractères.
Remarque :
int tab[10][5] ; /*matrice d’entier*/
Lors de la déclaration, on peut initialiser les composantes par des chaines de caractères.
Exemple : char jour [7][9]
= {"lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"} ; 7 lignes correspondent au jour et 9 caractères sur colonne (8+1).
Pour accédé à une chaine, il faut indiquer la ligne correspondante. Printf("c’est %s",jour[3]) ; -> c’est jeudi
Pour accéder à une caractère d’une chaine, il faut indiqué la ligne correspondante et l’indice du caractère dans la chaine.
Printf("%c",jour[0][0]) ; -> l
Pour affecter une chaine { une composante d’un tableau de type chaine de caractères, il faut utiliser la fonction strcpy.
Strcpy(jour[0], "monday") ;
/*on peut faire un programme pour convertir les jours*/
Chapitre :8 Les pointeurs
1-
Notion d’adressage :
La mémoire est composée par des cases mémoire, chacune de ses derniers est identifié par un numéro appelé adresse.
On peut donc accédé à une variable de deux façons : Par nom de cette variable
Par adresse 10
100 A
On suppose qu’on { la variable A portant comme valeur 10 et d’adresse 100.
1* adressage direct :
2* adressage indirect :
C’est le faite d’accédé au contenue d’une variable on passant par une autre variable spéciale qui contient l’adresse de la variable de début.
Exemple : 10
100 A
On construit un variable qui porte la valeur 100(adresse de notre valeur). Par exemple p 100 p On aura ; 10 100 A
2-
Notion de pointeur :
1* Définition :Un pointeur est une variable spéciale (déj{ énoncé dans l’accès indirect) contenant l’adresse d’une autre variable d’un type donné.
Si un pointeur p contient l’adresse d’une variable A on dit alors que p pointes sur A ou p est l’adresse de A.
100 A 2* déclaration :
Pour déclaré un pointeur on doit écrire le type de la variable sur la qu’elle il pointera suivie du caractère * pour préciser que c’est un pointeur puis enfin son nom.
Syntaxe :
Type* nom_pointeur ; p
Le type c’est liée { la valeur principale A. * est relié au nom du pointeur.
Remarque :
Cas entier : 4 octets 100
P p++ ; (p=p+1) p 3* les opérateurs de bases :
a- L’opérateur d’adressage : &
Pour avoir l’adresse mémoire d’une variable il faut utiliser l’opérateur d’adressage(&).
Ainsi ; &A fourni l’adresse de la variable A. Exemple :
int A=2 ; int *p ;
p=&A ; /*p pointe sur A c'est-à-dire il à son adresse*/
b- Opérateur contenue :
Pour accédé au contenue { l’adresse mémoire d’une variable pointé par un pointeur p, il faut utiliser l’opérateur * ainsi ; *p désigne le contenus de l’adresse refermée par p (contenue de A).
3-
Pointeur et tableau :
Soit T nom d’un tableau.
En langage c ; T est l’adresse du 1ére élément du tableau c’est { dire que : T&T [0]
T est donc un pointeur constant sur le 1ére élément du tableau. T+i : l’adresse de T[i] (élément iéme du tableau).
*(T+i) : T[i]
4-
Opérations sur les pointeurs :
1* arithmétique de pointeur :
On peut désormais déplacer un pointeur { l’aide des opérateurs (addition, soustraction, incrémentation (++) et décrémentation (--)).
On ne peut pas déplacer un pointeur un nombre de case mémoire dépassant la taille des cases réservé par la variable sur la quel il pointe. Exemple :
Cas entier : 4 octets 100
P p++ ; (p=p+1) p Avec
Sur 4 octets
100 101 102 103 (A)
100 : adresse de A, d’elle je peux s’avoir les autres (il suffit d’avoir 100 et le pointeur pointe sue cette valeur).
Remarque :
Dans le reste des chapitre on va s’avoir l’utilité de se travail. Pour qu’un pointeur pointe nulle part il faut lui associé la valeur numérique nulle
int *p ; p=0 ;
L’affectation d’un pointeur vers un autre veut dire que les deux pointeurs pointent sur la même objet.
Int A ; p
q A Int *p,*q ;
P=q ;
Si p porte (pointe) sur T[i] (p=&T[i]) alors p+n=&(T[i+n]) et p-n=&(T [i-n]).
Si p porte (pointe) sur T[i] (p=&T[i]) alors p++=&(T[i++]) Si p1 et p2 pointent dans un même tableau alors :
p1-p2 donne le nombre des composantes entre p1 et p2.
La comparaison de p1 et p2 est équivalente à la comparaissant des indices correspondantes.
5-
Allocation dynamique du mémoire :
C’est le fait de réservé des zone dans la mémoire d’un taille donné. Pour ce la il faut utiliser la fonction malloc définie en c qui permet l’allocation d’une place en mémoire { un pointeur.
Cette fonction est utilisé dés quand parle du pointeur. Syntaxe :
Nom_pointeur=(type*)malloc(size) ;
Size=taille quand veut réserver en mémoire (mesuré en se type : entier=4 octet si je donne 10 -> 10*4=40 octets).
Exemple :
int *p ; /* cette écriture veux dire : int p[4] ; */ P=(int*)malloc(10) ;
6-
Libération mémoire :
On peut libérer des zones mémoire déjà réservé après un certain travail fini.
C’est la fonction free qui assure ce travail. Syntaxe :
free(nom_pointeur) ; /* libérer l’espace réservé par la fonction malloc */
7-
Passage des paramètres dans une fonction :
Il existe deux types de passage : a- Passage par valeur :
Les fonctions obtiennent les valeurs de leur paramètre et non pas d’accès au variable.
On peut donc changé les valeurs des paramètres fournis sans modifier les valeurs originales dans la fonction appelante.
Exemple :
void echange(int a,int b) {
c=a ; a=b ; b=c ; }
Void main() /*fonction appelante*/ {
int x,y ;
printf("donner x puis y") ;
Chapitre :9 Les structures
1-
Le type structure :
1* introduction :
En enregistrement appelé structure on langage c est une variable qui permet d’imbriqué sous un seul nom plusieurs valeurs de types différents. Chaque de ses éléments s’appelle champ.
Pour accédé { un champ if suffit d’utilisé le nom de la structure.
Pour déclaré une structure il faut définir un modèle ont indiquons les champs de la structure c'est-à-dire le type et le nom des variables qui la compose. Syntaxe : Struct nom_structure { Type_champ1 nom_champ1 ; . . . . Type_champn nom_champn ; } ; Exemple : Struct etudiant { int age ; float moyenne ;
Char nom[10] ; } ;
La déclaration de la structure ne fait que donnée l’allure. C'est-à-dire une définitio{n d’un type de variable complexe.
La déclaration ne reserve donc pas l’espace mémoire pour une variable structuré.il faut donc définir un ou plusieurs variables structuré après avoir déclaré la structure.
2* définition d’une variable de type structure :
C’est une opération qui consiste { crée une variable aillons comme type celui d’une structure que l’ont déj{ déclaré (nommée et réservé un emplacement dans la mémoire).
On le définie comme suit :
Struct nom_structure nom_variable ; Exemple : Struct etudiant { float moyenne ; Char nom[10] ; } ;
Struct etudiant E1 ; /*E1 est le nom du variable de type struct etudiant*/ On peut faire aussi ;
Struct etudiant { float moyenne ; Char nom[10] ; } E1 ; E1 désigne un étudiant. Exemple 2 : Struct etudiant { float moyenne ;
Char nom[10] ; }
E1,E2 ;
Consiste à remplir des informations de deux étudiants (E1, E2). L’ors de la déclaration on peut initialiser une structure ont indiquons entre accolade la liste des valeurs séparé par des virgules (chaque valeur à le type du son champ).
Exemple :
Struct etudiant E1={12, "mahfoudhi"} ;
Pour modifier une valeur d’un champ donnée il suffit d’accédé au champ d’une structure en utilisant l’opérateur du champ (un point) placer entre le nom de la variable structuré et le nom du champ.
Syntaxe :
nom_variable.nom_champ ; Exemple :
E1.moyenne=14 ; /*on efface 12 et on le remplace par 14*/ Pour faire le remplissage : (par l’utilisateur)
Scanf("%f",&E1.moyenne) ;
2- Structure comportant des tableaux : Exemple :
Struct etudiant
Chapitre :10 Les listes chainées
1-
Introduction :
C’est une structure mais l’un de ses champ comporte un pointeur qui pointera vers une structure de méme type.
Structure : (étudier dans le chapitre précédent)
Mahfoudhi Ghaieth 15 12 11 13 14.25
Autri Johnson 11 12 14 17 15.44
(ne sont pas relié) Liste chainée :
Mahfoudhi Ghaieth 15 12 11 13 14.25 100(adresse)
100 2- Caractérisation d’une liste chainées : 1* principe :
Stoker les donnée qui vont être traité d’une manière séquentiel. Les éléments de liste sont appelés nœuds ou maillons, il ne sont pas ronger les un au côté des autres.
on dispose de pointeur de téte qui contient l’adresse du premier élément de la liste(je l’appelle on générale d ou debut).
Le dernier nœud ne pointe sur rien, il faut donc effectuer { son pointeur la valeur NULL.
2* inconvinion :
If faut parcourir toute la liste pour accéder à un élément (séquentiel). 3* avantage :
Pour déplacer un élément on lui supprimant ou ajoutant, il suffit de modifier ses liens.
3- Création d’une liste chainée : 1* déclaration :
Définir la structure de donnée ainsi un pointeur vers une structure de méme type(il pointera vers la téte de cette liste).
Exemple :
struct nœud {
int x ;
struct nœud* svt ;/*pointeur suivant*/ } ;
2* création d’une liste vide :
Struct nœud* L ;/*L est la téte de notre liste*/ L=NULL ;
L=NULL
3* affectation :
Comme les structure on utilise (.) dans la liste chainée en utilisera -> (&. (<->) ->).
Pour plus des détaille envoyer vos question et de mande du cour complet). 4* création d’une liste contenant un seul élément :
Les différente étapes sont :
Définition de la structure. (déjà vue) (1) Définition des pointeurs. (2)
Allouée la mémoire nécessaire pour les nouveaux nœuds. (3) Affecté des valeurs au champ des nouveaux nœuds. (4)
Définir les nouveaux nœuds comme du tète de la liste
L=now (pointeur responsable { la création des nouveaux nœuds). (5) Exemple : (1) struct nœud { int x ; struct nœud* svt ; } ; (2) L=NULL
struct nœud* now ; /*pointeur nouveux*/ (3)
now=(struct nœud*)malloc(sizeof(struct nœud)) ; now (4) now->x=2 ; now now->svt=NULL ; (5) L=now ; L->now now D’où L
Il faut voir les exercices pour mieux comprendre la cour (pratique). 2 NULL
2 NULL
