1. PARTIE 1 : Les
bases
- Les fonctions principales
- Les variables
- Les maths
- Les conditions (if / switch)
- Les boucles (for / do while /
while)

2. Code de base
#include <stdio.h>
#include <stdlib.h>
int main (void)
{
// Code
return 0;
}

3. Fonctions
Noms
principales
Effets Exemples
printf Affiche un message printf(«Hello world»);
scanf Récupère une saisie scanf(«%d», &variable);
Caractères spéciaux printf Effets
n Saut à la ligne
t Tabulation.
Symboles commentaires Effets
// Commentaire sur une ligne.
/*...*/ Commentaire en bloc.

4. Variables
Noms Appels printf / scanf Valeurs
entier (unsigned) int %d -2 à 2 milliards
décimal (unsigned) float %f Beaucoup
caractère (unsigned) char %c -127 à 128
chaîne de caractères char [TAILLE] %s Dépend de TAILLE

5. Variables (algo)
Variables : variable : entier
DEBUT
variable <- saisir() // Récupère saisie
afficher -> “La saisie vaut “ + variable// Affiche saisie
FIN

6. Variables (code)
#include <stdio.h>
#include <stdlib.h>
int main (void)
{
int variable = 0; // Initialisation variable
// NE PAS OUBLIER LE “&“ DEVANT variable !!!
scanf(“%d“, &variable); // Récupère saisie
printf(“La saisie vaut %d“, variable); // Affiche saisie
return 0;
}

7. Mathématiques
Symboles Définitions
+ Addition
- Soustraction
* Multiplication
/ Division
% Modulo

8. Maths (modulo)
11 2
5
1
11 = 2 * 5 + 1 => 11 % 2 = 1

9. Maths (fonctions)
Fonctions Effets
sqrt(X) Racine carrée de X
pow(X,Y) Puissance : X^Y
fabs(X) Valeur absolue de X
ceil(X) Entier sup. de X
floor(X) Entier inf. de X

10. Maths (algo)
Variables
valeur1, valeur2, resultat : entier
DEBUT
valeur1 <- 10, valeur2 <- 4
resultat <- valeur1 * valeur2 / 7
resultat <- resultat - 5; // Ou : “resultat -= 5;“, resultat = 1
resultat <- resultat + 1; // Ou : “resultat ++;“, resultat = 2
resultat <- resultat³ // resultat = 2^3 = 8
FIN

11. Maths (code)
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main (void)
{
int valeur1 = 10, valeur2 = 4; // Initialisation variables
int resultat = valeur1 * valeur2 / 7; // = 6 (c’est un int)
resultat = resultat - 5; // Ou : “resultat -= 5;“, resultat = 1
resultat = resultat + 1; // Ou : “resultat ++;“, resultat = 2
resultat = pow(resultat,3); // resultat = 2^3 = 8
return 0;
}

12. ASCII
Un caractère (char) a une valeur décimale
comprise entre 0 et 255.
Par exemple : le nombre 65 correspond à la
lettre «A».
#include ... int main (void){
int valeur; char caractere = ‘A’;
valeur = caractere+1; // C’est possible, valeur = 65 + 1 = 66
printf(“Caractere : %c ; ASCII : %d“, valeur);
// Affichera : «Caractere : B ; ASCII : 66»
return 0;
}

13. Conditions
Comme son nom l’indique, une condition
s’utilise quand on souhaite exécuter un code
selon un ou plusieurs cas particulier(s).

14. Conditions (if /
switch)
IF SWITCH
Plusieurs variables Une seule variable
Variables indéfinies Variables définies
Conditions ET/OU possibles Conditions ET/OU impossibles
Moins rapide à écrire Plus rapide à écrire
Moins clair à lire Plus clair à lire

15. Conditions (if
else)
Les accolades {} peuvent être supprimées si le
code de la condition ne fait qu’une ligne.
if (age < 18) printf(“Film -18 ans interdit.“);
Une condition peut être négative par «!»
if (!(age < 18)) printf(“Film -18 ans autorisé.“);
Une variable seule peut servir de condition
(booléen), toujours vraie si variable ≠ 0.
if (jeu_en_cours) printf(“Bonne partie.“);

16. Conditions
(Opérateurs)
Symboles Effets
== Egal
!= Différent
> Supérieur
< Inférieur
>= Sup. ou égal
<= Inf. ou égal
|| Ou
&& Et

17. Conditions
(Opérateurs bool)
if (A operateur B)
A B || &&
0 0 0 0
0 1 1 0
1 0 1 0
1 1 1 1

18. Conditions
(switch)
Mots-clés Effets
case Débute chaque condition.
default Exécuté par défaut.
break Quitte le switch.

19. Conditions
(switch)
#include ... int main (void){
switch (tension)
{
case 0 : printf(“T’es mort.“); break;
default : printf(“T’es en vie.“);
}
return 0;
}

20. Conditions (algo)
DEBUT
Si booleen1 ET non booleen3 Alors
Instructions 1
Sinon si booleen2
Instructions 2
Sinon
Instructions 3
Fin Si
FIN

21. Conditions (code)
int main(void)
{
if (booleen1 && !booleen3)
printf(“Instructions 1“);
else if (booleen2)
printf(“Instructions 2“);
else
printf(“Instructions 3“);
}

22. Boucles
Comme son nom l’indique, le code d’une
boucle se répète jusqu’à ce que la condition soit
fausse.
Elle s’utilise quand on souhaite exécuter un
code répétition.

23. Boucles
Mots-clés Effets
for On exécute le bloc de 0 à n fois, utilisé pour compter.
do while On exécute le bloc de 1 à n fois.
while On exécute le bloc de 0 à n fois.

24. Boucles (For)
La boucle for possède 3 arguments :
Le 1er pour initialiser.
Le 2è pour conditionner la fin.
Le 3è pour calculer le pas.

25. Boucles (algo)
DEBUT
// For
Pour i<-0 à 9
Instructions 1
i Suivant
// Do while
Faire
Instructions 2
Tant que i<10
// While
Tant que i<10
Instructions 3
Fin Tant que
FIN

26. Boucles (code)
int main(void)
{
int i=0;
for(i=0; i<10 ; i++){// Code}
do{// Code}while(i<10);
while(i<10){// Code}
}

27. Boucles
(ATTENTION !!!)
Attention aux boucles infinies !
int main(void)
{
while(!Arthur_Bon_En_Design){// Inutile}
while(!Barbara_Bon_En_Design){// OK}
while(!Jeremie_Bon_En_Design){// Boucle infinie}
}

28. PARTIE 2 :
Tableaux
- Tableaux 1 et 2 dimensions !
- Chaînes de caractères
- Define, nouvelle directive de
préprocesseur

29. Tableaux
Le tableau peut être de tous les types (int, float,
char).
Un tableau se déclare avec les crochets [] dans
lesquels on met le nombre de valeur max.
int main(void)
{
int Tableau_Entier[10];
float Tableau_Decimaux[5];
char Tableau_Caractete[100];
}

30. Tableaux
(initialisation)
int main(void)
{
int Tab_Int[3]={1, 2, 3}; // On initialise les valeurs au début
// Ou alors on entre les valeurs par adresse tableau
// Un tableau commence toujours à l’adresse 0
int Tab_Int2[3];
Tab_Int2[0] = 1;
Tab_Int2[1] = 2;
Tab_Int2[2] = 3;
}

31. Tableau à 2
dimensions
int main(void)
{
int Tab_Int[3][3]=
{
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
}

32. Chaînes de car.
Noms Appels printf / scanf Valeurs
entier (unsigned) int %d -2 à 2 milliards
décimal (unsigned) float %f Beaucoup
caractère (unsigned) char %c -127 à 128
chaîne de caractères char [TAILLE] %s Dépend de TAILLE

33. Chaînes de car.
(règles)
La chaîne se termine toujours par “0“.
Lors d’un scanf :
Le “&“ disparaît.
La saisie s’arrête dès l’appui sur la touche
“enter“ ou la présence d’un espace !

34. Chaînes de car.
(règles)
int main(void)
{
char Tab_Int[7];
scanf(“%s“, Tab_Int);
print(“%s“, Tab_Int);
}

35. Chaînes de car.
(règles)
Adresses Valeurs
0 B
1 o
2 n
3 j
4 o
5 u
6 r
7 0

36. Chaînes de car.
(Fonctions)
Fonctions Effets
strcpy(X,Y) Copie Y dans X
strcat(X,Y) Concatène X et Y, dans X.
strcmp(X,Y) Compare X et Y (0 si identique, 1 si non)
strlen(X) Renvoi la longueur de la chaîne de car.
Recherche caractère Y dans chaîne X, et
strchr(X,Y)
renvoie la chaîne à partir de Y.

37. Directive de
préprocesseur
#include est une directive de préprocesseur.
#include = appel des bibliothèques
#define = variable globale

38. Partie 2 (algo)
Variable globale TAILLE <- 10
Tableau entier Tab(TAILLE)
DEBUT
Tab <- Saisir()
Si Tab = “bonjour“ Alors
Afficher -> Tab
Fin Si
FIN

39. Partie 2 (code)
#include <string.h>
#define TAILLE 100
int main(void)
{
char Tab[TAILLE];
scanf(“%s“, tab)
if(strcmp(tab == “bonjour0“) printf(“%s“, tab);
return 0;
}