expression conditionnelle connue à la compilation

Le
Marc G
Bonjour,
Dans une "longue" fonction template, j'ai juste besoin d'une adaptation pour
un cas particulier de paramètre
=> je n'ai pas trop envie de spécialiser toute la fonction.
J'ai défini un template is_similar qui me permet de savoir à la compilation
si un paramètre correspond à un type donné.

//--
Pour info :
//--
template<typename U,typename V>
struct is_similar {
enum { Yes=0, No=1 };
};

// spécialisation lorsque les deux types sont identiques
template<typename U>
struct is_similar<U,U> {
enum { Yes=1, No=0 };
typedef bool is_similar_;
};
//--

VOICI A QUOI RESSEMBLE LA FONCTION :

template<typename T>
void ma_fonction(void) {

if (is_similar<T,ASpecificType>::Yes)
{

}

}

MA QUESTION :

Dans le code ci-dessus, l'expression conditionnelle associée à if est
toujours true ou toujours false pour un type donné.
Est-ce que je peux supposer qu'au moment de l'instanciation de la fonction,
le compilateur va "optimiser" et tenir compte uniquement du résultat du
test,
ie si j'écris
if (true) { code }
seul code est finalement intégré au programme.
Y-a-t-il quelque chose défini par la norme la-dessus ?
Merci à vous
Marc
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Fabien LE LEZ
Le #19900551
On Sat, 8 Aug 2009 10:06:06 +0200, "Marc G"
VOICI A QUOI RESSEMBLE LA FONCTION :



Ne crie pas ! Inutile de t'énerver comme ça !

Est-ce que je peux supposer qu'au moment de l'instanciation de la fonction,
le compilateur va "optimiser" et tenir compte uniquement du résultat du
test,



Probablement.

Y-a-t-il quelque chose défini par la norme la-dessus ?



Je n'ai pas la norme sous les yeux, mais ça m'étonnerait. Si le
compilateur s'aperçoit que le code n'est jamais appelé, il a le droit
de le supprimer. Ça dépend donc du compilo, et probablement des
options de compilation.

Ce qui est sûr, en revanche, c'est que si tu écris :

if (1)
{
... //1
}
else
{
... //2
}

Le code "//2", bien que jamais appelé, doit être correct.
Marc G
Le #19900621
> Ne crie pas ! Inutile de t'énerver comme ça !


Je ne criais pas, j'essayais d'être plus lisible :-(

Ce qui est sûr, en revanche, c'est que si tu écris :

if (1)
{
... //1
}
else
{
... //2
}

Le code "//2", bien que jamais appelé, doit être correct.


oui, j'avais remarqué, en particulier si tu fais référence à une donnée
membre, ou à qlq chose de spécifique ... ça ne compile pas !
Mais de mémoire avec mon compilateur, ça fait pareil avec un succession de
if ;-(
=> dans ce cas il faut spécialiser.
Merci à toi
Mathias Gaunard
Le #19901991
On 8 août, 10:06, "Marc G"
Bonjour,
Dans une "longue" fonction template, j'ai juste besoin d'une adaptation p our
un cas particulier de paramètre
=> je n'ai pas trop envie de spécialiser toute la fonction.



Si ta fonction est "longue", c'est déjà mauvais signe. Une bonne
définition de fonction doit tenir sur moins de trente lignes.
Découpe ta fonction en différentes sous-fonctions, et spécialise la
sous-fonction en question.


J'ai défini un template is_similar qui me permet de savoir à la compi lation
si un paramètre correspond à un type donné.

//-----------------------------------------
Pour info :
//-----------------------------------------
 template<typename U,typename V>
 struct is_similar {
  enum { Yes=0, No=1 };
 };

 // spécialisation lorsque les deux types sont identiques
 template<typename U>
 struct is_similar<U,U> {
  enum { Yes=1, No=0 };
  typedef bool is_similar_;
 };
//-----------------------------------------



Il s'agit de la méta-fonction is_same de type_traits, (sauf que tu
utilises un système Yes/No bizarre au lieu d'un booléen).


template<typename T>
void ma_fonction(void) {
...
if (is_similar<T,ASpecificType>::Yes)
{
...

}
...
}



Ici is_same est inutile, on peut directement spécialiser, mais c'est
juste pour montrer un exemple.

template<typename T>
typename enable_if<is_same<T, ASpecificType>, void>::type
ma_sous_fonction()
{
...
}

template<typename T>
typename disable_if<is_same<T, ASpecificType>, void>::type
ma_sous_fonction()
{
...
}

template<typename T>
void ma_fonction() // l'argument void c'est pour le C
{
...
ma_sous_fonction<T>();
...
}


MA QUESTION :

Dans le code ci-dessus, l'expression conditionnelle associée à if est
toujours true ou toujours false pour un type donné.
Est-ce que je peux supposer qu'au moment de l'instanciation de la fonctio n,
le compilateur va "optimiser" et tenir compte uniquement du résultat du
test,



Si l'optimisation s'effectue, ce ne sera probablement pas au moment de
l'instantiation de la fonction, mais plus tard, dans l'optimiseur qui
n'aura plus rien à voir avec C++.

ie si j'écris
if (true) { code }
seul code est finalement intégré au programme.
Y-a-t-il quelque chose défini par la norme la-dessus ?



La norme spécifie la sémantique du langage, pas le code qui est
généré.
Publicité
Poster une réponse
Anonyme