Déclaration de variable dans la condition d'un if

Bonjour.

Si j'ai les classes suivantes:

Code:

---

1 2 3 4

class Base { public: virtual ~Base(); [...] }; class One : public Base { [...] }; class Two : public Base { [...] };

---

Est-ce que le code suivant est du C++ standard? (c'est à dire, est-ce que déclarer une variable dans le if est valide?). Il semblerait que ça marche en VC6.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

void aFunction( const Base & object ) { if (const One* pOne = dynamic_cast<const One*>(&Object)) { pOne->doSomething(); } else if (const Two* pTwo = dynamic_cast<const Two*>(&Object)) { pTwo->doSomethingElse(); } else { // No use of pOne or pTwo. } }

---

C'est pour éviter de faire 2 fois le dynamic_cast, une fois dans la condition du if, l'autre dans le traitement.

Merci.

Non, je pense pas, la déclaration d'une variable dans la condiftion n'est pas autorisé dans aucun langage de programmation.

il faut passé par une déclaration prédéfinie au par avant, pour qu'elle as une valeur, et puis faire la condition.

Si si, c'est tout à fait légal.

Citation:

---

Envoyé par cmoibal

Non, je ne pense pas, la déclaration d'une variable dans la condiftion n'est pas autorisé dans aucun langage de programmation.

il faut passé par une déclaration prédéfinie au par avant, pour qu'elle as une valeur, et puis faire la condition.

---

C'est à priori ce à quoi je m'attendais. Néanmoins, j'ai constaté que VC6 accepte sans problème la syntaxe, et qu'en plus le comportement est celui auquel on peut s'attendre.

Ma question est de savoir si c'est permis par le langage ou est-ce propre a VC6. (je n'ai pas la norme sous la main, ni d'autres compilateurs)

Citation:

---

Envoyé par Sylvain Togni

Si si, c'est tout à fait légal.

---

Et la portée est le corps du if et du else... un peu comme un index de boucle dans un for.

Je testerais ce soir sur gcc pour voir.

Merci à tous.

Salut,

C'est tout à fait légal, quant à savoir si c'est une bonne idée... (surtout sur base d'un dynamic_cast :P)

Dans l'exemple donné, pourquoi ne pas tout simplement utiliser une classe abstraite qui fournit l'interface commune aux deux classes :question:

Il est peut etre possible de trouver un terme qui permette justement de regrouper la signification des comportements de la classe One et celui de la classe Two, qui appellera, par polymorphisme One->doSomething et Two->doSomethingElse, selon le cas ;)

Cela prendrait, tout simplement, la forme de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

class Base { public: /*...*/ virtual void genericDoSomething()=0; }; class One : public Base { public: virtual genericDoSomething(){doSomething();} /*la visibilité reste du pur choix de l'utilisateur selon les besoins */ void doSomething() { /*...*/ } }; class Two : public Base { public: virtual genericDoSomething(){doSomethingElse();} /*la visibilité reste du pur choix de l'utilisateur selon les besoins */ void doSomethingElse() { /*...*/ } };

---

(voire, carrément, de redéfinir le comportement directement dans genericDoSomething... ;))
[EDIT]j'allais oublier: la fonction deviendrait alors, tout simplement

Code:

---

1 2 3 4 5

void aFunction(const Base* object) { object->genericDoSomething(); }

---

Citation:

---

Envoyé par koala01

Salut,

C'est tout à fait légal, quant à savoir si c'est une bonne idée... (surtout sur base d'un dynamic_cast :P)

Dans l'exemple donné, pourquoi ne pas tout simplement utiliser une classe abstraite qui fournit l'interface commune aux deux classes :question:

---

Oui, c'est bien évidemment ce qui pourrait être fait. Mais dans mon cas particulier, d'une part je ne maitrise pas (je ne peux pas modifier) l'arborescence Base/One/Two mais en plus les actions sur les classes dérivées n'ont rien a voir entre elles. C'est du code que je récupère en maintenance, donc, je fais avec.

Ma question portait plus sur la légalité du code (pour ma culture générale, car ça fonctionne avec le compilo que j'utilise) que sur la conception, qui n'est pas sur ce coup là, des plus élégante.