Mutabilité
D est un langage typé statiquement: une fois qu'une variable a été déclarée, son type ne peut être modifié. Cela permet au compilateur d'empêcher certains bugs et de mettre en place certaines restrictions à la compilation.
Un typage sûr permet de créer des programmes importants sans erreurs et facilite leur maintenance.
Il y a plusieurs qualificateurs de types en D, mais les plus utilisés sont const et immutable.
immutable
En plus de son système de typage statique, D fourni des qualificateurs de types (parfois appelés "constructeurs de types") qui assurent un certain nombre de contraintes sur certains objets.
Par exemple, un objet immutable ne peut être initialisé qu'une fois et il n'est plus autorisé à changer après ça.
immutable int err = 5;
// ou : immutable err = 5 et le type est déduit
err = 5; // ne compilera pas : ERREUR
Les objets immutable peuvent donc être partagés entre différents threads non-synchronisés sans risques puisque par définition ils ne changent pas. Cela implique également que les objets immutable peuvent être mis en cache parfaitement.
const
Les objets const ne peuvent pas non plus être modifiés. Cette restriction n'est valide que dans la portée courante. Un pointeur const peut être créé à partir d'un objet mutable ou immutable. Cela signifie qu'un objet peut être const dans la portée courante, mais que quelqu'un peut le modifier à partir d'un autre contexte. Il est courant pour les API d'accepter des arguments const pour assurer qu'elles ne modifieront pas les données qu'on leur fournit en entrée, car cela permet à la fonction de traiter des données mutables ou immutable.
void foo ( const char[] s )
{
// si elle n'est pas commentée, la prochaine ligne
// produira une erreur (on ne peut pas modifier un const):
// s[0] = 'x';
import std.stdio : writeln;
writeln(s);
}
// grâce à const, ces deux exemples vont compiler:
foo("abcd"); // une string est un tableau immutable
foo("abcd".dup); // .dup retourne une copie mutable
immutable et const sont des qualificateurs de types transitifs, ce qui assure qu'une fois que const est appliqué à un type, cela s'applique récursivement à tous les composants de ce type.
Pour aller plus loin
Références de base
Références avancées
