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_;
};
//-----------------------------------------
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
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Fabien LE LEZ
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.
On Sat, 8 Aug 2009 10:06:06 +0200, "Marc G" <mgueguen@metrica.fr>:
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.
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
> 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
> 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
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
On 8 août, 10:06, "Marc G" wrote:
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> 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é.
On 8 août, 10:06, "Marc G" <mgueg...@metrica.fr> wrote:
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>
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é.
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> 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é.
