Fiche de Révision : Langage C (Intermédiaire)

Table des matières

1. Les bases du langage C
2. Les structures conditionnelles
3. Les boucles
   • 3.1 Boucles simples
   • 3.2 Boucles imbriquées
4. Les pointeurs
5. La récursion
6. Les structures (struct)
7. Concepts avancés
   • 7.1 Gestion dynamique de la mémoire
   • 7.2 Fonctions et pointeurs de fonction
   • 7.3 Préprocesseur et macros
   • 7.4 Gestion des erreurs

Les bases du langage C

Le langage C est un langage de programmation impératif, bas niveau, utilisé pour la programmation système et les applications performantes.

• Structure d’un programme C minimal :

#include <stdio.h>

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

• Types de données principaux :

• Déclaration de variables :

int a = 5;
float pi = 3.14;
char c = 'A';

• Entrée/Sortie :

int x;
scanf("%d", &x);          // Lecture d'un entier
printf("Valeur: %d\n", x); // Affichage

Les structures conditionnelles

• Permettent d’exécuter des blocs de code en fonction de conditions booléennes.

1. if / else

if (a > 0) {
    printf("Positif\n");
} else {
    printf("Négatif ou nul\n");
}

2. else if

if (a > 0) {
    printf("Positif\n");
} else if (a == 0) {
    printf("Nul\n");
} else {
    printf("Négatif\n");
}

3. switch - multi-branches basées sur une expression entière

switch (a) {
    case 1:
        printf("Un\n");
        break;
    case 2:
        printf("Deux\n");
        break;
    default:
        printf("Autre\n");
}

Note: La structure switch ne supporte que les valeurs entières (ou énumérations).

Les boucles

Boucles simples

Les boucles permettent la répétition d’un bloc de code.

1. while (tant que la condition est vraie)

int i = 0;
while (i < 5) {
    printf("%d\n", i);
    i++;
}

2. do-while (exécute au moins une fois)

int i = 0;
do {
    printf("%d\n", i);
    i++;
} while (i < 5);

3. for (boucle avec initialisation, condition, incrément)

for (int i = 0; i < 5; i++) {
    printf("%d\n", i);
}

Boucles imbriquées

• Utiles pour parcourir des matrices ou générer des combinaisons.

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

Exemple : affichage d’une matrice 3x3

int matrix[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

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

Les pointeurs

Le pointeur est une variable qui contient l’adresse mémoire d’une autre variable.

• Déclaration :

int *p;    // p est un pointeur vers un int
int a = 10;
p = &a;    // p contient l'adresse de a

• Déréférencement :

printf("%d\n", *p); // Affiche la valeur pointée par p (ici 10)

• Utilisations fréquentes :

  • Passer des arguments par adresse (pour modifier des variables dans une fonction)
  • Manipuler des tableaux
  • Manipuler des structures
  • Allocation dynamique

Exemple : échange de deux valeurs via pointeurs

void swap(int *x, int *y) {
    int temp = *x;
    *x = *y;
    *y = temp;
}

int main() {
    int a = 5, b = 10;
    swap(&a, &b);
    printf("a = %d, b = %d\n", a, b);
}

La récursion

La récursion est une fonction qui s’appelle elle-même.

Exemple classique : calcul de la factorielle

[Formule mathématique]

int factorial(int n) {
    if (n == 0)
        return 1;
    else
        return n * factorial(n - 1);
}

Points importants

• Toujours définir un cas de base pour éviter la récursion infinie.
• La récursion peut être coûteuse en mémoire (pile d’appels).
• Certaines fonctions récursives peuvent être transformées en boucles.

Les structures (struct)

Permettent de regrouper plusieurs variables sous un même type.

Déclaration

struct Point {
    int x;
    int y;
};

Utilisation

struct Point p1;
p1.x = 10;
p1.y = 20;

Initialisation

struct Point p2 = {5, 15};

Passage en fonction

void printPoint(struct Point pt) {
    printf("(%d, %d)\n", pt.x, pt.y);
}

Note : On peut aussi utiliser typedef pour simplifier la syntaxe :

typedef struct {
    int x;
    int y;
} Point;

Point p3 = {1, 2};

Concepts avancés

Gestion dynamique de la mémoire

En C, la mémoire peut être allouée dynamiquement avec malloc, calloc, realloc et libérée avec free.

int *arr = malloc(5 * sizeof(int)); // allocation mémoire pour 5 int
if (arr == NULL) {
    // Gestion erreur allocation
}

for (int i = 0; i < 5; i++) {
    arr[i] = i * i;
}

free(arr); // libération mémoire

Important : Toujours libérer la mémoire allouée pour éviter les fuites.

Fonctions et pointeurs de fonction

• Pointeur vers une fonction permet de passer des fonctions en argument, utile pour callbacks.

int add(int a, int b) {
    return a + b;
}

int operate(int (*func)(int, int), int x, int y) {
    return func(x, y);
}

int main() {
    int result = operate(add, 3, 4);
    printf("%d\n", result);  // Affiche 7
}

Préprocesseur et macros

• Le préprocesseur fait du traitement avant compilation.

Directives courantes

• #include : inclusion de fichiers
• #define : définition de macros

#define PI 3.14159
#define MAX(a,b) ((a) > (b) ? (a) : (b))

Attention : Les macros ne sont que du texte substitué, attention aux effets de bord.

Gestion des erreurs

• Le langage C ne supporte pas les exceptions.
• Utilisation classique : codes de retour et errno.

#include <errno.h>
#include <stdio.h>

FILE *f = fopen("file.txt", "r");
if (!f) {
    perror("Erreur ouverture fichier");
    return 1;
}

Diagramme Mermaid : Relations entre concepts du langage C

[Diagramme]

Résumé des points clés

• Bases : types, variables, entrée/sortie, fonctions main()
• Conditions : if, else if, else, switch
• Boucles : for, while, do-while, imbriquées pour tableaux multidimensionnels
• Pointeurs : manipulation d’adresses, passage par référence, tableaux dynamiques
• Récursion : cas de base indispensable, exemples classiques (factorielle, Fibonacci)
• Structures : regroupement de données complexes, typedef pour simplifier
• Concepts avancés : mémoire dynamique, pointeurs de fonction, macros, gestion des erreurs

Citation importante :

« Le langage C offre un contrôle précis du matériel grâce à la manipulation des pointeurs et à la gestion fine de la mémoire, mais cela nécessite une rigueur extrême pour éviter bugs et fuites mémoire. »

Cette fiche couvre les notions intermédiaires essentielles du langage C. Pour approfondir, il est conseillé de pratiquer avec des exercices impliquant manipulation de pointeurs, récursion et gestion dynamique de structures complexes.