merge Olivier's translation of operateur_paresseux

operateurs_paresseux.whata

@@ -1,24 +1,28 @@
 [set
     title       = "Opérateurs paresseux (''lazy'')"
     partAs      = chapitre
-    translator  = "Raphaël Jakse"
+    translator  = "Raphaël Jakse, Olivier Pisano"
+    proofreader = "Stéphane Gouget, Raphaël Jakse"
 ]
 
-L'évaluation paresseuse consiste a délayer l'exécution d'expressions au moment où on a besoin du résultat de ces expressions. Les évaluations paresseuses font partie des fonctionnalités de base de certains langages de programmation.
+Le évaluation paresseuse consiste à retarder l'exécution d'expressions jusqu'au moment où l'on a besoin du résultat de ces expressions. Les évaluations paresseuses font partie des fonctionnalités fondamentales de certains langages de programmation.
 
-Naturellement, délayer l'exécution des expressions au moment où leurs résultats sont vraiment nécessaires peut rendre les programmes plus rapides.
+Naturellement, retarder l'exécution d'expressions jusqu'à ce que leurs résultats soient vraiment nécessaires peut rendre les programmes plus rapides.
 
-Une idée qui est similaire à l'évaluation paresseuse est le comportement de ces trois opérateurs :
+Le comportement raccourci des opérateurs suivants est conceptuellement similaire aux évaluations paresseuses~ :
+
+ - [
+    L'opérateur [c > ||] (ou)~ : la seconde expression est évaluée seulement si la première est fausse ([c false]).
 
- - L'opérateur [* ou] [c > ||] : La seconde expression n'est évalué que si la première expression est fausse.
     [code=d <<<
        if (uneExpression() || peutNePasÊtreÉvaluée()) {
            // ...
        }
    >>>]
-   Si le résultat de [c uneExpression()] est [c true], le résultat de l'expression [c ||] est aussi vraie et la seconde expression n'est pas évaluée.
-
- - L'opérateur [* et] [c &&] : La seconde expression n'est évaluée que si la première expression est vraie.
+   Si le résultat de [c uneExpression()] est [c true], le résultat de l'expression [c > ||] est aussi vrai et la seconde expression n'est pas évaluée.
+ ]
+ - [
+    L'opérateur [c &&] (et)~ : la seconde expression est évaluée seulement si la première est vraie ([c true]).
 
     [code=d <<<
        if (uneExpression() && peutNePasÊtreÉvaluée()) {
@@ -26,18 +30,20 @@ Une idée qui est similaire à l'évaluation paresseuse est le comportement de c
        }
     >>>]
 
+   Si le résultat de uneExpression est faux ([c false]), le résultat de l'expression [c &&] est également faux et la seconde expression n'est pas évaluée.
+ ]
 
-   Si le résultat de [c uneExpression()] est [c false], le résultat de l'expression [c &&] est aussi fausse et la seconde expression n'est pas évaluée.
- - L'opérateur ternaire [c ?:] : Soit la première, soit la deuxième expression est évaluée selon si la condition est vraie ou fausse, respectivement.
-
+ - [
+    L'opérateur ternaire [c ?:]~ : soit la première, soit la deuxième expression est évaluée, si la condition est vraie ou fausse, respectivement.
 
     [code=d <<<
-       int i = condition() ? SoitCeli() : ouCela();
+        int i = condition() ? soitCeci() : soitCela();
     >>>]
+ ]
 
- La paresse de ces opérateurs n'est pas seulement une affaire de performance. Parfois, évaluer une des expressions peut être une erreur.
+La paresse de ces opérateurs n'est pas seulement une question de performance. Parfois, évaluer une des expressions peut être une erreur.
 
-Par exemple, vérifier la condition [c si la première lettre est A] ci-après serait une erreur quand la chaîne est vide :
+Par exemple, ci-après, vérifier la condition «~ [* si la première lettre est A]~ » serait une erreur si la chaîne est vide~ :
 
 [code=d <<<
     dstring s;
@@ -47,7 +53,7 @@ Par exemple, vérifier la condition [c si la première lettre est A] ci-après s
     }
 >>>]
 
-Pour accéder à l'élément d'indice zéro de [c s], il faut d'abord s'assurer que la chaîne a un tel élément. Pour cette raison, la vérification de condition suivante déplace cette expression logique potentiellement erronée au côté droit de l'opérateur [c &&] pour s'assurer qu'elle ne sera évaluée que quand il sera sûr de le faire :
+Pour pouvoir accéder à l'élément d'indice zéro de [c s], il faut d'abord s'assurer que la chaîne contient un tel élément. Pour cette raison, la vérification de condition suivante déplace cette expression logique potentiellement erronée du côté droit de l'opérateur [c &&] afin de s'assurer qu'elle ne sera évaluée que lorsqu'effectuer cette évaluation sera sans risque~ :
 
 
 [code=d <<<