Discussion :

[Glacius]

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 :

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
 
#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 :

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
 
#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 :

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

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 :

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

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

[Kalith]

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 ?

[Glacius]

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)

[hiura]

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.

[3DArchi]

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 :

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

1
2
 
template<class F> class Type_float;

Type_int_fwd.h

Code :

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

1
2
 
template<class Z> class Type_int;

Type_float_impl.h

Code :

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

1
2
3
4
5
6
 
#include "Type_int_fwd.h"
template<class F> class Type_float
{
// blablabla
};

Type_float.h

Code :

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

1
2
3
 
#include "type_int_impl.h"
#include "Type_float.tpp"

Type_float.tpp

Code :

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

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 !

[Glacius]

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 :

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

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 :

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
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.