Programmation en C

John Samuel

CPE Lyon

Année: 2023-2024
Courriel: john.samuel@cpe.fr

Creative Commons License

John SAMUEL

  • Enseignant-Chercheur, Conception Logicielle et Big Data, CPE Lyon,
  • Intérêts et thèmes de recherche : Représentation de connaissances, le web sémantique, les services web, l'intégration de données, l'entrepôt de données, les systèmes distribués, système d'information géographique
  • Cours : Programmation en C, Algorithmes en C, Data Mining et Machine Learning, Intelligence Artificielle et Deep Learning, Systèmes d'exploitation et Programmation Concurrente, Langages Web
  • Thèse : Intégration des données issues de services web

1.1. Programmation en C: Introduction

Objectifs

1.1. Programmation en C: Introduction

Bonjour le Monde!!

/* Fichier: bonjour1.c
* affiche 'Bonjour le Monde!!!' à l'écran.
* auteur: John Samuel
* Ceci est un commentaire sur plusieurs lignes
*/


#include <stdio.h> // headers

// Ceci est un commentaire sur une ligne
int main() {
  printf("Bonjour le Monde !!!");
  return 0;
}

1.1. Programmation en C: Introduction

Structures de contrôle

Les structures de contrôle en C dirigent l'exécution du code en fonction de conditions ou de boucles.

1.1. Programmation en C: Introduction

Gestion de mémoire

Adresses physiques
la conversion des adresses virtuelles en adresses physiques
La conversion des adresses virtuelles en adresses physiques

1.1. Programmation en C: Introduction

La chaine de compilation

Compilation: gcc

La chaîne de compilation en C est le processus séquentiel de transformation du code source en un exécutable.

1.1. Programmation en C: Introduction

File

File

Une file est une structure de données qui gère les éléments de manière FIFO (First-In-First-Out), ce qui signifie que l'élément ajouté en premier est le premier à être retiré.

1.1. Programmation en C: Introduction

Pile

Pile

Une pile est une structure de données qui gère les éléments de manière LIFO (Last-In-First-Out), où le dernier élément ajouté est le premier à être retiré.

1.1. Programmation en C: Introduction

Environnement de programmation:

Cours:

1.1. Programmation en C: Introduction

Devoir surveillé (DS): 60%

Vous recevrez un courrier détaillé avant l'examen

1.1. Programmation en C: Introduction

Cours Dates
Cours 1 12 septembre
Cours 2 14 septembre
Cours 3 19 septembre
Cours 4 21 septembre
Cours 5 26 septembre
Cours 6 28 septembre

1.1. Programmation en C: Introduction

Déroulement du cours

Le cours de 2 heures est structuré avec une première session de 55 à 60 minutes, suivie d'une pause de 5 à 10 minutes pour des questions, et conclut ensuite avec une deuxième session de 55 à 60 minutes.

1.1. Programmation en C: Introduction

Travaux pratiques et Projet

1.1. Programmation en C: Introduction

TP Points
TP 1 3
TP 2 3
TP 3 4
TP 4 3
TP 5 3
TP 6 4

1.1. Programmation en C: Introduction

Travaux pratiques

Chaque TP comporte plusieurs exercices. Chaque exercice est accompagné d'une indication de niveau de difficulté :

1.1. Programmation en C: Introduction

Travaux pratiques et Projet

La complexité des TP augmente progressivement après chaque séance, ce qui peut nécessiter plus de temps pour compléter tous les exercices.

1.1. Programmation en C: Introduction

Travaux pratiques: Rendus

  1. Le rendu est constitué de deux parties principales : le rapport d'auto-évaluation et les fichiers source.
  2. Votre dossier de rendu doit comporter les éléments suivants
    • Un fichier README.md contenant le rapport d'auto-évaluation.
    • Un fichier CONTRIBUTORS.md listant les noms et prénoms des contributeurs.
    • Un répertoire src/ contenant les fichiers sources, identifiables par les extensions .c et .h.

1.1. Programmation en C: Introduction

Travaux pratiques: Rendus

  1. Votre rendu doit être renommé au format "groupe_N1_N2.zip", où N1 et N2 représentent les noms (par exemple, "groupe_DUPONT_SMITH.zip").
  2. Assurez-vous d'écrire ou de compléter les fichiers README.md et CONTRIBUTORS.md au format Markdown.
  3. Le contenu du fichier README.md devrait comprendre :
    1. Rapport d'auto-évaluation pour le TP numéro N (où N varie de 1 à 6).
    2. Bibliothèques utilisées, y compris les bibliothèques standard.
    3. Références telles que les URL ou les groupes consultés pour l'exercice.
    4. Indication du niveau de difficulté (facile, moyen, difficile).
    5. Optionnellement, des commentaires ou des remarques supplémentaires peuvent être inclus.

1.1. Programmation en C: Introduction

Liste de contrôle

Avant de soumettre votre travail pratique, veuillez vérifier que vous avez respecté la liste de contrôle suivante :

1.1. Programmation en C: Introduction

Modèle de code

Vous pouvez consulter https://github.com/johnsamuelwrites/ProgC en ligne
ou le cloner sur votre machine à l'aide du terminal en utilisant les commandes suivantes.

$ git clone https://github.com/johnsamuelwrites/ProgC
$ cd ProgC
$ ls

Pour obtenir les dernières mises à jour du répertoire, vous pouvez exécuter la commande suivante:

$ git pull

1.1. Programmation en C: Introduction

Travaux pratiques et Projet

  • Le projet est basé sur une architecture client-serveur.
  • Les clients sont chargés de réaliser des analyses d'images.
  • Contrairement à la méthode classique, les clients ne transmettent pas les images complètes au serveur.
  • Au lieu de cela, ils envoient uniquement les résultats d'analyse générés localement.

1.1. Programmation en C: Introduction

Travaux pratiques et Projet

  • Ce modèle est similaire au concept d'"edge computing".
  • L'objectif est d'optimiser l'utilisation de la bande passante et de réduire la charge du serveur.
  • Il garantit également la confidentialité des données d'image.
  • Le serveur agrège les résultats d'analyse de plusieurs clients pour obtenir une vue globale ou des informations agrégées.
  • Cette approche est particulièrement efficace pour des applications impliquant la surveillance de nombreux capteurs, la collecte de données distribuées et la gestion de ressources informatiques décentralisées.

1.1. Programmation en C: Introduction

Objectifs des travaux pratiques

  1. Comprendre la chaine de compilation en utilisant GCC (GNU compilation chain) : prétraitement jusqu’à l’exécution
  2. Travailler avec les bibliothèques standards et les appels de système d’exploitation (fichiers, les sockets réseau etc.)
  3. Comprendre les pointeurs et manipuler les buffers en utilisant les pointeurs
  4. Créer, compiler et exécuter un projet C
  5. Travailler avec les différents formats de données comme BMP
  6. Créer un simple programme client-serveur pour le transfert de fichiers et messages
  7. Exécuter les applications existantes sur la machine (e.g. GNU plot)
  8. Documenter une application en utilisant le format markdown (*.md)
  9. Tester une application

1.1. Programmation en C: Introduction

⚠️ Attention

  1. Aucune soumission par courriel électronique.
  2. Les liens vers des sites externes comme GitHub/GitLab,... ne seront pas acceptés.
  3. Seules les soumissions complètes sur E-Campus seront acceptées pour l'évaluation.
  4. Ne pas modifier les noms de fichiers (*.c, *.h, *.md, ...).

1.2. Programmation en C: Histoire

Questions

Donnez des exemples de logiciels écrits en C

1.2. Programmation en C: Histoire

Exemples

  1. Noyau Linux: https://github.com/torvalds/linux
  2. GCC: https://gcc.gnu.org/git/gitweb.cgi?p=gcc.git
  3. GIT: https://git.kernel.org/pub/scm/git/git.git/
  4. Apache HTTP Server: https://github.com/apache/httpd
  5. Python: https://github.com/python/cpython

1.2. Programmation en C: Histoire

C

Le langage C est un langage de programmation :

Remarque: Pas de classes (Ce n'est pas un langage de programmation orienté-objet!!!)

Extensions de fichiers : .c, .h

1.2. Programmation en C: Histoire

1.2. Programmation en C: Histoire

Caractéristique Langage C Python
Paradigme de programmation Impératif, procédural Multiparadigme (impératif, orienté objet, fonctionnel)
Typage Statique (typage fort) Dynamique (typage fort) / Statique (Python 3.5+)
Syntaxe Syntaxe stricte et rigide Syntaxe simple et lisible
Performance Performant, optimisé pour les performances Moins performant, interprété
Gestion de la mémoire Besoin de gérer manuellement la mémoire Gestion automatique de la mémoire (ramassage des ordures)
Portabilité Portable, mais nécessite une compilation spécifique pour chaque plateforme Hautement portable grâce à son interpréteur

1.2. Programmation en C: Histoire

C: chronologie des langages de programmation

1.3. Bonjour le Monde!!

/* Fichier: bonjour1.c
* affiche 'Bonjour le Monde!!!' à l'écran.
* auteur: John Samuel
* Ceci est un commentaire sur plusieurs lignes
*/


#include <stdio.h> // headers

// Ceci est un commentaire sur une ligne
int main() {
  printf("Bonjour le Monde !!!");
  return 0;
}

Objectif : Ce code utilise des commentaires, inclut le fichier d'en-tête <stdio.h> pour l'utilisation de printf, définit la fonction main comme point d'entrée, utilise printf pour afficher un message, et renvoie 0 pour indiquer une exécution sans erreur.

1.3. Bonjour le Monde!!

/* Fichier: bonjour2.c
* affiche un message à l'écran en utilisant une variable
* auteur: John Samuel
* Ceci est un commentaire sur plusieurs lignes
*/


#include <stdio.h> // headers

int main() {
  int annee = 2023; //déclaration d'une variable
  printf("Bonjour le Monde!!! C'est l'annee %d", annee);
  return 0;
}

Objectif : Ce code déclare une variable annee, utilise printf pour afficher un message incluant la valeur.

1.4. Compilation

La compilation

$ gcc bonjour1.c

Pour voir tous les avertissements (*warnings*) pendant la compilation, vous pouvez utiliser les options -Wall et -Wextra.

$ gcc -Wall -Wextra -o bonjour bonjour.c

L'exécution

$./a.out
Bonjour le Monde!!!

1.4. La compilation

La compilation

$ gcc -o bonjour bonjour2.c

L'exécution

$./bonjour
Bonjour le Monde!!! C'est l'annee 2023

1.5. Les commentaires

Commentaires sur une ou plusieurs lignes

// Ceci est un commentaire sur une ligne (c99)

/* Ceci est un
 * commentaire sur
 * quatre lignes
 */

1.6. Les types de base

Les types de base en C sont les fondations sur lesquelles sont construites toutes les variables et données dans ce langage de programmation.

Types Mots clés Exemples
caractères char 'h', 'a', ...
entiers short, int, long, long long ...,-1,0,1,...
nombres en flottant float, double, long double 3.14, 3.14e23
énumrérations enum ETUDIANT, STAGIAIRE

1.7. Les types caractères et entiers

Le choix de stocker des données en un octet, deux octets, quatre octets ou huit octets dépend principalement de la précision nécessaire pour représenter les données.

Un octet, deux octets, quatre octets ou huit octets

1.7. Les types caractères et entiers

Types Mots-clés
caractère signed char, unsigned char
entier signed short, signed int, signed long, signed long long, unsigned short, unsigned int, unsigned long, unsigned long long

Remarque : La taille des types de base en C n'est pas standardisée car elle dépend de l'architecture matérielle sous-jacente du système sur lequel le code est exécuté, ce qui permet d'optimiser l'utilisation de la mémoire et les performances pour chaque plate-forme.

1.8. Declaration des variables

Variables char

Les variables de type "char" en C sont utilisées pour stocker des caractères, mais elles peuvent également être modifiées avec les qualificateurs "signed" (signé) ou "unsigned" (non signé) pour déterminer si elles peuvent représenter des valeurs négatives (signées) ou uniquement des valeurs positives (non signées).

char my_char_var1 = 'a';
char my_char_var2 = -125;
unsigned char my_char_var3 = 225;

Remarque: Remarquez-bien l'utilisation de sous-tiret en nommant les variables

1.8. Declaration des variables

Variables

char my_char_var = 'a';
unsigned char my_uchar_var = 234;
short my_short_var = -12;
unsigned short my_ushort_var = 65535;
int my_int_var = 12;
unsigned int my_uint_var = 3456;
long my_long_var = -1234553L;
unsigned long my_ulong_var = 234556UL;
long long my_llong_var = 1123345LL;
unsigned long long my_ullong_var = 1234567ULL;
float my_float_var = 3.14;
double my_double_var = 3.14E-12;
long double my_long_double_var = 3.14E-22;

1.8. Declaration des variables

Énumrérations

Les énumérations en C sont un moyen de définir un nouveau type de données personnalisé pour représenter un ensemble fini de valeurs entières nommées. Elles sont utiles pour rendre le code plus lisible et compréhensible.

enum status {ETUDIANT, STAGIAIRE}; // ETUDIANT = 0, STAGIAIRE = 1
enum status s = ETUDIANT;
enum status {ETUDIANT=1, STAGIAIRE}; // STAGIAIRE = 2
enum status {ETUDIANT=1, STAGIAIRE=14, ENSEIGNANT}; // ENSEIGNANT = 15
enum boolean {FAUX=0, VRAI};

Remarque: enum: unsigned int

1.9. L'intervalle minimum et maximum

limits.h

L'intervalle minimum et maximum de types de base en utilisant limits.h

Mots clés Intervalle
signed char [SCHAR_MIN, SCHAR_MAX]
unsigned char [0, UCHAR_MAX]

1.9. L'intervalle minimum et maximum

Mots clés Intervalle
(signed) short int [SHRT_MIN, SHRT_MAX]
unsigned short int [0, USHRT_MAX]
(signed) int [INT_MIN, INT_MAX]
unsigned int [0, UINT_MAX]
(signed) long [LONG_MIN, LONG_MAX]
unsigned long [0, ULONG_MAX]
(signed) long long [LLONG_MIN, LLONG_MAX]
unsigned long long [0, ULLONG_MAX]

1.9. L'intervalle minimum et maximum

float.h

L'intervalle minimum et maximum de types flottant en utilisant float.h

Mots clés Intervalle
float [FLT_MIN, FLT_MAX]
double [DBL_MIN, DBL_MAX]
long double [LDBL_MIN, LDBL_MAX]

1.10. taille (en octets)

sizeof

sizeof (char) //type
sizeof (my_uchar_var) //variable
printf("sizeof(char): %lu\n", sizeof (char));
printf("sizeof(long long int): %lu\n", sizeof (long long int));
printf("sizeof(my_char_var): %lu\n", sizeof (my_char_var));

Remarque 1: sizeof donne la taille d'une variable en octets ou d'un type de données.

Remarque 2: La valeur retournée peut varier, mais la taille d'une variable de type caractère est de 1 octet.

Remarque 3: La valeur retournée est du type "unsigned long int". C'est pourquoi nous utilisons "%lu".

1.11. Afficher à l'écran

Afficher à l'écran

printf("%d", my_int_var);
printf("%f", my_float_var);

1.11. printf: Afficher à l'écran

Mots clés Code de conversion
char c
unsigned char hhu
short hd
unsigned short hu
int d, i
unsigned int u
long int ld
unsigned long int lu

1.11. printf: Afficher à l'écran

Mots clés Code de conversion
long long int lld
unsigned long long int llu
float f, F,e, E
double g, G
long double Lg, LG, Le, LE
string of characters s

1.11. printf: Afficher à l'écran

Character Code de conversion
Retour-chariot \n
Tabulation \t

1.12. Les notations

Notation binaire

La notation binaire en C permet de représenter des nombres en utilisant uniquement les chiffres 0 et 1, en préfixant les valeurs binaires par "0b", ce qui facilite la manipulation des données au niveau des bits.

  int valeur = 0b10100100;

1.12. Les notations

Notation octale

La notation octale en C permet de représenter des nombres en utilisant la base octale, c'est-à-dire en utilisant les chiffres de 0 à 7, en préfixant les valeurs octales par "0".

  int valeurb = 0b10100100;
  int valeuro = 0244;
  printf("notation octale: %o\n", valeurb);
  printf("notation octale: %o\n", valeuro);

1.12. Les notations

Notation octale

1.12. Les notations

Notation héxadecimale

La notation hexadécimale en C permet de représenter des nombres en utilisant la base hexadécimale, c'est-à-dire en utilisant les chiffres de 0 à 9 et les lettres de A à F, en préfixant les valeurs hexadécimales par "0x".

  int valeurb = 0b10100100;
  int valeurx = 0xa4;
  printf("notation hexadecimale: %x\n", valeurb);
  printf("notation hexadecimale: %x\n", valeurx);

1.12. Les notations

Notation héxadecimale

1.13. Les opérateurs arithmétiques

Les opérateurs arithmétiques en C sont des symboles spéciaux tels que "+", "-", "*", "/", et "%" utilisés pour effectuer des opérations mathématiques telles que l'addition, la soustraction, la multiplication, la division et le modulo sur des valeurs numériques, facilitant ainsi la manipulation des données numériques dans les programmes.

Opérateur Objectif
+ addition
- soustraction
* multiplication
/ division
% modulus

1.13. Les opérateurs arithmétiques

int a = 20, b = 10;
Opérateur Exemple Résultat
+ a + b 30
- a - b 10
* a * b 200
/ a / b 2
% a % b 0

1.14. Les opérateurs relationnels

Les opérateurs relationnels en C, tels que "==", "!=", "<", ">" , "<=" , et ">=" , sont utilisés pour comparer des valeurs numériques ou des expressions et renvoient une valeur booléenne (vrai ou faux) en fonction de la relation spécifiée, ce qui permet de prendre des décisions conditionnelles dans les programmes en évaluant des conditions.

Opérateur Objectif
< inférieur
<= inférieur ou égale
> supérieur
>= supérieur ou égale
== égale
!= différent

1.14. Les opérateurs relationnels

int a = 20, b = 10;
Opérateur Exemple Résultat
< a < b 0
<= a <= b 0
> a > b 1
>= a >= b 1
== a == b 0
!= a != b 1

Remarque: Une valeur différente de zéro est considérée comme VRAIE et la valeur zéro est considérée comme FAUSSE.

1.15. Les opérateurs logiques

Les opérateurs logiques en C, tels que "&&" (ET logique), "||" (OU logique) et "!" (NON logique), sont utilisés pour combiner des expressions booléennes et effectuer des opérations de logique booléenne, ce qui permet de prendre des décisions conditionnelles complexes en évaluant plusieurs conditions simultanément dans les programmes.

int a = 20, b = 0;
Opérateur Objectif Exemple Résultat
! Négation !a 0
&& Et a && b 0
|| Ou a || b 1

Remarque: Une valeur différente de zéro est considérée comme VRAIE et la valeur zéro est considérée comme FAUSSE.

1.16. Les opérateurs d'incrementation

Les opérateurs d'incrémentation en C, "++" (incrémentation) et "--" (décrémentation), sont utilisés pour augmenter ou diminuer la valeur d'une variable numérique de 1, ce qui facilite les itérations et les mises à jour de variables dans les boucles et les calculs.

int a = 20, b = 0;
Opérateur Exemple Résultat
a++ b = a++ a = 21, b = 20
++a b = ++a a = 21, b = 21
a-- b = a-- a = 19, b = 20
--a b = --a a = 19, b = 19

1.17. Les opérateurs de manipulation de bits

Les opérateurs de manipulation de bits en C, tels que "&" (ET bit à bit), "|" (OU bit à bit), "^" (OU exclusif bit à bit) et "~" (NON bit à bit), permettent de réaliser des opérations de manipulation au niveau des bits au sein des données binaires, ce qui est utile pour effectuer des opérations de masquage, de décalage et de gestion de bits individuels dans les programmes.

Bit 1 Bit 2 & | ^ (XOR)
0 0 0 0 0
0 1 0 1 1
1 0 0 1 1
1 1 1 1 0

Remarque: Les valeurs ci-dessus (0 et 1) sont des bits binaires et non des valeurs entières.

1.17. Les opérateurs de manipulation de bits

int a = 0b01000100;
Opérateur Objectif Exemple Résultat
~ Négation ~a 0xffffffbb
& ET a & 0x4 0x4
| OR a | 0x2 0x46
^ XOR a ^ 0x4 0x40
<< décalage à gauche a << 1 0x88
>> décalage à droite a >> 1 0x22

1.18. Les opérateurs d'affectation

Les opérateurs d'affectation de bits en C, tels que "&=", "|=", "^=", "<<=", et ">>=" , sont utilisés pour combiner des opérations de manipulation de bits avec une opération d'affectation. Ils permettent de modifier les valeurs d'une variable en fonction du résultat d'une opération de manipulation de bits, ce qui simplifie la gestion des données au niveau des bits. Remarque: a op = b ::- a = a op b

Opérateur Objectif Exemple
= equal a = b
+= addition a += b
-= substraction a -= b
*= multiplication a *= b
/= division a /= b
%= modulo a %= b

1.18. Les opérateurs d'affectation

Opérateur Objectif Exemple
&= ET a &= b
|= OU a |= b
^= XOR a ^= b
<<= décalage à gauche a <<= b
>>= décalage à droite a >>= b

Remarque: a op = b ::- a = a op b

1.19. Structures de contrôle: les branchements conditionnels

if

if (condition) {
 ...
}

1.19. Structures de contrôle: les branchements conditionnels

if

int a = 20, b = 0;
if (a > b) {
 printf("a est supérieur à b");
}

L'objectif est de vérifier si la valeur de a est supérieure à celle de b et d'afficher un message si la condition est vraie.

1.19. Structures de contrôle: les branchements conditionnels

if

Les instructions if...else if...else permettent d'exécuter un bloc de code en fonction de plusieurs conditions alternatives.

if (condition1) {
 ...
} else if (condition2) {
 ...
} else {
 ...
}

1.19. Structures de contrôle: les branchements conditionnels

if

Les instructions if...else if...else permettent d'exécuter un bloc de code en fonction de plusieurs conditions alternatives.

if (condition1) {
 ...
} else if (condition2) {
 ...
} else {
 ...
}
Remarque 1: Toutes les nombres non nulles sont ont considérées comme vrai ('TRUE')
Remarque 2: else est optionnel

1.19. Structures de contrôle: les branchements conditionnels

if

int a = 20, b = 0;
if (a > b) {
 printf("a est supérieur à b");
} else if (a < b) {
 printf("a est inférieur à b");
} else {
 printf("a égale b");
}

1.20. Structures de contrôle: les branchements conditionnels (choix)

switch

switch est utilisée pour sélectionner une action à exécuter en fonction de la valeur de l'expression fournie.

switch (expression) {
 case valeur1 : instructions1
 case valeur2 : instructions2
 ...
 default : instructionsn
}

1.20. Structures de contrôle: les branchements conditionnels (choix)

switch

switch (expression) {
 case valeur1 : instructions1
 case valeur2 : instructions2
 ...
 default : instructionsn
}

1.20. Structures de contrôle: les branchements conditionnels (choix)

switch

int a = 20;
switch (a) {
 case 10 : instructions1
  break;
 case 20 : instructions2
 case 30 : instructions3
  break;
 ...
 default : instructionsn
}

Remarque:Le code exécute instructions2 et continue à exécuter instructions3 car il n'y a pas de break après instructions3.

1. Questions

Que sera-t-il affiché à l'écran suite à l'exécution de ce programme?

if (1) {
  printf("Hi");
} else {
  printf("Bonjour");
}

1.21. Structures de contrôle: les boucles

for

for(initialisation;condition;actualisation){
 ...
}

L'objectif de la boucle for en programmation est de répéter un bloc de code un certain nombre de fois en suivant les étapes suivantes

1.21. Structures de contrôle: les boucles

for

Ces étapes permettent de créer des boucles flexibles qui peuvent être utilisées pour parcourir des éléments d'une liste, effectuer des calculs répétitifs, ou exécuter des actions itératives. La boucle for est couramment utilisée pour simplifier la gestion des itérations dans un programme.

for(initialisation;condition;actualisation){
 ...
}

1.21. Structures de contrôle: les boucles

for

int a = 0;
for( a = 0; a < 10; a++){
 ...
}

L'objectif de ce code est d'initialiser la variable a à 0, puis de répéter un bloc de code tant que a est inférieur à 10, en augmentant la valeur de a à chaque itération.

1.21. Structures de contrôle: les boucles

for

int a = 0;
for(; a < 10; ){
 ...
}

L'objectif de ce code est de répéter un bloc de code tant que la variable a est inférieure à 10, en utilisant une initialisation préalable de a à 0 et en omettant l'actualisation de a à l'intérieur de la boucle.

Remarque: Une ou toutes les instructions d'initialisation, de condition ou d'actualisation peuvent être manquant.

1.21. Structures de contrôle: les boucles

for

int a = 0;
for( a = 0; a < 10; a++){
 ...
  a += 2 ;
 ...
}

L'objectif de ce code est d'initialiser la variable a à 0, puis de répéter un bloc de code tant que a est inférieur à 10, en augmentant la valeur de a de 2 à chaque itération à l'intérieur de la boucle, tout en incrémentant a de 1 avec l'opérateur a++ à chaque fin d'itération.

1.21. Structures de contrôle: les boucles

while

La boucle while maintient l'exécution d'un bloc de code tant que la condition entre les parenthèses reste vraie.

while(condition){
 ...
}

1.21. Structures de contrôle: les boucles

while

int a = 20;
while(a > 0){
 ...
 a--;
 ...
}

Ce code maintient la répétition d'un bloc de code tant que la valeur de la variable a est supérieure à 0, en la décrémentant à chaque itération.

1.21. Structures de contrôle: les boucles

while

int a = 0;
while(a < 20){
 ...
 a++;
 ...
}

Ce code vise à répéter un bloc de code tant que la valeur de la variable a est inférieure à 20, en l'incrémentant à chaque itération.

1.21. Structures de contrôle: les boucles

do..while

La boucle do..while garantit l'exécution d'un bloc de code au moins une fois avant de répéter son exécution tant que la condition spécifiée reste vraie.

do{
 ...
} while(condition);

1.21. Structures de contrôle: les boucles

do..while

int a = 20;
do{
 ...
  a --;
 ...
} while(a > 0);

Ce code exécute un bloc de code au moins une fois, puis le répète tant que la valeur de la variable a est supérieure à 0, en décrémentant a à chaque itération.

1.21. Structures de contrôle: les boucles

do..while

int a = 0;
do{
 ...
  a ++;
 ...
} while(a < 20);

Ce code garantit l'exécution d'un bloc de code au moins une fois, suivi de répétitions tant que la valeur de la variable a est inférieure à 20, en l'incrémentant à chaque itération.

1.22. Structures de contrôle: les sauts (branchements inconditionnels)

break

L'instruction break est utilisée pour interrompre prématurément l'exécution d'une boucle (par exemple, for ou while) ou d'un bloc de commutation switch. Lorsque break est rencontré, le programme sort immédiatement de la structure de contrôle dans laquelle il se trouve, sans attendre la fin normale de la condition ou de la boucle. Cela permet de quitter la structure dès qu'une condition souhaitée est atteinte ou lorsqu'une sortie anticipée est nécessaire.

do{
 ...
 if (condition 1) {
  ...
  break;
 }
 ...
} while(condition 2);

1.22. Structures de contrôle: les sauts (branchements inconditionnels)

break

do{
 ...
 if (condition 1) {
  ...
  break;
 }
 ...
} while(condition 2);

Ce code vise à exécuter un bloc de code au moins une fois, puis à répéter son exécution tant que condition 2 est vraie, tout en utilisant break pour sortir de la boucle si condition 1 est satisfaite.

1.22. Structures de contrôle: les sauts (branchements inconditionnels)

continue

L'instruction continue est utilisée pour passer immédiatement à l'itération suivante d'une boucle (par exemple, for ou while), en ignorant le reste du code à l'intérieur de la boucle pour cette itération particulière. Elle permet de sauter l'exécution des instructions restantes dans la boucle et de passer à la prochaine itération, ce qui est utile pour gérer des cas spécifiques sans quitter complètement la boucle.

do{
 ...
 if (condition 1) {
  ...
  continue;
 }
 ...
} while(condition 2);

1.22. Structures de contrôle: les sauts (branchements inconditionnels)

continue

do{
 ...
 if (condition 1) {
  ...
  continue;
 }
 ...
} while(condition 2);

Ce code a pour objectif d'exécuter un bloc de code au moins une fois, puis de le répéter tant que condition 2 est vraie, en utilisant continue pour sauter le reste du code dans une itération si condition 1 est satisfaite.

1.22. Structures de contrôle: les sauts (branchements inconditionnels)

break

while(condition 1){
 ...
 if (condition 2) {
  ...
  break;
 }
 ...
};

Dans ce code, l'objectif est d'exécuter un bloc de code tant que condition 1 est vraie, en utilisant break pour sortir de la boucle si condition 2 est satisfaite à l'intérieur de cette boucle.

1.22. Structures de contrôle: les sauts (branchements inconditionnels)

continue

while(condition 1){
 ...
 if (condition 2) {
  ...
  continue;
 }
 ...
};

Dans ce code, l'objectif est d'exécuter un bloc de code tant que condition 1 est vraie, en utilisant continue pour passer à l'itération suivante de la boucle si condition 2 est satisfaite à l'intérieur de cette boucle.

1.22. Structures de contrôle: les sauts (branchements inconditionnels)

break

for(initialisation;condition 1;actualisation){
 ...
 if (condition 2) {
  ...
  break;
 }
 ...
};

L'objectif de ce code avec la boucle "for" est d'initialiser une variable, puis de répéter un bloc de code tant que condition 1 est vraie, en utilisant break pour sortir de la boucle si condition 2 est satisfaite à l'intérieur de celle-ci.

1.22. Structures de contrôle: les sauts (branchements inconditionnels)

continue

for(initialisation;condition 1;actualisation){
 ...
 if (condition 2) {
  ...
  continue;
 }
 ...
};

L'objectif de ce code avec la boucle "for" est d'initialiser une variable, puis de répéter un bloc de code tant que condition 1 est vraie, en utilisant continue pour sauter le reste du code dans une itération si condition 2 est satisfaite à l'intérieur de la boucle.

1. Questions

Écrivez un programme qui affiche 0..20 en ordre croissant et décroissant utilisant for, while et do..while.

1. Questions

Écrivez un boucle infini en utilisant for, while, do..while.

1.23. Les tableaux

Tableau

Les tableaux sont des structures de données permettant de stocker un ensemble de valeurs du même type sous un même nom, organisées de manière séquentielle.

1.23. Les tableaux

Tableaux de tableaux

Les tableaux à deux indices sont des structures de données qui permettent de stocker des données dans une matrice rectangulaire.

Les tableaux à deux indices sont utiles pour stocker des données tabulaires, des images, des matrices, etc.

1.23. Les tableaux

Tableaux de tableaux

Les tableaux à plusieurs indices sont des structures de données permettant de stocker des données dans des dimensions multiples.

Les tableaux à plusieurs indices sont utilisés pour stocker des données tridimensionnelles, telles que des voxels dans une image 3D, des matrices 3D, des jeux de données multidimensionnels, etc.

1.23. Les tableaux

Déclaration: Tableaux de caractères

Pour déclarer un tableau, spécifiez le type des éléments qu'il contiendra, suivi du nom du tableau et de sa taille entre crochets.

par exemple

int tableau[5];

déclare un tableau d'entiers de taille 5.

char nom[20];

déclare un tableau de caractères (ou une chaîne de caractères) de taille 20.

Remarque: Langage C n'a pas un type nommé 'string'.

1.23. Tableaux

Déclaration: taille fixe

Les tableaux ont une taille fixe à la déclaration, qui ne peut pas être modifiée pendant l'exécution.

Exemple :

int itableau[20];
float ftableau[20];
double dtableau[20];

Objectif :

1.23. Tableaux

Initialisation: tableau à une dimension

Exemple :

int i;
int tableau[20];
for ( i = 0; i < 20; i++) {
 tableau[i] = i;
}

1.23. Les tableaux

Initialisation: tableau à une dimension

Exemple :

int prix[5] = { 11, 12, 13, 14, 15 };
int chambres[] = { 301, 302, 303 };
char message[] = "Bonjour Le Monde!!";

Remarque: Nous n'avons pas écrit la taille de chambres, message

1.23. Les tableaux

Initialisation: tableau à une dimension

Exemple :

int prix[5] = { 11, 12, 13, 14, 15 };
sizeof (prix) // 5 * sizeof(int)

1.23. Les tableaux

Initialisation: tableau à une dimension

Exemple :

int chambres[] = { 301, 302, 303 };
sizeof (chambres) // 3 * sizeof(int)

1.23. Les tableaux

Initialisation: tableau à une dimension

Exemple :

char message[] = "Bonjour Le Monde!!"; sizeof (message) // (18 + 1 (NULL)) * sizeof(char)

1.23. Les tableaux

Tableaux à deux indices

int prix[2][2] = {
  {11, 12},
  {13, 14}
};
sizeof (prix) // 2 * 2 * sizeof(int)

1.23. Les tableaux

Initialisation: Tableaux à deux indices

int chambres[][2] = {
  {201, 202},
  {301, 302}
};
sizeof (chambres) // 2 * 2 * sizeof(int)

Remarque: Nous n'avons pas précisé le nombre de lignes pour chambres.

1.23. Les tableaux

Initialisation: Tableaux à deux indices

char message[2][11] = {"Bonjour", "Le Monde!!"};
sizeof (message) // 2 * 11 * sizeof(char)

1. Programmation en C: Références

Références

Crédits d'images