Une petite question :

template <typename T>
class Test
{
...
friend std::ostream operator<<(std::ostream& o,Test<T>& e)
{

1. if (TYPE EST UN POINTEUR) // ce que je voudrais !

return o<< "adresse" << e << "element : " << *e;

1. else

return o<< "element" << e;

1. endif

}
};

Voila, mon soucis : si le parametre template est un pointeur, je voudrais retourner *e, sinon, je voudrais retourner e.
Si je ne mets pas de #if, au premier *e qu´il croise, il me sort une erreur de déréfencement interdit (normal, si mon parametre est statique, c´est interdit), mais j´aimerais que si c´est un pointeur il me retourne *e.

Quelqu´un a une idée ?

si c´est juste une histoire d´affichage, tu peux définir:
ostream& operator<< (ostream&, type);
et
ostream& operator<< (ostream&, type*);

Donc si c´est des objets (pour les types primaires, ca ne marchera pas), tu peux t´en sortir.

avec le préprocesseur ça ne peut pas marcher car il ne connait pas les type des données.

Par contre, il y a dans Visual C++ (je ne sais pas si c´est standard, mais la msdn ne dit pas "microsoft specific") l´operateur typeid qui fonctionne comme sizeof, sauf qu´il renvoit un objet de type const type_info qui possède particulièrement un membre char* name. Si tu lis le dernier caractère de ce membre ça sera un ´*´ si le type est un pointeur et une autre lettre si ce n´est pas un pointeur.

à partir de là tu peut te débrouiller.

Mais lje pense que t´aurais quand même un problème à la compilation, car le compilo ne te laissera pas déréférencer un objet qui n´est pas un pointeur, même si c´est une branche du code qui ne sera jamais exécuté.

Mais je pense que c´est la bonne piste.

specialisations de templates

sinon tu peux la jouer "traits class", en combinant avec typage statique (facon Alexandrescu) ; qq surcharges bien senties a coup d´ellipses, et tu peux faire un operateur qui retourne sur un "bidule" est un pointeur ou non

petit oubli..

note : les type_info ne sont dispos qu´avec les RTTI, ce qu´on voudra eviter a tout prix, a priori (il suffit de templatiser un mecanisme de downcast implicit pour remplacer la seule fonctionnalite interessante)

"les type_info ne sont dispos qu´avec les RTTI, ce qu´on voudra eviter a tout prix"

j´ai cru comprendre (tu le répète souvent...) que les performances sont catastrophique. Mais il me semble que pour ce dont a besoin JYY, c´est le plus simple car ça ne nécessite aucun autre code, ou surcharge de quoi que ce soit. Est-ce que s´il n´utilise pas ça au sein d´une application critique les performances sont si mauvaise qu´il ne faut vraiment pas l´utiliser (est-ce que ça va plomber tout le programme ?) .

D´autre part, avec VC++, il n´y a pas d´option pour activer ou supprimer le support des RTTI, est ce qu´un programme devient directement plus lent si une instruction les utilise ? ou est-ce que seul les appels à des fonctionnalité propre aux RTTI sont mauvais ?

effectivement, dans un environnement ou les performances importent peu, ce serait idiot de se priver de choses telles que les RTTI, exceptions, virtualite, etc.

maintenant, meme si les contraintes de perfs ne sont pas critiques, ca ne coute pas grand chose de faire ca "a la main", et ca peut etre une bonne habitude a prendre que de se passer de ces fonctionnalites certes pratiques mais tres couteuses (parceque le jour ou on aura besoin de downcasting implicit manuel, ceux qui ne l´auront jamais fait auparavant ne seront pas tres a l´aise..)

pour VC++, si si, il y a bien une option dans les settings des projets ; j´ai pas mon VC++ sous la main pour dire exactement ou cela dit ; ca doit etre qqpart dans le "code generation" un truc genre "enable runtime information".
au passage, les seules fonctionnalites majeures qu´autorisent les RTTI sont le typeid et le downcasting via dynamic_cast<>()

bah, ben comme d hab, ++lgv, et les type traits semble la solution la plus adapte a la question initiale. Si tu veux pas te faire chier tu peux tjs essayer de recuperer loki sur sourceforge, quoique sans le bouquin c est assez balaise a comprendre si tu n est pas habitue.

/kufa

Pour la question initiale:
http://rafb.net/paste/results/9Czjdi68.html

complement VC++ : c´est dans les settings d´un projet, C/C++ > Language > Enable runtime type information

il est vrai que je voudrais éviter les RTTI a tout prix. Du coup, je ne pense pas faire de dynamic_cast.
En ce qui concerne le type_info, ça aurait pu etre une idée, mais un (*e) ne compile pas (normal pour un e déclaré comme un template T)

bref, je verrai, peut etre que je surchargerai 2 opérateurs <<, un avec * et l´autre sans, j´va voir !

Merci en tout cas !!

mon code est une implementation de ce que tu voulais faire.

Kufa, je suis en train d´étudier ton code (en fait, j´avais vite répondu avant, sans aller cliquer sur le lien)
c´est exactement ce que je veux ! tres astucieux mécanisme qui instancie les fonctions template que quand c´est un pointeur, vraiment sympa !
Meme si je t´avoue que j´ai mis un certain temps avant d´en comprendre le mécanisme (ça fait 15 minutes que je lis ton code, lol !)

Les templates sont extremement puissants, meme si tout ces mecanismes ne sont pas triviaux.
Je recommande fortement le livre "Modern C++ design" d Alexandrescu pour les experimentes qui veulent apprendre un peu plus sur les templates.
L´avantage des template est que tout se fait au compile-time, par contre pour faire du code portable mieux vaut utiliser les dernieres version de vs ou gcc..