Beruflich Dokumente
Kultur Dokumente
Initiation au langage C
1 2
1
16/05/2018
Langages de
programmation
Langages Langages
impératifs déclaratifs
3 4
2
16/05/2018
Compilateur C
.C
✓ Langage a été inventé par Dennis Ritche en 1973; fichier
✓ Langage procédurale;
5 6
3
16/05/2018
4
16/05/2018
Programme typique en C Votre commentaire est court : double slash (//) suivi de votre commentaire.
/* commentaire s’étendant
fonction a() instructions
sur plusieurs lignes
de programme source */
fonction b() instructions
9
instructions
9 10
5
16/05/2018
• Contrôle
11 12
6
16/05/2018
13 14
7
16/05/2018
Type
Syntaxe
ensemble vide
void
• Type « char » ou « signed char »:
caractère
char – ASCII sur 8 bits
short int
entier court • de -128 et +127.
15 16
8
16/05/2018
17 18
9
16/05/2018
Les modificateurs des classes de mémorisation Les modificateurs des classes de mémorisation
• « const »:
• « extern »: – indique que le contenu d’une variable ne doit pas être
modifiée.
– indique une variable ou une fonction déclarée dans un
autre module.
• « volatile »:
• « register »: – indique qu’une variable peut voir son contenu changer
à tout moment par le programme, des interruptions ou
– demande au compilateur de placer des variables dans tout autre facteur extérieur. Empêche le compilateur
les registres du CPU. Augmente la vitesse de de faire des optimisations sur cette variable.
traitement.
22 23
10
16/05/2018
• Opérateurs arithmétique:
• Opérateurs à un paramètre: – *,/,+,-
–- change le signe de la variable – % modulo
–* « indirection » (pointeurs)
• value = *salary; /* contenu pointé par salaire */ • Opérateurs sur bits:
– & adresse – & et
– ++/-- incrémentation/décrémentation –| ou
– sizeof()
24 25
11
16/05/2018
• Opérateurs relationnels:
– <,>,<=,=> • Opérateur conditionnel:
– result = mode > 0 ? 1 : 0;
• Opérateurs d’égalité: – if mode>0 then result=1 else result=0.
– ==, !=
• Opérateurs d’assignation:
• Opérateurs logiques: – =, *=, /=, %=, +=, -=, <<=, >>=, &=, |=
– && et
– || ou
26 27
12
16/05/2018
28 29
13
16/05/2018
14
16/05/2018
32 33
15
16/05/2018
34 35
16
16/05/2018
36 37
17
16/05/2018
7. Quel type de donnée permet de stocker 15.4528 ? 8. Quel type de donnée permet de stocker -25 ?
a) char a) int
d) int d) float
38 39
18
16/05/2018
9. la variable A contient 10.5 , Qu'est-ce que la ligne 10. On souhaite récupérer un nombre décimal entré
suivante affiche ? au clavier, quelle ligne est correcte?
printf("A = %d ",A); a) scanf("%f", nombreDecimal);
a) A = %d b) scanf("%d", nombreDecimal);
b) A = 10.5 c) scanf("%lf", *nombreDecimal);
c) A = 10 d) scanf("%f", &nombreDecimal);
d) A = d , A
40 41
19
16/05/2018
1. b
11. Combien vaudra Res après les opérations suivantes ? 2. c
int A = 4;
3. b
Res = 5 + A++;
Res += 2 + A; 4. c
Res -= 4 + (--A) 5. c
Res = Res + A++; 6. b
a) 9
7. c
b) 10
c) 12
8. a
d) 14 9. c
10. d
11. c
42 43
20
16/05/2018
#include<stdio.h> #include<stdio.h>
int main(void) int main(void)
{ int a=2, b=3, c=4; { int a=2, b=3, c=4;
printf("opération a+++b égale %d\n",a+++b); printf("operation ++a+b égale %d\n",++a+b);
printf("la valeur de a est %d et la val de b est %d\n",a,b); printf("la valeur de a est %d et la val de b est %d\n",a,b);
return 0; return 0;
} }
44 45
21
16/05/2018
#include<stdio.h> #include<stdio.h>
int main(void) int main(void)
{ int a=2, b=3, c=4; { int a=2, b=3, c=4;
printf("operation a+--b égale %d\n",a+--b); printf("operation a+b-- égale %d\n",a+b--);
printf("la valeur de a est %d et la val de b est %d\n",a,b); printf("la valeur de a est %d et la val de b est %d\n",a,b);
return 0; return 0;
} }
46 47
22
16/05/2018
✓ if...else
Instructions de contrôle ✓ For
✓ While
et les tableaux en langage C ✓ Do while
✓ Switch
✓ Break
✓ Continue
✓ Goto
48 49
23
16/05/2018
Les structures de contrôle if...else Les structures de contrôle- Imbrication des instructions if
24
16/05/2018
25
16/05/2018
26
16/05/2018
/* Boucle while */
#include <stdio.h>
#define NUMBER 22
main()
{
int count = 1, total = 0;
56 57
27
16/05/2018
/* Boucle do while */
#include <stdio.h>
#define NUMBER 22
main()
{
int count = 1, total = 0;
do
{
printf(“Vive le langage C !!!\n”);
count++;
Syntaxe: total += count;
do instruction } while(count <= NUMBER);
while (expression); printf(“Le total est %d\n”, total);
}
58 59
28
16/05/2018
Les instructions de branchement inconditionnel : break Les instructions de branchement inconditionnel : continue
Syntaxe: Syntaxe:
break; continue ;
Exemple : Exemple:
main()
{ main()
int i ; { int i ;
for ( i=1 ; i<=5 ; i++ )
{ printf ("iteration %d\n", i) ; for ( i=1 ; i<=5 ; i++ )
printf ("bonjour\n") { printf ("début tour %d\n", i) ;
if ( i==3 ) break ;
printf ("fin tour %d\n", i) ; if (i<4) continue ;
} printf ("bonjour\n") ;
printf ("après la boucle") ;
} }}
60 61
29
16/05/2018
Syntaxe:
Syntaxe:
goto etiquette ;
Switch (expression) {
Exemple: case constante1 : instructions1;
for(...)
for(...) case constante2 : instructions2;
If (erreur)
goto TRAITEMENT_ERREUR;
...
... case constante n : instructionsn ;
TRAITEMENT_ERREUR: //le traitement d’erreur est effectue ici
printf("Erreur:...."); default : liste d′ instructions
...
}
Cette instruction est un instruction if généralisée.
62 63
30
16/05/2018
64 65
31
16/05/2018
f) If(x<y) { i = 5 , k = 3 }
g) If(x<y) { i = 5 ; k = 3 } ;
66 67
32
16/05/2018
Fonctions en C Fonctions en C
33
16/05/2018
Fonctions en C Fonctions en C
70 71
34
16/05/2018
/* Programme principal */ Un tableau est un ensemble fini d’ éléments de même type, stockés en
#include <stdio.h> mémoire à des adresses contigües.
• La récursivité void up_and_down(int);
main()
{
up_and_down(1);
Niveau 1 }
Niveau 2
Niveau 3 void up_and_down(int n)
Niveau 4 {
printf(“Niveau %d\n", n);
NIVEAU 4 if (n<4) Syntaxe
NIVEAU 3 up_and_down(n+1); Type nom-du-tableau[nombre- elements];
NIVEAU 2 printf(“NIVEAU %d\n”, n); Exemple
} Int tab[10];
NIVEAU 1
72 73
35
16/05/2018
#include <stdio.h>
Les tableaux main()
{ int i, som, nbm ;
#define N 10 float moy ;
Int main(){ int t[20] ;
Int tab[N];
Int i; for (i=0 ; i<20 ; i++)
... { printf ("donnez la note numéro %d : ", i+1) ;
for(i=0; i<N; i++) scanf ("%d", &t[i]) ;
printf("tab[%d]=%d\n",i, tab[i]); }
...}
Voici les points importants a retenir: for (i=0, som=0 ; i<20 ; i++) som += t[i] ;
• 1. On accède a un élément du tableau en lui appliquant l’operateur []; moy = som / 20 ;
• 2. les index des éléments d’un tableau vont de 0 a nombre-elements-1 printf ("\n\n moyenne de la classe : %f\n", moy) ;
• 3. la taille d’un tableau DOIT être connue statiquement par le compilateur. for (i=0, nbm=0 ; i<20 ; i++ )
• Impossible donc d écrire int[n] ou n est une variable. if (t[i] > moy) nbm++ ;
printf ("%d élèves ont plus de cette moyenne", nbm) ;
74
} 75
36
16/05/2018
37
16/05/2018
Cas particulier des tableaux de caractères Cas particulier des tableaux de caractères
#include<stdio.h>
Un tableau de caractères peut être initialise comme une liste de
Int main(){
caractères.
Char t1[7]="bonjour";//sans’\0’
Exemple: char ch[3]={’a’,’b’,’c’}; Char t2[]=" bonjour";//avec’\0’
Printf ("t1(de taille%i) = %s\n", sizeof(t1) / sizeof(char), t1);
–On peut aussi initialiser un tableau de caractère par une chaine Printf ("t2(de taille%i )= %s\n", sizeof(t2) / sizeof(char), t2);
littérale: return0;
Char ch[8]="exemple"; }
Ce programme renverra:
t1(de taille 7)=bonjour
t2(de taille 8)=bonjour
38
16/05/2018
#include<stdio.h>
Un tableau a deux dimensions se déclare donc de la manière #define L 3
suivante: #define C 2
Int mat[10][20]; int tab[L][C]={{1,2},{14,15},{100,200}};
Int main(){
On accède a un élément du tableau par l’expression mat[i][j]. Int i, j;
for(i=0; i<L; i++){
for(j=0; j<C; j++)
Initialisation
Printf ("tab[%d][%d]=%d\n", i, j, tab[i][j]);
Int tab [3] [4] = { { 1, 2, 3, 4 } , }
{ 5, 6, 7, 8 }, return0;
{ 9,10,11,12 } } }
int tab [3] [4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }
80 81
39
16/05/2018
82 83
40
16/05/2018
3. Combien de fois passe-t-on dans la boucle suivante ? 4. Comment inclure une bibliothèque standard ?
for ( compteur = 2; compteur < 9; compteur += 2 ) a) #include <windows.h>
a) 4
b) #include "windows.h"
b) 5
c) #include [windows.h]
c) 7
d) #include {windows.h}
d) 8
84 85
41
16/05/2018
5. Que donne le code suivant : &A ? 6. Lequel de ses codes crée un tableau de 5 entiers ?
a) L'adresse de la variable A a) int Tab(5);
b) La valeur de la variable A b) int *Tab[5];
c) La valeur de la variable sur laquelle pointe A c) int Tab[4];
d) int Tab [5]
86 87
42
16/05/2018
43
16/05/2018
Problématique
int x;
Pointeurs et Chaines de x=20 ;
Caractères en langage C
Printf (la valeur de x=%d\n, x ); 20
Printf (l’adresse de x=%d\n, &x );
&x x
90 91
44
16/05/2018
Problématique
45
16/05/2018
Syntaxe Syntaxe
94 95
46
16/05/2018
96 97
47
16/05/2018
main()
#include <stdio.h> {
int main (void) void echange (int * ad1, int * ad2) ;
int a=10, b=20 ;
{ printf ("avant appel %d %d\n", a, b) ;
echange (&a, &b) ;
int n=10; printf ("après appel %d %d", a, b) ;
}
int *p=&n;
void echange (int * ad1, int * ad2)
printf("%d\n", p); { int x ;
x = * ad1 ;
printf("%d\n",*p); * ad1 = * ad2 ;
* ad2 = x ;
} }
98 99
48
16/05/2018
49
16/05/2018
50
16/05/2018
51
16/05/2018
✓ Les pointeurs sont semblables aux variables, à ceci près programmation pour désigner… du texte, tout simplement !.
qu'au lieu de stocker un nombre ils stockent l'adresse à Une chaîne de caractère doit impérativement contenir un
laquelle se trouve une variable en mémoire.
caractère spécial à la fin de la chaîne, appelé « caractère de
✓ Si on place un symbole & devant un nom de variable, on fin de chaîne ».
obtient son adresse au lieu de sa valeur (ex. : &age).
Ce caractère s'écrit '\0'.
✓ Si on place un symbole * devant un nom de pointeur , on
obtient la valeur de la variable stockée à l'adresse indiquée
par le pointeur .
106 107
52
16/05/2018
char chaine[6];
// Tableau de 6 char pour stocker S-a-l-u-t + le \0 int main(void )
{
chaine[0] = 'S';
chaine[1] = 'a'; char chaine[] = "Salut";
chaine[2] = 'l'; // La taille du tableau chaine est automatiquement calculée
chaine[3] = 'u'; printf("%s", chaine);
chaine[4] = 't';
chaine[5] = '\0'; return 0;
}
108 109
53
16/05/2018
110 111
54
16/05/2018
55
16/05/2018
strcpy : copier une chaîne dans une autre char chaine1[10], chaine2[10];
char* strcpy(char Chaine1[], const char chaine2[]); printf("saisissez la chaine 1\n");
scanf("%s", &chaine1);
strcpy(chaine2, chaine1);
printf("le contenu de la chaine 2 après la copié est
%s\n",chaine2);
114 115
56
16/05/2018
116 117
57
16/05/2018
58
16/05/2018
{
printf("Voici la fin de la chaine a partir du premier d :%s",
suiteChaine);
}
return 0;
}
120 121
59
16/05/2018
Variante
strstr : rechercher une chaîne dans une autre
122 123
60
16/05/2018
int main()
{ sprintf : écrire dans une chaîne
char *suiteChaine;
// On cherche la première occurrence de "test" dans "Texte de test" : Cette fonction se trouve dans stdio.h contrairement aux
suiteChaine = strstr("Texte de test", "test");
if (suiteChaine != NULL)
autres fonctions que nous avons étudiées jusqu'ici, qui
{ étaient dans string.h.
printf("Premiere occurrence de test dans Texte de test :
%s\n", suiteChaine);
}
return 0;
}
124 125
61
16/05/2018
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) strpbrk : premier caractère de la liste
{ char* strpbrk(const char* chaine, const char* caractere);
char chaine[100];
int age = 15;
// On écrit "Tu as 15 ans" dans chaine
sprintf(chaine, "Tu as %d ans !", age);
// On affiche chaine pour vérifier qu'elle contient bien cela :
printf("%s", chaine);
return 0;
}
126 127
62
16/05/2018
128 129
63
16/05/2018
130 131
64
16/05/2018
2. b
3. b
4. b
132 133
65
16/05/2018
134 135
66
16/05/2018
introduction introduction
137
instructions
136 137
67
16/05/2018
Définition Exemple
}
138
68
16/05/2018
69
16/05/2018
Cas des fonctions sans valeur de retour/sans arguments En C, les arguments sont transmis par valeur
#include <stdio.h>
main()
void sansval (int n) { void echange (int a, int b) ;
int n=10, p=20 ;
void sansval (int) ; printf ("avant appel : %d %d\n", n, p) ;
echange (n, p) ;
float tirage (void) printf ("après appel : %d %d", n, p) }
void echange (int a, int b)
float tirage (void) ; {
int c ;
printf ("début echange : %d %d\n", a, b) ;
void message (void) c=a;
a=b;
void message (void) ; b=c;
printf ("fin echange : %d %d\n", a, b) ;
}
70
16/05/2018
71
16/05/2018
int test(void)
{ Variables variables
int a,b; globales locales
a = g();
b = h();
return fonction(a, b);
} 146 147
72
16/05/2018
73
16/05/2018
74
16/05/2018
152 153
75
16/05/2018
#include <stdio.h>
Nombre variable d'arguments #include <stdarg.h>
void test(int nbpar, ...)
#include <stdarg.h> { va_list adpar ;
int parv, i ;
void ma_fonction(type1 arg1, type2 arg2, ...) printf ("nombre de valeurs : %d\n", nbpar) ;
{... } va_start (adpar, nbpar) ;
<stdio.h> for (i=1 ; i<=nbpar ; i++)
va_start va_arg { parv = va_arg (adpar, int) ;
printf ("argument variable : %d\n", parv) ;
va_list va_end }} premier test
main() nombre de valeurs : 3
{ printf ("premier test\n") ; argument variable : 15
Ce code contient une erreur volontaire ! test (3, 15, 30, 40) ; argument variable : 30
printf ("\ndeuxième test\n") ; argument variable : 40
void ma_fonction(...); test (0) ; } deuxième test
nombre de valeurs : 0
154 155
76
16/05/2018
77
16/05/2018
158 159
78
16/05/2018
79
16/05/2018
&x x[1]
80
16/05/2018
164
81
16/05/2018
#include <stdlib.h>
D’une manière générale, le prototype de malloc
.....
est présenté comme suit : char * adr ;
.....
void * malloc (size_t taille)
adr = malloc (50) ;
.....
for (i=0 ; i<50 ; i++) *(adr+i) = 'x' ;
stdlib.h
166 167
82
16/05/2018
#include <stdio.h>
allocation de 100 octets en 06AC
#include <stdlib.h>
Second exemple allocation de 50 octets en 0714
main() libération de 100 octets en 06AC
{ allocation de 40 octets en 06E8
int* adr ; char * adr1, * adr2, * adr3 ;
..... adr1 = malloc (100) ;
printf ("allocation de 100 octets en %p\n", adr1) ;
adr = malloc (100 * sizeof(int)) ; adr2 = malloc (50) ;
..... printf ("allocation de 50 octets en %p\n", adr2) ;
for (i=0 ; i<100 ; i++) *(adr+i) = 1 ; free (adr1) ;
printf ("libération de 100 octets en %p\n", adr1) ;
adr3 = malloc (40) ;
printf ("allocation de 40 octets en %p\n", adr3) ;
}
168 169
83
16/05/2018
Autres outils de gestion dynamique : calloc et realloc Autres outils de gestion dynamique : calloc et realloc
84
16/05/2018
Autres outils de gestion dynamique : calloc et realloc Autres outils de gestion dynamique : calloc et realloc
172
85
16/05/2018
1. Que se passe-t-il en mémoire avec le code suivant : 2. Comment initialiser un pointeur sur un
malloc(sizeof(int) * 25); ? tableau de 10 char ?
A. Cela réserve de la mémoire pour un entier de 25 octets A. p = malloc (10);
B. Cela réserve de la mémoire pour un tableau de 25 entiers B. p = (char *) malloc(10,1);
C. Cela réserve de la mémoire pour un tableau de 25 octets
C. p = (char *) malloc (sizeof(10*char));
D. Cela réserve de la mémoire pour un tableau de 25 cchar
D. p = (char *) malloc(10 * sizeof(char));
86
16/05/2018
3. On souhaite modifier la taille d'un tableau T P pointe sur un tableau de 10 entiers, on souhaite
d'entiers, passer de 10 à 11 entiers ? libérer la mémoire qu'il occupe. Comment faire ?
A. T = (int *) malloc (11* sizeof( int ) ); A. P = NULL;
B. T = (int *) malloc (11); B. *P = 0;
C. T= (int *) realloc (T, 11* sizeof( int ) ); C. free( P );
D. T = (char *) realloc( 11 * sizeof (int )); D. free ( *P );
87
16/05/2018
1. b Les structures
2. d et les énumérations en
3. c langage C
4. c
179
88
16/05/2018
89
16/05/2018
90
16/05/2018
184 185
91
16/05/2018
art1.numero = art2.numero ;
art1.qte = art2.qte ;
art1.prix = art2.prix ;
186 187
92
16/05/2018
Définition des synonymes avec typedef Définition des synonymes avec typedef
La déclaration :
De même :
typedef int entier ; typedef int * ptr ;
signifie que entier est synonyme de int, de sorte que
signifie que ptr est synonyme de int *.
les déclarations suivantes sont équivalentes :
Les déclarations suivantes sont équivalentes :
int n, p ;
int * p1, * p2 ;
entier n, p ; ptr p1, p2 ;
188 189
93
16/05/2018
struct enreg
{ int numero ;
typedef int vecteur [3] ;
int qte ;
les déclarations suivantes sont équivalentes : float prix ;
int v[3], w[3] ; };
typedef struct enreg s_enreg ;
vecteur v, w ;
s_enreg art1, art2 ;
190 191
94
16/05/2018
95
16/05/2018
96
16/05/2018
typedef struct {
char nom[64]; Soit la déclaration suivante :
int age;
} etudiant; struct personne { char nom[30] ;
int main() { char prenom [20] ;
etudiant e;
etudiant *p = &e; float heures [31] ;
strcpy(e.nom, "ALI"); e.age = 18;
} employe, salesmen;
printf ("%s a %d ans\n", e.nom, e.age);
printf ("%s a %d ans\n", p->nom, p->age);
return 0; }
196 197
97
16/05/2018
Les notations :
Enfin :
le cinquième élément employe.nom
employe.heures[4] représente l’adresse de ce tableau.
du tableau heures
98
16/05/2018
int x ; notation :
int y ; traj[i].nom
}; représente le nom du point de rang i du tableau
struct point traj[50] ; traj. Il s’agit donc d’une valeur de type char.
200 201
99
16/05/2018
100
16/05/2018
struct date
Réaliser la même chose que dans { int jour ;
int mois ;
struct personne
l’exercice précédent, mais en prévoyant, int annee ;
{ char nom[30] ;
};
char prenom[20] ;
cette fois, un fonction pour la lecture des float heures [31] ;
struct date date_embauche ;
informations et une fonction pour struct date date_poste ;
} employe, salesmen;
l’affichage
204 205
101
16/05/2018
102
16/05/2018
Transmission d’une structure en argument d’une fonction Transmission d’une structure en valeur
de retour d’une fonction
#include <stdio.h>
struct enreg { int a ; float b ; } ;
main() struct enreg fct (...)
{ struct enreg x ;
void fct (struct enreg y) ; { struct enreg s ; /* structure locale à fct */
x.a = 1; x.b = 12.5;
printf ("\n avant appel fct : %d %f",x.a,x.b); .....
fct (x) ; return s ; /* dont la fonction renvoie la valeur */
printf ("\n au retour dans main : %d %f", x.a, x.b); }
void fct (struct enreg s) }
{ s.a = 0; s.b=1;
printf ("\n dans fct : %d %f", s.a, s.b);
}
208 209
103
16/05/2018
104
16/05/2018
212 213
105
16/05/2018
106
16/05/2018
0 1
Propriétés du type énumération Propriétés du type énumération 2
Les énumérations sont des types définissant un ensemble
enum couleur {jaune, rouge, bleu, vert} ;
de constantes.
107
16/05/2018
108
16/05/2018
220 221
109
16/05/2018
Exponentiations Logarithmes
Erreurs
La fonction pow peut déclencher une erreur : EDOM : x est négatif ;
EDOM : x est négatif, et y n’est pas un entier. ERANGE : x est nul.
222 223
110
16/05/2018
111
16/05/2018
Arc tangente
226 227
112
16/05/2018
introduction introduction
Programme.exe
On distingue traditionnellement deux techniques de
gestion de fichiers :
✓ l’accès séquentiel consiste à traiter les informations
séquentiellement ;
✓ l’accès direct consiste à se placer immédiatement sur
l’information souhaitée, sans avoir à parcourir celles
qui la précèdent.
228 229
113
16/05/2018
#include <stdio.h>
main() sortie = fopen (nomfich, "w") ;
{ char nomfich[21] ;
int n ; Elle possède deux arguments :
FILE * sortie ;
printf ("nom du fichier à créer : ") ; ✓ Le nom du fichier; ici, nous avons prévu que ce
scanf ("%s", nomfich) ; nom ne dépassera pas 20 caractères (le chiffre 21
sortie = fopen (nomfich, "w") ;
tenant compte du caractère \0) ;
do { printf ("donnez un entier : ") ;
scanf ("%d", &n) ;
if (n) ✓ Une indication sur le mode de manipulation.
fwrite (&n, sizeof(int), 1, sortie) ; }
while (n) ;
fclose (sortie) ; }
230 231
114
16/05/2018
115
16/05/2018
fclose (entree) ;}
234 235
116
16/05/2018
La lecture dans le fichier se fait par un appel de la On pourrait remplacer la boucle while par la
fonction fread : construction (moins concise) suivante :
fread (&n, sizeof(int), 1, entree); do
dont les arguments sont comparables à ceux de fwrite. { fread (&n, sizeof(int), 1, entree) ;
Mais, cette fois, la condition d’arrêt de la boucle est : if ( !feof(entree) ) printf ("\n%d", n) ;
}
feof (entree)
while ( !feof(entree) ) ;
236 237
117
16/05/2018
118
16/05/2018
✓fputc : écrit un caractère dans le fichier ; Cette fonction écrit un caractère à la fois dans le fichier. Son
prototype est :
✓ fputs : écrit une chaîne dans le fichier ;
int fputc(int caractere, FILE* pointeurSurFichier);
✓ fprintf : écrit une chaîne « formatée » dans le fichier,
fonctionnement quasi-identique à printf.
240 241
119
16/05/2018
120
16/05/2018
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
FILE* fichier = NULL; FILE* fichier = NULL;
Bonjour int age = 0;
fichier = fopen("test.txt", "w"); tout le monde fichier = fopen("test.txt", "w");
121
16/05/2018
122
16/05/2018
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ { FILE* fichier = NULL;
FILE* fichier = NULL; char chaine[1000] = "";
char chaine[1000] = "";
fichier = fopen("test.txt", "r"); fichier = fopen("test.txt", "r");
if (fichier != NULL)
if (fichier != NULL) {
{ while (fgets(chaine, 1000, fichier) != NULL)
fgets(chaine, 1000, fichier); {
printf("%s", chaine); printf("%s", chaine); }
fclose(fichier); fclose(fichier);
} }
return 0; return 0;
} }
248 249
123
16/05/2018
124
16/05/2018
✓ ftell : indique à quelle position vous êtes actuellement Cette fonction est très simple à utiliser. Elle renvoie la position
dans le fichier ; actuelle du curseur sous la forme d'un long :
252 253
125
16/05/2018
254 255
126
16/05/2018
256 257
127
16/05/2018
128
16/05/2018
1. Quelle est la syntaxe correcte pour la 2. Pour ouvrir un fichier en mode lecture et
déclaration d’un fichier ? écriture, avec suppression, nous précisons ?
a) file a) a
b) Fichier b) w
c) FILE c) w+
d) File d) r+
260 261
129
16/05/2018
130
16/05/2018
5. fseek(fichier, 2, SEEK_END);
a) Le code place le curseur à la fin du 1. c
fichier ;
2. c
3. a
b) Le code place le curseur à deux caractères
4. a c d
avant la fin du fichier ;
5. c
c) Le code est erroné ;
264 265
131
16/05/2018
266 267
132
16/05/2018
133
16/05/2018
270 271
134
16/05/2018
#define max 100 on peut expliciter facilement les relations entre constantes.
272 273
135
16/05/2018
274 275
136
16/05/2018
137
16/05/2018
#define CODE 1
#define MAX(a,b) a>b?a:b
.....
#if CODE == 1
Cette macro peut être appelée comme n'importe
instructions 1 quelle fonction C.
#elif CODE == 2 Ainsi, après passage du préprocesseur, z = MAX(x,y);
#endif
278 279
138
16/05/2018
#define abs(a) ((a) < 0 ? (-(a)) : (a)) #define min(a1,a2) ((a1) < (a2) ? (a1) : (a2))
280 281
139
16/05/2018
282 283
140
16/05/2018
284 285
141
16/05/2018
z = a + i ∗ b,
où a, b ∈ R.
Les listes chaînées
On rappelle que a est la partie réelle de z,
en langage C b sa partie imaginaire et i le nombre
imaginaire:
i =√−1 (i2= −1).
creal cimag
286 287
142
16/05/2018
#include <stdio.h>
#include <stdlib.h> Le langage C dispose d'un pointeur
#include <complex.h> particulier appelé pointeur générique qui
int main() est un pointeur compatible avec tous les
{ double complex z1 = 1.0 + 3.0 * I; autres pointeurs, c'est-à-dire que ce
double complex z2 = 1.0 - 4.0 * I; pointeur est à même de pointer vers
double complex somme = z1 + z2; n'importe quel type d'objet.
printf("Z1 + Z2 = %.2f %+.2fi\n", creal(somme), cimag(somme));
double complex diff = z1 - z2;
printf("Z1 - Z2 = %.2f %+.2fi\n", creal(diff), cimag(diff)); void *
return 0; }
288 289
143
16/05/2018
290 291
144
16/05/2018
292 293
145
16/05/2018
#include <stdio.h>
int somme(int a, int b);
int produit(int a, int b);
Fichier : exemple.c
int main()
{
int a = 2, b = 5;
printf("%d + %d = %d\n", a, b, somme(a, b));
printf("%d * %d = %d\n", a, b, produit(a, b));
return 0;
}
294 295
146
16/05/2018
147
16/05/2018
#include <stdio.h>
static int id(int x); /* Déclaration de la fonction "privee" */
il permet d'indiquer que la variable ou la
int main()
fonction est définie dans un autre fichier {
int x = 0;
(source ou objet). Placé devant une printf("id(%d) = %d\n", x, id(x));
return 0;
définition, il permet d'indiquer que la }
int id(int x)
variable ou la fonction est visible dans {
return x;
tout le projet. }
298 299
148
16/05/2018
Int T[5];
suivant
suivant
suivant
Int a; Int a; Int a;
T[0] T[1] T[2] T[3] T[4]
Null
suivant
T[0] T[1] T[i] T[2] T[3] T[4] Int a;
149
16/05/2018
Int a;
suivant
suivant
Flaot b; Flaot b; Flaot b;
char c;
{
char c; char c;
int val;
struct Element * suivant;
Null };
Int a; typedef struct Element* Element;
suivant
Flaot b;
char c;
150
16/05/2018
suivant
suivant
Int val; Int val;
✓ Initialiser la liste ;
✓ Ajouter un élément ;
Null
struct Element inserer(int info)
✓ Supprimer un élément ;
{struct Element liste=malloc(sizeof(struct Element));
✓ Afficher le contenu de la liste ; liste->val=info;
liste->suivant=NULL;
✓ Supprimer la liste entière. return liste;};
304
151
16/05/2018
Les listes chaînées- Ajouter un élément Les listes chaînées- supprimer un élément
suivant
suivant
Int val; Int val;
suivant
Int val; suivant Int val;
152
16/05/2018
suivant
Précédant
suivant
Précédant
suivant
a1 a3 a4
Vous pouvez ajouter des pièces une
à une en haut de la pile, mais aussi
suivant
a2
153
16/05/2018
Par exemple, imaginons une pile de nombres entiers de type int void empiler(Pile *pile, int nvNombre)
typedef struct Element Element; {
struct Element Element *nouveau = malloc(sizeof(*nouveau));
if (pile == NULL || nouveau == NULL) 21
{
int nombre; {
Element *suivant; 2 exit(EXIT_FAILURE); 2
}; }
154
16/05/2018
155
16/05/2018
156
16/05/2018
157
16/05/2018
158