a.abdelkaher@gmail.com
06 Février 2023
Algorithmique
Programmation en langage C
Concepts de base
Pile
File
Liste
Arbres
Graphes
1 Algorithmes
I Représentations des algorithmes
I Pseudo langage
I Codage d’un algorithme
2 Programmation en C
I Généralités
I Pointeur et tableau
I Les fonctions
I La récursivité
Calculer la factorielle de N
Ecrire("saisissez le nombre :")
Lire (N)
F←1
Pour I=1 à N Faire F← F × I
FinPour
Ecrire(F)
Remarque
Il n’existe pas de formalisme universel pour l’écriture d’un pseudo
programme.
Structures élémentaires :
1 Entrées/Sorties : scanf(), printf()
2 Affectation : X =Y
3 Instructions conditionnelles :
if condition instructions
if condition instructions1 else instructions2
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.
...
Initialisation
Pour récupérer l’adresse d’une variable A et la mettre dans le
pointeur P ( P pointe vers A ) :
int A=10, *P ;
P=&A ;
int a=1025;
int *p=&a;
printf("%d",*p); // chercher le contenu de 4 octets
// a partir de l’adresse 200 ---> 1025
char *p0=(char*)p; // p0 contient la meme adresse que p
printf("%d",*p0); // chercher le contenu de 1 octet
// a partir de l’adresse 200 ---> 1
Remarques :
I Chaque élément est repéré par sa position dans le tableau,
nommée indice, en langage C, la première position porte le
numéro 0.
I Dans l’exemple, les indices vont de 0 à 19.
I Le premier élément du tableau sera désigné par t[0],
I le troisième par t[2],
I le dernier par t[19].
I La notation &t[i] désigne l’adresse de cet élément t[i]
maximum
int maximum (int a, int b)
{
int max;
if (a>b)
max = a;
else
max = b;
return max;
}
somme
double Som(double x, double y)
{
return (x+y);
}
int main()
{
// declaration des variables
int c,x=20,y=19;
double z;
int A[5] = {1, 2, 3, 4, 5};
// appels des fonctions max, som
c = maximum( x, y);
printf("max(%d,%d)=%d",x,y,c);
c = maximum(12,15);
z=Som(2.5, 7.3);
AfficheTab(A,5);
return 0;
}
I int tab[10] ;
Exemple
int * p;
p = (int *) malloc ( 10* sizeof (int) );
if(p!=NULL)
for(i=0; i <10; i++)
scanf ("\%d",p+i);
free(p);
Résoudre(P) =
Remarques
Chaque appel de fac entraîne une allocation d’espace pour les
variables locales et pour son argument n (apparemment, fct ne
comporte aucune variable locale ; en réalité, il lui faut prévoir
un emplacement destiné à recevoir sa valeur de retour)
Chaque nouvel appel de fac,à l’intérieur de fac, provoque une
telle allocation, sans que les emplacements précédents soient
libérés.
Il y a donc un empilement des espaces alloués aux variables
locales, parallèlement à un empilement des appels de la
fonction
Ce n’est que lors de l’exécution de la première instruction
return que l’on commencera à « dépiler » les appels et les
emplacements et donc à libérer de l’espace mémoire.
Définition
Une définition de fonction f est récursive terminale quand tout
appel récursif est de la forme return f(...) ; La valeur retournée est
directement la valeur obtenue par un appel récursif, sans qu’il n’y
ait aucune opération sur cette valeur.
somme(a,b)
somme(4,2)=somme(5,1)=somme(6,0)=6
Définition
L’appel récursif n’est pas la dernière instruction et/ou elle n’est pas
isolée (fait partie d’une expression).
somme(a,b)
somme(4,2)=1+somme(4,1)=1+1+somme(4,0)=1+1+4=6
<stdio.h>
int fputc(int C, FILE *FP)
int fgetc(FILE *FP)
int printf(const char *FORMAT, ...)
int scanf(const char *FORMAT, ...)
int putchar(int C)
int getchar(void)
int puts(const char *CH)
char *gets(char *CH)
<string.h>
<math.h>
double sin(double X)
double cos(double X)
double tan(double X)
double asin(double X)
double acos(double X)
double atan(double X)
double exp(double X)
double log(double X)
double log10(double X)
double pow(double X, double Y)
double sqrt(double X)
double fabs(double X)
<stdlib.h>
void *malloc(unsigned int N)
void *calloc(int c,unsigned int N)
void *realloc(void *P,unsigned int N)
void free(void *P)
int atoi(const char *CH)
long atol(const char *CH)
double atof(const char *CH)