Fiche de révision : Programmation en C

📋 Plan du Cours

1. Structure et compilation d’un programme
2. Variables, types et opérations
3. Booléens, chaînes et affectations
4. Conditions, boucles et fonctions
5. Tableaux et chaînes en mémoire
6. Pointeurs et passage d’adresses
7. Allocation dynamique et tableaux 2D
8. Structures et pointeurs de structures

📖 1. Structure et compilation d’un programme

🔑 Notions clés & Définitions

• Fonction main : Le point de départ obligatoire d’un programme C et renvoie généralement un entier avec la déclaration int main().

★ À maîtriser

• La compilation transforme un fichier .c en exécutable avec une commande comme gcc programme.c -o programme, puis l’exécutable peut être lancé avec ./programme.

Compléments

• En C, #include <stdio.h> fournit notamment les fonctions d’entrée-sortie comme printf, les accolades délimitent un bloc, le point-virgule termine une instruction et return 0 termine normalement main.

💡 Astuce mémo

fichier .c → compilateur → exécutable

📖 2. Variables, types et opérations

🔑 Notions clés & Définitions

• Variable : Une zone mémoire identifiée par un nom, et son type reste fixe pendant l’exécution dans un langage C à typage statique.

★ À maîtriser

• Les types essentiels comprennent:
  • int pour les entiers
  • unsigned int pour les entiers non signés
  • float pour les flottants 32 bits
  • double pour les flottants 64 bits
  • char pour les caractères
  • bool pour les booléens
  • void pour l’absence de valeur de retour

📐 Formule — La division entre deux entiers est entière, ainsi $3 / 2 = 1$, tandis qu’une opération entre un entier et un flottant produit un flottant, ainsi $7.0 / 2 = 3.5$.

Compléments

📌 L’opérateur % donne le reste de la division entière, et une expression comme n % 2 == 0 permet de tester si n est pair.

💡 Astuce mémo

entier 7/2 = 3, flottant 7.0/2 = 3.5

📖 3. Booléens, chaînes et affectations

★ À maîtriser

📌 L’opérateur = réalise une affectation, tandis que l’opérateur == réalise une comparaison d’égalité.

• L’évaluation paresseuse de x && y cesse d’évaluer y lorsque x est faux, tandis que celle de x || y cesse d’évaluer y lorsque x est vrai.

• Un caractère s’écrit entre guillemets simples comme 'a', tandis qu’une chaîne s’écrit entre guillemets doubles comme "abc".

Compléments

• Les caractères spéciaux principaux sont:
  • '\n' pour le retour à la ligne
  • '\t' pour la tabulation
  • '\0' pour le caractère nul

💡 Astuce mémo

= affecte, == compare ; guillemets simples pour char, doubles pour chaîne

📖 4. Conditions, boucles et fonctions

🔑 Notions clés & Définitions

• Fonction : Associe un nom, des paramètres, un type de retour et un bloc d’instructions, puis renvoie éventuellement une valeur avec return.

📝 Points essentiels

• Une boucle while répète son corps tant que sa condition est vraie, tandis qu’une boucle for regroupe une initialisation, une condition et une mise à jour.

📌 Dans une boucle, break sort immédiatement de la boucle, tandis que continue ignore la fin du tour courant et passe au suivant.

• Une fonction récursive doit comporter un cas de base qui arrête les appels et un appel récursif qui réduit le problème, comme somme(n) appelant somme(n - 1) jusqu’à n == 0.

💡 Astuce mémo

condition → corps de boucle → mise à jour

📖 5. Tableaux et chaînes en mémoire

🔑 Notions clés & Définitions

• Tableau : Contient plusieurs valeurs du même type stockées consécutivement en mémoire, et son premier élément possède l’indice 0.
• Chaîne de caractères : Un tableau de char terminé obligatoirement par le caractère nul '\0', et une chaîne écrite char* s = "Bonjour" est immuable.

★ À maîtriser

📌 Le C ne vérifie pas automatiquement les indices d’un tableau, si bien qu’un accès comme t[7] dans un tableau int t[5] peut provoquer une modification mémoire, une erreur de segmentation ou un comportement imprévisible.

Compléments

📌 La déclaration int t[5] = {0} initialise toutes les cases à zéro, tandis que int t[5] seul n’initialise pas automatiquement les cases.

💡 Astuce mémo

un tableau de cases contiguës terminé par \0 pour une chaîne

📖 6. Pointeurs et passage d’adresses

🔑 Notions clés & Définitions

• Pointeur : Une variable qui contient une adresse mémoire, par exemple int* p peut contenir l’adresse d’une variable int.

📝 Points essentiels

📌 Pour une variable x, &x désigne son adresse mémoire, tandis que *p désigne la valeur située à l’adresse contenue dans p.

📌 Les arguments C sont passés par valeur, donc une fonction void f(int x) modifie seulement la copie locale x et ne modifie pas la variable originale.

• Pour modifier une variable dans une fonction, il faut transmettre son adresse avec f(&x), recevoir un pointeur avec void f(int* p), puis modifier la valeur avec *p = 10.

💡 Astuce mémo

& donne l’adresse, * donne la valeur à cette adresse

📖 7. Allocation dynamique et tableaux 2D

★ À maîtriser

• L’allocation dynamique d’un entier réserve la mémoire avec int* p = malloc(sizeof(int)), permet son utilisation via *p, puis impose sa libération avec free(p).

📌 NULL représente un pointeur qui ne désigne aucune zone mémoire valide et ne doit jamais être déréférencé avec *p lorsque p == NULL.

📐 Formule — Un tableau dynamique de n entiers se réserve avec $int* t = malloc(sizeof(int) * n)$, et l’expression *t est équivalente à t[0].

Compléments

📐 Formule — Dans un tableau 2D dynamique de n lignes et m colonnes, la position linéarisée de l’élément (i,j) est $p = m i + j$, avec $i = p / m$ et $j = p \% m$ pour retrouver ses coordonnées.

💡 Astuce mémo

malloc → utilisation → free

📖 8. Structures et pointeurs de structures

🔑 Notions clés & Définitions

• Structure : Regroupe plusieurs données éventuellement de types différents sous un même type comme struct personne.
• Structure récursive : Contient un pointeur vers une structure du même type, et NULL peut indiquer l’absence d’un élément suivant.

📝 Points essentiels

📌 Pour une structure normale p, l’accès à un champ s’écrit p.age, tandis que pour un pointeur vers structure p, l’accès abrégé s’écrit p->age et équivaut à (*p).age.

📌 Une structure passée normalement à une fonction est copiée, tandis qu’un pointeur vers structure permet de modifier la structure originale avec p->champ.

💡 Astuce mémo

p.age pour une structure, p->age pour un pointeur

📊 Tableaux de synthèse

Expressions de pointeurs

Comparaison des accès aux structures