Langage C : Résumé II

Chapitre 7 - Compilation et modularisation

7.1 Compilateur

7.1.1 Phases de la compilation

Le compilateur C de gcc est un programme qui transforme un fichier texte codé en langage C en un fichier exécutable.

7.1.2 Prétraitement / pré-compilation

Le fichier source subit des transformations purement textuelles.

Les directives de prétraitement commencent par #. (constantes, macros, ...)

7.1.3 Compilation

La compilation traduit le fichier générer pendant le pré-traitement en un fichier texte contenant du code assembleur.

7.1.4 Assemblage

L'assemblage transforme le code assembleur en un fichier binaire, donc en instructions directement compréhensible par le processeur.

7.1.5 Edition de liens

Un fichier est souvent séparé en plusieurs fichiers sources.

Une fois le code source assemblé, il faut donc lier entre les différents fichiers objets. L'édition de liens produit alors soit un fichier exécutable, soit une bibliothèque de fonctions.

7.2 Outils gcc

7.2.1 Etapes de compilation avec gcc

7.2.2 Extensions de fichiers avec gcc

7.2.3 Compilateur gcc

7.3 Modularisation

7.3.1 Compilation directe

7.3.2 Construction de librairies

7.3.3 Compilation avec librairies

7.3.4 Edition de lien avec librairies

7.3.5 Visibilité des variables (extern)

Le mot clé extern permet de déclarer la variable sans la définir, pour indiquer qu'elle est définie ailleurs.

7.3.6 Visibilité des fonctions

Une fonction déclarée avec le mot-clé static n'est utilisable que dans le fichier où elle est déclarée.

Par défaut, une fonction est globale, elle est donc accessible depuis n'importe quelle fonction.

7.3.7 Modularisation

Le but de la modularisation est de pouvoir gérer des gros programmes informatiques avec de nombreux développeurs :

• décomposition d'un code en modules
• Organisation hiérarchique des modules
• Regroupement par thèmes des modules
• Encapsulation : cacher le code, donner accès par des headers
• Type abstrait : cacher, si possible, les types de données
• Développement et tests de chaque module indépendamment
• Possibilité de la modification du cœur d'un module sans en toucher l'interface.

7.4 Outil make

C'est un script basé sur des dépendances qui permet :

• de compiler automatiquement des programmes
• de n'exécuter que des commandes nécessaires

Le fichier makefile décrit :

1. Les dépendances qu'il y a entre les fichiers intervenants dans la construction d'un exécutable
2. Les commandes (gcc, OS, ou autres) à lancer pour construire l'exécutable.

7.4.1 Règles de dépendances explicites

Une règle de dépendance est composée de trois parties :

1. Une cible (target)
2. Une liste de dépendances (sous-buts)
3. Des commandes de mise à jour

Syntaxe :

Chapitre 8 - Tableaux, structures, ...

8.1 Tableaux

8.1.1 Description

Un tableau est un ensemble d'éléments contigus en mémoire.

Tous les éléments sont de même type et sont référencés par un indice entier $i\in [0,n-1]$$i \in \left[ 0,n-1 \right]$ où $n$$n$ est le nombre total d'éléments du tableau.

8.1.2 Déclaration

xxxxxxxxxx
1
1
<type> <arrayName> [<size>], ... ;

• <type> : type des éléments du tableau (int, char, float, ...)
• <arrayName> : nom du tableau
• <size> : taille du tableau, càd le nombre d'éléments qu'il contiendra au maximum.

Depuis C99, la taille d'un tableau peut être issu d'une variable (la taille du tableau n'est donc pas connue à la compilation mais uniquement à l'exécution).

8.1.3 Initialisation

• On peut initialiser tous les éléments d'un tableau directement à sa déclaration
• On peut faire une initialisation partielle à la déclaration
• En mettant des accolades, on peut omettre la taille du tableau
• On peut affecter une valeur à un élément particulier d'un tableau

On peut initialiser toutes les valeurs d'un tableau à 0 avec :

xxxxxxxxxx
1
1
int array [100] = {}; // les 100 éléments vaudront 0

Il n'est pas possible d'affecter globalement tout le contenu d'un tableau à un autre avec un opérateur = !

Attention : le compilateur ne vérifie pas si les indices utilisés sont dans les limites du tableau. On peut alors lire ou modifier des cases mémoires qui n'appartiennent plus au tableau sans que le programme ne nous avertisse.

8.1.4 Tableau de valeurs constantes

Il est permis de déclarer des tableaux de valeurs constantes en définissant le type des éléments par const.

Il est ensuite impossible de modifier les valeurs de ce tableau (les valeurs sont constantes).

8.1.5 Taille des tableaux

Il est possible de connaitre la taille d'un tableau en bytes grâce à la fonction sizeof. On peut également l'utiliser pour connaitre le nombre de bytes que prend une variable ou un type.

xxxxxxxxxx
3
1
int data[100]; 
2
sizeof(data) // 400
3
sizeof(int) // 4

8.1.6 Tableaux multidimensionnels

xxxxxxxxxx
1
1
<type> <arrayName> [N1][N2]...[Ni]

Déclaration

xxxxxxxxxx
2
1
int data [10][20]; // 2 dimensions
2
float values [10][20][30]; // 3 dimensions

Initialisation

xxxxxxxxxx
1
1
int matrix [2][4] = {{1,2,3,4}, {5,6,7,8}};

Accès aux éléments

xxxxxxxxxx
2
1
int values [2][3] = {{1,2,3}, {4,5,6}};
2
int nb = values[0][2] // nb = 3

8.2 Chaînes de caractères

8.2.1 Définition

Une chaîne de caractères est un tableau unidimensionnel de type char, terminé par le caractère NULL (0x00, 0 ou '\0').

Exemple :

xxxxxxxxxx
1
1
char bonjour[] = {'b', 'o', 'n', 'j', 'o', 'u', 'r', '\0'};

On peut aussi déclarer une chaîne constante avec des guillemets :

xxxxxxxxxx
1
1
char bonjour[] = "bonjour";

8.2.2 Chaînes de caractères et I/O

printf et scanf supportent la saisie et l'affichage de chaînes de caractères avec la spécification de format %s.

printf affiche tous les caractères de la chaîne jusqu'au caractère de fin (exclu).

scanf("%s", ...) récupère tous les caractères saisis jusqu'au premier séparateur (espace ou fin de ligne). '\0' va automatiquement être ajouté à la fin de la chaîne.

8.3 Structures

8.3.1 Définition

Les structures permettent de désigner sous un seul nom, un ensemble de valeurs pouvant être de type différents.

8.3.2 Syntaxe

xxxxxxxxxx
7
1
struct <id> 
2
{
3
    <type1> <n1>;
4
    <type2> <n2>;
5
    ...
6
    <typeN> <nN>;
7
}<var1>, ... ;

<id> ou <var> sont optionnels (l'un ou l'autre).

8.3.3 Déclaration de variables de type structure

Déclaration

xxxxxxxxxx
1
1
struct PatientFile client1;

Déclaration et initialisation

xxxxxxxxxx
5
1
struct PatienFile
2
    client1 = {"Jules", 25, 176, 72},
3
    client2 = {"Eva", 18},
4
    client3 = {"Charles", .weight=87};
5

8.3.4 Accès aux membres

On accède à un membre d'une variable de type structure avec l'opérateur point .

xxxxxxxxxx
1
1
<variable>.<membre>

Syntaxe

xxxxxxxxxx
3
1
struct PatientFile myPatient;
2
myPatient.height = 190.0;
3
strcpy(myPatient.name, "Edgar");

8.3.5 Imbrications

Exemple

xxxxxxxxxx
11
1
struct Date
2
{
3
    short day, month, year;
4
};
5

6
struc PatientFileB
7
{
8
    char name[32];
9
    struct Date birthDate;
10
    float height;
11
};

xxxxxxxxxx
1
1
struct PatientFileB marc = {"Marc", {01,01,1990}, 190.0};

8.3.6 Accès aux membres de structures imbriquées

Exemple

xxxxxxxxxx
3
1
struct PatientFileB jeanne;
2
jeanne.height = 173.5;
3
jeanne.birthDate.year = 1992;

8.3.7 Affectation de structures

Possible uniquement si les deux structures sont de même type.

Exemple

xxxxxxxxxx
4
1
struct PatientFile jean = {"Jean", ...};
2
struct PatientFile marc;
3

4
marc = jean; // tout le contenu est recopié

8.3.8 Structures et fonctions

Une fonction peut retourner un résultat de type structure ou un pointeur sur une structure :

xxxxxxxxxx
1
1
struct MyStruct function1(...);

Une structure peut également être passée comme paramètre à une fonction :

xxxxxxxxxx
4
1
void function1(struct MyStruct s1)
2
{
3
    ...
4
}

8.4 typedef

Le langage C permet de renommer des types en leur donnant un synonyme.

L'intérêt est de simplifier l'écriture et la lecture du code ainsi que pour favoriser la portabilité du code.

Pour déclarer un nouveau type, on utilise le mot-clé typedef.

8.4.1 Type synonyme standard

Syntaxe

xxxxxxxxxx
1
1
typedef <type std> <synonyme>;

Exemple

xxxxxxxxxx
5
1
typedef unsigned int uint32;
2
typedef unsigned char uint8;
3

4
uint32 n1 = 423; // équivalent à "unsigned int n1 = 3;"
5
uint8  n2 = 123; //...

8.4.2 Type synonyme pour un tableau

Syntaxe

xxxxxxxxxx
1
1
typedef <type std> <synonyme> [<n>];

Exemple

xxxxxxxxxx
2
1
typedef char str[80];
2
str s1; // équivalent à " char str[80]; "

8.4.3 Type synonyme pour structure

Syntaxe

xxxxxxxxxx
1
1
typedef <déf structure> <synonyme>;

Exemple

xxxxxxxxxx
5
1
typedef struct
2
{
3
    int x, y;
4
} Coord;
5
Coord pt1;

Chapitre 9 - Pointeurs

9.1 Accès à la mémoire

9.1.1 Adressage direct

On accède au contenu d'une variable par le nom de la variable.

xxxxxxxxxx
1
1
printf("%d", x); // x vaut 40

9.1.2 Adressage indirect

On accède au contenu d'une variable par son adresse ou par un pointeur (variable qui contient l'adresse).

xxxxxxxxxx
1
1
printf("%d", *3F06); // 40 est contenu dans la case 3F06

9.2 Pointeurs

9.2.1 Définition

Les pointeurs sont des variables qui mémorisent les adresse physiques de la mémoire. Cela nous permet d'accéder à un emplacement mémoire.

Une variable permet d'accéder à un emplacement mémoire.

Un pointeur permet d'accéder à n'importe quel emplacement mémoire. C'est une variable qui contient l'adresse d'une autre variable.

9.2.2 Adresse d'une variable

L'adresse d'une certaine variable est obtenue avec l'opérateur &.

xxxxxxxxxx
1
1
&x // ceci représente l'adresse de la variable x

9.2.3 Déclaration d'un pointeur

Syntaxe

xxxxxxxxxx
1
1
<type> *<variable>;

Le type correspond au type de la case mémoire pointée. On utilise le symbole * pour le différencier d'une variable ordinaire lors de sa déclaration.

9.2.4 Opérateur de déréférencement *

Soit un pointeur px pointant sur la variable x. On peut afficher la valeur de la variable x à partir du pointeur déréférencé :

xxxxxxxxxx
1
1
printf("%d", *px); // on affiche le contenu de x 

On peut également écrire des valeurs dans x de cette manière :

xxxxxxxxxx
1
1
*px = 20; // x vaudra maintenant 20 

9.2.5 Pointeurs particuliers

pointeur NULL

On utilise la constante NULL pour indiquer qu'un pointeur ne contient pas encore d'adresse valide. Dans l'idéal, il faudrait toujours initialiser les pointeurs à la constante NULL.

xxxxxxxxxx
1
1
int *px = NULL;

Type void*

Ce type est utilisé quand on ne sait pas encore le type sur lequel va pointer le pointeur.

xxxxxxxxxx
1
1
void *p; 

Chapitre 10 - Allocation dynamique

10.1 Allocation statique vs dynamique

10.1.1 Allocation mémoire statique et sizeof

On cherche la taille que prend une certaine variable ou constante en mémoire.

Pour ça, on utilise l'opérateur unaire sizeof.

L'opérateur sizeof donne, en octets :

• la taille d'une variable
• la taille d'une constante
• la taille d'un type

Syntaxe :

xxxxxxxxxx
3
1
sizeof <var>
2
sizeof <const>
3
sizeof(<type>)

10.1.2 Allocation dynamique

Si on ne connait pas la taille des données avant l'exécution, on peut réserver une place suffisante en mémoire. Or, on est presque sûr qu'une partie de cette place réservée ne sera jamais utilisée.

Pour éviter ça, le programmeur peut lui-même gérer l'allocation mémoire en fonction des besoins au moment de l'exécution, avec un mécanisme d'allocation dynamique.

10.1.3 Fonction malloc

La fonction malloc réserve dynamiquement de la mémoire lors de l'exécution du programme.

Syntaxe :

xxxxxxxxxx
1
1
void* malloc(int N)

N nombre de bytes à réserver.

retour : adresse de type void* d'un bloc mémoire de N octets (réservé pour nous). Si espace insuffisant : renvoie NULL

10.1.4 Fonction free

La fonction free libère la mémoire précédemment réservée avec malloc.

Syntaxe :

xxxxxxxxxx
1
1
free(<adress>)

La mémoire est libérée automatiquement à la fin du programme, même si la fonction free n'a pas été utilisée.

10.1.5 Fuite mémoire

Si on perd l'adresse d'un bloc de mémoire qui nous a été alloué (avec malloc) sans l'avoir préalablement libéré avec free, on parle de fuite mémoire.

Bonne pratique : affecter la valeur NULL au pointeur immédiatement après avoir libéré la mémoire.

10.2 Allocation de variables en mémoire

10.2.1 Organisation mémoire

Chapitre 11 - Pointeurs et fonctions II

11.1 Pointeurs de pointeurs et arithmétique

11.1.1 Pointeur de pointeur

Soit une variable a. *ptr_a = &a est un pointeur sur la variable a. ptr_a contient alors la valeur de l'adresse de la variable a. Or, cette valeur est elle aussi stockée quelque part dans la mémoire, précisément à l'adresse ptr_b = &ptr_a. La valeur stockée en a est alors accessible par a ou par *ptr_a ou par **ptr_b. **ptr_b est un pointeur double sur a.

11.1.2 Arithmétique des pointeurs

Affectation

Soient ptr1 et ptr2 deux pointeurs sur le même type de données, alors ptr1 = ptr2 fait pointer ptr1 sur le même "objet" que ptr2

Addition et soustraction entière

Si ptr pointe sur l'élément a[i] d'un tableau, alors :

• ptr+n pointe sur a[i+n]
• ptr-n pointe sur a[i-n]

Soustraction de deux pointeurs

Soient ptr1 et ptr2 deux pointeurs pointant sur le même tableau.

ptr2-ptr1 fournit le nombre d'éléments compris entre ptr1 et ptr2.

Si le résultat de la soustraction est :

• positif : ptr1 précède ptr2
• nul : ptr1 = ptr2
• négatif : ptr2 précède ptr1
• indéfini : les pointeurs ne pointent pas sur le même tableau

11.2 Interaction d'un programme avec l'OS

La fonction main() :

• renvoie une valeur avec return

• reçoit des valeurs de l'OS avec :

  • une liste d'arguments : int main (int argc, char **argv);
  • des variables d'environnement

11.3 Passage de tableaux en paramètre

11.3.1 Tableau unidimensionnel comme argument

Passer un tableau en argument correspond en réalité à passer une copie de son adresse.

xxxxxxxxxx
2
1
float tab[4] = {1, 2, 3, 4};
2
function(tab);

L'argument est donc un pointeur sur une variable de type float :

xxxxxxxxxx
3
1
void function(float *array)
2
// ou 
3
void function (float array[])

11.4 Pointeurs de fonctions

En C, comme pour les variables, chaque fonction possède une adresse définie. On peut alors mémoriser cette dernière dans une variable (pointeur) qui contiendra l'adresse de la fonction :

xxxxxxxxxx
1
1
<type> (* ptrSurFonction) (<args>);

Exemple :

Tableau de pointeurs de fonctions

xxxxxxxxxx
1
1
<type> (* tabPtrFonctions [taille]) (<args>);

Résumé

11.5 Callback

Une fonction de rappel [callback] est une fonction qui est passée en argument à une autre fonction. Cette dernière peut alors faire usage de cette fonction de rappel comme de n'importe quelle autre fonction, alors qu'elle ne la connait pas par avance. (Wikipédia)

Exemples d'application

• programmation évènementielle : associer une action à un évènement
• fonction dont le comportement peut être modifié : tri croissant / décroissant, il suffit de passer la fonction en argument selon le mode choisi

Chapitre 12 - Structures et types composés

12.1 Champs de bits

Structure particulière qui permet de compacter et d'aligner les données. Chaque membre de la structure est défini comme un champ en précisant à la fin de sa déclaration le nombre de bits qu'il occupe.

Déclaration

xxxxxxxxxx
6
1
struct <name>
2
{
3
    <type1> <member1> : <nb_bits> ;
4
    <type2> <member2> : <nb_bits> ;
5
    ....
6
};

Remarques

1. Les types des champs doivent être entiers
2. Il n'est pas possible de prendre l'adresse d'un champ
3. Les exécutables contenant des champs de bits ne sont pas portables

12.2 union

Les unions permettent de stocker des objets de type différents dans un même espace mémoire. Cela signifie que l'on ne peut pas sauvegarder deux informations de types différents en même temps !

xxxxxxxxxx
6
1
union <name>
2
{
3
    <type1> <member1>;
4
    <type2> <member2>;
5
    ...
6
};

La taille d'un variable de type union est fixe ; elle est égale à la taille nécessaire pour stocker le membre le plus grand.

12.3 enum

Les énumérations permettent d'attribuer un identificateur à un entier grâce au déclarateur d'énumération enum.

xxxxxxxxxx
6
1
enum <name>
2
{
3
    <id1> [= val1],
4
    <id2> [= val2],
5
    ...
6
};

12.4 typedef

Le langage C permet de renommer des types en leur donnant un synonyme avec le mot-clé typedef.

12.4.1 typedef struct

xxxxxxxxxx
1
1
typedef struct {<définition de la structure>} <type_name> ;

12.4.2 typedef enum

xxxxxxxxxx
1
1
typedef enum {<enumeration>} <enum_name>;

12.4.3 typedef de pointeur de fonction

xxxxxxxxxx
1
1
typedef <type_retour> (*<type_name>) (<arg_type_1>, <arg_type_2, ...);

Chapitre 13 - structures de données dynamiques : listes chaînées

13.1 Introduction

Les listes chaînées répondent au problème que l'on rencontre quand la taille, la quantité ou l'organisation des données varie au cours du temps et qu'il n'est pas possible de les prédire au moment de la compilation.

On va alors utiliser des structures dynamiques.

Le principe de base est que chaque membre de la liste est le successeur ou le prédécesseur d'un autre membre de cette même liste. Pour cela, on utilisera des pointeurs sur des structures. De cette manière, il devient possible d'accéder à un membre à partir d'un autre.

Il existe plusieurs types de structures dynamiques :

13.2 Exercice complet

main.c

xxxxxxxxxx
36
1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <stdbool.h>
4
#include "structures.h"
5

6
#include "node.h"
7
#include "node.c"
8

9
int main(int argc, char *argv[])
10
{
11
    /* your code here ...   */
12

13
    node *head = ask_numbers_and_get_head();
14

15
    if (head == NULL)
16
    {
17
        printf("\nEmpty list !\n");
18
        return 1;
19
    }
20

21
    printf("\n\ncontenu de la liste chainee : \n");
22
    print_node(head);
23

24
    inc_node(head);
25

26
    printf("\n\nchaque element de la liste chainee incremente de 1 : \n");
27
    print_node(head);
28

29
    printf("\n\n");
30
    free_node(head);
31

32
    /* end of the program   */
33
    printf("\n\n----- program finished-------\n\n");
34
    system("PAUSE");
35
    return 0;
36
}

structures.h

xxxxxxxxxx
12
1
#ifndef STRUCTURES_H_
2
#define STRUCTURES_H_
3

4
struct node
5
{
6
    int nb;
7
    struct node *next;
8
};
9

10
typedef struct node node;
11

12
#endif

node.c

xxxxxxxxxx
81
1
#include "structures.h"
2
#include <stdlib.h>
3
#include <stdio.h>
4
#include <stdbool.h>
5
#include "node.h"
6

7
node *ask_numbers_and_get_head(void)
8
{
9
    node *head = NULL;   /* initialisation of pointer on node structure at NULL*/
10
    bool toExit = false; /*variable to determine if we have to stop asking user for more numbers. True if we have to stop, false if not */
11

12
    printf("Entrez des nombres, separes par ENTER, puis entrez 0 pour terminer\n\n");
13

14
    do
15
    {
16
        static int i = 0;                             /* index variable to show values count */
17
        node *element = (node *)malloc(sizeof(node)); /* creates a new element that will contain the number entered by user */
18
        element->nb = 0;                              /* initializes the number variable of the element at 0 */
19
        element->next = NULL;                         /* initializes the pointer on next element at NULL */
20

21
        printf("valeur %d : ", ++i); /* displays prompt */
22
        scanf("%d", &(element->nb)); /* store input in current element */
23

24
        if (element->nb != 0) /* if the user has not entered a 0 */
25
        {
26
            add_node(&head, element); /* adds the current element to the list */
27
        }
28
        else
29
        {
30
            free(element); /* frees the element we just created, it only contains the 0 value */
31
            toExit = true; /* set toExit variable to true because we want to exit the do while loop */
32
        }
33

34
    } while (!toExit); /* continues loop while toExit variable is not set to false */
35

36
    return head; /* return the pointer on the first element of the list we just created */
37
}
38

39
void inc_node(node *current)
40
{
41
    if (current->next != NULL) /* if the next element exists */
42
    {
43
        inc_node(current->next); /* calls the same function we are in */
44
    }
45
    ++current->nb; /* increments the number value of current element */
46
}
47

48
void add_node(node **head, node *new)
49
{
50
    if (*head == NULL) /* if we are creating the first element of the list */
51
    {
52
        *head = new;          /* the head is the element previously created */
53
        (*head)->next = NULL; /* the next element does not exist yet  */
54
    }
55
    else /* for all other elements */
56
    {
57
        new->next = *head; /* the element after the element we just created is the previous head */
58
        *head = new;       /* the head is now the element we just created */
59
    }
60
}
61

62
void print_node(node *current)
63
{
64
    printf("\n0x%p : %d", current, current->nb); /* prints the content of the current element with its address */
65

66
    if (current->next != NULL) /* if next element exits */
67
    {
68
        print_node(current->next); /* calls the function we are in to print next element */
69
    }
70
}
71

72
void free_node(node *current)
73
{
74
    if (current->next != NULL) /* if next element exists */
75
    {
76
        free_node(current->next); /* calls the same function we are in to free next element first */
77
    }
78

79
    printf("\nfreeing 0x%p", current);
80
    free(current); /* frees the last element of the list */
81
}

node.h

37
1
#ifndef NODES_H_
2
#define NODES_H_
3

4
#include "structures.h"
5

6
/* 
7
    Recursive function that prints the specified list. The function ends when current->next is NULL. 
8
    node *current : pointer on node structure where to begin the printing
9
*/
10
void print_node(node *current);
11

12
/* 
13
    Recursive function that frees the specified list. The function ends when current->next is NULL.
14
    node *current : pointer on node structure where to begin the memory freeing
15
*/
16
void free_node(node *current);
17

18
/*
19
    This function adds a node at the beginning of the specified list
20
    node **head : pointer on a pointer on node structure where the current head is. 
21
    node * new : pointer on a node structure that we want to add at the beginning of the list. 
22
*/
23
void add_node(node **head, node *new);
24

25
/*
26
    Recursive function that increments all the numeric members of the list (i.e. current->nb). The function ends when current->next is NULL.
27
    node *current : pointer on node structure where to begin the incrementation
28
*/
29
void inc_node(node *current);
30

31
/*
32
    This function asks user to enter a set of integer numbers. It stops for asking when the user enters a 0. 
33
    The function returns a pointer on node structure that is the head of a linked list, containing all the numbers entered by the user. 
34
*/
35
node *ask_numbers_and_get_head(void);
36

37
#endif