Discussion :

[Feriaman]

Bonjour à tous,

Ça y est, je suis enfin tombé (professionnellement, j'entends) sur un code développé par quelqu'un de plus fanatique que moi.

Moi qui prône le bien coder, le boost, le template, la meta-prog à tous crins depuis de longues années, j'ai aujourd'hui pour mission de péréniser un code tellement plein de templates, que j'ai le plus grand mal à le lire.

Pour vous donner une idée, une recherche du mot clef "typename" dans le projet donne 8417 résultats pour 911 fichiers (*)

J'en appelle donc à tous mes co-fanatiques en cette discipline qu'est l'abus de templates : ceux avec lesquels j'ai eu l'occasion d'avoir de long débats passionnés (ici même et ailleurs), et ceux qui ne m'ont pas encore offert cette chance.

Ma question est simple : "Quels outils utilisez-vous pour parcourir vos codes templatés ?"

Mieux qu'une explication, voici un exemple :
Toto.h

Code :

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

1
2
3
4
class Toto
{
	typedef int Count;
}

Titi.h

Code :

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

1
2
3
4
5
template<typename T> class Titi
{
	typedef T::Count Count;
	Count count;
}

Tata.h

Code :

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

1
2
3
4
template<typename T> class Tata
{
	typedef Titi<T> Tutu;
}

main.cpp

Code :

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

1
2
3
...
	Tata<Toto> > instance_de_Tata;
...

Tata.hpp

Code :

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

1
2
3
4
...
	Tutu tutu;
	tutu.count; // <--- de quel type est ceci ?
...

Quand je tombe sur la ligne marquée du fichier Tata.hpp, aujourd'hui, il me faut une bonne minute pour remonter au type de "count". (d'autant plus que les fichiers sont répartis dans de nombreux répertoires, et que mon IDE ne sait, la plupart du temps répondre que : "symbol not defined").

Cette minute me prend d'énergie, qu'en général quand j'obtiens ma réponse, je n'ai plus du tout en tête la raison pour laquelle je me suis posé cette question.

Ma découverte du code est donc excessivement longue, et par la même, la maintenance engendrée doit l'être aussi.

J'ai donné le code à manger à tous les "code completer" dont je dispose (dont celui de crosoft). Et sous prétexte de ne pas savoir résoudre parfaitement le problème, aucun d'entre eux ne semble le résoudre même partiellement.

En particulier, le lien entre Tata et Toto est très compliqué à faire. Je me contenterais d'un système semi-automatique, mais cela ne semble pas exister.

A l'heure actuelle, je n'ai que trois pistes :
- écrire mon propre outil (ouhla !)
- proposer une réorganisation du code (en supprimant une partie des templates)
- écrire un pseudo-dictionnaire (étant donné que souvent les mêmes noms de typename ou presque désignent souvent les mêmes types)

Avant de me lancer sur l'une ou l'autre de ces pistes, je préfèrerais savoir si l'un d'entre vous connait un outil qui pourrait m'aider.

Merci à ceux qui ont lu.
Merci à ceux qui répondront.


(*) je sais, certains vont me dire que l'on peut (et que l'on doit) utiliser des typedef même si l'on n'utilise pas de template, et ils auront raison. Mais j'espère qu'ils m'accorderont le fait que cette utilisation est négligeable (si ce n'est en importance, au moins en volume) devant celle des typename et typedef induits par les templates.

[Arzar]

L'arroseur arrosé.
Je vais suivre attentivement ce topic, car j'ai le même genre de problème que tu as parfaitement bien décris face à du code fortement templaté.

Il m'est arrivé sur des projets où les temps de compilation ne sont pas trop long de rajouter artificiellement des erreurs dans le code pour profiter des messages d'erreur du compilateur.

Par exemple remplacer :

Code :

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

1
2
Tutu tutu;
tutu.count; // <--- de quel type est ceci ?

Par :

Code :

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

1
2
Tutu tutu;
static_cast<float****>(tutu.count); // la conversion échoue et force la compilation à sortir en erreur

Même si c'est vrai que dans ce cas le message émit par VS2008 n'est pas particulièrement glorieux...

>Compilation en cours...
1>main.cpp
1>mes documents\visual studio 2008\projects\testbasiccpp\testbasiccpp\tata.hpp(6) : error C2440: 'static_cast'*: impossible de convertir de 'int' en 'float ****'
1> La conversion d'un type intégral en type pointeur nécessite reinterpret_cast, un cast de style C ou un cast de style fonction
1> mes documents\visual studio 2008\projects\testbasiccpp\testbasiccpp\tata.hpp(4)*: lors de la compilation de la fonction membre '<Inconnu>' de la classe <Inconnu>
1> mes documents\visual studio 2008\projects\testbasiccpp\testbasiccpp\main.cpp(493)*: voir la référence à l'instanciation de la classe modèle 'Tata<T>' en cours de compilation
1> with
1> [
1> T=Toto
1> ]
1>Le journal de génération a été enregistré à l'emplacement "file://Mes documents\Visual Studio 2008\Projects\TestBasicCpp\TestBasicCpp\Debug\BuildLog.htm"
1>TestBasicCpp - 1 erreur(s), 0 avertissement(s)
========== Génération*: 0 a réussi, 1 a échoué, 0 mis à jour, 0 a été ignoré ==========

"impossible de convertir de 'int' en 'float ****'"
Bon avec cette technique on sait quand même que le type final de tutu.count; est bien un int, mais j'avoue que la ligne suivante est un peu déprimante :
" lors de la compilation de la fonction membre '<Inconnu>' de la classe <Inconnu>".

Je serais curieux de savoir ce que le compilateur clang émet comme erreur car il est réputé pour générer des messages d'erreur largement supérieur à ceux de GCC et VS sur du code fortement templaté.

Mais c'est vrai qu'au final ce n'est pas une technique vraiment utilisable car sur un vrai projet C++ les temps de compilation peuvent vite dépasser les quelques dizaines de seconde donc ça ne vaut plus vraiment le coup.

Edit :
Visiblement il y a quelques progrès sur les messages d'erreur avec VS2010.

main.cpp
mes documents\visual studio 2010\testbasiccpp\testbasiccpp\tata.hpp(6): error C2440: 'static_cast'*: impossible de convertir de 'int' en 'float ****'
1> La conversion d'un type intégral en type pointeur nécessite reinterpret_cast, un cast de style C ou un cast de style fonction
1> mes documents\visual studio 2010\testbasiccpp\testbasiccpp\tata.hpp(4)*: lors de la compilation de la fonction membre 'void Tata<T>::foo(void)' de la classe modèle
1> with
1> [
1> T=Toto
1> ]
1> mes documents\visual studio 2010\testbasiccpp\testbasiccpp\main.cpp(493)*: voir la référence à l'instanciation de la classe modèle 'Tata<T>' en cours de compilation
1> with
1> [
1> T=Toto
1> ]
========== Génération*: 0 a réussi, 1 a échoué, 0 mis à jour, 0 a été ignoré ==========

[Feriaman]

Merci pour ta réponse. Je n'avais en effet pas pensé à utiliser le compilateur de cette manière.

Mais comme tu le soulignes toi-même : ça marche mais ce n'est pas très pratique (surtout que le temps de compilation des codes fortement templatés ne permet pas forcément d'en faire une utilisation massive).

L'arroseur arrosé.
Je vais suivre attentivement ce topic, car j'ai le même genre de problème que tu as parfaitement bien décris face à du code fortement templaté.

En 10 ans de carrière, c'est la première fois que je suis confronté au problème. (d'habitude, c'est moi qui écrit tout le code template, du coup je le maitrise).

Je ne pense pas qu'il existe énormément de projets industriels qui présente ce problème. Conclusions : On doit être sur le même projet.

[r0d]

Houla, détrompes-toi, j'ai vu passer beaucoup de code qui abuse des templates.
Moins en France, c'est vrai, mais du code qui vient de certains pays d'europe de l'est ou de ricanie (le pays des ricains), j'en ai vu beaucoup.
Bon par contre, je ne suis pas fan des templates et je ne pourrais pas vous aider sur ce coup-là. Sauf peut-être un conseil (qui a déjà été dit implicitement par Arzar), compiler le code avec l'option 0x, car il me semble qu'un effort a été fait sur l'analyse des templates. Donc si tu es sous visual par exemple, passe à visual10 et peut-être que l'intellisense sera plus apte à retrouver les types de tes variables.

[3DArchi]

Salut,
J'ai l'impression qu'on va être beaucoup à lire avec attention les réponses à ce thead

Bon ben, pas très original, comme Arzar et comme probablement beaucoup de monde, le premier réflexe c'est le compilo. J'essaie d'avoir un environnement qui me permette d'utiliser plusieurs compilateurs. Ca rend (parfois) les messages moins abscons.

Ensuite, le 'killer' outil que j'utilise il s'appelle ........ Bic 2.0 avec feuille de papier intégrée ... avec un bon 'Search file' (les analyseurs statiques de code ont tendance à un peu s'embrouiller).

[Joel F]

perso, j'aime bien compiler avec /W4 ou -Wall etc et utiliser boost::mpl::print<T> qui emet un warning contenant le nom du type T.

[Feriaman]

perso, j'aime bien compiler avec /W4 ou -Wall etc et utiliser boost::mpl::print<T> qui emet un warning contenant le nom du type T.

Merci pour cet élément de réponse. J'ai essayé ce que tu propose, et d'après ce que j'en ai compris, cela permet pas de résoudre l'ensemble du problème, mais c'est déjà ça.

J'ai commencé aussi à me renseigner sur les plug-in GCC, mais aussi riche que soit la documentation sur le sujet, je n'ai pas réussi à trouver de documentation complète sur l'AST de gcc. En particulier, j'aimerais savoir quelle forme à l'AST d'un code templaté.

L'idée serait de rédiger un plug-in gcc qui établirait la carte {typename => fichier source} qui me manque. Cette idée est sans-doute vaine (sinon, ce serait déjà fait par d'autres), mais peut-être trouverais-je quelque chose qui suffit dans mon cas. Et puis j'aimerais comprendre pourquoi c'est si difficile.

Pour l'instant dans ma tête : tout est accessible à la compilation (puisqu'il s'agit de templates) et le compilateur sait forcément interpréter les types, je ne comprends pas qu'on arrive pas à sortir cette information.

Si je trouve un week-end pour réaliser un plug-in qui affichera l'ensemble des déclarations, d'un code compilé, j'aurais peut-être plus d'éléments. Mais pour le moment, il n'en est pas question.

Quant à l'accès possible à l'AST de Visual ... no comment.

[tomayo]

Désolé je n'ai strictement aucune réponse a donner!!!

C'est juste pour suivre la discussion car le moins q'on puisse dire c'est que j'ai ce probleme depuis des lustres

A titre d'info, mon travail c'est de deployer puis developper dans des librairies et codes de calcul open sources genre OpenFOAM, DEAL... Bon c'est sur que ca doit pas etre le meme niveau de technicite que vous mais ca reste rempli de templates de A a Z et c'est une barbarie sans nom a analyser comme codes!
Il est clair et net que je mets en gros 10 fois plus de temps a prendre en main ces codes que des codes standards procedurals ou meme des codes POO plus acces sur du polymorphisme dynamique. Bon apres je ne suis pas un grand expert ès templates et meme des trucs genre Blitz, Boost je galere autant

Toujours est-il que cette discussion est passionnante. Puisse-t-elle donner lieu a foultitudes de reponses interessantes Si c'est le cas je veux bien synthetiser l'ensemble et en faire un p'ti tutorial. Allé louia

[r0d]

Je suis peut-être trop pessimiste, mais quand on voit comment les programmeurs de microsoft (pour visual studio) et de gnu (pour gcc) galèrent pour sortir des messages de compilation compréhensibles, je ne vois pas trop qui serait en mesure de faire mieux qu'eux.

[Feriaman]

Bonjour,

Je n'ai pas (encore) pris le temps de faire ce que je m'étais proposé de faire avec le plug-in gcc, mais je partage ton pessimisme avant même de m'y être attelé. Je vous promet qu'à mon prochain inter-contrat, je sors un article qui explique non-pas comment faire, mais pourquoi ce n'est pas possible

En attendant, j'ai opté pour un refactoring anti-template. Notamment en remplaçant certaines utilisations par du polymorphisme (oui je sais, c'est moins class et on perd du temps à l'éxecution, mais au moins c'est lisible et l'IDE s'en sort).

[Goten]

Je suis peut-être trop pessimiste, mais quand on voit comment les programmeurs de microsoft (pour visual studio) et de gnu (pour gcc) galèrent pour sortir des messages de compilation compréhensibles, je ne vois pas trop qui serait en mesure de faire mieux qu'eux.

clang?

[r0d]

Pourquoi parles-tu de clang ici? Qu'apporte-t-il concernant l'analyse de templates?

[Goten]

Tu demandes "qui est capable de faire mieux que VS et G++ sur les messages d'erreurs", je te réponds : clang. (et jusqu'à preuve du contraire clang est un outil de développement, donc ma réponse est justifiée).

[r0d]

Les messages d'erreur de compilation sur les templates de clang sont mieux que g++?
Je ne connais pas du tout clang, mais ça m'intéresse.

[Goten]

Les messages d'erreur de compilation sur les templates de clang sont mieux que g++?
Je ne connais pas du tout clang, mais ça m'intéresse.

Dans une certaine mesure oui. Je vais pas te dire que c'est la panacé hein (puisqu'à la base le problème vient plus du language qu'autre chose).

Et si je me suis permis de dire c'est que clang n'est pas un compilateur mais une infrastructure de compilateur, et à ce titre fourni des composants réutilisables. (une idée pour le projet dont parlait le PO)

[tomayo]

J'ai degotté ca:

http://www.bdsoft.com/tools/stlfilt.html

Sur un exemple, ca a l'air pas mal comme simplifications. Voir ceci:

http://www.parashift.com/c++-faq/tem...html#faq-35.17

...mais il faut voir sur du vrai code... Je vais essayer de l'utiliser pour m'en faire une idée. Si des personnes pouvaient en faire de meme,...ou si elles connaissent deja et qu'elles savent que ce n'est pas top, c'est cool de prévenir ca me fera gagner du temps

Bon c'est plus maintenu depuis g++-4.2 donc c'est pas super néanmoins ca donnera une premiere idee apres on peut voir pour reprendre

[Luc Hermitte]

Je m'en sers depuis des années et c'est très pratique pour virer les arguments par défaut de la SL, et simplifier les messages d'erreur.
Ca fait parti des must-use déjà signalés dans le passé. p.ex.:
http://www.developpez.net/forums/d11...ns/#post775338

Maintenant, les derniers gcc semblent disposer d'une option pour simplifier les messages. Je ne m'en suis pas encore servi -- c'est peut-être pour cela que stlfilt ne se préoccupe pas des derniers gcc.

[SKone]

Visual Assist s'en sort plutôt bien en ce qui concerne les templates. Mais il existe aussi des outils pour "décoder" les erreurs des templates comme celui de bdsoft mais qui ne semble plus être maintenu.

[oodini]

(*) je sais, certains vont me dire que l'on peut (et que l'on doit) utiliser des typedef même si l'on n'utilise pas de template, et ils auront raison.

Moi, je n'aime pas les typedef... Faut vraiment que les formes soient très longues pour que j'y ai recours.