Apprendre C

C est un langage de programmation à usage général, développé en 1972, et toujours très populaire.
C est très puissant ; il a été utilisé pour développer des systèmes d'exploitation, des bases de
données, des applications, etc.
Exemples dans chaque chapitre
Example
#include <stdio.h>

int main() {
printf("Hello World!");
return 0;
}

C'est quoi C?
C est un langage de programmation à usage général créé par Dennis Ritchie aux Bell Laboratories
en 1972.
C'est une langue très populaire, malgré son ancienneté.
C est fortement associé à UNIX, car il a été développé pour écrire le système d'exploitation UNIX.
Pourquoi apprendre le C ?
• C'est l'un des langages de programmation les plus populaires au monde
• Si vous connaissez C, vous n'aurez aucun problème à apprendre d'autres langages de
programmation populaires tels que Java, Python, C++, C#, etc., car la syntaxe est similaire.
• C est très rapide, comparé à d'autres langages de programmation, comme Java et Python
• C est très polyvalent; il peut être utilisé à la fois dans les applications et les technologies
Différence entre C et C++
• C++ a été développé comme une extension de C, et les deux langages ont presque la même syntaxe
• La principale différence entre C et C++ est que C++ prend en charge les classes et les objets, alors
que C ne le fait pas.
Il n'est pas nécessaire d'avoir une expérience préalable en algorithmique.
Pour commencer à utiliser C, vous avez besoin de deux choses :
• Un éditeur de texte, comme Notepad, pour écrire du code C
• Un compilateur, comme GCC, pour traduire le code C dans un langage que l'ordinateur
comprendra
Il existe de nombreux éditeurs de texte et compilateurs parmi lesquels choisir.
Installer un IDE
Un IDE (Integrated Development Environment) est utilisé pour éditer et compiler le code.
Les IDE populaires incluent Code : Blocks, Eclipse et Visual Studio. Ils sont tous gratuits et
peuvent être utilisés à la fois pour éditer et déboguer du code C.
Remarque : les IDE basés sur le Web peuvent également fonctionner, mais les fonctionnalités sont
limitées.
Nous utiliserons Code :: Blocks, qui, selon nous, est un bon point de départ.
Vous pouvez trouver la dernière version de Codeblocks sur http://www.codeblocks.org/ .
Téléchargez le mingw-setup.exefichier, qui installera l'éditeur de texte avec un compilateur.
Démarrage
Créons notre premier fichier C.
Ouvrez Codeblocks et accédez à Fichier > Nouveau > Fichier vide.
Écrivez le code C suivant et enregistrez le fichier sous myfirstprogram.c
(Fichier > Enregistrer le fichier sous) :

#include <stdio.h>

int main() {
printf("Hello World!");
return 0;
}
Dans Codeblocks, cela devrait ressembler à ceci :

Ensuite, allez dans Build > Build and Run pour lancer (exécuter) le programme. Le résultat
ressemblera à ceci :
Hello World!
Process returned 0 (0x0) execution time : 0.011 s
Press any key to continue.
monpremierprogramme.c
Code:
#include <stdio.h>

int main() {
printf("Hello World!");
return 0;
}
Résultat:
Hello World!
Syntaxe
Décomposons le code pour mieux le comprendre :
Exemple
#include <stdio.h>

int main() {
printf("Hello World!");
return 0;
}
Exemple expliqué
Ligne 1 : #include <stdio.h> est une bibliothèque de fichiers d'en-tête qui nous permet de
travailler avec des fonctions d'entrée et de sortie, telles que printf()(utilisé à la ligne 4). Les
fichiers d'en-tête ajoutent des fonctionnalités aux programmes C.
Ne vous inquiétez pas si vous ne comprenez pas comment #include <stdio.h>fonctionne.
Considérez-le simplement comme quelque chose qui apparaît (presque) toujours dans votre
programme.
Ligne 2 : une ligne vide. C ignore les espaces blancs. Mais nous l'utilisons pour rendre le code plus
lisible.
Ligne 3 : Une autre chose qui apparaît toujours dans un programme C, c'est main(). C'est ce qu'on
appelle une fonction. Tout code à l'intérieur de ses accolades {} sera exécuté.
Ligne 4 : printf() est une fonction utilisée pour sortir/imprimer du texte à l'écran. Dans notre
exemple, il affichera "Hello World".
Notez que : Chaque instruction C se termine par un point-virgule;
Remarque : Le corps de int main()peut également être écrit comme suit :
int main(){printf("Hello World!");return 0;}
Rappel : Le compilateur ignore les espaces blancs. Cependant, plusieurs lignes rendent le code
plus lisible.
Ligne 5 : return 0 termine la main()fonction.
Ligne 6 : N'oubliez pas d'ajouter l'accolade fermante} pour terminer la fonction principale.

Sortie (texte d'impression)

Pour afficher des valeurs ou imprimer du texte en C, vous pouvez utiliser la printf() fonction :
Exemple
#include <stdio.h>

int main() {
printf("Hello World!");
return 0;
}
Vous pouvez utiliser autant de printf()fonctions que vous le souhaitez. Cependant, notez qu'il
n'insère pas de nouvelle ligne à la fin de la sortie :
Exemple
#include <stdio.h>
int main() {
printf("Hello World!");
printf("I am learning C.");
return 0;
}
Nouvelles lignes
Pour insérer une nouvelle ligne, vous pouvez utiliser le \n caractère :
Exemple
#include <stdio.h>

int main() {
printf("Hello World!\n");
printf("I am learning C.");
return 0;
}
Vous pouvez également générer plusieurs lignes avec une seule printf()fonction. Cependant,
sachez que cela rendra le code plus difficile à lire :
Exemple
#include <stdio.h>

int main() {
printf("Hello World!\nI am learning C.\nAnd it is awesome!");
return 0;
}
Astuce : Deux \n caractères l'un après l'autre créeront une ligne vide :
Exemple
#include <stdio.h>

int main() {
printf("Hello World!\n\n");
printf("I am learning C.");
return 0;
}
Qu'est-ce que c'est \n exactement ?
Le caractère de saut de ligne (\n) est appelé une séquence d’échappement, et il force le curseur à
changer sa position au début de la ligne suivante sur l'écran. Il en résulte une nouvelle ligne.
Voici des exemples d'autres séquences d'échappement valides :
Sequence d'échappement Description
Crée un onglet
\t
horizontal
Insère un
caractère barre
\\
oblique inverse
(\)
Insère un
\" guillemet
double

Commentaires en C
Les commentaires peuvent être utilisés pour expliquer le code et le rendre plus lisible. Il peut
également être utilisé pour empêcher l'exécution lors du test d'un code alternatif.
Les commentaires peuvent être monolignes ou multilignes.

Commentaires sur une seule ligne

Les commentaires sur une seule ligne commencent par deux barres obliques ( //).
Tout texte entre //et la fin de la ligne est ignoré par le compilateur (ne sera pas exécuté).
Cet exemple utilise un commentaire sur une seule ligne avant une ligne de code :
Exemple
// This is a comment
printf("Hello World!");
Cet exemple utilise un commentaire sur une seule ligne à la fin d'une ligne de code :
Exemple
printf("Hello World!"); // This is a comment

Commentaires multilignes
Les commentaires multilignes commencent par /*et se terminent par */.
Tout texte entre /*et */sera ignoré par le compilateur :
Exemple
/* The code below will print the words Hello World!
to the screen, and it is amazing */
printf("Hello World!");

C'est à vous de décider lequel vous souhaitez utiliser. Normalement, nous l'utilisons //pour des
commentaires courts et /* */plus longs.
Bon à savoir : Avant la version C99 (sortie en 1999), vous ne pouviez utiliser que des
commentaires multilignes en C.
Variables C
Les variables sont des conteneurs pour stocker des valeurs de données, comme des nombres et des
caractères.
En C, il existe différents types de variables (définies avec différents mots clés), par exemple :
• int- stocke des nombres entiers (nombres entiers), sans décimales, comme 123ou-123
• float- stocke des nombres à virgule flottante, avec des décimales, telles que 19.99ou-19.99
• char- stocke des caractères uniques, tels que 'a'ou 'B'. Les valeurs char sont entourées de
guillemets simples

Déclarer (créer) des variables

Pour créer une variable, précisez le type et attribuez-lui une valeur :
Syntaxe
type variableName = value;
Où type est l'un des types C (tel que int) et variableName est le nom de la variable (tel que x ou
myName ). Le signe égal est utilisé pour attribuer une valeur à la variable.
Donc, pour créer une variable qui doit stocker un nombre, regardez l'exemple suivant :
Exemple
Créez une variable appelée myNum de type int et affectez-lui la valeur 15 :
int myNum = 15;
Vous pouvez également déclarer une variable sans affecter la valeur, et affecter la valeur plus tard :
Exemple
// Declare a variable
int myNum;

// Assign a value to the variable

myNum = 15;

Variables de sortie
Vous pouvez sortir des valeurs/imprimer du texte avec la printf()fonction :
Exemple
printf("Hello World!");
Dans de nombreux autres langages de programmation (comme Python , Java et C++ ), vous
utiliseriez normalement une fonction d'impression pour afficher la valeur d'une variable.
Cependant, ce n'est pas possible en C:
Exemple
int myNum = 15;
printf(myNum); // Nothing happens
Pour sortir des variables en C, vous devez vous familiariser avec quelque chose appelé
"spécificateurs de format".

Spécificateurs de format
Les spécificateurs de format sont utilisés avec la printf() fonction pour indiquer au compilateur
quel type de données la variable stocke. Il s'agit essentiellement d'un espace réservé pour la valeur
de la variable.
Un spécificateur de format commence par un signe de pourcentage %, suivi d'un caractère.
Par exemple, pour afficher la valeur d'une int variable, vous devez utiliser le spécificateur de
format %d ou %i entouré de guillemets doubles, à l'intérieur de la printf()fonction :
Exemple
int myNum = 15;
printf("%d", myNum); // Outputs 15
Pour imprimer d'autres types, utilisez %c for char et %f for float:
Exemple
// Create variables
int myNum = 15; // Integer (whole number)
float myFloatNum = 5.99; // Floating point number
char myLetter = 'D'; // Character

// Print variables
printf("%d\n", myNum);
printf("%f\n", myFloatNum);
printf("%c\n", myLetter);
Pour combiner à la fois du texte et une variable, séparez-les par une virgule à l'intérieur de la
printf()fonction :
Exemple
int myNum = 15;
printf("My favorite number is: %d", myNum);
Pour imprimer différents types dans une seule printf()fonction, vous pouvez utiliser ce qui suit
:
Exemple
int myNum = 15;
char myLetter = 'D';
printf("My number is %d and my letter is %c", myNum, myLetter);
Modifier les valeurs des variables
Remarque : Si vous affectez une nouvelle valeur à une variable existante, elle écrasera la valeur
précédente :
Exemple
int myNum = 15; // myNum is 15
myNum = 10; // Now myNum is 10
Vous pouvez également affecter la valeur d'une variable à une autre :
Exemple
int myNum = 15;

int myOtherNum = 23;

// Assign the value of myOtherNum (23) to myNum

myNum = myOtherNum;

// myNum is now 23, instead of 15

printf("%d", myNum);
Ou copiez les valeurs dans des variables vides :
Exemple
// Create a variable and assign the value 15 to it
int myNum = 15;

// Declare a variable without assigning it a value

int myOtherNum;

// Assign the value of myNum to myOtherNum

myOtherNum = myNum;

// myOtherNum now has 15 as a value

printf("%d", myOtherNum);

Ajouter des variables ensemble

Pour ajouter une variable à une autre variable, vous pouvez utiliser l’+ opérateur :
Exemple
int x = 5;
int y = 6;
int sum = x + y;
printf("%d", sum);

Déclarer plusieurs variables

Pour déclarer plusieurs variables du même type, utilisez une liste séparée par des virgules :
Exemple
int x = 5, y = 6, z = 50;
printf("%d", x + y + z);
Vous pouvez également affecter la même valeur à plusieurs variables du même type :
Exemple
int x, y, z;
x = y = z = 50;
printf("%d", x + y + z);

Noms des variables

Toutes les variables C doivent être identifiées par des noms uniques.
Ces noms uniques sont appelés identificateurs .
Les identifiants peuvent être des noms courts (comme x et y) ou des noms plus descriptifs (age,
sum, totalVolume).
Remarque : Il est recommandé d'utiliser des noms descriptifs afin de créer un code
compréhensible et maintenable :
Exemple
// Good
int minutesPerHour = 60;

// OK, but not so easy to understand what m actually is

int m = 60;
Les règles générales pour nommer les variables sont :
• Les noms peuvent contenir des lettres, des chiffres et des traits de soulignement
• Les noms doivent commencer par une lettre ou un trait de soulignement (_)
• Les noms sont sensibles à la casse ( myVaret myvar sont des variables différentes)
• Les noms ne peuvent pas contenir d'espaces ou de caractères spéciaux tels que !, #, %, etc.
• Les mots réservés (tels que int) ne peuvent pas être utilisés comme noms
Vous pouvez également affecter la même valeur à plusieurs variables du même type :
Exemple concret
Souvent, dans nos exemples, nous avons tendance à simplifier les noms de variables pour qu'ils
correspondent à leur type de données (myInt ou myNum pour les int types, myChar pour les char
types, etc.). Ceci est fait pour éviter toute confusion.
Cependant, si vous voulez un exemple concret sur la façon dont les variables peuvent être utilisées,
jetez un œil à ce qui suit, où nous avons créé un programme qui stocke différentes données d'un
étudiant :
Exemple
// Student data
int studentID = 15;
int studentAge = 23;
float studentFee = 75.25;
char studentGrade = 'B';

// Print variables
printf("Student id: %d\n", studentID);
printf("Student age: %d\n", studentAge);
printf("Student fee: %f\n", studentFee);
printf("Student grade: %c", studentGrade);

Types de données
Une variable en C doit être un type de données spécifié, et vous devez utiliser un spécificateur de
format à l'intérieur de la printf()fonction pour l'afficher :
Exemple
// Create variables
int myNum = 5; // Integer (whole number)
float myFloatNum = 5.99; // Floating point number
char myLetter = 'D'; // Character

// Print variables
printf("%d\n", myNum);
printf("%f\n", myFloatNum);
printf("%c\n", myLetter);
Types de données de base
Le type de données spécifie la taille et le type d'informations que la variable stockera.
Nous allons nous concentrer sur les plus basiques :
Data Type Size Description
int 2 or 4 bytes Stores whole numbers, without decimals
Stores fractional numbers, containing one or more decimals. Sufficient
float 4 bytes
for storing 6-7 decimal digits
Stores fractional numbers, containing one or more decimals. Sufficient
double 8 bytes
for storing 15 decimal digits
char 1 byte Stores a single character/letter/number, or ASCII values

Spécificateurs de format de base

Il existe différents spécificateurs de format pour chaque type de données. En voici quelques uns :
Format Specifier Data Type
%d or %i int
%f float
%lf double
%c char
%s strings
Définir la précision décimale
Vous avez probablement déjà remarqué que si vous imprimez un nombre à virgule flottante, la
sortie affichera 6 chiffres après la virgule :
Exemple
float myFloatNum = 3.5;
double myDoubleNum = 19.99;

printf("%f\n", myFloatNum); // Outputs 3.500000

printf("%lf", myDoubleNum); // Outputs 19.990000
Si vous souhaitez supprimer les zéros supplémentaires (définir la précision décimale), vous pouvez
utiliser un point (.) suivi d'un nombre qui spécifie le nombre de chiffres à afficher après la virgule
:
Exemple
float myFloatNum = 3.5;

printf("%f\n", myFloatNum); // Default will show 6 digits after the decimal point
printf("%.1f\n", myFloatNum); // Only show 1 digit
printf("%.2f\n", myFloatNum); // Only show 2 digits
printf("%.4f", myFloatNu m); // Only show 4 digits

Conversion de type
Parfois, vous devez convertir la valeur d'un type de données en un autre type. C'est ce qu'on appelle
la conversion de type.
Par exemple, si vous essayez de diviser deux nombres entiers 5 par 2, vous vous attendez à ce que
le résultat soit 2.5. Mais comme nous travaillons avec des entiers (et non des valeurs à virgule
flottante), l'exemple suivant affichera simplement 2 :
Exemple
int x = 5;
int y = 2;
int sum = 5 / 2;
printf("%d", sum); // Outputs 2
Pour obtenir le bon résultat, vous devez savoir comment fonctionne la conversion de type.
Il existe deux types de conversion en C :
• Conversion implicite (automatiquement)
• Conversion explicite (manuellement)

Conversion implicite
La conversion implicite est effectuée automatiquement par le compilateur lorsque vous affectez
une valeur d'un type à un autre.
Par exemple, si vous affectez une int valeur à un floatt ype :
Exemple
// Automatic conversion: int to float
float myFloat = 9;
printf("%f", myFloat); // 9.000000
Comme vous pouvez le voir, le compilateur convertit automatiquement la valeur int 9 en une
valeur flottante de 9.000000.
Cela peut être risqué, car vous pourriez perdre le contrôle de valeurs spécifiques dans certaines
situations.
Surtout si c'était l'inverse - l'exemple suivant convertit automatiquement la valeur float 9.99 en
une valeur int de 9:
Exemple
// Automatic conversion: float to int
int myInt = 9.99;

printf("%d", myInt); // 9
Que s'est-il passé .99 ? Nous voudrions peut-être ces données dans notre programme ! Donc sois
prudent. Il est important que vous sachiez comment le compilateur fonctionne dans ces situations,
pour éviter des résultats inattendus.
Comme autre exemple, si vous divisez deux nombres entiers : 5 par 2, vous savez que la somme
est 2.5. Et comme vous le savez depuis le début de cette page, si vous stockez la somme sous
forme d'entier, le résultat n'affichera que le nombre 2. Par conséquent, il serait préférable de stocker
la somme sous la forme a float ou a double, n'est-ce pas ?
Exemple
float sum = 5 / 2;

printf("%f", sum); // 2.000000

Pourquoi le résultat 2.00000 et pas 2.5? Eh bien, c'est parce que 5 et 2 sont toujours des entiers
dans la division. Dans ce cas, vous devez convertir manuellement les valeurs entières en valeurs à
virgule flottante. (Voir ci-dessous).
Conversion explicite
La conversion explicite est effectuée manuellement en plaçant le type entre parenthèses () devant
la valeur.
En considérant notre problème de l'exemple ci-dessus, nous pouvons maintenant obtenir le bon
résultat :
Exemple
// Manual conversion: int to float
float sum = (float) 5 / 2;

printf("%f", sum); // 2.500000

Vous pouvez également placer le type devant une variable :
Exemple
int num1 = 5;
int num2 = 2;
float sum = (float) num1 / num2;

printf("%f", sum); // 2.500000

vous pouvez rendre la sortie encore plus propre en supprimant les zéros supplémentaires (si vous
le souhaitez) :
Exemple
int num1 = 5;
int num2 = 2;
float sum = (float) num1 / num2;

printf("%.1f", sum); // 2.5

Constantes
Si vous ne voulez pas que les autres (ou vous-même) modifient les valeurs des variables existantes,
vous pouvez utiliser le mot-cle const.
Cela déclarera la variable comme "constante", ce qui signifie non modifiable et en lecture seule :
Exemple
const int myNum = 15; // myNum will always be 15
myNum = 10; // error: assignment of read-only variable 'myNum'
Vous devez toujours déclarer la variable comme constante lorsque vous avez des valeurs peu
susceptibles de changer :
Exemple
const int minutesPerHour = 60;
const float PI = 3.14;

Remarques sur les constantes

Lorsque vous déclarez une variable constante, celle-ci doit être affectée d'une valeur :
Exemple
Comme ça:
const int minutesPerHour = 60;
Ceci cependant ne fonctionnera pas :
const int minutesPerHour;
minutesPerHour = 60; // error

Bonnes pratiques
Une autre chose à propos des variables constantes est qu'il est considéré comme une bonne pratique
de les déclarer en majuscules. Ce n'est pas obligatoire, mais utile pour la lisibilité du code et
commun aux programmeurs C :
Exemple
const int BIRTHYEAR = 1980;
Les opérateurs
Les opérateurs sont utilisés pour effectuer des opérations sur des variables et des valeurs.
Dans l'exemple ci-dessous, nous utilisons l' + opérateur pour additionner deux valeurs :
Exemple
int myNum = 100 + 50;
Bien que l' +opérateur soit souvent utilisé pour additionner deux valeurs, comme dans l'exemple
ci-dessus, il peut également être utilisé pour additionner une variable et une valeur, ou une variable
et une autre variable :
Exemple
int sum1 = 100 + 50; // 150 (100 + 50)
int sum2 = sum1 + 250; // 400 (150 + 250)
int sum3 = sum2 + sum2; // 800 (400 + 400)
C divise les opérateurs dans les groupes suivants :
• Opérateurs arithmétiques
• Opérateurs d'affectation
• Opérateurs de comparaison
• Opérateurs logiques
• Opérateurs au niveau du bit

Opérateurs arithmétiques
Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques courantes.
Operator Name Description Example
+ Addition Adds together two values x+y
- Subtraction Subtracts one value from another x-y
* Multiplication Multiplies two values x*y
/ Division Divides one value by another x/y
% Modulus Returns the division remainder x%y
++ Increment Increases the value of a variable by 1 ++x
-- Decrement Decreases the value of a variable by 1 --x

Opérateurs d'affectation
Les opérateurs d'affectation sont utilisés pour affecter des valeurs aux variables.
Dans l'exemple ci-dessous, nous utilisons l’opérateur d’affectation (=) pour affecter la valeur 10 à
une variable appelée x :
Exemple
int x = 10;
L’opérateur d'affectation d'addition (+=) ajoute une valeur à une variable :
Exemple
int x = 10;
x += 5;
Une liste de tous les opérateurs d'affectation :
Operator Example Same As
= x=5 x=5
+= x += 3 x=x+3
-= x -= 3 x=x-3
*= x *= 3 x=x*3
/= x /= 3 x=x/3
%= x %= 3 x=x%3
&= x &= 3 x=x&3
|= x |= 3 x=x|3
^= x ^= 3 x=x^3
 >>= x >>= 3 x = x >> 3
<<= x <<= 3 x = x << 3

Opérateurs de comparaison
Les opérateurs de comparaison sont utilisés pour comparer deux valeurs (ou variables). Ceci est
important dans la programmation, car cela nous aide à trouver des réponses et à prendre des
décisions.
La valeur de retour d'une comparaison est soit 1 ou 0, ce qui signifie vrai (1) ou faux (0). Ces
valeurs sont appelées valeurs booléennes
Dans l'exemple suivant, nous utilisons l’opérateur supérieur à (>) pour savoir si 5 est supérieur à
3:
Exemple
int x = 5;
int y = 3;
printf("%d", x > y); // returns 1 (true) because 5 is greater than 3
Une liste de tous les opérateurs de comparaison :
Operator Name Example
== Equal to x == y
!= Not equal x! = y
Greater
> x>y
than
< Less than x<y
Greater
>= than or x >= y
equal to
Less than
<= x <= y
or equal to

Opérateurs logiques
Vous pouvez également tester les valeurs vraies ou fausses avec des opérateurs logiques.
Les opérateurs logiques sont utilisés pour déterminer la logique entre les variables ou les valeurs :
Operator Name Description Example
&& Logical and Returns true if both statements are true x < 5 && x < 10
|| Logical or Returns true if one of the statements is true x < 5 || x < 4
Reverse the result, returns false if the result
! Logical not !(x < 5 && x < 10)
is true

Taille de l'opérateur
La taille mémoire (en octets) d'un type de données ou d'une variable peut être trouvée avec sizeof
opérateur :
Exemple
int myInt;
float myFloat;
double myDouble;
char myChar;

printf("%lu\n", sizeof(myInt));
printf("%lu\n", sizeof(myFloat));
printf("%lu\n", sizeof(myDouble));
printf("%lu\n", sizeof(myChar));

Notez que nous utilisons le %lu spécificateur de format pour imprimer le résultat, au lieu de %d.
C'est parce que le compilateur s'attend à ce que l'opérateur sizeof renvoie un long unsigned int(
%lu), au lieu de int( %d). Sur certains ordinateurs, cela peut fonctionner avec %d, mais il est plus
sûr d'utiliser %lu.

Booléens
Très souvent, en programmation, vous aurez besoin d'un type de données qui ne peut avoir qu'une
des deux valeurs, comme :
• OUI NON
• ALLUMÉ ÉTEINT
• VRAI FAUX
Pour cela, C a un bool type de données, appelé booleans.
Les booléens représentent des valeurs qui sont soit true ou false.

Variables booléennes
En C, le bool type n'est pas un type de données intégré, comme int ou char.
Il a été introduit dans C99 et vous devez importer le fichier d'en-tête suivant pour l'utiliser :
#include <stdbool.h>
Une variable booléenne est déclarée avec le bool mot clé et ne peut prendre que les valeurs true
ou false :
bool isProgrammingFun = true;
bool isFishTasty = false;
Avant d'essayer d'imprimer les variables booléennes, vous devez savoir que les valeurs booléennes
sont renvoyées sous forme d'entiers :
• 1 (ou tout autre nombre différent de 0) représente true
• 0 représente false
Par conséquent, vous devez utiliser le %d spécificateur de format pour imprimer une valeur
booléenne :
Exemple
// Create boolean variables
bool isProgrammingFun = true;
bool isFishTasty = false;

// Return boolean values

printf("%d", isProgrammingFun); // Returns 1 (true)
printf("%d", isFishTasty); // Returns 0 (false)
Cependant, il est plus courant de renvoyer une valeur booléenne en comparant des valeurs et des
variables.

Comparer des valeurs et des variables

La comparaison de valeurs est utile en programmation, car elle nous aide à trouver des réponses et
à prendre des décisions.
Par exemple, vous pouvez utiliser un opérateur de comparaison , tel que l’opérateur supérieur à
(>), pour comparer deux valeurs :
Exemple
printf("%d", 10 > 9); // Returns 1 (true) because 10 is greater than 9
Dans l'exemple ci-dessus, vous pouvez voir que la valeur de retour est une valeur booléenne.
Vous pouvez également comparer deux variables :
Exemple
int x = 10;
int y = 9;
printf("%d", x > y);
Dans l'exemple ci-dessous, nous utilisons l’opérateur égal à (==) pour comparer différentes
valeurs :
Exemple
printf("%d", 10 == 10); // Returns 1 (true), because 10 is equal to 10
printf("%d", 10 == 15); // Returns 0 (false), because 10 is not equal to 15
printf("%d", 5 == 55); // Returns 0 (false) because 5 is not equal to 55
Vous n'êtes pas limité à comparer uniquement les chiffres. Vous pouvez également comparer des
variables booléennes, ou même des structures spéciales, comme des tableaux (dont vous en
apprendrez plus dans un chapitre ultérieur) :
Exemple
bool isHamburgerTasty = true;
bool isPizzaTasty = true;

// Find out if both hamburger and pizza is tasty

printf("%d", isHamburgerTasty == isPizzaTasty);
N'oubliez pas d'inclure le <stdbool.h>fichier d'en-tête lorsque vous travaillez avec des variables
bool.

Exemple réel
Pensons à un "exemple réel" où nous devons savoir si une personne est assez âgée pour voter.
Dans l'exemple ci-dessous, nous utilisons l’opérateur >= de comparaison pour savoir si l'âge (25)
est supérieur OU égal à la limite d'âge pour voter, qui est fixée à 18 :
Exemple
int myAge = 25;
int votingAge = 18;

printf("%d", myAge >= votingAge); // Returns 1 (true), meaning 25 year olds are allowed to vote!
Une approche encore meilleure (puisque nous sommes sur une lancée maintenant), serait
d'envelopper le code ci-dessus dans une if...else déclaration, afin que nous puissions effectuer
différentes actions en fonction du résultat :
Exemple
Sortie "Assez vieux pour voter !" si myAge est supérieur ou égal à 18. Sinon, affichez "Pas assez
vieux pour voter." :
int myAge = 25;
int votingAge = 18;

if (myAge >= votingAge) {

printf("Old enough to vote!");
} else {
printf("Not old enough to vote.");
}
Les booléens sont la base de toutes les comparaisons et conditions.

Conditions et instructions If
Vous avez déjà appris que C supporte les conditions logiques usuelles des mathématiques :
• Inférieur à: a < b
• Inférieur ou égal à: a <= b
• Supérieur à: a > b
• Supérieur ou égal à: a >= b
• Égal à a == b
• Différent de: a!= b
Vous pouvez utiliser ces conditions pour effectuer différentes actions pour différentes décisions.
C contient les instructions conditionnelles suivantes :
• Utilisez if pour spécifier un bloc de code à exécuter, si une condition spécifiée est true
• Utilisez else de spécifier un bloc de code à exécuter, si la même condition est false
• Utilisez else ifpour spécifier une nouvelle condition à tester, si la première condition est false
• Utilisez switch pour spécifier de nombreux blocs de code alternatifs à exécuter

L'instruction if
Utilisez l'instruction if pour spécifier un bloc de code à exécuter si une condition est true.
Syntaxe
if (condition) {
// block of code to be executed if the condition is true
}
Notez que if c'est en lettres minuscules. Les lettres majuscules (If ou IF) généreront une erreur.
Dans l'exemple ci-dessous, nous testons deux valeurs pour savoir si 20 est supérieur à 18. Si la
condition est true, imprimez du texte :
Exemple
if (20 > 18) {
printf("20 is greater than 18");
}
On peut aussi tester des variables :
Exemple
int x = 20;
int y = 18;
if (x > y) {
printf("x is greater than y");
}
Exemple expliqué
Dans l'exemple ci-dessus, nous utilisons deux variables, x et y , pour tester si x est supérieur à y (à
l'aide de l' opérateur >). Comme x est 20, et y est 18, et nous savons que 20 est supérieur à 18, nous
affichons à l'écran que "x est supérieur à y".

La déclaration d'autre
Utilisez l’instruction else pour spécifier un bloc de code à exécuter si la condition est false.
Syntaxe
if (condition) {
// block of code to be executed if the condition is true
} else {
// block of code to be executed if the condition is false
}
Exemple
int time = 20;
if (time < 18) {
printf("Good day.");
} else {
printf("Good evening.");
}
// Outputs "Good evening."
Exemple expliqué
Dans l'exemple ci-dessus, le temps (20) est supérieur à 18, donc la condition est false. Pour cette
raison, nous passons à la else condition et imprimons à l'écran "Bonsoir". Si l'heure était inférieure
à 18, le programme imprimerait "Bonne journée".

L'instruction else if
Utilisez l’instruction else if pour spécifier une nouvelle condition si la première condition est
false.
Syntaxe
if (condition1) {
// block of code to be executed if condition1 is true
} else if (condition2) {
// block of code to be executed if the condition1 is false and condition2 is true
} else {
// block of code to be executed if the condition1 is false and condition2 is false
}
Exemple
int time = 22;
if (time < 10) {
printf("Good morning.");
} else if (time < 20) {
printf("Good day.");
} else {
printf("Good evening.");
}
// Outputs "Good evening."
Exemple expliqué
Dans l'exemple ci-dessus, le temps (22) est supérieur à 10, donc la première condition est false.
La condition suivante, dans la déclaration else if, est également false, nous passons donc à la
else condition puisque condition1 et condition2 sont les deux false- et affichons à l'écran
"Bonsoir".
Cependant, si l'heure était 14h, notre programme afficherait "Bonne journée".

Un autre exemple
Cet exemple montre comment vous pouvez utiliser if..else pour savoir si un nombre est positif
ou négatif :
Exemple
int myNum = 10; // Is this a positive or negative number?

if (myNum > 0) {
printf("The value is a positive number.");
} else if (myNum < 0) {
printf("The value is a negative number.");
} else {
printf("The value is 0.");
}

Abréviation If...Else (opérateur ternaire)

Il existe également un raccourci if else, connu sous le nom d’opérateur ternaire car il se compose
de trois opérandes. Il peut être utilisé pour remplacer plusieurs lignes de code par une seule ligne.
Il est souvent utilisé pour remplacer les instructions simples if else :
Syntaxe
variable = (condition)? expressionTrue: expressionFalse;
Au lieu d'écrire :
Exemple
int time = 20;
if (time < 18) {
printf("Good day.");
} else {
printf("Good evening.");
}
Vous pouvez simplement écrire :
Exemple
int time = 20;
(time < 18) ? printf("Good day.") : printf("Good evening.");
C'est à vous de décider si vous souhaitez utiliser l'instruction traditionnelle if...else ou l'opérateur
ternaire.
Instruction de commutation
Au lieu d'écrire de nombreuses if..else déclarations, vous pouvez utiliser la switch
déclaration.
L’instruction switch sélectionne l'un des nombreux blocs de code à exécuter :
Syntaxe
switch(expression) {
case x:
// code block
break;
case y:
// code block
break;
default:
// code block
}
Voilà comment cela fonctionne :
• L' expression switch est évaluée une fois
• La valeur de l'expression est comparée aux valeurs de chaque case
• S'il y a correspondance, le bloc de code associé est exécuté
• L' instruction break sort du bloc de commutation et arrête l'exécution
• L'instruction default est facultative et spécifie du code à exécuter s'il n'y a pas de
correspondance de casse
L'exemple ci-dessous utilise le numéro du jour de la semaine pour calculer le nom du jour de la
semaine :
Exemple
int day = 4;

switch (day) {
case 1:
printf("Monday");
break;
case 2:
printf("Tuesday");
break;
case 3:
printf("Wednesday");
break;
case 4:
printf("Thursday");
break;
case 5:
printf("Friday");
break;
case 6:
printf("Saturday");
 break;
case 7:
printf("Sunday");
break;
}

// Outputs "Thursday" (day 4)

La pause
Lorsque C atteint un mot- break clé, il sort du bloc de commutation.
Cela arrêtera l'exécution de plus de code et de tests de cas à l'intérieur du bloc.
Lorsqu'une correspondance est trouvée et que le travail est terminé, il est temps de faire une pause.
Il n'y a pas besoin de plus de tests.
Un break peut faire gagner beaucoup de temps d'exécution car il "ignore" l'exécution de tout le
reste du code dans le bloc switch.

Le mot clé par défaut

Le mot-spécifie default clé du code à exécuter s'il n'y a pas de correspondance de casse :
Exemple
int day = 4;

switch (day) {
case 6:
printf("Today is Saturday");
break;
case 7:
printf("Today is Sunday");
break;
default:
printf("Looking forward to the Weekend");
}

// Outputs "Looking forward to the Weekend"

Remarque : Le mot clé par défaut doit être utilisé comme dernière instruction dans le commutateur
et ne nécessite pas de pause.

Boucles
Les boucles peuvent exécuter un bloc de code tant qu'une condition spécifiée est atteinte.
Les boucles sont pratiques car elles permettent de gagner du temps, de réduire les erreurs et de
rendre le code plus lisible.

Pendant que la boucle

La boucle while parcourt un bloc de code tant qu'une condition spécifiée est true :
Syntaxe
while (condition) {
// code block to be executed
}
Dans l'exemple ci-dessous, le code de la boucle s'exécutera encore et encore tant qu'une variable
(i) est inférieure à 5 :
Exemple
int i = 0;

while (i < 5) {
printf("%d\n", i);
i++;
}
Remarque : N'oubliez pas d'augmenter la variable utilisée dans la condition (i++), sinon la boucle
ne se terminera jamais !

La boucle faire/pendant que

La do/while boucle est une variante de la while boucle. Cette boucle exécutera le bloc de code
une fois, avant de vérifier si la condition est vraie, puis elle répétera la boucle tant que la condition
est vraie.
Syntaxe
do {
// code block to be executed
}
while (condition);
L'exemple ci-dessous utilise une do/while boucle. La boucle sera toujours exécutée au moins une
fois, même si la condition est fausse, car le bloc de code est exécuté avant que la condition ne soit
testée :
Exemple
int i = 0;

do {
printf("%d\n", i);
i++;
}
while (i < 5);
N'oubliez pas d'augmenter la variable utilisée dans la condition, sinon la boucle ne se terminera
jamais !

Pour la boucle
Lorsque vous savez exactement combien de fois vous voulez parcourir un bloc de code, utilisez
la boucle for au lieu d'une boucle while :
Syntaxe
for (statement 1; statement 2; statement 3) {
// code block to be executed
}
L’instruction 1 est exécutée (une fois) avant l'exécution du bloc de code.
L’instruction 2 définit la condition d'exécution du bloc de code.
L’instruction 3 est exécutée (à chaque fois) après l'exécution du bloc de code.
L'exemple ci-dessous imprimera les chiffres de 0 à 4 :
Exemple
int i;

for (i = 0; i < 5; i++) {

printf("%d\n", i);
}
Exemple expliqué
L'instruction 1 définit une variable avant le début de la boucle (int i = 0).
L'instruction 2 définit la condition d'exécution de la boucle (i doit être inférieur à 5). Si la condition
est vraie, la boucle recommencera, si elle est fausse, la boucle se terminera.
L'instruction 3 augmente une valeur (i++) chaque fois que le bloc de code dans la boucle a été
exécuté.

Un autre exemple
Cet exemple n'imprimera que les valeurs paires entre 0 et 10 :
Exemple
for (i = 0; i <= 10; i = i + 2) {
printf("%d\n", i);
}

Boucles imbriquées
Il est également possible de placer une boucle à l'intérieur d'une autre boucle. C'est ce qu'on appelle
une boucle imbriquée.
La "boucle interne" sera exécutée une fois pour chaque itération de la "boucle externe” :
Exemple
int i, j;

// Outer loop
for (i = 1; i <= 2; ++i) {
printf("Outer: %d\n", i); // Executes 2 times

// Inner loop
for (j = 1; j <= 3; ++j) {
printf(" Inner: %d\n", j); // Executes 6 times (2 * 3)
}
}

Pause
L’instruction break utilisée dans un chapitre précédent. Il a été utilisé pour "sauter" d'une switch
déclaration.
L’instruction break peut également être utilisée pour sortir d'une boucle.
Cet exemple sort de la boucle for lorsque i est égal à 4 :
Exemple
int i;

for (i = 0; i < 10; i++) {

if (i == 4) {
break;
}
printf("%d\n", i);
}

Continuer
L’instruction continue interrompt une itération (dans la boucle), si une condition spécifiée se
produit, et continue avec l'itération suivante dans la boucle.
Cet exemple ignore la valeur de 4 :
Exemple
int i;

for (i = 0; i < 10; i++) {

if (i == 4) {
continue;
}
printf("%d\n", i);
}
Interrompre et continuer dans la boucle While
Vous pouvez également utiliser break et continue dans les boucles while :
Exemple de pause
int i = 0;

while (i < 10) {

if (i == 4) {
break;
}
printf("%d\n", i);
i++;
}
Continuer Exemple
int i = 0;

while (i < 10) {

if (i == 4) {
i++;
continue;
}
printf("%d\n", i);
i++;
}
Tableaux
Les tableaux sont utilisés pour stocker plusieurs valeurs dans une seule variable, au lieu de déclarer
des variables distinctes pour chaque valeur.
Pour créer un tableau, définissez le type de données (comme int) et spécifiez le nom du tableau
suivi de crochets [].
Pour y insérer des valeurs, utilisez une liste séparée par des virgules, à l'intérieur d'accolades :
int myNumbers [] = {25, 50, 75, 100};
Nous avons maintenant créé une variable qui contient un tableau de quatre entiers.

Accéder aux éléments d'un tableau

Pour accéder à un élément du tableau, reportez-vous à son numéro d’index.
Les index des tableaux commencent par 0 : [0] est le premier élément. [1] est le deuxième élément,
etc.
Cette instruction accède à la valeur du premier élément [0] dans myNumbers:
Exemple
int myNumbers [] = {25, 50, 75, 100};
printf("%d", myNumbers[0]);

// Outputs 25

Modifier un élément de tableau

Pour modifier la valeur d'un élément spécifique, reportez-vous au numéro d'index :
Exemple
myNumbers[0] = 33;
Exemple
int myNumbers[] = {25, 50, 75, 100};
myNumbers[0] = 33;

printf("%d", myNumbers[0]);

// Now outputs 33 instead of 25

Boucle dans un tableau

Vous pouvez parcourir les éléments du tableau avec la boucle for.
L'exemple suivant renvoie tous les éléments du myNumbers tableau :
Exemple
int myNumbers[] = {25, 50, 75, 100};
int i;

for (i = 0; i < 4; i++) {

printf("%d\n", myNumbers[i]);
}
Définir la taille du tableau
Une autre façon courante de créer des tableaux consiste à spécifier la taille du tableau et à ajouter
des éléments ultérieurement :
Exemple
// Declare an array of four integers:
int myNumbers[4];

// Add elements
myNumbers[0] = 25;
myNumbers[1] = 50;
myNumbers[2] = 75;
myNumbers[3] = 100;
En utilisant cette méthode, vous devez connaître la taille du tableau, afin que le programme
stocke suffisamment de mémoire.
Vous ne pouvez pas modifier la taille du tableau après sa création.

Tableaux multidimensionnels
Vous avez découvert les tableaux , également appelés tableaux à une dimension. C'est quelque
chose que vous utiliserez beaucoup lors de la programmation en C. Cependant, si vous voulez
stocker des données sous forme de tableau, comme un tableau avec des lignes et des colonnes, vous
devez vous familiariser avec les tableaux multidimensionnels.
Un tableau multidimensionnel est essentiellement un tableau de tableaux.
Les tableaux peuvent avoir n'importe quel nombre de dimensions. Nous présenterons les plus
courantes ; tableaux à deux dimensions (2D).

Tableaux bidimensionnels
Un tableau 2D est également connu sous le nom de matrice (un tableau de lignes et de colonnes).
Pour créer un tableau 2D d'entiers, regardez l'exemple suivant :
int matrix[2][3] = { {1, 4, 2}, {3, 6, 8} };
La première dimension représente le nombre de lignes [2], tandis que la deuxième dimension
représente le nombre de colonnes [3]. Les valeurs sont placées dans l'ordre des lignes et peuvent
être visualisées comme suit :

Accéder aux éléments d'un tableau 2D

Pour accéder à un élément d'un tableau à deux dimensions, vous devez spécifier le numéro d'index
de la ligne et de la colonne.
Cette instruction accède à la valeur de l'élément dans la première ligne (0) et la troisième colonne
(2) du tableau matriciel.
Exemple
int matrix[2][3] = { {1, 4, 2}, {3, 6, 8} };

printf("%d", matrix[0][2]); // Outputs 2

N'oubliez pas que : Les index de tableau commencent par 0 : [0] est le premier élément. [1] est le
deuxième élément, etc.
Modifier les éléments d'un tableau 2D
Pour changer la valeur d'un élément, se référer au numéro d'index de l'élément dans chacune des
dimensions :
L'exemple suivant changera la valeur de l'élément dans la première ligne (0) et la première
colonne (0) :
Exemple
int matrix[2][3] = { {1, 4, 2}, {3, 6, 8} };
matrix[0][0] = 9;

printf("%d", matrix[0][0]); // Now outputs 9 instead of 1

Boucle à travers un tableau 2D

Pour parcourir un tableau multidimensionnel, vous avez besoin d'une boucle pour chacune des
dimensions du tableau.
L'exemple suivant affiche tous les éléments du tableau matriciel :
Exemple
int matrix[2][3] = { {1, 4, 2}, {3, 6, 8} };

int i, j;
for (i = 0; i < 2; i++) {
for (j = 0; j < 3; j++) {
printf("%d\n", matrix[i][j]);
}
}

Chaine de caractères
Les chaînes sont utilisées pour stocker du texte/des caractères.
Par exemple, "Hello World" est une chaîne de caractères.
Contrairement à de nombreux autres langages de programmation, C n'a pas de type String pour
créer facilement des variables de chaîne. Au lieu de cela, vous devez utiliser le type char et créer
un tableau de caractères pour créer une chaîne en C :
char greetings [] = "Hello World!";
Notez que vous devez utiliser des guillemets doubles ("").
Pour générer la chaîne, vous pouvez utiliser la printf()fonction avec le spécificateur de format
%s pour indiquer à C que nous travaillons maintenant avec des chaînes :
Exemple
char greetings [] = "Hello World!";
printf("%s", greetings);
Chaînes d'accès
Étant donné que les chaînes sont en fait des tableaux en C, vous pouvez accéder à une chaîne en
vous référant à son numéro d'index entre crochets [].
Cet exemple imprime le premier caractère (0) dans les messages d’accueil :
Exemple
char greetings [] = "Hello World!";
printf("%c", greetings[0]);
Notez que nous devons utiliser le %c spécificateur de format pour imprimer un seul caractère.

Modifier les chaînes

Pour modifier la valeur d'un caractère spécifique dans une chaîne, reportez-vous au numéro d'index
et utilisez des guillemets simples :
Exemple
char greetings [] = "Hello World!";
greetings [0] = 'J';
printf("%s", greetings);
// Outputs Jello World! instead of Hello World!

Boucle sur une chaîne

Vous pouvez également parcourir les caractères d'une chaîne à l'aide d'une boucle for :
Exemple
char carName[] = "Volvo";
int i;

for (i = 0; i < 5; ++i) {

printf("%c\n", carName[i]);
}

Une autre façon de créer des chaînes

Dans les exemples ci-dessus, nous avons utilisé un "littéral de chaîne" pour créer une variable de
chaîne. C'est le moyen le plus simple de créer une chaîne en C.
Vous devez également noter que vous pouvez créer une chaîne avec un ensemble de caractères.
Cet exemple produira le même résultat que l'exemple au début de cette page :
Exemple
char greetings [] = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!', '\0'};
printf("%s", greetings);
Pourquoi incluons-nous le \0 personnage à la fin ? Ceci est connu sous le nom de "caractère de
fin nul" et doit être inclus lors de la création de chaînes à l'aide de cette méthode. Il indique à C
que c'est la fin de la chaîne.

Différences
La différence entre les deux façons de créer des chaînes est que la première méthode est plus facile
à écrire et vous n'avez pas besoin d'inclure le \0 caractère, car C le fera pour vous.
Vous devez noter que la taille des deux tableaux est la même : ils ont tous les deux 13 caractères
(l'espace compte également comme un caractère d'ailleurs), y compris le \0 caractère :
Exemple
char greetings [] = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!', '\0'};
char greetings2[] = "Hello World!";

printf("%lu\n", sizeof(greetings)); // Outputs 13

printf("%lu\n", sizeof(greetings2)); // Outputs 13
C Caractères spéciaux

Chaînes - Caractères spéciaux

Étant donné que les chaînes doivent être écrites entre guillemets, C comprendra mal cette chaîne
et générera une erreur :
char txt[] = "We are the so-called "Vikings" from the north.";
La solution pour éviter ce problème est d'utiliser le caractère d'échappement antislash.
Le caractère d'échappement barre oblique inverse (\) transforme les caractères spéciaux en
caractères de chaîne :
Escape character Result Description
\' ' Single quote
\" " Double quote
\\ \ Backslash
La séquence \" insère un guillemet double dans une chaîne :
Exemple
char txt[] = "We are the so-called \"Vikings\" from the north.";
La séquence \' insère un guillemet simple dans une chaîne :
Exemple
char txt[] = "It\'s alright.";
La séquence \\ insère une seule barre oblique inverse dans une chaîne :
Exemple
char txt[] = "The character \\ is called backslash.";
Les autres caractères d'échappement populaires en C sont :
Escape
Result
Character
\n New Line
\t Tab
\0 Null

Fonctions de chaîne
C a également de nombreuses fonctions de chaîne utiles, qui peuvent être utilisées pour effectuer
certaines opérations sur les chaînes.
Pour les utiliser, vous devez inclure le <string.h>fichier d'en-tête dans votre programme :
#include <string.h>
Longueur de chaine
Par exemple, pour obtenir la longueur d'une chaîne, vous pouvez utiliser la strlen()fonction :
Exemple
char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
printf("%d", strlen(alphabet));
Dans le chapitre Chaînes , nous avions l'habitude sizeof d'obtenir la taille d'une chaîne/d'un
tableau. Notez que sizeof et strlen se comporte différemment, car sizeof inclut également le
\0 caractère lors du comptage :
Exemple
char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
printf("%d", strlen(alphabet)); // 26
printf("%d", sizeof(alphabet)); // 27
Il est également important que vous sachiez que sizeof renverra toujours la taille de la mémoire
(en octets), et non la longueur réelle de la chaîne :
Exemple
char alphabet[50] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
printf("%d", strlen(alphabet)); // 26
printf("%d", sizeof(alphabet)); // 50

Concaténer des chaînes

Pour concaténer (combiner) deux chaînes, vous pouvez utiliser la strcat()fonction :
Exemple
char str1[20] = "Hello ";
char str2[] = "World!";

// Concatenate str2 to str1 (result is stored in str1)

strcat(str1, str2);

// Print str1
printf("%s", str1);
Notez que la taille de str1 doit être suffisamment grande pour stocker le résultat des deux chaînes
combinées (20 dans notre exemple).

Copier les chaînes

Pour copier la valeur d'une chaîne dans une autre, vous pouvez utiliser la strcpy()fonction :
Exemple
char str1[20] = "Hello World!";
char str2[20];

// Copy str1 to str2

strcpy(str2, str1);

// Print str2
printf("%s", str2);
Notez que la taille de str2 doit être suffisamment grande pour stocker la chaîne copiée (20 dans
notre exemple).

Comparer les chaînes

Pour comparer deux chaînes, vous pouvez utiliser la strcmp() fonction.
Elle renvoie 0si les deux chaînes sont égales, sinon une valeur différente de 0 :
Exemple
char str1[] = "Hello";
char str2[] = "Hello";
char str3[] = "Hi";

// Compare str1 and str2, and print the result

printf("%d\n", strcmp(str1, str2)); // Returns 0 (the strings are equal)

// Compare str1 and str3, and print the result

printf("%d\n", strcmp(str1, str3)); // Returns -4 (the strings are not equal)

Entrée utilisateur
Vous avez déjà appris que printf()est utilisé pour sortir des valeurs en C.
Pour obtenir l'entrée de l’utilisateur, vous pouvez utiliser la scanf()fonction :
Exemple
Sortie d'un nombre saisi par l'utilisateur :
// Create an integer variable that will store the number we get from the user
int myNum;

// Ask the user to type a number

printf("Type a number: \n");

// Get and save the number the user types

scanf("%d", &myNum);

// Output the number the user typed

printf("Your number is: %d", myNum);
La scanf()fonction prend deux arguments : le spécificateur de format de la variable ( %ddans
l'exemple ci-dessus) et l'opérateur de référence ( &myNum), qui stocke l'adresse mémoire de la
variable.
Conseil : vous en apprendrez plus sur les adresses mémoire et les fonctions dans le chapitre suivant.

Entrées multiples
La scanf()fonction autorise également plusieurs entrées (un entier et un caractère dans l'exemple
suivant) :
Exemple
// Create an int and a char variable
int myNum;
char myChar;
// Ask the user to type a number AND a character
printf("Type a number AND a character and press enter: \n");

// Get and save the number AND character the user types
scanf("%d %c", &myNum, &myChar);

// Print the number

printf("Your number is: %d\n", myNum);

// Print the character

printf("Your character is: %c\n", myChar);

Prendre une entrée de chaîne

Vous pouvez également obtenir une chaîne saisie par l'utilisateur :
Exemple
Sortez le nom d'un utilisateur :
// Create a string
char firstName[30];

// Ask the user to input some text

printf("Enter your first name: \n");

// Get and save the text

scanf("%s", firstName);

// Output the text

printf("Hello %s", firstName);
Notez que vous devez spécifier la taille de la chaîne/du tableau (nous avons utilisé un nombre très
élevé, 30, mais au moins nous sommes certains qu'il stockera suffisamment de caractères pour le
prénom), et vous n'avez pas à spécifier l'opérateur de référence (&) lorsque vous travaillez avec des
chaînes dans scanf().
Cependant, la scanf()fonction a quelques limitations : elle considère l'espace (espace blanc,
tabulation, etc.) comme un caractère de fin, ce qui signifie qu'elle ne peut afficher qu'un seul mot
(même si vous tapez beaucoup de mots). Par exemple :
Exemple
char fullName[30];

printf("Type your full name: \n");

scanf("%s", &fullName);

printf("Hello %s", fullName);

// Type your full name: John Doe

// Hello John
Dans l'exemple ci-dessus, vous vous attendriez à ce que le programme imprime "John Doe", mais
il n'imprime que "John".
C'est pourquoi, lorsque nous travaillons avec des chaînes, nous utilisons souvent la
fgets()fonction pour lire une ligne de texte . Notez que vous devez inclure les arguments
suivants : le nom de la variable chaîne, sizeof( string_name ), et stdin:
Exemple
char fullName[30];

printf("Type your full name: \n");

fgets(fullName, sizeof(fullName), stdin);

printf("Hello %s", fullName);

// Type your full name: John Doe

// Hello John Doe
Utilisez la scanf()fonction pour obtenir un seul mot en entrée et utilisez fgets()-la pour
plusieurs mots.

Adresse mémoire
Lorsqu'une variable est créée en C, une adresse mémoire est affectée à la variable.
L'adresse mémoire est l'emplacement où la variable est stockée sur l'ordinateur.
Lorsque nous attribuons une valeur à la variable, elle est stockée dans cette adresse mémoire.
Pour y accéder, utilisez l'opérateur de référence (&), et le résultat représente l'endroit où la variable
est stockée :
Exemple
int myAge = 43;
printf("%p", &myAge); // Outputs 0x7ffe5367e044
Remarque : L'adresse mémoire est au format hexadécimal (0x..). Vous n'obtiendrez peut-être pas
le même résultat dans votre programme.
Vous devez également noter qu'il &myAge est souvent appelé "pointeur". Un pointeur stocke
essentiellement l'adresse mémoire d'une variable comme sa valeur. Pour imprimer des valeurs de
pointeur, nous utilisons le %pspécificateur de format.

Pourquoi est-il utile de connaître l'adresse mémoire ?

Les pointeurs sont importants en C, car ils nous permettent de manipuler les données dans la
mémoire de l'ordinateur - cela peut réduire le code et améliorer les performances.
Les pointeurs sont l'une des choses qui distinguent C des autres langages de programmation,
comme Python et Java .

Création de pointeurs
Vous avez appris du chapitre précédent, qu'on peut obtenir l’adresse mémoire d'une variable avec
l'opérateur de référence & :
Exemple
int myAge = 43; // an int variable

printf("%d", myAge); // Outputs the value of myAge (43)

printf("%p", &myAge); // Outputs the memory address of myAge (0x7ffe5367e044)
Un pointeur est une variable qui stocke l'adresse mémoire d'une autre variable comme valeur.
Une variable de pointeur pointe vers un type de données (comme int) du même type et est créée
avec l’opérateur*. L'adresse de la variable avec laquelle vous travaillez est affectée au pointeur :
Exemple
int myAge = 43; // An int variable
int* ptr = &myAge; // A pointer variable, with the name ptr, that stores the address of myAge

// Output the value of myAge (43)

printf("%d\n", myAge);

// Output the memory address of myAge (0x7ffe5367e044)

printf("%p\n", &myAge);

// Output the memory address of myAge with the pointer (0x7ffe5367e044)

printf("%p\n", ptr);
Exemple expliqué
Créez une variable de pointeur avec le nom ptr, qui pointe vers une intvariable ( myAge). Notez
que le type du pointeur doit correspondre au type de la variable avec laquelle vous travaillez.
Utilisez l' &opérateur pour stocker l'adresse mémoire de la myAgevariable et affectez-la au pointeur.
Maintenant, ptrcontient la valeur de myAgel'adresse mémoire de .

Déréférence
Dans l'exemple ci-dessus, nous avons utilisé la variable de pointeur pour obtenir l'adresse mémoire
d'une variable (utilisée avec l’opérateur de & référence).
Cependant, vous pouvez également obtenir la valeur de la variable vers laquelle pointe le pointeur,
en utilisant l' opérateur * (l' opérateur de déréférencement ) :
Exemple
int myAge = 43; // Variable declaration
int* ptr = &myAge; // Pointer declaration

// Reference: Output the memory address of myAge with the pointer (0x7ffe5367e044)
printf("%p\n", ptr);

// Dereference: Output the value of myAge with the pointer (43)

printf("%d\n", *ptr);
Notez que le *signe peut prêter à confusion ici, car il fait deux choses différentes dans notre code :
• Lorsqu'il est utilisé dans une déclaration ( int* ptr), il crée une variable de pointeur .
• Lorsqu'il n'est pas utilisé dans une déclaration, il agit comme un opérateur de déréférencement .

Bon à savoir : Il existe trois manières de déclarer des variables de pointeur, mais la première est
principalement utilisée :
int* myNum; // Most used
int *myNum;
int * myNum;

Pourquoi devrais-je en savoir plus sur les pointeurs ?

Les pointeurs sont l'une des choses qui distinguent C des autres langages de programmation,
comme Python et Java .
Ce chapitre n'était qu'une courte introduction aux pointeurs. Ils sont importants en C, car ils nous
permettent de manipuler les données dans la mémoire de l'ordinateur - cela peut réduire le code et
améliorer les performances.
Cependant, les pointeurs doivent être manipulés avec précaution, car il est possible d'endommager
les données stockées dans d'autres adresses mémoire.
Fonctions C
Une fonction est un bloc de code qui ne s'exécute que lorsqu'elle est appelée.
Vous pouvez transmettre des données, appelées paramètres, dans une fonction.
Les fonctions sont utilisées pour effectuer certaines actions, et elles sont importantes pour réutiliser
le code : Définissez le code une fois et utilisez-le plusieurs fois.

Fonctions prédéfinies
Il s'avère donc que vous savez déjà ce qu'est une fonction.
Par exemple, main()est une fonction, qui est utilisée pour exécuter du code, et printf()est une
fonction ; utilisé pour afficher/imprimer du texte à l'écran :
Exemple
int main() {
printf("Hello World!");
return 0;
}

Créer une fonction

Pour créer (souvent appelé declare ) votre propre fonction, spécifiez le nom de la fonction, suivi
de parenthèses () et d'accolades {}:
Syntaxe
void myFunction() {
// code to be executed
}
Exemple expliqué
• myFunction()est le nom de la fonction
• void signifie que la fonction n'a pas de valeur de retour.
• À l'intérieur de la fonction (le corps), ajoutez du code qui définit ce que la fonction doit faire

Appeler une fonction

Les fonctions déclarées ne sont pas exécutées immédiatement. Ils sont "enregistrés pour une
utilisation ultérieure" et seront exécutés lorsqu'ils seront appelés.
Pour appeler une fonction, écrivez le nom de la fonction suivi de deux parenthèses () et d'un point-
virgule ;
Dans l'exemple suivant, myFunction()sert à imprimer un texte (l'action), lorsqu'elle est appelée :
Exemple
A l’intérieur main, appelez myFunction():
// Create a function
void myFunction() {
printf("I just got executed!");
}

int main() {
myFunction(); // call the function
return 0;
}

// Outputs "I just got executed!"

Une fonction peut être appelée plusieurs fois :
Exemple
void myFunction() {
printf("I just got executed!");
}

int main() {
myFunction();
myFunction();
myFunction();
return 0;
}

// I just got executed!

// I just got executed!
// I just got executed!

Paramètres de la fonction C
Paramètres et arguments
Les informations peuvent être transmises aux fonctions en tant que paramètre. Les paramètres
agissent comme des variables à l'intérieur de la fonction.
Les paramètres sont spécifiés après le nom de la fonction, entre parenthèses. Vous pouvez ajouter
autant de paramètres que vous le souhaitez, il vous suffit de les séparer par une virgule :
Syntaxe
returnType functionName(parameter1, parameter2, parameter3) {
// code to be executed
}
La fonction suivante qui prend une chaîne de caractères avec le nom comme paramètre. Lorsque
la fonction est appelée, nous transmettons un nom, qui est utilisé à l'intérieur de la fonction pour
imprimer "Bonjour" et le nom de chaque personne.
Exemple
void myFunction(char name[]) {
printf("Hello %s\n", name);
}
int main() {
myFunction("Liam");
myFunction("Jenny");
myFunction("Anja");
return 0;
}

// Hello Liam
// Hello Jenny
// Hello Anja
Lorsqu'un paramètre est passé à la fonction, il est appelé argument. Ainsi, à partir de l'exemple
ci-dessus : name est un paramètre tandis que Liam, Jenny et Anja sont des arguments.

Paramètres multiples
Dans la fonction, vous pouvez ajouter autant de paramètres que vous le souhaitez :
Exemple
void myFunction(char name[], int age) {
printf("Hello %s. You are %d years old.\n", name, age);
}

int main() {
myFunction("Liam", 3);
myFunction("Jenny", 14);
myFunction("Anja", 30);
return 0;
}

// Hello Liam. You are 3 years old.

// Hello Jenny. You are 14 years old.
// Hello Anja. You are 30 years old.
Notez que lorsque vous travaillez avec plusieurs paramètres, l'appel de fonction doit avoir le même
nombre d'arguments qu'il y a de paramètres, et les arguments doivent être passés dans le même
ordre.

Passer des tableaux en tant que paramètres de fonction

Vous pouvez également passer des tableaux à une fonction :
Exemple
void myFunction(int myNumbers[5]) {
for (int i = 0; i < 5; i++) {
printf("%d\n", myNumbers[i]);
}
}

int main() {
int myNumbers[5] = {10, 20, 30, 40, 50};
 myFunction(myNumbers);
return 0;
}
Exemple expliqué
La fonction ( myFunction) prend un tableau comme paramètre ( int myNumbers[5]) et parcourt
les éléments du tableau avec la boucle for.
Lorsque la fonction est appelée à l'intérieur main()de , nous transmettons le tableau myNumbers,
qui génère les éléments du tableau.
Notez que lorsque vous appelez la fonction, vous n'avez qu'à utiliser le nom du tableau lorsque
vous le passez en argument myFunction(myNumbers). Cependant, la déclaration complète du
tableau est nécessaire dans le paramètre de fonction ( int myNumbers[5]).

Valeurs de retour
Le mot-clé void, utilisé dans les exemples précédents, indique que la fonction ne doit pas renvoyer
de valeur. Si vous souhaitez que la fonction renvoie une valeur, vous pouvez utiliser un type de
données (tel que int ou float, etc.) au lieu de void, et utiliser le mot clé return à l'intérieur de
la fonction :
Exemple
int myFunction(int x) {
return 5 + x;
}

int main() {
printf("Result is: %d", myFunction(3));
return 0;
}

// Outputs 8 (5 + 3)
Cet exemple retourne la somme d'une fonction à deux paramètres :
Exemple
int myFunction(int x, int y) {
return x + y;
}

int main() {
printf("Result is: %d", myFunction(5, 3));
return 0;
}

// Outputs 8 (5 + 3)
Vous pouvez également stocker le résultat dans une variable :
Exemple
int myFunction(int x, int y) {
return x + y;
}
int main() {
int result = myFunction(5, 3);
printf("Result is = %d", result);
return 0;
}
// Outputs 8 (5 + 3)

Déclaration et définition de la fonction

Vous venez d'apprendre des chapitres précédents que vous pouvez créer et appeler une fonction de
la manière suivante :
Exemple
// Create a function
void myFunction() {
printf("I just got executed!");
}

int main() {
myFunction(); // call the function
return 0;
}
Une fonction se compose de deux parties :
• Declaration: le nom de la fonction, le type de retour et les paramètres (le cas échéant)
• Définition: le corps de la fonction (code à exécuter)
void myFunction() { // declaration
// the body of the function (definition)
}
Pour l'optimisation du code, il est recommandé de séparer la déclaration et la définition de la
fonction.
Vous verrez souvent des programmes C qui ont une déclaration de fonction ci-dessus main()et une
définition de fonction ci-dessous main(). Cela rendra le code mieux organisé et plus facile à lire :
Exemple
// Function declaration
void myFunction();

// The main method

int main() {
myFunction(); // call the function
return 0;
}

// Function definition
void myFunction() {
printf("I just got executed!");
}

Un autre exemple
Si nous utilisons l'exemple du chapitre précédent concernant les paramètres de fonction et les
valeurs de retour :
Exemple
int myFunction(int x, int y) {
return x + y;
}

int main() {
int result = myFunction(5, 3);
printf("Result is = %d", result);
return 0;
}
// Outputs 8 (5 + 3)
Il est considéré comme une bonne pratique de l'écrire comme ceci à la place :
Exemple
// Function declaration
int myFunction(int, int);

// The main method

int main() {
int result = myFunction(5, 3); // call the function
printf("Result is = %d", result);
return 0;
}

// Function definition
int myFunction(int x, int y) {
return x + y;
}

Récursivité
La récursivité est la technique permettant à une fonction de s'appeler elle-même. Cette technique
permet de décomposer des problèmes compliqués en problèmes simples plus faciles à résoudre.
La récursivité peut être un peu difficile à comprendre. La meilleure façon de comprendre comment
cela fonctionne est de l'expérimenter.
Exemple de récursivité
Additionner deux nombres ensemble est facile à faire, mais ajouter une plage de nombres est plus
compliqué. Dans l'exemple suivant, la récursivité est utilisée pour additionner une plage de
nombres en la décomposant en la simple tâche d'additionner deux nombres :
Exemple
int sum(int k);

int main() {
int result = sum(10);
printf("%d", result);
return 0;
}

int sum(int k) {
if (k > 0) {
return k + sum(k - 1);
} else {
return 0;
}
}
Exemple expliqué
Lorsque la sum()fonction est appelée, elle ajoute un paramètre kà la somme de tous les nombres
inférieurs à ket renvoie le résultat. Lorsque k devient 0, la fonction renvoie simplement 0. Lors de
l'exécution, le programme suit ces étapes :
(9)
10 + sum (9)
10 + (9 + sum (8))
10 + (9 + (8 + sum (7))) ...
10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + sum (0)
10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + 0+ s8) )
10 + ( 9 + ( 8 +
Comme la fonction ne s'appelle pas quand k vaut 0, le programme s'arrête là et renvoie le résultat.
Le développeur doit être très prudent avec la récursivité car il peut être assez facile de se glisser
dans l'écriture d'une fonction qui ne se termine jamais, ou qui utilise des quantités excessives de
mémoire ou de puissance de processeur. Cependant, lorsqu'elle est écrite correctement, la
récursivité peut être une approche de programmation très efficace et mathématiquement élégante.

Fonctions mathématiques
Il existe également une liste de fonctions mathématiques disponibles, qui vous permet d'effectuer
des tâches mathématiques sur des nombres.
Pour les utiliser, vous devez inclure le fichier math.h d'en-tête dans votre programme :
#include <math.h>

Racine carrée
Pour trouver la racine carrée d'un nombre, utilisez la sqrt() fonction :
Exemple
printf("%f", sqrt(16));

Arrondir un nombre
La fonction ceil() arrondit un nombre vers le haut à son entier le plus proche, et la méthode
floor() arrondit un nombre vers le bas à son entier le plus proche, et renvoie le résultat :
Exemple
printf("%f", ceil(1.4));
printf("%f", floor(1.4));
De puissance
La fonction pow() renvoie la valeur de x à la puissance y ( x y ):
Exemple
printf("%f", pow(4, 3));

Autres fonctions mathématiques

Une liste d'autres fonctions mathématiques populaires (de la bibliothèque<math.h>) se trouve dans
le tableau ci-dessous :
Function Description
abs(x) Returns the absolute value of x
acos(x) Returns the arccosine of x
asin(x) Returns the arcsine of x
atan(x) Returns the arctangent of x
cbrt(x) Returns the cube root of x
cos(x) Returns the cosine of x
exp(x) Returns the value of Ex
sin(x) Returns the sine of x (x is in radians)
tan(x) Returns the tangent of an angle

Structures C
Les structures sont un moyen de regrouper plusieurs variables liées en un seul endroit. Chaque
variable de la structure est connue comme un membre de la structure.
Contrairement à un tableau , une structure peut contenir de nombreux types de données différents
(int, float, char, etc.).

Créer une structure

Vous pouvez créer une structure en utilisant le mot clé struct et déclarer chacun de ses membres
à l'intérieur d'accolades :
struct MyStructure { // Structure declaration
int myNum; // Member (int variable)
char myLetter; // Member (char variable)
}; // End the structure with a semicolon
Pour accéder à la structure, vous devez créer une variable de celle-ci.
Utilisez le mot-clé struct à l'intérieur de la main()méthode, suivi du nom de la structure puis du
nom de la variable de structure :
Créez une variable de structure avec le nom "s1":
struct myStructure {
int myNum;
char myLetter;
};
int main() {
struct myStructure s1;
return 0;
}
Accéder aux membres de la structure
Pour accéder aux membres d'une structure, utilisez la syntaxe à points (.) :
Exemple
// Create a structure called myStructure
struct myStructure {
int myNum;
char myLetter;
};

int main() {
// Create a structure variable of myStructure called s1
struct myStructure s1;

// Assign values to members of s1

s1.myNum = 13;
s1.myLetter = 'B';

// Print values
printf("My number: %d\n", s1.myNum);
printf("My letter: %c\n", s1.myLetter);

return 0;
}
Vous pouvez désormais créer facilement plusieurs variables de structure avec des valeurs
différentes, en utilisant une seule structure :
Exemple
// Create different struct variables
struct myStructure s1;
struct myStructure s2;

// Assign values to different struct variables

s1.myNum = 13;
s1.myLetter = 'B';

s2.myNum = 20;
s2.myLetter = 'C';

Qu'en est-il des chaînes dans les structures ?

N'oubliez pas que les chaînes en C sont en fait un tableau de caractères, et malheureusement, vous
ne pouvez pas attribuer de valeur à un tableau comme celui-ci :
Exemple
struct myStructure {
int myNum;
char myLetter;
char myString[30]; // String
};

int main() {
struct myStructure s1;

// Trying to assign a value to the string

s1.myString = "Some text";

// Trying to print the value

printf("My string: %s", s1.myString);

return 0;
}
Une erreur se produira :
prog.c:12:15: error: assignment to expression with array type
Cependant, il existe une solution pour cela ! Vous pouvez utiliser la strcpy() fonction et attribuer
la valeur à s1.myString, comme ceci :
Exemple
struct myStructure {
int myNum;
char myLetter;
char myString[30]; // String
};

int main() {
struct myStructure s1;

// Assign a value to the string using the strcpy function

strcpy(s1.myString, "Some text");

// Print the value

printf("My string: %s", s1.myString);

return 0;
}
Résultat :
My string: Some text

Syntaxe plus simple

Vous pouvez également affecter des valeurs aux membres d'une variable de structure au moment
de la déclaration, sur une seule ligne.
Insérez simplement les valeurs dans une liste séparée par des virgules à l'intérieur d'accolades {}.
Notez que vous n'êtes pas obligé d'utiliser la strcpy()fonction pour les valeurs de chaîne avec
cette technique :
Exemple
// Create a structure
struct myStructure {
int myNum;
char myLetter;
char myString[30];
};

int main() {
// Create a structure variable and assign values to it
struct myStructure s1 = {13, 'B', "Some text"};

// Print values
printf("%d %c %s", s1.myNum, s1.myLetter, s1.myString);

return 0;
}
Remarque : L'ordre des valeurs insérées doit correspondre à l'ordre des types de variables déclarés
dans la structure (13 pour int, 'B' pour char, etc.).

Copier des structures

Vous pouvez également affecter une structure à une autre.
Dans l'exemple suivant, les valeurs de s1 sont copiées dans s2 :
Exemple
struct myStructure s1 = {13, 'B', "Some text"};
struct myStructure s2;

s2 = s1;

Modifier les valeurs

Si vous voulez changer/modifier une valeur, vous pouvez utiliser la syntaxe pointée (.).
Et pour modifier une valeur de chaîne, la strcpy()fonction est à nouveau utile :
Exemple
struct myStructure {
int myNum;
char myLetter;
char myString[30];
};

int main() {
// Create a structure variable and assign values to it
struct myStructure s1 = {13, 'B', "Some text"};
 // Modify values
s1.myNum = 30;
s1.myLetter = 'C';
strcpy(s1.myString, "Something else");

// Print values
printf("%d %c %s", s1.myNum, s1.myLetter, s1.myString);

return 0;
}
La modification des valeurs est particulièrement utile lorsque vous copiez des valeurs de structure :
Exemple
// Create a structure variable and assign values to it
struct myStructure s1 = {13, 'B', "Some text"};

// Create another structure variable

struct myStructure s2;

// Copy s1 values to s2
s2 = s1;

// Change s2 values
s2.myNum = 30;
s2.myLetter = 'C';
strcpy(s2.myString, "Something else");

// Print values
printf("%d %c %s\n", s1.myNum, s1.myLetter, s1.myString);
printf("%d %c %s\n", s2.myNum, s2.myLetter, s2.myString);
Ok, alors, comment les structures sont-elles utiles ?
Imaginez que vous deviez écrire un programme pour stocker différentes informations sur les
voitures, telles que la marque, le modèle et l'année. Ce qui est génial avec les structures, c'est que
vous pouvez créer un seul "modèle de voiture" et l'utiliser pour toutes les voitures que vous
fabriquez. Voir ci-dessous pour un exemple concret.

Exemple réel
Utilisez une structure pour stocker différentes informations sur Cars :
Exemple
struct Car {
char brand[50];
char model[50];
int year;
};

int main() {
struct Car car1 = {"BMW", "X5", 1999};
struct Car car2 = {"Ford", "Mustang", 1969};
 struct Car car3 = {"Toyota", "Corolla", 2011};

printf("%s %s %d\n", car1.brand, car1.model, car1.year);

printf("%s %s %d\n", car2.brand, car2.model, car2.year);
printf("%s %s %d\n", car3.brand, car3.model, car3.year);

return 0;
}

Énumérations C
Une énumération est un type spécial qui représente un groupe de constantes (valeurs non
modifiables).
Pour créer une énumération, utilisez le mot-clé enum, suivi du nom de l'énumération, et séparez les
éléments de l'énumération par une virgule :
enum Level {
LOW,
MEDIUM,
HIGH
};
Notez que le dernier élément n'a pas besoin de virgule.
Il n'est pas obligatoire d'utiliser des majuscules, mais souvent considéré comme une bonne pratique.
Enum est l'abréviation de "énumérations", ce qui signifie "spécifiquement répertorié".
Pour accéder à l'énumération, vous devez en créer une variable.
Dans la méthode main(), spécifiez le mot-clé enum, suivi du nom de l'énumération ( Level) puis
du nom de la variable enum ( myVar dans cet exemple) :
enum Level myVar;
Maintenant que vous avez créé une variable enum ( myVar), vous pouvez lui attribuer une valeur.
La valeur attribuée doit être l'un des éléments à l'intérieur de l'énumération ( LOW, MEDIUMou HIGH) :
enum Level myVar = MEDIUM;
Par défaut, le premier élément (LOW) a la valeur 0, le second (MEDIUM) a la valeur 1, etc.
Si vous essayez maintenant d'imprimer myVar, il affichera 1, ce qui représenteMEDIUM :
int main() {
// Create an enum variable and assign a value to it
enum Level myVar = MEDIUM;

// Print the enum variable

printf("%d", myVar);

return 0;
}

Changer les valeurs

Comme vous le savez, le premier élément d'une énumération a la valeur 0. Le second a la valeur 1,
et ainsi de suite.
Pour donner plus de sens aux valeurs, vous pouvez facilement les modifier :
enum Level {
LOW = 25,
MEDIUM = 50,
HIGH = 75
};
printf("%d", myVar); // Now outputs 50
Notez que si vous attribuez une valeur à un élément spécifique, les éléments suivants mettront à
jour leurs numéros en conséquence :
enum Level {
LOW = 5,
MEDIUM, // Now 6
HIGH // Now 7
};

Énumération dans une instruction Switch

Les énumérations sont souvent utilisées dans les instructions switch pour vérifier les valeurs
correspondantes :
enum Level {
LOW = 1,
MEDIUM,
HIGH
};

int main() {
enum Level myVar = MEDIUM;

switch (myVar) {
case 1:
printf("Low Level");
break;
case 2:
printf("Medium level");
break;
case 3:
printf("High level");
break;
}
return 0;
}
Pourquoi et quand utiliser les énumérations ?
Les énumérations sont utilisées pour donner des noms aux constantes, ce qui facilite la lecture et
la maintenance du code.
Utilisez des énumérations lorsque vous avez des valeurs dont vous savez qu'elles ne changeront
pas, comme les jours du mois, les jours, les couleurs, le jeu de cartes, etc.