Datasets:
Kant1
/
French_Wikibooks_articles

Dataset card Data Studio Files Community
1
text
stringlengths
0
211k
Cela dépend en fait du type d'objet sur lequel les écritures se font :
C'est ce qui fait qu'un programme affichant des messages à intervalle régulier (genre une seconde), affichent ces lignes une à une sur un terminal, et par bloc de plusieurs lignes lorsqu'on redirige sa sortie vers un programme de mise en page (comme codice_90), avec une latence qui peut s'avérer gênante. C'est ce qui fait aussi qu'une instruction comme codice_91 n'affichera en général rien, car il n'y a pas de retour à la ligne.
En fait ce comportement peut être explicitement réglé, avec cette fonction :
int setvbuf(FILE * restrict flux, char * restrict mem, int mode, size_t taille);
Cette fonction doit être appelée juste après l'ouverture du flux et avant la première écriture. Les arguments ont la signification suivante :
La fonction codice_103 renvoie 0 si elle réussit, et une valeur différente de zéro dans le cas contraire (en général le paramètre codice_98 est invalide).
Cette fonctionnalité peut être intéressante pour les programmes générant des messages sporadiques. Il peut effectivement s'écouler un temps arbitrairement long avant que le bloc mémoire soit plein, si cette commande est redirigée vers un autre programme, ce qui peut s'avérer assez dramatique pour des messages signalant une avarie grave. Dans ce cas, il est préférable de forcer l'écriture par ligne (ou immédiate), plutôt que de faire suivre systématiquement chaque écriture de ligne par un appel à codice_105, avec tous les risques d'oubli que cela comporte.
Quelques remarques pour finir.
La famille de fonctions codice_81 permet donc de couvrir un large éventail de besoins, au prix d'une pléthore d'options pas toujours faciles à retenir.
Il faut aussi faire attention au fait que certaines implémentations de codice_81 tiennent compte de la localisation pour les conversions des nombres réels (virgule ou point comme séparateur décimal, espace ou point comme séparateurs des milliers, etc.). Ceci peut être gênant lorsqu'on veut retraiter la sortie de la commande. Pour désactiver la localisation, on peut utiliser la fonction codice_108:
setlocale( LC_ALL, "C" );
printf( ... );
setlocale( LC_ALL, "" );
Entrées formatées.
La bibliothèque codice_84 propose quelques fonctions très puissantes pour saisir des données depuis un flux quelconque. Le comportement de certaines fonctions (codice_110 notamment) peut paraître surprenant de prime abord, mais s'éclaircira à la lumière des explications suivantes.
int scanf(const char * restrict format, ...);
int fscanf(FILE * restrict flux, const char * restrict format, ...);
int sscanf(const char * restrict chaine, const char * restrict format, ...);
Ces trois fonctions permettent de lire des données formatées provenant de :
L'argument "format" ressemble aux règles d'écriture de la famille de fonction codice_30, cependant les arguments qui suivent ne sont plus des variables d'entrée mais des variables de sortie (ie : l'appel à codice_110 va modifier leur valeur, il faut donc passer une référence).
Ces fonctions retournent le nombre d'arguments correctement lus depuis le format, qui peut être inférieur ou égal au nombre de spécificateurs de format, et même nul.
Format de conversion.
Les fonctions codice_116 analysent le spécificateur de format et les données d'entrée, en les comparant caractère à caractère et s'arrêtant lorsqu'il y en a un qui ne correspond pas. À noter que les blancs (espaces, tabulations et retour à la ligne) dans le spécificateur de format ont une signification spéciale : à un blanc de la chaîne "format" peut correspondre un nombre quelconque de blanc dans les données d'entrée, y compris aucun. D'autres part, il est possible d'insérer des séquences spéciales, commençant par le caractère '%' et à l'image de codice_81, pour indiquer qu'on aimerait récupérer la valeur sous la forme décrite par le caractère suivant le '%' :
Contraindre la largeur.
Comme pour la fonction codice_81, il est possible de contraindre le nombre de caractères à lire, en ajoutant ce nombre juste avant le caractère de conversion. Dans le cas des chaînes, c'est même une obligation, dans la mesure où codice_116 ne pourra pas ajuster l'espace à la volée.
Exemple :
/* Lit une chaîne de caractères entre guillemets d'au plus 127 caractères */
char tmp[128];
if (fscanf(fichier, "Config = \"%127[^\"]\"", tmp ) == 1)
printf("L'argument associé au mot clé 'Config' est '%s'\n", tmp);
Cet exemple est plus subtil qu'il ne paraît. Il montre comment analyser une structure relativement classique de ce qui pourrait être un fichier de configuration de type "MotClé=Valeur". Ce format spécifie donc qu'on s'attend à trouver le mot clé "Config", en ignorant éventuellement les blancs initiaux, puis le caractère '=', entouré d'un nombre quelconque de blancs, éventuellement aucun. À la suite de cela, on doit avoir un guillemet ('"'), puis au plus 127 caractères autres que que les guillemets, qui seront stockés dans la zone mémoire codice_133 (qui sera terminée par 0, d'où l'allocation d'un caractère supplémentaire). Le guillemet final est là pour s'assurer, d'une part, que la longueur de la chaîne est bien inférieure à 127 caractère et, d'autre part, que le guillemet n'a pas été oublié dans le fichier.
En cas d'erreur, on peut par exemple ignorer tous les caractères jusqu'à la ligne suivante.
Ajuster le type des arguments.
On peut aussi ajuster le type des arguments en fonction des attributs de taille :
Ainsi pour lire la valeur d'un entier sur l'entrée standard, on utilisera un code tel que celui ci :
int main(void)
int i;
printf("Entrez un entier : ");
scanf("%d", &i);
printf("la variable i vaut maintenant %d\n", i);
return 0;
Les appels à codice_30 ne sont pas indispensables à l'exécution du codice_110, mais permettent à l'utilisateur de comprendre ce qu'attend le programme (et ce qu'il fait aussi).
Conversions muettes.
La fonction codice_110 reconnaît encore un autre attribut qui permet d'effectuer la conversion, mais sans retourner la valeur dans une variable. Il s'agit du caractère étoile '*', qui remplace l'éventuel attribut de taille.
En théorie, la valeur de retour ne devrait pas tenir compte des conversions muettes.
Exemple:
int i, j;
sscanf("1 2.434e-308 2", "%d %*f %d", &i, &j); /* i vaut 1 et j vaut 2 */
Quelques remarques pour finir.
La fonction codice_116 n'est pas particulièrement adaptée pour offrir une saisie conviviale à l'utilisateur, même en peaufinant à l'extrême les spécificateurs de format. En général, il faut s'attendre à une gestion très rudimentaire du clavier, avec très peu d'espoir d'avoir ne serait-ce que les touches directionnelles pour insérer du texte à un endroit arbitraire.
Qui plus est, lors de saisie de texte, les terminaux fonctionnent en mode bloc : pour que les données soient transmises à la fonction de lecture, il faut que l'utilisateur confirme sa saisie par entrée. Même les cas les plus simple peuvent poser problèmes. Par exemple, il arrive souvent qu'on ne veuille saisir qu'un caractère pour répondre à une question du genre codice_138, avant d'écraser un fichier. Utiliser une des fonctions de saisie nécessite de saisir d'abord un caractère, ensuite de valider avec la touche "entrée". Ce qui peut non seulement être très pénible s'il y a beaucoup de questions, mais aussi "risqué" si on ne lit les caractères qu'un à un. En effet, dans ce dernier cas, si l'utilisateur entre une chaîne de plusieurs caractères, puis valide sa saisie, les caractères non lus seront disponibles pour des lectures ultérieures, répondant de ce fait automatiquement aux questions du même type.
Il s'agit en fait de deux opérations en apparence simples, mais impossible à réaliser avec la bibliothèque C standard :
Ces fonctionnalités sont hélas le domaine de la gestion des terminaux POSIX et spécifiées dans la norme du même nom.
On l'aura compris, cette famille de fonction est plus à l'aise pour traiter des fichiers, ou tout objet nécessitant le moins d'interaction possible avec l'utilisateur. Néanmoins dans les cas les plus simples, ce sera toujours un pis-aller.
À noter, que contrairement à la famille de fonction codice_81, codice_116 n'est pas sensible à la localisation pour la saisie de nombres réels.
Entrées non formatées.
Pour saisir des chaînes de caractères indépendamment de leur contenu, on peut utiliser les fonctions suivantes :
char * fgets(char * restrict chaine, int taille_max, FILE * restrict flux);
int fgetc( FILE * restrict flux);
int ungetc( int octet, FILE * flux );
La fonction codice_141 permet de saisir une ligne complète dans la zone mémoire spécifiée, en évitant tout débordement. Si la ligne peut être contenue dans le bloc, elle contiendra le caractère de saut de ligne (codice_11), en plus du caractère nul. Dans le cas contraire, la ligne sera tronquée, et la suite de la ligne sera obtenue à l'appel suivant. Si la fonction a pu lire au moins un caractère, elle retournera la chaîne transmise en premier argument, ou codice_29 s'il n'y a plus rien à lire.
Un exemple de lecture de ligne arbitrairement longue est fournie dans le livre Exercices en langage C (énoncé et solution).
La fonction codice_144 permet de ne saisir qu'un caractère depuis le flux spécifié. À noter que la fonction renvoie bien un entier de type codice_24 et non de type codice_75, car en cas d'erreur (y compris la fin de fichier), cette fonction renvoie codice_13 (défini à -1 en général).
À noter que cette fonction est incapable de traiter des fichiers mixtes (binaire et texte) depuis un descripteur en mode caractère (accès séquentiel). D'une part la fonction ne renvoyant pas le nombre d'octets lus (ce qui aurait facilement réglé le problème) et d'autre part, ftell() ne fonctionnant pas sur de tels descripteurs, il faudra reprogrammer codice_148 pour gérer ce cas de figure.
Entrées/sorties brutes.
Les fonctions suivantes permettent d'écrire ou de lire des quantités arbitraires de données depuis un flux. Il faut faire attention à la portabilité de ces opérations, notamment lorsque le flux est un fichier. Dans la mesure où lire et écrire des structures binaires depuis un fichier nécessite de gérer l'alignement, le bourrage, l'ordre des octets pour les entiers ("big endian", "little endian") et le format pour les réels, il est souvent infiniment plus simple de passer par un format texte.
Sortie.
size_t fwrite(const void * buffer, size_t taille, size_t nombre, FILE * flux);
Entrée.
size_t fread(void * buffer, size_t taille, size_t nombre, FILE * flux);
Lit "nombre" éléments, chacun de taille "taille", à partir du "flux" et stocke le résultat dans le "buffer". Renvoie le nombre d'éléments correctement lus.
Gestion des erreurs.
Qui dit entrées/sorties dit forcément une pléthore de cas d'erreurs à gérer. C'est souvent à ce niveau que se distinguent les « bonnes » applications des autres : fournir un comportement cohérent face à ces situations exceptionnelles. Dans la description des fonctions précédentes, il est fait mention que, en cas d'erreur, un code spécial est retourné par la fonction. De plus, on dispose de la fonction codice_149, qui permet de savoir si une erreur a été déclenchée sur un fichier lors d'un appel antérieur à une fonction de la bibliothèque standard.
Si ces informations permettent de savoir s'il y a eu une erreur, elles ne suffisent pas à connaître la cause de l'erreur. Pour cela, la bibliothèque codice_84 repose sur la variable globale "errno", dont l'utilisation est décrite dans le chapitre sur la gestion d'erreur.
Vi
Vi/Découvrir Vi
Découvrir "vi".
Historique.
L'éditeur "vi" (prononcez vi aïe) adhère aux principes des applications Unix :
il remplit une fonction spécifique au mieux et s'intègre au reste du
système, communiquant avec les autres applications pour s'associer leur
capacités. Léger et portable, il peut toujours être présent, simple sur
le système le plus basique ou amélioré sur un système habituel.
Bill Joy (Willam N. Joy (1954 -), co-fondateur de Sun Microsystems),
étudiant à Berkeley,
planche au cours de l'été 1975 sur des algorithmes dont la taille imposante
(200 lignes) empêche une
correcte implantation dans le cœur du système Pascal. À l'époque,
l'éditeur couramment utilisé était "ed" et de nombreuses
améliorations en étaient développées, dont "em"
que George Coulouris lui procure. "Em" avait cependant quelques défauts, comme