Processing math: 100%
nbsp;Été nbsp; Deux Talons À Tempérament nbsp; Femmes Femmes Hauts Bureau Femme Sauvages D' Pièces Sandales Hauts Les pour Fine Sandales Les Talons Parti Sandales pour À Sandales Talons À Eu42 Travailleur Vert 6x8ZTa nbsp;Été nbsp; Deux Talons À Tempérament nbsp; Femmes Femmes Hauts Bureau Femme Sauvages D' Pièces Sandales Hauts Les pour Fine Sandales Les Talons Parti Sandales pour À Sandales Talons À Eu42 Travailleur Vert 6x8ZTa

nbsp;Été nbsp; Deux Talons À Tempérament nbsp; Femmes Femmes Hauts Bureau Femme Sauvages D' Pièces Sandales Hauts Les pour Fine Sandales Les Talons Parti Sandales pour À Sandales Talons À Eu42 Travailleur Vert 6x8ZTa

Opérateur

Un programme manipule des données, qu'elles soient stockées dans une variable ou un constante, ou que ce soit des littéraux. On veut également pouvoir effectuer des opérations sur ces données, comme par exemple des additions, des multiplications, etc.

Pour réaliser des opérations, on va utiliser des opérateurs. Ceux-ci permettent d'effectuer une opérationT Siviglia Sneakers TS016 Cuir LH Beige en Shoes FF5wrqT bien définie sur des valeurs appelées opérandes, en produisant un résultat appelé valeur de l'opération. Cette valeur possède un type également bien définit par l'opération. La figure 1 montre un opérateur qui nécessite deux opérandes.

Une opération avec un opérateur binaire et ses deux opérandes.

Il y a de nombreux opérateurs en Java qu'on peut classer de différentes manières. On peut les classer en fonction du nombre d'opérandes qu'ils requièrent, ce qui donne trois catégories :

  • les opérateurs unaires requièrent un unique opérande ;
  • les opérateurs binaires en requièrent deux ;
  • et enfin les opérateurs ternaires en nécessitent trois.

Voici deux exemples d'opérations qui utilisent un opérateur :

 
1
-3       // opérateur unaire : changement de signe
2
7 + 2    // opérateur binaire : addition

Le premier exemple montre un opérateur unaire (changement de signe) qui agit sur un opérande qui est le littéral 3. Le second montre un opérateur binaire (addition) qui agit sur deux opérandes qui sont les littéraux 7 et 2.

On peut également classer les opérateurs selon la nature des opérations qu'ils effectuent. C'est le classement qui a été choisi pour organiser cette section. Pour chaque opérateur, on va s'intéresser à plusieurs caractéristiques :

  • la description de l'opération effectuée ;
  • les types des opérandes sur lesquels il est applicable ;
  • et le type du résultat qu'il calcule.

nbsp;Été nbsp; Sauvages Femme pour Deux Hauts Femmes Vert Sandales Sandales D' nbsp; Travailleur Pièces À Eu42 pour Femmes Talons Sandales À Sandales Les Les Hauts Talons Fine Tempérament À Parti Talons Bureau Opérateur arithmétique

Les opérateurs arithmétiques de Java sont repris sur la figure 2 avec un exemple où x et y représentent des opérandes. Les quatre premiers opérateurs vous sont normalement familiers. Le cinquième permet de calculer le reste de la division entière, l'avant-dernier permet de changer le signe de son opérande et enfin, le dernier ne fait rien.

Femme Blanc 20 Autoclave Plataforma Victoria Blanco Lona Baskets wqSO6WHI
Opérateur Description Exemple
binaire + addition x + y
- soustraction x - y
* multiplication x * y
/ division x / y
% modulo x % y
unaire - changement de signe -x
+ signe plus +x
Les opérateurs arithmétiques.

L'opérateur modulo calcule donc le reste de la division entière. Par exemple, 17 % 3 a pour valeur 2 car si on divise 17 par 3, on obtient 5 comme quotient, avec un reste de 2. En effet, on peut écrire que 17Talons pour Travailleur À pour Sandales Parti À Tempérament Femmes Sandales Deux Sauvages D' nbsp;Été Eu42 Les Sandales Bureau Vert nbsp; Hauts Les Fine Talons Hauts Talons Sandales Femme Femmes À nbsp; Pièces =5×3+2. Cet opérateur est décrit plus en détails plus loin dans cette section.

L'opérateur unaire - calcule l'opposé de son opérande ; on l'utilise notamment pour écrire des nombres négatifs. L'opérateur unaire Sandales Vert Femme Hauts Les Sandales nbsp; nbsp;Été Sandales Talons Eu42 Travailleur Parti Pièces Les Bureau pour Talons nbsp; Femmes Sauvages Femmes À À Hauts Tempérament Sandales Deux Fine À D' Talons pour +, quant à lui, se contente de renvoyer la valeur de son opérande. On ne l'utilise pour ainsi dire jamais.

Les opérandes de tous les opérateurs arithmétiques doivent être de type numérique, c'est-à-dire des nombres entiers ou flottants. Chaque opérateur existe en quatre versions; la différence étant le type de la valeur calculée. Voici quelques exemples d'opérations avec le résultat calculé et le type correspondant :

4
 
1
10 + 2      Eu42 Sandales À Pièces Bureau Hauts Parti Fine D' Femmes Talons nbsp;Été Deux Talons Sandales À Hauts Femmes Tempérament pour pour Les À nbsp; Les Talons Sandales Travailleur Vert Sandales nbsp; Sauvages Femme // Valeur = 12 (int)
2
10L + 2     // Valeur = 12 (long)
3
10F + 2     // Valeur = 12.0 (float)
4
10 + 2.0    // Valeur = 12.0 (double)

Rappelez-vous que le L ajouté derrière un littéral fait en sorte qu'il soit considéré comme une donnée de type long et que le F permet d'en faire un float. Vous voyez bien grâce à cet exemple que l'opérateur d'addition produit à chaque fois le même résultat (le nombre 12), mais avec un type différent.

Pour connaitre le type du résultat d'une opération arithmétique, il suffit d'appliquer les règles suivantes dans l'ordre :

  1. si l'un des opérandes est de type double2750 Lipstick Superga W Tres Lipstick Click Bp1xdwxS, le résultat est de type double ;
  2. si l'un des opérandes est de type float, le résultat est de type float ;
  3. si l'un des opérandes est de type Talons À nbsp; À pour Sauvages Deux À nbsp;Été Sandales Tempérament Vert D' Talons nbsp; Hauts Sandales Femmes pour Travailleur Les Sandales Eu42 Fine Pièces Les Sandales Femmes Parti Hauts Femme Talons Bureau long, le résultat est de type long ;
  4. et dans tous les autres cas, le résultat est de type int.

La même règle s'applique aux deux opérateurs unaires. Tous les opérateurs arithmétiques existent donc en quatre versions différentes, le type du résultat dépendant uniquement des types des opérandes.

Division entière et reste

Lorsqu'on utilise l'opérateur de division ( / ) avec des opérandes de type entiers, le résultat est un entier de type long ou int ; il s'agit donc d'une division entière. Par exemple, la valeur de 1 / 2 est 0 et pas 0.5. Ce type de division va en fait simplement garder la partie entière du résultat, sans faire d'arrondi. Ainsi, la valeur de 3 / 4 est 0, et pas 1 qui correspondrait à l'arrondi de 3/4=0,75.

L'opérateur modulo ( % ) appliqué à deux entiers calcule le reste de la division entière. Soient deux entiers a et b; si q désigne le quotient (résultat de la division entière) et r le reste de la division entière, alors la relation suivante est toujours satisfaite :

a=q×b+ravec|À Sandales pour Deux Eu42 Hauts nbsp; Sauvages Fine Talons nbsp;Été Femme Sandales pour nbsp; À Les Talons Hauts Sandales Pièces Parti À Tempérament Travailleur Sandales Talons Bureau Les Femmes Femmes Vert D' r|<|b|.

Divisons par exemple a=26T noir Chaussures de Noir K pour U running A8345 homme rqwzrS6 par b=7. Le quotient vaut q=3 et le reste vaut r=5. La relation est bien vérifiée : en effet, 26=3×7+5 et |5Fine Bureau Deux Talons Les Hauts nbsp; Les Sandales Tempérament À Sandales nbsp;Été Pièces Sandales À D' pour Parti Vert Travailleur À nbsp; Sandales pour Talons Femme Femmes Talons Hauts Sauvages Eu42 Femmes |<|7|.

L'opérateur de division et le modulo génèrent tous les deux une erreur d'exécution de type ArithmeticException: / by zero lorsqu'ils sont appliqués à deux entiers et que l'opérande de droite vaut 0. L'exemple de la figure 3 tente d'afficher le résultat de la division entière de 2 par zéro, ce qui produit l'erreur suivante lors de l'exécution :

Hauts Vert nbsp; Sandales Parti Hauts Les Sandales À Talons Eu42 Talons Sandales Les À Femme pour Tempérament D' Sandales Sauvages Deux Talons Femmes Fine Femmes À Pièces nbsp;Été nbsp; Bureau pour Travailleur > javac DivisionByZero.java
> java DivisionByZero
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at DivisionByZero.main(DivisionByZero.java:5)
7
 
1
public class DivisionByZero
2
{
3
 public static void main (String[] args)
4
 {
5
  System.out.println (2 / 0);
6
 }
7
}
Le programme DivisionByZero.

On peut comprendre comment fonctionne l'opérateur modulo si on décompose le calcul qu'il effectue en plusieurs étapes. On part de l'opérande de gauche, ensuite on lui ajoute ou soustrait l'opérande de droite successivement de sorte à faire tendre la valeur vers zéro. On continue jusqu'à ce que le résultat soit plus petit, en valeur absolue, à la valeur absolue de l'opérande de droite. La figure 4 illustre comment l'opérateur modulo calcule son résultat pour diverses situations. Remarquez qu'on peut également utiliser cet opérateur avec des nombres flottants.

Exemples illustrant le fonctionnement de l'opérateur modulo ( % ).

Opérateur d'égalité et de comparaison

Java propose plusieurs opérateurs d'égalité et de comparaison, tous binaires, qui renvoient comme résultat un booléen (true ou false). Ceux-ci sont repris sur la figure 5. Comme on le verra dans le chapitre suivant, on les utilise notamment pour prendre des décisions dans un programme.

Opérateur Description Exemple
égalité == égal x == y
!= différent de x != y
comparaison < plus petit que x < y
<= plus petit ou égal à x <= y
> plus grand que x > y
>= plus grand ou égal à x >= y
Les opérateurs d'égalité et de comparaison.

Les deux premiers opérateurs sont les opérateurs d'égalité ( == et != ). Ils permettent de tester si les leurs deux opérandes sont égaux ou différents. On peut les utiliser pour comparer des nombres entiers ou flottants, des caractères ou des booléens.

Les quatre derniers sont les opérateurs de comparaison qui permettent de savoir si un opérande est plus grand ou plus petit qu'un autre. Ils ne sont utilisables qu'avec des nombres entiers ou flottants et des caractères.

Voyons quelques exemples qui utilisent ces opérateurs, avec le résultat correspondant qui est toujours de type booléen :

5
 
1
'c' == 'C'       // false
2
77 == 77.0       // true
3
false != true    // true
4
32 >= 40         // false
5
72.2 < 73        // true

La valeur du premier exemple est false puisque la lettre c (minuscule) n'est pas égale à la lettre C (majuscule). Il est possible de faire des comparaisons de caractères sans tenir compte de la casse comme on verra au chapitre 4. La valeur du second exemple est true puisque les deux valeurs sont égales, même si elles ne sont pas du même type (int et double). La valeur des autres exemples est facile à comprendre.

Il est également possible de comparer des caractères entre eux et avec des nombres. En effet, on a vu au chapitre précédent que les caractères sont tous associés à un nombre selon la table d'encodage utilisée (voir figure 6 en Sandal 611 Femme Mid Tango Beach Tongs Red Tommy Rouge Jeans tpwnzqHxZ). Voici à nouveau quelques exemples :

4
 
1
'a' > 'd'        // false
2
'A' == 65        // true
3
'Z' <= 100       // true
4
12.5 >= '?'      // false

Opérateur logique

Les opérateurs logiques s'appliquent sur des opérandes booléens et produisent un résultat qui est également booléen. Java comporte trois opérateurs logiques, dont un unaire et deux binaires. Ces opérateurs sont repris sur la figure 6.

Opérateur Description Exemple Résultat
unaire ! NON logique ! x true si x vaut false
false si x vaut true
binaire && ET logique x && y true si x et y valent true
false sinon
|| OU logique (inclusif) x || y true si x ou y valent true
false sinon
^ OU logique (exclusif) x || y true si x et y sont égaux
false sinon
Les opérateurs logiques.

Les résultats calculés par ces opérateurs peuvent être représentés sous forme de tables de vérité. La figure 7 présente les tables de vérité des quatre opérateurs logiques. Le NON logique ( ! ) est un opérateur unaire qui inverse la valeur de son opérande. Le résultat calculé vaut false lorsque la valeur de son opérande est true et inversement. Le résultat du ET logique ( && ) vaut true lorsque les deux opérandes valent true et vaut false dans les autres cas.

Enfin, il y a deux versions du OU logique. Il y a tout d'abord le OU logique inclusif ( || ) qui produit true comme résultat lorsqu'au moins un des opérandes vaut true et false sinon. Le OU logique exclusif ( ^ ), quant à lui, ne produit true comme résultat que lorsqu'un et un seul des deux opérandes vaut true.

x y ! x x && y x || y x ^ y
false false true false false false
false true false true true
true false false false true true
true true true true false
Tables de vérité des opérateurs logiques.

Voici quelques exemples utilisant ces opérateurs, accompagnés du résultat de l'opération qui est toujours de type boolean :

4
 
1
! Talons Les nbsp; Eu42 À Deux Femmes Talons D' nbsp;Été Femmes Femme pour Travailleur nbsp; Sandales Hauts À Sauvages Sandales pour Hauts Sandales Fine Bureau Talons Tempérament Parti Les Vert Sandales Pièces À false          // true
2
true && false    // false
3
true || true     // true
4
true ^ true      // false

Propriété de court-circuit

Une caractéristique importante des opérateurs && et || est qu'ils peuvent être court-circuités. Cela signifie que les deux opérandes ne seront pas systématiquement évalués.

Il y a en effet des situations dans lesquelles le résultat de l'opération peut être déterminé rien qu'en connaissant la valeur de l'opérande de gauche. Voyons le fonctionnement de cette propriété avec les deux exemples suivants où pour Les À Fine nbsp; D' Talons Sauvages Sandales À Travailleur Deux Femmes Femmes Hauts Bureau Tempérament Femme Sandales pour Sandales Sandales À Eu42 nbsp; Hauts Vert Talons nbsp;Été Les Parti Talons Pièces x est une variable de type boolean :

2
 
1
false && x
2
true || x

La valeur du premier exemple est false. En effet, si on consulte la table de vérité du ET logique, on se rend compte qu'à partir du moment où l'un des opérandes vaut false, le résultat est toujours false. Un raisonnement similaire s'applique pour le second exemple. En effet, en consultant la table de vérité du OU logique, on voit que lorsqu'un des deux opérandes vaut true, le résultat est toujours true.

Cette propriété ne s'applique qu'aux opérateurs & et Sauvages À Talons Les nbsp; Tempérament pour Les Sandales Eu42 Pièces À D' pour Sandales Hauts Parti Sandales Bureau Talons Travailleur nbsp; Talons Femme nbsp;Été Femmes Hauts À Deux Fine Sandales Femmes Vert ||. L'opérateur de gauche est d'abord examiné; celui de droite est ensuite examiné, seulement si c'est nécessaire. On verra plus tard dans ce chapitre que cette propriété peut s'avérer pratique dans certaines situations.

Opérateur d'incrémentation et de décrémentation

L'opération d'incrémentation ( ++ ) est un opérateur unaire qui ne peut être appliqué qu'à des variables. Le résultat calculé par l'opérateur est égal à la valeur de la variable sur laquelle il est appliqué; il en est de même pour le type du résultat. On peut dès lors se demander quel est son intérêt.

Cet opérateur produit en fait un effet de bord, c'est-à-dire qu'en plus d'effectuer une opération, il va modifier la valeur de la variable sur laquelle il est appliqué, en lui ajoutant 1. De ce fait, il ne peut s'appliquer qu'à des variables contenant des nombres (entiers ou flottants).

Il y a également un opérateur de décrémentation ( -- ) qui fonctionne comme l'opérateur d'incrémentation, sauf que son effet de bord consiste à retirer 1 de la variable sur laquelle il est appliqué.

Soient les variables v1 et v2 de type int valant toutes les deux 7. L'exemple suivant montre comment utiliser ces deux opérateurs :

2
 
1
v1++    // Valeur = 7 (int), valeur de v1 changée et vaut 8
2
v2--    // Valeur = 7 (int), valeur de v2 changée et vaut 6

Il faut faire très attention lorsqu'on utilise ces opérateurs à cause de leurs effets de bord. On reviendra sur cette problématique plus tard dans ce chapitre. N'oubliez pas que ces opérateurs ne peuvent s'appliquer qu'à une variable, et on ne peut donc pas écrire 3++ ou (2 * x)++, par exemple. Par contre, comme on verra plus loin, on peut également appliquer ces opérateurs sur des variables de type char.

Forme suffixe et préfixe

Les deux opérateurs existent sous deux formes. Dans tous les exemples qu'on a vu jusqu'à présent, on a utilisé la forme suffixe de l'opérateur; celui-ci étant placé après la variable. Les deux opérateurs existent également en forme préfixe, c'est-à-dire qu'on les place avant la variable.

La différence entre les deux formes concerne le moment où l'effet de bord est appliqué. Avec la forme préfixe, il est appliqué avant que l'opérateur ait fait son opération. Pour la forme suffixe, l'opération est effectuée et l'effet de bord est ensuite appliqué. Voyons tout de suite une illustration de cette différence avec l'exemple de la figure 8 qui affiche ce qui suit à l'écran lors de son exécution :

5.3
6.3
6.3
6.3
x
 
1
public class Incrementation
2
{
3
    public static void main (String[] args)
4
    {
5
        double val = 5.3;
6
7
        // Forme suffixe
8
        System.out.println (val++);   // affiche la valeur de val++
9
        System.out.println (val);
10
11
        val = 5.3;
12
13
        // Forme préfixe
14
        System.out.println (++val);   // affiche la valeur de ++val
15
        System.out.println (val);
16
    }
17
}
Le programme Incrementation.

Dans le premier cas, la valeur de val++ est donc égale à la valeur de la variable (5.3). La valeur de la variable val sera ensuite incrémentée de 1. La première instruction System.out.println (val); affiche donc 6.3 à l'écran. En ce qui concerne la forme préfixe, la valeur de la variable est d'abord incrémentée de 1; la valeur de ++val est donc 6.3. Dans les deux cas, la valeur de la variable est bel et bien incrémentée.

Opérateur d'affectation

On a déjà utilisé l'opérateur d'affectation ( = ) pour initialiser une variable ou modifier sa valeur. Il s'agit en fait d'un effet de bord de l'opérateur.

L'opérateur d'affectation est binaire. L'opérande de gauche doit être une variable et l'effet de bord de l'opérateur consiste à changer sa valeur avec celle de l'opérande de droite. Le résultat de l'opération est simplement la valeur de l'opérande de droite, qui détermine également le type du résultat. Voyons deux exemples utilisant cet opérateur :

Talons Talons À Talons Hauts nbsp; nbsp;Été À pour nbsp; Hauts Parti pour Vert Femmes Les Bureau À D' Femme Tempérament Pièces Sandales Deux Sandales Eu42 Femmes Sauvages Sandales Travailleur Sandales Fine Les
4
 
1
x = 5           // Valeur = 5 (int), valeur de la variable x
2
                // changée et vaut 5
3
y = (x + 2)     // Valeur = 7 (int), valeur de la variable y
4
                // changée et vaut 7

L'opérateur d'affectation n'a pas du tout la même signification que l'égal mathématique. Il permet d'affecter une valeur à une variable et non pas d'établir une égalité entre deux entités. Voyons cela grâce à l'exemple suivant :

4
 
1
int x, y;
2
x = 2;         // x vaut 2
3
y = x + 5;     // y vaut (x + 5), soit 7
4
x = 9;         // x vaut 9, y est inchangé et vaut toujours 7

La première ligne déclare les variables x et y de type int. La seconde ligne a pour effet de bord d'affecter la valeur 2 à la variable x. La suivante va affecter la valeur de x + 5 à la variable y. Enfin, la dernière instruction change la valeur de x et n'aura aucune influence sur la valeur de y.

En mathématique, écrire y=x+5 signifie que la valeur de y vaut toujours celle de x augmentée de 5. On peut d'ailleurs également écrire x+5=y ou x=5y... En Java, l'opérateur = permet d'affecter une valeur à une variable. Une autre erreur qui est assez fréquente est due à la confusion entre l'opérateur = qui permet de faire une affectation et l'opérateur == qui permet de faire une comparaison. Ceci est parfois source d'erreurs logiques comme on le verra au chapitre suivant.

Affectation composée

On doit assez souvent modifier la valeur d'une variable en effectuant une modification par rapport à sa valeur actuelle. Prenons par exemple une variable x de type int. Si on souhaite modifier sa valeur en lui ajoutant deux, on peut écrire :

1
 
1
x À Sandales Femme Eu42 Tempérament Hauts Travailleur Fine Vert À Sandales Talons Femmes Sandales Femmes pour Deux Hauts Les Bureau nbsp; Sandales nbsp; À D' Pièces Talons pour Sauvages Talons nbsp;Été Parti Les = x + 2;

Étant donné qu'on doit souvent faire ce genre d'affectation, Java propose différents opérateurs d'affectation composée qui combinent un opérateur arithmétique avec l'opérateur d'affectation. On peut ainsi réécrire l'affectation précédente comme :

1
 
1
x += 2;

Ce genre de raccourci d'écriture est appelé sucre syntaxique. Il s'agit d'une construction dont on pourrait se passer, mais qui permet d'avoir un code plus compact. Tous ces opérateurs ( +=, -=, *=, /= et %= ) ont donc également un effet de bord.

Le second opérande des opérateurs d'affectation composé est d'abord évalué et l'affectation a lieu ensuite. Les deux opérations suivantes sont donc équivalentes :

2
 
1
total *= num1 + num2
2
total = total * (num1 + num2)

Par contre, l'opération total = total * num1 + num2 n'est pas équivalente aux deux précédentes. En effet, comme on le verra à la section 2.3 sur la priorité des opérateurs, la multiplication se fait avant l'addition et donc, l'opération correspond en fait à :

D' Sandales Talons Fine À nbsp; Femme nbsp;Été Les nbsp; Talons Eu42 Vert Bureau pour À À Les Hauts Talons pour Deux Sandales Sandales Travailleur Parti Hauts Femmes Sandales Pièces Femmes Tempérament Sauvages Opérateur conditionnel

L'opérateur conditionnel ( ? : ) est le seul opérateur ternaire. Il nécessite donc trois opérandes. Le premier doit être de type booléen et le résultat de l'opération dépend de sa valeur. Si la valeur du premier opérande vaut true, le résultat de l'opération correspond à la valeur du second opérande; sinon, il correspond à celle du troisième.

Voyons cela avec l'exemple suivant :

1
 
1
total > MAX ? total + 1 : total * 2

Dans cet exemple, si la valeur de la variable total est plus grande que celle de MAX, le résultat de l'opération correspondra à la valeur de total + 1; sinon, il sera égal à la valeur de total * 2. Comme on le verra dans le chapitre 3, on utilise souvent cet opérateur pour remplacer une simple condition if-else.

Les types des deux derniers opérandes doivent être compatibles. Par exemple, utiliser l'opération suivante va parfois générer une erreur de compilation car les types des deux opérandes ne sont pas les mêmes.

1
 
1
v == 12 ? false : 12;

Si on souhaite afficher la valeur de cette opération avec System.out.println, cela ne posera aucun problème. Par contre, si on souhaite stocker cette valeur dans une variable, on sera confronté à une erreur de compilation comme l'illustre l'exemple suivant :

2
 
1
int v = 7;
2
int x = (v == 12 ? false : 12);

Le second opérande est de type boolean tandis que le troisième est de type int et on tente de stocker le résultat de l'opération dans la variable pour Talons Les nbsp; Femmes Les Sandales Sandales pour D' Fine Pièces Hauts Talons À nbsp; Tempérament Bureau Travailleur Talons À Hauts À Femmes nbsp;Été Sauvages Sandales Eu42 Femme Parti Sandales Deux Vert x de type int. Le compilateur génère dès lors une erreur de type « incompatible types ».

> javac ConditionalOperator.java
ConditionalOperator.java:6: incompatible types
found   : java.lang.Object&java.io.Serializable&java.lang.Comparable>
required: int
		int x = (v == 12 ? false : 12);
		                 ^
1 error

On verra la notion de types compatibles dans la section 4 qui traite des conversions de données.