vérification d'existence utilité

Bonjour,

Je ne comprends pas l'utilité de la condition (a[j] && (v[j] != j)). En particulier, pourquoi vérifie-t'on l"existence de a[j].?

Code:

---

1 2 3 4 5 6

bool *a = new bool[n]; for (int i = 0; i < n; i++) a[i] = true; for (int j = 0; j < n; j++) if (a[j] && (v[j] != j)) // Pourquoi vérifie-t'on que a[j] existe? {}

---

Merci d'avance.

Bonjour,

a étant un pointeur vers un tableau de n bool, on ne vérifie ici pas l'existence de l'élément, mais si celui-ci est à true ou non.
Si oui, on vérifie alors la condition suivante v[j] != j.

Bon, déjà, on ne vérifie pas l'existence de a[j], qui existe toujours (pour j<n).
On vérifie que sa valeur est true.

Ensuite, avec le code que tu présentes, cela peut effectivement sembler stupide.

Mais on peut très ben imagine que le code qui suit fait quelque chose du genre :

Code:

---

a[j+2] = maFonction(j);

---

et alors, 2 itérations plus tard, a[j] pourrait avoir une valeur autre que true.

Bonsoir,

A Winjerome en effet, merci.
Merci à codini pour son explication.
Mais pour le code suivant, pourquoi vérifie t'on que le i existe?

Code:

---

1 2 3 4 5 6 7

for (int i = 0; i < p.n; i++) { if (i) // Pourquoi vérifier si le i existe? s << ' '; s << p.v[i] + 1; }

---

Merci.

Oublie le terme "existe", if ( condition ) vérifie avant tout si condition est non-nul.
Donc ici si i est différent de 0 : soit tout sauf la première itération.

Salut,

On ne vérifie pas que a[j] existe, on vérifie la valeur de l'élément a[j].

Ce code correspond trait pour trait (la facilité de lecture en moins à

Code:

---

if (a[j]==true && (v[j] != j))

---

Voici une petite explication, histoire de fixer les choses :
a est un tableau de booléen, c'est à dire un ensemble de valeurs qui peuvent valoir true ou false.
comme il s'agit de valeurs booléennes, elles peuvent parfaitement être utilisées "telles quelle" comme opérande pour l'opérateur logique AND: si a[j] vaut vrai, cela donnera la formule si (vrai ET QUE (v[j] != j)) (le résultat dépendant alors uniquement de la valeur de v[j] ;) et si a[j] vaut false, cela donnera la formule si(faux ET QUE (plus rien à foutre, le résultat est d'office faux ;)) )

Dis-toi que si i n'existe pas, ça ne compile pas...

En fait, le terme "vérifier l'existence" avec un if, ça me fait penser à javascript. Est-ce de là que vient ton expérience (ou au moins, d'un autre langage de script)?

Bonjour,

Aussi par exemple, dans ce code là, il s'agit bien de "vérifié l'existence" via
l'utilisation de assert.

Code:

---

1 2 3 4 5 6 7

class A { public: long n; // taille du tableau R * v; // le pointeur sur le tableau A(long m) : n(m), v( new double[n]) { assert(v && n>0 ); } // un constructeur

---

PS:
J'ai fais un peu de script shell, peut-etre que mon expression "vérifié l'existence" viens de là.

Par exemple,

Code:

---

1 2 3 4 5

#!/bin/bash # script plop.sh   if [ ! -e "$1" ]; then echo "$1 n'existe pas"

---

Dont l'exécution donne:

Code:

---

1 2 3

(mando@polgara) (~) $ ./plop.sh dieu dieu n'existe pas

---

Citation:

---

Envoyé par xavierdestev

Aussi par exemple, dans ce code là, il s'agit bien de "vérifié l'existence" via l'utilisation de assert.

---

Non. Le assert en question vérifie que n est différent de 0, et que n est strictement supérieur à 0.

if (a) signifie implicitement if (a!=0).

Merci pour les réponses.

En fait, il faut savoir que toute variable déclarée existe forcément.

Le seul cas où l'on fait un test qui peut être assimilé à un test d'existence, c'est lorsque l'on teste un pointeur.

Mais commençons par le commencement : Pour comprendre cette explication, il faut savoir ce qu'est un pointeur ;)

Un pointeur n'est jamais qu'une valeur numérique entière (généralement non signée) qui représente l'adresse en mémoire à laquelle on trouvera un élément du type indiqué (ou d'un type compatible).

Il arrive que l'on "prévoie qu'il puisse y avoir" un élément, alors qu'il n'y en a pas forcément.

Or, comme je viens de te le dire, toute variable déclarée existe forcément, entre le moment de sa déclaration et le moment où l'on quitte la portée dans laquelle elle est déclarée(*).

La seule solution, si l'on veut pouvoir indiquer que "c'est quelque chose qui n'existe pas forcément", c'est d'utiliser l'adresse de ce "quelque chose", et de lui donner une valeur particulière si le quelque chose n'existe effectivement pas.

L'adresse de ce quelque chose, c'est un pointeur sur ce quelque chose et la valeur particulière que l'on peut lui donner est nullptr (en C++11) ou NULL (avant C++11).

Cette valeur est définie pour être égale à la valeur booléenne false, ce qui fait que, lorsque l'on fait un test du genre de if(ptr)/* ... */ renverra true toute valeur qui n'est pas égale à nullptr (NULL).

Ainsi, si tu as une structure proche de

Code:

---

1 2 3 4

struct ListItem{ int value; ListItem * next; };

---

qui te permettra de créer une liste chainée d'entiers, chaque élément a d'office une valeur (s'il existe un élément, element.value existe), mais il y a d'office un élément qui n'est pas relié à un élément suivant: le dernier de la liste.

Il n'y aurait aucun sens (et il serait dangereux) d'essayer d'accéder à la valeur de l'élément suivant le dernier élément de la liste!

Nous commencerons donc par nous assurer que next contient une adresse valide ( en fait différente de nullptr, c'est le mieux que l'on puisse faire, en espérant que next ait bien été initialisé à nullptr lorsqu'il ne pointait vraiment vers aucun élément :P) avant d'essayer d'accéder au champs "value" de next.

Cela se traduira le plus souvent par

Code:

---

1 2 3

if (lePointeur->next ){ /* next existe, on peut faire ce qu'on veut ici */ }

---

qui correspond strictement à

Code:

---

1 2 3

if (lePointeur->next != nullptr){ /* next existe, on peut faire ce qu'on veut ici */ }

---

Cela pourrait prendre la forme d'une assertion (bien qu'une assertion sert avant tout à vérifier qu'un condition soit remplie, et à éviter d'aller plus loin en débug afin de permettre au développeur de savoir où il s'est planté) sous la forme de

Code:

---

assert(lePointeur->next);

---

Il n'y a que dans un cas similaire que nous aurons effectivement quelque chose qui correspond à un test d'existence ;)

(*)En fait, c'est ici que je devrais faire la distinction entre la variable d'une part et l'espace mémoire d'en représenter le contenu de l'autre.

En effet, la variable existe d'office entre le moment où elle est déclarée et le moment où l'on quitte la portée dans laquelle elle a été déclarée.

Mais si l'on travaille avec un pointeur (qui ne représente que l'adresse mémoire à laquelle on est sensé trouver un objet du type attendu), le pointeur et l'objet réel sont deux éléments clairement distincts ;)