đ Retour au Sommaire
FĂ©licitations dâavoir atteint ce chapitre ! Vous maĂźtrisez maintenant les bases du C : les variables, les types de donnĂ©es, les fonctions dâentrĂ©e/sortie. Mais jusquâĂ prĂ©sent, vos programmes se contentaient dâexĂ©cuter des instructions de maniĂšre sĂ©quentielle, de haut en bas, sans possibilitĂ© de faire des calculs complexes, de prendre des dĂ©cisions ou de rĂ©pĂ©ter des actions.
Dans ce chapitre, tout change. Vous allez apprendre Ă :
Ce sont les briques fondamentales qui transforment un simple script en un véritable programme capable de résoudre des problÚmes complexes.
Un opĂ©rateur est un symbole qui indique au compilateur dâeffectuer une opĂ©ration spĂ©cifique sur une ou plusieurs valeurs (appelĂ©es opĂ©randes).
int resultat = 5 + 3;
Dans cette expression :
+ est lâopĂ©rateur (addition)5 et 3 sont les opĂ©randesresultat reçoit la valeur calculĂ©e (8)Le C propose plusieurs catĂ©gories dâopĂ©rateurs :
| Catégorie | Exemples | Usage |
|---|---|---|
| Arithmétiques | +, -, *, /, % |
Calculs mathématiques |
| Logiques | &&, ||, ! |
Conditions et tests |
| Relationnels | ==, !=, <, >, <=, >= |
Comparaisons |
| Bit-Ă -bit | &, |, ^, ~, <<, >> |
Manipulation des bits |
| Affectation | =, +=, -=, *=, /= |
Attribution de valeurs |
| Incrémentation | ++, -- |
Augmenter/diminuer de 1 |
Chaque catĂ©gorie a son rĂŽle et ses cas dâusage. Ce chapitre les explore en dĂ©tail.
Une structure de contrĂŽle est une instruction qui permet de modifier le flux dâexĂ©cution dâun programme. Au lieu dâexĂ©cuter les instructions ligne par ligne, vous pouvez :
Programme simple sans contrĂŽle :
#include <stdio.h>
int main(void)
{
printf("Ligne 1\n");
printf("Ligne 2\n");
printf("Ligne 3\n");
return 0;
}
ExĂ©cution : Ligne 1 â Ligne 2 â Ligne 3 â Fin
Toutes les instructions sont exĂ©cutĂ©es, dans lâordre, une seule fois.
Programme avec condition :
#include <stdio.h>
int main(void)
{
int age = 25;
printf("DĂ©but du programme\n");
if (age >= 18) {
printf("Vous ĂȘtes majeur\n");
} else {
printf("Vous ĂȘtes mineur\n");
}
printf("Fin du programme\n");
return 0;
}
Exécution : Le programme décide quelle ligne afficher selon la valeur de age.
Programme avec boucle :
#include <stdio.h>
int main(void)
{
for (int i = 1; i <= 3; i++) {
printf("Répétition numéro %d\n", i);
}
return 0;
}
Exécution : La ligne printf est répétée 3 fois automatiquement.
Sans structures de contrÎle, impossible de créer des programmes qui :
Exemple : Une calculatrice qui change de comportement selon lâopĂ©ration choisie.
La plupart des problÚmes nécessitent :
Exemple : Calculer la moyenne dâun ensemble de notes.
// Sans boucle : impossible si on a 100 notes
int note1 = 15, note2 = 18, note3 = 12;
float moyenne = (note1 + note2 + note3) / 3.0;
// Avec boucle : possible pour n'importe quel nombre de notes
float somme = 0;
for (int i = 0; i < nb_notes; i++) {
somme += notes[i];
}
float moyenne = somme / nb_notes;
Comprendre les opĂ©rateurs et structures de contrĂŽle permet dâĂ©crire du code :
Tout ce que vous apprendrez ensuite repose sur ce chapitre :
Sans maĂźtriser ce chapitre, impossible de progresser !
Ce chapitre est organisé en 7 sections progressives :
Les bases des calculs en C.
Pourquoi : Tout programme fait des calculs. Câest la base absolue.
Combiner des conditions et prendre des décisions complexes.
&&), OU logique (||), NON logique (!)Pourquoi : Permet de créer des conditions sophistiquées pour contrÎler le programme.
Manipuler les données au niveau le plus bas : les bits.
Pourquoi : Essentiel pour la programmation systĂšme, lâembarquĂ© et les optimisations.
Faire des choix dans vos programmes.
if, else if, else? :)switch et casePourquoi : Permet au programme de sâadapter et de rĂ©agir aux diffĂ©rentes situations.
RĂ©pĂ©ter des actions et contrĂŽler lâexĂ©cution.
while, do-while, forbreak et continuePourquoi : Automatise les tùches répétitives et traite des ensembles de données.
Ăcrire du code lisible et professionnel.
Pourquoi : Un code bien formaté est plus facile à lire, comprendre et maintenir.
Automatiser le formatage pour garantir la cohérence.
Pourquoi : Ăconomise du temps et garantit un code toujours bien formatĂ© automatiquement.
Ce chapitre suit une progression logique :
Opérateurs de base (5.1)
â
OpĂ©rateurs logiques (5.2) â NĂ©cessaires pour les conditions
â
OpĂ©rateurs bit-Ă -bit (5.3) â ComplĂ©mentaires
â
Conditions (5.4) â Utilise les opĂ©rateurs logiques
â
Boucles (5.5) â Utilise souvent des conditions
â
Formatage (5.6-5.7) â Rend tout plus lisible
Chaque section sâappuie sur les prĂ©cĂ©dentes. Il est important de les Ă©tudier dans lâordre.
Ă la fin de ce chapitre, vous serez capable dâĂ©crire des programmes comme :
#include <stdio.h>
int main(void)
{
float a, b;
char operation;
printf("Entrez une opération (ex: 5 + 3) : ");
scanf("%f %c %f", &a, &operation, &b);
if (operation == '+') {
printf("RĂ©sultat : %.2f\n", a + b);
} else if (operation == '-') {
printf("RĂ©sultat : %.2f\n", a - b);
} else if (operation == '*') {
printf("RĂ©sultat : %.2f\n", a * b);
} else if (operation == '/' && b != 0) {
printf("RĂ©sultat : %.2f\n", a / b);
} else {
printf("Opération invalide\n");
}
return 0;
}
#include <stdio.h>
#include <stdbool.h>
int main(void)
{
int n;
bool est_premier = true;
printf("Entrez un nombre : ");
scanf("%d", &n);
if (n <= 1) {
est_premier = false;
} else {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
est_premier = false;
break;
}
}
}
if (est_premier) {
printf("%d est un nombre premier\n", n);
} else {
printf("%d n'est pas un nombre premier\n", n);
}
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(void)
{
srand(time(NULL));
int nombre_secret = rand() % 100 + 1;
int tentative;
int nb_essais = 0;
printf("J'ai choisi un nombre entre 1 et 100. Devinez !\n");
do {
printf("Votre tentative : ");
scanf("%d", &tentative);
nb_essais++;
if (tentative < nombre_secret) {
printf("Trop petit !\n");
} else if (tentative > nombre_secret) {
printf("Trop grand !\n");
} else {
printf("Bravo ! Vous avez trouvé en %d essais !\n", nb_essais);
}
} while (tentative != nombre_secret);
return 0;
}
#include <stdio.h>
#define READ (1 << 0) // 0x01 â Permission de lecture
#define WRITE (1 << 1) // 0x02 â Permission d'Ă©criture
#define EXECUTE (1 << 2) // 0x04 â Permission d'exĂ©cution
int main(void)
{
int permissions = READ | WRITE; // Lecture et Ă©criture
if (permissions & READ) {
printf("Vous pouvez lire\n");
}
if (permissions & WRITE) {
printf("Vous pouvez Ă©crire\n");
}
if (permissions & EXECUTE) {
printf("Vous pouvez exécuter\n");
} else {
printf("Vous ne pouvez pas exécuter\n");
}
return 0;
}
Ces exemples combinent opérateurs, conditions et boucles pour créer des programmes utiles et interactifs !
Ă la fin de ce chapitre, vous devrez maĂźtriser :
+=, -=, etc.)if et switchbreak et continue Ă bon escientChaque section combine :
Les exemples commencent simples et deviennent progressivement plus complexes :
Niveau 1 : Exemples basiques
int x = 5 + 3; // Addition simple
Niveau 2 : Exemples intermédiaires
float moyenne = (note1 + note2 + note3) / 3.0;
Niveau 3 : Exemples avancés
for (int i = 0; i < n; i++) {
if (tableau[i] > max) {
max = tableau[i];
index_max = i;
}
}
De nombreux tableaux et comparaisons pour visualiser les différences :
| Opérateur | Signification | Exemple | Résultat |
|---|---|---|---|
+ |
Addition | 5 + 3 |
8 |
- |
Soustraction | 5 - 3 |
2 |
* |
Multiplication | 5 * 3 |
15 |
/ |
Division | 5 / 3 |
1 (division entiĂšre) |
Ce chapitre vous aidera Ă Ă©viter des erreurs classiques :
= et ==// â ERREUR : Affectation au lieu de comparaison
if (x = 5) { // Affecte 5 Ă x et teste si 5 est vrai (toujours vrai)
printf("x vaut 5\n");
}
// â
CORRECT : Comparaison
if (x == 5) { // Compare x avec 5
printf("x vaut 5\n");
}
// â RĂ©sultat inattendu
int a = 5, b = 2;
float resultat = a / b; // resultat = 2.0 (pas 2.5 !)
// â
CORRECT
float resultat = (float)a / b; // resultat = 2.5
// â Boucle infinie
int i = 0;
while (i < 10) {
printf("%d\n", i);
// Oubli d'incrémenter i !
}
// â
CORRECT
int i = 0;
while (i < 10) {
printf("%d\n", i);
i++; // Incrémentation
}
// â RĂ©sultat inattendu
int resultat = 5 + 3 * 2; // resultat = 11 (pas 16 !)
// Explication : * a priorité sur +
// â
CORRECT si on veut 16
int resultat = (5 + 3) * 2; // resultat = 16
Chaque piÚge sera expliqué en détail dans les sections concernées.
Tout au long de ce chapitre, vous utiliserez GCC :
# Compiler un programme
gcc -Wall -Wextra -std=c17 mon_programme.c -o mon_programme
# Exécuter
./mon_programme
Les options -Wall -Wextra sont essentielles : elles affichent les avertissements qui peuvent révéler des erreurs subtiles.
Pour comprendre comment les conditions et boucles fonctionnent :
# Compiler avec symboles de débogage
gcc -g mon_programme.c -o mon_programme
# DĂ©boguer
gdb ./mon_programme
Ă partir de la section 5.7, vous utiliserez clang-format :
# Installer
sudo apt install clang-format
# Formater un fichier
clang-format -i mon_fichier.c
Avant de commencer ce chapitre, assurez-vous de maĂźtriser :
printf(), scanf()Si ces notions ne sont pas claires, révisez les chapitres précédents avant de continuer.
Ne vous contentez pas de lire. Pour chaque exemple :
Modifiez les exemples :
La programmation sâapprend par la pratique :
Notez :
Avant de plonger dans les détails, retenez ces points essentiels :
Des symboles qui effectuent des opérations sur des valeurs. Ils permettent de :
Des instructions qui modifient le flux dâexĂ©cution. Elles permettent de :
if, switch)while, for, do-while)break, continue)à la fin de ce chapitre, vous pourrez écrire des programmes complets qui calculent, décident et répÚtent des actions intelligemment !
Vous avez maintenant une vue dâensemble de ce chapitre crucial. Vous comprenez :
Il est temps de passer Ă la pratique !
La prochaine section (5.1 - Opérateurs arithmétiques) démarre avec les bases des calculs en C. Vous allez apprendre à :
PrĂȘt Ă Ă©crire vos premiers programmes qui calculent ? Passons Ă la section 5.1 !
Rappelez-vous : tout programme que vous utilisez quotidiennement (navigateur web, systĂšme dâexploitation, jeux vidĂ©o, applications mobiles) utilise massivement les concepts de ce chapitre.
En maßtrisant les opérateurs et structures de contrÎle, vous franchissez la frontiÚre entre :
Câest ici que votre voyage en programmation C devient vraiment passionnant !
Bonne lecture et bon apprentissage ! đ
âïž OpĂ©rateurs arithmĂ©tiques