Templates, dependance croisée, specialisation

Bonjour,


Je suis entrain de coder un programme ou j'utilise 2 types de données, les entiers et les flottants. Je definit ces 2 types en utilisant des templates car suivant le cas je vais avoir besoin de differents types entiers (int, gmp) et differents types flottants (double, dpe, mpfr). Donc j'ai 2 classes (j'ai zappé les methodes non relevantes):

type_int.h

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

#ifndef Type_int_H #define Type_int_H #include "files.h" //(les headers bateaux genre iostream, std...) using namespace std; template<class F> class Type_float;   template<class Z> class Type_int{ /*...*/ public: /*...*/ template<class F> Type_int<Z> & operator=(const Type_float<F>& s); }; #include "type_int.cpp"   #endif

---

et

type_float.h

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

#ifndef Type_float_H #define Type_float_H #include "files.h" //(les headers bateaux genre iostream, std...) #include "type_int.h" using namespace std; template<class F> class Type_float { /*...*/ public: /* */ template<class Z> Type_float<F> & operator=(const Type_int<Z>& s); }; #include "type_float.cpp" #endif

---

J'ai besoin d'un truc qui me permet de passer de l'un a l'autre, d'ou dépendance croisée entre les 2. j'ai donc mis type_int 'en premier', avec une forward declaration de Type_float pour qu'il me jette pas. type_float.cpp et type_int.cpp incluent tous les 2 les 2 .h, et la méthode qui m'interresse est codée de la meme manière dans les 2. Mais si tout ce passe bien pour Type_float, si je tente de specialiser le '=' de Type_int de la maniere suivante :

Code:

---

1 2 3 4 5 6

template<> template<> inline Type_int<double>& Type_int<double>::operator=(const Type_float<double>& s) { data= s.GetData(); return *this; }

---

Je me fait jeter par le compilo :

Code:

---

1 2 3 4 5 6

g++ -c type_int.cpp -o type_int.o -ansi - pedantic -Wall g++ -c type_float.cpp -o type_float.o -ansi -pedantic -Wall type_int.cpp: In member function 'Type_int<Z>& Type_int<Z>::operator=(const Type_float<F>&) [with F = double, Z = double]' : type_int.cpp:179: erreur: invalid use of undefined type 'const struct Type_float<double>' type_int.h:9: erreur: declaration of 'const struct Type_float<double>'

---

Je compile avec g++.real (GCC) 4.1.2.

ça fait des heures que je suis dessus, donc si quelqu'un qui s'y connait mieux que moi a une idée, je suis preneur.

Merci d'avance

J'ai ce genre de code dans mon projet (mais perso je n'utilise aucune spécialisation, donc je n'ai aucun problème).
Où est-ce que tu met la spécialisation ? Si tu la met à la fin de type_int.h, forcément le compilateur ne pourra pas faire grand chose...
Tu as essayé en le mettant à la fin de type_float.h ?

La specialisation se situe dans type_int.cpp, qui est inclus a la fin de type_int.h (template oblige).

la placer dans type_float (.h ou cpp) semble effectivement une bonne idée, je vais essayer des demain matin (je n'ai pas acces a la machine pour l'instant)

Un conseil, pour ne pas te mélanger les pinceaux entre les définitions des templates et les sources, nomme les fichiers .tpp et .cpp.

Une solution (je n'ai pas testé) :
(j'ai la flemme d'écrire les includes guard mais faut les mettre)
Type_float_fwd.h

Code:

---

1 2	template<class F> class Type_float;

---

Type_int_fwd.h

Code:

---

1 2	template<class Z> class Type_int;

---

Type_float_impl.h

Code:

---

1 2 3 4 5 6

#include "Type_int_fwd.h" template<class F> class Type_float { // blablabla };

---

Type_float.h

Code:

---

1 2 3

#include "type_int_impl.h" #include "Type_float.tpp"

---

Type_float.tpp

Code:

---

1 2 3

#include "type_int_impl.h" // blablablablabla

---

Idem pour type_int.h et type_int.tpp.

P.S. : pas de using namespace dans un .h !

J'ai testé la solution de Kalith, qui marche nickel. ça me chatouille un peu d'avoir des méthodes de type_int codées dans type_float, mais bon. Je suis entrain de regarder ce que tu proposes 3DArchi, mais il m'apparait assez clairement que je fais pas les choses proprement a l'heure actuelle, donc je prefererais d'abord me mettre 'a la norme' avant de me lancer dans ta technique.


A l'heure actuelle dans mon projet j'ai :
main.cpp -> un main bateau, qui recupere l'entrée et crée une instance de boulot pour travailler avec
boulot.cpp / boulot.h (template<class Z, class F>)
matrix.cpp / matrix.h (template<class T>)
my_vect.cpp/ my_vect.h (template<class T>)
type_float.cpp / type_float.h (template<class F>)
type_int.cpp/type_int.h (template<class Z>)

et toutes les classes ci dessus suivent le modèle suivant :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#ifndef Type_float_H #define Type_float_H #include "files.h" //(les headers bateaux genre iostream, std...) #include "type_int.h" //using namespace std; retiré car mal d'après le précédent message. template<class F> class Type_float { /*Attributs*/ public: /* Methodes*/ }; #include "type_float.cpp" #endif

---

et
type_float.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

#ifndef Type_float_cpp #define Type_float_cpp #include "type_float.h" #include "whatever"   using namespace std;   /*Méthodes génériques */   //Code des méthodes génériques, genre : template<class F> Type_float<F>& Type_float<F>::operator*=(const Type_float<F>& s) { mul(s); return *this; }   /*Spécialisation double*/   //Code des spécialisations pour les doubles, genre : template<> inline void Type_float<double>::mul(const Type_float<double>& c) { data *= c.GetData(); } #endif

---

Si j'ai a peu pres compris, je devrais séparer les codes 'génériques' des codes spécialisés, et donc avoir 3 fichiers par classe ? Genre :
.h -> déclaration de la classe
.tpp -> code des fonctions templates, inclus a la fin du .h
.cpp -> code des spécialisations, retirer les 'templates<>' et les 'inline'

Ou je suis completement a coté de la plaque ?

Merci de votre aide en tout cas.

Salut,
Ce que je te proposes :

• []_fwd.h : un en-tête forward : que des déclarations pas de définitions
  
  Code:

  ---

  1 2	template<class F> class Type_float;

  ---

• []_impl.h : un en-tête avec la définition de la classe mais pas de ses méthodes :
  
  Code:

  ---

  1 2 3 4 5 6

  template<class F> class Type_float { // blablabla };

  ---

• [].tpp : la définition des méthodes :
  
  Code:

  ---

  1 2 3 4 5

  template<class F> Type_float<F>::Type_float() { }

  ---

• [].h : fait le lien entre la définition de la classe et son implémentation :
  
  Code:

  ---

  1 2 3

  #include "xx_impl.h" #include "xx.tpp"

  ---

Ensuite, quand une autre classe a besoin de celle-ci sans l'instancier :
-> include du XX_fwd.h dans sa déclaration
-> include du XX_impl.h dans sa définition
Si elle a besoin de l'instancier -> include du XX.h

Et donc je laisse mes templates<> et autres inline dans les specialisations, car elles sont dans le .tpp, right ?

ça va multiplier le nombre de fichiers tout ça :)

Salut,

Citation:

---

Envoyé par Glacius

Et donc je laisse mes templates<> et autres inline dans les specialisations, car elles sont dans le .tpp, right ?

ça va multiplier le nombre de fichiers tout ça :)

---

Oui, mais...

A vrai dire, je me demande déjà pourquoi vouloir absolument séparer les différents types primitifs...

En effet, si tu viens un jour à devoir manipuler deux ou trois types différents dans un même fichier (ou pire, dans une même fonction), tu va devoir multiplier tes includes, or, l'énorme avantage des template est que le code exécutable n'est réellement créé que lorsqu'il est utilisé...

Tu pourrais donc très bien envisager un fichier unique proche de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

#ifnedef PRIMITIVES_TEMPLATE_HPP #define PRIMITIVES_TEMPLATE_HPP /* commençons par les déclarations anticipées */ template<class T> class Type_int; template <class T> class Type_float; template <class T> class Type_brol; template <class T> class Type_bidule; /*...*/ /* poursuivons par les définitions (et des spécialisations éventuelles)  * des différentes classes  */ template<class T> class Type_int { public: /*...*/ protected: /* ...*/ private: /*...*/ }; template <class T> class Type_float { public: /*...*/ protected: /* ...*/ private: /*...*/ }; template <class T> class Type_brol { public: /*...*/ protected: /* ...*/ private: /*...*/ }; template <class T> class Type_bidule { public: /*...*/ protected: /* ...*/ private: /*...*/ }; /* terminons par les définitions des fonctions membres  * (éventuellement dans un fichier séparé inclus ici)  */   #endif // PRIMITIVES_TEMPLATE_HPP

---

Finalement, ces différents types pourraient très bien être, peu ou prou, considérés comme autant de trait d'une politique unique, qui pourrait prendre la forme de

Code:

---

1 2 3 4 5 6 7 8 9

template<class U, template<class> class T> class MyPolicy : public T<U> { /*...*/ }; typedef MyPolicy<UnType,Type_int> UnTypeEntier; typedef MyPolicy<UnType,Type_float> UnTypeFloat; typedef MyPolicy<AutreType,Type_float> AutreTypeFloat; /*...*/

---

et il n'y a donc pas forcément de raison, a priori, de les placer dans des fichiers séparés

On diverge un poil là :)

Ma principale raison pour séparer les implementations de float et int est que j'aime pas les fichiers trop long (chacun des 2 a 3 specialisations, vu le nombre de méthodes, ça chiffre vide en lignes). Ca me semblait assez naturel, surtout que les 2 sont là pour des usages distincts (le type float est beaucoup plus développé que le type int).

En tout cas merci à tous pour votre aide, je suis bien content d'avoir vaincu (croisons les doigts) les templates. Je vais pouvoir m'attaquer aux parties fun maintenant que le squellette est fait : I/O et optimisation.

Enfait j'utilise pratiquement la même structure que celle proposée par koala dans son dernier message (j'ai épuré le code pour que ça soit plus lisible) :
types.h

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#ifndef TYPES_H #define TYPES_H   // inclure les headers standards ici // #include <cmath> // ...   template<class T> class s_int_t; template<class T> class s_uint_t; template<class T> class s_float_t;   #include "int.h" #include "uint.h" #include "float.h"   // Je n'ai pas de spécialisations, mais si j'en avais, je les mettrais donc ici // #include "int_spe.h" // ...   #endif

---

int.h

Code:

---

1 2 3 4 5

template<class T> class s_int_t { // blablabla };

---

... etc.

Ensuite, je n'ai plus qu'à inclure "types.h" partout où j'ai besoin de ces types personalisés.
Ca n'a pas vraiment de sens de les inclure séparément, vu qu'ils sont tous liés (par des constructeurs de conversion par exemple).

PS : si tu t'en sors bien, tu peux te passer des spécialisations normalement ;)

Code:

---

1 2 3 4 5 6 7

template<class T, class N> Type_int<T>& Type_int<T>::operator=(const Type_float<N>& s) { // Tous les Type_float<N> possèdent une méthode GetData(). // On fait un static_cast au cas où T est différent de N. data= static_cast<T>(s.GetData()); return *this; }

---

PPS : au niveau des optimisations, vu que tu semble utiliser correctement les références constantes, activer les optimisations du compilateur peut te donner des résultats intéressants.
Exemple : si ton Type_float<T> ne fait que des trucs du genre :

Code:

---

1 2 3 4 5 6 7 8 9 10

Type_float<T> Type_float<T>::operator+(const Type_float<T>& s) const { return data + s.data; }   Type_float<T> Type_float<T>::operator<(const Type_float<T>& s) const { return data < s.data; } // ...

---

... tu peux t'attendre à des performances similaires à celles du type T.