78 lines
3.0 KiB
Plaintext
78 lines
3.0 KiB
Plaintext
[set
|
||
title = "[c auto] et [c typeof]"
|
||
partAs = chapitre
|
||
translator = "Raphaël Jakse"
|
||
proofreader = "Stéphane Goujet"
|
||
]
|
||
|
||
[ = [c auto]
|
||
|
||
Quand on a défini les variables de type [c File] dans le chapitre précédent, on a répété le nom du type des deux côtés de l'opérateur [c ~=]~ :
|
||
|
||
[code=d <<<
|
||
File file = File("enregistrements_etudiants", "w");
|
||
>>>]
|
||
|
||
Cela semble redondant. C'est également lourd et sujet à erreurs, surtout quand le nom du type est plus long.
|
||
|
||
[code=d <<<
|
||
NomDeTypeTresLong var = NomDeTypeTresLong(/* ... */);
|
||
>>>]
|
||
|
||
Heureusement, le nom du type sur le côté gauche de l'affectation n'est pas nécessaire parce que le compilateur peut inférer le type de la variable depuis l'expression à droite de l'affectation. Pour que le compilateur infère le type, le mot-clé [c auto] peut être utilisé~ :
|
||
|
||
[code=d <<<
|
||
auto var = NomDeTypeTresLong(/* ... */);
|
||
>>>]
|
||
|
||
[c auto] peut être utilisé avec n'importe quel type même si le type n'est pas écrit explicitement du côté droit~ :
|
||
|
||
[code=d <<<
|
||
auto duree = 42;
|
||
auto distance = 1.2;
|
||
auto accueil = "Hello";
|
||
auto vehicule = JoliVelo("bleu");
|
||
>>>]
|
||
|
||
|
||
Même si [c auto] est l'abréviation de [i automatique], il ne vient pas d'[i inférence automatique des types]. Il vient de [* classe automatique de stockage], qui est une notion à propos de la durée de vie des variables. [c auto] est utilisé quand aucun autre indicateur n'est approprié. Par exemple, la définition suivante n'utilise pas [c auto]~ :
|
||
|
||
[code=d <<<
|
||
immutable i = 42;
|
||
>>>]
|
||
|
||
Dans ce code, le compilateur infère le type de [c i] en [c immutable int] (nous verrons [c immutable] dans un chapitre ultérieur).
|
||
]
|
||
[ = [c typeof]
|
||
|
||
[c typeof] donne le type d'une expression (ce qui comprend les variables simples, les objets, les littéraux...).
|
||
|
||
Ce qui suit est un exemple de comment [c typeof] peut être utilisé pour spécifier un type sans l'écrire explicitement~ :
|
||
|
||
[code=d <<<
|
||
int valeur = 100; // déjà défini comme 'int'
|
||
|
||
typeof(valeur) valeur2; // signifie "type de valeur"
|
||
typeof(100) valeur3; // signifie "type du littéral 100"
|
||
>>>]
|
||
|
||
|
||
Les deux dernières définitions sont équivalentes à ce qui suit~ :
|
||
|
||
[code=d <<<
|
||
int valeur2;
|
||
int valeur3;
|
||
>>>]
|
||
|
||
Il est évident que [c typeof] n'est pas nécessaire dans des situations comme celles-ci, quand les types sont déjà connus. Ce mot-clé est surtout utile dans les définitions de modèles ([i templates]), que nous verrons dans des chapitres ultérieurs.
|
||
]
|
||
|
||
[ = Exercices
|
||
|
||
Comme nous n'avons vu précédemment, le type des littéraux tels que 100 est [c int] (et non [c short], [c long], ou n'importe quel autre type). Écrire un programme pour déterminer le type des littéraux à virgule flottante comme 1.2.
|
||
|
||
[c typeof()] et [c .stringof] sont utiles pour ce programme.
|
||
|
||
[[part:corrections/auto_et_typeof || … La solution]]
|
||
]
|