IdentifiantMot de passe
Mot de passe oublié ?Je m'inscris ! (gratuit)

Cours complet pour apprendre à programmer en D

précédentsommairesuivant

49. La valeur null et l'Opérateur is ▲

Dans le chapitre précédent, nous avons vu qu'une variable d'un type référence n'a pas besoin de référencer un objet :

 
Sélectionnez
MaClasse referenceUnObjet = new MaClasse;
MaClasse variable;   // ne référence pas un objet

Étant d'un type par référence, variable a, dans le code précédent, une identité, mais ne référence pas encore d'objet. Un tel objet peut être représenté comme ceci dans sa case mémoire :

Image non disponible

Une référence qui ne référence aucune valeur est null. Nous développerons ce point.

Une telle variable est dans un état quasiment inutile. Comme elle ne référence pas d'objet, elle ne peut pas être utilisée dans un contexte où un objet MaClasse est requis :

 
Sélectionnez
import std.stdio;
 
class MaClasse
{
    int membre;
}
 
void utiliser(MaClasse variable)
{
    writeln(variable.membre);  // ← BOGUE
}
 
void main()
{
    MaClasse variable;
    utiliser(variable);
}

Il n'y a pas d'objet référencé par le paramètre que la fonction utiliser reçoit. Essayer d'accéder à un membre d'un objet non existant fait planter le programme :

 
Sélectionnez
$ ./essai
$ Erreur de segmentation

« Erreur de segmentation » est une indication que le programme a été tué par le système d'exploitation parce qu'il a essayé d'accéder à une adresse mémoire illégale.

49-1. La valeur null ▲

La valeur spéciale null peut être affichée comme n'importe quelle autre valeur.

 
Sélectionnez
writeln(null); // affiche 'null' dans la sortie

Comme dans beaucoup d'autres langages, la représentation entière de null est 0.

Une variable null peut être utilisée dans deux contextes :

  1. En lui affectant un objet

     
    Sélectionnez
    variable = new MaClasse;  // référence maintenant un objet

  2. Cette affectation fait pointer variable vers l'objet nouvellement créé. À partir de là, variable peut être utilisée pour n'importe quelle opération valide du type MaClasse ;

  3. Pour déterminer si elle est null.
    Cependant, comme l'opérateur == a besoin de deux objets pour faire la comparaison, l'expression qui suit ne peut pas être compilée :

     
    Sélectionnez
    if (variable == null)     // ERREUR de compilation
  4. Pour cette raison, pour savoir si une variable est null, on utilise l'opérateur is.

49-2. L'opérateur is ▲

Cet opérateur répond à la question « a la valeur nulle ? » (NDT is veut dire « est » en anglais) :

 
Sélectionnez
if (variable is null) {
    // Ne référence aucun objet
}

L'opérateur is peut aussi être utilisé avec d'autres types de variable. Dans l'utilisation suivante, il compare les valeurs de deux entiers :

 
Sélectionnez
if (vitesse is nouvelleVitesse) {
    // Leurs valeurs sont égales
 
} else {
    // Leurs valeurs sont différentes
}

Lorsqu'on l'utilise avec les tranches, il détermine si deux tranches référencent le même ensemble d'éléments :

 
Sélectionnez
if (tranche is tranche2) {
    // Elles donnent accès aux mêmes éléments
}

49-3. L'opérateur !is ▲

!is est l'opposé de is. Il donne true quand les valeurs sont différentes :

 
Sélectionnez
if (vitesse !is nouvelleVitesse) {
    // Leurs valeurs sont différentes
}

49-4. Affecter la valeur null ▲

Affecter la valeur null à une variable de type référence fait que la variable arrête de référencer son objet actuel.

S'il se trouve que cette affectation supprime la dernière référence à cet objet, alors l'objet devient un candidat à la finalisation par le ramasse-miettes. En effet, pour un objet, n'être référencé par aucune variable veut dire qu'il n'est pas utilisé du tout dans le programme.

Regardons l'exemple d'un chapitre précédentTypes valeur et types référence où deux variables référençaient le même objet :

 
Sélectionnez
auto variable = new MaClasse;
auto variable2 = variable;

Ce qui suit est une représentation de l'état de la mémoire après l'exécution de ce code :

Image non disponible

Affecter la valeur null à l'une des deux variables casse sa relation avec l'objet :

 
Sélectionnez
variable = null;

À partir de ce point, il n'y a plus que variable2 qui référence l'objet :

Image non disponible

Affecter null à la dernière référence rendrait l'objet inatteignable :

 
Sélectionnez
variable2 = null;

Un tel objet inatteignable sera finalisé par le ramasse-miettes à un certain moment dans le futur. Du point de vue du programme, l'objet n'existe pas :

Image non disponible

Nous avons discuté des moyens de vider un tableau associatif dans les exercices du chapitre sur les tableaux associatifsTableaux associatifs. Nous connaissons maintenant une quatrième méthode : affecter null à un tableau associatif casse la relation entre cette variable et les éléments :

 
Sélectionnez
string[int] noms;
// ...
noms = null;     // Ne donne accès à aucun élément

De manière similaire aux exemples avec MaClasse, si noms était la dernière référence aux éléments du tableau associatif, ces éléments seront finalisés par le ramasse-miettes.

Les tranches peuvent également être affectées à null :

 
Sélectionnez
int[] tranche = autreTranche[ 10 .. 20 ];
// ...
tranche = null;     // Ne donne accès à aucun élément

49-5. Résumé▲

  • null est la valeur indiquant qu'une variable ne donne accès à aucun élément.
  • Les références qui ont la valeur null ne peuvent être utilisées que dans deux opérations : leur affecter une valeur et déterminer si elles sont null ou pas.
  • Comme l'opérateur == peut nécessiter l'accès à un objet, déterminer si une variable est null doit être fait avec l'opérateur is.
  • !is est l'opposé de is.
  • Affecter null à une variable fait que cette variable ne pointe plus vers aucun objet.
  • Les objets qui ne sont référencés par aucune variable sont finalisés par le ramasse-miettes.
précédentsommairesuivant