Programmation en langage C

Introduction au Langage C

• Présentation du langage C, ses origines et ses avantages
• Comparaison avec d'autres langages comme C++, Java et ses concurrents

Pré-requis Techniques

• Installation d'un éditeur de texte et d'un compilateur C
• Configuration de l'environnement de développement

Utilisation du Terminal

• Démonstration des commandes de base du terminal
• vim pour créer, éditer, enregistrer et quitter un fichier
• Compilation d'un programme C
• Exécution d'un fichier exécutable.
• Commandes cd pour changer de répertoire
• Commande ls -all pour lister le contenu d'un répertoire et comprendre les droits sur les fichiers (notamment les indicateurs drwx et les droits)
• Explication des fichiers exécutables et de la signification des droits sur un fichier
• Utilisation de cat pour lire le contenu d'un fichier
• Création d'un fichier vide avec la commande touch

Hello World

• Création d'un programme "Hello World" en C
• Analyse des lignes de code
• Exécution manuelle du programme pour comprendre son fonctionnement

Syntaxe de Base

• Affichage à l'écran en mode console
• Utilisation de commentaires
• Introduction aux types de variables : int, float, char
• Affichage des variables à l'écran
• Opérations de base (+, -, =)
• Création et appel de fonctions pour améliorer la lisibilité du code

Compréhension des Types de Variables

• Revue du système binaire pour comprendre les limites des types de variables
• Gestion des débordements en explorant les valeurs maximales et minimales que les variables peuvent stocker

Fonctions et modularité

1. Définition et appel de fonctions
2. Passer des arguments aux fonctions
3. La fonction `main` et les arguments de ligne de commande (`argc` et `argv`)
   1. Description de `argc` (argument count) et `argv` (argument vector)
   2. Exemples d'utilisation pour lire les arguments de ligne de commande
   3. Manipulation des arguments pour diverses opérations

   • Présentation de argc et argv en C

     En langage C, argc et argv sont des paramètres de la fonction main utilisés pour récupérer les arguments passés à un programme lors de son exécution. Ils permettent à un programme d'interagir avec la ligne de commande, ce qui est essentiel pour de nombreuses applications.

     Définition

     1. argc (argument count)

        1. Type : int
        2. Description : Représente le nombre d'arguments passés au programme, y compris le nom du programme lui-même.
        3. Exemple : Si le programme est exécuté avec ./monprogramme arg1 arg2, alors argc vaut 3.

     2. argv (argument vector)

        1. Type : char *argv[] (tableau de chaînes de caractères)
        2. Description : Contient les arguments passés au programme. Chaque élément du tableau est une chaîne de caractères représentant un argument.
        3. Exemple : Si le programme est exécuté avec ./monprogramme arg1 arg2, alors argv est un tableau de chaînes contenant ["./monprogramme", "arg1", "arg2"].

     Structure de la fonction main

     La signature de la fonction main utilisant argc et argv est :

                         
                     int main(int argc, char *argv[]) 
                     {
                         // Code du programme
                     }
                          
                      

     Exemple de Code

                     
                     //utilisation de argc et argv pour lire et afficher les arguments de la ligne de commande
                     #include <stdio.h>
     
                     int main(int argc, char *argv[]) 
                     {
                         // Affiche le nombre d'arguments
                         printf("Nombre d'arguments : %d\n", argc);
     
                         // Affiche chaque argument
                         for (int i = 0; i < argc; i++) {
                             printf("Argument %d : %s\n", i, argv[i]);
                         }
     
                         return 0;
                     }
                     
                 

     Exemple d'exécution

     Si le programme ci-dessus est compilé (dans un fichier nommé arguments.c) et exécuté avec les arguments suivants :

                         
                         gcc -o arguments arguments.c
                         ./arguments Hello World
                         
                     

     La sortie serait :

                         
                             Nombre d'arguments : 3
                             Argument 0 : ./arguments
                             Argument 1 : Hello
                             Argument 2 : World
                             Analyse de la sortie
                             Nombre d'arguments : 3 :
                         
                     

     1. Le programme indique qu'il a reçu 3 arguments. Cela inclut le nom du programme lui-même.
     2. Argument 0 : ./arguments :Le premier argument (index 0) est toujours le nom du programme exécuté.
     3. Argument 1 : Hello : Le deuxième argument (index 1) est le premier argument réel passé à la ligne de commande, ici "Hello".
     4. Argument 2 : World : Le troisième argument (index 2) est le deuxième argument réel, ici "World".

     Conclusion

     L'utilisation de argc et argv en C est une méthode puissante pour passer des informations à un programme via la ligne de commande. Elle permet de rendre les programmes plus flexibles et interactifs. La compréhension de ces paramètres est essentielle pour tout développeur travaillant en C, car elle ouvre la porte à une large gamme d'applications, des utilitaires simples aux systèmes complexes de traitement de données.

Bibliothèque Standard C

    
#include <stdio.h>

int main() 
{
int nombre;
printf("Entrez un nombre : ");
scanf("%d", &nombre);
printf("Vous avez entré : %d\n", nombre);
            
return 0;
}
    

#include  <stdio.h>
#include  <string.h>
        
int main() 
{
  char chaine1[] = "Bonjour";
  char chaine2[] = "Monde";
  char chaine3[100]; // Tampon pour le résultat
            
  // Copie de chaine1 dans chaine3
  strcpy(chaine3, chaine1);
            
  // Concaténation de chaine2 à la fin de chaine3
  strcat(chaine3, chaine2);
            
  printf("Résultat : %s\n", chaine3);
            
  return 0;
}

#include  <stdio.h>
#include  <string.h>
        
int main() 
{
  char chaine1[] = "Bonjour";
  char chaine2[] = "Monde";
  char chaine3[100]; // Tampon pour le résultat
            
  // Copie de chaine1 dans chaine3
  strcpy(chaine3, chaine1);
            
  // Concaténation de chaine2 à la fin de chaine3
  strcat(chaine3, chaine2);
            
  printf("Résultat : %s\n", chaine3);
            
  return 0;
}

L'Adresse Mémoire, les Pointeurs, les Tableaux et l'Allocation Dynamique

1. Les pointeurs

   Les pointeurs en langage C sont des variables qui stockent l'adresse mémoire d'une autre variable. Ils offrent un moyen puissant de manipuler directement la mémoire, permettant un accès efficace et flexible aux données.

   1. Déclaration de Pointeurs

      La déclaration d'un pointeur se fait en indiquant le type de données qu'il pointe, suivi d'une étoile (*). Exemple :

      int *ptr; // Déclaration d'un pointeur vers un entier

      Cela indique que ptr est un pointeur vers un entier. La variable pointée peut être n'importe quelle variable de type entier.

   2. Obtenir l'Adresse d'une Variable

      L'opérateur "address-of" (&) est utilisé pour obtenir l'adresse mémoire d'une variable. Par exemple :

      
                              int x = 10;
                              int *ptr = &x;  // Pointeur ptr stocke l'adresse de x
                              

   3. Accéder à la Valeur Pointée par un Pointeur

      L'opérateur de déréférencement (*) est utilisé pour accéder à la valeur pointée par un pointeur. Exemple :

      int y = *ptr; // y prend la valeur stockée à l'adresse pointée par ptr

   4. Utilisation des Pointeurs dans les Fonctions

      Les pointeurs sont souvent utilisés pour permettre à une fonction de modifier directement la valeur d'une variable en dehors de la fonction. Exemple :

                                  
                                  void modifierValeur(int *ptr) {
                                      *ptr = 42;
                                  }
      
                                  int main() {
                                      int variable = 10;
                                      modifierValeur(&variable);  // Passer l'adresse de la variable à la fonction
                                      // Maintenant, variable a la valeur 42
                                      return 0;
                                  }
                                  
                              

   5. Pointeurs et Tableaux

      En C, les tableaux peuvent être manipulés à l'aide de pointeurs. Par exemple :

                                  
                                  int tableau[3] = {1, 2, 3};
                                  int *ptr = tableau;  // Pointeur pointant vers le début du tableau
      
                                  // Accéder aux éléments du tableau via le pointeur
                                  int premierElement = *ptr;   // Équivalent à tableau[0]
                                  int deuxiemeElement = *(ptr + 1);  // Équivalent à tableau[1]
                                  
                              

   Les pointeurs en langage C offrent donc une puissance significative, mais ils nécessitent une gestion prudente de la mémoire. Ils sont indispensables pour des tâches avancées telles que la manipulation de structures de données complexes, l'allocation dynamique de mémoire et le passage efficace de paramètres entre fonctions. Comprendre les pointeurs est essentiel pour maîtriser le développement en langage C.

2. L'Allocation Dynamique en Langage C

   1. Introduction

      L'allocation dynamique de la mémoire est un concept fondamental en programmation. En langage C, cela permet de réserver de la mémoire à l'exécution, contrairement à l'allocation statique où la taille de la mémoire est déterminée à la compilation. L'allocation dynamique est particulièrement utile lorsque la taille de la mémoire nécessaire n'est connue qu'au moment de l'exécution du programme.
      L'allocation dynamique en langage C peut être utilisée dans de nombreux scénarios pour gérer efficacement la mémoire à l'exécution.

      Exemples:

      1. Tableaux de taille variable : Lorsque la taille d'un tableau n'est pas connue à l'avance ou peut varier pendant l'exécution du programme, l'allocation dynamique permet de créer des tableaux de taille variable.
      2. Listes chaînées : Les structures de données telles que les listes chaînées peuvent être implémentées en utilisant l'allocation dynamique pour allouer de la mémoire pour chaque nœud au fur et à mesure qu'ils sont ajoutés à la liste.
      3. Piles et files : Les piles et les files peuvent être implémentées en utilisant des tableaux dynamiques, où la taille de la pile ou de la file peut croître ou diminuer dynamiquement en fonction des opérations effectuées.
      4. Matrices dynamiques : Si la taille d'une matrice n'est pas connue à la compilation, l'allocation dynamique peut être utilisée pour allouer de la mémoire pour une matrice dont les dimensions sont déterminées à l'exécution.
      5. Traitement de chaînes de caractères : En travaillant avec des chaînes de caractères de longueur variable, l'allocation dynamique permet de réserver la mémoire nécessaire pour stocker ces chaînes, sans avoir à spécifier une taille fixe à l'avance.
      6. Lecture de fichiers de taille inconnue : Lors de la lecture de fichiers dont la taille est inconnue à l'avance, l'allocation dynamique peut être utilisée pour stocker les données lues en mémoire de manière flexible.
      7. Gestion de structures de données complexes : Dans des applications nécessitant la manipulation de structures de données complexes et variables, telles que les arbres ou les graphes, l'allocation dynamique permet d'allouer et de libérer la mémoire au besoin pour ces structures.

   2. Fonctions de l'allocation dynamique en C

      En langage C, l'allocation dynamique est gérée par les fonctions suivantes, déclarées dans l'en-tête stdlib.h :

      • malloc() : Cette fonction alloue une zone de mémoire de taille donnée et renvoie un pointeur vers le début de cette zone.
      • calloc() : Cette fonction alloue de la mémoire pour un certain nombre d'objets de taille donnée, initialisant tous les bits à zéro, et renvoie un pointeur vers le début de cette zone.
      • realloc() : Cette fonction permet de modifier la taille d'un bloc de mémoire déjà alloué, et renvoie un pointeur vers le début de ce bloc.
      • free() : Cette fonction libère la mémoire précédemment allouée par malloc(), calloc() ou realloc().

      Les fonctions malloc, calloc, et realloc sont toutes utilisées pour allouer de la mémoire dynamiquement en langage C, mais elles diffèrent légèrement dans leur fonctionnement et leur utilisation.

      1. malloc

         1. malloc : Le nom "malloc" signifie "allocation de mémoire" et indique simplement que cette fonction est utilisée pour allouer de la mémoire dynamiquement.
         2. La fonction malloc (memory allocation) est utilisée pour allouer un bloc de mémoire de taille donnée en octets.
         3. Syntaxe :

            void* malloc(size_t size);

         4. Elle prend en argument la taille en octets du bloc de mémoire à allouer.
         5. Elle renvoie un pointeur vers le début de la mémoire allouée, ou NULL si l'allocation échoue.
         6. Elle n'initialise pas le contenu de la mémoire allouée, laissant les valeurs indéterminées.

      2. calloc

         • calloc : Le nom "calloc" signifie "allocation contiguë" et fait référence au fait que cette fonction alloue de la mémoire pour un certain nombre d'objets consécutifs, en les initialisant à zéro.
         • La fonction calloc (contiguous allocation) est utilisée pour allouer de la mémoire pour un certain nombre d'objets de taille donnée, et initialise tous les bits à zéro.
         • Syntaxe :

           void* calloc(size_t num_elements, size_t element_size);

         • Elle prend en argument le nombre d'éléments et la taille en octets de chaque élément.
         • Elle renvoie un pointeur vers le début de la mémoire allouée, ou NULL si l'allocation échoue.
         • Elle garantit que la mémoire allouée est initialisée à zéro, ce qui peut être utile dans certaines situations.

      3. realloc

         • realloc : Le nom "realloc" signifie "réallocation" et indique que cette fonction est utilisée pour réallouer de la mémoire déjà allouée, soit pour la redimensionner, soit pour la libérer.
         • La fonction realloc (re-allocation) est utilisée pour modifier la taille d'un bloc de mémoire déjà alloué, soit pour l'agrandir, soit pour le réduire.
         • Syntaxe :

           void* realloc(void* ptr, size_t new_size);

         • Elle prend en argument un pointeur vers le bloc de mémoire à redimensionner et la nouvelle taille souhaitée en octets.
         • Elle renvoie un pointeur vers le début du bloc de mémoire redimensionné, ou NULL si l'allocation échoue. Si ptr est NULL, la fonction se comporte comme malloc.
         • Elle peut être utilisée pour agrandir ou réduire un bloc de mémoire déjà alloué. Si l'allocation échoue, le pointeur d'origine reste valide et la mémoire n'est pas modifiée.

   3. Utilisation des Fonctions

      • malloc()

        La syntaxe de malloc() est la suivante :

        ptr = (cast_type*) malloc(size); 

        Exemple

                                                
                                                int* ptr;
                                                ptr = (int*) malloc(10 * sizeof(int));
                                                
                                            

        Cette instruction alloue de la mémoire pour 10 entiers et renvoie un pointeur vers le début de cette zone de mémoire.

      • calloc()

        La syntaxe de calloc() est la suivante :

        ptr = (cast_type*) calloc(num_elements, element_size);

        Exemple

                                            
                                                int* ptr;
                                                ptr = (int*) calloc(10, sizeof(int));
                                                # Cette instruction alloue de la mémoire pour 10 entiers et initialise tous les bits à zéro.
                                            
                                        

      • realloc()

        La syntaxe de realloc() est la suivante :

        ptr = realloc(ptr, new_size);

        Exemple

                                            
                                                ptr = realloc(ptr, 20 * sizeof(int));
                                                # Cette instruction réalloue la mémoire pour le pointeur ptr avec une nouvelle taille de 20 entiers.
                                            
                                        

        La fonction realloc est utilisée lorsque vous avez déjà alloué de la mémoire dynamiquement avec malloc, calloc, ou même si vous avez obtenu un pointeur par une précédente utilisation de realloc, et que vous souhaitez modifier la taille de ce bloc de mémoire.

        Quelques cas d'utilisation de realloc :

        • Agrandissement du bloc de mémoire : Si vous avez besoin de plus d'espace pour stocker des données, vous pouvez utiliser realloc pour agrandir le bloc de mémoire déjà alloué. Cela peut être utile lorsque vous ne connaissez pas la taille nécessaire à l'avance.
        • Réduction du bloc de mémoire : Si vous avez alloué plus de mémoire que nécessaire et que vous souhaitez réduire la taille du bloc, realloc peut également être utilisé pour cela. Cela peut être utile pour économiser de la mémoire lorsque la taille du bloc n'est plus nécessaire.
        • Modification de la taille du bloc de mémoire : Si vous avez besoin d'ajuster la taille du bloc de mémoire pour répondre à de nouveaux besoins dans votre programme, realloc est une solution efficace.

        1. Exemple d'utilisation de realloc pour agrandir un bloc de mémoire

                                                                   
                                                                       int *ptr;
                                                                       ptr = (int*)malloc(5 * sizeof(int)); // Alloue de la mémoire pour 5 entiers
                                                                       // Utilisation de ptr...
                                                                       ptr = (int*)realloc(ptr, 10 * sizeof(int)); // Agrandit le bloc de mémoire pour 10 entiers
                                                                   
                                                               

           Il est important de noter que realloc peut retourner un nouveau pointeur ou le même pointeur que celui passé en argument. Si la réallocation échoue, realloc renvoie NULL et l'ancien pointeur reste valide. Il est donc recommandé de stocker le résultat de realloc dans un nouveau pointeur pour éviter la perte de la référence à la mémoire allouée en cas d'échec de réallocation.

        2. Exemple d'utilisation de realloc pour réduire la taille d'un bloc de mémoire :

                                                                   
                                                                       int *ptr;
                                                                       ptr = (int*)malloc(10 * sizeof(int)); // Alloue de la mémoire pour 10 entiers
                                                                       // Utilisation de ptr...
                                                                       ptr = (int*)realloc(ptr, 5 * sizeof(int)); // Réduit le bloc de mémoire pour 5 entiers
                                                                   
                                                               

           Il est important de noter que realloc peut retourner un nouveau pointeur ou le même pointeur que celui passé en argument. Si la réallocation échoue, realloc renvoie NULL et l'ancien pointeur reste valide. Il est donc recommandé de stocker le résultat de realloc dans un nouveau pointeur pour éviter la perte de la référence à la mémoire allouée en cas d'échec de réallocation.

      • free()

        La syntaxe de free() est la suivante :

        free(ptr); # Cette instruction libère la mémoire allouée pour le pointeur ptr.

   4. Gestion des Erreurs

      Il est important de vérifier si les allocations de mémoire réussissent. Les fonctions malloc(), calloc() et realloc() retournent NULL si l'allocation échoue. Par conséquent, il est recommandé de vérifier si le pointeur retourné est NULL après chaque appel.

      Exemple

                              
                                  int* ptr;
                                  ptr = (int*) malloc(10 * sizeof(int));
                                  if (ptr == NULL) 
                                  {
                                      printf("Erreur d'allocation de mémoire.\n");
                                      exit(1);
                                  }
                              
                          

   5. Libération de la Mémoire

      Il est crucial de libérer la mémoire allouée dynamiquement à la fin de son utilisation pour éviter les fuites de mémoire. Utilisez la fonction free() pour libérer la mémoire lorsque vous n'en avez plus besoin.

      Exemple

      free(ptr);

   6. Le choix entre malloc et calloc

      Le choix entre malloc et calloc dépend des besoins spécifiques de votre programme, en particulier de la nécessité d'initialiser ou non la mémoire allouée.

      Utilisez malloc lorsque :

      • Vous avez besoin d'allouer de la mémoire pour un bloc de données sans initialiser son contenu.
      • Vous prévoyez d'initialiser manuellement les données après l'allocation.
      • L'initialisation des données n'est pas nécessaire ou sera effectuée ultérieurement dans le programme.

      Utilisez calloc lorsque :

      • Vous avez besoin d'allouer de la mémoire pour un bloc de données et que vous souhaitez que toutes les valeurs de ce bloc soient initialisées à zéro.
      • Vous voulez vous assurer que les données allouées commencent avec des valeurs définies.
      • Vous préférez éviter d'avoir à initialiser manuellement les données après l'allocation.

      En résumé, si l'initialisation des données n'est pas nécessaire ou si elle sera effectuée manuellement après l'allocation, utilisez malloc. Si vous avez besoin que toutes les données allouées soient initialisées à zéro dès le départ, utilisez calloc.

   7. Exemple complet

      
                       #include <stdio.h>
                       #include <stdlib.h>
      
                      int main() {
                          // Déclaration d'un pointeur pour stocker l'adresse de la mémoire allouée
                          int *ptr;
                          int n;
      
                          // Demande à l'utilisateur de saisir la taille du tableau
                          printf("Entrez la taille du tableau : ");
                          scanf("%d", &n);
      
                          // Allocation dynamique de mémoire pour un tableau d'entiers de taille n
                          ptr = (int*)malloc(n * sizeof(int));
      
                          // Vérification si l'allocation a réussi
                          if (ptr == NULL) {
                              printf("Erreur d'allocation de mémoire.");
                              return 1; // Arrêt du programme avec un code d'erreur
                          }
      
                          // Demande à l'utilisateur de saisir les éléments du tableau
                          printf("Entrez les éléments du tableau :\n");
                          for (int i = 0; i < n; i++) {
                              scanf("%d", &ptr[i]);
                          }
      
                          // Affichage des éléments du tableau
                          printf("Les éléments du tableau sont :\n");
                          for (int i = 0; i < n; i++) {
                              printf("%d ", ptr[i]);
                          }
      
                          // Libération de la mémoire allouée
                          free(ptr);
      
                          return 0; // Fin normale du programme
                      }
                      

      Cet exemple permet à l'utilisateur de saisir la taille d'un tableau, puis les éléments de ce tableau. Il utilise l'allocation dynamique pour allouer de la mémoire en fonction de la taille saisie par l'utilisateur, stocke les éléments dans le tableau, les affiche, puis libère la mémoire allouée dynamiquement à la fin du programme.

   8. Conclusion

      L'allocation dynamique en langage C est une fonctionnalité puissante mais nécessite une gestion prudente de la mémoire. En comprenant les fonctions malloc(), calloc(), realloc() et free(), vous pouvez gérer efficacement la mémoire de votre programme de manière dynamique. Gardez à l'esprit de vérifier les erreurs d'allocation et de libérer la mémoire appropriée pour éviter les problèmes de fuite de mémoire.

annexe