Kant1/French_Wikibooks_articles · Datasets at Hugging Face

text stringlengths 0 211k
À cause de la grande quantité de code existant à l'époque qui reposait sur ce comportement, le C90 a conservé cette possibilité. Cependant, elle a été retirée de la norme C99, et est à éviter même lorsqu'on travaille en C90.
En effet, c'est plus qu'une bonne habitude de programmation de s'assurer que "chaque" fonction utilisée dans un programme ait son prototype déclaré avant qu'elle ne soit définie ou utilisée. C'est d'autant plus indispensable lorsque les fonctions sont définies et utilisées dans des fichiers différents.
Ancienne notation.
À titre anecdotique, ceci est la façon « historique » de définir une fonction, avant que le prototypage ne fut utilisé. Cette notation est interdite depuis C90.
type_retour fonction(par1, par2, ..., parN)
type1 par1;
type2 par2;
typeN parN;
/* Déclarations de variables ... */
/* Instructions ... */
Au lieu de déclarer les types à l'intérieur même de la fonction, ils sont simplement décrits après la fonction et avant la première accolade ouvrante. À noter que codice_2 "pouvait" être omis, et dans ce cas valait par défaut codice_29.
Fichiers.
Exécuter des fichiers.
Les primitives sont "execl, execlp, execle, exect, execv, execvp".
L'exemple ci-dessous lance un fichier "test.exe" sur un bureau de Windows 7 :
int main()
int fichier;
fichier = execl ( "c:\\Users\\public\\Desktop\\test.exe", "test.exe", ".", (char*)0);
Renommer et supprimer des fichiers.
Utiliser la fonction "rename" (appel système) pour renommer un fichier.
Utiliser "remove" (bibliothèque C, tous types de fichiers) ou "unlink" (appel système pour supprimer un fichier) et "rmdir" (appel système pour supprimer un répertoire).
Attention, "remove", "unlink" et "rmdir" ne suppriment pas réellement le fichier ou répertoire, mais uniquement un nom (lien statique ou "dur" (hardlink)) dudit fichier ou répertoire. Si le nom en question est le dernier nom du fichier ou répertoire, alors le système de fichiers n'a plus de référence vers le fichier qui n'est dès lors plus accessible et l'espace qu'il occupait est disponible pour d'autres fichiers. Les données ne sont aucunement effacées, seul le lien permettant d'y accéder est détruit. Si le fichier avait plusieurs noms il reste accessible par ses autres noms. La commande "ln ancien_nom nouveau_nom" permet de donner un nom supplémentaire "nouveau_nom" au fichier "ancien_nom".
Copier des fichiers.
Il faut copier le contenu du premier dans le second.



Programmation C/Types avancés

Structures.
struct ma_structure {
type1 champ1;
type2 champ2;
typeN champN;
} var1, var2, ..., varM;
Déclare une structure (ou enregistrement) "ma_structure" composé de N champs, "champ1" de type "type1", "champ2" de type "type2", etc. On déclare, par la même occasion, M variables de type "struct ma_structure".
Accès aux champs.
L'accès aux champs d'une structure se fait avec un point :
struct complexe {
int reel;
int imaginaire;
} c;
c.reel = 1;
c.imaginaire = 2;
Initialisation.
Il y a plusieurs façons d'initialiser une variable de type structure :
Manipulation.
La seule opération prise en charge par le langage est la copie, lors des affectations ou des passages de paramètres à des fonctions. Toutes les autres opérations sont à la charge du programmeur, notamment la comparaison d'égalité (cf. section suivante).
Alignement et bourrage (padding).
Il s'agit d'un concept relativement avancé, mais qu'il est bien de connaitre pour agir en connaissance de cause. Lorsqu'on déclare une structure, on pourrait naïvement croire que les champs se suivent les uns à la suite des autres en mémoire. Or, il arrive souvent que des octets soient intercalés entre les champs.
Considérez la structure suivante:
struct ma_structure {
char champ1; /* 8 bits */
int champ2; /* 32 bits */
char champ3; /* 8 bits */
On pourrait penser que cette structure occupera 6 octets en mémoire, et pourtant, sur une bonne partie des compilateurs, on obtiendrait une taille plus proche des 12 octets.
En fait, les compilateurs insèrent quasiment toujours des octets entre les champs pour pouvoir les "aligner" sur des adresses qui correspondent à des mots machines. Cela est dû à une limitation de la plupart des processeurs, qui ne peuvent lire des « mots » de plus d'un octet que s'ils sont alignés sur un certain adressage (alors qu'il n'y a pas de contrainte particulière pour lire un seul octet, si le type codice_1 est défini sur 8bit).
En se représentant la mémoire comme un tableau continu, on peut tracer le dessin suivant:
Les cases codice_2, codice_3, codice_4, ... représentent des octets, et les "blocs" des sections de 32 bits. Si on suppose qu'une variable de type codice_5 doive être placée en mémoire à partir du bloc numéro N, alors un compilateur pourra, pour des raisons de performance, placer codice_6 en codice_2, codice_8 de codice_9 à codice_10, et codice_11 en codice_12. Cela permettrait en effet d'accéder simplement à codice_8: le processeur fournit des instructions permettant de lire ou d'écrire directement le bloc N + 1. Dans ce cas, les octets de codice_3 à codice_15 ne sont pas utilisés; on dit alors que ce sont des octets "de bourrage" (ou "padding" en anglais).
Un autre compilateur (ou le même, appelé avec des options différentes) peut aussi placer codice_8 de codice_3 à codice_9, et codice_11 en codice_20, pour optimiser l'utilisation mémoire. Mais alors il devra générer un code plus complexe lors des accès à codice_8, le matériel ne lui permettant pas d'accéder en une seule instruction aux 4 octets codice_3 à codice_9.
En fait il faut garder à l'esprit que toutes les variables suivent cette contrainte: aussi bien les variables locales aux fonctions, les champs de structures, les paramètres de fonctions, etc.
L'existence d'octets de bourrage ainsi que leur nombre sont non seulement dépendants de l'architecture, mais aussi du compilateur. Cela dit, il est toujours possible de connaître la « distance » ("offset") d'un champ par rapport au début de la structure, et ce, de manière portable. Pour cela il existe une macro, déclarée dans l'entête codice_24:
size_t offsetof(type, champ);
La valeur renvoyée est le nombre de codice_1 (i.e. d'octets la plupart du temps), entre le début de la structure et celui du champ. Le premier argument attendu est bel et bien le "type" de la structure et non une variable de ce type, ni un pointeur vers une variable de ce type. Pour s'en souvenir, il suffit de savoir que beaucoup d'implémentations d'codice_26 utilisent une arithmétique de ce genre:
size_t distance = (size_t) &((type *)NULL)->champ;
Si codice_27 était un pointeur, il faudrait faire un déréférencement supplémentaire (ou éviter l'étoile dans la macro). À noter que, même si cette macro peut s'avérer contraignante (notamment lorsqu'on ne dispose que de type pointeur), il est quand même préférable de l'utiliser pour des raisons de portabilité.
Voici un petit exemple d'utilisation de cette macro:
struct ma_structure {
char champ1;
int champ2;
char champ3;
int main(void)
/* en C99 */
printf("L'offset de 'champ2' vaut %zu.\n",
offsetof(struct ma_structure, champ2));

/* en C90 */
printf("L'offset de 'champ2' vaut %lu.\n",
(unsigned long) offsetof(struct ma_structure, champ2));
return 0;
Sur une architecture 32 bits, vous obtiendrez très certainement la réponse:
En fait toute cette section était pour souligner le fait qu'il est difficilement portable de comparer les structures comme des blocs binaires (via la fonction codice_28 par exemple), car il n'y a aucune garantie que ces octets de bourrage soient initialisés à une certaine valeur. De la même manière, il est sage de prendre quelques précautions avant de transférer cette structure à l'extérieur du programme (comme un fichier, un tube de communication ou une socket IP). En général, il préférable de traiter la structure champ par champ, pour ce genre d'opérations.
Mais comme rien n'est toujours totalement négatif, les conséquences du bourrage offre énormément de souplesse :
imaginons 2 structures:
struct str {
char *string;
struct str_ok {
char *string;
size_t len;
quelle que soit la structure utilisé, on peut avec l'adresse et la cast (struct str *) accéder à la chaine.
int main (void)
struct str s = { "chaine" };
struct str_ok sok = { "chaine", 0 };
void *p = &sok;
if (((struct str *)p)->string)
sok.len = strlen(sok.string);
printf("%s\n", ((struct str *)p)->string);
/* en revanche: Peut-être très dangereux ! */
p = &s;
printf("%s\n",((struct str_ok *)p)->string);

À cause de la grande quantité de code existant à l'époque qui reposait sur ce comportement, le C90 a conservé cette possibilité. Cependant, elle a été retirée de la norme C99, et est à éviter même lorsqu'on travaille en C90.

En effet, c'est plus qu'une bonne habitude de programmation de s'assurer que "chaque" fonction utilisée dans un programme ait son prototype déclaré avant qu'elle ne soit définie ou utilisée. C'est d'autant plus indispensable lorsque les fonctions sont définies et utilisées dans des fichiers différents.

Ancienne notation.

À titre anecdotique, ceci est la façon « historique » de définir une fonction, avant que le prototypage ne fut utilisé. Cette notation est interdite depuis C90.

type_retour fonction(par1, par2, ..., parN)

type1 par1;

type2 par2;

typeN parN;

/* Déclarations de variables ... */

/* Instructions ... */

Au lieu de déclarer les types à l'intérieur même de la fonction, ils sont simplement décrits après la fonction et avant la première accolade ouvrante. À noter que codice_2 "pouvait" être omis, et dans ce cas valait par défaut codice_29.

Fichiers.

Exécuter des fichiers.

Les primitives sont "execl, execlp, execle, exect, execv, execvp".

L'exemple ci-dessous lance un fichier "test.exe" sur un bureau de Windows 7 :

int main()

int fichier;

fichier = execl ( "c:\\Users\\public\\Desktop\\test.exe", "test.exe", ".", (char*)0);

Renommer et supprimer des fichiers.

Utiliser la fonction "rename" (appel système) pour renommer un fichier.

Utiliser "remove" (bibliothèque C, tous types de fichiers) ou "unlink" (appel système pour supprimer un fichier) et "rmdir" (appel système pour supprimer un répertoire).

Attention, "remove", "unlink" et "rmdir" ne suppriment pas réellement le fichier ou répertoire, mais uniquement un nom (lien statique ou "dur" (hardlink)) dudit fichier ou répertoire. Si le nom en question est le dernier nom du fichier ou répertoire, alors le système de fichiers n'a plus de référence vers le fichier qui n'est dès lors plus accessible et l'espace qu'il occupait est disponible pour d'autres fichiers. Les données ne sont aucunement effacées, seul le lien permettant d'y accéder est détruit. Si le fichier avait plusieurs noms il reste accessible par ses autres noms. La commande "ln ancien_nom nouveau_nom" permet de donner un nom supplémentaire "nouveau_nom" au fichier "ancien_nom".

Copier des fichiers.

Il faut copier le contenu du premier dans le second.

Programmation C/Types avancés

Structures.

struct ma_structure {

type1 champ1;

type2 champ2;

typeN champN;

} var1, var2, ..., varM;

Déclare une structure (ou enregistrement) "ma_structure" composé de N champs, "champ1" de type "type1", "champ2" de type "type2", etc. On déclare, par la même occasion, M variables de type "struct ma_structure".

Accès aux champs.

L'accès aux champs d'une structure se fait avec un point :

struct complexe {

int reel;

int imaginaire;

} c;

c.reel = 1;

c.imaginaire = 2;

Initialisation.

Il y a plusieurs façons d'initialiser une variable de type structure :

Manipulation.

La seule opération prise en charge par le langage est la copie, lors des affectations ou des passages de paramètres à des fonctions. Toutes les autres opérations sont à la charge du programmeur, notamment la comparaison d'égalité (cf. section suivante).

Alignement et bourrage (padding).

Il s'agit d'un concept relativement avancé, mais qu'il est bien de connaitre pour agir en connaissance de cause. Lorsqu'on déclare une structure, on pourrait naïvement croire que les champs se suivent les uns à la suite des autres en mémoire. Or, il arrive souvent que des octets soient intercalés entre les champs.

Considérez la structure suivante:

struct ma_structure {

char champ1; /* 8 bits */

int champ2; /* 32 bits */

char champ3; /* 8 bits */

On pourrait penser que cette structure occupera 6 octets en mémoire, et pourtant, sur une bonne partie des compilateurs, on obtiendrait une taille plus proche des 12 octets.

En fait, les compilateurs insèrent quasiment toujours des octets entre les champs pour pouvoir les "aligner" sur des adresses qui correspondent à des mots machines. Cela est dû à une limitation de la plupart des processeurs, qui ne peuvent lire des « mots » de plus d'un octet que s'ils sont alignés sur un certain adressage (alors qu'il n'y a pas de contrainte particulière pour lire un seul octet, si le type codice_1 est défini sur 8bit).

En se représentant la mémoire comme un tableau continu, on peut tracer le dessin suivant:

Les cases codice_2, codice_3, codice_4, ... représentent des octets, et les "blocs" des sections de 32 bits. Si on suppose qu'une variable de type codice_5 doive être placée en mémoire à partir du bloc numéro N, alors un compilateur pourra, pour des raisons de performance, placer codice_6 en codice_2, codice_8 de codice_9 à codice_10, et codice_11 en codice_12. Cela permettrait en effet d'accéder simplement à codice_8: le processeur fournit des instructions permettant de lire ou d'écrire directement le bloc N + 1. Dans ce cas, les octets de codice_3 à codice_15 ne sont pas utilisés; on dit alors que ce sont des octets "de bourrage" (ou "padding" en anglais).

Un autre compilateur (ou le même, appelé avec des options différentes) peut aussi placer codice_8 de codice_3 à codice_9, et codice_11 en codice_20, pour optimiser l'utilisation mémoire. Mais alors il devra générer un code plus complexe lors des accès à codice_8, le matériel ne lui permettant pas d'accéder en une seule instruction aux 4 octets codice_3 à codice_9.

En fait il faut garder à l'esprit que toutes les variables suivent cette contrainte: aussi bien les variables locales aux fonctions, les champs de structures, les paramètres de fonctions, etc.

L'existence d'octets de bourrage ainsi que leur nombre sont non seulement dépendants de l'architecture, mais aussi du compilateur. Cela dit, il est toujours possible de connaître la « distance » ("offset") d'un champ par rapport au début de la structure, et ce, de manière portable. Pour cela il existe une macro, déclarée dans l'entête codice_24:

size_t offsetof(type, champ);

La valeur renvoyée est le nombre de codice_1 (i.e. d'octets la plupart du temps), entre le début de la structure et celui du champ. Le premier argument attendu est bel et bien le "type" de la structure et non une variable de ce type, ni un pointeur vers une variable de ce type. Pour s'en souvenir, il suffit de savoir que beaucoup d'implémentations d'codice_26 utilisent une arithmétique de ce genre:

size_t distance = (size_t) &((type *)NULL)->champ;

Si codice_27 était un pointeur, il faudrait faire un déréférencement supplémentaire (ou éviter l'étoile dans la macro). À noter que, même si cette macro peut s'avérer contraignante (notamment lorsqu'on ne dispose que de type pointeur), il est quand même préférable de l'utiliser pour des raisons de portabilité.

Voici un petit exemple d'utilisation de cette macro:

struct ma_structure {

char champ1;

int champ2;

char champ3;

int main(void)

/* en C99 */

printf("L'offset de 'champ2' vaut %zu.\n",

offsetof(struct ma_structure, champ2));

/* en C90 */

printf("L'offset de 'champ2' vaut %lu.\n",

(unsigned long) offsetof(struct ma_structure, champ2));

return 0;

Sur une architecture 32 bits, vous obtiendrez très certainement la réponse:

En fait toute cette section était pour souligner le fait qu'il est difficilement portable de comparer les structures comme des blocs binaires (via la fonction codice_28 par exemple), car il n'y a aucune garantie que ces octets de bourrage soient initialisés à une certaine valeur. De la même manière, il est sage de prendre quelques précautions avant de transférer cette structure à l'extérieur du programme (comme un fichier, un tube de communication ou une socket IP). En général, il préférable de traiter la structure champ par champ, pour ce genre d'opérations.

Mais comme rien n'est toujours totalement négatif, les conséquences du bourrage offre énormément de souplesse :

imaginons 2 structures:

struct str {

char *string;

struct str_ok {

char *string;

size_t len;

quelle que soit la structure utilisé, on peut avec l'adresse et la cast (struct str *) accéder à la chaine.

int main (void)

struct str s = { "chaine" };

struct str_ok sok = { "chaine", 0 };

void *p = &sok;

if (((struct str *)p)->string)

sok.len = strlen(sok.string);

printf("%s\n", ((struct str *)p)->string);

/* en revanche: Peut-être très dangereux ! */

p = &s;

printf("%s\n",((struct str_ok *)p)->string);