OpenLLM-France/wikimedia huggingface dataset:
# Programmation Bash/Interactions avec l'utilisateur

* Introduction
* Hello World
* Notions essentielles du shell bash
* Interactions avec le système de fichiers
* Flux et redirections
* Tests
* Calculs
* Structures conditionnelles
* Boucles
* Interactions avec l'utilisateur
* Regex
* Fonctions
* Scripts
* Enchaînements et scripts
* Liste des commandes
* Commandes ksh
* Problèmes connus
* Introduction
* Hello World
* Notions essentielles du shell bash
* Interactions avec le système de fichiers
* Flux et redirections
* Tests
* Calculs
* Structures conditionnelles
* Boucles
* Interactions avec l'utilisateur
* Regex
* Fonctions
* Scripts
* Enchaînements et scripts
* Liste des commandes
* Commandes ksh
* Problèmes connus
[ Modifier le sommaire ]

## Lire la saisie d'un utilisateur

Les commandes suivantes permettent de gérer l'interaction avec l'utilisateur :
* la commande echo affiche des données soit sur la sortie standard, soit sur la sortie d'erreur,
* la commande read lit les valeurs entrées au clavier et les stocke dans une variable.
read var permet de lire une valeur entrée au clavier par l'utilisateur et de stocker cette valeur dans la variable var.
Exemple :
Dans cet exemple, read lit une valeur que l'utilisateur saisit au clavier en l'occurrence : toto. Cette valeur est stockée dans la variable a. Le contenu de cette variable a est affiché grâce à echo et son contenu est effectivement toto.
Si aucun nom de variable n'est fourni lors de l'appel de read, la valeur entrée par l'utilisateur est stockée dans la variable REPLY.
Exemple

## Interaction et case

Souvent, dans les scripts, on trouve la structure suivante :
# Programmation Bash/Calculs

* Introduction
* Hello World
* Notions essentielles du shell bash
* Interactions avec le système de fichiers
* Flux et redirections
* Tests
* Calculs
* Structures conditionnelles
* Boucles
* Interactions avec l'utilisateur
* Regex
* Fonctions
* Scripts
* Enchaînements et scripts
* Liste des commandes
* Commandes ksh
* Problèmes connus
* Introduction
* Hello World
* Notions essentielles du shell bash
* Interactions avec le système de fichiers
* Flux et redirections
* Tests
* Calculs
* Structures conditionnelles
* Boucles
* Interactions avec l'utilisateur
* Regex
* Fonctions
* Scripts
* Enchaînements et scripts
* Liste des commandes
* Commandes ksh
* Problèmes connus
[ Modifier le sommaire ]
Trois méthodes permettent d'effectuer des calculs, la première utilise la syntaxe spéciale $((operation)), la seconde utilise la commande let. La troisième utilise la commande bc, qui accepte aussi les nombres décimaux. Taper bc seul sur la ligne de commande permet de passer en mode interactif. Voici comment on peut incrémenter une variable avec chacune des méthodes :
mais il est possible "dans certaines circonstances" (man bash,ÉVALUATION ARITHMÉTIQUE) de réaliser des opérations plus complexes:
let argument [argument] (cf man bash,COMMANDES INTERNES DE L'INTERPRÉTEUR)

## Calcul avancé avec bc

En natif, Bash ne propose que des fonctionnalités de calcul limitées (additions simples ...). bc permet des calculs plus complexes, avec gestion des décimales (ne pas oublier l'option -l). Exemple :
Calcul d'une racine carrée :
# Programmation Bash/Introduction

* Introduction
* Hello World
* Notions essentielles du shell bash
* Interactions avec le système de fichiers
* Flux et redirections
* Tests
* Calculs
* Structures conditionnelles
* Boucles
* Interactions avec l'utilisateur
* Regex
* Fonctions
* Scripts
* Enchaînements et scripts
* Liste des commandes
* Commandes ksh
* Problèmes connus
* Introduction
* Hello World
* Notions essentielles du shell bash
* Interactions avec le système de fichiers
* Flux et redirections
* Tests
* Calculs
* Structures conditionnelles
* Boucles
* Interactions avec l'utilisateur
* Regex
* Fonctions
* Scripts
* Enchaînements et scripts
* Liste des commandes
* Commandes ksh
* Problèmes connus
[ Modifier le sommaire ]
Le Bash est un shell, c'est-à-dire un interpréteur de commandes, écrit pour le projet GNU en 1989.
Bash est l'acronyme de Bourne-Again SHell, un calembour sur le shell Bourne sh, qui a été historiquement le premier shell d'Unix. Le shell Bourne original fut écrit par Stephen Bourne. Bash a été principalement écrit par Brian Fox et Chet Ramey. La syntaxe de Bash est compatible avec sh et inclut des développements issus de csh et ksh.
En effet, le Korn shell (ksh) est un shell Unix développé par David Korn. Il est compatible avec le Bash et inclut également un grand nombre de fonctionnalités du C shell, mais il permet également des fonctions de scripting avancées utilisées dans des langages de programmation plus évolués comme awk, sed, et Perl. La liste de ses commandes sera détaillée à la fin de ce livre.
Bash est le shell par défaut de la plupart des systèmes GNU/Linux, il est distribué sous la licence libre GNU GPL. Il fonctionne sur la plupart des systèmes d'exploitation de type Unix, et a également été porté sous Windows par Cygwin, puis sous windows 10 build 14316 par Microsoft.
Si un langage de programmation permet de dire à un processeur ce qu’il doit faire, un interpréteur de commandes permet de dire à un système d’exploitation, un service ou à une application ce qu’ils doivent faire. Cette nuance permet aux anglo-saxons de distinguer les notions de programming lorsqu’il s’agit d’écrire un code pour créer une application et de scripting lorsqu’il s’agit de programmer un système d’exploitation, un service ou une application. Le jeu d'instructions de Bash est donc spécialisé afin d'utiliser des systèmes Unix.
# Programmation Bash/Enchaînements et scripts

* Introduction
* Hello World
* Notions essentielles du shell bash
* Interactions avec le système de fichiers
* Flux et redirections
* Tests
* Calculs
* Structures conditionnelles
* Boucles
* Interactions avec l'utilisateur
* Regex
* Fonctions
* Scripts
* Enchaînements et scripts
* Liste des commandes
* Commandes ksh
* Problèmes connus
* Introduction
* Hello World
* Notions essentielles du shell bash
* Interactions avec le système de fichiers
* Flux et redirections
* Tests
* Calculs
* Structures conditionnelles
* Boucles
* Interactions avec l'utilisateur
* Regex
* Fonctions
* Scripts
* Enchaînements et scripts
* Liste des commandes
* Commandes ksh
* Problèmes connus
[ Modifier le sommaire ]

## Scripts
### Exécution d'un script

Il y a deux manières d'exécuter un script, soit en rendant le script exécutable, soit en passant le fichier comme argument à la commande ksh.

### Variables spéciales

Plusieurs variables spéciales sont disponibles lors de l'exécution d'un script.
* $0 a pour valeur le nom du script ;
* $1 jusqu'à $9 ont respectivement pour valeur les neuf premiers arguments du script ;
* $# a pour valeur le nombre d'arguments passés au script ;
* $@ contient la liste de tous les arguments du script.
* $* contient la liste de tous les arguments du script (décomposée).
En ksh, à partir du dixième argument, il faut coder la valeur numérique entre accolades, exemple : ${10} pour le 10ème.
Pour tester si le script contient au moins un paramètre :

## Enchaînements
### Enchaînements simples

Les commandes com1 jusqu'à comN sont exécutées parallèlement.
Les commandes com1 jusqu'à comN sont exécutées successivement.

### Enchaînements conditionnels

Cet exemple va exécuter toutes les commandes com1 jusqu'à comN tant que celles ci se terminent correctement.
Dans cet exemple les commandes com1 jusqu'à comN seront exécutées successivement tant qu'aucune ne se termine correctement.

## Références

* ↑ http://www.dartmouth.edu/~rc/classes/ksh/arguments.html
# Programmation Bash/Fonctions

* Introduction
* Hello World
* Notions essentielles du shell bash
* Interactions avec le système de fichiers
* Flux et redirections
* Tests
* Calculs
* Structures conditionnelles
* Boucles
* Interactions avec l'utilisateur
* Regex
* Fonctions
* Scripts
* Enchaînements et scripts
* Liste des commandes
* Commandes ksh
* Problèmes connus
* Introduction
* Hello World
* Notions essentielles du shell bash
* Interactions avec le système de fichiers
* Flux et redirections
* Tests
* Calculs
* Structures conditionnelles
* Boucles
* Interactions avec l'utilisateur
* Regex
* Fonctions
* Scripts
* Enchaînements et scripts
* Liste des commandes
* Commandes ksh
* Problèmes connus
[ Modifier le sommaire ]
Comme pour tout autre langage, l'utilisation de fonctions facilite le développement de scripts et la structuration de ceux-ci.

## Déclaration

Pour déclarer une fonction, il existe différentes méthodes, nous pouvons toujours utiliser la syntaxe suivante malgré le fait qu'elle soit dépréciée :
La déclaration d'une fonction doit toujours se situer avant son appel.
Le mot-clé function est optionnel :
Les deux syntaxes ont leur avantage :
* L'absence du mot-clé permet au script d'être compatible avec les shells Bourne et Korn.
* La présence du mot-clé permet d'éviter une collision de nom avec les alias.

## Appel et paramètres
### Appel

Pour appeler une fonction, on utilise la syntaxe suivante:

### Paramètres passés à la fonction

Ces paramètres sont bien sûrs optionnels. À l'intérieur de la fonction, ils sont représentés, respectivement, par les variables $1, $2,... , $n. $0 représente toujours le nom du script (et non de la fonction) qui s'exécute.
Le nombre de paramètres passés à une fonction est représenté par la variable $#
Exemple:
Ce qui donne le résultat suivant:

### Fin

Une fonction termine son exécution lorsqu'elle n'a plus d'instructions à exécuter ou lorsqu'elle rencontre l'instruction return ou exit. Ces instructions peuvent être suivies d'un entier positif, qui correspond à la valeur de retour de la fonction. Si aucune valeur n'est spécifiée, c'est la valeur 0 qui est renvoyée.
La valeur de retour de la dernière fonction appelée est stockée dans la variable $?

## Variables

Outre les paramètres, une fonction peut utiliser plusieurs variables:
* Réutiliser toutes les variables globales du script. Par défaut dans un script shell, les variables sont déclarées comme étant globales.
* En déclarer de nouvelles.
* Déclarer des variables locales. Pour déclarer une variable localement, il faut la faire précéder du mot clé local. Une telle variable ne sera utilisable que dans la fonction qui la déclare durant l'exécution de celle-ci mais sera considérée comme globale (donc connue) par les fonctions appelées à partir de cette fonction (après la déclaration locale de la variable).
Pour éviter d'accéder en lecture à une variable n'ayant pas d'existence, on peut inscrire la commande set -u en début de script.
# Préparation au certificat d'opérateur du service amateur/Les notations en mathématiques

* À propos de ce livre
* Aperçu de l'activité de radioamateur
* Présentation du certificat et de l'examen

### Outils mathématiques

* Testez votre niveau
* Choisir une calculatrice... et s'en servir !
* Les notations en mathématiques
* Calculs de base
* Rappels de mathématiques
* Résoudre des équations
* Les unités

### Les briques de base

* Loi d'Ohm, énergie, puissance
* Théorie de l'électromagnétisme
* Qu'est-ce qu'une onde ?

### Réglementation

* Réglementation internationale
* Les modulations et classes d'émission
* Fréquences et puissances autorisées
* Procédures radio

### Technique
#### Bases d'électricité

* Circuits électriques
* Courants alternatifs et continus
* Résistances
* Condensateurs
* Bobines
* Transistors
* Amplificateurs
* Oscillateurs et mélangeurs
* Diodes

#### Radioélectricité

* Ondes
* Antennes
* Émetteurs
* Récepteurs
* Lignes de transmission

### Annexes

* Bibliographie, webographie
* Arrêté du 21 septembre 2000
* À propos de ce livre
* Aperçu de l'activité de radioamateur
* Présentation du certificat et de l'examen

### Outils mathématiques

* Testez votre niveau
* Choisir une calculatrice... et s'en servir !
* Les notations en mathématiques
* Calculs de base
* Rappels de mathématiques
* Résoudre des équations
* Les unités

### Les briques de base

* Loi d'Ohm, énergie, puissance
* Théorie de l'électromagnétisme
* Qu'est-ce qu'une onde ?

### Réglementation

* Réglementation internationale
* Les modulations et classes d'émission
* Fréquences et puissances autorisées
* Procédures radio

### Technique
#### Bases d'électricité

* Circuits électriques
* Courants alternatifs et continus
* Résistances
* Condensateurs
* Bobines
* Transistors
* Amplificateurs
* Oscillateurs et mélangeurs
* Diodes

#### Radioélectricité

* Ondes
* Antennes
* Émetteurs
* Récepteurs
* Lignes de transmission

### Annexes

* Bibliographie, webographie
* Arrêté du 21 septembre 2000
[ Modifier le sommaire ]

## L'utilisation des lettres

En mathématiques, on travaille avec des nombres (10, 11, 29, 8, 3,5), mais il arrive que, lassé d'avoir à écrire un nombre particulièrement long (par exemple 190 388 172 839 401 840 000 000), on décide de lui donner un nom. Ce nom est représenté par une lettre : $a$, $B$, $z$... Ainsi, on peut par exemple décider que $a=10$ et $B=300$, auquel cas $a+b=310$.
L'alphabet comporte 26 lettres, mais parfois, on préférera utiliser plusieurs lettres pour désigner un nombre. On pourra alors utiliser l'indice, et noter par exemple $P_{\text{consommée}}$ qui se lira « P indice consommée ».
On peut également vouloir nommer plusieurs nombres par une même lettre, auquel cas on fera la différence en rajoutant des apostrophes, qui seront notés « prime » : par exemple, $P=10,P'=18,P''=20$ se liront successivement « P égale 10, P prime égale 18, P prime prime égale 20 ».
# Préparation au certificat d'opérateur du service amateur/Ondes

* À propos de ce livre
* Aperçu de l'activité de radioamateur
* Présentation du certificat et de l'examen

### Outils mathématiques

* Testez votre niveau
* Choisir une calculatrice... et s'en servir !
* Les notations en mathématiques
* Calculs de base
* Rappels de mathématiques
* Résoudre des équations
* Les unités

### Les briques de base

* Loi d'Ohm, énergie, puissance
* Théorie de l'électromagnétisme
* Qu'est-ce qu'une onde ?

### Réglementation

* Réglementation internationale
* Les modulations et classes d'émission
* Fréquences et puissances autorisées
* Procédures radio

### Technique
#### Bases d'électricité

* Circuits électriques
* Courants alternatifs et continus
* Résistances
* Condensateurs
* Bobines
* Transistors
* Amplificateurs
* Oscillateurs et mélangeurs
* Diodes

#### Radioélectricité

* Ondes
* Antennes
* Émetteurs
* Récepteurs
* Lignes de transmission

### Annexes

* Bibliographie, webographie
* Arrêté du 21 septembre 2000
* À propos de ce livre
* Aperçu de l'activité de radioamateur
* Présentation du certificat et de l'examen

### Outils mathématiques

* Testez votre niveau
* Choisir une calculatrice... et s'en servir !
* Les notations en mathématiques
* Calculs de base
* Rappels de mathématiques
* Résoudre des équations
* Les unités

### Les briques de base

* Loi d'Ohm, énergie, puissance
* Théorie de l'électromagnétisme
* Qu'est-ce qu'une onde ?

### Réglementation

* Réglementation internationale
* Les modulations et classes d'émission
* Fréquences et puissances autorisées
* Procédures radio

### Technique
#### Bases d'électricité

* Circuits électriques
* Courants alternatifs et continus
* Résistances
* Condensateurs
* Bobines
* Transistors
* Amplificateurs
* Oscillateurs et mélangeurs
* Diodes

#### Radioélectricité

* Ondes
* Antennes
* Émetteurs
* Récepteurs
* Lignes de transmission

### Annexes

* Bibliographie, webographie
* Arrêté du 21 septembre 2000
[ Modifier le sommaire ]
Une onde radioélectrique (onde radio), est une champ électromagnétique produit par une antenne, dont la fréquence est inférieure à 300 GHz :
* soit une longueur d'onde dans le vide supérieure à 1 mètre (fréquences inférieures à 300 MHz) pour les ondes radio dites « radiofréquences »,
* et une longueur d'onde dans le vide supérieure à 1 millimètre (fréquences comprises entre 300 MHz et 300 GHz) pour les ondes radio dites « hyperfréquences ».
Adaptées au transport de signaux issus de la voix et de l'image, les ondes radio permettent les radiocommunications (talkie-walkies, téléphone sans fil, téléphonie mobile…), la radiodiffusion et les radars.
Un champ électromagnétique signifie un champ électrique couplé à un champ magnétique.
# Programmation C-C++/Les exceptions/Exceptions dans les constructeurs

Cours de C/C++ :
| Les exceptions ||
| | Lancement et récupération d'une exception |
| | Remontée des exceptions |
| | Liste des exceptions autorisées pour une fonction |
| | Hiérarchie des exceptions |
| | Exceptions dans les constructeurs |
| Livre original de C. Casteyde ||
Il est parfaitement légal de lancer une exception dans un constructeur. En fait, c'est même la seule solution pour signaler une erreur lors de la construction d'un objet, puisque les constructeurs n'ont pas de valeur de retour.
Lorsqu'une exception est lancée à partir d'un constructeur, la construction de l'objet échoue. Par conséquent, le compilateur n'appellera jamais le destructeur pour cet objet, puisque cela n'a pas de sens. Cependant, ce comportement soulève le problème des objets partiellement initialisés, pour lesquels il est nécessaire de faire un peu de nettoyage à la suite du lancement de l'exception. Le C++ dispose donc d'une syntaxe particulière pour les constructeurs des objets susceptibles de lancer des exceptions. Cette syntaxe permet simplement d'utiliser un bloc try pour le corps de fonction des constructeurs. Les blocs catch suivent alors la définition du constructeur, et effectuent la libération des ressources que le constructeur aurait pu allouer avant que l'exception ne se produise.
Le comportement du bloc catch des constructeurs avec bloc try est différent de celui des blocs catch classiques. En effet, les exceptions ne sont normalement pas relancées une fois qu'elles ont été traitées. Comme on l'a vu ci-dessus, il faut utiliser explicitement le mot clé throw pour relancer une exception à l'issue de son traitement. Dans le cas des constructeurs avec un bloc try cependant, l'exception est systématiquement relancée. Le bloc catch du constructeur ne doit donc prendre en charge que la destruction des données membres partiellement construites, et il faut toujours capter l'exception au niveau du programme qui a cherché à créer l'objet.
De même, lorsque la construction de l'objet se fait dans le cadre d'une allocation dynamique de mémoire, le compilateur appelle automatiquement l'opérateur delete afin de restituer la mémoire allouée pour cet objet. Il est donc inutile de restituer la mémoire de l'objet alloué dans le traitement de l'exception qui suit la création dynamique de l'objet, et il ne faut pas y appeler l'opérateur delete manuellement.

## Exemple 9-5. Exceptions dans les constructeurs

Dans cet exemple, lors de la création dynamique d'un objet A, une erreur d'initialisation se produit et une exception est lancée. Celle-ci est alors traitée dans le bloc catch qui suit la définition du constructeur de la classe A. L'opérateur delete est bien appelé automatiquement, mais le destructeur de A n'est jamais exécuté.
En général, si une classe hérite de une ou plusieurs classes de base, l'appel aux constructeurs des classes de base doit se faire entre le mot clé try et la première accolade. En effet, les constructeurs des classes de base sont susceptibles, eux aussi, de lancer des exceptions. La syntaxe est alors la suivante :
# Programmation C-C++/Les exceptions/Remontée des exceptions

Cours de C/C++ :
| Les exceptions ||
| | Lancement et récupération d'une exception |
| | Remontée des exceptions |
| | Liste des exceptions autorisées pour une fonction |
| | Hiérarchie des exceptions |
| | Exceptions dans les constructeurs |
| Livre original de C. Casteyde ||
Les fonctions intéressées par les exceptions doivent les capter avec le mot clé catch comme on l'a vu ci-dessus. Elles peuvent alors effectuer tous les traitements d'erreurs que le C++ ne fera pas automatiquement. Ces traitements comprennent généralement le rétablissement de l'état des données manipulées par la fonction (dont, pour les fonctions membres d'une classe, les données membres de l'objet courant), ainsi que la libération des ressources non encapsulées dans des objets de classe de stockage automatique (par exemple, les fichiers ouverts, les connexions réseau, etc.).
Une fois ce travail effectué, elles peuvent, si elles le désirent, relancer l'exception, afin de permettre un traitement complémentaire par leur fonction appelante. Le parcours de l'exception s'arrêtera donc dès que l'erreur aura été complètement traitée. Bien entendu, il est également possible de lancer une autre exception que celle que l'on a reçue, comme ce peut être par exemple le cas si le traitement de l'erreur provoque lui-même une erreur.
Pour relancer l'exception en cours de traitement dans un gestionnaire d'exception, il faut utiliser le mot clé throw. La syntaxe est la suivante :
L'exception est alors relancée, avec comme valeur l'objet que le compilateur a construit en interne pour propager l'exception. Les gestionnaires d'exception peuvent donc modifier les paramètres des exceptions, s'ils les attrapent avec une référence.
Si, lorsqu'une exception se produit dans un bloc try, il est impossible de trouver le bloc catch correspondant à la classe de cette exception, il se produit une erreur d'exécution. La fonction prédéfinie std::terminate est alors appelée. Elle se contente d'appeler une fonction de traitement de l'erreur, qui elle-même appelle la fonction abort de la bibliothèque C. Cette fonction termine en catastrophe l'exécution du programme fautif en générant une faute (les ressources allouées par le programme ne sont donc pas libérées, et des données peuvent être perdues). Ce n'est généralement pas le comportement désiré, aussi est-il possible de le modifier en changeant la fonction appelée par std::terminate.
Pour cela, il faut utiliser la fonction std::set_terminate, qui attend en paramètre un pointeur sur la fonction de traitement d'erreur, qui ne prend aucun paramètre et renvoie void. La valeur renvoyée par std::set_terminate est le pointeur sur la fonction de traitement d'erreur précédente. std::terminate et std::set_terminate sont déclaréee dans le fichier d'en-tête exception.
localiser