Datasets:
Kant1
/
French_Wikibooks_articles

Dataset card Data Studio Files Community
1
text
stringlengths
0
211k
Qu'ils parlent allemand, anglais, espagnol, hollandais, italien, portugais, roumain ou suédois, ils vous comprendront.
Qu'ils vivent en Afrique, en Amérique, en Asie, en Europe ou en Océanie, ils vous comprendront s'ils parlent une langue occidentale.
Le regrettable passé colonial fait que ces langues sont répandues dans d'innombrables pays non anglophones ou peu anglophones, les anglophones comprenant tout aussi bien l'interlingue (occidental) eux-mêmes. Aucune autre langue ne vous permet de vous adresser à un tel auditoire! Il est le double de l'anglais, considérablement plus que celui de l'espagnol, et des milliers de fois plus considérable que celui de l'esperanto!
Les Slaves et les Grecs maîtrisant l'écriture latine comprennent l'interlingue (occidental): l'inventeur de cette langue était lui-même russophone et germanophone de langues maternelles, et passa sa vie en terre baltique.
Programmation C/Entrées/sorties
Les fonctions d'entrées/sorties sont celles qui vous permettent de communiquer avec l'extérieur, c'est-à-dire, la console, les fichiers, tubes de communication, socket IP, etc ... Pour utiliser ces fonctions, il faut inclure l'en-tête codice_1, avec la directive d'inclusion :
Manipulation de fichiers.
En C, les fichiers ouverts sont représentés par le type codice_2, qui est un type "opaque" : on ne connaît pas la nature réelle du type, mais seulement des fonctions pour le manipuler. Ainsi, on ne peut créer directement de variables de type codice_2, seules les fonctions de la bibliothèque standard peuvent créer une variable de ce type, lors de l'ouverture d'un fichier. Ces données sont donc uniquement manipulées par des pointeurs de type codice_4.
Ce type est un "flux" de données, qui représente des fichiers, mais peut aussi représenter toute autre source ou destination de données. L'en-tête codice_1 fournit trois flux que l'on peut utiliser « directement » :
Souvent, "l'entrée standard" envoie au programme les données issues du clavier, et les "sorties standard" envoient les données que le programme génère à l'écran. Mais d'où viennent et où vont ces données dépend étroitement du contexte et de l'implémentation ; la bibliothèque standard fournit le type codice_2 comme une abstraction pour les manipuler tous de la même manière, ce qui libère le programmeur de certains détails d'implémentations, et permet à l'utilisateur d'un programme d'employer (suivant son implémentation) aussi bien son clavier qu'un fichier comme entrée standard.
Ouverture.
FILE * fopen(const char * restrict chemin, const char * restrict mode)
Ouvre le fichier désigné par le "chemin" et renvoie un nouveau flux de données pointant sur ce fichier. L'argument "mode" est une chaîne de caractères désignant la manière dont on veut ouvrir le fichier :
Lorsqu'un fichier est ouvert en écriture, les données qui sont envoyées dans le flux ne sont pas directement écrites sur le disque. Elles sont stockées dans un "tampon", une zone mémoire de taille finie. Lorsque le tampon est plein, les données sont purgées ("flush"), elles sont écrites dans le fichier. Ce mécanisme permet de limiter les accès au système de fichiers et donc d'accélérer les opérations sur les fichiers.
À noter une particularité des systèmes Microsoft Windows, est de traiter différemment les fichiers textes, des fichiers binaires. Sur ces systèmes, le caractère de saut de ligne est en fait composé de deux caractères (CR, puis LF, de code ASCII respectif 13 et 10, ou codice_10 et codice_11 écrit sous forme de caractère C). Lorsqu'un fichier est ouvert en mode texte (mode par défaut), toute séquence CRLF lue depuis le fichier sera convertie en LF, et tout caractère LF écrit sera en fait précédé d'un caractère CR supplémentaire. Si le fichier est ouvert en mode binaire, aucune conversion n'aura lieu.
Ce genre de comportement issu d'un autre âge, est en fait bien plus agaçant que réellement utile. Le premier réflexe est en général de désactiver ce parasitage des entrées/sorties, tant il est pénible. Pour cela deux cas de figure :
Fermeture.
int fclose(FILE * flux);
Dissocie le "flux" du fichier auquel il avait été associé par codice_12. Si le fichier était ouvert en écriture, le tampon est vidé. Cette fonction renvoie 0 si la fermeture s'est bien passée (notamment la purge des zones en écriture), ou codice_13 en cas d'erreur (voir le paragraphe sur la gestion d'erreurs).
Suppression.
int remove(const char * path);
Supprime le fichier ou le répertoire nommé 'codice_14'. La fonction renvoie 0 en cas de réussite et une valeur non nulle en cas d'erreur, ce qui peut inclure :
Renommage (ou déplacement).
int rename(const char * ancien_nom, const char * nouveau_nom);
Cette fonction permet de renommer l'ancien fichier ou répertoire nommé 'codice_15' par 'codice_16'. Elle peut aussi servir a déplacer un fichier, en mettant le chemin absolu ou relatif du nouvel emplacement dans 'codice_16'.
La fonction renvoie 0 si elle réussit et une valeur non nulle en cas d'erreur.
Les causes d'erreur dépendent de l'implémentation, et peuvent être:
Déplacement dans le flux.
int fseek( FILE * flux, long deplacement, int methode );
long ftell( FILE * flux );
codice_18 permet de se déplacer à une position arbitraire dans un "flux". Cette fonction renvoie 0 en cas de réussite.
"deplacement" indique le nombre d'octet à avancer (ou reculer si ce nombre est négatif) à partir du point de référence ("methode") :
codice_19 permet de savoir à quelle position se trouve le curseur (ce depuis le début).
En cas d'erreur, ces deux fonctions renvoient -1.
Plusieurs remarques peuvent être faites sur ces deux fonctions :
Synchronisation.
int fflush ( FILE *flux );
Cette fonction purge toutes les zones mémoires en attente d'écriture et renvoie 0 si tout s'est bien passé, ou codice_13 en cas d'erreur. Si codice_29 est passé comme argument, tous les flux ouverts en écriture seront purgés.
À noter que cette fonction ne permet pas de purger les flux ouverts en lecture (Pour répondre à une question du genre « Voulez-vous effacer ce fichier (o/n) ? » ). Une instruction de ce genre sera au mieux ignorée, et au pire provoquera un comportement indéterminé :
fflush( stdin );
Pour effectuer une purge des flux ouverts en lecture, il faut passer par des appels systèmes normalisés dans d'autres documents (POSIX), mais dont la disponibilité est en général dépendante du système d'exploitation.
Sorties formatées.
int printf(const char * restrict format, ...);
int fprintf(FILE * restrict flux, const char * restrict format, ...);
int sprintf(char * restrict chaine, const char * restrict format, ...);
int snprintf(char * restrict chaine, size_t taille, const char * restrict format, ...);
Ces fonctions permettent d'écrire des données formatées dans :
En retour elle indique le nombre de caractères qui a été écrit à l'écran, dans le flux ou la zone mémoire (caractère nul non compris pour codice_32).
Bien que cela ait déjà été traité dans la section dédiée aux chaînes de caractères, il faut faire très attention avec la fonction codice_34. Dans la mesure où la fonction n'a aucune idée de la taille de la zone mémoire transmise, il faut s'assurer qu'il n'y aura pas de débordements. Mieux vaut donc utiliser la fonction codice_35, qui permet de limiter explicitement le nombre de caractère à écrire.
À noter que codice_35 devrait toujours retourner la taille de la chaine à écrire, indépendamment de la limite fixée par le paramètre codice_37. Le conditionnel reste de mise, car beaucoup d'implémentations de cette fonction se limitent à retourner le nombre de caractères "écrit", c'est à dire en s'arrêtant à la limite le cas échéant.
Type de conversion.
Mis à part l'« endroit » où écrivent les fonctions, elles fonctionnent exactement de la même manière, nous allons donc décrire leur fonctionnement en prenant l'exemple de codice_30.
L'argument "format" est une chaîne de caractères qui détermine ce qui sera affiché par codice_30 et sous quelle forme. Cette chaîne est composée de texte « normal » et de séquences de contrôle permettant d'inclure des variables dans la sortie. Les séquences de contrôle commencent par le caractère « % » suivi d'un caractère parmi :
Contraindre la largeur des champs.
Une autre fonctionnalité intéressante du spécificateur de format est que l'on peut spécifier sur combien de caractère les champs seront alignés. Cette option se place entre le '%' et le format de conversion et se compose d'un signe '-' optionnel suivit d'un nombre, éventuellement d'un point et d'un autre nombre (codice_46). Par exemple: codice_47.
Le premier nombre indique sur combien de caractère se fera l'alignement. Si la valeur convertie est plus petite, elle sera alignée sur la droite, ou la gauche si un signe moins est présent au début. Si la valeur est plus grande que la largeur spécifiée, le contenu s'étendra au-delà, décalant tout l'alignement. Pour éviter ça, on peut spécifier un deuxième nombre au delà duquel le contenu sera tronqué. Quelques exemples:
printf("%10s", "Salut"); /* " Salut" */
printf("%-10s", "Salut"); /* "Salut " */
printf("%10s", "Salut tout le monde"); /* "Salut tout le monde" */
printf("%10.10s", "Salut tout le monde"); /* "Salut tout" */
Contraindre la largeur des champs numériques.
On peut aussi paramétrer la largeur du champ, en spécifiant codice_48 à la place. Dans ce cas, en plus de la valeur à afficher (i.e. 1234), il faut donner avant un entier de type codice_24 pour dire sur combien de caractères l'alignement se fera (i.e. 10) :
printf("%-*d", 10, 1234); /* "1234 " */
printf("%*d", 10, 1234); /* " 1234" */
À noter que pour le formatage de nombres entiers, la limite « dure » du spécificateur de format est sans effet, pour éviter de fâcheuses erreurs d'interprétation. On peut toutefois utiliser les extensions suivantes :
Exemples :
printf("%+010d", 543); /* "+000000543" */
printf("%-+10d", 543); /* "+543 " */
printf("%-+10d", 1234567890); /* "+1234567890" */
printf("%-+10.10d", 1234567890); /* "+1234567890" */
printf("%08x", 543); /* "0000021f" */
Contraindre la largeur des champs réels.
Pour les réels, la limite « dure » sert en fait à indiquer la précision voulue après la virgule :
printf("%f", 3.1415926535); /* "3.141593" */
printf("%.8f", 3.1415926535); /* "3.14159265" */
Spécifier la taille de l'objet.
Par défaut, les entiers sont présupposés être de type codice_24, les réels de type codice_41 et les chaînes de caractères de type codice_55. Il arrive toutefois que les types soient plus grands (et non plus petits à cause de la promotion des types, c.f. paragraphes opérateurs et fonction à nombre variable d'arguments), le spécificateur de format permet donc d'indiquer la taille de l'objet en ajoutant les attributs suivants "avant" le caractère de conversion :
Pour résumer les types d'arguments attendus en fonction de l'indicateur de taille et du type de conversion :
codice_65 et codice_66 sont des nouveautés de C99. On notera qu'avec l'attribut codice_65 et les formats codice_68, codice_69, codice_70, codice_71, codice_72 ou codice_73, le type est codice_74 et non codice_75. En effet, comme vu dans le chapitre Types de base, le type codice_75 peut être signé ou non, suivant l'implémentation. Ici, on est sûr de manipuler le type caractère signé.
Quelques exemples :
signed char nb;
printf("%d%hhn", 12345, &nb); /* Affichage de "12345" et nb vaudra 5 */
printf("%ls", L"Hello world!"); /* "Hello world!" */
Arguments positionnels.
Il s'agit d'une fonctionnalité relativement peu utilisée, mais qui peut s'avérer très utile dans le cadre d'une application internationalisée. Considérez le code suivant (tiré du manuel de codice_77) :
printf( gettext("La chaine '%s' a %zu caractères\n"), s, strlen(s) );
codice_77 est un ensemble de fonctions permettant de manipuler des catalogues de langues. La principale fonction de cette bibliothèque est justement codice_79, qui en fonction d'une chaîne de caractère retourne la chaîne traduite selon la locale en cours (où celle passée en argument si rien n'a été trouvé).
Une traduction en allemand du message précédant, pourrait donner :
codice_80
On remarque d'emblée que les spécificateurs de format sont inversés par rapport à la chaîne originale. Or l'ordre des arguments passés à la fonction codice_81 sera toujours le même. Il est quand même possible de s'en sortir avec les arguments positionnels. Pour cela, il suffit d'ajouter à la suite du caractère codice_82 un nombre, suivi d'un signe codice_83. Ce nombre représente le numéro de l'argument à utiliser pour le spécificateur, en commençant à partir de 1. Un petit exemple :
char * s = "Bla bla";
printf("La chaine %2$s a %1$zu caractères\n", strlen(s), s); /* "La chaîne Bla bla a 7 caractères" */
À noter que si un des arguments utilise la référence positionnelle, tous les autres arguments devront faire évidemment de même, sous peine d'avoir un comportement imprévisible.
Écriture par bloc ou par ligne.
Il s'agit d'une fonctionnalité relativement pointue de la bibliothèque codice_84, mais qui peut expliquer certains comportement en apparence étrange (notamment avec les systèmes POSIX). Les réglages par défaut étant bien faits, il y a peu de chance pour que vous ayez à vous soucier de cet aspect, si ce n'est à titre de curiosité.
En règle générale les flux de sortie ouvert par via la bibliothèque codice_84 sont gérés par bloc, ce qui veut dire qu'une "écriture" (via codice_81, codice_87 ou codice_88) ne sera pas systématiquement répercutée dans le fichier associé.