Discussion :

[Jacques86]

Bonjour,

J'ai un petit problème avec Dev C++. J'essaye de programmer quelques fonctions sur les arbres binaires de recherche en utilisant les modèles. J'ai un fichier abr.h pour les déclarations, un fichier abr.cpp pour l'implémentation et un fichier main.cpp pour tester avec une fonction main.

Dans le fichier abr.cpp j'ai mis #include "abr.h" pas de problème aucune erreur la dessus.

En revanche dans le fichier main.cpp si j'ajoute #include "abr.h" lorsque je crée un arbre paramétré il ne semble pas faire le lien (undefined reference) avec les déclarations de abr.cpp. Par contre si je mets #include "abr.cpp" à la place tout marche correctement.

Quelqu'un pourrait-il m'expliquer ou est le problème ? J'ai cru comprendre qu'il fallait mieux éviter de faire des inclusions de .cpp ...

D'avance merci !

Voici le listing du code non terminé mais à priori sans erreurs :

fichier abr.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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#ifndef ABR_H
#define ABR_H
#include<iostream>
 
using namespace std;
 
template<class C, class V>
class Abr{
      public:
             Abr();
             bool estVide() const;
             V& get(const C& c);
             bool ajouter(const C& c, const V& v);
             void afficher(ostream& out=cout) const;
      private:
              static C CLE_DEFAUT;
              static V VALEUR_DEFAUT;
              C cle;
              V valeur;
              Abr<C,V> *g, *d;
              void attacher(const C& c,const V& v){
                   cle = c;
                   valeur = v;
                   g = new Abr();
                   d = new Abr();
              }
              const Abr<C,V>* chercher(const C& c) const;
};
 
#endif

fichier abr.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
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
#include "Abr.h"
 
template<class C, class V>
C Abr<C,V> :: CLE_DEFAUT=0;
 
template<class C, class V>
V Abr<C,V> :: VALEUR_DEFAUT=0;
 
template<class C, class V>
Abr<C,V>::Abr():cle(CLE_DEFAUT),valeur(VALEUR_DEFAUT),g(NULL),d(NULL){
}
 
template<class C, class V>
bool Abr<C,V>::estVide() const{
  return Abr<C,V>::cle=CLE_DEFAUT
         && Abr<C,V>::valeur=VALEUR_DEFAUT
         && g=NULL
         && d=NULL;
}
 
template<class C, class V>
V& Abr<C,V>::get(const C& c){
  return chercher(c)->valeur;
}
 
template<class C, class V>
bool Abr<C,V>::ajouter(const C& c, const V& v){
  Abr<C,V>* x = this;
  while(!x->estVide()){
    if(x->cle<c)
      x=x->g;
    else if(x->cle>c)
      x=x->d;
    else if(x->cle == c)
      return false;
  }
  if(x->estVide())
    x->attacher(c,v);
  return true;
}
 
template<class C, class V>
void Abr<C,V>::afficher(ostream& out) const{
     if(!estVide()){
       g->Abr<C,V>::afficher(out);
       out << cle;
       d->Abr<C,V>::afficher(out);
     }
}

fichier main.cpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <cstdlib>
#include <iostream>
#include "Abr.h"
 
using namespace std;
 
int main(int argc, char *argv[])
{
    Abr<int,int> arbre; // petit test de création d'un arbre qui foire avec #include "Abr.h" et marche avec #include "Abr.cpp"
    system("PAUSE");
    return EXIT_SUCCESS;
}

[JolyLoic]

[koala01]

Salut, et bienvenue sur le forum...

Autant le dire tout de suite, je n'ai pas lu tout le code... Mais,

Dés le moment où j'entend parler de "classe paramétrée" et/ ou je lis le terme "template" dans un fichier d'en-tête, j'ai tendance à croire que le problème vient de la mécompréhension du principe même des template

En fait, si, pour des classes non paramétrées, c'est le fichier d'en-tête qui doit être inclu dans le fichier d'implémentation - ainsi d'ailleurs que dans tout fichier qui nécessite de connaitre les classes/fonctions déclarée dans le fichier d'en-tête - il faut savoir que, dans le cas de classes (ou de fonctions) template, l'implémentation est indissociable de la déclaration.

En effet, le compilateur n'a aucun moyen de créer un code bianire utilisable par le processeur tant qu'il ne sait pas à quel type de donnée il a affaire

Cela signifie que, chaque fois qu'une spécialisation sera donnée pour une classe ou une fonction template, le compilateur devra créer le code binaire correspondant au type réellement utilisé

Cela veut aussi dire que, pour pouvoir créer ce code binaire, il doit disposer... du corps de la fonction/des méthodes

Au final, cela signifie que tu as deux possibilités pour travailler avec les template:

1. Soit tu fournis l'implémentation directement dans le fichier d'en-tête
2. Soit tu inclu le fichier d'implémentation dans le fichier d'en-tête (au lieu d'inclure le fichier d'en-tête dans le fichier d'implémentaiton)

Dans le deuxième cas, on préférera alors ne pas utiliser l'extension ".cpp" - qui pourrait prêter à confusion - mais n'importe quelle autre extension arbitrairement choisie par toi

Tout cela se trouve clairement précisé dans la FAQ

[EDIT]grilled, une fois de plus (moi et ma manie de faire des discours )

[Jacques86]

Zut désolé ! Je ne pensais pas que le problème était spécifiquement lié aux templates alors je n'avais pas regardé cette partie de la FAQ.

En tout cas, ton petit discours aura été bien utile, je comprends mieux maintenant.

Moi aussi je ferai des discours quand je serai devenu un gourou en C++.