Programmation en C
Les appels systèmes, les erreurs et la chaine de compilation

John Samuel
CPE Lyon

Année: 2024-2025
Courriel: john(dot)samuel(at)cpe(dot)fr

Objectifs

• La portée des variables
• Préprocesseur
• Les appels systèmes
• Les erreurs
• La chaine de compilation

Une variable constante

L'objectif d'une variable constante est de déclarer une valeur immuable qui ne peut pas être modifiée après son initialisation, afin d'assurer l'intégrité des données et de prévenir les erreurs potentielles.

/* Une variable constante
*/

#include <stdio.h>


int main() {
  const int année = 2017; // une variable constante
  année = 2019; // tentative de modification d'une variable constante
  printf("C'est l'annee %d", année);
  return 0;
}

Erreur pendant la compilation

Les variables constantes sont des valeurs en lecture seule, et toute tentative de modification de leur valeur après leur initialisation entraîne une erreur de compilation pour préserver leur immutabilité.

$ gcc bonjour.c
const.c: In function ‘main’:
const.c:5:8: error: assignment of read-only variable ‘année’
année = 2019;


Une variable globale

Les variables globales sont visibles et modifiables depuis toutes les fonctions du programme. Il est généralement recommandé de limiter l'utilisation de variables globales et de les utiliser avec précaution pour éviter des effets secondaires indésirables dans un programme complexe.

/* affiche un message à l'écran en utilisant une variable globale
*/

#include <stdio.h>
int année = 2017 // une variable globale;

int main() {
  printf("C'est l'annee %d", année); //affiche 2017
  return 0;
}

Une variable globale

/* affiche un message à l'écran en utilisant une variable globale */

#include <stdio.h>
int main() {
  printf("C'est l'annee %d", année);
  return 0;
}
int année = 2017 // une variable globale;

Dans la fonction main(), l'affichage de la valeur de année est tenté avant sa déclaration et son initialisation, ce qui génère une erreur de compilation. Le compilateur ne sait pas ce qui est tenté d'être affiché avant que la variable année ne soit définie.

Erreur pendant la compilation

$ gcc bonjour.c
bonjour.c: In function ‘main’:
bonjour.c:5:30: error: ‘année’ undeclared (first use in this function)
5 | printf("C'est l'annee %d", année);
| ^~~~
bonjour.c:5:30: note: each undeclared identifier is reported only once for each function it appears in


L'erreur de compilation indique que la variable année n'a pas été déclarée avant son utilisation dans la fonction main().

Une variable locale

/* affiche un message à l'écran en utilisant une variable locale */
#include <stdio.h>
int année = 2017 // une variable globale;
int main() {
  int année = 2018 // une variable locale;
  printf("C'est l'annee %d", année); //affiche 2018
  return 0;
}

La variable année déclarée en dehors de la fonction main() est une variable globale. Elle est visible et accessible depuis n'importe quelle fonction dans votre programme. La variable année déclarée à l'intérieur de la fonction main() est une variable locale. Elle n'est visible et accessible qu'à l'intérieur de la fonction main().

Cela démontre la portée des variables, où une variable locale a la priorité sur une variable globale du même nom lorsqu'elle est déclarée dans la même portée.

Une variable locale

/* affiche un message à l'écran en utilisant une variable locale */
#include <stdio.h>
int année = 2017 // une variable globale;

int main() {
  int année = 2018 // une variable locale;
  {
   int année = 2019 // une variable locale;
   printf("C'est l'annee %d", année); //affiche 2019
  }
  printf("C'est l'annee %d", année); //affiche 2018
  return 0;
}

1. Passage par valeur

void echange( int a, int b ) {
  int temp = a;
  a = b;
  b = temp;
}

int main() {
  int a = 10, int b = 20;
  echange(a, b);
  printf("a: %d, b: %d", a, b); //affiche 10, 20
  return 0;
}

Il est important de noter que cette fonction effectue un passage par valeur, ce qui signifie que les valeurs originales de a et b ne seront pas modifiées en dehors de la fonction.

2.1 Passage par référence: une variable

void echange( int *a, int *b ) {
  int temp = *a;
  *a = *b;
  *b = temp;
}

int main() {
  int a = 10, int b = 20;
  echange(&a, &b);
  printf("a: %d, b: %d", a, b); //affiche 20, 10
  return 0;
}

Après l'exécution de cette fonction, les valeurs pointées par *a et *b ont été échangées de manière efficace grâce à l'utilisation de pointeurs, et ces modifications sont visibles en dehors de la fonction, car elle utilise le passage par référence.

2.2. Passage par référence: un tableau

Le passage par référence d'un tableau est une manière de transmettre un tableau à une fonction en lui fournissant directement une référence (ou un pointeur) vers le tableau d'origine, plutôt que de faire une copie du tableau.

void affichage( char message[10] ) {
  printf("%s\n", message);
}

int main() {
  char message[10] = "Bonjour";
  affichage(message);
  return 0;
}

2.2. Passage par référence: un tableau

Toute modification apportée au tableau à l'intérieur de la fonction affectera également le tableau d'origine en dehors de la fonction.

void affichage( char message[] ) {
  message[0] = 'b';
  printf("%s\n", message); // affiche "bonjour"
}

int main() {
  char message[10] = "Bonjour";
  affichage(message);
  printf("%s\n", message); // affiche "bonjour"
  return 0;
}

2.2. Passage par référence: un tableau

Lorsqu'un tableau est passé en tant qu'argument à une fonction, il est automatiquement converti en un pointeur vers son premier élément. Cela signifie que char message[] est équivalent à char *message dans le contexte de cette fonction.

void affichage( char *message ) {
  printf("%s\n", message);
}

int main() {
  char message[10] = "Bonjour";
  affichage(message);
  return 0;
}

2.2. Passage par référence: un tableau

void affichage( int tableau[2][2] ) {
  for ( int i = 0; i < 2; i++) {
    for ( int j = 0; j < 2; j++) {
     printf("%d\n",  tableau[i][j]);
    }
  }
}

int main() {
  int prix[2][2] = {{11, 12}, {13, 14}};
  affichage(prix);
  return 0;
}

2.2. Passage par référence: un tableau

void affichage( int tableau[][] ) {
  for ( int i = 0; i < 2; i++) {
    for ( int j = 0; j < 2; j++) {
     printf("%d\n",  tableau[i][j]);
    }
  }
}

int main() {
  int prix[2][2] = {{11, 12}, {13, 14}};
  affichage(prix);
  return 0;
}

2.2. Passage par référence: un tableau

Erreur pendant la compilation

Remarque : L'erreur lors de la compilation est due à la déclaration d'une fonction avec un tableau multidimensionnel sans spécifier la taille de la deuxième dimension.

$ gcc tableau.c
tableau.c:3:21: error: array type has incomplete element type ‘int[]’
3 | void affichage( int tableau[][] ) {
| ^~~~~~~
tableau.c:3:21: note: declaration of ‘tableau’ as multidimensional array must have bounds for all dimensions except the first
tableau.c: In function ‘main’:
tableau.c:15:13: error: type of formal parameter 1 is incomplete


2.2. Passage par référence: un tableau

Pour corriger l'erreur, nous avons précisé la taille de la deuxième dimension.

void affichage( int tableau[][2] ) {
  for ( int i = 0; i < 2; i++) {
    for ( int j = 0; j < 2; j++) {
     printf("%d\n",  tableau[i][j]);
    }
  }
}
int main() {
  int prix[2][2] = {{11, 12},{13, 14}};
  affichage(prix);
  return 0;
}

2.2. Passage par référence: un tableau

Pour corriger l'erreur, nous avons utilisé un pointeur vers un tableau à deux dimensions.

void affichage( int (*tableau)[2] ) {
  for ( int i = 0; i < 2; i++) {
    for ( int j = 0; j < 2; j++) {
     printf("%d\n",  tableau[i][j]);
    }
  }
}
int main() {
  int prix[2][2] = {{11, 12}, {13, 14}};
  affichage(prix);
  return 0;
}

2.2. Passage par référence: un tableau

Un pointeur vers un pointeur d'entiers : Un pointeur qui pointe vers un tableau de pointeurs.

void affichage( int **tableau, int lignes, int colonnes ) {
  for ( int i = 0; i < lignes; i++) {
    for ( int j = 0; j < colonnes; j++) {
     printf("%d\n",  tableau[i][j]);
    }
  }
}
int main() {
  int **prix, lignes, colonnes;   ....
  affichage(prix, lignes, colonnes);
  return 0;
}

Passage par référence: un tableau

int main() {
  int **tableau, lignes = 2, colonnes = 10;
  tableau = calloc(sizeof(int *), lignes);
  for ( int i = 0; i < lignes; i++) {
   tableau[i] = calloc(sizeof(int), colonnes);
  }
  for ( int i = 0; i < lignes; i++) {
    for ( int j = 0; j < colonnes; j++) {
       tableau[i][j] = i+j;
    }
  }
...


Passage par référence: un tableau

...
  affichage(tableau, lignes, colonnes);
  for ( int i = 0; i < lignes; i++) {
   free(tableau[i]);
  }
  free(tableau);
  return 0;
}

Remarque : Le tableau tableau a été passé par référence à la fonction affichage, de sorte que toute modification apportée à tableau à l'intérieur de cette fonction serait également répercutée sur le tableau d'origine.

cercle.c

Le préprocesseur est une étape initiale du processus de compilation. Son principal objectif est de traiter des directives de préprocesseur et d'effectuer des transformations sur le code source avant que le compilateur ne commence son travail.

#define PI 3.14159

float aire( float rayon) {
 return(PI * rayon * rayon);
}


Une directive de préprocesseur #define est utilisée pour définir une constante PI avec la valeur 3.14159. Le préprocesseur effectue une substitution de texte, ce qui signifie que partout où le mot PI est utilisé dans le code source, il sera remplacé par la valeur 3.14159 avant que le code ne soit soumis au compilateur.

Remarque: Utilisez l'option gcc -E pour voir le code après le prétraitement, ce qui montrera comment les macros sont substituées et comment le code est modifié avant la compilation.

Prototype (defs.h)

#define PI 3.1415926535


La directive #include est utilisée pour inclure le contenu du fichier "defs.h" dans le code source. Cela permet d'utiliser les définitions et les macros contenues dans ce fichier. La directive #ifndef est utilisée pour vérifier si la macro "PI" est déjà définie. Si elle ne l'est pas (d'où le nom "If Not DEFined"), alors la directive suivante est exécutée.

cercle.c

#include "defs.h"
#ifndef PI // Si PI n'est pas défini
#define PI 3.14159
#endif
float aire( float rayon) {
 return(PI * rayon * rayon);
}


Prototype (defs.h)

Erreur: PI est une macro et non une variable, et il n'est pas modifiable. La tentative de modification de la valeur de PI générera une erreur de compilation, car les macros ne peuvent pas être réassignées.

#include "defs.h"
float aire( float rayon) {
 PI = 3.14;
 return(PI * rayon * rayon);
}


Erreur (compilation)

Error: lvalue required as left operand of assignment
PI = 3.14;
   ^

operators.h

int somme( int, int);
int num = 20;



L'utilisation

#include "operators.h" // en-têtes(headers)
#include "operators.h" // pas d'erreurs



Lorsqu'un fichier d'en-tête contient uniquement des déclarations, il n'y a pas d'erreur si le fichier d'en-tête est inclus plusieurs fois. Les déclarations n'introduisent pas de données réelles en mémoire, elles spécifient simplement le type des fonctions ou des variables.

operators.h

int num = 20;



L'utilisation

#include "operators.h" // en-têtes(headers)
#include "operators.h" // erreur

$ gcc operator.c
note: previous definition of ‘num’ was here
int num=20;


Lorsque le fichier d'en-tête "operators.h" est inclus deux fois, cela entraîne une double inclusion de la définition de la variable num, ce qui n'est pas autorisé en C.

operators.h (bonne pratique)

#ifndef __OPERATORS_H__
#define __OPERATORS_H__
int num = 20;
int somme( int, int);
#endif //__OPERATORS_H__

L'utilisation

#include "operators.h" // en-têtes(headers)
#include "operators.h" // 2eme fois, mais pas d'erreurs



Lorsque le même fichier d'en-tête est inclus une deuxième fois (ou plus), la condition #ifndef __OPERATORS_H__ est fausse, car la macro __OPERATORS_H__ est déjà définie, et le préprocesseur n'inclura pas le contenu du fichier d'en-tête une deuxième fois. Cela évite les erreurs de déclaration multiple.

Fonction macro

#ifndef PI
#define PI 3.14159
#endif

#ifndef square
#define square(value) value * value
#endif

float aire( float rayon) {
 return(PI * square(rayon));
}


#define square(value) value * value: Cette directive est utilisée comme une fonction macro qui prend un argument value et renvoie sa valeur au carré en multipliant value par lui-même.

Remarque: Il'n y a pas d'espace entre square et (

struct couleur1{
 unsigned char rouge;
 unsigned char vert;
 unsigned char bleu;
 unsigned int compteur;
};
struct couleur2{
 unsigned char rouge;
 unsigned int compteur;
 unsigned char vert;
 unsigned char bleu;
};  printf( "size- couleur1: %lu, couleur2: %lu\n",
  sizeof( struct couleur1), sizeof( struct couleur2));

Question: Quel est l'affichage de ce programme?

Alignement d'un octet

• L'affichage de ce programme dépend de la manière dont les membres de la structure sont alignés en mémoire par le compilateur. Les règles d'alignement peuvent varier en fonction de l'architecture matérielle et du compilateur utilisé.
• En général, les compilateurs tentent d'aligner les membres de la structure de manière à optimiser l'accès à la mémoire, en particulier pour les types de données couramment utilisés.
• Cela signifie que les membres peuvent être décalés pour obtenir un meilleur alignement.

Alignement de 4 octets

• La taille totale d'une structure est déterminée par la somme des tailles de ses membres, mais en tenant compte de l'alignement.
• Dans la structure couleur1, la taille totale serait 12 octets, car chaque membre est aligné sur 4 octets, mais dans la structure couleur2, la taille totale serait 8 octets, car les membres rouge et vert sont alignés sur 4 octets, mais bleu et count sont alignés sur 4 octets.

Alignement en utilisant gcc

En utilisant gcc

#pragma pack(push)
#pragma pack(1) //alignement d'un octet
struct couleur3{
 unsigned char rouge;
 unsigned char vert;
 unsigned char bleu;
 unsigned int compteur;
};
#pragma pack(pop)

 printf( "%lu\n", sizeof(struct couleur3));

L'utilisation des directives #pragma pack(push) et #pragma pack(1) dans le code vous permet de spécifier un alignement d'un octet pour la structure couleur3. Cela signifie que les membres de la structure ne seront pas alignés de manière traditionnelle, mais plutôt sur un seul octet, ce qui minimise l'utilisation de la mémoire.
Remarque: L'affichage de ce programme: 7

struct couleur4{ //alignement de 4 octets
 unsigned char rouge;
 unsigned char vert;
 unsigned char bleu;
 unsigned char _pad;
 unsigned int compteur;
};
struct couleur5{ //alignement de 4 octets
 unsigned char rouge;
 unsigned char _pad1[3];
 unsigned int compteur;
 unsigned char vert;
 unsigned char bleu;
 unsigned char _pad2[2];
};

• L'alignement en mémoire est important pour optimiser les performances, en particulier sur certaines architectures matérielles.
• Pour aligner les structures sur un nombre spécifique d'octets (dans ce cas, 4 octets), des octets de remplissage, appelés "paddings," sont souvent ajoutés pour s'assurer que chaque membre est correctement aligné.
• Remarque: Utilisez l'option gcc -Wpadded pour savoir si une structure nécessite du padding our être alignée.

struct couleur{
 unsigned char rouge;
 unsigned char vert;
 unsigned char bleu;
 unsigned int compteur;
};
int main() {
 struct couleur c1;
 struct couleur *scptr = &c1;
 c1.bleu = 0xff;
 scptr->bleu = 0x01;
 printf( "c1.bleu: %hhx\n", c1.bleu); //0x01
 (*scptr).bleu = 0x22;
 printf( "c1.bleu: %hhx\n", c1.bleu); //0x22
}

scptr->bleu = 0x01 modifie également le membre bleu, mais à travers le pointeur scptr. Cela équivaut à (*scptr).bleu = 0x22, ce qui signifie que vous accédez au membre bleu de la structure pointée par scptr.

 struct couleur *scptr = &c1;


Les notations équivalents

(*scptr).bleu

scptr->bleu

L'opérateur -> combine les opérations de déréférencement et d'accès au membre en une seule étape. Cela rend le code plus lisible et réduit les risques d'erreurs de déréférencement. Les deux notations sont interchangeables.

struct couleur{
 unsigned char rouge;
 unsigned char vert;
 unsigned char bleu;
 unsigned int compteur;
};
void change( struct couleur *c) {
 c->bleu = 0x01;
}
int main() {
 struct couleur c1;
 c1.bleu = 0xff;
 change(&c1);
 printf( "c1.bleu: %hhx\n", c1.bleu); //0x01
}

Un membre d'une structure est modifié en utilisant une fonction qui prend un pointeur vers la structure en argument. Cette approche permet de manipuler directement la structure à l'intérieur de la fonction sans avoir besoin de renvoyer la structure modifiée, car les pointeurs permettent de travailler avec la même instance de la structure.

struct couleur{
 unsigned char rouge;
 unsigned char vert;
 unsigned char bleu;
 unsigned int compteur;
};
void nochange( struct couleur c) {
 c.bleu = 0x03;
}
int main() {
 struct couleur c1;
 c1.bleu = 0xff;
 nochange(c1);
 printf( "c1.bleu: %hhx\n", c1.bleu); //0xff
}

La fonction 0x03 est censée modifier le membre bleu de la structure c pour lui attribuer la valeur 0x03. Cependant, la fonction est déclarée pour prendre la structure c en tant que copie (par valeur) au lieu d'un pointeur. Par conséquent, lorsqu'elle est appelée dans la fonction main, une copie de la structure c1 est passée à la fonction nochange. Toute modification apportée à cette copie n'affecte pas la structure d'origine.

Une liste de couleurs simplement chaînée

Une liste simplement chaînée est une structure de données linéaire composée de nœuds, où chaque nœud contient une valeur et une référence (pointeur) vers le nœud suivant. Elle est utilisée pour stocker des éléments de manière séquentielle, offrant une manipulation efficace des données en insérant ou supprimant des éléments en temps constant, mais avec un accès moins efficace aux éléments au milieu de la liste.

Une liste de couleurs simplement chaînée

Chaque nœud de la liste contient également un pointeur vers le nœud suivant de la liste, permettant de stocker et de naviguer à travers une séquence de couleurs. Cette structure est souvent utilisée pour représenter une séquence de couleurs dans des applications graphiques ou de traitement d'images.

struct couleur{
 unsigned char rouge;
 unsigned char vert;
 unsigned char bleu;
 unsigned int compteur;
 struct couleur *next;
};


Une liste de couleurs simplement chaînée

int main() {
 struct couleur first, c1, c2;
 struct couleur *cptr;
 first.next = &c1;
 c1.next = &c2;
 c2.next = NULL;
 cptr = &first;

 while(cptr != NULL) { //navigation
  printf( "cptr->bleu: %hhx\n", cptr->bleu);
  cptr = cptr->next; //couleur suivante
 }
}

Un pointeur cptr est utilisé pour parcourir la liste, et à chaque étape, la valeur du composant "bleu" de la couleur actuelle est affichée à l'aide de printf. La boucle continue jusqu'à ce que le pointeur atteigne la fin de la liste, ce qui permet de parcourir et d'afficher les composants "bleu" de toutes les couleurs de la liste.

Une liste d'entiers simplement chaînée

Une liste d'entiers simplement chaînée

Chaque élément de la liste est représenté par la structure element, qui contient un numéro entier (numero) et un pointeur vers l'élément suivant (suivant). Deux fonctions sont fournies : insertion pour ajouter un nouvel élément à la liste et parcours pour parcourir et afficher les éléments de la liste. Cela permet de construire et de manipuler une liste d'entiers simplement chaînée.

struct element{
 unsigned int numero;
 struct element *suivant;
};

// insertion d'un élement dans une liste
void insertion(struct element*, int);

// parcours de la liste
void parcours(struct element *);

La saisie d'entiers par l'utilisateur

int main() {
 struct element premier;
 premier.suivant = NULL;
 while(1) {
   int numero;
   char strnum[50];
   fgets(strnum, sizeof(strnum), stdin);
   if(strcmp(strnum, "FIN\n") == 0) {
     break;
   }
   sscanf(strnum, "%d\n", &numero);
   insertion(&premier, numero);
 }
 parcours(&premier);
}

Une liste d'entiers simplement chaînée: insertion

Insertion d'un élément dans une liste simplement chaînée

L'objectif de cette fonction est d'insérer un nouvel élément dans une liste chaînée en créant un nouvel élément, en assignant une valeur à ce nouvel élément, et en ajustant les pointeurs pour l'insérer correctement dans la liste existante, ce qui permet de modifier la structure de la liste chaînée.

void insertion(struct element *premier, int numero) {
  struct element *nouveau;
  nouveau = malloc(sizeof(*nouveau));
  nouveau->numero = numero;
  nouveau->suivant = premier->suivant;
  premier->suivant = nouveau;
}
 


Une liste d'entiers simplement chaînée: parcours

Parcours d'une liste simplement chaînée

void parcours(struct element *premier) {
   struct element *elem = premier;
   while(elem != NULL) {
   printf("%d\n", elem->numero);
   elem = elem->suivant;
  }
 }


Une liste de couleurs doublement chaînée

Une liste doublement chaînée a pour objectif de permettre la navigation dans une structure de données linéaire de manière bidirectionnelle, offrant un accès à la fois vers l'élément précédent et l'élément suivant, ce qui facilite l'insertion, la suppression et la recherche efficace des éléments.

Une liste de couleurs doublement chaînée

struct couleur{
 unsigned char rouge;
 unsigned char vert;
 unsigned char bleu;
 unsigned int compteur;
 struct couleur *next;
 struct couleur *prev;
};


L'objectif de cette structure de données est de créer une liste doublement chaînée de couleurs, où chaque élément conserve des informations sur la couleur, un compteur, ainsi que des pointeurs vers l'élément précédent et l'élément suivant. Cela permet une navigation bidirectionnelle efficace et des opérations telles que l'insertion et la suppression d'éléments au sein de la liste chaînée.

int main() {
 struct couleur first, c1, c2, last;
 struct couleur *cptr = &last;

 first.next = &c1;
 first.prev = NULL;
 last.next = NULL;
 last.prev = &c2;
 c1.next = &c2;
 c1.prev = &first;
 c2.next = &last;
 c2.prev = &c1;

 while(cptr != &first) { //navigation
  printf( "cptr->bleu: %hhx\n", cptr->bleu);
  cptr = cptr->prev; //couleur précédente
 }
}

Une liste d'entiers simplement chaînée

Insertion d'un élément et parcours d une liste doublement chaînée

 struct element {
   int num;
   struct element *suivant;
   struct element *precedent;
 };
 
 struct liste {
   struct element premier;
   struct element dernier;
 };
 
 void insertion_debut(struct liste *, struct element *);
 void insertion_fin(struct liste *, struct element *);
 void parcourir_debut(struct liste *);
 void parcourir_fin(struct liste *);


Une liste de couleurs doublement chaînée: insertion

Une liste d'entiers doublement chaînée

 void insertion_debut(struct liste *liste,
   struct element *nouveau) {
  nouveau->suivant = liste->premier.suivant;
  nouveau->precedent = &liste->premier;
  liste->premier.suivant->precedent = nouveau;
  liste->premier.suivant = nouveau;
 }
 


Une liste de couleurs doublement chaînée: insertion

Une liste d'entiers doublement chaînée

 void insertion_fin(struct liste *liste,
    struct element *nouveau) {
  nouveau->suivant = &liste->dernier;
  nouveau->precedent = liste->dernier.precedent;
  liste->dernier.precedent->suivant = nouveau;
  liste->dernier.precedent = nouveau;
 }


Une liste d'entiers doublement chaînée

 void parcourir_debut(struct liste *liste) {
  struct element *elem = liste->premier.suivant;
  while(elem != &liste->dernier) {
   printf("%d\n", elem->num);
   elem = elem->suivant;
  }
 }
 


Une liste d'entiers doublement chaînée

 
 void parcourir_fin(struct liste *liste) {
  struct element *elem = liste->dernier.precedent;
  while(elem != &liste->premier) {
   printf("%d\n", elem->num);
   elem = elem->precedent;
  }
 }


La saisie d'entiers par l'utilisateur

 int main() {
  struct liste liste;
  liste.premier.suivant = &liste.dernier;
  liste.dernier.precedent = &liste.premier;
  liste.premier.precedent = NULL;
  liste.dernier.suivant = NULL;
 


La saisie d'entiers par l'utilisateur

  while (1) {
   char strnum[50];
   struct element *elem = malloc(sizeof(*elem));
   fgets(strnum, sizeof(strnum), stdin);
   if(strcmp(strnum, "FIN\n") == 0) {
    break;
   }
 
   sscanf(strnum, "%d\n", &elem->num);
   insertion_fin(&liste, elem);
  }
 
  parcourir_debut(&liste);
  parcourir_fin(&liste);
 }


Les fonctions "add" et "subtract" effectuent des opérations d'addition et de soustraction respectivement.

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

int soustraction( int a, int b ) {
 return a - b;
}

Le pointeur de fonction "func" est utilisé pour sélectionner dynamiquement l'une de ces fonctions en fonction de la valeur de l'opérateur, puis appelle la fonction appropriée pour effectuer le calcul. Dans cet exemple, la fonction "add" est appelée car l'opérateur est '+', affichant "value: 50".

int main() {
 int (*func)(int, int); //pointeur de function
 char op = '-';
 int num1 = 20, num2 = 30;
 if (op == '+') {
  func = somme;
 }
 else {
  func = soustraction;
 }
 printf("value: %d\n",func(20, 30));
}

/* Fichier: stats.c
* la taille d'un fichier
* auteur: John Samuel
*/

#include <stdio.h> // en-têtes(headers)
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

int main(int argc, char ** argv) {
 struct stat sf;
 stat ("./stats.c", &sf);
 printf("Taille: %ld octets", sf.st_size);
 return 0;
}

#include <stdio.h> // en-têtes(headers)
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>

int main(int argc, char ** argv) {
 struct stat sf;
 int status;
 status = stat (argv[1], &sf);
 if (status == -1) {
  perror("Stats");
  return(EXIT_FAILURE);
 }
 printf("Taille: %ld octets", sf.st_size);
 return 0;
}

Le programme utilise la fonction stat pour obtenir des informations sur le fichier spécifié par l'utilisateur. Les informations sont stockées dans la structure struct stat sf. Si la fonction stat échoue, elle renvoie -1, et le programme affiche un message d'erreur à l'aide de perror et se termine avec le code de sortie "EXIT_FAILURE".

La compilation

$ gcc -o stats stats.c

L'exécution

$./stats stats.c
Taille: ... octets
$ echo $?
0

L'exécution

$ ./stats nostats
Stats: No such file or directory
$ echo $?
1


Le code se termine ensuite avec le code de sortie "1", qui indique généralement qu'une erreur s'est produite pendant l'exécution du programme. Dans ce cas, l'erreur provient du fait que le fichier spécifié en argument n'a pas été trouvé, d'où le message d'erreur "No such file or directory".

L'objectif de la fonction perror dans cet exemple est d'afficher un message d'erreur explicite à l'utilisateur en cas d'échec lors de l'exécution de la fonction stat, en indiquant la nature de l'erreur, comme "No such file or directory" dans le cas d'un fichier introuvable.

#include <sys/types.h>
#include <dirent.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
int main(int argc, char **argv) {
 if (argc < 2) {
  printf("Usage: readdir path\n");
  return(EXIT_FAILURE);
 }

 DIR *dirp = opendir(argv[1]);
 if (dirp == NULL) {
  perror("opendir");
  return(EXIT_FAILURE);
 }



 struct dirent * ent;
 while(1) {
  ent = readdir(dirp);
  if (ent == NULL) {
   break;
  }
  printf("%s\n", ent->d_name);
 }

 closedir(dirp);
 return(0);
}


Ce programme a pour objectif de lister les fichiers et répertoires d'un répertoire spécifié par l'utilisateur. Le programme utilise une boucle pour parcourir le contenu du répertoire. Il lit chaque entrée (fichiers ou sous-répertoires) du répertoire à l'aide de la fonction readdir. Si la fin du répertoire est atteinte, la boucle s'arrête.

La programmation modulaire est une approche de développement logiciel qui consiste à diviser un programme en modules indépendants, également appelés unités ou composants, chacun responsable d'une fonctionnalité ou d'une tâche spécifique.

• Modules indépendants : Chaque module est conçu pour accomplir une tâche spécifique et est généralement indépendant des autres modules. Il peut s'agir de fonctions, de fichiers source, de bibliothèques ou de classes, selon la structure du programme.
• Encapsulation : Les détails d'implémentation d'un module sont masqués aux autres parties du programme. Seules les interfaces publiques sont accessibles, ce qui permet de cacher la complexité interne et de prévenir les interférences non souhaitées.
• Communication entre modules : Les modules communiquent généralement entre eux via des interfaces bien définies, telles que des fonctions ou des structures de données partagées. Cela permet une interaction contrôlée et prévisible entre les parties du programme.

• Réutilisation de code : Les modules autonomes peuvent être réutilisés dans d'autres projets ou parties du programme, ce qui accélère le développement et améliore la cohérence du code.
• Lisibilité et maintenabilité : En divisant le programme en modules, il devient plus facile de comprendre, de déboguer et de maintenir le code. Chaque module ayant une responsabilité claire, il est plus simple d'identifier et de résoudre les problèmes.
• Testabilité : Les modules autonomes peuvent être testés individuellement, ce qui facilite la création de tests unitaires pour chaque fonctionnalité du programme.
• Éviter les redondances : La programmation modulaire permet d'éviter la duplication de code en regroupant des fonctionnalités similaires dans un seul module réutilisable.

Client

L'objectif est de créer un socket client pour établir une connexion avec un serveur distant via le protocole TCP/IP en utilisant le port 8089. Le code configure l'adresse du serveur, crée un socket, et tente de se connecter au serveur distant. En cas d'échec, il affiche un message d'erreur.

Client

#define PORT 8089
int main() {
 int socketfd;
 int bind_status;
 struct sockaddr_in server_addr, client_addr;
 /* Création d'un socket
  * AF_INET: Protocoles Internet IPv4
  * SOCK_STREAM: flux d'octets bidirectionnels, basés sur la connexion
  */
 socketfd = socket(AF_INET, SOCK_STREAM, 0);
 if ( socketfd < 0 ) {
  perror("Impossible d'ouvrir un socket");
  return -1;
 }


Client

 // détails de l'adresse du serveur
 memset(&server_addr, 0, sizeof(server_addr));
 server_addr.sin_family = AF_INET;
 server_addr.sin_port = htons(PORT);
 server_addr.sin_addr.s_addr = INADDR_ANY;

 //Se connecter au serveur
 int connect_status = connect(socketfd, (struct sockaddr *)
   &server_addr, sizeof(server_addr));
 if ( connect_status < 0 ) {
  perror("Impossible de se connecter au serveur");
  return -1;
 }


Serveur

L'objectif est de créer un serveur socket en utilisant le protocole TCP/IP (IPv4), de configurer le serveur pour accepter les connexions entrantes sur un port donné, d'écouter les demandes de connexion des clients et d'accepter ces connexions lorsqu'elles sont établies. Le serveur est configuré pour être capable d'accepter plusieurs connexions de clients en utilisant la fonction accept.

Serveur

int main() {
 int socketfd;
 int bind_status;
 struct sockaddr_in server_addr, client_addr;

 /* Création d'un socket
  * AF_INET: Protocoles Internet IPv4
  * SOCK_STREAM: flux d'octets bidirectionnels, basés sur la connexion
  */
 socketfd = socket(AF_INET, SOCK_STREAM, 0);
 if ( socketfd < 0 ) {
  perror("Impossible d'ouvrir un socket");
  return -1;
 }



Serveur

 int option = 1;
 setsockopt(socketfd, SOL_SOCKET, SO_REUSEADDR,
  &option, sizeof(option));
 // détails de l'adresse du serveur
 memset(&server_addr, 0, sizeof(server_addr));
 server_addr.sin_family = AF_INET;
 server_addr.sin_port = htons(PORT);
 server_addr.sin_addr.s_addr = INADDR_ANY;
 bind_status = bind(socketfd, (struct sockaddr *)
   &server_addr, sizeof(server_addr));
 if (bind_status < 0 ) {
  perror("Impossible de se lier à un socket");
  return -1;
 }


 // Commencez à écouter le socket
 listen(socketfd, 10);
 char data[1024];

 int client_addr_len = sizeof(client_addr);
 int client_socket_fd = accept(socketfd,
   (struct sockaddr *) &client_addr, &client_addr_len);
 if(client_socket_fd < 0 ) {
  perror("Impossible d'accepter les demandes des clients");
  return -1;
 }


6 étapes de la chaine de compilation

1. Préprocesseur

Cette étape consiste à traiter les directives de préprocesseur contenues dans le code source, telles que les directives d'inclusion (#include) et de remplacement de macros (#define). Le résultat est généralement un fichier source modifié avec ces directives résolues.

cercle.c

#ifndef PI
#define PI 3.14159
#endif

float aire( float rayon) {
 return(PI * rayon * rayon);
}


1. Préprocesseur

$ gcc -E cercle.c # 1 "cercle.c"
# 1 ""
# 1 ""
# 31 ""
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 32 "" 2
# 1 "cercle.c"

float aire(float rayon) {
return(3.14 * rayon * rayon);
}


Le résultat affiche le code source après le traitement des directives de préprocesseur. Cela peut inclure des inclusions de fichiers, la résolution de macros et d'autres transformations avant la compilation proprement dite.

2. Langage intermédiaire

Ces étapes montrent comment le code source est transformé en diverses représentations intermédiaires avant d'atteindre le code machine final. Chacune de ces étapes permet une analyse et une optimisation du code à différents niveaux.

$ gcc -v bonjour.c # les étapes importantes
$ gcc -save-temps -v bonjour.c # les fichiers *.i, *.s
$ gcc -fdump-tree-all bonjour.c
$ gcc -fdump-rtl-all bonjour.c


2. Langage intermédiaire

Ce code généré montre comment les opérations mathématiques sont exprimées en AST (Abstract Syntax Tree - arbre de syntaxe abstraite).

$ gcc -fdump-tree-all -c cercle.c
$ cat cercle.c.005t.gimple
aire (float rayon)
{
float D.1914;
_1 = (double) rayon;
_2 = _1 * 3.140000000000000124344978758017532527446746826171875e+0;
_3 = (double) rayon;
_4 = _2 * _3;
D.1914 = (float) _4;
return D.1914;
}

3. Optimisation de code

$ gcc -O2 bonjour.c


• -O1 : Niveau d'optimisation 1. Il applique des optimisations de base pour améliorer les performances tout en maintenant une bonne expérience de débogage.
• -O2 : Niveau d'optimisation 2. Il applique des optimisations plus avancées, ce qui peut entraîner une meilleure performance, mais la compilation peut prendre plus de temps.
• -O3 : Niveau d'optimisation 3. Il applique des optimisations plus agressives que -O2, ce qui peut donner de meilleures performances, mais la compilation peut prendre plus de temps et la taille du fichier exécutable peut augmenter.
• -Os : Optimisation de la taille du binaire. Il cherche à réduire la taille du fichier exécutable, ce qui peut être utile dans des environnements avec des contraintes de stockage.
• -Ofast : Niveau d'optimisation élevé. Il applique des optimisations maximales, souvent au détriment de la taille du fichier exécutable. Utilisé pour obtenir la meilleure performance possible.
• -Og : Optimisation pour le débogage. Il optimise le code tout en conservant des informations de débogage utiles.

4. Génération de code natif

L'option -S indique au compilateur de produire le code assembleur au lieu de générer un exécutable. Le résultat de cette étape est un fichier avec l'extension .s, qui contient le code assembleur généré.

$ gcc -S bonjour.c
$ cat bonjour.s

4. Génération de code natif et l'optimisation de code

int main() {
  int num = 2 + 3;
  return(0);
}

Compilation (Pas d'optimisations)

$ gcc -O0 -S somme.c

L'absence d'optimisation (-O0) signifie que le compilateur n'a pas appliqué d'optimisations particulières, ce qui permet d'obtenir un code assembleur directement équivalent au code C source.

somme.s

main:
.LFB0:
  .cfi_startproc
  pushq %rbp
  .cfi_def_cfa_offset 16
  .cfi_offset 6, -16
  movq %rsp, %rbp
  .cfi_def_cfa_register 6
  movl $5, -4(%rbp)
  movl $0, %eax
  popq %rbp
  .cfi_def_cfa 7, 8
  ret
  .cfi_endproc


4. Génération de code natif et l'optimisation de code

int main() {
  int num = 2 + 3;
  return(0);
} $ gcc -O2 -S somme.c

somme.s

main:
.LFB0:
  .cfi_startproc
  xorl %eax, %eax
  ret
  .cfi_endproc

Compilation (optimisation: 2) : L'optimisation de niveau 2 a permis au compilateur de reconnaître que l'addition 2 + 3 est constante et que la valeur de retour de la fonction est toujours 0. Par conséquent, le calcul inutile est éliminé, ce qui donne un code assembleur très efficace et court. Cette optimisation est typique des optimisations de constantes que le compilateur peut effectuer pour améliorer les performances du code.

4. Génération de code

sur une machine d'architecture 64 bits

$ gcc bonjour.c
$ file a.out
 a.out: ELF 64-bit LSB shared object, x86-64


Cela signifie que le programme compilé est conçu pour être exécuté sur une machine d'architecture 64 bits, spécifiquement une architecture x86-64.

4. Génération de code

sur une machine d'architecture 64 bits

Cette commande indique au compilateur GCC de générer un exécutable 32 bits en utilisant l'architecture i686 (Intel 80386). L'option -m32 spécifie que l'exécutable doit être compilé en tant qu'application 32 bits.

$ gcc -march=i686 -m32 bonjour.c


Cette commande est similaire à la précédente, mais elle génère également le code assembleur (-S) pour le programme.

$ gcc -S -march=i686 -m32 bonjour.c
$ file ./a.out
 ./a.out: ELF 32-bit LSB shared object, Intel 80386


5. Code objet

Cette commande compile le fichier source "client.c" en un fichier objet "client.o". L'option -c indique au compilateur de générer uniquement le fichier objet sans produire d'exécutable. Cela permet de diviser le processus de compilation en deux étapes.

$ gcc -c client.c
$ gcc -c color.c


Cette commande prend les fichiers objets "color.o" et "client.o" et les compile en un exécutable nommé "color". Le compilateur lie les fichiers objets pour créer l'exécutable final.

$ gcc -o color color.o client.o


Cette approche est couramment utilisée pour séparer la compilation en plusieurs étapes, ce qui peut être utile dans des projets plus importants où différentes parties du programme sont gérées séparément avant d'être liées ensemble pour former l'exécutable final.

5. Code objet (Modifications et recompilation)

$ gcc -c client.c color.c
$ gcc -o client client.o color.o
$ vim client.c # Modification du fichier
$ gcc -c client.c
$ vim client.c # Modification du fichier
$ gcc -c client.c
$ gcc -o client client.o color.o


L'objectif de cette séquence de commandes est de compiler des fichiers source en fichiers objet, puis de recompiler le programme avec des modifications apportées au fichier source "client.c". Cela permet de mettre à jour le programme en reflétant les changements apportés au code source sans avoir à recompiler entièrement toutes les sources. Cela peut accélérer le processus de développement en évitant de recompiler inutilement les parties du programme qui n'ont pas changé.

L'optimisation du code vise à améliorer les performances, la consommation de mémoire et l'efficacité du code.

• Optimisation des boucles : L'une des principales sources d'optimisation réside dans l'amélioration des boucles. Cela inclut la réduction du nombre d'itérations, l'élimination de calculs redondants et la minimisation des opérations coûteuses à l'intérieur des boucles.
• Utilisation de types de données appropriés : Choisir les types de données appropriés peut réduire la consommation de mémoire et améliorer les performances. Par exemple, utiliser des types de données entiers plus petits lorsque cela est possible au lieu de int ou long.
• Élimination de la récursion : La récursion peut être coûteuse en termes de performances en raison de la gestion de la pile. Dans certains cas, il est préférable de remplacer la récursion par une approche itérative.

• Utilisation d'instructions SIMD : Les instructions SIMD (Single Instruction, Multiple Data) peuvent accélérer le traitement parallèle des données. Les bibliothèques telles que SSE (Streaming SIMD Extensions) peuvent être utilisées pour exploiter ces instructions.
• Optimisation de la mémoire cache : La gestion efficace de la mémoire cache est essentielle pour améliorer les performances. Cela inclut la réduction des accès mémoire aléatoires, l'alignement des données en mémoire et la minimisation des conflits de cache.
• Élimination de code mort : Supprimer le code inutilisé ou non atteint par le programme peut réduire la taille du binaire et améliorer la lisibilité du code.

La sécurité en programmation C est cruciale pour éviter les vulnérabilités et les failles de sécurité qui pourraient être exploitées par des attaquants.

• Débordement de tampon (Buffer Overflow) : En C, les débordements de tampon sont courants car le langage permet d'accéder directement à la mémoire. Les développeurs doivent faire attention à la taille des tampons et à la gestion des chaînes de caractères pour éviter les débordements de tampon qui peuvent conduire à des vulnérabilités.
• Gestion de la mémoire : La gestion de la mémoire en C est manuelle, ce qui signifie que les développeurs doivent allouer et libérer la mémoire correctement. Les fuites de mémoire ou les références à des zones mémoire libérées sont des vulnérabilités potentielles.
• Dépassement de limites de tableaux : En C, il est facile d'accéder en dehors des limites d'un tableau, ce qui peut provoquer des comportements imprévisibles et des vulnérabilités de sécurité. Il est important de vérifier les indices pour éviter cela.
• Utilisation de fonctions dangereuses : Certaines fonctions en C, telles que gets() et strcpy(), sont connues pour être dangereuses en raison de leur manque de contrôle sur les limites des tampons. Il est préférable d'utiliser des alternatives plus sûres comme fgets() et strncpy().

• Conversion de types non sécurisée : Les conversions de types en C peuvent être source de vulnérabilités si elles ne sont pas correctement vérifiées. Par exemple, la conversion d'un pointeur générique (void *) en un type spécifique peut provoquer des problèmes de sécurité si elle n'est pas gérée avec précaution.
• Gestion des erreurs : La gestion des erreurs en C doit être effectuée avec prudence. Les erreurs non gérées peuvent provoquer des comportements inattendus ou des vulnérabilités. Il est essentiel de gérer les erreurs de manière appropriée, par exemple en évitant la divulgation d'informations sensibles.
• Sécurité réseau : Lors de la programmation réseau en C, il est important de se méfier des vulnérabilités telles que les débordements de tampon lors de la réception de données réseau, ainsi que des erreurs de validation de données provenant de sources non fiables.

Les règles de codage sont des directives et des conventions qui définissent la manière dont le code doit être écrit pour assurer une lisibilité, une maintenabilité et une sécurité maximale.

• Indentation et Espacement :
  • Utilisez une indentation cohérente (généralement de 4 espaces) pour améliorer la lisibilité. Utilisez des espaces plutôt que des tabulations.
  • Alignez le code de manière appropriée pour améliorer la lisibilité.
• Nommage des Identificateurs :
  • Utilisez des noms de variables, de fonctions et de constantes significatifs. Évitez les noms de variables trop courts ou trop longs.
  • Suivez une convention de nommage cohérente, telle que camelCase ou snake_case.
• Commentaires :
  • Commentez votre code de manière appropriée pour expliquer la logique complexe ou les parties délicates.
  • Utilisez des commentaires clairs et concis. Évitez les commentaires redondants qui répètent ce que fait le code.

• Fonctions :
  • Divisez le code en fonctions modulaires pour améliorer la réutilisabilité et la maintenabilité. Limitez la longueur des fonctions pour qu'elles fassent une seule chose.
  • Utilisez des prototypes de fonction et déclarez les fonctions avant de les utiliser.
• Constantes :
  • Utilisez des constantes nommées pour améliorer la lisibilité et la maintenance.
  Évitez d'utiliser des valeurs littérales magiques dans le code.
• Gestion de la Mémoire :
  • Libérez la mémoire allouée dynamiquement avec free une fois que vous n'en avez plus besoin.
  • Évitez les fuites de mémoire en vous assurant que chaque allocation de mémoire est associée à une libération correspondante.
• Évitez l'utilisation de fonctions dangereuses :
  • Évitez les fonctions non sécurisées telles que gets() et strcpy() qui peuvent provoquer des débordements de tampon.
  • Utilisez des alternatives sécurisées telles que fgets() et strncpy.

• Gestion des Erreurs :
  • Gérez les erreurs de manière appropriée et fournissez des informations utiles en cas d'échec. Évitez d'ignorer les erreurs.
• Utilisation de la bibliothèque standard :
  • Privilégiez l'utilisation de fonctions de la bibliothèque standard pour effectuer des opérations courantes plutôt que de réinventer la roue.
• Portabilité :
  • Écrivez un code portable qui fonctionne sur différentes plates-formes et compilateurs.
  • Évitez de dépendre de comportements spécifiques à une plate-forme.
• Modularité :
  • Décomposez le code en modules logiques réutilisables.
  • Évitez la dépendance excessive entre les modules.
• Convention d'Écriture de Code :
  • Suivez une convention de style de code établie pour le projet ou l'organisation.
  • Respectez la cohérence du style au sein du projet.

Makefile

Makefile et make permettent de créer facilement un exécutable à partir du code source. Il prend en considération la dernière heure de modification des fichiers pour décider de l'exécution ou non d'une ou plusieurs commandes.

$ cat Makefile
client: client.c color.c # création de l'exécutable client
<TAB>gcc -o client client.c color.c


Voici comment le Makefile que vous avez partagé fonctionne :

• Le fichier Makefile commence par définir une règle. Dans ce cas, la règle s'appelle "client," et elle dépend des fichiers source "client.c" et "color.c." La partie commentée après le "#" explique simplement la fonction de cette règle.
• La ligne suivante commence par une tabulation (représentée par ). Cela indique une action à effectuer pour la règle "client." Dans ce cas, l'action est d'utiliser le compilateur GCC pour créer un exécutable nommé "client" à partir des fichiers source "client.c" et "color.c."

Makefile

$ make
gcc -o client client.c color.c


Le programme "make" lit le fichier Makefile et trouve la règle "client." Il vérifie si les dépendances ("client.c" et "color.c") ont été modifiées depuis la dernière exécution. Si elles l'ont été, ou si l'exécutable "client" n'existe pas, alors "make" exécute l'action spécifiée."make" compile le programme en utilisant GCC, ce qui est indiqué dans le Makefile, et génère l'exécutable "client" en utilisant les fichiers source "client.c" et "color.c."

Remarque : Le Makefile est utile pour automatiser la compilation et la gestion de projets logiciels complexes, en s'assurant que seules les parties modifiées sont recompilées, ce qui permet d'économiser du temps et des ressources.

Makefile

$ cat Makefile
client: client.o color.o # création de l'exécutable client
 gcc -o client client.o color.o

client.o: client.c client.h # compilation
 gcc -c client.c

color.o: color.c color.h # compilation
 gcc -c color.c



L'objectif du Makefile est d'automatiser le processus de compilation d'un programme appelé "client." Il définit des règles pour créer l'exécutable "client" en compilant les fichiers source "client.c" et "color.c," ainsi que leurs dépendances "client.h" et "color.h" si nécessaire.

Makefile

L'objectif est de définir des variables pour le compilateur (CC) et les options de compilation (CFLAGS). Il définit également les fichiers objets (COBJS et SOBJS) pour le programme client et serveur, ainsi que les cibles "server" et "client" pour la compilation de ces programmes. Le Makefile permet ainsi de compiler ces programmes en utilisant les règles et les variables prédéfinies.

$ cat Makefile
CC ?= gcc
CFLAGS ?= -Wall -Wextra -g

COBJS ?= client.o color.o
SOBJS ?= server.o color.o

.SUFFIXES: .c .o
SERVER = server
CLIENT = client


Makefile

all: $(SERVER) $(CLIENT) #création des exécutables

$(SERVER): $(SOBJS) # création de l'exécutable server
    $(CC) -o $(SERVER) $(SOBJS)

$(CLIENT): $(COBJS) # création de l'exécutable client
    $(CC) -o $(CLIENT) $(COBJS)

.c.o: # Compilation de tous les fichiers
    $(CC) -c $*.c


Le Makefile a pour objectif de compiler deux programmes, "server" et "client," en utilisant des fichiers source correspondants. La règle "all" indique que les cibles "server" et "client" doivent être construites. Pour construire ces cibles, le Makefile utilise les fichiers objets "SOBJS" et "COBJS" respectivement. Enfin, la règle ".c.o" définit comment compiler tous les fichiers source en fichiers objets en utilisant le compilateur "CC."

Exécution d'un Makefile

$ vim server.c # Modification du fichier
$ vim client.c # Modification du fichier
$ vim color.c # Modification du fichier
$ make # Compilation de tous les fichiers et création d'un exécutable.
$ vim color.c # Modification du fichier
$ make # Compilation d'un seul fichier (color.c) et création d'un exécutable.
$ make # Ni compilation ni création d'un nouveau exécutable car aucun fichier n'a été modifié


Remarque : Lorsque vous exécutez make une troisième fois, il constate que aucun fichier n'a été modifié depuis la dernière compilation, donc aucune compilation n'est effectuée, et aucun nouvel exécutable n'est créé. Cette étape est importante pour économiser du temps et des ressources lors du développement de logiciels, car seuls les fichiers pertinents sont recompilés.

Références

• Langage C, Claude Delannoy
• https://fr.wikipedia.org/wiki/Alignement_en_mémoire
• https://fr.wikipedia.org/wiki/Compilateur
• https://fr.wikipedia.org/wiki/G%C3%A9n%C3%A9ration_de_code_natif

Crédits d'images

• Wikimedia Commons