Opérateurs C : Incrémentation et Conditions

Points Clés de la Programmation C

Cette note résume les concepts fondamentaux de la programmation en langage C, de la syntaxe de base aux structures de contrôle avancées, en passant par la gestion de la mémoire et les fonctions.

I. Opérateurs d'Incrémentation et de Décrémentation

• Post-incrémentation/décrémentation: L'opération est effectuée après que la valeur de la variable soit utilisée dans l'expression.
  • i++; équivaut à i = i + 1; ou i += 1;
  • i--; équivaut à i = i - 1; ou i -= 1;
• Pré-incrémentation/décrémentation: L'opération est effectuée avant que la valeur de la variable ne soit utilisée dans l'expression.
  • ++i;
  • --i;
• Exemple:
  1. int i = 5; int a = i++; → a sera 5, puis i devient 6.
  2. int i = 5; int a = ++i; → i devient 6, puis a sera 6.

II. Conditions Booléennes

Expriment une valeur vraie ou fausse.

• Opérateurs de comparaison:
  • a == b: Vrai si a est égal à b. (Attention au double =)
  • a != b: Vrai si a est différent de b.
  • a < b: Vrai si a est strictement inférieur à b.
  • a > b: Vrai si a est strictement supérieur à b.
  • a <= b: Vrai si a est inférieur ou égal à b.
  • a >= b: Vrai si a est supérieur ou égal à b.
• Combinaison de conditions:
  • Condition1 && Condition2: Vrai si les deux conditions sont vraies. (Attention au double &&)
  • Condition1 || Condition2: Vrai si au moins une des deux conditions est vraie. (Attention au double ||)
  • !Condition1: Vrai si Condition1 est fausse.

III. Structures de Contrôle Conditionnel

A. Instruction if-else

Permet d'exécuter du code de manière conditionnelle.

• Syntaxe de base:

  if (condition) expression1;
  else expression2; // La partie 'else' est facultative

• Multiples instructions: Utiliser des accolades { } pour regrouper plusieurs lignes de code.

  if (condition) {
      Ligne A1;
      Ligne A2;
  } else {
      Ligne B1;
      Ligne B2;
  }

• Conditions en cascade: else if permet de tester plusieurs conditions successives.

  if (condition1) {
      // Instructions si condition1 est vraie
  } else if (condition2) {
      // Instructions si condition1 est fausse et condition2 est vraie
  } else {
      // Instructions si toutes les conditions précédentes sont fausses
  }

• Règle d'or: Toujours commencer par l'organigramme avant d'écrire le programme.

B. Instruction switch-case

Alternative au if-else if pour tester une variable contre plusieurs valeurs constantes.

• Syntaxe:

  switch (expression) { // expression doit être un entier (int ou char)
      case constante_1:
          instructions_1;
          break; // Sort du switch
      case constante_2:
          instructions_2;
          break;
      default: // Facultatif
          instructions_3;
  }

• Rôle de break;: Sans break;, l'exécution "tombe" dans le cas suivant (fall-through).
• Le bloc default est exécuté si aucune constante ne correspond à l'expression.

IV. Tableaux

Collections de variables du même type, accessibles par un index.

A. Tableaux à une dimension

• Déclaration: int tab[10]; (tableau de 10 entiers)
• Accès aux éléments: Les indices commencent à 0.
  • Premier élément: tab[0]
  • Dernier élément: tab[9] (pour un tableau de taille 10)
• Initialisation:
  • int z[] = {0, 5, 3}; (crée un tableau de 3 éléments)
  • Le contenu n'est pas initialisé par défaut lors de la déclaration seule.

B. Tableaux à deux dimensions

• Déclaration: int tab[5][10]; (5 lignes, 10 colonnes)
• Convention: Premier indice pour les lignes, second pour les colonnes.
• Initialisation:

  int valeurs[3][4] = {
      {1,2,3,4},
      {5,6,7,8},
      {9,10,11,12}
  };

V. Boucles

Permettent des répétitions d'instructions.

A. Boucle for

Utilisée quand le nombre d'itérations est connu d'avance.

• Syntaxe:

  for ( Avant ; Condition ; dernière instruction ) {
      Instructions ;
  }

• Avant: Initialisation du compteur.
• Condition: Critère de continuation de la boucle.
• Dernière instruction: Incrémentation/décrémentation du compteur.
• Attention: Un point-virgule ; après la parenthèse du for termine la boucle immédiatement, rendant le bloc d'instructions suivant indépendant du for.
• Parcourir un tableau à une dimension:
  • Du premier au dernier: for (i = 0; i < nbcases; i++) {...}
  • Du dernier au premier: for (i = nbcases - 1; i >= 0; i--) {...}
• Parcourir un tableau à deux dimensions: Nécessite des boucles imbriquées.

  for (CbLigne = 0; CbLigne < nbLigne; CbLigne++) {
      for (CbColonne = 0; CbColonne < nbColonne; CbColonne++) {
          // Manipuler Tab[CbLigne][CbColonne]
      }
  }

B. Boucle while

Répète un bloc d'instructions tant qu'une condition reste vraie.

• Syntaxe:

  Avant;
  while (Condition) {
      Instructions;
  }

• La condition est évaluée avant chaque itération. Si initialement fausse, le corps de la boucle n'est jamais exécuté.
• Une boucle while(1) { ... } crée une boucle infinie.

C. Boucle do-while

Similaire au while, mais garantit que le corps de la boucle est exécuté au moins une fois.

• Syntaxe:

  Avant;
  do {
      Instructions;
  } while (Condition);

• La condition est évaluée après chaque itération.

D. Instruction break dans les boucles

• break met fin immédiatement à la boucle la plus interne où il est utilisé.
• Utilisation: Classique et recommandée avec switch-case.
• Déconseillé: Éviter si possible dans les boucles while, do-while, for pour maintenir la clarté du code.

VI. Fonctions

Blocs de code réutilisables qui effectuent une tâche spécifique.

A. Concept

• Similaire à une fonction mathématique y = f(x): prend des entrées et produit une sortie.
• Peut prendre zéro, une ou plusieurs variables en entrée.
• Peut retourner une seule valeur, ou aucune (fonction void).
• Chaque entrée et la sortie ont un type défini.

B. Définition et Appel

• Prototype (déclaration): Indique le type de retour, le nom de la fonction et les types/noms des paramètres.

  int maFonction(int param1, float param2);

  Le nom des paramètres dans le prototype est facultatif.
• Appel: Exécute la fonction avec des arguments.

  resultat = maFonction(var_int, var_float);

  Les types des arguments doivent correspondre aux types des paramètres du prototype.
• Définition: Le corps de la fonction où le traitement est implémenté.

  int maFonction(int param1, float param2) {
      // Instructions
      return valeur_de_retour;
  }

C. Passage de Paramètres

• Passage par valeur (par défaut): Les arguments sont copiés dans les paramètres de la fonction.
  • Toute modification des paramètres à l'intérieur de la fonction n'affecte pas les variables originales dans la fonction appelante (par exemple, main).
  • Les variables dans la fonction appelante et les paramètres de la fonction appelée sont des emplacements mémoire différents (variables locales).

  void mult2(int x, int fact) {
      x = fact * x; // Modifie la copie locale de x, pas l'original
  }

• Passage par référence (avec pointeurs): Transmet l'adresse des variables à une fonction.
  • Permet à la fonction de modifier directement les variables originales.
  • Indispensable pour retourner plusieurs "résultats" d'une fonction.

  void mult2(int *Ptx, int fact) {
      *Ptx = fact * (*Ptx); // Modifie la valeur à l'adresse pointée par Ptx
  }

• Passage de tableaux: Lorsque vous passez un tableau à une fonction, son nom est traité comme un pointeur vers son premier élément.
  • Il n'y a pas de copie locale du tableau. La fonction manipule directement le tableau original.
  • Conséquence: Les modifications sur le tableau dans la fonction affectent le tableau original.
  • La taille du tableau n'est pas connue dans la fonction, il faut la passer en paramètre.

    void maFonctionTableau(int tableau[], int taille);

    ou

    void maFonctionTableau(int *tableau, int taille);

VII. Pointeur

Variable qui stocke une adresse mémoire. Un concept crucial en C.

A. Déclaration et Utilisation

• Un pointeur contient l'adresse du premier octet d'une variable.
• Déclaration: Ajouter * après le type.
  • int *Pta; (Pointeur vers un entier)
  • float *PtrFloat; (Pointeur vers un flottant)
• Obtenir l'adresse d'une variable: Utiliser l'opérateur & (adresse de).
  • int a = 2; Pta = &a; (Pta contient l'adresse de a)
• Accéder à la valeur pointée: Utiliser l'opérateur * (contenu de l'adresse).
  • *Pta = *Pta + 1; (Ajoute 1 à la valeur stockée à l'adresse pointée par Pta, soit la valeur de a)
• Règle d'or: Toujours initialiser les pointeurs pour éviter des accès mémoire aléatoires et des plantages.

B. Allocation Dynamique de Mémoire

Permet de réserver de la mémoire pendant l'exécution du programme.

• malloc(): Alloue un bloc de mémoire.

  int *Pta;
  Pta = (int *) malloc(sizeof(int)); // Alloue de la mémoire pour un seul entier

  • sizeof(type): Retourne la taille en octets du type.
  • malloc(): Retourne un pointeur de type void* vers le début de la zone allouée. Un cast est nécessaire ((int *)).
  • En cas d'échec (mémoire insuffisante), malloc() retourne NULL.
• free(): Libère la mémoire précédemment allouée par malloc().

  free(Pta);

  Indispensable pour éviter les fuites de mémoire (memory leaks).

VIII. Pseudo-Code

Méthodologie pour organiser un programme avant l'écriture du code réel. Forme allégée et indépendante du langage.

• Mots clés courants:
  • LIRE: Saisie (e.g., scanf())
  • ECRIRE ou AFFICHER: Affichage (e.g., printf())
  • FIN: Fin du programme (e.g., return 0;)
• Affectation: Utilise la flèche ← (e.g., Variable1 ← Valeur)
• Structures conditionnelles: SI ... ALORS ... SINON SI ... SINON ... FIN SI
• Structures de test: SELON expression ... : action ... SINON ... FIN SELON
• Boucles:
  • TANT QUE condition FAIRE action FIN TANT QUE
  • REPETER action TANT QUE condition
  • POUR variable allant de val_debut à val_fin FIN POUR
• Démarche recommandée: Identifier les variables → Écrire le pseudo-code/organigramme → Écrire le programme (avec commentaires et noms parlants).

IX. Entrées/Sorties Standard (stdio.h)

A. Affichage: printf()

• Syntaxe de base: printf("texte à afficher\n");
• Spécificateurs de format: Indiquent le type de la variable à afficher.

  Type/Variable	Format	Description
  int, short, long	%d, %hd, %ld	Décimal
  	%o, %ho, %lo	Octal
  	%x, %hx, %lx	Hexadécimal (minuscule)
  	%X, %hX, %lX	Hexadécimal (majuscule)
  float, double, long double	%f, %lf, %Lf	Décimal (point)
  	%e, %le, %Le	Exponentiel (minuscule)
  	%g, %lg, %Lg	Le plus court des deux (f ou e)
  char	%c	Caractère
  char[] (chaîne de caractères)	%s	Chaîne de caractères
  Pointeur	%p	Adresse (hexadécimal)

• Options de format: Largeur, précision, alignement, signe.
  • %10d: Largeur minimale de 10 caractères.
  • %.6f: 6 chiffres après la virgule pour un flottant.
  • %06d: Remplissage par des zéros sur 6 chiffres.
  • %+d: Affiche toujours le signe.
  • %#x: Préfixe 0x pour l'hexadécimal.

B. Saisie: scanf()

• Syntaxe: scanf("format", &variable);
• Important: Il faut toujours passer l'adresse de la variable (avec &) où stocker la valeur saisie, sauf pour les chaînes de caractères (car le nom du tableau est déjà une adresse).
• Exemple: scanf("%d", &Nbr1);
• Exemple pour chaîne: scanf("%s", str); (str est déjà un pointeur).

X. Opérateurs Arithmétiques et Priorités

• Opérateurs:
  • -: Unaire (changement de signe) - priorité supérieure.
  • *, /, % (modulo): Multiplicatifs - priorité moyenne.
  • +, -: Additifs - priorité inférieure.
• La priorité détermine l'ordre d'évaluation des opérations. Les parenthèses ( ) forcent un ordre d'évaluation.
• En cas de même priorité, l'évaluation se fait de gauche à droite.

XI. Conversions de Types (Type Casting)

• Conversions implicites: Se produisent automatiquement lors d'opérations entre types différents. Le résultat intermédiaire prend le type le "plus précis".

  short → int → long → float → double → long double

  Exemple: int a; double c; double d = a * c; (→ a est converti en double avant la multiplication).
• Conversions explicites (cast): Forcer une conversion de type.

  int a; double b;
  a = (int)b; // Convertit b en entier (possible perte de précision)

  Pour garantir la précision dans les calculs impliquant des entiers et des flottants:

  d = (double)a / (double)b * c;

XII. Chaînes de Caractères

• Les chaînes sont des tableaux de caractères, terminés par le caractère nul '\0' (code ASCII 0x0).
• Déclaration et initialisation:
  • char chaine1[] = "exemple"; (le compilateur ajoute '\0' et détermine la taille).
  • char str[33]; (pour une chaîne de 32 caractères maximum + '\0').
• Les guillemets doubles " " sont utilisés pour les chaînes, les apostrophes simples ' ' pour les caractères seuls.
• Caractères d'échappement (ex: \n pour nouvelle ligne, \t pour tabulation).