Discussion :

[nikopol82]

Bonjour,
Dans une classe j'ai cree une methode template. Le parametre template est un bouléen "isConst".
Le comportement du code est correct, mais j'aimerai que la méthode soit const dans un cas et non const dans l'autre, au sens ou elle ne change pas les données membres de la classe.

Evidemment, je pourrais dupliquer le code pour faire un cas const et un autre cas non const, mais je me demandais si il y avait une façon plus élégante de faire ça.

exemple (les variables commençant par un underscore sont des données membre de la classe) :

La méthode que je veux const ou non const

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 template <bool isConst> inline void inCircleListFromNULL(    std::vector<simplex<scalar_type> *> & toDelete,\
std::vector<pathToFace<scalar_type> > & visibleFaces,\
scalar_type * const & point)
{
    //....DU CODE
    typedef typename std::list<pathToFace<scalar_type> > LPTF;
    IncrementOrErase<LPTF,isConst>::apply(_externFaces,il);
    //... DU CODE
}

Avec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 //La fonction IncrementOrErase FAIT ++il ou il=container.erase(il) 
//selon si isConst est true ou false
template <class container_type, bool isConst> struct IncrementOrErase;
template <class container_type> struct IncrementOrErase<container_type,false>
{
    static inline void apply(container_type & cont, typename container_type::iterator & il)
    {
        il = cont.erase(il);
    }
};
template <class container_type> struct IncrementOrErase<container_type,true>
{
    static inline void apply(const container_type & cont, typename container_type::const_iterator & il)
    {
        ++il;
    }
};

Merci d'avance,

S.

[loufoque]

Utilise [code] déja, pour que ce soit lisible.

[ac_wingless]

Il y a une contradiction entre l'utilisation d'un paramètre template (donc entièrement définissable par l'utilisateur), et la détermination d'une valeur par le compilateur (donc non définissable par l'utilisateur). En particulier, on peut écrire "IncrementOrErase<LPTF,true>::apply(_externFaces,un_iterateur_non_const);". Bien sûr, si on veut pouvoir écrire ceci, l'avortement rétroactif du programmeur concerné s'impose très naturellement comme la seule solution vraiment élégante.
Par ailleurs, quitte à mettre un namespace si on a peur de la pollution de l'espace des noms, une classe ne contenant que des fonctions statiques de même nom est avantageusement remplacée par la surcharge bête:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
template < class C >  void apply ( const C& c, typename C::const_iterator& i ) { i++; }
template < class C >  void apply (       C& c, typename C::iterator&       i ) { i = c.erase(i); }

[nikopol82]

Quand tu dis qu'on peut écrire "IncrementOrErase<LPTF,true>::apply(_externFaces,un_iterateur_non_const);", je ne vois pas pourquoi : celà donnerait une erreur de compilation (conversion impossible d'un iterateur non const en const_iterator.) En tous cas je ne veux pas du tout pouvoir écrire ceci évidemment.

Ce que je veux c'est que la méthode
template <bool isConst> inline void inCircleListFromNULL(..) ait un prototype const dans le cas isConst==true et pas dans l'autre cas ie,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
 template <true> inline void inCircleListFromNULL(..) const;
//et
 template <false> inline void inCircleListFromNULL(..); //Pas const

Le but est d'ajouter le mot clef const à la fin de la méthode dans le cas isConst==true.

En tous cas merci pour la réponse. C'est sûr que la méthode par surcharge est plus simple pour ce qui est de apply.

S.

[loufoque]

Tu peux faire ça avec SFINAE je pense.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
template<bool isConst>
typename enable_if_c<isConst, void>::type inCircleListFromNULL(..) const;
 
template<bool isConst>
typename disable_if_c<isConst, void>::type inCircleListFromNULL(..); //Pas const

[ac_wingless]

Quand tu dis qu'on peut écrire "IncrementOrErase<LPTF,true>::apply(_externFaces,un_iterateur_non_const);", je ne vois pas pourquoi : celà donnerait une erreur de compilation (conversion impossible d'un iterateur non const en const_iterator.) En tous cas je ne veux pas du tout pouvoir écrire ceci évidemment.

Je voulais simplement souligner que l'écriture manuelle de "true" était redondante, puisque le compilateur n'acceptera que "false". Quant à ma blague pourrie, faut pas faire attention...
L'ajout de "const" n'est pertinent que pour des fonction membres d'une classe, dont en l'occurrence l'existence n'est pas justifiée dans le code proposé (cette classes est artificielle, car ne contenant que des fonctions membres statiques, elle a donc la fonction d'un namespace). Par contre, si la classe a ses raisons d'exister par ailleurs, alors il suffit d'utiliser la même technique de surcharge pour les fonctions, cette fois membres et non indépendantes, ce qui aboutit bien sûr à l'ajout du mot const.

[nikopol82]

Bonjour,
Bien entendu, toutes ces fonctions sont bien des fonctions membres d'une classe. J'ai bien compris le sens du mot const en fin de prototype et c'est aussi pourquoi j'ai parlé de méthodes et pas de fonctions.
S.

[nikopol82]

Ta méthode semble résoudre mon problème. Réponse précise et rapide.

S.