Question sur les templates

Marsh Posté le 12-01-2006 à 23:19:48

Salut,

Voila j'essaie de capter un peu le fonctionnement des template en C++ j'ai entendu dire que c'est le compilo qui genere une version du code pour chaque utilisation, ce qui est different des generics en Java ou c'est de la réécriture de code en compile time donc changement des <Type> par des casts et c'est tout ...

Je suis tombé sur un exemple d'un pote qui voulais gerer des plugins (des .o avec du code generique dedans) et ca marchait pas ... ptet parce qu'avoir des .o à partir des .h deja c'est mort.
Et que c'est mort de chez mort car deja les .o sont pas normalisés et que il n'existe aucun compilo qui face marcher le mot cle export.

Donc voila c'était pour qu'un esprit averti/avisé puisse m'éclairer au sujet des templates du C++, qu'en est t-il réelement, qu'est ce qui se passe derriere, en quoi c'est different de Java ?

PS : C'est quand meme ouf le retard sur la norme.

Message cité 1 fois
Message édité par Chronoklazm le 13-01-2006 à 02:20:18

---------------
Scheme is a programmable programming language ! I heard it through the grapevine !

Reply

Marsh Posté le 12-01-2006 à 23:19:48

Reply

Marsh Posté le 13-01-2006 à 04:23:16

Code :

// THE QuiCK N' DIRTY TEMPLATE SURVIVAL KIT
// oublies tout , le compilateur C++ moderne
// il copie, il colle, il cherche, il remplace,ton code comme une dactylo déchainée
// les templates ils te grondent si tu fais des bêtises
// sinon ils font le travail de 50 ingénieurs allemands sous exta.
// la définition canonique est assez simple
template <class Noyau> struct Point
{
Noyau x,y,z;
Point(Noyau _x=0,Noyau _y=0,Noyau _z=0):x(_x),y(_y),z(_z) {}
};
// l'instanciation aussi
Point<double> origine;
/* // qui remplace simplement "Noyau" par "double" et produit un imaginaire :
struct __Point
{
double x,y,z;
__Point(double _x=0,double _y=0,double _z=0):x(_x),y(_y),z(_z) {}
};
__Point origine; */
// c'est déjà très pratique on peut écrire
typedef Point<unsigned char> Couleur;
const Couleur jaune(255,240,0);
// après on peut très bien fournir des paramètres par défaut
template <class Noyau=float> struct Point
{
Noyau x,y,z;
Point(Noyau _x=0.0f,Noyau _y=0.0f,Noyau _z=0.0f):x(_x),y(_y),z(_z) {}
};
// qui permet des instanciations du genre
Point<> bar;
// les templates ne sont pas difficiles sur le nombre de paramètres et gèrent la précédence
template <class Noyau=double,class Bool=bool,Bool checkBounds=true> struct Point
{
Noyau x,y,z;
Point(Noyau _x=0.0f,Noyau _y=0.0f,Noyau _z=0.0f):x(_x),y(_y),z(_z)
{
if(checkBounds)
{
/* etc */
}
}
};
// les typedef prennent déjà une autre tournure...
typedef Point<long double,bool,true> Point_Managed;
typedef Point<float,size_t,false> Point_Savage;
// ça reste un pré-processeur on peut très bien écrire
template<int Major=0,int Minor=0,int Release=0,int Buid=-1> struct Version
{
void get(std::ostream&o)
{
o<<"v"<<Major<<'.'<<Minor<<'.'<<Release<<'.'<<Buid<<std::endl;
}
};
static Version<0,2> version;
// aucun stockage superflu, ça marche récursivement aussi
Point<Point<int> > bar;
/* // qui correspond à peu près à ça
struct __Point
{
struct
{
int x,y,z;
} __Point_;
__Point_ x,y,z;
};
__Point bar;
*/
// les appels suivants sont ok
bar.x.y=0;
bar.z=Point<int>(7,-1,-1);
// en fait le compilateur ne vérifie le code que quand c'est nécessaire, on peut écrire directement
template <class Objet,class Param> struct Executable
{
Objet o;
// Executable(const Objet&_o):o(_o){}
void operator()(const Param &param1=-1)
{
o.Go(param1);
}
};
// sans rien connaitre de Objet ou de Param, cepedant seules les classes avec une méthode Go (et les bons paramètres) seront acceptées si ton code appelle l'opérateur () de Executable
struct Foo
{
void Go(std::string name)
{
std::cout<<"Foo::"<<name<<" fait son truc"<<std::endl;
}
};
class Bar
{
// du blabla
public :
// ...
void Go(int id)
{
std::cout<<"un Bar fait le truc n°"<<id<<std::endl;
}
};
// puis quelque part dans le code
Executable<Foo,std::string> commande;
// blablah
commande("Hello" );
// ou directement
Executable<Bar,int>()(0x12345678);
}
// si les types sont connus à l'avance ça offre une alternative simple et efficace à l'héritage
// où tout est mis à plat avant l'exécution... tu dois maintenant comprendre ça :
template<int count> class unrolled_loop
{
public:
unrolled_loop()
{
unrolled_loop<count-1>();
std::cout <<"item #"<< count << std::endl;
}
};
// ça prend tout son sens avec une spécialisation, la cerise sur le gâteau des templates :
template <> class unrolled_loop<0>{};
// ça arrête d'appeller récursivement le constructeur de unrolled_loop<count-1> pour le cas où count-1==0
// à partir de la, il n'y a plus que les instructions std::cout <<"item #"... à ajouter au fichier objet/binaire.
unrolled_loop<1024> scan_line; // 1024 tests & incréments économisés
// yeah !!

Message édité par fra0 le 13-01-2006 à 06:44:29

Reply

Marsh Posté le 15-01-2006 à 23:27:52

Chronoklazm a écrit :

Je suis tombé sur un exemple d'un pote qui voulais gerer des plugins (des .o avec du code generique dedans) et ca marchait pas ... ptet parce qu'avoir des .o à partir des .h deja c'est mort.
Et que c'est mort de chez mort car deja les .o sont pas normalisés et que il n'existe aucun compilo qui face marcher le mot cle export.

les .o ne sont pas normalisé, mais c'est pour ça que c'est mort. Et il y a des compilos qui implémentent export : ceux qui utilise le front end d'EDG et un ou deux autres il me semble, mais je ne sais plus lesquels. Je me rappelle l'avoir lu sur fclc++, dans un post de jean marc Bourguet.

Chronoklazm a écrit :

Donc voila c'était pour qu'un esprit averti/avisé puisse m'éclairer au sujet des templates du C++, qu'en est t-il réelement, qu'est ce qui se passe derriere, en quoi c'est different de Java ?

Pose une question un peu plus précise si tu peux, tu veux savoir comment fonctionne l'instanciation ?, comment on les utilisent ?, quels sont les différents modèles d'intanciation ?

Chronoklazm a écrit :

PS : C'est quand meme ouf le retard sur la norme.

ça énerve pas mal de monde ...

Reply

Question sur les templates

Sujets relatifs:

Leave a Replay