Principes des Langages de Programmation
Les pointeurs, les structures et les fonctions

John Samuel
CPE Lyon

Année: 2024-2025
Courriel: john.samuel@cpe.fr

Objectifs

• Les pointeurs
• Les structures
• Les unions
• Introduction aux fonctions

Architecture

L'architecture d'une machine influence la programmation en C en déterminant les détails de la gestion de la mémoire, la taille des types de données, l'ordre d'exécution des instructions (gestion des threads sur un processeur multicœur), et d'autres caractéristiques matérielles (par exemple, la taille des registres), ce qui peut nécessiter des ajustements spécifiques lors de la rédaction de code pour différentes plateformes matérielles.

Architecture

• 16 bits: E.g., Intel C8086
• 32 bits: E.g., Intel 80386,Intel Pentium II/III, AMD Athlon
• 64 bits: E.g., AMD Athlon 64, Intel Core 2

Une architecture n-bit peut adresser une mémoire de taille 2ⁿ.

Le nombre de bits d'une machine est étroitement lié à la mémoire de plusieurs manières :

• Taille des données en mémoire : Le nombre de bits détermine la quantité de données que la machine peut manipuler en une seule opération. Par exemple, sur une architecture 32 bits, les entiers sont généralement stockés sur 4 octets (32 bits), tandis que sur une architecture 64 bits, ils sont stockés sur 8 octets (64 bits). Cela influe sur la capacité de stockage et la manipulation des données en mémoire.
• Adressage mémoire : Le nombre de bits dans une adresse mémoire détermine la taille de l'espace d'adressage de la machine. Sur une architecture 32 bits, vous avez théoriquement un espace d'adressage de 2^32 octets (4 Go), tandis qu'une architecture 64 bits offre un espace d'adressage de 2^64 octets (plusieurs exaoctets). Cela affecte la capacité de la machine à adresser et à accéder à la mémoire.

Le nombre de bits d'une machine est étroitement lié à la mémoire de plusieurs manières :

• Performance : Les architectures 64 bits permettent souvent de manipuler de plus grandes quantités de données en une seule opération, ce qui peut améliorer les performances dans certaines situations. Cependant, cela peut également entraîner une utilisation de la mémoire plus intensive, ce qui nécessite de prendre en compte la gestion de la mémoire.
• Compatibilité : Les programmes écrits pour une architecture donnée (32 bits ou 64 bits) peuvent ne pas être compatibles avec une autre. La taille des pointeurs et des données affecte la manière dont le code interagit avec la mémoire, ce qui peut nécessiter des adaptations lors de la migration d'une architecture à l'autre.

Le nombre de bits dans une architecture détermine sa capacité à adresser et à gérer la mémoire, ce qui est essentiel pour la performance et la capacité des systèmes informatiques.

• 16 bits: 65,536 adresses (octets)
• 32 bits: 4 Gio (2³²:4,294,967,295)adresses (octets)
• 64 bits: 16 Eio (2⁶⁴) adresses (octets)

La capacité de la mémoire vive (RAM) d'un ordinateur est de 4 Go, 8 Go, 16 Go, etc., et elle détermine la quantité de données que l'ordinateur peut stocker temporairement pour un traitement rapide.

• La mémoire virtuelle étend l'utilisation de la mémoire de masse en utilisant des adresses virtuelles et physiques.
• Adresses: Les adresses virtuelles et les adresses physiques
  • Les adresses virtuelles sont utilisées par les programmes.
  • Les adresses physiques sont utilisées par les puces mémoire.
• L'unité de gestion mémoire traduit les adresses virtuelles en adresses physiques pour faciliter l'accès à la mémoire.

Dans une représentation binaire donnée,

• Le bit de poids fort (MSB, acronyme de "Most Significant Bit") est le bit le plus à gauche et il représente la plus grande puissance de 2 dans la valeur binaire. Il a la plus grande valeur lorsque tous les autres bits sont à zéro.

• Le bit de poids faible (LSB, acronyme de "Least Significant Bit") est le bit le plus à droite et il représente la plus petite puissance de 2 dans la valeur binaire. Il a la plus petite valeur lorsque tous les autres bits sont à zéro.

Dans une représentation binaire sur 8 bits (octet)

• MSB (Bit de poids fort) : C'est le bit le plus à gauche de l'octet, généralement le 7e bit si l'on compte de 0 à 7. Il représente la plus grande puissance de 2 dans cet octet, soit 2^7. Sa valeur maximale est 128 lorsque ce bit est à 1.
• LSB (Bit de poids faible) : C'est le bit le plus à droite de l'octet, généralement le 0e bit si l'on compte de 0 à 7. Il représente la plus petite puissance de 2, soit 2^0, et sa valeur maximale est 1 lorsque ce bit est à 1.

Dans une représentation binaire sur 16 bits

• MSB (Bit de poids fort) : C'est le bit le plus à gauche des 16 bits, généralement le 15e bit si l'on compte de 0 à 15. Il représente la plus grande puissance de 2 dans ces 16 bits, soit 2^15. Sa valeur maximale est 32 768 lorsque ce bit est à 1.
• LSB (Bit de poids faible): C'est le bit le plus à droite des 16 bits, généralement le 0e bit si l'on compte de 0 à 15. Il représente la plus petite puissance de 2, soit 2^0, et sa valeur maximale est 1 lorsque ce bit est à 1.

Endianness (Boutisme)

L'ordre d'organisation des octets en mémoire.

• Big-endian (grand-boutiste) : Convention où l'octet le plus significatif est stocké en premier dans la mémoire.
• Little-endian (petit-boutiste) : Convention où l'octet le moins significatif est stocké en premier dans la mémoire.

Remarque: Dans ce cours, nous utilisons la convention petit-boutiste.

char c = 'a';
char *my_char_addr = &c;


Un pointeur est une variable qui stocke l'adresse mémoire d'une autre variable.
• Un pointeur de type char nommé my_char_addr est défini et reçoit l'adresse mémoire de la variable c en utilisant l'opérateur d'adresse '&'.
• my_char_addr fait référence à l'emplacement mémoire où la valeur 'a' est stockée.
• Remarque: my_char_addr = 0xab71

Les liens entre les pointeurs en C, les adresses virtuelles et les adresses physiques

• Pointeur en C : Un pointeur en C est une variable qui stocke une adresse mémoire. Il est utilisé pour référencer et accéder à des données situées à cette adresse mémoire.
• Adresse Physique : L'adresse physique est l'adresse réelle à laquelle les données sont stockées en mémoire physique (RAM). Contrairement à l'adresse virtuelle, elle dépend de l'architecture matérielle de l'ordinateur.
• Gestion de la Mémoire : Le système d'exploitation et l'unité de gestion mémoire (MMU) sont responsables de la traduction des adresses virtuelles en adresses physiques. Cela permet au système d'exploitation de gérer la mémoire de manière efficace, notamment en utilisant des techniques telles que la pagination ou la segmentation.

Les liens entre les pointeurs en C, les adresses virtuelles et les adresses physiques

• Protection de la Mémoire : L'utilisation d'adresses virtuelles permet de mettre en place des mécanismes de protection de la mémoire. Par exemple, un programme ne peut pas accéder directement à la mémoire d'un autre programme en utilisant des adresses virtuelles, ce qui renforce la sécurité et l'isolation des processus.
• Portabilité du Code : L'utilisation d'adresses virtuelles rend le code portable entre différentes architectures matérielle, car il peut utiliser des pointeurs en C avec des adresses virtuelles sans se soucier des détails de l'adresse physique sous-jacente.

Les liens entre les pointeurs en C, les adresses virtuelles et les adresses physiques

• Les pointeurs en C utilisent des adresses virtuelles pour accéder à la mémoire, tandis que l'unité de gestion mémoire du système d'exploitation traduit ces adresses virtuelles en adresses physiques pour un accès réel à la mémoire.
• Cela permet une gestion efficace de la mémoire, la protection des processus et la portabilité du code entre différentes plateformes matérielles.

short *

short s = 0xa478;
short *my_short_addr = &s;


Ce code initialise une variable short s avec la valeur hexadécimale 0xa478, puis crée un pointeur my_short_addr qui référence l'adresse mémoire de s.

Remarque: my_short_addr = 0xab71.

int *

int i = 0xa47865ff;
int *my_int_addr = &i;


Ce code initialise une variable short i avec la valeur hexadécimale 0xa47865ff, puis crée un pointeur my_int_addr qui référence l'adresse mémoire de i.

Remarque: my_int_addr = 0xab71

long int *

long int li = 0xa47865ff;
long int *my_long_int_addr = &li;


Ce code initialise une variable short li avec la valeur hexadécimale 0xa47865ff, puis crée un pointeur my_long_int_addr qui référence l'adresse mémoire de li.

Remarque: my_long_int_addr = 0xab71

IEEE 754

float (32-bit)

• signe: bit 31
• exposant: bits 23-30
• mantisse: bits 0-22

IEEE 754

float (32-bit): Pour stocker un numéro en utilisant la conversion IEEE 754, voici les étapes :

• Déterminez le signe : Si le numéro est positif, le bit de signe est 0 ; s'il est négatif, le bit de signe est 1.
• Exprimez le numéro en binaire normalisé : Convertissez le numéro en une forme binaire normalisée, c'est-à-dire sous la forme "1.xxxx" où "xxxx" représente la partie fractionnaire en binaire. Par exemple, pour le nombre 9.5 (1001.1), la forme normalisée en binaire est "1.0011".
• Déterminez l'exposant : L'exposant est le décalage nécessaire pour normaliser le numéro. Par exemple, pour "1001.1", l'exposant est 3 car il faut décaler la virgule de trois positions vers la gauche pour obtenir "1.0011".
• Appliquez le biais : Ajoutez le biais à l'exposant pour éviter les valeurs négatives. Pour les float 32 bits, le biais est 127. Donc, si l'exposant est 3, l'exposant stocké est 3 + 127 = 130 en binaire.
• Stockez le résultat : Combinez le signe, l'exposant et la mantisse (la partie fractionnaire) pour obtenir la représentation binaire complète du numéro en virgule flottante.

IEEE 754

float (32-bit): Pour stocker un numéro en utilisant la conversion IEEE 754, voici les étapes pour stocker le nombre 9.5:

• Le signe est 0 (positif).
• La forme normalisée en binaire est "1001.1".
• L'exposant est 3.
• En ajoutant le biais (127), l'exposant stocké est 130 en binaire, soit "10000010".
• La mantisse est "00110000000000000000000" (les bits fractionnaires après le point).

IEEE 754

double (64-bit)

• signe: bit 63
• exposant: bits 52-62
• mantisse: bits 0-51

Remarque: IEEE 754

IEEE 754

double (64-bit): La conversion d'un nombre en double précision (double) se fait généralement en plusieurs étapes :

• Normalisation : Le nombre est converti en une forme binaire normalisée de la forme "1.xxxx" (partie fractionnaire après la virgule) multipliée par une puissance de 2.
• Calcul de l'exposant : L'exposant est déterminé en fonction du décalage nécessaire pour normaliser le nombre. Dans l'exemple ci-dessus, l'exposant serait 2.
• Application du biais : Un décalage, appelé "biais", est ajouté à l'exposant pour le rendre positif. Le biais est de 1023.
• Représentation des signes, exposants et mantisses : Le bit le plus significatif est utilisé pour le signe (0 pour positif, 1 pour négatif), suivie de la représentation de l'exposant (sur un certain nombre de bits) et de la mantisse (fraction binaire après le point, sur un certain nombre de bits).
• Assemblage des bits : Les bits du signe, de l'exposant et de la mantisse sont combinés pour former la représentation binaire du nombre en double précision.

float *

float f = 2;
float *my_float_addr = &f;


Remarque: my_float_addr = 0xab71

float *

float f = 1;
float *my_float_addr = &f;


Remarque: my_float_addr = 0xab71

double *

double d = 2;
double *my_double_addr = &d;


Remarque: my_double_addr = 0xab71

double *

double d = 2;
double *my_double_addr = &d;


Remarque: my_double_addr = 0xab71

printf: Afficher à l'écran

Type	Code de conversion
pointeur	%p


  printf("char : %p\n", my_char_addr);
  printf("short : %p\n", my_short_addr);
  printf("int : %p\n", my_int_addr);
  printf("long int : %p\n", my_long_int_addr);
  printf("float : %p\n", my_float_addr);
  printf("double : %p\n", my_double_addr);

L'opérateur de déréférenciation * est utilisé pour accéder à la valeur stockée à l'adresse mémoire pointée par un pointeur.

char c = 'a';
char *my_char_addr = &c;
printf ("%c", *my_char_addr);


• char *my_char_addr = &c : Un pointeur my_char_addr de type char est déclaré et reçoit l'adresse mémoire de la variable c à l'aide de l'opérateur d'adresse &. À présent, my_char_addr pointe vers l'emplacement en mémoire où la valeur 'a' est stockée.
• printf ("%c", *my_char_addr) : L'opérateur de déréférencement (*) est utilisé avec *my_char_addr pour accéder à la valeur stockée à l'adresse mémoire pointée par my_char_addr, qui est 'a'. La fonction printf affiche ensuite cette valeur 'a' à l'écran.

L'opérateur de déréférencement (*) est utilisé pour accéder et afficher la valeur de la variable c à travers le pointeur my_char_addr.

Pour distinguer l'opérateur * en tant qu'opérateur de déréférencement, vous pouvez vous appuyer sur le contexte dans lequel il est utilisé.

Déclaration de pointeur : Lorsque vous déclarez un pointeur, l'opérateur * est utilisé pour indiquer qu'il s'agit d'un pointeur. Par exemple :

char *my_char_addr = &c;


Dans ce contexte, * n'est pas un opérateur de déréférencement, mais plutôt une partie de la déclaration du pointeur.

Utilisation du pointeur : Lorsque vous utilisez un pointeur pour accéder à la valeur pointée, l'opérateur * est utilisé comme opérateur de déréférencement. Par exemple :

printf ("%c", *my_char_addr);
char d = *my_char_addr;


L'opérateur * est utilisé pour obtenir la valeur de la variable à laquelle my_char_addr pointe, c'est-à-dire la valeur de c.

L'opérateur * est utilisé pour manipuler un objet pointé lorsqu'il est utilisé avec un pointeur.

Exemple 1

char c = 'a';
char *my_char_addr = &c;
c = 'b';
*my_char_addr = 'c';
printf ("%c", c); //le caractère pointé par my_char_addr prend la valeur 'c'

L'opérateur * est utilisé avec *my_char_addr pour accéder et modifier la valeur stockée à l'adresse mémoire pointée par my_char_addr. Cela permet de changer la valeur de la variable c en modifiant directement la mémoire à l'emplacement indiqué par le pointeur.

L'opérateur * est utilisé pour manipuler un objet pointé lorsqu'il est utilisé avec un pointeur.

Exemple 2

int i = 0x20;
int *my_int_addr = &i;
*my_int_addr = 1;
*my_int_addr = *my_int_addr + 1; //i = 0x2
i = i + 3; //i = 0x5
printf ("%x", *my_int_addr); // 5


L'opérateur * est utilisé avec *my_int_addr pour accéder et modifier la valeur stockée à l'adresse mémoire pointée par my_int_addr. Cela permet de changer la valeur de la variable i en modifiant directement la mémoire à l'emplacement indiqué par le pointeur.

void *

char a = 'a';
char *cptr = &a;
int i = 1;
cptr = &i;

$ gcc ...
warning: assignment from incompatible pointer type [-Wincompatible-pointer-types]
cptr = &i;

void *

Un pointeur générique est un type spécial de pointeur qui peut contenir l'adresse mémoire de n'importe quel type de données, c'est-à-dire qu'il peut pointer vers n'importe quel type de variable. Le terme "générique" signifie que le pointeur n'a pas de type de données spécifique associé.

char a = 'a'; char *cptr = &a;
void *vptr = &a;

int i = 1; vptr = &i;

float f = 1; vptr = &f;

L'avantage principal d'un pointeur générique est sa polyvalence. Vous pouvez l'utiliser pour stocker l'adresse d'une variable de n'importe quel type,

Sans perte d'information

La conversion de type, également appelée "cast", consiste à changer le type d'une variable d'un type de données à un autre. Cependant, il est important de noter que certaines conversions peuvent entraîner une perte d'information, tandis que d'autres non.

• char-> short : Il n'y a généralement pas de perte d'information lors de la conversion de char à short, car char est généralement un type de données d'un octet et short est généralement de deux octets. La valeur char est simplement étendue à deux octets. Cependant, si la valeur char était négative, la conversion pourrait provoquer une extension signée, ce qui signifie que les bits de signe seraient étendus pour remplir la largeur du short.
• short-> int : la conversion de short à int ne provoque généralement pas de perte d'information. Les valeurs short sont simplement étendues pour remplir la largeur de l'int. Encore une fois, si la valeur short était négative, l'extension signée pourrait être appliquée.
• int-> long int : La conversion de int à long int ne provoque généralement pas de perte d'information non plus. Les valeurs int sont simplement étendues pour remplir la largeur du long int.

short s = 0xffff;
int i = s;


Avec perte d'information

• int-> float : Cette conversion peut entraîner une perte d'information, car les types int et float sont représentés différemment en mémoire. Les valeurs entières sont converties en valeurs à virgule flottante, ce qui signifie qu'elles peuvent perdre de la précision. Par exemple, un grand entier pourrait être tronqué si sa valeur est trop grande pour être représentée avec précision en tant que nombre à virgule flottante.

Exemple

int i = 0xffff;
float f = i;


Remarque: N'oubliez pas d'utiliser sizeof.

Les conversions explicites

Les conversions explicites, également appelées typecasts, sont des opérations dans lesquelles vous spécifiez explicitement le type de données vers lequel vous souhaitez convertir une variable.

short s = 0xffff;
float f = 30.999;
int i = (int) s;
int j = (int) f;


Remarque: Une conversion explicite (typecasting): (type)

void *

Lorsque vous souhaitez accéder aux données pointées par un pointeur générique, vous devez le convertir vers le type approprié.

char a = 'a';
char b = 'b';
char *cptr = &a;
void *vptr = &b;

cptr = (char *)vptr;



Écrivez un programme en utilisant char * et les opérateurs de pointeurs pour voir les octets d'une variable long int.

Tableau

est un ensemble d'éléments homogènes

Mais comment travailler avec un ensemble d'éléments hétérogènes?

Base de données de gestion des étudiants

char prenom[135][30];
char nom[135][30];
char rue[135][30];
char ville[135][30];
unsigned short notes[135];



Question: Quels sont les problèmes?

Base de données de gestion des étudiants

• Taille des tableaux fixe : Les tableaux 'prenom', 'nom', 'rue' et 'ville' sont définis avec une taille fixe de 135 éléments. Cela signifie que la base de données peut contenir un maximum de 135 étudiants. Si vous avez besoin de gérer plus d'étudiants, vous devez redimensionner manuellement ces tableaux, ce qui peut être fastidieux et source d'erreurs.
• Taille fixe des champs : Les champs 'prenom', 'nom', 'rue' et 'ville' sont également définis avec une taille fixe de 30 caractères. Cela peut poser problème si les noms ou les adresses des étudiants dépassent cette limite, car les données seront tronquées, ce qui peut entraîner une perte d'information.

Base de données de gestion des étudiants

• Manque de flexibilité : Cette base de données utilise des tableaux multidimensionnels pour stocker les informations des étudiants. Cela peut rendre la gestion des données moins flexible, notamment pour l'ajout ou la suppression d'étudiants.
• Aucune validation des données : Cette base de données n'inclut pas de mécanisme de validation des données. Par exemple, il n'y a pas de contrôle sur la validité des valeurs des notes (elles pourraient être en dehors de la plage attendue) ni sur les chaînes de caractères (par exemple, des adresses incorrectes pourraient être saisies).

Une structure (struct) est une construction de données en programmation permettant de regrouper plusieurs variables de types différents sous un seul nom, facilitant ainsi la manipulation et la gestion de données complexes.

struct etudiant{
 char prenom[30];
 char nom[30];
 char rue[30];
 char ville[30];
 short notes;
};

Avantages

• Flexibilité : Vous pouvez gérer un nombre variable d'étudiants en ajoutant ou en supprimant des éléments dans le tableau de structures.
• Structure de données plus appropriée : L'utilisation de structures permet de regrouper les données d'un étudiant en un seul objet, ce qui est plus naturel et lisible.

La déclaration et l'utilisation d'une structure

Ce code crée une variable d'une structure etudiant, et l'initialise avec les données spécifiques à un étudiant nommé Dupont Pierre.

struct etudiant dupont = { "Dupont", "Pierre", "Boulevard du 11 novembre 1918", "Villeurbanne", 19};

La déclaration et l'utilisation d'une structure

Ce code vise à définir une variable d'une structure "color:blue",>etudiant pour stocker les informations d'un étudiant particulier nommé "Dupont Pierre", avec une adresse et une note.

struct etudiant dupont;

strcpy(dupont.prenom, "Dupont");
strcpy(dupont.nom, "Pierre");
strcpy(dupont.rue, "Boulevard du 11 novembre 1918");
strcpy(dupont.ville, "Villeurbanne");
dupont.notes = 19;

Tableaux de structures

Ce code crée un tableau de structures nommé etudiant_cpe pouvant contenir jusqu'à 135 étudiants, puis il initialise le premier étudiant du tableau avec les données spécifiques à "Dupont Pierre" notamment son prénom, nom, adresse et note.

struct etudiant etudiant_cpe[135];

strcpy(etudiant_cpe[0].prenom, "Dupont");
strcpy(etudiant_cpe[0].nom, "Pierre");
strcpy(etudiant_cpe[0].rue, "Boulevard du 11 novembre 1918");
strcpy(etudiant_cpe[0].ville, "Villeurbanne");
etudiant_cpe[0].notes = 19;

Une structure dans une structure

Ce code définit deux structures, adresse et etudiant, où la structure etudiant contient une structure adresse comme l'un de ses membres. Cela permet de stocker les informations de l'étudiant, y compris son prénom, nom et adresse, de manière organisée et hiérarchique.

struct adresse{
 char rue[30];
 char ville[30];
};
struct etudiant{
 char prenom[30];
 char nom[30];
 struct adresse adresse;
 short notes;
};

Une structure dans une structure

Ce code définit une structure etudiant qui inclut une structure imbriquée adresse. Cela permet de regrouper les informations relatives à un étudiant, telles que son prénom, nom et notes, ainsi que ses données d'adresse, y compris la rue et la ville, de manière structurée et organisée.

struct etudiant{
 char prenom[30];
 char nom[30];
 struct adresse{
  char rue[30];
  char ville[30];
 } adresse;
 short notes;
};

Une structure dans une structure

Ce code crée un tableau de structures etudiant nommé etudiant_cpe pouvant contenir jusqu'à 135 étudiants. Il utilise la structure imbriquée adresse pour stocker les détails de l'adresse de l'étudiant.

struct etudiant etudiant_cpe[135];

strcpy(etudiant_cpe[0].prenom, "Dupont");
strcpy(etudiant_cpe[0].nom, "Pierre");
strcpy(etudiant_cpe[0].adresse.rue, "Boulevard du 11 novembre 1918");
strcpy(etudiant_cpe[0].adresse.ville, "Villeurbanne");
etudiant_cpe[0].notes = 19;

/* Fichier: bonjour2.c
* affiche un message à l'écran en utilisant un variable
* auteur: John Samuel
* Ceci est un commentaire sur plusieurs lignes
*/

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

int main() {
  int year = 2024; //déclaration d'un variable
  printf("Bonjour le Monde!!! C'est l'annee %d", year);
  return 0;
}

Les fonctions sont utilisées pour encapsuler des morceaux de code spécifiques dans un programme afin d'effectuer des opérations ou de calculer des résultats de manière modulaire et réutilisable.

Prototype: Le but de ce prototype est de fournir aux autres parties du programme des informations sur la manière d'appeler la fonction "add" et sur les types de données qu'elle attend et renvoie.

int add( int, int);

L'implémentation: Plutôt que de répéter le même code d'addition partout où vous en avez besoin dans votre programme, vous pouvez simplement appeler la fonction "add".

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

Les fichiers .h servent à déclarer les prototypes de fonctions et les structures de données pour permettre une séparation claire entre l'interface publique et la définition de fonctions dans les fichiers .c.

Prototype (operators.h)

int add( int, int);

L'implémentation (operators.c)

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

La déclaration d'une fonction consiste en un prototype qui spécifie le type de retour et les types des paramètres entre parenthèses, tandis que l'implémentation de la fonction utilise la même signature avec des noms de variables pour les paramètres et inclut le code à exécuter.

Prototype

type fonction( [type,]*);

L'implémentation

type fonction( [type variable,]*) {
 [return valeur];
}

Remarque: type: void, les types de base, les types composés

Les fichiers .h sont inclus à l'aide de #include pour permettre l'accès aux déclarations de fonctions, structures et variables définies dans le fichier d'en-tête, ce qui permet d'utiliser ces fonctionnalités dans d'autres parties du programme.

L'utilisation

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

int num1 = 20, num2 = 60;
int sum = add( num1, num2);


Remarque: Regardez l'utilisation de " " dans en-têtes

Prototype (nom.h)

void print( char *, int);

L'implémentation (nom.c)

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

void print( char * nom, int size ) {
 int i;
 for( i = 0; i < size && nom[i] != '\0'; i++) {
   printf( "%c", nom[i]);
 }
}

Remarque: Il n'y a pas de return

/* Fichier: bonjour3.c
* affiche un message à l'écran en utilisant print
* auteur: John Samuel
*/

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

int main() {
 print( "Bonjour le Monde!!!", 19);
 char message[] = "Pierre";
 print("Je suis ", 8);
 print(message, 19);
 return 0;
}

La compilation

$ gcc -o bonjour bonjour3.c nom.c

L'exécution

$./bonjour
Bonjour le Monde!!! Je suis Pierre

Remarque: un seul fichier C peut avoir une fonction nommée 'main'.

Les outils Linux

L'interface en ligne de commande (CLI) est un moyen d'interagir avec un système d'exploitation ou un logiciel en utilisant du texte, généralement en saisissant des commandes dans un terminal. Les commandes sont des instructions données à un système via une interface en ligne de commande, et les arguments sont des informations spécifiques fournies avec ces commandes pour indiquer ce qu'elles doivent faire

• $ ls -l
• $ cd dossier
• $ cat fichier

• ls -l utilise la commande "ls" pour lister les fichiers avec l'argument "-l" qui spécifie une liste détaillée
• cd dossier utilise la commande "cd" pour changer de répertoire vers "dossier"
• cat fichier utilise la commande "cat" pour afficher le contenu du fichier "fichier."

/* Fichier: bonjour4.c
* affiche un message à l'écran en utilisant les arguments de la ligne de commandes.
* auteur: John Samuel
*/

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

int main(int argc, char ** argv) {
 print("Bonjour le Monde. Je suis ", 26);
 print(argv[1], 20);
 print(argv[2], 20);
 print(argv[3], 20);
 print(argv[4], 20);
 return 0;
}

La compilation

$ gcc -o bonjour bonjour4.c nom.c

L'exécution

$./bonjour Pierre Dupont Lyon 69001
Bonjour le Monde. Je suis Pierre Dupont Lyon 69001

La fonction main prend deux arguments, int argc et char ** argv, qui permettent de passer des arguments lors de l'exécution du programme.

Le programme peut ainsi accéder et utiliser ces arguments pour effectuer des actions spécifiques en fonction de ces valeurs. Dans l'exemple donné, le programme "bonjour4.c" semble utiliser les arguments pour afficher un message de salutation personnalisé en fonction des noms et de l'adresse passés en arguments lors de son exécution.

• int argc représente le nombre total d'arguments passés au programme, y compris le nom du programme lui-même. Dans cet exemple, argc serait égal à 6, car il y a six arguments au total.
• char ** argv est un tableau de pointeurs vers des chaînes de caractères (tableau de chaînes de caractères) où chaque élément pointe vers un argument passé au programme. Dans cet exemple, argv contiendrait les éléments suivants :
  • argv[0] : Pointe vers le nom du programme, qui serait "bonjour" dans ce cas.
  • argv[1] : Pointe vers "Pierre"
  • argv[2] : Pointe vers "Dupont"
  • argv[3] : Pointe vers "Lyon"
  • argv[4] : Pointe vers "69001"
  • argv[5] : Pointe vers NULL (marquant la fin de la liste des arguments)

La compilation

/* Fichier: bonjour4.c
 * affiche un message à l'écran en utilisant
 * les arguments de la ligne de commandes. */

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

int main(int argc, char ** argv) {
 print("Bonjour le Monde. Je suis ", 26);
 if ( argc == 2 ) {
  print(argv[1], 20);
 }
 return 0;
}

Remarque: argv[0] est toujours le nom de la fichier exécutable (e.g., bonjour)

/* Fichier: string.c
* manipulation d'une chaine de caractères.
* auteur: John Samuel
*/

#include <stdio.h> // en-têtes(headers)
#include <string.h>

int main(int argc, char ** argv) {
 char nom[10];
 printf("Bonjour. Votre nom? ");
 scanf("%s", nom);
 printf("La taille: %lu\n", strlen(nom));
 return 0;
}

Objectif : L'objectif de la fonction strlen est de calculer la longueur (le nombre de caractères) d'une chaîne de caractères, c'est-à-dire le nombre de caractères qu'elle contient avant d'atteindre le caractère nul '\0' qui marque la fin de la chaîne.

La compilation

$ gcc -o strlen string.c

1^ere Exécution

$./strlen
Bonjour. Votre nom? John
La taille: 4


La compilation

2^eme Exécution

Lorsqu'un nom excessivement long est saisi, ce programme provoque une erreur de dépassement de pile (stack smashing).

$./strlen
Bonjour. Votre nom? : ABCDEFGHIJKLMNOPQRSTUVWXYZ
*** stack smashing detected ***: ./strlen terminated


/* Fichier: string.c
* manipulation d'une chaine de caractères.
* auteur: John Samuel
*/
#include <stdio.h> // en-têtes(headers)
#include <string.h>
int main(int argc, char ** argv) {
 char nom[10];
 printf("Bonjour. Votre nom? ");
 scanf("%s", nom);
 printf("La taille: %lu\n", strnlen(nom, sizeof(nom)));
 return 0;
}

Objectif : La fonction strnlen a pour objectif de calculer la longueur d'une chaîne de caractères en comptant le nombre de caractères présents jusqu'à ce qu'elle atteigne une taille maximale spécifiée. Elle permet ainsi de déterminer la longueur d'une chaîne tout en évitant les dépassements de mémoire potentiels. Cela aide à garantir la sécurité et la stabilité du programme en s'assurant qu'il n'essaie pas de lire au-delà de la taille maximale autorisée pour la chaîne de caractères.

/* Fichier: string.c
* scanf("%[0-9]s",...).
* auteur: John Samuel
*/
#include <stdio.h> // en-têtes(headers)
#include <string.h>
int main(int argc, char ** argv) {
 char nom[10];
 char sortie[100];
 printf("Bonjour. Votre nom? ");
 scanf("%9s", nom);
 sprintf(sortie, "La taille: %lu\n", strnlen(nom, sizeof(nom)));
 return 0;
}

Objectif: scanf("%9s", nom) lit une chaîne de caractères d'au plus 9 caractères depuis l'entrée standard et la stocke dans la variable nom, garantissant ainsi qu'aucun dépassement de mémoire ne se produit.

/* Fichier: string.c
* sprintf.
* auteur: John Samuel
*/
#include <stdio.h> // en-têtes(headers)
#include <string.h>
int main(int argc, char ** argv) {
 char nom[10];
 char sortie[100];
 printf("Bonjour. Votre nom? ");
 scanf("%9s", nom);
 sprintf(sortie, "La taille: %lu\n", strnlen(nom, sizeof(nom)));
 return 0;
}

Remarque: L'objectif de ce code est de formater une chaîne de caractères contenant la taille d'une autre chaîne (nom) limitée à un maximum de 10 caractères, puis de stocker ce résultat dans la variable sortie.

/* Fichier: string.c
* snprintf.
*/
#include <stdio.h> // en-têtes(headers)
#include <string.h>
int main(int argc, char ** argv) {
 char nom[10];
 char sortie[100];
 printf("Bonjour. Votre nom? ");
 scanf("%9s", nom);
 snprintf(sortie, sizeof(sortie), "La taille: %lu\n",
   strnlen(nom, sizeof(nom)));
 return 0;
}

Remarque: Utiliser snprintf au lieu de sprintf est une pratique plus sûre pour éviter les dépassements de mémoire potentiels.

/* Fichier: string.c
* atoi
* auteur: John Samuel
*/

#include <stdio.h> // en-têtes(headers)
#include <string.h>

int main(int argc, char ** argv) {
 char numstr[10] = "1024";
 int num = atoi(numstr);
 printf("Numéro: %d", num);
 return 0;
}

La fonction atoi en C a pour objectif de convertir une chaîne de caractères représentant un nombre entier en une valeur entière de type int. Elle ignore les espaces initiaux, lit les chiffres jusqu'à ce qu'elle atteigne un caractère non numérique, puis retourne la valeur entière correspondante.

/* sscanf */

#include <stdio.h> // en-têtes(headers)
#include <string.h>

int main(int argc, char ** argv) {
 int inum1, inum2;
 float fnum3 = 20;
 char numstr[10] = "10 20 30.33";
 sscanf(numstr, "%d %d %f", &inum1, &inum2, &fnum3);
 printf("Numéros: %d %d %f\n", inum1, inum2, fnum3);
 return 0;
}

La fonction sscanf permet de lire et de convertir des valeurs depuis une chaîne de caractères en fonction d'un format spécifié, stockant ces valeurs dans des variables, ce qui facilite l'extraction de données structurées à partir de chaînes de caractères formatées. La fonction sscanf analyse la chaîne numstr en recherchant des entiers et un nombre à virgule flottante délimités par des points-virgules, puis stocke ces valeurs dans les variables inum1, fnum2, et fnum3.

/* sscanf */

#include <stdio.h> // en-têtes(headers)
#include <string.h>

int main(int argc, char ** argv) {
 int inum1, inum2;
 float fnum3 = 20;
 char numstr[10] = "10;20;30.33";
 sscanf(numstr, "%d;%d;%f", &inum1, &inum2, &fnum3);
 printf("Numéros: %d %d %f\n", inum1, inum2, fnum3);
 return 0;
}

La fonction sscanf analyse la chaîne numstr en recherchant des entiers et un nombre à virgule flottante délimités par des espaces, puis stocke ces valeurs dans les variables inum1, fnum2, et fnum3.

La compilation

$ gcc -o strnlen string2.c

1^ere Exécution

$./strnlen
Bonjour. Votre nom? John
La taille: 4


• strcat concatene deux chaines de caractères
• strncat concatene deux chaines de caractères avec une taille maximum donnée par l'utilisateur.
• strcpy copie deux chaines de caractères
• strncpy copie deux chaines de caractères avec une taille maximum donnée par l'utilisateur
• strcmp compare deux chaines de caractères
• strncmp compare deux chaines de caractères avec une taille maximum donnée par l'utilisateur

/* Fichier: string3.c
* manipulation d'une chaine de caractères.
*/

#include <stdio.h> // en-têtes(headers)
#include <string.h>
int main(int argc, char ** argv) {
 char message[]= {"Bonjour"}, nom[]= {"John"}, string[20] = "";
 strncat(string, message, 19);
 strcat(string, " ");
 strncat(string, nom, 19);
 printf("%s", message));
 return 0;
}

/* Fichier: string4.c
* manipulation d'une chaine de caractères.
* auteur: John Samuel
*/
#include <stdio.h> // en-têtes(headers)
#include <string.h>
int main(int argc, char ** argv) {
 char message[]= {"Bonjour"}, nom[]= {"John"}, string[20] = "";
 strncpy(string, message, 19);
 strcpy(string, " ");
 strncpy(string, nom, 19);
 printf("%s", message));
 return 0;
}

La compilation

$ gcc -o strncat string3.c
$ gcc -o strncpy string4.c

1^ere Exécution

$./strncat
Bonjour John


2^eme Exécution

$./strncpy
John


#include <stdlib.h>

void * malloc( size_t size);
void * calloc( size_t nmemb, size_t size);
void free( void * ptr); // désallocation ou libération de mémoire


• malloc : Cette fonction alloue dynamiquement une région de mémoire de la taille spécifiée size en octets, et elle renvoie un pointeur vers le début de cette mémoire allouée. L'objectif est de permettre la création de structures de données dynamiques lorsqu'on ne connaît pas la taille exacte à l'avance.
• calloc : Cette fonction alloue dynamiquement une région de mémoire pour un tableau de nmemb éléments, chacun de size octets, initialisée à zéro, et elle renvoie un pointeur vers le début de cette mémoire allouée. Elle est couramment utilisée pour allouer de la mémoire pour des tableaux.
• free : Cette fonction libère la mémoire précédemment allouée dynamiquement à l'aide de malloc ou calloc. Son objectif est de libérer la mémoire inutilisée afin d'éviter les fuites de mémoire et d'optimiser l'utilisation des ressources mémoire dans un programme.

/* Fichier: memory.c
* Allocation dynamique de mémoire
* auteur: John Samuel
*/

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

int main(int argc, char ** argv) {
 char *content = malloc(10 * sizeof(char));
 strncat(content, "Bonjour", 10);
 free(content); //libération de mémoire
 return 0;
}

/* Fichier: memory.c
* Allocation dynamique de mémoire
* auteur: John Samuel
*/

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

int main(int argc, char ** argv) {
 char *content = calloc(10, sizeof(char));
 strncat(content, "Bonjour", 10);
 free(content); // libération de mémoire
 return 0;
}

Écrivez un programme qui réserve et libère un espace mémoire pour un tableau d'entiers (int, long int, short ou long long int) et un tableau de nombres en flottant (float, double ou long double) en utilisant malloc, calloc et free.

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.

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);
 }


Références

• Langage C, Claude Delannoy
• https://fr.wikipedia.org/wiki/Architecture_32_bits
• https://en.wikipedia.org/wiki/X86
• https://fr.wikipedia.org/wiki/Endianness
• https://fr.wikipedia.org/wiki/IEEE_754

Crédits d'images

• Wikimedia Commons